pax_global_header00006660000000000000000000000064150411117000014500gustar00rootroot0000000000000052 comment=07ccf82fc307a49f1b51d4a1149d864b2ebfcf60 nvc-r1.17.1/000077500000000000000000000000001504111170000125375ustar00rootroot00000000000000nvc-r1.17.1/.clangd000066400000000000000000000001261504111170000137670ustar00rootroot00000000000000# -*- mode: yaml -*- Diagnostics: ClangTidy: Remove: bugprone-sizeof-expression nvc-r1.17.1/.gitattributes000066400000000000000000000000601504111170000154260ustar00rootroot00000000000000PKGBUILD text eol=lf test/regress/vlog2.v -text nvc-r1.17.1/.github/000077500000000000000000000000001504111170000140775ustar00rootroot00000000000000nvc-r1.17.1/.github/FUNDING.yml000066400000000000000000000013331504111170000157140ustar00rootroot00000000000000# These are supported funding model platforms github: nickg patreon: # Replace with a single Patreon username open_collective: # Replace with a single Open Collective username ko_fi: # Replace with a single Ko-fi username tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] nvc-r1.17.1/.github/actions/000077500000000000000000000000001504111170000155375ustar00rootroot00000000000000nvc-r1.17.1/.github/actions/windows-installer/000077500000000000000000000000001504111170000212245ustar00rootroot00000000000000nvc-r1.17.1/.github/actions/windows-installer/action.yml000066400000000000000000000043111504111170000232230ustar00rootroot00000000000000runs: using: "composite" steps: - uses: msys2/setup-msys2@v2 with: update: true msystem: clang64 install: >- base-devel mingw-w64-clang-x86_64-llvm mingw-w64-clang-x86_64-check mingw-w64-clang-x86_64-ncurses mingw-w64-clang-x86_64-libffi mingw-w64-clang-x86_64-pkgconf mingw-w64-clang-x86_64-tcl mingw-w64-clang-x86_64-zstd mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-nodejs mingw-w64-clang-x86_64-jansson unzip git autoconf automake-wrapper - name: Fix missing tags shell: msys2 {0} run: | git fetch --tags --force - name: Generate configure script shell: msys2 {0} run: bash autogen.sh - name: Configure shell: msys2 {0} run: | echo $PATH export PATH=$PATH:/c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.14/bin mkdir build cd build bash ../configure --enable-static-llvm --enable-tcl \ --enable-gui CFLAGS="-O2" --prefix=`pwd`/installdir \ --without-system-cc - name: Build shell: msys2 {0} working-directory: ./build run: | make -j $(nproc) - name: Install shell: msys2 {0} working-directory: ./build run: | make install - name: Build MSI installer working-directory: ./build shell: msys2 {0} run: | export PATH=$PATH:/c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.14/bin which candle make V=1 msi-installer echo "MSI=$(ls *.msi)" >> $GITHUB_ENV - name: Install working-directory: ./build shell: powershell run: | Start-Process msiexec.exe -ArgumentList "/i ${{ env.MSI }} /qn /l* .\msilog.log" -Wait type .\msilog.log echo "C:\Program Files\NVC\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append - name: Sanity test working-directory: ./build shell: powershell run: | nvc.exe --version - name: Upload artifact uses: actions/upload-artifact@v4 with: name: 'Windows installer' path: build/${{ env.MSI }} nvc-r1.17.1/.github/workflows/000077500000000000000000000000001504111170000161345ustar00rootroot00000000000000nvc-r1.17.1/.github/workflows/build-test.yml000066400000000000000000000352561504111170000207460ustar00rootroot00000000000000name: Build and test on: push: branches: - '**' tags-ignore: - '**' pull_request: concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: ${{ github.ref_name != 'master' }} jobs: build-ubuntu: strategy: matrix: include: - { os: 22.04, mode: debug } - { os: 22.04, mode: release } name: Ubuntu ${{ matrix.os }} (${{ matrix.mode }}) runs-on: ubuntu-${{ matrix.os }} steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - name: Install dependencies run: | sudo apt-get update sudo apt-get install automake flex llvm-dev check lcov \ libdw-dev libffi-dev libreadline-dev tcl8.6-dev \ libzstd-dev libxml2-utils libjansson-dev - name: Generate configure script run: ./autogen.sh - name: Configure debug if: ${{ matrix.mode == 'debug' }} run: | mkdir build && cd build ../configure --enable-gcov --enable-asan \ --with-llvm=/usr/bin/llvm-config --enable-debug \ --enable-tcl --enable-gui - name: Configure release if: ${{ matrix.mode == 'release' }} run: | mkdir build && cd build ../configure --with-llvm=/usr/bin/llvm-config \ --enable-tcl - name: Build run: ASAN_OPTIONS=detect_leaks=0 make -C build -j $(nproc) everything - name: Test run: ASAN_OPTIONS=detect_leaks=0 make -C build check - name: Test in precompile mode run: | export ASAN_OPTIONS=detect_leaks=0 cd build ./bin/run_regr -p -s - name: Test in synchronous JIT mode run: | export NVC_JIT_ASYNC=0 export NVC_JIT_THRESHOLD=1 export ASAN_OPTIONS=detect_leaks=0 cd build ./bin/run_regr -j -s - name: Test in interpreter mode run: | export NVC_JIT_THRESHOLD=0 export ASAN_OPTIONS=detect_leaks=0 cd build ./bin/run_regr -j -s # ieee12 too slow # - name: Test without intrinsics # run: | # export NVC_JIT_INTRINSICS=0 # cd build # rm -rf logs # ./bin/run_regr ieee - name: Test without vector intrinsics run: | export NVC_JIT_INTRINSICS=1 export NVC_VECTOR_INTRINSICS=0 cd build rm -rf logs ASAN_OPTIONS=detect_leaks=0 ./bin/run_regr ieee - name: JIT benchmarks run: | export ASAN_OPTIONS=detect_leaks=0 # XXX: remove this ./build/bin/jitperf -L build/lib/ test/perf/simple.vhd -f add2 - name: Check for orphan tests if: ${{ matrix.mode == 'debug' }} run: make -C build orphan-tests - name: Coverage report if: ${{ matrix.mode == 'debug' }} run: make -C build cov-generate - name: Coveralls if: ${{ matrix.mode == 'debug' }} continue-on-error: true uses: coverallsapp/github-action@master with: github-token: ${{ secrets.GITHUB_TOKEN }} path-to-lcov: ./build/coverage/nvc.info build-mac: strategy: matrix: include: - { os: macos-13, arch: x86_64 } - { os: macos-14, arch: arm64 } name: Mac OS (${{ matrix.arch }}) runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - name: Fix Python symlinks run: | find /usr/local/bin -lname '*/Library/Frameworks/Python.framework/*' -delete -print brew unlink python && brew link --overwrite python - name: Work around pkg-config issue run: brew uninstall --ignore-dependencies --force pkg-config@0.29.2 - name: Install dependencies run: brew install llvm check automake libffi pkg-config zstd - name: Generate configure script run: ./autogen.sh - name: Configure run: | mkdir build && cd build ../configure --with-llvm=$(brew --prefix llvm)/bin/llvm-config \ --enable-debug --disable-lto - name: Build run: make -C build -j $(sysctl -n hw.logicalcpu) - name: Test run: make -C build check - name: Test in synchronous JIT mode run: | export NVC_JIT_ASYNC=0 export NVC_JIT_THRESHOLD=1 cd build rm -rf logs ./bin/run_regr -j -s - name: Test in precompile mode run: | cd build rm -rf logs ./bin/run_regr -p -s - name: Dist clean run: make -C build distclean - name: Configure for release run: | cd build ../configure --with-llvm=$(brew --prefix llvm)/bin/llvm-config \ --disable-debug - name: Build release run: make -C build -j $(sysctl -n hw.logicalcpu) build-windows: name: Windows MSYS2 runs-on: windows-2022 defaults: run: shell: msys2 {0} steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - uses: msys2/setup-msys2@v2 with: update: true install: >- base-devel mingw-w64-x86_64-llvm mingw-w64-x86_64-check mingw-w64-x86_64-ncurses mingw-w64-x86_64-libffi mingw-w64-x86_64-pkgconf mingw-w64-x86_64-gcc mingw-w64-x86_64-tcl mingw-w64-x86_64-tcllib mingw-w64-x86_64-zstd unzip git autoconf automake-wrapper - name: Generate configure script run: bash autogen.sh - name: Configure run: | mkdir build cd build bash ../configure --enable-debug --disable-lto - name: Build run: make -C build -j $(nproc) - name: Test run: make -C build check - name: Test in synchronous JIT mode run: | export NVC_JIT_ASYNC=0 export NVC_JIT_THRESHOLD=1 cd build rm -rf logs ./bin/run_regr -j -s - name: Test in precompile mode run: | cd build rm -rf logs ./bin/run_regr -p -s - name: Build MSYS2 package run: | cd contrib/msys2 makepkg-mingw -sCLf --nocheck pacman -Qlp *.zst echo "MSYS2_PKG=$(ls *.zst)" >> $GITHUB_ENV - name: Install release run: pacman -U --noconfirm contrib/msys2/*.zst - name: Install OSVVM run: nvc --install osvvm - name: Install UVVM run: nvc --install uvvm build-package: name: Build package runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - name: Get version id: version run: | vers=$(sed -n '1s/AC_INIT(\[.*\], \[\([0-9\.]*\).*\].*/\1/p' configure.ac) full=$(git log --date=format:%Y%m%d --pretty=$vers~git%cd.%h -1) echo "VERSION=$full" >> $GITHUB_ENV - name: Build Debian package run: | ln -s contrib/debian debian sed -i 's/nvc (.*)/nvc (${{ env.VERSION }}-1)/' debian/changelog sudo apt-get update sudo apt-get build-dep . export DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -uc -us -b mv ../*.deb . - name: 'Upload artifact' uses: actions/upload-artifact@v4 with: name: 'Ubuntu package' path: nvc_${{ env.VERSION }}-1_amd64.deb vests: name: VESTs needs: [ build-package ] runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - uses: actions/checkout@v4 with: repository: nickg/vests path: vests fetch-depth: 1 - name: Install dependencies run: | sudo apt-get update sudo apt-get install ruby ruby-colorize - uses: actions/download-artifact@v4 with: name: 'Ubuntu package' - name: Install pre-built package run: >- sudo apt-get install ./nvc_*.deb - name: Check --version output run: nvc --version - name: Run VESTs run: >- cd vests && ../test/run_vests.rb . projects: name: External Projects needs: [ build-package ] runs-on: ubuntu-22.04 timeout-minutes: 15 steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - uses: actions/checkout@v4 with: repository: nickg/vhdl-projects path: vhdl-projects fetch-depth: 1 - uses: actions/download-artifact@v4 with: name: 'Ubuntu package' - name: Install pre-built package run: >- sudo apt-get install ./nvc_*.deb tcllib - name: Check --version output run: nvc --version - name: Install OSVVM run: nvc --install osvvm - name: Install UVVM run: nvc --install uvvm - name: Install FMF packages run: nvc --install fmf - name: Test FPHDL run: ./vhdl-projects/fphdl/test.sh - name: Test ZPU run: ./vhdl-projects/zpu/test.sh - name: Test Flopoco run: ./vhdl-projects/flopoco/test.sh - name: Test HardH264 run: ./vhdl-projects/hardh264/test.sh - name: Test J-Core run: ./vhdl-projects/jcore/test.sh - name: Test Dummy_Plug run: ./vhdl-projects/ikwzm/dummyplug/test.sh - name: Test OpenRIO run: ./vhdl-projects/openrio/test.sh - name: Test SPI-FPGA run: ./vhdl-projects/spi-fpga/test.sh - name: Test JSON-for-VHDL run: ./vhdl-projects/json/test.sh - name: Test UVVM run: ./vhdl-projects/uvvm/test.sh - name: Test vhdl-format run: ./vhdl-projects/format/test.sh - name: Test NEORV32 run: ./vhdl-projects/neorv32/test.sh - name: Test vhdl-extras run: ./vhdl-projects/extras/test.sh - name: Test PoC run: ./vhdl-projects/poc/test.sh - name: Test FMF dsp6713 run: ./vhdl-projects/fmf/dsp6713/test.sh - name: Test Grlib run: ./vhdl-projects/grlib/test.sh - name: Test MEGA65 run: ./vhdl-projects/mega65/test.sh - name: Test NetWiz run: ./vhdl-projects/netwiz/test.sh - name: Test real_matrix package run: ./vhdl-projects/realmatrix/test.sh - name: Test Canola run: ./vhdl-projects/canola/test.sh vunit: name: VUnit needs: [ build-package ] runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: repository: VUnit/vunit ref: master path: vunit submodules: recursive fetch-depth: 1 - uses: actions/checkout@v4 with: repository: antonblanchard/microwatt ref: master path: microwatt fetch-depth: 1 - name: Install dependencies run: | sudo apt-get update sudo apt-get install python3 python3-colorama make - uses: actions/download-artifact@v4 with: name: 'Ubuntu package' - name: Install pre-built package run: >- sudo apt-get install ./nvc_*.deb - name: Check --version output run: nvc --version - name: Set environment variables run: | echo "VUNIT_SIMULATOR=nvc" >> $GITHUB_ENV echo "PYTHONPATH=$(pwd)/vunit" >> $GITHUB_ENV - name: Run uart example run: | python3 vunit/examples/vhdl/uart/run.py - name: Run axi_dma example run: | python3 vunit/examples/vhdl/axi_dma/run.py - name: Run com example run: | python3 vunit/examples/vhdl/com/run.py - name: Run com tests run: | python3 vunit/vunit/vhdl/com/run.py - name: Run data_types tests run: | python3 vunit/vunit/vhdl/data_types/run.py - name: Run verification_components tests run: | python3 vunit/vunit/vhdl/verification_components/run.py - name: Run Microwatt tests run: | cd microwatt make git.vhdl python3 run.py osvvm: name: OSVVM needs: [ build-package ] runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - name: Get OSVVM version run: | vers=$(awk '/git_wrapper/ { print $3; }' contrib/install-osvvm.sh) echo "OSVVM_VERSION=$vers" >> $GITHUB_ENV - uses: actions/checkout@v4 with: repository: OSVVM/OsvvmLibraries path: OsvvmLibraries ref: ${{ env.OSVVM_VERSION }} submodules: recursive fetch-depth: 1 - name: Patch OSVVM to reduce verbosity run: | find OsvvmLibraries/Scripts -name VendorScripts_NVC.tcl -exec \ sed -i '/puts $SimulateMessage/d' \{} \; - name: Install dependencies run: | sudo apt-get update sudo apt-get install tcl tcllib git - uses: actions/download-artifact@v4 with: name: 'Ubuntu package' - name: Install pre-built package run: >- sudo apt-get install ./nvc_*.deb - name: Check --version output run: nvc --version - name: Run OSVVM tests run: | export OSVVM_DIR=./OsvvmLibraries export OSVVM_MUST_BUILD=1 tclsh ./test/test-osvvm.tcl cocotb: name: Cocotb needs: [ build-package ] runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: repository: cocotb/cocotb ref: master path: cocotb submodules: recursive fetch-depth: 1 - name: Install dependencies run: | sudo apt-get update sudo apt-get install python3 python3-nox - uses: actions/download-artifact@v4 with: name: 'Ubuntu package' - name: Install pre-built package run: >- sudo apt-get install ./nvc_*.deb - name: Check --version output run: nvc --version - name: Run cocotb regression tests run: | cd cocotb python3 -mnox -k "dev_test_sim and nvc and vhdl" msi-installer: name: Windows installer runs-on: windows-2022 steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Build MSI installer uses: ./.github/actions/windows-installer - name: Run ieee1 regression test shell: powershell run: | nvc.exe -a test\regress\ieee1.vhd nvc.exe -e ieee1 nvc.exe -r ieee1 'package require msgcat; package require yaml' | Set-Content -Path test.tcl nvc.exe --do .\test.tcl nvc-r1.17.1/.github/workflows/release-packages.yml000066400000000000000000000045431504111170000220610ustar00rootroot00000000000000name: Build release packages on: push: tags: - '*' workflow_dispatch: jobs: pkg-ubuntu: name: Package for Ubuntu strategy: matrix: include: - { os: ubuntu-22.04 } - { os: ubuntu-24.04 } runs-on: ${{matrix.os}} steps: - uses: actions/checkout@v3 with: fetch-depth: 1 - name: Get version id: version run: | vers=$(sed -n '1s/AC_INIT(\[.*\], \[\([0-9\.]*\).*\].*/\1/p' configure.ac) echo "VERSION=$vers" >> $GITHUB_ENV - name: Build Debian package run: | ln -s contrib/debian debian sed -i 's/nvc (.*)/nvc (${{ env.VERSION }}-1)/' debian/changelog sudo apt-get -y build-dep . dpkg-buildpackage -uc -us -b mv ../nvc_${{ env.VERSION }}-1_amd64.deb nvc_${{ env.VERSION }}-1_amd64_${{ matrix.os }}.deb - name: 'Upload artifact' uses: actions/upload-artifact@v4 with: name: '${{matrix.os}} package' path: nvc_${{ env.VERSION }}-1_amd64_${{ matrix.os }}.deb msi-installer: name: Windows installer runs-on: windows-2022 defaults: run: shell: msys2 {0} steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Build MSI installer uses: ./.github/actions/windows-installer docker: name: Docker image runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v3 with: fetch-depth: 1 - name: Build Docker image run: ./contrib/docker/build.sh - uses: actions/checkout@v4 with: repository: nickg/vhdl-projects path: vhdl-projects fetch-depth: 1 - name: Test run: | docker run --rm -v $(pwd)/vhdl-projects:/data \ ghcr.io/nickg/nvc:latest /data/flopoco/test.sh - name: Login to ghcr.io run : | echo "${{ secrets.GHCR_TOKEN }}" | \ docker login -u ${{ vars.GHCR_USER }} --password-stdin ghcr.io - name: Push release tag if: startsWith(github.ref, 'refs/tags/') run: | vers=$(sed -n '1s/AC_INIT(\[.*\], \[\([0-9\.]*\).*\].*/\1/p' configure.ac) docker push ghcr.io/nickg/nvc:latest docker tag ghcr.io/nickg/nvc:latest ghcr.io/nickg/nvc:$vers docker push ghcr.io/nickg/nvc:$vers nvc-r1.17.1/.github/workflows/test-llvm.yml000066400000000000000000000027241504111170000206130ustar00rootroot00000000000000name: Test LLVM releases on: workflow_dispatch: schedule: - cron: '30 21 * * 1' concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true jobs: build-ubuntu: strategy: matrix: include: - { llvm: 13 } - { llvm: 15 } - { llvm: 17 } - { llvm: 18 } - { llvm: 19 } - { llvm: 20 } name: LLVM ${{ matrix.llvm }} runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v4 with: fetch-depth: 1 - name: Install LLVM run: | wget https://apt.llvm.org/llvm.sh chmod +x llvm.sh sudo ./llvm.sh ${{ matrix.llvm }} - name: Install other dependencies run: | sudo apt-get update sudo apt-get install automake flex check \ libdw-dev libffi-dev libreadline-dev tcl8.6-dev \ libzstd-dev libxml2-utils libjansson-dev - name: Generate configure script run: ./autogen.sh - name: Configure run: | mkdir build && cd build ../configure --with-llvm=/usr/bin/llvm-config --enable-debug \ --with-llvm=/usr/bin/llvm-config-${{ matrix.llvm }} - name: Build run: make -C build -j $(nproc) - name: Check version run: ./build/bin/nvc --version - name: Test run: | export NVC_JIT_ASYNC=0 export NVC_JIT_THRESHOLD=1 make -C build check nvc-r1.17.1/.github/workflows/test-osvvm.yml000066400000000000000000000042301504111170000210050ustar00rootroot00000000000000name: Test OSVVM on Windows on: workflow_dispatch: schedule: - cron: '30 21 * * 0' jobs: test-osvvm: name: Test OSVVM runs-on: windows-2022 steps: - uses: nickg/setup-nvc@v1 with: version: latest - uses: actions/checkout@v4 with: fetch-depth: 1 - uses: actions/checkout@v4 with: repository: OSVVM/OsvvmLibraries path: OsvvmLibraries ref: dev submodules: recursive fetch-depth: 1 - uses: msys2/setup-msys2@v2 with: msystem: mingw64 update: true install: >- mingw-w64-x86_64-tcllib # - name: Test OSVVM # shell: powershell # run: | # $Env:OSVVM_DIR = $(Resolve-Path -Path OsvvmLibraries) # echo $Env:OSVVM_DIR # $Env:OSVVM_MUST_BUILD = 1 # Get-ChildItem -Path $Env:OSVVM_DIR -Recurse -Filter "VendorScripts_NVC.tcl" | ForEach-Object { # (Get-Content $_.FullName) -replace 'puts \$SimulateMessage', '' | Set-Content $_.FullName # } # nvc.exe --do .\test\test-osvvm.tcl - name: Test OSVVM shell: msys2 {0} run: | export PATH=/c/Program\ Files/NVC/bin:$PATH export OSVVM_DIR=$(realpath OsvvmLibraries) export OSVVM_MUST_BUILD=1 find $OSVVM_DIR -name VendorScripts_NVC.tcl -exec \ sed -i '/puts $SimulateMessage/d' \{} \; tclsh ./test/test-osvvm.tcl - name: Publish results uses: dorny/test-reporter@v1 with: name: OSVVM Regression Results path: ./*.xml reporter: java-junit list-suites: all list-tests: failed fail-on-error: true fail-on-empty: true - name: Upload logs uses: actions/upload-artifact@v4 if: failure() with: name: osvvm-logs path: | *.log *.yml *.html *.xml reports/*.html reports/**/*.html logs/**/*.* reports/*.css reports/osvvm.png if-no-files-found: error nvc-r1.17.1/.gitignore000066400000000000000000000013551504111170000145330ustar00rootroot00000000000000build/ Makefile.in /INSTALL /aclocal.m4 /autom4te.cache/ /configure /depcomp /install-sh /missing /configure.scan /autoscan.log /ylwrap /compile *.o *.a *.gcda *.gcno *.exe *.exe.stackdump *.so *~ TAGS logs Makefile !www/Makefile src/lexer.c .deps /config.h.in /config.h /config.log /config.status /config.guess /config.sub /src/nvc stamp-h1 IDEAS PERF GPATH GRTAGS GSYMS GTAGS .dirstamp bin/ .gtags.files compile_commands.json www/*.html /debian /compile_flags.txt .cache # Generated GUI files contrib/gui/node_modules contrib/gui/dist/ contrib/gui/.vite # VI test suite also cannot be distributed test/vi_suite* # VESTs can be redistributed but keep it out of the main repository test/vests/* # Examples has its own repository test/examples/* nvc-r1.17.1/COPYING000066400000000000000000001045131504111170000135760ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . nvc-r1.17.1/Makefile.am000066400000000000000000000113651504111170000146010ustar00rootroot00000000000000EXTRA_DIST = autogen.sh nvc.1 README.md NEWS.md THANKS.md ACLOCAL_AMFLAGS = -I m4 man_MANS = nvc.1 AM_CPPFLAGS = -I$(top_srcdir)/thirdparty -I$(top_srcdir)/src AM_CFLAGS = -Wall $(EXTRA_CFLAGS) $(LTO_FLAG) AM_CXXFLAGS = -Wall $(EXTRA_CFLAGS) $(LTO_FLAG) AM_LDFLAGS = $(EXTRA_LDFLAGS) $(LLVM_LDFLAGS) AM_YFLAGS = --locations $(EXTRA_YFLAGS) AM_LFLAGS = -o lex.yy.c AM_CC = $(PTHREAD_CC) AM_CFLAGS += $(PTHREAD_CFLAGS) AM_LDFLAGS += $(PTHREAD_LIBS) AM_CFLAGS += \ $(check_CFLAGS) \ $(libdw_CFLAGS) \ $(libdwarf_CFLAGS) \ $(libffi_CFLAGS) \ $(zlib_CFLAGS) \ $(capstone_CFLAGS) \ $(LLVM_CFLAGS) \ $(libzstd_CFLAGS) \ $(TCL_CFLAGS) bin_PROGRAMS = noinst_LIBRARIES = include_HEADERS = check_PROGRAMS = check_LIBRARIES = noinst_PROGRAMS = pkgdata_DATA = pkglibexec_PROGRAMS = pkglibexec_SCRIPTS = EXTRA_PROGRAMS = BUILT_SOURCES = CLEANFILES = DISTCLEANFILES = BOOTSTRAPLIBS = LIBDIRS = lib_LIBRARIES = pkglib_LIBRARIES = include thirdparty/Makemodule.am include src/Makemodule.am include src/cov/Makemodule.am include src/jit/Makemodule.am include src/mir/Makemodule.am include src/psl/Makemodule.am include src/rt/Makemodule.am include src/sdf/Makemodule.am include src/vhdl/Makemodule.am include src/vhpi/Makemodule.am include src/vlog/Makemodule.am include src/vpi/Makemodule.am include test/Makemodule.am include test/vhpi/Makemodule.am include lib/Makemodule.am include lib/std/Makemodule.am include lib/std.08/Makemodule.am include lib/std.19/Makemodule.am include lib/nvc/Makemodule.am include lib/nvc.08/Makemodule.am include lib/nvc.19/Makemodule.am include lib/ieee/Makemodule.am include lib/ieee.08/Makemodule.am include lib/ieee.19/Makemodule.am include lib/vital/Makemodule.am include lib/synopsys/Makemodule.am include contrib/Makemodule.am include contrib/gui/Makemodule.am include contrib/msi/Makemodule.am clean-local: clean-libs rm -f src/vlog/vlog-parse.c -test ! -d logs || rm -r logs everything: $(BUILT_SOURCES) config.h $(MAKE) $(AM_MAKEFLAGS) all-am $(check_PROGRAMS) $(EXTRA_PROGRAMS) if MAINTAINER_MODE compile-commands: $(MAKE) -C $(top_builddir) clean bear -- $(MAKE) -k -j$$(nproc) -C $(top_builddir) everything release: update-test-dist echo $(PACKAGE_VERSION) | grep -E "^[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+$$" $(AM_V_GEN)( \ v=$(PACKAGE_VERSION); d=$$(date '+%Y-%m-%d'); \ b=$$(echo $(PACKAGE_VERSION) | sed 's/.[0-9]$$//'); \ n=$$(date '+%-d'); l=$$(date '+%B %Y'); \ case $$n in \ 1?) n=$${n}th ;; \ *1) n=$${n}st ;; \ *2) n=$${n}nd ;; \ *3) n=$${n}rd ;; \ *) n=$${n}th ;; \ esac; \ last=$$(awk '/## Version/ { print($$3); exit }' $(top_srcdir)/NEWS.md); \ sed -i "s/\(Unreleased changes\)/\1\n\n## Version $$v - $$d/" $(top_srcdir)/NEWS.md; \ sed -i "s/\bmaster\b/$$b/" $(top_srcdir)/www/features.html.in; \ sed -i -e "/define(__version,/cdefine(__version, \`$$v')dnl" \ -e "/define(__release_date,/cdefine(__release_date, \`$$n $$l')dnl" \ -e "/define(__release_date_short,/cdefine(__release_date_short, \`$$d')dnl" \ $(top_srcdir)/www/defs.m4; \ sed -i 's/'$$last'/'$$v'/g' $(top_srcdir)/README.md; \ $(MAKE) -C $(top_builddir) distcheck; \ gpg --yes -b $(top_builddir)/$(PACKAGE)-$(VERSION).tar.gz \ ) tag: echo "Tagging $(PACKAGE_VERSION)" git tag -a -m "Release $(PACKAGE_VERSION)" r$(PACKAGE_VERSION) -s sync-branch: head -n1 $(top_srcdir)/configure.ac | grep -q \\-devel || exit 1; \ last=$$(awk '/## Version/ { print($$3); exit }' $(top_srcdir)/NEWS.md); \ branch=origin/v$$(echo $$last | sed 's/.[0-9]$$//')-branch; \ echo "last version was $$last, branch $$branch"; \ git show $$branch:NEWS.md >/tmp/NEWS.md; \ new=$$(awk '/## Version/ { print($$3); exit }' /tmp/NEWS.md); \ echo "new version was $$new"; \ awk '/Version '$$last'/ { exit; } /Version/ { x=1 } x==1,/./ { print($$0); }' \ /tmp/NEWS.md > /tmp/trimmed.md; \ sed -i -e '/Version/,$$ b;' -e '/^$$/ r /tmp/trimmed.md' $(top_srcdir)/NEWS.md; \ git checkout $$branch $(top_srcdir)/www/defs.m4; \ sed -i 's/'$$last'/'$$new'/g' $(top_srcdir)/README.md upload-artifacts: tag=$$(git describe --tags $$(git rev-list --tags --max-count=1)) && \ gh release upload $$tag $(top_builddir)/$(PACKAGE)-$${tag/r/}.tar.gz{,.sig} && \ scp $(top_builddir)/$(PACKAGE)-$${tag/r/}.tar.gz{,.sig} vds:/sites/nick/files && \ run_id=$$(gh run list -w "Build release packages" \ -L 1 --json headBranch,databaseId \ --jq '.[0] | select(.headBranch == "'$$tag'").databaseId') && \ echo "Run ID : $$run_id" && \ rm -rf /tmp/artifacts && \ mkdir -p /tmp/artifacts && \ gh run download $$run_id --dir /tmp/artifacts && \ find /tmp/artifacts -type f -print -exec gh release upload $$tag \{\} \; endif # MAINTAINER_MODE .PHONY: cov-reset cov-report compile-commands everything .PHONY: release sync-branch upload-artifacts nvc-r1.17.1/NEWS.md000066400000000000000000001435111504111170000136420ustar00rootroot00000000000000## Unreleased changes ## Version 1.17.1 - 2025-07-26 - Fixed a build failure on Linux Arm64. - An `others` choice is now allowed in an unconstrained array aggregate if the `--relaxed` option is passed and the aggregate appears in one of the contexts where the VHDL-2019 "function knows vector size" feature applies (#641, #1175). - VHPI handles have been made more robust. A user-visible effect of this change is that handles with distinct pointer values may refer to the same object. Always use `vhpi_compare_handles` to compare handles rather than comparing the value of the handles directly. - Type marks like `arr(index)'subtype` are now parsed correctly (#1245). - Several other minor bugs were resolved (#1249). ## Version 1.17.0 - 2025-07-12 - Updated to OSVVM 2025.02 and UVVM 2025.04.18 for `nvc --install`. - Added `--merge-mode` option to control behaviour when merging non-equal coverage databases. - `generate` statements now create separate hierarchy in the code coverage report - Fixed "unit is too big to compile" error with very large number of signals (#1200). - Just-in-time compilation is now the default and the `--jit` elaboration option has no effect. Use `--precompile` to restore the previous behaviour. - Fixed a crash when `set_cover_scope_name` from `nvc.cover_pkg` was called with coverage disabled (#1218). - Code coverage reports now contain the source files instead of referencing them (from @Blebowski). - The `--ieee-warnings` option now supports `off-at-0` to suppress warnings only in the first time step (from @supleed2). - Top-level generics can now be set to hexadecimal values from the command line using `-g name='X"12"'`. The value must be escaped or quoted to avoid the double quotes being interpreted by the shell. - Fixed a crash when ports with view mode indications are partially associated in a port map (#1208). - Files declared in impure functions are now closed after the `return` expression has been evaluated rather than before (#1229). - Added missing slice direction check at runtime (#1231). - Several other minor bugs were resolved (#1220, #1233, #1234, #1239). ## Version 1.16.2 - 2025-06-11 - Fixed a crash when an entity uses VHDL-2019 enhanced type generics and sub-elements of a port with a generic array type are associated individually (#1201). - Fixed an issue where some `generate` statements were inaccessible from VHPI (#1213). - Several other minor bugs were resolved (#1202, #1204, #1212). ## Version 1.16.1 - 2025-05-12 - Fixed an elaboration failure where generic names differ in case between entity and component and the files were analysed with `--preserve-case` (#1195). - Fixed a crash when expression coverage is enabled and a port is associated with a non-static expression (#1194). - Fixed a debug assertion failure when initialising an array with more than 2**32 elements (#1196). - Fixed a crash when concatenating unconstrained arrays of arrays (#1199). ## Version 1.16.0 - 2025-04-21 - Added support for PSL `prev()`, `stable()`, `rose()` and `fell()` built-in functions (#1135). - Signals can now be read and passed to subprograms during elaboration and the effective value is the default value associated with the signal. This behaviour is not defined by the LRM but matches all other simulators (#1144). - MSYS2 binary packages are no longer provided with releases as these become out-of-date too quickly. Windows users should instead download the self-contained MSI package. - The Ubuntu binary packages for releases now have predictable names without the git commit hash (#1131). - Improved error messages when design units have circular dependencies or depend on obsolete design units (#1152). - Toggle coverage count is displayed correctly for unreachable constant driven toggle bins and transitions from `X` are counted with `--count-from-undefined` instead of just `U`. - Added an experimental `--preserve-case` analysis option to retain the original spelling of VHDL identifiers (#723). - `--ieee-warnings` is now a global option and should be placed before the `-r` command. Passing it to the `-r` command is still supported but deprecated and may not take effect in some situations (#1151). - Fixed a crash when a partial association in a port map has a conversion function (#1161). - Improved the formatting of the `--help` output. - The GitHub Action has been renamed from `nickg/setup-nvc-ci` to `nickg/setup-nvc`, although the old name should redirect to the new. - A Docker image was added at `ghcr.io/nickg/nvc` (#1165). - Unconstrained input ports can now be constrained by the result subtype of a conversion function (#1171). - Type marks are now allowed in the prefix of selected names in relaxed mode (#1173). - Added the `nvc.random` random number generation package and `--seed` argument for deterministic results. - Added support for PSL `union` operator (from @Blebowski). - The implementation of concatenations has been reworked fixing several bugs (#1178). - Added support for conditional force assignment (#1185). - Access and file types are now supported in VHPI (#1192). - Fixed a crash when open actual was used for formal parameter without default. - Several other minor bugs were resolved (#1174, #1159, #1177, #1191, #1188). ## Version 1.15.2 - 2025-03-01 - Fixed invalid LLVM IR generation which could cause a crash with LLVM 14 (#1145). - Functional coverage is now reported correctly when summing from nested hierarchies (#1154). - External names can now be the target of concurrent signal assignment statements (#1156). - Fixed a crash when packages are passed through multiple layers of generics. - Fixed a crash when a record subtype has a partially constrained element (#1155). - Fixed wrong result of VHDL-2019 `std.env.file_path` when the source file was analysed using a relative path (#1162). - Fixed a crash when `'last_event` or `'last_active` is used with a record type (#1164). ## Version 1.15.1 - 2025-01-22 - Fixed a crash when a subprogram is called with too many named arguments (from @NikLeberg) (#1091). - Fixed a crash when a constant record aggregate has a null array element (#1137). - Fixed a regression that caused some array aggregates to be incorrectly reported as ambiguous (#1138). - The Windows installer now bundles the Tcllib library (#1136). - Fixed a bug where PSL directives in comments were parsed incorrectly when split over multiple lines (#1135). ## Version 1.15.0 - 2025-01-11 - `--load` is now a global option and should be placed before the `-r` command. This allows VHPI foreign subprograms to be called during elaboration (#988). - The `--per-file` coverage report option outputs code coverage reports for each source file instead of each instance (#823). - The new `--check-synthesis` analysis option warns when signals are missing from process sensitivity lists. - Fixed a crash when a generic subprogram is associated with `open` (#1025). - Added a functional coverage API in `nvc.cover_pkg` that can be used by external frameworks such as OSVVM to define cover points. - Added `threshold-` option for coverage to set minimal count a coverage bin must reach to be reported as covered. - Added a warning for potential infinite loops in processes without sensitivity and lacking any wait statements (from @NikLeberg). - Selected names can now be to register value change callbacks with `vhpi_register_cb` (#1045). - Removed the limit on the maximum number of parameters that can be passed to a VHDL subprogram (#1036). - The new `--no-save` analysis option parses and checks the input files but does not save the working library to disk. This is a replacement for the `--syntax` top-level command which is now deprecated. - The coverage database file name has changed to `.ncdb` in the current working directory and this can now be customised with the new `--cover-file=` elaboration option. Attempts to access the old file name inside the library directory will be redirected to the new location, with a warning. - Partial association of ports with interface views now works correctly (#1074). - Added support for PSL suffix implication, SERE repetition, and SERE fusion. - Nested arrays more than two levels deep can now be dumped in FST format (#1071). - Added support for package external names (#1072). - Fixed parser hang for bit string literals (from @NikLeberg). - Fixed a crash on an illegal package definition inside an interface. - Comping the Vivado vendor libraries with `nvc --install vivado` is now around 2x faster and analysing files with many dependencies is up to an order of magnitude faster (#1098). - The `--jit` elaboration mode now works on Windows-on-Arm systems. - `vhpi_assert` now behaves the same as VHDL `assert` for the purposes of determining the simulation exit code and early termination (#1060). - The `'driving_value` attribute now works correctly with record types. - Added basic support for `'instance_name`, `'path_name` and `'simple_name` attributes of generate block labels (from @NikLeberg) (#1125). - Comments are now parsed correctly inside PSL directives (#1129). - Updated to OSVVM 2024.11 and UVVM 2024.10.08 for `nvc --install`. - Several other minor bugs were resolved (#1038, #1057, #1067, #1124). ## Version 1.14.2 - 2024-11-23 - Fixed a crash when `'last_value` is used with record types (#1043). - Fixed a crash when a process sensitivity list contains an external name and the process is elaborated before the object referenced by the name (#1062). - Fixed parser hang for integers in scientific notation (from @NikLeberg). - Fixed a platform detection issue that caused JIT code loading to fail on Apple silicon macOS (#1069). - The `STD_INPUT` and `STD_OUTPUT` files can now be opened and closed multiple times (#1079). - Fixed a crash when a subtype is used for an aggregate element association range choice which associates an array slice (#1080). - Several other minor bugs were resolved (#1038, #1055). ## Version 1.14.1 - 2024-10-26 - Fixed an error when using the `work` library alias and the working library has the same name as design unit being analysed (#991). - Added a check for illegal references to signal or variable external names inside pure functions (#1010). - Added a check that the parameter of `'stable` and other implicit signal attributes is a static expression (#1018). - Fixed an elaboration crash when an external name is passed to a procedure (#1029). - Record subtype constraints can now be accessed over VHPI (#1035). - Several other minor bugs were resolved (#1017, #1020, #1030, #1040). ## Version 1.14.0 - 2024-09-22 - Waiting on implicit `'stable` and `'quiet` signals now works correctly. - Updated to OSVVM 2024.07 and UVVM 2024.07.03b for `nvc --install`. - Added a warning when an inner declaration hides an outer declaration in a way that is likely to be unintentional (#905). - The `-c` sub-command for coverage is deprecated and replaced with separate `--cover-report` and `--cover-merge` commands. See the manual for details. - The argument to the `--cover-export` command is now the path to a coverage database file instead of a top-level unit name. - The `--force-init` command which was deprecated in the 1.7 release has been removed. - Coverage exclude files now support `fold` command to merge coverage data from independent sub-hierarchies (from @Blebowski). - FSM state coverage bin renamed from STATE to BIN_STATE. - A signature is now allowed in the formal part of generic map associations in VHDL-2019 mode. - `use lib.pack.all` no longer makes the bare package name `pack` potentially visible. - Very limited initial Verilog support has been added, including the ability to instantiate vendor-supplied UDPs from VHDL. - Fixed a regression which caused parse errors for some concurrent assertion statements (#956). - Arrays-of-arrays with `downto` direction are now dumped in the correct order (#957). - Fixed incorrect result of `'event` and `'active` where the prefix is an array of records. - Fixed a crash when the `'stable` attribute is used with a record type (#960). - Conversion functions applied to individual record elements in a port map now work correctly (#963). - External name elaboration order checks were overly strict (#964). - Associating a signal with an `out` or `inout` parameter in a procedure that is not within a process now produces an analysis error rather than crashing at runtime (#965). - The `--dump-arrays` option now takes an optional argument to specify an upper limit on the length of nested arrays to dump (#959). - Matching `case?` statements are now checked for duplicate and missing choices at analysis time (#966). - Limited maximum instantiation depth to prevent crashes due to stack overflow when elaborating a design that has unbounded recursive entity instantiation (#969). - Physical subtype ranges and 64-bit integer types are now handled correctly by VHPI (#978). - Added support for generic map on subprogram call in VHDL-2019 and improved support for array type generics. - Optimised emission of FST initial signal values which also fixes a potential crash (#979). - Added checks for duplicate attribute specification (#977). - Several other minor bugs were resolved (#961, #962, #971, #975, #985). ## Version 1.13.3 - 2024-08-24 - Type checking was not performed correctly for conversion function actuals in port maps (#945). - Fixed a crash with signal aliases inside an instantiated generic package (#946). - Fixed random crashes when the simulation heap size is eight gigabytes or larger (#949). - Fixed a crash when a constant array with unconstrained element type is initialised with an aggregate (#954). - External names in concurrent assertion statements and PSL assertions are now parsed correctly (#952). - Several other minor bugs were resolved (#942, #943, #950, #951, #953). ## Version 1.13.2 - 2024-08-11 - Fixed an incorrect bounds check error when a constant declaration has a partially constrained type (#932). - Elaboration of large designs on Windows no longer fail with linker errors due to excessive command line length. - Fixed a bug which prevented VCD files from being generated on Windows systems using the UCRT runtime library (#637). - Fixed a crash when the type of a qualified expression is an unconstrained array-of-array (#934). - Fixed random segmentation fault when the simulation heap size is larger than four gigabytes (#935). - Fixed an incorrect ambiguous subprogram error when using the 1993 standard and calling a subprogram via a selected name such as `ieee.numeric_std."="`. ## Version 1.13.1 - 2024-07-25 - Windows installer was missing some standard library files. - Fixed a regression where generics and ports could not be referenced in external names (#921). - Fixed a crash when an unconstrained port with a default value is associated with `open`. - Fixed a duplicate symbol linker error with some uses of the `'delayed` attribute. - Fixed a crash when an aliased subprogram is matched by a generic subprogram `<>` (#924) - Fixed a crash when a generic package containing a subprogram is passed to an entity package generic (#925). - Fixed an intermittent "failed to suspend thread" fatal error on macOS (#922). - Fixed a crash when a shared variable is declared inside an instantiated generic package in 2019 mode (#923). - Fixed a crash when a port with unconstrained array-of-record type is associated with a signal that has a static subtype. - Fixed incorrect longest static prefix calculation for array slices containing `'length`, `'left`, `'right` and similar attributes (#930). - Fixed wrong result when slicing a generic that has an unconstrained array type (#931). ## Version 1.13.0 - 2024-07-13 - Type and package generics now work correctly with components and configurations (#883). - Fixed a crash when a matching `case?` alternative contains multiple choices (#890). - Implemented VHPI support for package declarations and `vhpiPackInsts` iterators (#891). - Signatures in attribute names are now parsed correctly (#892). - Attribute specifications for `all` are now parsed correctly (#889). - Predefined `"="` and `"/="` operators are no longer declared for file types. - Alias of packages now work correctly (#893). - Stricter checking of identifiers to reject those with multiple consecutive underscores or trailing underscores (from @typingArtist). - Stricter checking for subprograms, deferred constants, and protected types referenced before their corresponding body or full declaration. - Decimal physical literals like `8.2 ms` are now correctly rounded (to `8200 us` in this case) when they are converted to the base unit (#899). - External names can now be passed as `signal` actuals to subprograms (#900). - Fixed a crash when branch coverage is enabled and an if-statement contains a `return` (#903). - The `NVC_CONCURRENT_JOBS` environment variable can be used to scale the number of worker threads NVC creates based on the number of concurrently executing simulations. - Fixed a crash when certain attributes such as `'val` are used in the target of a signal assignment statement (#908). - Signals in packages are now dumped to the FST file (#901). - Function interface declarations can now be `pure` or `impure` (#917). ## Version 1.12.2 - 2024-05-15 - Fixed a crash when `'transaction` is used with a record type. - Fixed a compatibility issue with LLVM 18 that could cause an illegal instruction exception when the `--jit` elaboration option is used (#887). ## Version 1.12.1 - 2024-05-09 - Fixed a crash when a process contains a `force` or `release` assignment inside a `process (all)` statement (#877). - Fixed a crash creating a waveform dump with `--dump-arrays` and the design contains an array-of-array-of-records (#878). - Fixed a spurious error when a type declaration from a package generic is used in a port list (#881). - Fixed an assertion failure when a procedure declared within a `process (all)` assigns to a signal (#882). - Added a missing check for illegal assignment to external signal name outside a process (#884). - Fixed a crash while printing diagnostic information when the simulation delta cycle limit is reached (#885). - Generic actuals no longer need to be globally static, which was never required by the LRM (#886). ## Version 1.12.0 - 2024-04-07 - The `--jit` elaboration option no longer requires `--no-save`. - Fixed a crash when subtype bounds depend on a package instance generic (#815). - Fixed various issues in the implementation of guarded blocks and disconnection specifications (#829). - The `--std` option now controls which VHDL standard the `--install` command uses to compile third-party libraries (#836). - The prefix of an indexed or slice name now must be another name or function call, as required by the LRM (#835). - The implementation of conversions in port maps has been reworked and fixes a number of long-standing issues (#843). - Added support for `inertial` keyword in port maps (#843). - Fixed a bug where `'last_value` could give the wrong result if the signal has multiple sources. - Updated to OSVVM 2023.09a and UVVM 2023.09.16 for `nvc --install`. - The `--exit-severity=` option now also controls which severity level results in a non-zero exit code (#850). - Improvements to waveform dumping for signals with record types or types with non-locally-static bounds (#851, #852). - The parameter for attributes with dimensions such as `'length(N)` may be any integer type when `--relaxed` is passed (#862). - Resolved several other minor issues (#654, #854, #855, #859, #863). - The default standard version was changed to VHDL-2008. - The `--vhpi-trace` option now implies `--vhpi-debug`. - The bounds of array aggregates are now calculated correctly in several corner cases (#873). - Added supported for VHPI foreign subprograms. ## Version 1.11.3 - 2024-02-04 - Fixed incorrect effective value when a signal has multiple sources due to port-collapsing optimisation (#824). - Signals that appear in aggregate choice expressions like `(S downto 0 => '0')` are now included in the sensitivity list for concurrent statement equivalent processes, and in `process (all)` (#825). - The direction of aggregates with range choices is now calculated correctly in VHDL-2008 mode (#826). - Fixed a memory corruption bug when evaluating certain aggregates that contain a range association (#827). - Resolved several other minor issues (#837, #839, #840). ## Version 1.11.2 - 2024-01-04 - Fixed an incorrect length check in the equivalent process for non-static port map actuals (#817). - Library file names for design units that contain extended identifiers such as `/Foo/` are now encoded in a way that avoids illegal characters and case sensitivity issues on Windows and macOS (#816). - Implemented `vhpiIsNullP` and `vhpiIsDiscreteP` for ranges. - Fixed a crash when an aliased enumeration literal appears in a case choice expression (#819). - Fixed calculation of longest static prefix with indexes and slices of a constant array (#820). - Fixed a crash during elaboration when simplifying an if-statement that depends on a generate parameter (#821). - Increased the limit on the number of subprogram arguments to allow compiling some Lattice IPs (from @sean-anderson-seco). ## Version 1.11.1 - 2023-12-16 - Fix crash during elaboration when an if-statement branch is always taken (#812). - VHPI plugins can now access types in instantiated packages (from @sean-anderson-seco). - The `--version` output now includes the bare Git commit SHA if the program is built from a shallow clone with no tags (#813). ## Version 1.11.0 - 2023-12-06 - New command `--cover-export` exports coverage data in the Cobertura XML format which is supported by most CI environments such as GitLab. - Generics on internal instances can now be overridden with the `-g` elaboration option. For example `-g uut.value=42`. - Implemented the `'reflect` attribute and associated protected types from VHDL-2019. - Added support for VHDL-2019 sequential block statements. - Implemented the VHDL-2019 directory I/O functions in `std.env`. - Added VHDL-2019 assert API (with @Blebowski). - Implemented `'image`, `'value` and `to_string` for composite types in VHDL-2019. - Implemented the "closely related record types" feature from VHDL-2019. - Implemented the "composition with protected types" feature from VHDL-2019. - The new `--shuffle` option runs processes in a random order which can help to identify code that depends on a particular execution order. - Updated to OSVVM 2023.07 for `nvc --install`. - Various enhancements and fixes to the VHPI implementation. - Implemented the VHDL-2019 changes to `instance_name` and `path_name` for protected type variables. - VHPI error messages are no longer reported as diagnostic messages on the console. The new `--vhpi-debug` option restores the old behaviour. - Support for type conversions between arrays with closely related element types. - Added support for FSM state coverage collection (from @Blebowski). - An alias of a type now correctly creates implicit aliases for each predefined operator of that type (#776). - Improve overload resolution where a partial named association implies the formal parameter must be an array (#793). - Handling of implicit conversion for universal types has been reworked to better comply with the LRM. - Fixed a crash when string literal characters have a type which is an alias to another type (#801). - Added a warning when calling the predefined `"="` and `"/="` operators on arrays and the left and right hand sides have different lengths. - Expressions like `abs(x)**2.0` are now parsed correctly (#805). ## Version 1.10.4 - 2023-10-16 - Fixed compatibility with LLVM 17. - Fixed an intermittent crash when using the `--jit` elaboration option. - Improved overload resolution when subprogram argument is known to have character type. - Improved bounds checking for port map actuals. - Fixed a crash with aggregates for record types that contain an unconstrained field (#768). - Fix spurious "checksum 00000000" error when analysing multiple design units and one contains `use work.all` (#769). - Fix crash when using the `--relaxed` analysis option and multiple warnings are printed (#770). ## Version 1.10.3 - 2023-09-17 - Fixed memory corruption in rare circumstances with functions declared in process declarative regions (#751). - Fixed a race condition when creating library directories that occasionally led to build failures with `make -j` (#746). - Aliases of protected type methods are now allowed. - Fixed a crash when a pragma appears outside of a design unit (#752). - Fixed a crash analysing an alias of an alias of a subprogram (#755). - Fixed an elaboration failure when an allocator expression has an array type with an unconstrained element (#756). - Fixed a memory leak in the `--print-deps` command. - Fixed a crash when evaluating globally static expressions during elaboration with coverage enabled (#759). - Fixed an analysis crash where a predefined function for a type declared in a package is overridden in the package body only (#760). ## Version 1.10.2 - 2023-08-20 - Fixed a crash due to an array bounds check being incorrectly optimised out (#747). - The type of string literals and aggregates in generic map associations such as `G => X"00"` where `G` has a generic type can now be determined correctly (#750). - Fixed a spurious "duplicate declaration" error if a use clause for an instantiated packages appears in the same declarative region that instantiated the package (#750). - Improved checking for configuration specifications. - Empty bit string literals are now parsed correctly. - Fixed stack corruption when a function returns an alias of one of its array arguments. ## Version 1.10.1 - 2023-07-28 - Fixed incorrect sensitivity list generation with concurrent statements such as `x <= C(y)` where C is a constant array. - Fixed an incorrect optimisation which caused `'event` to return the wrong value in rare circumstances. - Decimal bit string literals more than 64 bits wide are now supported (#731). - The format of fractional `time` values returned by the standard `to_string` function was changed to match other simulators. - Fixed a crash when constant folding a locally static expression in a package body (#742). - Added support for reading command line arguments in VHPI (from @Forty-Bot). - Fixed a compilation error when using the predefined `minimum`/`maximum` functions with arrays of physical types. - Overloaded protected procedure calls could read the wrong value of protected type variables in rare circumstances. ## Version 1.10.0 - 2023-07-14 - The Zstandard compression library is now a build dependency. Install `libzstd-dev` or similar. - The `integer` type is now 64-bit in VHDL-2019 mode. - The [VUnit](https://vunit.github.io/) VHDL libraries can now be installed with `nvc --install vunit` but please note this does not install the Python infrastructure. - Updated to OSVVM 2023.05 and UVVM 2023.03.21 for `nvc --install`. - Conditional expressions are now allowed in constant, signal, and variable declarations in VHDL-2019 mode. - Conditional return statements are now supported in VHDL-2019. - Added support for the "function knows vector size" feature in VHDL-2019. - Entity ports with variable class and protected type are now supported in VHDL-2019 mode. - The [xpm_vhdl](https://github.com/fransschreuder/xpm_vhdl) project which provides VHDL models of the Xilinx XPM macros can now be installed with `nvc --install xpm_vhdl`. - Many improvements to the VHPI implementation (from @Forty-Bot). - `vhpi_put_value` with `vhpiDepositPropagate` mode is now supported. - The Synopsys `std_logic_misc` package is now compiled for 2008 (#696). - Fixed an issue where leading `NUL` characters in a report message would prevent the entire message being printed (#700). - Added support for interfaces in VHDL-2019 including mode view declarations, mode view indications, and the `'converse` attribute. - Added support for VHDL-2008 matching `select?` statements (#705). - Added support for the new `'designated_subtype` and `'index` attributes in VHDL-2019. - Implemented the date/time functions from `std.env` in VHDL-2019. - The default exit severity was changed from `error` to `failure`. This means a failing assertion no longer immediately terminates the simulation. The old behaviour can be restored with `--exit-severity=error`. - Comparison operators as well as `minimum`/`maximum` functions are now defined for all scalar array types in VHDL-2019. - Added support for selected signal and variable sequential assignment statements. - The `-a` analysis command now accepts an `-f list` option where `list` is a text file containing a list of files to analyse. Alternatively this may be written `@list`. - Accesses to protected types and files are now allowed in VHDL-2019. - Fixed a crash when indexing a null array (#734). - Named and range choices are now supported in aggregate targets of variable and signal assignments (#712). - The `synopsys.attributes` package is no longer distributed or built as part of the standard libraries. ## Version 1.9.2 - 2023-05-01 - Fix elaboration errors with recursive entity instantiation (#668). - Updated to latest GtkWave FST writer library. - Fix crash when an external name is used in a wait expression (#674). - Fix stack corruption when passing large numbers of arguments (#665). - Protected procedure calls with `out` or `inout` signal arguments now create drivers (#675). - Fixed a crash when a `next` or `exit` statement appears inside `process (all)` (#676). - The `--jit` elaboration options now works on Intel Macs (#680). - Fixed a corner case where a forced signal with no drivers had the wrong effective value after `release` (#681). - Fixed a crash when a signal assignment statement contains only `unaffected` (#677). ## Version 1.9.1 - 2023-04-15 - Fix build errors and warnings on MSYS2 Clang x64 environment. - Fix build failure due to missing `SHT_X86_64_UNWIND` on Alpine and Ubuntu 18.04 (#666). - Elaboration now works correctly when the `--with-system-cc=` configure argument is given a non-absolute path (#667). - Fixed a crash when a subprogram declared in a for-generate block is called during elaboration (#668). - Real to physical or 64-bit integer conversion now produces the correct result when evaluated during elaboration (#669). - Matching `case?` statements are now handled correctly in inside `process (all)` (#670). - Pass `-no_fixup_chains` to linker on macOS to avoid warning. - `;` can now be used as a separator in the `--work` and `--map` arguments on Windows in addition to `:` (#671). ## Version 1.9.0 - 2023-04-07 - Code generation has been rewritten to enable faster elaboration and "just-in-time" compilation in the future. - Now compatible with LLVM 16. - Implemented the VHDL-2019 call path reporting API. - The `elsif` VHDL-2019 conditional analysis directive now works correctly (#604). - The `'transaction` implicit signal no longer incurs a delta-cycle delay. - `x'ascending` now reports the correct result if `x` has unconstrained array type and null range. - The predefined `"="` operator on record types now always uses the predefined equality comparison for fields even in the presence of a user-defined `"="` operator. - It is no longer necessary on Windows to link VHPI plugins at elaboration time with `NVC_FOREIGN_OBJ`. Use the `--load` option to load the plugin at run time as on other operating systems. - The experimental `--jit` elaboration option defers native code generation until run time. This can dramatically reduce total test time for short-running simulations. - Statements like `wait for X` where `X` is negative but not a constant now produce an error at run time (#633). - NVC is now supported by [VUnit](https://vunit.github.io/). - Implicit signal attributes like `'transaction` are now considered static signal names (#640). - Added support for fine-grained coverage collection via `--coverage-spec` elaboration option (from @Blebowski). - The ABI for passing unconstrained arrays to foreign subprograms changed slightly, see the manual for details. - Implemented new file I/O operations from VHDL-2019. - Added analysis option `--define` to set user-defined conditional analysis identifiers (from @Blebowski). - Optional support for using ZSTD to compress library files if `libzstd-dev` is installed. - ISO-8859-1 extended characters are now handled properly in identifiers and when printing to the terminal. - The new `configure` option `--disable-default-paths` disables the default library search paths (#652). - Subtype indications used as case range choices no longer crash during analysis (#655). - The default standard version was changed to VHDL-2002 and will likely change again to -2008 in a future release. Users are recommended to use the `--std=` option to specify an explicit standard revision to avoid any compatibility issues. - Fixed a crash when elaborating a port map which contains a subtype of a record (#662). - Implemented VHDL-2019 syntax relaxations for empty records and trailing semicolon in interface lists (from @bpadalino). - A Bash auto-completion script is now installed by default. Run `configure` with `--without-bash-completion` to disable this. ## Version 1.8.2 - 2023-02-14 - Fixed "failed to suspend thread" crash on macOS. - Fix incorrect coverage scope nesting with array case statements (from @Blebowski). - Expressions like `FOO(X)'DELAYED` now work as expected rather than producing a fatal error (#603). - Fixed a bug where data was not propagated through inout ports in certain conditions (#609). - The `-gNAME=VALUE` option to set generic values from the command line now works correctly for subtypes of enumeration types (#618). - Fixed crash when creating an array of record subtypes where the subtype declaration has an element constraint (#615). ## Version 1.8.1 - 2023-01-23 - Initial signal values for certain types were not dumped correctly in FST files on Windows (#596). - Missing `thirdparty/str-two-way.h` from distribution tarball (#599). ## Version 1.8.0 - 2023-01-22 - The `--disable-opt` and `--native` elaborate options which were deprecated in version 1.3 have been removed. - The JSON dumper which was unmaintained for several years has been removed. - VHDL-2019 mode can be enabled with `--std=2019`. Please note there is very limited support for this standard at present. - The new `--no-save` elaboration option skips saving the elaborated design and other generated files to the working library. - Added support for `else` and `elsif` in generate statements (#510). - Xilinx Vivado vendor libraries can now be compiled with `nvc --install vivado`. - LLVM 8.0 or later is now required due to deprecation of non-opaque pointers. - Altera/Intel Quartus vendor libraries can now be compiled with `nvc --install quartus`. - The `nvc --version` output now includes the commit hash if built from a Git checkout. - The new `--gtkw` run option writes a `.gtkw` save file for GtkWave containing all the signals in the design (suggested by @amb5l). - `libffi` is now a build-time dependency. - Negation of the smallest negative value of a type such as `-integer'left` now produces an error. - Default OSVVM version updated to 2022.11. - `case .. generate` statements are now supported in VHDL-2008. - Coverage implementation was reworked and now collects statement, branch, expression and toggle metrics (from @Blebowski). - The `--make` command is deprecated and will be repurposed in a later release. Use the new `--print-deps` command instead to generate Makefile dependencies. ## Version 1.7.2 - 2022-10-16 - Fixed build on FreeBSD/arm (#534). - Fixed crash with generic package instantiation (#520). - Now compatible with LLVM 15.0. - Fixed calculation of longest static prefix with `'RANGE` expression (#542). - `MOD` and `REM` are now defined for physical types in VHDL-2008 (#540). - Signal declarations are now allowed in entity declarative part (#547). - Protected objects are now allowed in concurrent procedure calls (#547). - Opening a file with `APPEND_MODE` now actually appends to the file instead of truncating (#551). ## Version 1.7.1 - 2022-08-31 - Added missing textio `WRITE [LINE, REAL, STRING]` in VHDL-2008. - Added support for FreeBSD/powerpc (#503, #504, from @pkubaj). - Fixed "missing vcode unit" error during elaboration (#502). - Fixed crash with recursive entity instantiation (#502). - Fixed error with expressions like `X'ELEMENT'LENGTH` (#508). - Added support for FreeBSD/i386. - Fixed crash reading resolved value of record signal (#502). - Improved folding of for-generate expressions (#514). - Fixed memory leak when forcing signals. - Fixed crash with type conversion in generic map (#518). - Fixed crash with expressions like `X'DELAYED'STABLE` (#517). - External names now work with record signals (#520). - Xilinx Vivado vendor libraries can now be compiled with `nvc --install vivado`. - VITAL libraries are now built by default on Windows. - Fixed build with old versions of Glibc. - Resolution functions with nested record types now behave correctly (#516). - Avoid repeated `stat(2)` calls when accessing library. - Fixed very slow elaboration in some cases with function calls in generic map expressions. - Fixed intermittent segfault during elaboration (#506). - Fixed incorrect constant folding of case statements with range choices. - Fixed crash with constrained array declared in entity. - Real valued signals can now be dumped in FST files (#524). - Fixed signal assignment delay with side effects being evaluated twice (#527). - An error is now reported for duplicate choices in array-type case statements (#528). ## Version 1.7.0 - 2022-08-07 - *Breaking change:* In-tree builds are no longer supported: use a separate build directory instead. - *Breaking change:* The `--force-init` command is deprecated and has no effect. - Added support for VHDL-2008 type generics on packages and entities. - Diagnostic messages have been enhanced with more contextual information. - Added support for record element constraints and record fields with unconstrained array types. - Alias of multidimensional array allowed in VHDL-2008 mode. - Implemented VHDL-2008 rules for aggregates with slices. - VHPI is now always enabled at build time and the `--enable-vhpi` configure option has no effect. - Arithmetic operations that overflow the underlying machine type now produce an error (#101). - Added support for VHDL-2008 force/release assignments. - Basic support for external names in VHDL-2008. - Matching case `case?` statements are supported in VHDL-2008 mode. - Fixed several bugs in the implementation of guarded signals. - Implemented VHDL-2008 rules for generic visibility. - Shared variable declaration permitted in entity declaration. - Case expression no longer requires a locally static subtype in VHDL-2008 mode (#460). - The VHDL heap is now garbage collected as required by VHDL-2019 and the `deallocate` operator has no effect other than setting the access to `null`. - A new global option `-H` specifies the size of the simulation heap and defaults to 16 megabytes. - Concurrent procedure call allowed in entity statement part. - Added support for `'SUBTYPE` and `'ELEMENT` attributes in VHDL-2008. - The new top-level `--init` command creates a new empty library directory. - The `-a` analysis command now reads from the standard input if the file name is `-`. - Added support for array element constraints in VHDL-2008. - The `--prefer-explicit` analysis option which was deprecated before the 1.0 release has been removed. - A new `--relaxed` analysis option enables "relaxed rules" mode. This has the same effect as enabling all the existing `--relax=` options. However some constructs will still produce warnings. - The `--relax=` analysis option is deprecated and is now equivalent to passing `--relaxed`. The individual options are ignored. - Added support for generic subprograms in VHDL-2008. - New command `--install` allows easy installation of common third-party packages such as OSVVM and UVVM. - Identifiers in waveform dumps are now in lower case instead of upper case. - The function `CURRENT_DELTA_CYCLE` in `NVC.SIM_PKG` can be used to query the current delta cycle number. ## Version 1.6.2 - 2022-04-03 - Fix `make -j` with GNU make (#440). - Subtraction from zero could return the wrong result in some circumstances. - Fix incorrect code generation for access-to-array. - Fix assertion failure with nested context. - Generic declarations are now allowed to hide the entity name. - Fix spurious error about duplicate declarations when using VHDL-2008 context declarations. - Fix incorrect default generic value when component and entity specify generics in different order (#448). - Postponed processes with sensitivity lists now work correctly. - Unit tests no longer fail when built without debug symbols (#445). - Simulation now correctly terminates when time reaches `TIME'HIGH`. - Assertion failure and report messages were not printed during the initialisation phase of the simulation. ## Version 1.6.1 - 2022-02-05 - Fix compatibility with BSD make (#440). - Fix an out-of-memory condition when initialising processes (#441). - Fix incorrect generic value in binding specification (#442). - Fix spurious error in overload resolution if required arguments follow optional arguments (#443). - Fix intermittent crash generating code for enumerated types (#444). - Minor elaboration performance optimisation. ## Version 1.6.0 - 2022-01-25 - Name resolution and overload resolution has been completely rewritten which should fix a number of long-standing issues. - The elaboration phase was largely written which fixes a number of long-standing issues and significantly improves elaboration speed. - VHDL-2008 IEEE standard libraries are now built and installed in addition to the VHDL-1993 libraries. - The VHDL-1993 standard libraries are now derived from the Apache 2.0 licensed sources from VHDL-2019. - There is now a project website at [https://www.nickg.me.uk/nvc/](https://www.nickg.me.uk/nvc/). Please link to this in preference to the GitHub project page. - Compiled VHDL code now includes DWARF debug information which is used for runtime stack trace if libdw or libdwarf is installed. - Added support for VHDL-2008 reduction operators, match operators, and condition conversion. - Added support for VHDL-2008 element resolution. - Variable assignment now supports aggregate targets. - The `--relax=impure` option allows pure functions to call impure functions. - Added support for VHDL-2008 "all" sensitised processes. - Added support for ports and generics in block statements. - Added support for the 'BASE attribute. - Type name now allowed in element association choice (#407). - Implement textio READ procedure for REAL. - LLVM 6.0 or later is now required to build. - Added support for MINIMUM, MAXIMUM, and TO_STRING predefined operators in VHDL-2008. - VCD files are now generated from FST data in a similar manner to `fst2vcd(1)`. This should improve compatibility with other tools. - Added support for 'LAST_ACTIVE attribute (#423). - Added support for 'DRIVING and 'DRIVING_VALUE attributes. - Added a new option `--ieee-warnings=off` to disable warning messages from the standard IEEE packages. - Support for configurations has been significantly improved (#372). - Added support for VHDL-2008 delimited comments. - Added support for guard expressions on blocks. - Added support for guarded signals. - Added support for HREAD, HWRITE, and other TEXTIO additions in VHDL-2008. - Code generation now happens in parallel when LLVM is built with multi-threading enabled. - Link time optimisation (LTO) is now enabled for release builds where supported. - The default assertion failure message for certain simple scalar comparisons now shows the values of the left and right hand sides. - Added support for VHDL-2008 conditional variable assignment statements. - Added support for VHDL-2008 extended bit string literals. - Non-globally-static actuals allowed in port maps in VHDL-2008 mode. - Added support for VHDL-2008 sequential conditional signal assignment statements. - Added basic support for package generics and package instantiation. - Nested arrays can now be included in the waveform dump but only if the `--dump-arrays` option is passed. This is disabled my default due the significant performance and memory overhead. - Added support for record types in waveform dump (#216). - Added support for foreign subprograms using the VHPIDIRECT protocol. - Library build is now reproducible when running `make -j`. - Fix a constant folding crash with nested records. - Fixed a crash when a record aggregate contains an "others" association and the fields have array types with different lengths. - Fixed a stack overflow when a subprogram with unconstrained array arguments is called repeatedly in a loop (#414). - Fixed intermittent crash when evaluating nested constant records (#425). - Fixed missing import libraries on Windows (#424). - Standard libraries are now installed under `$prefix/lib/nvc/` instead of `$prefix/share/nvc`. - New configure option `--disable-vital` disables building the VITAL packages whose license status is unclear. - Support for the LXT wave output format, which was deprecated in version 1.5, has been removed. Use the default FST format instead. - The `fetch-ieee.sh` script which did nothing since the last release has been removed. - The `--codegen` command, which has been deprecated since 1.3, was removed. - The `--profile` option now prints internal simulation statistics instead of the top processes by CPU time. ## Version 1.5.3 - 2021-11-13 - Handle access(2) returning EPERM in macOS sandbox (#421). - Fix race when multiple processes concurrently update a library. - Fix `--syntax` command when file contains multiple design units. - Allow constant folding of nand/nor/xor/xnor. - Fix potential out of memory condition when evaluating complex assert expressions. - Fix incorrect result of `mod` operator with negative operands. - Fixed intermittent crash when evaluating nested constant records (#425). - Buffer too small for printing TIME'HIGH (#98). ## Version 1.5.2 - 2021-07-28 - Link libexecinfo on FreeBSD. - Implement textio READ procedure for BIT and TIME (#408). - Fixed a crash when a long running procedure suspends in a loop (#412). - Fix static linking with LLVM 12.0. - Fix crash when assigning to a signal declared in a package. - Fix incorrect recording of dependencies which caused a failure to load generated DLLs on Windows. - Fix file locking error when a library is located on NFS (#417). - Optimise loading large library index from disk. - Fix a crash when using 'VALUE with enumeration subtypes (#419). - Fix a crash when a signal with more than 256 elements is declared in a package (#420). ## Version 1.5.1 - 2021-04-09 - Fix a compiler warning in vcode.c. - Disable VHDL backtrace on non-Linux systems as the symbol names cannot be parsed reliably (#385). - Update to latest `pc_from_uncontext.m4` for Apple M1 support. - Fix incorrect application of LRM rules for building an equivalent wait statement for concurrent statements. - Library build is now reproducible when running `make -j` (#409). - Fix assertion failure with nested record type (#404). - Use Pandoc to generate the manual page. ## Version 1.5 - 2020-07-19 - IEEE library sources are now distributed - Updated FST library to match GtkWave 3.3.79 - The LXT wave output format is deprecated, use FST instead - Fix incorrect file name in assertion message - Fix crash while recovering from parse error - Add `--dump-json` command to print AST as JSON (from Sebastien Van Cauwenberghe) - Fix crash when using LLVM 7 and later - Fix spurious assertion failure in `std.textio.readline` - Reals are now rounded to the nearest integer as specified by the LRM - Fix crash when constant folding uses too much memory - Improved memory management in evaluator (thanks to Frank Mori Hess) - Various other minor fixes and improvements ## Version 1.4 - 2018-07-16 - Windows with MSYS2 is now fully supported - Continuous integration for OS X and Windows using Travis and AppVeyor - Record resolution functions are now supported - The `--relax=prefer-explicit` option now works correctly ## Version 1.3 - 2017-12-31 - Native code is always generated on platforms that support it - Initial support for VHDL-2017 conditional compilation blocks - The TCL shell has been removed - Various code generation and constant folding fixes - Fix crash when build IEEE library from non-clean tree - ORC is used for JIT if LLVM version is 3.9 or later - LLVM 3.8 or later is now required - Added `-O0` to `-O3` options to control LLVM optimisation level - The `--disable-opt` option is deprecated, use `-O0` instead - The elaborate `--native` option is now a global option and should be placed before the `-e` command - The `--codegen` command is deprecated, use `--native` when analysing to generate native shared libraries for packages ## Version 1.2 - 2017-05-04 - Compile time evaluation now uses vcode - Record aggregates can now be constant folded (#305) - The TCL shell is deprecated and will be removed in the next release - Compatible with LLVM 4.0 - Functions returning records can now be constant folded (#315) - LLVM 3.4 or later is now required ## Version 1.1 - 2016-11-05 - Improvements to based literal parsing - Improved stack traces on Linux when `libdw-dev` installed - Fixed elaboration of subprograms in entity declarations - Improved elaboration performance when design contains many signals - Fixed various bugs involving record signals - Fixed sensitivity list generation for concurrent procedure calls - Improvements to simulation performance - Implemented `vhpi_get_phys` - Added command `--list` to print all units in a library - Rewrote the `run_regr` program in C so `make check` no longer requires Ruby - The `--relax=generic-static` option is now renamed to `--relax=locally-static` and applies in wider range of contexts ## Version 1.0 - 2016-05-01 - First stable release nvc-r1.17.1/README.md000066400000000000000000000217301504111170000140210ustar00rootroot00000000000000### Synopsis [![Build Status](https://github.com/nickg/nvc/actions/workflows/build-test.yml/badge.svg?branch=master&event=push)](https://github.com/nickg/nvc/actions) [![Coverage Status](https://coveralls.io/repos/github/nickg/nvc/badge.svg?branch=master)](https://coveralls.io/github/nickg/nvc?branch=master) NVC is a [VHDL](https://en.wikipedia.org/wiki/VHDL) compiler and simulator. NVC supports almost all of VHDL-2008 with the exception of PSL, and it has been successfully used to simulate several real-world designs. Experimental support for VHDL-2019 is under development. NVC has a particular emphasis on simulation performance and uses [LLVM](https://llvm.org/) to compile VHDL to native machine code. NVC is not a synthesizer. That is, it does not output something that could be used to program an FPGA or ASIC. It implements only the simulation behaviour of the language as described by the [IEEE 1076](https://standards.ieee.org/standard/1076-2019.html) standard. NVC supports popular verification frameworks including [OSVVM](https://osvvm.org/), [UVVM](https://www.uvvm.org/), [VUnit](https://vunit.github.io/) and [cocotb](https://www.cocotb.org/). See [below](#vendor-libraries) for installation instructions. ### Usage Simulating a VHDL hardware design involves three steps: _analysing_ the source files; _elaborating_ the design; and _running_ the simulation. This is analogous to compiling, linking, and executing a software program. With NVC these steps are accomplished using the `-a`, `-e`, and `-r` commands: $ nvc -a my_design.vhd my_tb.vhd $ nvc -e my_tb $ nvc -r my_tb Or more succinctly, as a single command: $ nvc -a my_design.vhd my_tb.vhd -e my_tb -r Where `my_tb` is the name of the top-level test-bench entity. The full manual can be read after installation using `man nvc` or [online](https://www.nickg.me.uk/nvc/manual.html). ### License This program is [free software](https://www.gnu.org/philosophy/free-sw.en.html) distributed under the terms of the GNU General Public License version 3 or later. You may use, modify, and redistribute the program as you wish but if you distribute modifications you must preserve the license text and copyright notices, and also make the modified source code available to your users. The source files for the IEEE standard libraries are included in the repository. These were originally provided under a proprietary license that forbid distribution of modifications, but in 2019 were relicensed under Apache 2.0. Freely redistributable versions of the 1993 libraries were made by editing and removing declarations from the 2019 libraries, and so are also licensed under Apache 2.0. Certain VHDL libraries developed specifically for NVC under `lib/nvc` and `lib/std` are also licensed under Apache 2.0. See the individual files for details. The VITAL libraries are distributed under `lib/vital`. These were derived from draft copies of the packages freely available on the internet. The license status of these is unclear as the final text is part of the VITAL standard which must be purchased from the IEEE. If you are packaging this program for a distribution with strict free software requirements you should strip these files from the tarball and configure with `--disable-vital`. ### Installing NVC is developed under GNU/Linux and is regularly tested on macOS and Windows under MSYS2. On macOS NVC can be installed with `brew install nvc`. NVC is also packaged for [FreeBSD](https://www.freshports.org/cad/nvc), [Gentoo](https://packages.gentoo.org/packages/sci-electronics/nvc), Arch Linux [AUR](https://aur.archlinux.org/packages/nvc), and [several other distributions](https://repology.org/project/nvc/versions). A Windows installer is available from the [releases page](https://github.com/nickg/nvc/releases/) and can be installed using [winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/) with `winget install NickGasson.NVC`. Users of systems without existing packages should build from source. For testing in GitHub Actions use [setup-nvc](https://github.com/marketplace/actions/setup-nvc). There is also a Docker image [ghcr.io/nickg/nvc](https://github.com/nickg/nvc/pkgs/container/nvc) for other CI environments. NVC has both a release branch and a development master branch. The master branch should be stable enough for day-to-day use and has comprehensive regression tests, but the release branch is more suitable for third party packaging. The latest released version is [1.17.1](https://github.com/nickg/nvc/releases/tag/r1.17.1). Significant changes since the last release are detailed in [NEWS.md](NEWS.md). If you are building from a Git clone rather than a released tarball you first need to generate the configure script using: ./autogen.sh In-tree builds are not supported so create a separate build directory: mkdir build && cd build Finally build and install using the standard autotools steps: ../configure make sudo make install To use a specific version of LLVM add `--with-llvm=/path/to/llvm-config` to the configure command. The minimum supported LLVM version is 8.0. Versions between 8 and 18 have all been tested. NVC also depends on Flex to generate the lexical analyser. On a Debian derivative the following should be sufficient to install all required dependencies: sudo apt-get install build-essential automake autoconf \ flex check llvm-dev pkg-config zlib1g-dev libdw-dev \ libffi-dev libzstd-dev On `rpm` based distributions, the following can be installed to fulfill required dependencies: sudo dnf install autoconf automake flex check llvm-devel libffi-devel \ zlib-ng-compat-devel libzstd-devel elfutils-devel Only the MSYS2 environment on Windows is supported. The "Clang x64" environment should be used because it supports native Windows thread-local storage unlike the GCC-based environments. The required dependencies can be installed with: pacman -S base-devel mingw-w64-clang-x86_64-{llvm,ncurses,libffi,check,pkgconf,zstd,autotools,clang} [GTKWave](http://gtkwave.sourceforge.net/) or [Surfer](https://surfer-project.org/) can be used to view simulation waveforms. For GTKWave, version 3.3.79 or later is required for the default FST format. #### Testing To run the regression tests: make check The unit tests require the [check](https://libcheck.github.io/check/) library. ### Reporting bugs Report bugs to [nick@nickg.me.uk](mailto:nick+nvc@nickg.me.uk) or using the [GitHub issue tracker](https://github.com/nickg/nvc/issues). Please include enough information to reproduce the problem, ideally with a small VHDL test case. Issue [#412](https://github.com/nickg/nvc/issues/412) is a good example. Please remember that this software is provided to you with NO WARRANTY and no expectation of support, but I will do my best to help with any issues you encounter. ### Contributing Patches can be sent as either pull requests on GitHub or by email using [git --send-email](https://git-send-email.io/). Please note however that as this is purely a spare-time hobby project for me, I have limited time available to review patches. All code submitted must follow the guidelines in [contrib/STYLE.md](contrib/STYLE.md). I will not accept patches that add new copyright owners under `src/`. This is to ensure there is clear legal ownership should, for example, the license need to be updated. Significant contributors are instead listed in [THANKS.md](THANKS.md). ### Language Support VHDL standard revisions are commonly referred to by the year they were published. For example IEEE 1076-2008 is known as VHDL-2008. The default standard in NVC is currently VHDL-2008 but this can be changed with the `--std` argument. For example `--std=1993` selects the VHDL-1993 standard. The 1993, 2000, and 2002 revisions of the standard are fully supported. Please raise bugs for any missing or incorrectly implemented features you encounter. The current status of VHDL-2008 and VHDL-2019 support can be found on the [features](https://www.nickg.me.uk/nvc/features.html) page. ##### VHPI The VHDL standard contains a comprehensive API called VHPI for interfacing with foreign code written in C or another language. NVC implements a subset of VHPI sufficient for running [cocotb](https://www.cocotb.org/). Refer to the [manual](https://www.nickg.me.uk/nvc/manual.html#VHPI) for more information. ### Vendor Libraries NVC provides scripts to compile popular verification frameworks and the simulation libraries of common FPGA vendors. * For [OSVVM](https://osvvm.org/) use `nvc --install osvvm` * For [UVVM](https://www.uvvm.org/) use `nvc --install uvvm` * For Xilinx ISE use `nvc --install ise` * For Xilinx Vivado use `nvc --install vivado` and additionally `nvc --install xpm_vhdl` if you require simulation models of the XPM macros * For Altera Quartus use `nvc --install quartus` * For Lattice iCEcube2 use `nvc --install icecube2` * For [Free Model Foundry](https://freemodelfoundry.com/) common packages use `nvc --install fmf` The libraries will be installed under `~/.nvc/lib`. nvc-r1.17.1/THANKS.md000066400000000000000000000022211504111170000140460ustar00rootroot00000000000000NVC was written by Nick Gasson with help from the following people: - Adam Barnes (@amb5l) wrote the installation and test scripts for OSVVM, and the MSYS2 packaging scripts. - Arild Velure (@avelure) made a huge number of useful bug reports. - Brian Padalino (@bpadalino) provided lots of useful feedback and bug reports. - David Koontz provided invaluable feedback and testing during early development. - KAWAZOME Ichiro (@ikwzm) provided many test cases and high quality bug reports. - KIMURA Masaru (@hiyuh) contributed the initial Windows/Cygwin port and fixed several bugs. - Michael Mitchener (@mitchsm) made many improvements to the bounds checking pass. - Ondrej Ille (@Blebowski) added many features to code coverage collection and reporting. - Olaf Kraigher (@kraigher) made several improvements to the parser and `std.textio` implementation. - Sean Anderson (@Forty-Bot) contributed a large part of the VHPI implementation. - Sebastien Van Cauwenbergh (@svancau) contributed the JSON output module. Special thank you to @bpadalino, @tmeissner, @Blebowski, @amb5l, @m42uko, @a-panella, and @cmarqu for sponsoring me! nvc-r1.17.1/autogen.sh000077500000000000000000000001211504111170000145320ustar00rootroot00000000000000#!/bin/sh cd $(git rev-parse --show-toplevel) autoreconf --force --install -I m4 nvc-r1.17.1/configure.ac000066400000000000000000000416661504111170000150420ustar00rootroot00000000000000AC_INIT([nvc], [1.17.1], [https://github.com/nickg/nvc/issues], [nvc], [https://www.nickg.me.uk/nvc/]) AC_PREREQ([2.69]) AC_CANONICAL_HOST AC_CANONICAL_TARGET AM_INIT_AUTOMAKE([1.12 -Wall -Wno-portability color-tests foreign subdir-objects serial-tests]) AM_SILENT_RULES([yes]) AC_CONFIG_MACRO_DIR([m4]) AS_IF([test -d ${srcdir}/.git], [enable_maintainer_mode="yes" AC_DEFINE([HAVE_GIT_SHA], [1], [Have Git commit hash])], [enable_maintainer_mode="no"]) AM_MAINTAINER_MODE AM_CONDITIONAL([ENABLE_GIT_SHA], [test -d ${srcdir}/.git]) FORCE_OUT_OF_TREE AC_USE_SYSTEM_EXTENSIONS AC_PROG_CC AC_PROG_CXX AC_PROG_INSTALL AC_PROG_MKDIR_P AC_PROG_LEX([noyywrap]) AC_EXEEXT AC_C_INLINE AC_C_RESTRICT AC_CHECK_HEADERS([sys/ptrace.h sys/prctl.h]) AC_CHECK_FUNCS([tcgetwinsize memmem strcasestr getline fseeko ftello]) AC_CHECK_FUNCS([fpurge __fpurge strchrnul strndup gettid popen]) AC_CHECK_MEMBERS([struct stat.st_mtimespec.tv_nsec]) AC_CHECK_MEMBERS([struct stat.st_mtim.tv_nsec]) AC_CHECK_HEADERS([ucontext.h]) AC_CHECK_HEADERS([sys/ucontext.h]) AC_CHECK_HEADERS([stdio_ext.h]) AS_IF([test "$ac_cv_header_ucontext_h" = yes ], [AC_MSG_CHECKING([for getcontext]) AC_LINK_IFELSE( [AC_LANG_PROGRAM([#include ], [ucontext_t uc; getcontext(&uc);])], [AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_GETCONTEXT], [1], [Defined if getcontext is available])], [AC_MSG_RESULT([no])])]) case $host_os in # Darwin does not allow empty archives darwin*) ac_cv_func_memmem=no ;; esac AM_CONDITIONAL([GNULIB_MEMMEM], [test "x$ac_cv_func_memmem" != xyes]) AM_CONDITIONAL([GNULIB_STRCASESTR], [test "x$ac_cv_func_strcasestr" != xyes]) AM_CONDITIONAL([GNULIB_GETLINE], [test "x$ac_cv_func_getline" != xyes]) AM_CONDITIONAL([GNULIB_STRCHRNUL], [test "x$ac_cv_func_strchrnul" != xyes]) AM_CONDITIONAL([GNULIB_STRNDUP], [test "x$ac_cv_func_strndup" != xyes]) EXTRA_CFLAGS= EXTRA_LDFLAGS= EXTRA_YFLAGS= # Need to prevent GCC calling strndup builtin if using gnulib version if test "x$ac_cv_func_strndup" != xyes; then AX_CHECK_COMPILE_FLAG([-fno-builtin-strndup], [AX_APPEND_FLAG([-fno-builtin-strndup], [EXTRA_CFLAGS])]) fi # Prefer linking with Mold if available AX_CHECK_LINK_FLAG( [-fuse-ld=mold], [AX_APPEND_FLAG([-fuse-ld=mold], [EXTRA_LDFLAGS]) AX_CHECK_LINK_FLAG([-Wl,--undefined-version], [AX_APPEND_FLAG([-Wl,--undefined-version], [EXTRA_LDFLAGS])])]) CHECK_DYNAMIC_LIST( [EXPORT_LDFLAGS="-Wl,--dynamic-list=$srcdir/src/symbols.txt"], [AX_CHECK_LINK_FLAG([-rdynamic], [EXPORT_LDFLAGS="-rdynamic"])]) AC_SUBST(EXPORT_LDFLAGS) AX_CHECK_COMPILE_FLAG([-fPIC], [SHLIB_CFLAGS="-fPIC"], [SHLIB_CFLAGS=""], [-Werror]) AC_SUBST(SHLIB_CFLAGS) case $target_cpu in x86_64|amd64) AX_CHECK_COMPILE_FLAG( [-mavx2], [AC_DEFINE_UNQUOTED([HAVE_AVX2], [1], [Target supports AVX2 instructions])], [], [-Werror]) AX_CHECK_COMPILE_FLAG( [-msse4.1], [AC_DEFINE_UNQUOTED([HAVE_SSE41], [1], [Target supports SSE4.1 instructions])], [], [-Werror]) AX_CHECK_COMPILE_FLAG( [-msha], [AC_DEFINE_UNQUOTED([HAVE_SSE_SHA], [1], [Target supports SHA instructions])], [], [-Werror]) case "$CFLAGS" in *mno-popcnt*) ;; # Disabled by user *) AX_CHECK_COMPILE_FLAG( [-mpopcnt], [AX_APPEND_FLAG([-mpopcnt], [EXTRA_CFLAGS]) AC_DEFINE_UNQUOTED([HAVE_POPCNT], [1], [Target supports POPCNT instructions])], [], [-Werror]) ;; esac ;; aarch64) AX_CHECK_COMPILE_FLAG( [-march=armv8-a+crypto], [AC_DEFINE_UNQUOTED([HAVE_ARM_CRYPTO], [1], [Target supports ARMv8 crypto instructions])], [], [-Werror]) AC_CHECK_HEADERS([arm_neon.h]) ;; esac AX_GCC_FUNC_ATTRIBUTE([returns_nonnull]) AX_GCC_BUILTIN([__builtin_setjmp]) AX_PROG_FLEX([], [AC_MSG_ERROR([Flex not found])]) case $host_os in *cygwin*|msys*|mingw32*) LIBS="$LIBS -ldbghelp -lwsock32" # For StackTrace64 and sockets DIR_SEP=\\\\ pathprog="cygpath -m" AC_CHECK_PROG([CANDLE], [candle], [yes]) # For WiX installer NVC_CHECK_MSYS ;; *) AC_SEARCH_LIBS([dlopen], [dl dld], [], [ AC_MSG_ERROR([unable to find the dlopen() function]) ]) AX_PTHREAD([], [AC_MSG_ERROR([pthread not found])]) DIR_SEP=/ pathprog="echo" ;; esac AM_CONDITIONAL([ENABLE_WIX], [test x$CANDLE = xyes]) AC_PATH_PROG([sh_path], ["sh"], ["/bin/sh"]) AC_DEFINE_UNQUOTED([SH_PATH], ["`$pathprog $sh_path`"], [Path to POSIX shell]) AC_PATH_PROG([diff_path], ["diff"], ["/usr/bin/diff"]) AC_DEFINE_UNQUOTED([DIFF_PATH], ["`$pathprog $diff_path`"], [Path to diff program]) AC_PATH_PROG([xmllint_path], ["xmllint"]) if test -n "$xmllint_path"; then # This is only used for regression tests AC_DEFINE_UNQUOTED([XMLLINT_PATH], ["`$pathprog $xmllint_path`"], [Path to xmllint program for tests]) fi AC_DEFINE_UNQUOTED([DIR_SEP], ["$DIR_SEP"], [Directory separator]) AC_DEFINE_UNQUOTED([EXEEXT], ["$EXEEXT"], [Executable file extension]) AC_SEARCH_LIBS([pow], [m], [], [ AC_MSG_ERROR([unable to find the pow() function]) ]) PKG_CHECK_MODULES([zlib], [zlib >= 1.0.0]) AC_DEFINE_UNQUOTED([FST_REMOVE_DUPLICATE_VC], [1], [Enable FST glitch removal]) AC_ARG_ENABLE([llvm], [AS_HELP_STRING([--enable-llvm], [Build LLVM code generator])], [enable_llvm=$enableval], [enable_llvm=yes]) AM_CONDITIONAL([ENABLE_LLVM], [test x$enable_llvm != xno]) if test "$enable_llvm" != "no"; then AC_DEFINE_UNQUOTED([ENABLE_LLVM], [1], [LLVM code generator enabled]) AX_LLVM_C([engine passes ipo linker native]) else AM_CONDITIONAL([LLVM_STATIC], [false]) fi PKG_CHECK_MODULES([check], [check >= 0.9.4], [], [AC_MSG_WARN(libcheck not found - unit tests will not run)]) PKG_CHECK_MODULES([capstone], [capstone >= 4.0], [AC_DEFINE_UNQUOTED([HAVE_CAPSTONE], [1], [Have capstone for diassembly])], [true]) PKG_CHECK_MODULES([libffi], [libffi >= 3.0]) PKG_CHECK_MODULES([libzstd], [libzstd >= 1.4]) AC_ARG_ENABLE([gui], [AS_HELP_STRING([--enable-gui], [Build browser-based GUI (WIP)])], [enable_gui=$enableval], [enable_gui=no]) AS_IF([test x$enable_gui = xyes], [AC_DEFINE_UNQUOTED([ENABLE_GUI], [1], [Browser-based GUI enabled]) AC_CHECK_PROGS([NPM], [npm]) AS_IF([test x$NPM = x], [AC_MSG_ERROR([please install NodeJS])])]) AM_CONDITIONAL([ENABLE_GUI], [test x$enable_gui = xyes]) AC_ARG_ENABLE([server], [AS_HELP_STRING([--enable-server], [Build WebSocket interface])], [enable_server=$enableval], [enable_server=$enable_gui]) AS_IF([test x$enable_server = xyes], [AC_DEFINE_UNQUOTED([ENABLE_SERVER], [1], [WebSocket server enabled]) PKG_CHECK_MODULES([jansson], [jansson >= 2.0])]) AM_CONDITIONAL([ENABLE_SERVER], [test x$enable_server = xyes]) AS_IF([test x$enable_gui$enable_server = xyesno], [AC_MSG_ERROR([GUI supports requires --enable-server])]) AC_ARG_ENABLE([tcl], [AS_HELP_STRING([--enable-tcl], [Build TCL interface])], [enable_tcl=$enableval], [enable_tcl=$enable_server]) AS_IF([test x$enable_tcl = xyes], [AC_DEFINE_UNQUOTED([ENABLE_TCL], [1], [TCL shell enabled]) found_tcl=no for pkg in tcl8.6 tcl86 tcl; do PKG_CHECK_MODULES([TCL], [$pkg >= 8.6.0], [found_tcl=yes], [true]) done AS_IF([test x$found_tcl = xno], [AC_MSG_ERROR([TCL library not found, try installing tcl-dev])]) AX_LIB_READLINE if test "x$ax_cv_lib_readline" = xno ; then AC_MSG_ERROR([readline or a compatible library is required when TCL is enabled]) fi]) AM_CONDITIONAL([ENABLE_TCL], [test x$enable_tcl = xyes]) AS_IF([test x$enable_server$enable_tcl = xyesno], [AC_MSG_ERROR([WebSocket server requires --enable-tcl])]) AC_CHECK_HEADER([unwind.h], [], [AC_MSG_ERROR([required header unwind.h not found (try installing libunwind)])]) AC_SEARCH_LIBS([_Unwind_Backtrace], [c++abi], [ # libc++-abi needs to link -lpthread on OpenBSD if test "$ac_cv_search__Unwind_Backtrace" = "-lc++abi"; then AX_PTHREAD([LIBS="$PTHREAD_LIBS $LIBS"], [AC_MSG_ERROR([pthread not found])]) fi ], [AC_MSG_ERROR([cannot find library for _Unwind_Backtrace])], [-lpthread]) case $host_os in linux*) PKG_CHECK_MODULES([libdw], [libdw >= 0.159], [AC_DEFINE_UNQUOTED([HAVE_LIBDW], [1], [Have libdw for stack traces])], [true]) ;; freebsd*|openbsd*|netbsd*|darwin*|msys*|mingw32*) PKG_CHECK_MODULES([libdwarf], [libdwarf >= 0.4], [AC_DEFINE_UNQUOTED([HAVE_LIBDWARF], [1], [Have libdwarf for stack traces])], [true]) ;; esac AX_DEFINE_DIR([PREFIX], [prefix], [Installation prefix]) AX_DEFINE_DIR([LIBDIR], [libdir/nvc], [Installation library directory]) AX_DEFINE_DIR([LIBEXECDIR], [libexecdir/nvc], [Location of internal programs]) AX_DEFINE_DIR([DATADIR], [datadir/nvc], [Location of data files]) AX_DEFINE_DIR([TESTDIR], [srcdir/test], [Location of testcases]) AM_CONDITIONAL([ARCH_X86_64], [test x$target_cpu = xx86_64 -o x$target_cpu = xamd64]) AM_CONDITIONAL([ARCH_ARM64], [test x$target_cpu = xaarch64]) # Prefer calling the linker directy to using CC linker_path= case $host_os in linux*|openbsd*) AC_PATH_TARGET_TOOL([linker_path], [ld]) ;; esac if test -n "$linker_path"; then AC_DEFINE_UNQUOTED([LINKER_PATH], ["$linker_path"], [System linker]) fi # CC may constain unwanted -std=... option. cc_bare=${CC%% *} AC_ARG_WITH([system-cc], [AS_HELP_STRING([--with-system-cc=PATH], [Path to system compiler to be used for linking])], [system_cc="$withval"], [AC_PATH_PROG([system_cc], ["$cc_bare"])]) if test x$system_cc != xno; then AC_MSG_CHECKING([if $system_cc executable exists]) AS_IF([command -v $system_cc >/dev/null], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no]) AC_MSG_ERROR([system C compiler $system_cc not found])]) AC_DEFINE_UNQUOTED([SYSTEM_CC], ["`$pathprog $system_cc`"], [System compiler]) else AC_DEFINE_UNQUOTED([BOOTSTRAP_CC], ["`$pathprog $cc_bare`"], [Bootstrap compiler]) fi case $host_os in *cygwin*|msys*|mingw32*) implib_required=yes DLL_EXT=dll LIB_EXT=lib ;; *) DLL_EXT=so LIB_EXT=a ;; esac if test x$implib_required = xyes ; then AC_DEFINE_UNQUOTED([IMPLIB_REQUIRED], [1], [Import library required]) fi AC_DEFINE_UNQUOTED([DLL_EXT], ["$DLL_EXT"], [Dynamic library extension]) AC_SUBST(DLL_EXT) AC_SUBST(LIB_EXT) AM_CONDITIONAL([IMPLIB_REQUIRED], [test x$implib_required = xyes]) case $host_os in darwin*) SHLIB_LDFLAGS="-shared -flat_namespace -undefined dynamic_lookup" AX_CHECK_LINK_FLAG( [-Wl,-no_fixup_chains], [AC_DEFINE([HAVE_NO_FIXUP_CHAINS], [1], [Defined if linker supports -no_fixup_chains]) AX_APPEND_FLAG([-Wl,-no_fixup_chains], [SHLIB_LDFLAGS])]) ;; *) SHLIB_LDFLAGS="-shared" esac AC_SUBST(SHLIB_LDFLAGS) NVC_CHECK_EMUTLS if test "$nvc_cv_use_emutls" = "yes"; then AC_MSG_WARN(m4_normalize( [this system uses emulated thread-local storage which has a significant performance overhead])) case $host_os in msys*|mingw32*) AC_MSG_NOTICE([try building in the MSYS2 Clang x64 environment instead]) ;; esac fi AC_ARG_ENABLE([vital], [AS_HELP_STRING([--enable-vital], [Build VITAL packages])], [enable_vital=$enableval], [enable_vital=yes]) AM_CONDITIONAL([ENABLE_VITAL], [test x$enable_vital = xyes]) AC_ARG_ENABLE([frame-pointer], [AS_HELP_STRING([--enable-frame-pointer], [Preserve frame pointer for profiling])], [AX_APPEND_FLAG([-fno-omit-frame-pointer], [EXTRA_CFLAGS]) AX_APPEND_FLAG([-mno-omit-leaf-frame-pointer], [EXTRA_CFLAGS]) preserve_frame_pointer=$enableval], [preserve_frame_pointer=no]) if test x$preserve_frame_pointer = xyes ; then AC_DEFINE_UNQUOTED([PRESERVE_FRAME_POINTER], [1], [Preserve frame pointer for profiling]) fi AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug], [Enable extra debugging checks for development])], [enable_debug=$enableval if test x$enableval = xyes; then NVC_DEBUG_ONLY([--enable-debug]) fi], [enable_debug=no]) if test x$enable_debug != xyes ; then AC_DEFINE_UNQUOTED([NDEBUG], [1], [Disable extra debugging checks for development]) fi AC_ARG_ENABLE([asan], [AS_HELP_STRING([--enable-asan], [Enable address sanitiser])], [if test x$enableval = xyes; then NVC_DEBUG_ONLY([--enable-asan]) EXTRA_CFLAGS="$EXTRA_CFLAGS -fsanitize=address -fno-omit-frame-pointer" EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fsanitize=address -fno-omit-frame-pointer" fi]) AC_ARG_ENABLE([tsan], [AS_HELP_STRING([--enable-tsan], [Enable thread sanitiser])], [if test x$enableval = xyes; then NVC_DEBUG_ONLY([--enable-tsan]) EXTRA_CFLAGS="$EXTRA_CFLAGS -fsanitize=thread" EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fsanitize=thread" fi]) AC_ARG_ENABLE([ubsan], [AS_HELP_STRING([--enable-ubsan], [Enable undefined behaviour sanitiser])], [if test x$enableval = xyes; then NVC_DEBUG_ONLY([--enable-ubsan]) EXTRA_CFLAGS="$EXTRA_CFLAGS -fsanitize=undefined" EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fsanitize=undefined" fi]) AC_ARG_ENABLE([default-paths], [AS_HELP_STRING([--disable-default-paths], [Disable default library search paths])], [enable_default_paths=$enableval], [enable_default_paths=yes]) if test x$enable_default_paths != xno ; then AC_DEFINE_UNQUOTED([ENABLE_DEFAULT_PATHS], [1], [Enable default library search paths]) fi AC_ARG_ENABLE([lto], [AS_HELP_STRING([--disable-lto], [Disable link time optimisation])], [enable_lto=$enableval], [AS_IF([test x$enable_debug = xyes], [enable_lto=no], # LTO off by default in debug builds [enable_lto=yes])]) LTO_FLAG= if test x$enable_lto = xyes; then AX_CHECK_COMPILE_FLAG([-flto=auto], [LTO_FLAG="-flto=auto"], [], [-Werror]) AX_CHECK_LINK_FLAG([$LTO_FLAG], [], [LTO_FLAG=], [-Werror]) AX_COMPILER_VENDOR AS_CASE([$ax_cv_c_compiler_vendor], [gnu], [AC_CHECK_TOOLS([AR], [gcc-ar ar]) AC_CHECK_TOOLS([RANLIB], [gcc-ranlib ranlib])], [clang], [AC_CHECK_TOOLS([AR], [llvm-ar ar]) AC_CHECK_TOOLS([RANLIB], [llvm-ranlib ranlib])]) else AC_CHECK_TOOL([AR], [ar]) AC_PROG_RANLIB fi AC_SUBST(LTO_FLAG) AC_ARG_WITH([bash-completion], AS_HELP_STRING( [--with-bash-completion[=PATH]], [Install the bash auto-completion script in this directory.]), [], [with_bash_completion=yes]) if test "x$with_bash_completion" = "xyes"; then BASH_COMPLETION_DIR="$datadir/bash-completion/completions" else BASH_COMPLETION_DIR="$with_bash_completion" fi AC_SUBST([BASH_COMPLETION_DIR]) AM_CONDITIONAL([ENABLE_BASH_COMPLETION], [test "x$with_bash_completion" != "xno"]) # Turn on silent make when using the GNU version AX_CHECK_GNU_MAKE if test x$_cv_have_gnu_make = xyes ; then MAKEFLAGS='$(if $(V),,-s)' fi # Do not use built-in make rules AX_APPEND_FLAG([-r], [MAKEFLAGS]) AC_ARG_ENABLE([parallel_make], [AS_HELP_STRING([--enable-parallel-make], [Enable make -j by default])], [parallel_make=$enableval], [parallel_make=no]) # Build with make -j by default but only if requested if test x$parallel_make = xyes; then AC_MSG_CHECKING([whether to enable parallel make by default]) AX_COMPARE_VERSION([$ax_check_gnu_make_version], [ge], [4,0], [AC_MSG_RESULT([yes]) AX_APPEND_FLAG([-j], [MAKEFLAGS])], [AC_MSG_RESULT([no])]) fi AC_SUBST(MAKEFLAGS) # Instrument the compiler with code coverage AC_ARG_ENABLE([gcov], [AS_HELP_STRING([--enable-gcov], [Instrument compiler with gcov (for development only)])], [enable_gcov=$enableval if test x$enableval = xyes; then NVC_DEBUG_ONLY([--enable-gcov]) EXTRA_CFLAGS="$EXTRA_CFLAGS --coverage -fno-inline -Og" EXTRA_LDFLAGS="$EXTRA_LDFLAGS --coverage" fi], [enable_gcov=no]) AM_CONDITIONAL([ENABLE_GCOV], [test x$enable_gcov = xyes]) AC_DEFINE_UNQUOTED([TARGET_SYSTEM], ["$target"], [Target system description for crash reports]) AC_SUBST(EXTRA_CFLAGS) AC_SUBST(EXTRA_LDFLAGS) AC_SUBST(EXTRA_YFLAGS) AS_IF([test x$enable_maintainer_mode = xyes ], [AC_PATH_PROG([MANDOC], [mandoc])]) AM_CONDITIONAL([HAVE_MANDOC], [test -n "$MANDOC"]) # Work around automake setting ARFLAGS=cru by default which produces a # warning on modern systems ARFLAGS="${ARFLAGS:-cr}" AC_SUBST(ARFLAGS) AC_CONFIG_HEADERS([config.h]) AC_CONFIG_FILES([Makefile]) AC_OUTPUT nvc-r1.17.1/contrib/000077500000000000000000000000001504111170000141775ustar00rootroot00000000000000nvc-r1.17.1/contrib/Makemodule.am000066400000000000000000000010051504111170000165750ustar00rootroot00000000000000pkglibexec_SCRIPTS += \ contrib/functions.sh \ contrib/install-osvvm.sh \ contrib/install-osvvm.tcl \ contrib/install-uvvm.sh \ contrib/install-vivado.sh \ contrib/install-quartus.sh \ contrib/install-ise.sh \ contrib/install-icecube2.sh \ contrib/install-libero.sh \ contrib/install-vunit.sh \ contrib/install-xpm_vhdl.sh \ contrib/install-fmf.sh EXTRA_DIST += $(pkglibexec_SCRIPTS) if ENABLE_BASH_COMPLETION bashcompletiondir = $(BASH_COMPLETION_DIR) dist_bashcompletion_DATA = contrib/nvc.bash endif nvc-r1.17.1/contrib/README.md000066400000000000000000000002011504111170000154470ustar00rootroot00000000000000This directory contains scripts to install various third party packages. Feel free to create a pull request to add new packages. nvc-r1.17.1/contrib/STYLE.md000066400000000000000000000057651504111170000154360ustar00rootroot00000000000000When submitting patches please make sure your code is formatted using the same style as existing code. Namely: * Indent with three spaces *never* with tabs. * Lines should never be longer than 80 characters, including comments. * Do not break lines before opening braces *except* at the start of a function. For example: ```c void my_func(int x) { if (x > 5) { for (int i = 0; i < 100; i++) { // .... } } } ``` * When an `if` statement branch has a single statement do not wrap it with braces, unless that statement is particularly large and split over multiple lines. ```c if (x < 10) do_something(); ``` * Put a line break after a closing brace and before an `else`. This is sometimes called the "Stroustrup" style in editors. ```c if (x == 7) { // .... } else { // .... } ``` * Insert a space around operators and between keywords and opening parenthesis, as in the examples above. * Remove all trailing whitespace and do not insert more than one blank line at a time. * Use C++ style `//` comments instead of traditional C `/*` comments. * All identifiers are `snake_case`, never `camelCase` or `PascalCase`. * When in doubt, refer to how existing code formats the construct you are using. Some more general coding guidelines: * Avoid the standard C string functions where possible as they are difficult to use correctly. Instead use the `text_buf_t` functions declared in `util.h` (e.g. `tb_printf` and friends). * If you must call `sprintf` then use `checked_sprintf` instead which avoids common mistakes. * Generally, try to use the wrapper functions from `util.h` where possible as these are portable and handle errors for you. For example `make_dir()` instead of `mkdir()` (which takes different arguments on Windows vs other systems). * Do not call `malloc`, `calloc`, etc. directly. Instead use the wrapper functions `xmalloc`, `xcalloc` and so on which check for allocation failure. * To allocate an array dynamically use `xmalloc_array(count, size)` instead of `xmalloc(count * size)` as the former checks for integer overflow. * Typedefs are suffixed with `_t`. Yes, I know this is reserved by POSIX. * Most of the code is written in pseudo object-oriented style. Prefer opaque structs in header files with accessor functions over exposing the struct fields. For a type `foo_t` there should be a constructor `foo_new` and, if applicable, a cleanup function `foo_free`. Methods on `foo_t` are usually prefixed `foo_` unless this makes the name awkward. * Use `LOCAL` in a pointer declaration to automatically free storage at the end of its scope (this is a macro that expands to `__attribute__((cleanup(..)))`). This is much less error-prone than manually calling `free`. `LOCAL_TEXT_BUF` is an instance of `text_buf_t` that is freed at the end of its scope. * Avoid writing excessive amounts of comments unless it is particularly difficult to understand the code without them. nvc-r1.17.1/contrib/debian/000077500000000000000000000000001504111170000154215ustar00rootroot00000000000000nvc-r1.17.1/contrib/debian/changelog000066400000000000000000000002151504111170000172710ustar00rootroot00000000000000nvc (1.10-1) UNRELEASED; urgency=medium * Built from GitHub actions. -- Nick Gasson Sun, 23 Apr 2023 14:33:19 +0100 nvc-r1.17.1/contrib/debian/compat000066400000000000000000000000031504111170000166200ustar00rootroot0000000000000010 nvc-r1.17.1/contrib/debian/control000066400000000000000000000006171504111170000170300ustar00rootroot00000000000000Source: nvc Maintainer: Nick Gasson Section: misc Priority: optional Standards-Version: 3.9.2 Build-Depends: debhelper (>= 9), tcl-dev, llvm-dev, libreadline-dev, check, libzstd-dev, libdw-dev, libjansson-dev, flex, pkg-config, git Package: nvc Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, binutils Recommends: tcllib Description: VHDL compiler and simulator nvc-r1.17.1/contrib/debian/copyright000066400000000000000000000016731504111170000173630ustar00rootroot00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: NVC Source: https://www.nickg.me.uk/nvc/ Files: * Copyright: 2011-2023 Nick Gasson License: GPL-3+ This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. . This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. . You should have received a copy of the GNU General Public License along with this program. If not, see . . On Debian systems, the complete text of the GNU General Public License version 2 can be found in "/usr/share/common-licenses/GPL-3". nvc-r1.17.1/contrib/debian/rules000077500000000000000000000002621504111170000165010ustar00rootroot00000000000000#!/usr/bin/make -f %: dh $@ --builddirectory=build/x-debian override_dh_auto_configure: dh_auto_configure --builddirectory=build/x-debian -- \ --enable-tcl --enable-server nvc-r1.17.1/contrib/debian/source/000077500000000000000000000000001504111170000167215ustar00rootroot00000000000000nvc-r1.17.1/contrib/debian/source/format000066400000000000000000000000141504111170000201270ustar00rootroot000000000000003.0 (quilt) nvc-r1.17.1/contrib/docker/000077500000000000000000000000001504111170000154465ustar00rootroot00000000000000nvc-r1.17.1/contrib/docker/Dockerfile000066400000000000000000000010151504111170000174350ustar00rootroot00000000000000FROM debian:bookworm AS build WORKDIR /src COPY . . RUN ln -s contrib/debian . ARG VERSION RUN sed -i "s/nvc (.*)/nvc ($VERSION-1)/" debian/changelog RUN apt-get -y update RUN apt-get -y build-dep . RUN DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -uc -us -b FROM debian:bookworm RUN --mount=from=build,target=/src \ apt-get -y update && \ apt-get -y install /src/nvc_*.deb && \ rm -rf /var/lib/apt/lists/* RUN nvc --version CMD ["/usr/bin/nvc"] LABEL org.opencontainers.image.source=https://github.com/nickg/nvc nvc-r1.17.1/contrib/docker/Dockerfile.dockerignore000066400000000000000000000001111504111170000221030ustar00rootroot00000000000000# -*- mode: fundamental -*- build/ contrib/docker/ .github/ *~ configure nvc-r1.17.1/contrib/docker/build.sh000077500000000000000000000004121504111170000171010ustar00rootroot00000000000000#!/bin/bash set -e -o pipefail cd $(dirname ${BASH_SOURCE[0]})/../.. vers=$(sed -n '1s/AC_INIT(\[.*\], \[\([0-9\.]*\).*\].*/\1/p' configure.ac) docker build -f contrib/docker/Dockerfile . \ --build-arg VERSION=$vers \ --tag ghcr.io/nickg/nvc:latest nvc-r1.17.1/contrib/functions.sh000066400000000000000000000022131504111170000165410ustar00rootroot00000000000000#!/bin/bash if [ -z "$NVC_INSTALL_DEST" ]; then if command -v cygpath &>/dev/null; then export NVC_INSTALL_DEST="$(cygpath -m $HOME)/.nvc/lib" else export NVC_INSTALL_DEST=$HOME/.nvc/lib fi fi export SCRIPT_DIR=$(dirname $BASH_SOURCE) _safe () { echo $* $* [ $? = 0 ] || exit 1 } _nvc () { local _work=${WORK:-work} local _dest=$NVC_INSTALL_DEST local _opts="--std=${STD:-1993} --work=$_dest/$_work -L$_dest $GLOBAL_OPTS" [ -d $_dest ] || _safe mkdir -p $_dest _safe ${NVC:-nvc} $_opts $* } analyse () { local _files=$* _nvc -a $A_OPTS $_files } analyse_list () { local _work=$1 shift if [ $# -gt 0 ]; then WORK=$_work _nvc -a $A_OPTS -f $* else while read _src; do WORK=$_work analyse $_src done fi } git_wrapper () { local _repo=$1 local _base=$(basename $_repo) local _tag=$2 local _cache=${CACHE:-$HOME/.cache/nvc}/$_base-$_tag if [ ! -d $_cache/.git ]; then _safe mkdir -p $_cache _safe git clone --recursive $_repo -b $_tag $_cache --depth=1 fi _safe cd $_cache } std_suffix () { case "$1" in 1993) ;; 2008) echo ".08" ;; 2019) echo ".19" ;; esac } nvc-r1.17.1/contrib/gui/000077500000000000000000000000001504111170000147635ustar00rootroot00000000000000nvc-r1.17.1/contrib/gui/.eslintrc.js000066400000000000000000000025771504111170000172350ustar00rootroot00000000000000module.exports = { "env": { "browser": true, "es2021": true }, "extends": [ "eslint:recommended", "plugin:@typescript-eslint/recommended", ], "overrides": [ { "env": { "node": true }, "files": [ ".eslintrc.{js,cjs}", "*.config.js", ], "parserOptions": { "sourceType": "script" } } ], "parser": "@typescript-eslint/parser", "parserOptions": { "ecmaVersion": "latest", "sourceType": "module" }, "plugins": [ "@typescript-eslint", "@stylistic", ], "ignorePatterns": ["node_modules/", "dist/"], "rules": { "@typescript-eslint/no-explicit-any": [ "off" ], "@stylistic/indent": [ "error", 2, { "ignoredNodes": ["JSXElement *", "JSXElement"], "SwitchCase": 1 } ], "@stylistic/jsx-indent-props": [ "warn", "first" ], "@stylistic/jsx-closing-bracket-location": [ "warn", "after-props" ], "@stylistic/jsx-first-prop-new-line": [ "warn", "never" ], "@stylistic/quotes": [ "warn", "double" ], "@stylistic/semi": [ "error", "always" ], "@stylistic/brace-style": [ "error", "stroustrup", { "allowSingleLine": true } ], "@stylistic/type-annotation-spacing": [ "error" ], "@stylistic/max-len": ["error", { "code": 80 }], "@stylistic/no-tabs": ["error"], "@stylistic/eol-last": ["error", "always"], } }; nvc-r1.17.1/contrib/gui/Makemodule.am000066400000000000000000000027751504111170000174000ustar00rootroot00000000000000NPM = $(AM_V_GEN)npm --prefix $(top_srcdir)/contrib/gui BUNDLE_ASSETS = \ gui/assets/index.css \ gui/assets/allPaths.js \ gui/assets/allPathsLoader.js \ gui/assets/splitPathsBySizeLoader.js \ gui/assets/index2.js \ gui/assets/index3.js \ gui/assets/index.js if ENABLE_GUI guidir = $(pkgdatadir)/gui assetsdir = $(guidir)/assets gui_DATA = gui/index.html contrib/gui/guilib.tcl assets_DATA = $(BUNDLE_ASSETS) CLEANFILES += gui/index.html $(BUNDLE_ASSETS) .stamp-npm gui/index.html: $(GUI_FILES) .stamp-npm $(AM_V_GEN)( \ cd $(top_srcdir)/contrib/gui; \ npx tsc -noEmit && \ npm run lint && \ npx vite build --outDir $(abs_builddir)/gui --emptyOutDir; \ ) gui/assets/index.css: gui/index.html gui/assets/allPaths.js: gui/index.html gui/assets/allPathsLoader.js: gui/index.html gui/assets/splitPathsBySizeLoader.js: gui/index.html gui/assets/index2.js: gui/index.html gui/assets/index3.js: gui/index.html gui/assets/index.js: gui/index.html .stamp-npm: $(srcdir)/contrib/gui/package-lock.json $(NPM) ci $(AM_V_AT)touch .stamp-npm endif EXTRA_DIST += $(GUI_FILES) if MAINTAINER_MODE update-js-dist: $(AM_V_GEN)( \ echo "# Generated automatically, do not edit." ; \ echo "GUI_FILES = \\" ; \ cd $(top_srcdir) ; \ git ls-files -- 'contrib/gui/*.ts' 'contrib/gui/*.tsx' 'contrib/gui/*.json' \ 'contrib/gui/*.css' 'contrib/gui/*.html' \ | sort | sed -e 's/^/\t/' -e '$$ ! s/$$/ \\/' ; \ ) > $(top_srcdir)/contrib/gui/dist.mk endif .PHONY: update-js-dist include contrib/gui/dist.mk nvc-r1.17.1/contrib/gui/README.md000066400000000000000000000007521504111170000162460ustar00rootroot00000000000000## Hacking NVC always serves the static HTML and JS files from the install prefix. Development using `make`, `make install`, and then reloading is way too slow so use the [https://vitejs.dev/](Vite) development server instead by running `nvc --gui` and then `npm start` in this directory in another window. The open [http://localhost:5173](http://localhost:5173) in your web browser (note the different port number). This will automatically reload when any of the source files changes. nvc-r1.17.1/contrib/gui/babel.config.js000066400000000000000000000002011504111170000176230ustar00rootroot00000000000000module.exports = { presets: [ ["@babel/preset-env", {targets: {node: "current"}}], "@babel/preset-typescript", ], }; nvc-r1.17.1/contrib/gui/component/000077500000000000000000000000001504111170000167655ustar00rootroot00000000000000nvc-r1.17.1/contrib/gui/component/App.tsx000066400000000000000000000044621504111170000202530ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // import type { Toaster } from "@blueprintjs/core"; import { FocusStyleManager, OverlayToaster } from "@blueprintjs/core"; import "@blueprintjs/core/lib/css/blueprint.css"; import React from "react"; import Split from "react-split"; import Conduit from "../lib/conduit"; import { Model } from "../lib/model"; import ClosedAlert from "./ClosedAlert"; import Transcript from "./Transcript"; import WaveView from "./WaveView"; import Sidebar from "./Sidebar"; import { bindEvents } from "../lib/react-util"; const socket = new WebSocket(`ws://${window.location.host}/socket`); socket.binaryType = "arraybuffer"; const conduit = new Conduit(socket); const model = new Model(conduit); const toaster: Toaster = OverlayToaster.create({ position: "top-right" }); function showRestartToast() { toaster.show({ message: "simulation restarted" }); } function setWindowTitle(top: string) { toaster.show({ message: `simulation ${top} loaded` }); document.title = `${top.toLowerCase()} - NVC`; } function showQuitToast() { toaster.show({ message: "simulation unloaded" }); } FocusStyleManager.onlyShowFocusOnTabs(); function App() { bindEvents(model, { restartSim: showRestartToast, quitSim: showQuitToast, startSim: setWindowTitle, }); return (
); } export default App; nvc-r1.17.1/contrib/gui/component/ClosedAlert.tsx000066400000000000000000000025371504111170000217350ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // import { Alert, Intent } from "@blueprintjs/core"; import React, { useEffect, useState } from "react"; import type Conduit from "../lib/conduit"; interface IProps { conduit: Conduit; } function ClosedAlert(props: IProps) { const [closed, setClosed] = useState(false); useEffect(() => { props.conduit.onClose = () => { setClosed(true); }; }, []); const onConfirm = () => { location.reload(); }; return (

Lost connection to server

 ); } export default ClosedAlert; nvc-r1.17.1/contrib/gui/component/Sidebar.tsx000066400000000000000000000020411504111170000210730ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // import React from "react"; import { Tab, Tabs } from "@blueprintjs/core"; import SignalPanel from "./SignalPanel"; function Sidebar() { return ( } /> ); } export default Sidebar; nvc-r1.17.1/contrib/gui/component/SignalPanel.tsx000066400000000000000000000015631504111170000217270ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // import React from "react"; function SignalPanel() { return (

Example panel

text

); } export default SignalPanel; nvc-r1.17.1/contrib/gui/component/Toolbar.tsx000066400000000000000000000034501504111170000211310ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // import { Navbar, Button, Alignment, Classes } from "@blueprintjs/core"; import React from "react"; import { formatTime } from "../lib/time-util"; interface IProps { now: bigint; height: number; onZoomIn?: () => void; onZoomOut?: () => void; } function Toolbar({now, height, onZoomIn, onZoomOut}: IProps) { return ( {formatTime(now)} ", istr(item->hier), out_of_table ? "style=\"float: right;\"" : "", out_of_table ? "Exclude Command " : ""); if (add_td) fprintf(f, ""); } static void cover_print_bin(FILE *f, cover_pair_t *pair, uint32_t flag, cov_pair_kind_t pkind, int cols, const char **vals) { if (pair->item->flags & flag) { fprintf(f, "Bin"); for (int i = 0; i < cols; i++) fprintf(f, "%s", vals[i]); // Toggle flags hold unreachability in highest bit of runtime data // Must be masked out to print properly fprintf(f, "%d", (pair->item->data) & ~COV_FLAG_UNREACHABLE); fprintf(f, "%d", pair->item->atleast); if (pkind == PAIR_UNCOVERED) cover_print_get_exclude_button(f, pair->item, flag, true); if (pkind == PAIR_EXCLUDED) { cover_flags_t flags = pair->item->flags; const char *er = (flags & COV_FLAG_UNREACHABLE) ? "Unreachable" : (flags & COV_FLAG_EXCLUDED_USER) ? "User exclude" : "Exclude file"; fprintf(f, "%s", er); } fprintf(f, ""); } } static void cover_print_bin_header(FILE *f, cov_pair_kind_t pkind, int cols, const char **titles) { fprintf(f, "
"); fprintf(f, ""); for (int i = 0; i < cols; i++) { const char *val = titles[i]; fprintf(f, "", val); } fprintf(f, ""); fprintf(f, ""); if (pkind == PAIR_UNCOVERED) fprintf(f, ""); if (pkind == PAIR_EXCLUDED) fprintf(f, ""); fprintf(f, ""); } static void cover_print_bins(FILE *f, cover_pair_t *first_pair, cov_pair_kind_t pkind) { cover_pair_t *last_pair = first_pair + first_pair->item->consecutive - 1; for (cover_pair_t *pair = first_pair; pair <= last_pair; pair++) { loc_t loc = pair->item->loc; switch (pair->item->kind) { case COV_ITEM_BRANCH: { const char *v_true = "True"; const char *v_false = "False"; cover_print_bin(f, pair, COV_FLAG_TRUE, pkind, 1, &v_true); cover_print_bin(f, pair, COV_FLAG_FALSE, pkind, 1, &v_false); if (pair->item->flags & COV_FLAG_CHOICE) { int curr = loc.first_column; int last = (loc.line_delta) ? strlen(pair->line->text) : loc.column_delta + curr; LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, ""); while (curr <= last) { tb_printf(tb, "%c", pair->line->text[curr]); curr++; } tb_printf(tb, ""); const char *v = tb_get(tb); cover_print_bin(f, pair, COV_FLAG_CHOICE, pkind, 1, &v); } break; } case COV_ITEM_TOGGLE: { const char *v_01[2] = {"0", "1"}; const char *v_10[2] = {"1", "0"}; cover_print_bin(f, pair, COV_FLAG_TOGGLE_TO_1, pkind, 2, v_01); cover_print_bin(f, pair, COV_FLAG_TOGGLE_TO_0, pkind, 2, v_10); break; } case COV_ITEM_STATE: { ident_t state_name = ident_rfrom(pair->item->hier, '.'); const char *v = istr(state_name); cover_print_bin(f, pair, COV_FLAG_STATE, pkind, 1, &v); break; } case COV_ITEM_EXPRESSION: { const char *t_str = (pair->item->flags & COV_FLAG_EXPR_STD_LOGIC) ? "'1'" : "True"; const char *f_str = (pair->item->flags & COV_FLAG_EXPR_STD_LOGIC) ? "'0'" : "False"; const char *ff[2] = {f_str, f_str}; const char *ft[2] = {f_str, t_str}; const char *tf[2] = {t_str, f_str}; const char *tt[2] = {t_str, t_str}; if ((pair->item->flags & COV_FLAG_TRUE) || (pair->item->flags & COV_FLAG_FALSE)) { cover_print_bin(f, pair, COV_FLAG_TRUE, pkind, 1, &t_str); cover_print_bin(f, pair, COV_FLAG_FALSE, pkind, 1, &f_str); } else if (pair->item->flags & COV_FLAG_00 || pair->item->flags & COV_FLAG_01 || pair->item->flags & COV_FLAG_10 || pair->item->flags & COV_FLAG_11) { cover_print_bin(f, pair, COV_FLAG_00, pkind, 2, ff); cover_print_bin(f, pair, COV_FLAG_01, pkind, 2, ft); cover_print_bin(f, pair, COV_FLAG_10, pkind, 2, tf); cover_print_bin(f, pair, COV_FLAG_11, pkind, 2, tt); } break; } case COV_ITEM_FUNCTIONAL: { cover_item_t *item = pair->item; assert (item->source == COV_SRC_USER_COVER); const char *v[item->n_ranges] LOCAL; for (int i = 0; i < item->n_ranges; i++) if (item->ranges[i].min == item->ranges[i].max) v[i] = xasprintf("%"PRIi64, item->ranges[i].min); else v[i] = xasprintf("%"PRIi64" - %"PRIi64, item->ranges[i].min, item->ranges[i].max); cover_print_bin(f, pair, COV_FLAG_USER_DEFINED, pkind, item->n_ranges, v); break; } default: fatal("unsupported type of code coverage: %d at 'cover_print_bins' !", pair->item->kind); } } fprintf(f, "
%sCountThresholdExclude CommandExcluded due to
"); } static void cover_print_pairs(FILE *f, cover_pair_t *first, cov_pair_kind_t pkind, int pair_cnt) { if (pair_cnt == 0) return; cover_pair_t *last = first + pair_cnt - 1; cover_pair_t *curr = first; int step; do { if (curr > first) fprintf(f, "
"); step = curr->item->consecutive; switch (curr->item->kind) { case COV_ITEM_STMT: if (pkind == PAIR_UNCOVERED) cover_print_get_exclude_button(f, curr->item, 0, false); if (pkind == PAIR_EXCLUDED) fprintf(f, "
Excluded due to: Exclude file
"); cover_print_item_title(f, curr); cover_print_code_loc(f, curr); fprintf(f, "
Count: %d", curr->item->data); fprintf(f, "
Threshold: %d", curr->item->atleast); break; case COV_ITEM_BRANCH: { cover_print_item_title(f, curr); cover_print_code_loc(f, curr); const char *title = (curr->item->flags & COV_FLAG_CHOICE) ? "Choice of" : "Evaluated to"; cover_print_bin_header(f, pkind, 1, &title); cover_print_bins(f, curr, pkind); break; } case COV_ITEM_TOGGLE: { if (curr->item->flags & COV_FLAG_TOGGLE_SIGNAL) fprintf(f, "

Signal:

"); else if (curr->item->flags & COV_FLAG_TOGGLE_PORT) fprintf(f, "

Port:

"); const char *sig_name = istr(ident_runtil(curr->item->hier, '.')); sig_name += curr->item->metadata; fprintf(f, " %s", sig_name); const char *title[2] = {"From", "To"}; cover_print_bin_header(f, pkind, 2, title); cover_print_bins(f, curr, pkind); break; } case COV_ITEM_EXPRESSION: { cover_print_item_title(f, curr); cover_print_code_loc(f, curr); if ((curr->item->flags & COV_FLAG_TRUE) || (curr->item->flags & COV_FLAG_FALSE)) { const char *title = "Evaluated to"; cover_print_bin_header(f, pkind, 1, &title); } else { const char *title[2] = {"LHS", "RHS"}; cover_print_bin_header(f, pkind, 2, title); } cover_print_bins(f, curr, pkind); break; } case COV_ITEM_STATE: cover_print_item_title(f, curr); cover_print_code_loc(f, curr); const char *title = "State"; cover_print_bin_header(f, pkind, 1, &title); cover_print_bins(f, curr, pkind); break; case COV_ITEM_FUNCTIONAL: if (curr->item->source == COV_SRC_USER_COVER) { cover_print_item_title(f, curr); fprintf(f, "
%s", istr(curr->item->func_name)); const char *title[curr->item->n_ranges] LOCAL; for (int i = 0; i < curr->item->n_ranges; i++) title[i] = xasprintf("Variable %d", i); cover_print_bin_header(f, pkind, curr->item->n_ranges, title); cover_print_bins(f, curr, pkind); } else { if (pkind == PAIR_UNCOVERED) cover_print_get_exclude_button(f, curr->item, 0, false); cover_print_item_title(f, curr); cover_print_code_loc(f, curr); fprintf(f, "
Count: %d", curr->item->data); fprintf(f, "
Threshold: %d", curr->item->atleast); } break; default: fatal("unsupported type of code coverage: %d at 'cover_print_pairs' !", curr->item->kind); } curr += step; } while (curr <= last); fprintf(f, "
\n"); } static void cover_print_chain(FILE *f, cover_data_t *data, cover_chain_t *chn, cover_item_kind_t kind) { // HTML TAB fprintf(f, "
\n"); for (cov_pair_kind_t pkind = PAIR_UNCOVERED; pkind < PAIR_LAST; pkind++) { int n; cover_pair_t *first_pair; if (pkind == PAIR_UNCOVERED) { if (cover_enabled(data, COVER_MASK_DONT_PRINT_UNCOVERED)) continue; first_pair = chn->miss; n = chn->n_miss; } else if (pkind == PAIR_EXCLUDED) { if (cover_enabled(data, COVER_MASK_DONT_PRINT_EXCLUDED)) continue; first_pair = chn->excl; n = chn->n_excl; } else { if (cover_enabled(data, COVER_MASK_DONT_PRINT_COVERED)) continue; first_pair = chn->hits; n = chn->n_hits; } fprintf(f, "
\n"); else if (pkind == PAIR_EXCLUDED) fprintf(f, "#d6eaf8;\">\n"); else fprintf(f, "#ccffcc;\">\n"); fprintf(f, "

"); if (pkind == PAIR_UNCOVERED) fprintf(f, "Uncovered "); else if (pkind == PAIR_EXCLUDED) fprintf(f, "Excluded "); else fprintf(f, "Covered "); if (kind == COV_ITEM_STMT) fprintf(f, "statements:"); else if (kind == COV_ITEM_BRANCH) fprintf(f, "branches:"); else if (kind == COV_ITEM_TOGGLE) fprintf(f, "toggles:"); else if (kind == COV_ITEM_EXPRESSION) fprintf(f, "expressions:"); else if (kind == COV_ITEM_STATE) fprintf(f, "FSM states:"); else if (kind == COV_ITEM_FUNCTIONAL) fprintf(f, "functional coverage:"); fprintf(f, "

\n"); fprintf(f, "
\n"); cover_print_pairs(f, first_pair, pkind, n); fprintf(f, "
\n"); fprintf(f, "
\n\n"); } fprintf(f, "
\n"); } static void cover_print_chns(FILE *f, cover_data_t *data, cover_chain_group_t *chns) { fprintf(f, "
" " \n" " \n" " \n" " \n" " \n" " \n" "
\n\n"); cover_print_chain(f, data, &(chns->stmt), COV_ITEM_STMT); cover_print_chain(f, data, &(chns->branch), COV_ITEM_BRANCH); cover_print_chain(f, data, &(chns->toggle), COV_ITEM_TOGGLE); cover_print_chain(f, data, &(chns->expression), COV_ITEM_EXPRESSION); cover_print_chain(f, data, &(chns->state), COV_ITEM_STATE); cover_print_chain(f, data, &(chns->functional), COV_ITEM_FUNCTIONAL); } static void cover_print_jscript_funcs(FILE *f) { fprintf(f, "\n"); } static bool cover_bin_unreachable(cover_data_t *data, cover_item_t *item) { if ((data->mask & COVER_MASK_EXCLUDE_UNREACHABLE) == 0) return false; // Toggle items remember unreachability in run-time data. Must check item kind // not to get false unreachability on statement items. Excludes both bins // automatically! if (item->kind == COV_ITEM_TOGGLE && ((item->data & COV_FLAG_UNREACHABLE) != 0)) { item->flags |= COV_FLAG_UNREACHABLE; return true; } // Expression items remember unreachability as unreachable mask if (item->kind == COV_ITEM_EXPRESSION && ((item->flags & COV_FLAG_UNREACHABLE) != 0)) return true; return false; } #define CHAIN_APPEND(chn, type, first_chn_item, curr_item, curr_line) \ do { \ if (chn->n_##type == chn->alloc_##type) { \ chn->alloc_##type *= 2; \ chn->type = xrealloc_array(chn->type , chn->alloc_##type , \ sizeof(cover_pair_t)); \ } \ chn->type[chn->n_##type].item = curr_item; \ chn->type[chn->n_##type].line = curr_line; \ chn->n_##type++; \ /* Count consecutive items appended to the one single chain type */ \ if (first_chn_item == NULL) { \ first_chn_item = curr_item; \ first_chn_item->consecutive = 1; \ } \ else \ first_chn_item->consecutive++; \ } while (0); static int cover_append_item_to_chain(cover_data_t *data, cover_chain_group_t *chns, cover_stats_t *flat, cover_stats_t *nested, cover_item_t *first_item, cover_line_t *line, int *skipped) { unsigned *flat_total = NULL; unsigned *nested_total = NULL; unsigned *flat_hits = NULL; unsigned *nested_hits = NULL; cover_chain_t *chn; switch (first_item->kind) { case COV_ITEM_STMT: flat_total = &(flat->total_stmts); flat_hits = &(flat->hit_stmts); nested_total = &(nested->total_stmts); nested_hits = &(nested->hit_stmts); chn = &(chns->stmt); break; case COV_ITEM_BRANCH: flat_total = &(flat->total_branches); flat_hits = &(flat->hit_branches); nested_total = &(nested->total_branches); nested_hits = &(nested->hit_branches); chn = &(chns->branch); break; case COV_ITEM_TOGGLE: flat_total = &(flat->total_toggles); flat_hits = &(flat->hit_toggles); nested_total = &(nested->total_toggles); nested_hits = &(nested->hit_toggles); chn = &(chns->toggle); break; case COV_ITEM_STATE: flat_total = &(flat->total_states); flat_hits = &(flat->hit_states); nested_total = &(nested->total_states); nested_hits = &(nested->hit_states); chn = &(chns->state); break; case COV_ITEM_EXPRESSION: flat_total = &(flat->total_expressions); flat_hits = &(flat->hit_expressions); nested_total = &(nested->total_expressions); nested_hits = &(nested->hit_expressions); chn = &(chns->expression); break; case COV_ITEM_FUNCTIONAL: flat_total = &(flat->total_functional); flat_hits = &(flat->hit_functional); nested_total = &(nested->total_functional); nested_hits = &(nested->hit_functional); chn = &(chns->functional); break; default: fatal("unsupported type of code coverage: %d at 'cover_append_item_to_chain'!", first_item->kind); } // Process all consecutive cover_items in belonging to the same RTL construct // "first_item->consecutive" gives the number of items to process since cover item emit. // Re-distribute so that this number is valid even if the items are sorted into // "hit", "miss" and "exclude" pair lists. The "consecutive" in the original cover_item // will get corrupted, but "consecutive" for each first item in each of the pair lists will // correspond to how many items within that given pair list correspond to the // same RTL construct. This re-sorting then simplifies coverage reporting. cover_item_t *first_hits_item = NULL; cover_item_t *first_miss_item = NULL; cover_item_t *first_excl_item = NULL; int n_steps = first_item->consecutive; cover_item_t *last_item = first_item + n_steps - 1; for (cover_item_t *curr_item = first_item; curr_item <= last_item; curr_item++) { (*flat_total)++; (*nested_total)++; if (curr_item->data >= curr_item->atleast && curr_item->atleast > 0) { (*flat_hits)++; (*nested_hits)++; if (chn->n_hits > data->report_item_limit) { (*skipped)++; curr_item++; continue; } CHAIN_APPEND(chn, hits, first_hits_item, curr_item, line) } else if ((curr_item->flags & COV_FLAG_EXCLUDED) || cover_bin_unreachable(data, curr_item)) { (*flat_hits)++; (*nested_hits)++; if (chn->n_excl > data->report_item_limit) { (*skipped)++; curr_item++; continue; } CHAIN_APPEND(chn, excl, first_excl_item, curr_item, line) } else { if (chn->n_miss > data->report_item_limit) { (*skipped)++; curr_item++; continue; } CHAIN_APPEND(chn, miss, first_miss_item, curr_item, line) } }; return n_steps; } /////////////////////////////////////////////////////////////////////////////// // Per hierarchy reporting functions /////////////////////////////////////////////////////////////////////////////// static void cover_report_hier_scope(cover_rpt_hier_ctx_t *ctx, cover_scope_t *s, const char *dir, FILE *summf, int *skipped) { for (int i = 0; i < s->items.count;) { int step = 1; cover_item_t *item = &(s->items.items[i]); assert(item->loc.file_ref == s->loc.file_ref); cover_file_t *f_src = cover_file_for_scope(s); if (f_src == NULL) { i += 1; continue; } cover_line_t *line = &(f_src->lines[item->loc.first_line-1]); switch (item->kind) { case COV_ITEM_STMT: case COV_ITEM_BRANCH: case COV_ITEM_TOGGLE: case COV_ITEM_STATE: case COV_ITEM_EXPRESSION: case COV_ITEM_FUNCTIONAL: step = cover_append_item_to_chain(ctx->data, &(ctx->chns), &(ctx->flat_stats), &(ctx->nested_stats), item, line, skipped); break; default: fatal("unsupported type of code coverage: %d at 'cover_report_hier_scope'!", item->kind); } i += step; } cover_report_hier_children(ctx, s, dir, summf, skipped); } static void cover_print_summary_table_row(FILE *f, cover_data_t *data, cover_stats_t *stats, ident_t entry_name, ident_t entry_link, int lvl, bool top, bool print_out) { fprintf(f, " \n" " %s\n", top ? "hier/" : "", istr(entry_link), istr(entry_name)); cover_print_percents_cell(f, stats->hit_stmts, stats->total_stmts); cover_print_percents_cell(f, stats->hit_branches, stats->total_branches); cover_print_percents_cell(f, stats->hit_toggles, stats->total_toggles); cover_print_percents_cell(f, stats->hit_expressions, stats->total_expressions); cover_print_percents_cell(f, stats->hit_states, stats->total_states); cover_print_percents_cell(f, stats->hit_functional, stats->total_functional); int avg_total = stats->total_stmts + stats->total_branches + stats->total_toggles + stats->total_expressions + stats->total_states + stats->total_functional; int avg_hit = stats->hit_stmts + stats->hit_branches + stats->hit_toggles + stats->hit_expressions + stats->hit_states + stats->total_functional; cover_print_percents_cell(f, avg_hit, avg_total); fprintf(f, " \n"); float perc_stmt = 0.0f; float perc_branch = 0.0f; float perc_toggle = 0.0f; float perc_expr = 0.0f; float perc_state = 0.0f; float perc_functional = 0.0f; if (stats->total_stmts > 0) perc_stmt = 100.0 * ((float)stats->hit_stmts) / stats->total_stmts; if (stats->total_branches > 0) perc_branch = 100.0 * ((float)stats->hit_branches) / stats->total_branches; if (stats->total_toggles > 0) perc_toggle = 100.0 * ((float)stats->hit_toggles) / stats->total_toggles; if (stats->total_expressions > 0) perc_expr = 100.0 * ((float)stats->hit_expressions) / stats->total_expressions; if (stats->total_states > 0) perc_state = 100.0 * ((float)stats->hit_states) / stats->total_states; if (stats->total_functional > 0) perc_functional = 100.0 * ((float)stats->hit_functional) / stats->total_functional; if (top) { notef("code coverage results for: %s", istr(entry_name)); if (stats->total_stmts > 0) notef(" statement: %.1f %% (%d/%d)", perc_stmt, stats->hit_stmts, stats->total_stmts); else notef(" statement: N.A."); if (stats->total_branches > 0) notef(" branch: %.1f %% (%d/%d)", perc_branch, stats->hit_branches, stats->total_branches); else notef(" branch: N.A."); if (stats->total_toggles > 0) notef(" toggle: %.1f %% (%d/%d)", perc_toggle, stats->hit_toggles, stats->total_toggles); else notef(" toggle: N.A."); if (stats->total_expressions > 0) notef(" expression: %.1f %% (%d/%d)", perc_expr, stats->hit_expressions, stats->total_expressions); else notef(" expression: N.A."); if (stats->total_states > 0) notef(" FSM state: %.1f %% (%d/%d)", perc_state, stats->hit_states, stats->total_states); else notef(" FSM state: N.A."); if (stats->total_functional > 0) notef(" functional: %.1f %% (%d/%d)", perc_functional, stats->hit_functional, stats->total_functional); else notef(" functional: N.A."); } else if (opt_get_int(OPT_VERBOSE) && print_out) { cover_rpt_buf_t *new = xcalloc(sizeof(cover_rpt_buf_t)); new->tb = tb_new(); new->prev = data->rpt_buf; data->rpt_buf = new; tb_printf(new->tb, "%*s %-*s %10.1f %% (%d/%d) %10.1f %% (%d/%d) %10.1f %% (%d/%d) " "%10.1f %% (%d/%d) %10.1f %% (%d/%d)", lvl, "", 50-lvl, istr(ident_rfrom(entry_name, '.')), perc_stmt, stats->hit_stmts, stats->total_stmts, perc_branch, stats->hit_branches, stats->total_branches, perc_toggle, stats->hit_toggles, stats->total_toggles, perc_expr, stats->hit_expressions, stats->total_expressions, perc_state, stats->hit_states, stats->total_states); } } static char *cover_get_report_name(const char *in) { SHA1_CTX ctx; unsigned char buf[SHA1_LEN]; char *rv = xcalloc(2 * SHA1_LEN + 1); SHA1Init(&ctx); SHA1Update(&ctx, (const char unsigned*)in, strlen(in)); SHA1Final(buf, &ctx); for (int i = 0; i < SHA1_LEN; i++) snprintf(rv + i * 2, 3, "%02x", buf[i]); return rv; } static void cover_print_hier_nav_tree(FILE *f, cover_scope_t *s) { fprintf(f, "\n\n"); } static void cover_report_hier(cover_rpt_hier_ctx_t *ctx, cover_scope_t *s, const char *dir) { char *rpt_name LOCAL = cover_get_report_name(istr(s->hier)); char *hier LOCAL = xasprintf("%s/%s.html", dir, rpt_name); FILE *f = fopen(hier, "w"); if (f == NULL) fatal("failed to open report file: %s\n", hier); INIT_CHAIN(ctx, stmt); INIT_CHAIN(ctx, branch); INIT_CHAIN(ctx, toggle); INIT_CHAIN(ctx, expression); INIT_CHAIN(ctx, state); INIT_CHAIN(ctx, functional); cover_print_html_header(f); cover_print_hier_nav_tree(f, s); cover_print_inst_name(f, s); cover_file_t *src = cover_file_for_scope(s); if (src) cover_print_file_name(f, src->src_path, src->rpt_path); else cover_print_file_name(f, "", ""); fprintf(f, "

\n Sub-instances:\n

\n\n"); cover_print_summary_table_header(f, "sub_inst_table", true); int skipped = 0; cover_report_hier_children(ctx, s, dir, f, &skipped); cover_print_table_footer(f); fprintf(f, "

\n Current Instance:\n

\n\n"); cover_print_summary_table_header(f, "cur_inst_table", true); ident_t rpt_name_id = ident_new(rpt_name); cover_print_summary_table_row(f, ctx->data, &(ctx->flat_stats), s->hier, rpt_name_id, ctx->lvl, false, false); cover_print_table_footer(f); fprintf(f, "

\n Details:\n

\n\n"); if (skipped) fprintf(f, "

The limit of " "printed items was reached (%d). Total %d items are not " "displayed.

\n\n", ctx->data->report_item_limit, skipped); cover_print_chns(f, ctx->data, &(ctx->chns)); cover_print_jscript_funcs(f); cover_print_timestamp(f); fclose(f); } static void cover_report_hier_children(cover_rpt_hier_ctx_t *ctx, cover_scope_t *s, const char *dir, FILE *summf, int *skipped) { for (int i = 0; i < s->children.count; i++) { cover_scope_t *it = s->children.items[i]; if (it->type == CSCOPE_INSTANCE) { // Collect coverage of sub-block cover_rpt_hier_ctx_t sub_ctx = {}; sub_ctx.parent = ctx; sub_ctx.data = ctx->data; sub_ctx.lvl = ctx->lvl + 2; cover_report_hier(&sub_ctx, it, dir); const char *rpt_name LOCAL = cover_get_report_name(istr(it->hier)); cover_print_summary_table_row(summf, ctx->data, &(sub_ctx.nested_stats), ident_rfrom(it->hier, '.'), ident_new(rpt_name), sub_ctx.lvl, false, true); // Add coverage from sub-hierarchies ctx->nested_stats.hit_stmts += sub_ctx.nested_stats.hit_stmts; ctx->nested_stats.total_stmts += sub_ctx.nested_stats.total_stmts; ctx->nested_stats.hit_branches += sub_ctx.nested_stats.hit_branches; ctx->nested_stats.total_branches += sub_ctx.nested_stats.total_branches; ctx->nested_stats.hit_toggles += sub_ctx.nested_stats.hit_toggles; ctx->nested_stats.total_toggles += sub_ctx.nested_stats.total_toggles; ctx->nested_stats.hit_expressions += sub_ctx.nested_stats.hit_expressions; ctx->nested_stats.total_expressions += sub_ctx.nested_stats.total_expressions; ctx->nested_stats.hit_states += sub_ctx.nested_stats.hit_states; ctx->nested_stats.total_states += sub_ctx.nested_stats.total_states; ctx->nested_stats.hit_functional += sub_ctx.nested_stats.hit_functional; ctx->nested_stats.total_functional += sub_ctx.nested_stats.total_functional; } else cover_report_hier_scope(ctx, it, dir, summf, skipped); } } static void cover_report_per_hier(FILE *f, cover_data_t *data, char *subdir) { for (int i = 0; i < data->root_scope->children.count; i++) { cover_scope_t *child = AGET(data->root_scope->children, i); cover_rpt_hier_ctx_t top_ctx = {}; top_ctx.data = data; cover_report_hier(&top_ctx, child, subdir); char *rpt_link LOCAL = cover_get_report_name(istr(child->hier)); cover_print_summary_table_row(f, data, &(top_ctx.nested_stats), child->hier, ident_new(rpt_link), top_ctx.lvl, true, true); } if (opt_get_int(OPT_VERBOSE)) { notef("Coverage for sub-hierarchies:"); printf("%-55s %-20s %-20s %-20s %-20s %-20s\n", "Hierarchy", "Statement", "Branch", "Toggle", "Expression", "FSM state"); cover_rpt_buf_t *buf = data->rpt_buf; while (buf) { printf("%s\n", tb_get(buf->tb)); tb_free(buf->tb); data->rpt_buf = buf->prev; free(buf); buf = data->rpt_buf; }; } cover_print_table_footer(f); } /////////////////////////////////////////////////////////////////////////////// // Per source file reporting functions /////////////////////////////////////////////////////////////////////////////// static void cover_print_file_nav_tree(FILE *f, cover_rpt_file_ctx_t *ctx_list, int n_ctxs) { fprintf(f, "\n\n"); } static cover_rpt_file_ctx_t *cover_rpt_file_collect_scope( cover_data_t *data, cover_rpt_file_ctx_t *ctx_list, cover_scope_t *s, int *n_ctxs, int *alloc_ctxs) { cover_file_t *scope_f = cover_file_for_scope(s); if (scope_f) { // Look if data exist for this source file cover_rpt_file_ctx_t *curr_ctx = NULL; for (cover_rpt_file_ctx_t *it = ctx_list; it < ctx_list + (*n_ctxs); it++) if (it->file == scope_f) { curr_ctx = it; break; } // Create new per-file context if not if (curr_ctx == NULL) { if (*n_ctxs == *alloc_ctxs) { *alloc_ctxs *= 2; ctx_list = xrealloc_array(ctx_list, *alloc_ctxs, sizeof(cover_rpt_file_ctx_t)); } curr_ctx = ctx_list + *n_ctxs; curr_ctx->file = scope_f; (*n_ctxs)++; } int l_size = curr_ctx->items.count; // Upon first scope being placed into the file, copy directly. // This optimizes for use-case where there is single scope with many // toggle coverage items (e.g. include-mems), no need to iterate! // If multiple instantiations of instance with such toggle items is done, // then this will not help. if (l_size == 0) { for (int i = 0; i < s->items.count; i++) APUSH(curr_ctx->items, AREF(s->items, i)); } else { // Walk scope items and check if they exist in file items. // Merge if yes, append if no. // TODO: This has O(n^2). May be issue for large designs ? for (int i = 0; i < s->items.count; i++) { cover_item_t *scope_item = AREF(s->items, i); bool found = false; for (int i = 0; i < curr_ctx->items.count; i++) { cover_item_t *file_item = curr_ctx->items.items[i]; // We must take into account: // - kind - different kind items can be at the same loc // - loc - to get aggregated per-file data // - flags - to not merge different bins if ((file_item->kind == scope_item->kind) && loc_eq(&(file_item->loc), &(scope_item->loc)) && (file_item->flags == scope_item->flags)) { cover_merge_one_item(file_item, scope_item->data); found = true; break; } } if (!found) APUSH(curr_ctx->items, scope_item); } } } // Process nested scopes for (int i = 0; i < s->children.count; i++) { cover_scope_t *child = AGET(s->children, i); ctx_list = cover_rpt_file_collect_scope(data, ctx_list, child, n_ctxs, alloc_ctxs); } return ctx_list; } static void cover_report_per_file(FILE *top_f, cover_data_t *data, char *subdir) { int alloc_ctxs = 32; int n_ctxs = 0; cover_rpt_file_ctx_t *ctx_list = xcalloc_array(alloc_ctxs, sizeof(cover_rpt_file_ctx_t)); // Traverse hierarchy and merge all items into "per-file" lists for (int i = 0; i < data->root_scope->children.count; i++) { cover_scope_t *child = AGET(data->root_scope->children, i); ctx_list = cover_rpt_file_collect_scope(data, ctx_list, child, &n_ctxs, &alloc_ctxs); } // Convert to chains and print for (int i = 0; i < n_ctxs; i++) { cover_rpt_file_ctx_t *ctx = ctx_list + i; if (ctx->file == NULL) { i += 1; continue; } INIT_CHAIN(ctx, stmt); INIT_CHAIN(ctx, branch); INIT_CHAIN(ctx, toggle); INIT_CHAIN(ctx, expression); INIT_CHAIN(ctx, state); INIT_CHAIN(ctx, functional); int skipped = 0; for (int j = 0; j < ctx->items.count;) { int step = 1; cover_item_t *item = ctx->items.items[j]; cover_line_t *line = &(ctx->file->lines[item->loc.first_line-1]); cover_stats_t nested; switch (item->kind) { case COV_ITEM_STMT: case COV_ITEM_BRANCH: case COV_ITEM_TOGGLE: case COV_ITEM_STATE: case COV_ITEM_EXPRESSION: case COV_ITEM_FUNCTIONAL: step = cover_append_item_to_chain(data, &(ctx->chns), &(ctx->stats), &nested, item, line, &skipped); break; default: fatal("unsupported type of code coverage: %d at 'cover_report_per_file'!", item->kind); } j += step; } // Print per-file report char *file_name LOCAL = xstrdup((char*)ctx->file->src_path); ident_t base_name_id = ident_new(basename(file_name)); char *file_path LOCAL = xasprintf("%s/%s.html", subdir, istr(base_name_id)); FILE *f = fopen(file_path, "w"); if (f == NULL) fatal_errno("failed to open report file: %s\n", file_path); cover_print_html_header(f); cover_print_file_nav_tree(f, ctx_list, n_ctxs); cover_print_file_name(f, ctx->file->src_path, ctx->file->rpt_path); fprintf(f, "

\n Current File:\n

\n\n"); cover_print_summary_table_header(f, "cur_file_table", true); cover_print_summary_table_row(f, data, &(ctx->stats), base_name_id, base_name_id, 0, false, false); cover_print_table_footer(f); fprintf(f, "

\n Details:\n

\n\n"); if (skipped) fprintf(f, "

The limit of " "printed items was reached (%d). Total %d items are not " "displayed.

\n\n", data->report_item_limit, skipped); cover_print_chns(f, data, &(ctx->chns)); cover_print_jscript_funcs(f); cover_print_timestamp(f); // Print top table summary cover_print_summary_table_row(top_f, data, &(ctx->stats), base_name_id, base_name_id, 0, true, false); } cover_print_table_footer(top_f); cover_print_jscript_funcs(top_f); } /////////////////////////////////////////////////////////////////////////////// // Global API /////////////////////////////////////////////////////////////////////////////// void cover_report(const char *path, cover_data_t *data, int item_limit) { char *subdir LOCAL = xasprintf("%s/hier", path); make_dir(path); make_dir(subdir); static const struct { const char *name; cover_mask_t mask; } lst[] = { { "covered", COVER_MASK_DONT_PRINT_COVERED }, { "uncovered", COVER_MASK_DONT_PRINT_UNCOVERED }, { "excluded", COVER_MASK_DONT_PRINT_EXCLUDED }, }; LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "Code coverage report contains: "); bool first = true; for (int i = 0; i < ARRAY_LEN(lst); i++) if (!cover_enabled(data, lst[i].mask)) { if (first) first = false; else tb_printf(tb, ", "); tb_printf(tb, "%s", lst[i].name); } tb_printf(tb, " coverage details."); notef("Code coverage report folder: %s.", path); notef("%s", tb_get(tb)); char *top LOCAL = xasprintf("%s/index.html", path); FILE *f = fopen(top, "w"); cover_print_html_header(f); data->report_item_limit = item_limit; if (data->mask & COVER_MASK_PER_FILE_REPORT) { cover_print_summary_table_header(f, "file_table", false); cover_report_per_file(f, data, subdir); } else { cover_print_summary_table_header(f, "inst_table", true); cover_report_per_hier(f, data, subdir); } cover_print_timestamp(f); fclose(f); } nvc-r1.17.1/src/debug.c000066400000000000000000000631641504111170000145720ustar00rootroot00000000000000// // Copyright (C) 2021-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #if defined __MINGW32__ || defined __CYGWIN__ #define WINVER 0x0A00 #define _WIN32_WINNT 0x0A00 #include #include #endif #include "debug.h" #include "array.h" #include "hash.h" #include "ident.h" #include "lib.h" #include "thread.h" #include #include #include #include #if !defined __MINGW32__ && !defined __CYGWIN__ #include #include #include #include #include #endif // !__MINGW32__ && !__CYGWIN__ #if defined HAVE_LIBDW #include #include #include #elif defined HAVE_LIBDWARF #if defined HAVE_LIBDWARF_LIBDWARF_H #include #include #else // HAVE_LIBDWARF_LIBDWARF_H #include #include #endif // HAVE_LIBDWARF_LIBDWARF_H #endif #ifdef __APPLE__ #include #endif #ifdef __ARM_EABI_UNWINDER__ #define _URC_NORMAL_STOP _URC_END_OF_STACK #endif #define MAX_TRACE_DEPTH 25 struct debug_info { A(debug_frame_t*) frames; unsigned skip; }; //////////////////////////////////////////////////////////////////////////////// // Utilities typedef struct _di_lru_cache di_lru_cache_t; struct _di_lru_cache { di_lru_cache_t *next; di_lru_cache_t *prev; debug_frame_t frame; }; #define DI_LRU_SIZE 256 STATIC_ASSERT(DI_LRU_SIZE > MAX_TRACE_DEPTH); typedef struct _debug_unwinder debug_unwinder_t; struct _debug_unwinder { debug_unwinder_t *next; debug_unwind_fn_t fn; void *context; uintptr_t start; uintptr_t end; }; static debug_unwinder_t *unwinders = NULL; static void di_lru_reuse_frame(debug_frame_t *frame, uintptr_t pc) { free((char *)frame->module); free((char *)frame->symbol); free((char *)frame->srcfile); for (debug_inline_t *it = frame->inlined; it != NULL; ) { debug_inline_t *next = it->next; free((char *)it->symbol); free((char *)it->srcfile); free(it); it = next; } memset(frame, '\0', sizeof(debug_frame_t)); frame->pc = pc; } static bool di_lru_get(uintptr_t pc, debug_frame_t **pframe) { static __thread di_lru_cache_t *lru_cache = NULL; unsigned size; di_lru_cache_t **it; for (it = &lru_cache, size = 0; *it != NULL && (*it)->frame.pc != pc; it = &((*it)->next), size++) ; if (*it != NULL && *it == lru_cache) { *pframe = &((*it)->frame); return true; } else if (*it != NULL) { di_lru_cache_t *tmp = *it; if ((*it)->next) (*it)->next->prev = (*it)->prev; *it = (*it)->next; tmp->next = lru_cache; tmp->prev = NULL; lru_cache->prev = tmp; lru_cache = tmp; *pframe = &(tmp->frame); return true; } else if (size < DI_LRU_SIZE) { di_lru_cache_t *new = xcalloc(sizeof(di_lru_cache_t)); new->prev = NULL; new->next = lru_cache; if (lru_cache) lru_cache->prev = new; lru_cache = new; di_lru_reuse_frame(&(new->frame), pc); *pframe = &(new->frame); return false; } else { di_lru_cache_t *lru = container_of(it, di_lru_cache_t, next); lru->prev->next = NULL; lru->next = lru_cache; lru_cache->prev = lru; lru_cache = lru; di_lru_reuse_frame(&(lru->frame), pc); *pframe = &(lru->frame); return false; } } static bool custom_fill_frame(uintptr_t ip, debug_frame_t *frame) { for (debug_unwinder_t *uw = unwinders; uw; uw = uw->next) { if (ip >= uw->start && ip < uw->end) { (*uw->fn)(ip, frame, uw->context); return true; } } return false; } //////////////////////////////////////////////////////////////////////////////// // Libdw backend #if defined HAVE_LIBDW static void libdw_fill_inlining(uintptr_t biased_ip, Dwarf_Die *fundie, debug_frame_t *frame) { Dwarf_Die child; if (dwarf_child(fundie, &child) == 0) { Dwarf_Die *iter = &child; do { if (dwarf_tag(iter) != DW_TAG_inlined_subroutine) continue; else if (!dwarf_haspc(iter, biased_ip)) continue; debug_inline_t *inl = xcalloc(sizeof(debug_inline_t)); inl->symbol = xstrdup(dwarf_diename(iter)); Dwarf_Attribute attr; if (dwarf_attr(iter, DW_AT_abstract_origin, &attr) == NULL) continue; Dwarf_Die origin; if (dwarf_formref_die(&attr, &origin) == NULL) continue; const char *srcfile = dwarf_decl_file(iter); if (srcfile != NULL) inl->srcfile = xstrdup(srcfile); if (frame->kind == FRAME_VHDL) { Dwarf_Die *scopes; int n = dwarf_getscopes_die(&origin, &scopes); for (int i = 0; i < n; i++) { if (dwarf_tag(&(scopes[i])) == DW_TAG_module) inl->vhdl_unit = ident_new(dwarf_diename(&(scopes[i]))); } } Dwarf_Word call_lineno = 0; if (dwarf_attr(iter, DW_AT_call_line, &attr)) dwarf_formudata(&attr, &call_lineno); Dwarf_Word call_colno = 0; if (dwarf_attr(iter, DW_AT_call_column, &attr)) dwarf_formudata(&attr, &call_colno); if (frame->inlined) { inl->lineno = frame->inlined->lineno; inl->colno = frame->inlined->colno; frame->inlined->lineno = call_lineno; frame->inlined->colno = call_colno; } else { inl->lineno = frame->lineno; inl->colno = frame->colno; frame->lineno = call_lineno; frame->colno = call_colno; } inl->next = frame->inlined; frame->inlined = inl; libdw_fill_inlining(biased_ip, iter, frame); } while (dwarf_siblingof(iter, iter) == 0); } } static void platform_fill_frame(uintptr_t ip, debug_frame_t *frame) { static Dwfl *handle = NULL; static Dwfl_Module *home = NULL; if (handle == NULL) { static Dwfl_Callbacks callbacks = { .find_elf = dwfl_linux_proc_find_elf, .find_debuginfo = dwfl_standard_find_debuginfo, .debuginfo_path = NULL }; if ((handle = dwfl_begin(&callbacks)) == NULL) fatal("failed to initialise dwfl"); dwfl_report_begin(handle); if (dwfl_linux_proc_report(handle, getpid()) < 0) fatal("dwfl_linux_proc_report failed"); dwfl_report_end(handle, NULL, NULL); home = dwfl_addrmodule(handle, (uintptr_t)platform_fill_frame); } Dwfl_Module *mod = dwfl_addrmodule(handle, ip); frame->kind = (mod == home) ? FRAME_PROG : FRAME_LIB; frame->pc = ip; const char *module_name = dwfl_module_info(mod, 0, 0, 0, 0, 0, 0, 0); const char *sym_name = dwfl_module_addrname(mod, ip); Dwarf_Addr mod_bias = 0; Dwarf_Die *cudie = dwfl_module_addrdie(mod, ip, &mod_bias); if (cudie == NULL) { // Clang does not emit aranges so search each CU cudie = dwfl_module_nextcu(mod, NULL, &mod_bias); } Dwarf_Die *fundie = NULL, *module = NULL, child, child1; do { if (dwarf_child(cudie, &child) != 0) continue; Dwarf_Die *iter = &child; do { switch (dwarf_tag(iter)) { case DW_TAG_inlined_subroutine: case DW_TAG_subprogram: if (dwarf_haspc(iter, ip - mod_bias)) { fundie = iter; goto found_die_with_ip; } break; case DW_TAG_module: if (dwarf_child(&child, &child1) == 0) { Dwarf_Die *iter1 = &child1; do { switch (dwarf_tag(iter1)) { case DW_TAG_inlined_subroutine: case DW_TAG_subprogram: if (dwarf_haspc(iter1, ip - mod_bias)) { module = iter; fundie = iter1; goto found_die_with_ip; } } } while (dwarf_siblingof(iter1, iter1) == 0); } break; } } while (dwarf_siblingof(iter, iter) == 0); } while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias))); found_die_with_ip: if (cudie != NULL) { Dwarf_Line *srcloc = dwarf_getsrc_die(cudie, ip - mod_bias); const char *srcfile = dwarf_linesrc(srcloc, 0, 0); dwarf_lineno(srcloc, (int *)&(frame->lineno)); dwarf_linecol(srcloc, (int *)&(frame->colno)); if (module != NULL) { // VHDL compilation units are wrapped in a DWARF module which // gives the unit name frame->kind = FRAME_VHDL; frame->vhdl_unit = ident_new(dwarf_diename(module)); } if (srcfile != NULL) frame->srcfile = xstrdup(srcfile); if (fundie != NULL) libdw_fill_inlining(ip - mod_bias, fundie, frame); } if (sym_name != NULL) frame->symbol = xstrdup(sym_name); if (module_name != NULL) frame->module = xstrdup(module_name); } //////////////////////////////////////////////////////////////////////////////// // Libdwarf backend #elif defined HAVE_LIBDWARF typedef struct { Dwarf_Debug debug; Dwarf_Arange *aranges; Dwarf_Signed arange_count; } libdwarf_handle_t; static bool libdwarf_die_has_pc(libdwarf_handle_t *handle, Dwarf_Die die, Dwarf_Addr pc) { Dwarf_Addr low_pc = 0, high_pc = 0; if (dwarf_lowpc(die, &low_pc, NULL) == DW_DLV_OK) { Dwarf_Half form; enum Dwarf_Form_Class class; if (dwarf_highpc_b(die, &high_pc, &form, &class, NULL) == DW_DLV_OK) { if (class == DW_FORM_CLASS_CONSTANT) high_pc += low_pc; // DWARF4 return pc >= low_pc && pc < high_pc; } } Dwarf_Attribute attr; if (dwarf_attr(die, DW_AT_ranges, &attr, NULL) != DW_DLV_OK) return false; Dwarf_Off offset; if (dwarf_global_formref(attr, &offset, NULL) != DW_DLV_OK) return false; Dwarf_Ranges *ranges; Dwarf_Signed ranges_count = 0; Dwarf_Unsigned byte_count = 0; bool result = false; if (dwarf_get_ranges_b(handle->debug, offset, die, NULL, &ranges, &ranges_count, &byte_count, NULL) == DW_DLV_OK) { for (int i = 0; i < ranges_count; i++) { if (ranges[i].dwr_addr1 != 0 && pc >= ranges[i].dwr_addr1 + low_pc && pc < ranges[i].dwr_addr2 + low_pc) { result = true; break; } } dwarf_dealloc_ranges(handle->debug, ranges, ranges_count); } return result; } #ifdef __APPLE__ static void get_macho_uuid(const char *fname, uint8_t uuid[16]) { memset(uuid, '\0', 16); FILE *f = fopen(fname, "r"); if (f == NULL && errno == ENOENT) return; else if (f == NULL) { warnf("open: %s", fname); return; } struct mach_header_64 fhdr; if (fread(&fhdr, sizeof(fhdr), 1, f) != 1) fatal_errno("error reading %s", fname); if (fhdr.magic != MH_MAGIC_64) { warnf("bad Mach-O magic %x", fhdr.magic); goto out_close; } void *cmdbuf = xmalloc(fhdr.sizeofcmds); if (fread(cmdbuf, fhdr.sizeofcmds, 1, f) != 1) fatal_errno("error reading %s", fname); void *rptr = cmdbuf; for (int i = 0; i < fhdr.ncmds; i++) { const struct load_command *load = rptr; if (load->cmd == LC_UUID) { memcpy(uuid, ((struct uuid_command *)rptr)->uuid, 16); goto out_free; } rptr += load->cmdsize; } assert(rptr == cmdbuf + fhdr.sizeofcmds); warnf("could not read UUID from %s", fname); memset(uuid, '\0', 16); out_free: free(cmdbuf); out_close: fclose(f); } #endif static libdwarf_handle_t *libdwarf_handle_for_file(const char *fname) { static shash_t *hash = NULL; if (hash == NULL) hash = shash_new(64); libdwarf_handle_t *handle = shash_get(hash, fname); if (handle == (void *)-1) return NULL; else if (handle == NULL) { Dwarf_Debug debug = NULL; Dwarf_Error err = NULL; char true_path[PATH_MAX] = ""; int ret = dwarf_init_path(fname, true_path, sizeof(true_path), DW_GROUPNUMBER_ANY, NULL, NULL, &debug, &err); #ifdef __APPLE__ if (strcmp(fname, true_path) != 0) { uint8_t exe_uuid[16], dsym_uuid[16]; get_macho_uuid(fname, exe_uuid); get_macho_uuid(true_path, dsym_uuid); if (memcmp(exe_uuid, dsym_uuid, 16) != 0) { warnf("UUID of %s does not match %s", fname, true_path); shash_put(hash, fname, (void *)-1); return NULL; } } #endif if (ret == DW_DLV_ERROR) { warnf("dwarf_init: %s: %s", fname, dwarf_errmsg(err)); dwarf_dealloc_error(debug, err); shash_put(hash, fname, (void *)-1); return NULL; } else if (ret == DW_DLV_NO_ENTRY) { shash_put(hash, fname, (void *)-1); return NULL; } handle = xcalloc(sizeof(libdwarf_handle_t)); handle->debug = debug; shash_put(hash, fname, handle); } return handle; } static void libdwarf_get_symbol(libdwarf_handle_t *handle, Dwarf_Die die, Dwarf_Unsigned rel_addr, debug_frame_t *frame) { Dwarf_Die child, prev = NULL; if (dwarf_child(die, &child, NULL) != DW_DLV_OK) return; do { if (prev != NULL) dwarf_dealloc(handle->debug, prev, DW_DLA_DIE); prev = child; Dwarf_Half tag; if (dwarf_tag(child, &tag, NULL) != DW_DLV_OK) continue; else if (tag == DW_TAG_module) { libdwarf_get_symbol(handle, child, rel_addr, frame); if (frame->symbol == NULL) continue; char *name; if (dwarf_diename(child, &name, NULL) == DW_DLV_OK) { frame->vhdl_unit = ident_new(name); frame->kind = FRAME_VHDL; dwarf_dealloc(handle->debug, name, DW_DLA_STRING); break; } continue; } else if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine) continue; else if (!libdwarf_die_has_pc(handle, child, rel_addr)) continue; char *name; if (dwarf_diename(child, &name, NULL) == DW_DLV_OK) { frame->symbol = xstrdup(name); dwarf_dealloc(handle->debug, name, DW_DLA_STRING); } break; } while (dwarf_siblingof_b(handle->debug, child, true, &child, NULL) == DW_DLV_OK); if (prev != NULL) dwarf_dealloc(handle->debug, prev, DW_DLA_DIE); } static void libdwarf_get_srcline(libdwarf_handle_t *handle, Dwarf_Die die, Dwarf_Unsigned rel_addr, debug_frame_t *frame) { Dwarf_Small tablecount; Dwarf_Line_Context linecontext; Dwarf_Signed idx = 0; if (dwarf_srclines_b(die, NULL, &tablecount, &linecontext, NULL) == DW_DLV_OK) { Dwarf_Line* linebuf = NULL; Dwarf_Signed linecount = 0; if (dwarf_srclines_from_linecontext(linecontext, &linebuf, &linecount, NULL) == DW_DLV_OK) { Dwarf_Unsigned pladdr = 0; for (Dwarf_Signed i = 0; i < linecount; i++) { Dwarf_Unsigned laddr; if (dwarf_lineaddr(linebuf[i], &laddr, NULL) != DW_DLV_OK) break; else if (rel_addr == laddr) { idx = i; break; } else if (rel_addr < laddr && rel_addr > pladdr) { idx = i - 1; break; } pladdr = laddr; } if (idx >= 0) { Dwarf_Unsigned lineno; if (dwarf_lineno(linebuf[idx], &lineno, NULL) == DW_DLV_OK) frame->lineno = lineno; char *srcfile; if (dwarf_linesrc(linebuf[idx], &srcfile, NULL) == DW_DLV_OK) { frame->srcfile = xstrdup(srcfile); dwarf_dealloc(handle->debug, srcfile, DW_DLA_STRING); } } dwarf_srclines_dealloc_b(linecontext); } } } static bool libdwarf_scan_aranges(libdwarf_handle_t *handle, Dwarf_Unsigned rel_addr, debug_frame_t *frame) { Dwarf_Off cu_header_offset = 0; bool found = false; if (handle->aranges == NULL) { if (dwarf_get_aranges(handle->debug, &(handle->aranges), &(handle->arange_count), NULL) != DW_DLV_OK) return false; } Dwarf_Arange arange; if (dwarf_get_arange(handle->aranges, handle->arange_count, rel_addr, &arange, NULL) != DW_DLV_OK) return false; if (dwarf_get_cu_die_offset(arange, &cu_header_offset, NULL) != DW_DLV_OK) return false; Dwarf_Die die = NULL; if (dwarf_offdie_b(handle->debug, cu_header_offset, true, &die, NULL) != DW_DLV_OK) return false; Dwarf_Half tag = 0; if (dwarf_tag(die, &tag, NULL) != DW_DLV_OK) goto free_die; else if (tag != DW_TAG_compile_unit) goto free_die; if (libdwarf_die_has_pc(handle, die, rel_addr)) { libdwarf_get_srcline(handle, die, rel_addr, frame); libdwarf_get_symbol(handle, die, rel_addr, frame); found = true; } free_die: dwarf_dealloc(handle->debug, die, DW_DLA_DIE); return found; } static bool libdwarf_scan_cus(libdwarf_handle_t *handle, Dwarf_Unsigned rel_addr, debug_frame_t *frame) { Dwarf_Unsigned next_cu_offset; bool found = false; while (dwarf_next_cu_header_d(handle->debug, true, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &next_cu_offset, NULL, NULL) == DW_DLV_OK) { if (found) continue; // Read all the way to the end to reset the iterator Dwarf_Die die = NULL; if (dwarf_siblingof_b(handle->debug, 0, true, &die, NULL) != DW_DLV_OK) continue; Dwarf_Half tag = 0; if (dwarf_tag(die, &tag, NULL) != DW_DLV_OK) goto free_die; else if (tag != DW_TAG_compile_unit) goto free_die; if (libdwarf_die_has_pc(handle, die, rel_addr)) { libdwarf_get_srcline(handle, die, rel_addr, frame); libdwarf_get_symbol(handle, die, rel_addr, frame); found = true; } free_die: dwarf_dealloc(handle->debug, die, DW_DLA_DIE); die = NULL; } return found; } static void platform_fill_frame(uintptr_t ip, debug_frame_t *frame) { #if defined __MINGW32__ HANDLE hProcess = GetCurrentProcess(); frame->kind = FRAME_PROG; static DWORD64 home_fbase = 0; INIT_ONCE({ IMAGEHLP_MODULE module = { .SizeOfStruct = sizeof(module) }; if (SymGetModuleInfo(hProcess, ip, &module)) home_fbase = module.BaseOfImage; }); char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)]; PSYMBOL_INFO psym = (PSYMBOL_INFO)buffer; memset(buffer, '\0', sizeof(SYMBOL_INFO)); psym->SizeOfStruct = sizeof(SYMBOL_INFO); psym->MaxNameLen = MAX_SYM_NAME; const char *fallback_symbol = NULL; DWORD64 disp; if (SymFromAddr(hProcess, ip, &disp, psym)) { frame->disp = disp; fallback_symbol = psym->Name; } IMAGEHLP_MODULE module = { .SizeOfStruct = sizeof(module) }; if (!SymGetModuleInfo(hProcess, ip, &module)) return; if (module.BaseOfImage != home_fbase) frame->kind = FRAME_LIB; frame->module = xstrdup(module.ImageName); Dwarf_Addr rel_addr = ip - module.BaseOfImage; #else Dl_info dli; if (!dladdr((void *)ip, &dli)) return; static void *home_fbase = NULL; if (home_fbase == NULL) { Dl_info dli_home; extern int main(int, char **); if (dladdr(main, &dli_home)) home_fbase = dli_home.dli_fbase; } frame->kind = dli.dli_fbase == home_fbase ? FRAME_PROG : FRAME_LIB; frame->module = xstrdup(dli.dli_fname); frame->disp = ip - (uintptr_t)dli.dli_saddr; const char *fallback_symbol = dli.dli_sname; #if defined __FreeBSD__ Dwarf_Addr rel_addr; if (frame->kind == FRAME_PROG) rel_addr = ip; else rel_addr = ip - (uintptr_t)dli.dli_fbase; #elif defined __APPLE__ Dwarf_Addr rel_addr = ip - (uintptr_t)dli.dli_fbase + 0x100000000; #else Dwarf_Addr rel_addr = ip - (uintptr_t)dli.dli_fbase; #endif #endif libdwarf_handle_t *handle = libdwarf_handle_for_file(frame->module); if (handle != NULL) { if (!libdwarf_scan_aranges(handle, rel_addr, frame)) { // Clang does emit aranges so we have to search each compilation unit libdwarf_scan_cus(handle, rel_addr, frame); } } if (frame->symbol == NULL && fallback_symbol != NULL) { // Fallback: just use the nearest global symbol frame->symbol = xstrdup(fallback_symbol); } } //////////////////////////////////////////////////////////////////////////////// // Windows backend #elif defined __MINGW32__ || defined __CYGWIN__ static void platform_fill_frame(uintptr_t ip, debug_frame_t *frame) { HANDLE hProcess = GetCurrentProcess(); frame->kind = FRAME_PROG; static DWORD64 home_fbase = 0; INIT_ONCE({ IMAGEHLP_MODULE module = { .SizeOfStruct = sizeof(module) }; if (SymGetModuleInfo(hProcess, ip, &module)) home_fbase = module.BaseOfImage; }); char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)]; PSYMBOL_INFO psym = (PSYMBOL_INFO)buffer; memset(buffer, '\0', sizeof(SYMBOL_INFO)); psym->SizeOfStruct = sizeof(SYMBOL_INFO); psym->MaxNameLen = MAX_SYM_NAME; DWORD64 disp; if (SymFromAddr(hProcess, ip, &disp, psym)) { frame->disp = disp; frame->symbol = xstrdup(psym->Name); } IMAGEHLP_MODULE module = { .SizeOfStruct = sizeof(module) }; if (SymGetModuleInfo(hProcess, ip, &module)) { frame->module = xstrdup(module.ModuleName); if (module.BaseOfImage != home_fbase) frame->kind = FRAME_LIB; } } //////////////////////////////////////////////////////////////////////////////// // Generic Unix fallback #else static void platform_fill_frame(uintptr_t ip, debug_frame_t *frame) { Dl_info dli; if (!dladdr((void *)ip, &dli)) return; static void *home_fbase = NULL; if (home_fbase == NULL) { Dl_info dli_home; extern int main(int, char **); if (dladdr(main, &dli_home)) home_fbase = dli_home.dli_fbase; } frame->kind = dli.dli_fbase == home_fbase ? FRAME_PROG : FRAME_LIB; frame->module = xstrdup(dli.dli_fname); frame->disp = ip - (uintptr_t)dli.dli_saddr; if (dli.dli_sname) frame->symbol = xstrdup(dli.dli_sname); } #endif static _Unwind_Reason_Code unwind_frame_iter(struct _Unwind_Context* ctx, void *param) { debug_info_t *di = param; if (di->skip > 0) { di->skip--; return _URC_NO_REASON; } int ip_before_instruction = 0; uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction); if (ip == 0) return _URC_NO_REASON; else if (!ip_before_instruction) ip -= 1; debug_frame_t *frame; if (!di_lru_get(ip, &frame) && !custom_fill_frame(ip, frame)) platform_fill_frame(ip, frame); APUSH(di->frames, frame); if (frame->symbol != NULL && strcmp(frame->symbol, "main") == 0) return _URC_NORMAL_STOP; else return _URC_NO_REASON; } //////////////////////////////////////////////////////////////////////////////// // Public interface __attribute__((noinline)) debug_info_t *debug_capture(void) { #ifdef __MINGW32__ INIT_ONCE(SymInitialize(GetCurrentProcess(), NULL, TRUE)); #endif debug_info_t *di = xcalloc(sizeof(debug_info_t)); static __thread bool in_progress = false; if (in_progress) return di; // Guard against re-entrancy in_progress = true; // The various DWARF libraries do not seem to be thread-safe static nvc_lock_t lock; SCOPED_LOCK(lock); di->skip = 1; _Unwind_Backtrace(unwind_frame_iter, di); in_progress = false; return di; } void debug_free(debug_info_t *di) { ACLEAR(di->frames); free(di); } unsigned debug_count_frames(debug_info_t *di) { return di->frames.count; } const debug_frame_t *debug_get_frame(debug_info_t *di, unsigned n) { return AGET(di->frames, n); } void debug_add_unwinder(void *start, size_t len, debug_unwind_fn_t fn, void *context) { debug_unwinder_t *uw = xmalloc(sizeof(debug_unwinder_t)); uw->next = unwinders; uw->fn = fn; uw->context = context; uw->start = (uintptr_t)start; uw->end = (uintptr_t)start + len; unwinders = uw; } void debug_remove_unwinder(void *start) { for (debug_unwinder_t **p = &unwinders; *p; p = &((*p)->next)) { if ((*p)->start == (uintptr_t)start) { debug_unwinder_t *tmp = *p; *p = (*p)->next; free(tmp); return; } } fatal_trace("no unwinder registered for %p", start); } const char *debug_symbol_name(void *addr) { debug_frame_t *frame; if (!di_lru_get((uintptr_t)addr, &frame)) platform_fill_frame((uintptr_t)addr, frame); return frame->symbol; } nvc-r1.17.1/src/debug.h000066400000000000000000000037111504111170000145670ustar00rootroot00000000000000// // Copyright (C) 2021-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _DEBUG_H #define _DEBUG_H #include "util.h" #include "ident.h" #include typedef struct debug_info debug_info_t; typedef struct debug_inline debug_inline_t; typedef struct debug_src debug_src_t; typedef enum { FRAME_PROG, FRAME_LIB, FRAME_VHDL } frame_kind_t; typedef struct debug_inline { const char *symbol; const char *srcfile; ident_t vhdl_unit; unsigned lineno; unsigned colno; debug_inline_t *next; } debug_inline_t; typedef struct { frame_kind_t kind; uintptr_t pc; const char *symbol; const char *srcfile; const char *module; ident_t vhdl_unit; unsigned lineno; unsigned colno; ptrdiff_t disp; debug_inline_t *inlined; } debug_frame_t; typedef void (*debug_unwind_fn_t)(uintptr_t, debug_frame_t *, void *); debug_info_t *debug_capture(void); void debug_free(debug_info_t *di); unsigned debug_count_frames(debug_info_t *di); const debug_frame_t *debug_get_frame(debug_info_t *di, unsigned n); void debug_add_unwinder(void *start, size_t len, debug_unwind_fn_t fn, void *context); void debug_remove_unwinder(void *start); const char *debug_symbol_name(void *addr); #endif // _DEBUG_H nvc-r1.17.1/src/diag.c000066400000000000000000000774121504111170000144110ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "diag.h" #include "fbuf.h" #include "option.h" #include "thread.h" #include #include #include #include #include #include #include #include #define LOC_MAGIC 0xf00f typedef struct _hint_rec hint_rec_t; typedef struct { file_ref_t ref; char *name_str; char *abs_str; const char *linebuf; bool tried_open; unsigned last_line; const char *last_ptr; } loc_file_t; typedef A(loc_file_t) file_list_t; struct loc_wr_ctx { fbuf_t *fbuf; unsigned first_line; unsigned first_column; unsigned line_delta; unsigned column_delta; bool have_index; }; struct loc_rd_ctx { fbuf_t *fbuf; char **file_map; file_ref_t *ref_map; size_t n_files; unsigned first_line; unsigned first_column; unsigned line_delta; unsigned column_delta; bool have_index; }; typedef enum { HINT_NOTE, HINT_HELP } hint_kind_t; typedef struct { loc_t loc; char *text; int priority; hint_kind_t kind; } diag_hint_t; typedef A(diag_hint_t) hint_list_t; struct _diag { text_buf_t *msg; diag_level_t level; hint_list_t hints; hint_list_t trace; bool color; bool source; bool suppress; bool prefix; }; typedef struct _hint_rec { diag_hint_fn_t fn; void *context; } hint_rec_t; static unsigned n_diags[DIAG_FATAL + 1]; static unsigned error_limit = 0; static file_list_t loc_files; static nvc_lock_t diag_lock = 0; static __thread diag_consumer_t consumer_fn = NULL; static __thread void *consumer_ctx = NULL; #define MAX_HINT_RECS 4 static __thread hint_rec_t hint_recs[MAX_HINT_RECS]; #define DIAG_THEME_CLASSIC 1 #define DIAG_THEME_RUST 2 #define DIAG_THEME DIAG_THEME_CLASSIC //////////////////////////////////////////////////////////////////////////////// // File management static loc_file_t *loc_file_data(const loc_t *loc) { return AREF(loc_files, loc->file_ref); } file_ref_t loc_file_ref(const char *name, const char *linebuf) { if (name == NULL) return FILE_INVALID; for (unsigned i = 0; i < loc_files.count; i++) { if (strcmp(loc_files.items[i].name_str, name) == 0) return loc_files.items[i].ref; } // Strip any consecutive '/' characters char *name_buf = xstrdup(name), *p = name_buf; for (char *s = name_buf; *s != '\0'; s++) { if (*s != '/' || *(s + 1) != '/') *p++ = *s; } *p = '\0'; loc_file_t new = { .linebuf = linebuf, .name_str = name_buf, .ref = loc_files.count }; APUSH(loc_files, new); return new.ref; } const char *loc_file_str(const loc_t *loc) { if (loc->file_ref != FILE_INVALID) return loc_file_data(loc)->name_str; else return NULL; } static const char *loc_abs_path(const loc_t *loc) { if (loc->file_ref == FILE_INVALID) return NULL; loc_file_t *data = loc_file_data(loc); if (data->abs_str != NULL) return data->abs_str; if ((data->abs_str = realpath(data->name_str, NULL)) == NULL) { // Avoid repeated calls to realpath in failing case data->abs_str = data->name_str; } return data->abs_str; } //////////////////////////////////////////////////////////////////////////////// // Source location tracking bool loc_invalid_p(const loc_t *loc) { return loc == NULL || loc->first_line == LINE_INVALID || loc->file_ref == FILE_INVALID; } loc_t get_loc(unsigned first_line, unsigned first_column, unsigned last_line, unsigned last_column, file_ref_t file_ref) { if (first_line > last_line) return LOC_INVALID; else if (first_line == last_line && first_column > last_column) return LOC_INVALID; loc_t result = { .first_line = MIN(first_line, LINE_INVALID), .first_column = MIN(first_column, COLUMN_INVALID), .line_delta = MIN(last_line - first_line, DELTA_INVALID), .column_delta = MIN(last_column - first_column, DELTA_INVALID), .file_ref = file_ref }; return result; } const char *loc_get_source(const loc_t *loc) { if (loc->file_ref == FILE_INVALID || loc->first_line == LINE_INVALID || loc->first_column == COLUMN_INVALID) return NULL; loc_file_t *file = loc_file_data(loc); if (file->linebuf == NULL && !file->tried_open) { file->tried_open = true; int fd = open(file->name_str, O_RDONLY); if (fd < 0) return NULL; file_info_t info; if (!get_handle_info(fd, &info)) goto close_file; if (info.type != FILE_REGULAR) goto close_file; if (info.size > 0) file->linebuf = map_file(fd, info.size); close_file: close(fd); } if (file->linebuf == NULL) return NULL; unsigned line = 1; const char *ptr = file->linebuf; if (file->last_line > 0 && loc->first_line >= file->last_line) { line = file->last_line; ptr = file->last_ptr; } for (; line < loc->first_line; line++) { if ((ptr = strchr(ptr, '\n'))) ptr++; else return NULL; } file->last_line = loc->first_line; file->last_ptr = ptr; return ptr; } bool loc_eq(const loc_t *a, const loc_t *b) { return a->first_line == b->first_line && a->first_column == b->first_column && a->line_delta == b->line_delta && a->column_delta == b->column_delta && a->file_ref == b->file_ref; } loc_wr_ctx_t *loc_write_begin(fbuf_t *f) { loc_wr_ctx_t *ctx = xcalloc(sizeof(loc_wr_ctx_t)); ctx->fbuf = f; ctx->have_index = false; return ctx; } void loc_write_end(loc_wr_ctx_t *ctx) { free(ctx); } void loc_write(const loc_t *loc, loc_wr_ctx_t *ctx) { if (!ctx->have_index) { write_u16(LOC_MAGIC, ctx->fbuf); fbuf_put_uint(ctx->fbuf, loc_files.count); for (unsigned i = 0; i < loc_files.count; i++) { size_t len = strlen(loc_files.items[i].name_str) + 1; fbuf_put_uint(ctx->fbuf, len); write_raw(loc_files.items[i].name_str, len, ctx->fbuf); } ctx->have_index = true; } fbuf_put_uint(ctx->fbuf, loc->file_ref); fbuf_put_int(ctx->fbuf, loc->first_line - ctx->first_line); fbuf_put_int(ctx->fbuf, loc->line_delta - ctx->line_delta); fbuf_put_int(ctx->fbuf, loc->first_column - ctx->first_column); fbuf_put_int(ctx->fbuf, loc->column_delta - ctx->column_delta); ctx->first_line = loc->first_line; ctx->first_column = loc->first_column; ctx->line_delta = loc->line_delta; ctx->column_delta = loc->column_delta; } loc_rd_ctx_t *loc_read_begin(fbuf_t *f) { loc_rd_ctx_t *ctx = xcalloc(sizeof(loc_rd_ctx_t)); ctx->fbuf = f; return ctx; } void loc_read_end(loc_rd_ctx_t *ctx) { for (size_t i = 0; i < ctx->n_files; i++) free(ctx->file_map[i]); free(ctx->file_map); free(ctx->ref_map); free(ctx); } void loc_read(loc_t *loc, loc_rd_ctx_t *ctx) { if (!ctx->have_index) { uint16_t magic = read_u16(ctx->fbuf); if (magic != LOC_MAGIC) fatal("corrupt location header in %s", fbuf_file_name(ctx->fbuf)); ctx->n_files = fbuf_get_uint(ctx->fbuf); ctx->file_map = xcalloc_array(ctx->n_files, sizeof(ident_t)); ctx->ref_map = xcalloc_array(ctx->n_files, sizeof(file_ref_t)); for (size_t i = 0; i < ctx->n_files; i++) { size_t len = fbuf_get_uint(ctx->fbuf); char *buf = xmalloc(len + 1); read_raw(buf, len, ctx->fbuf); buf[len] = '\0'; ctx->file_map[i] = buf; ctx->ref_map[i] = FILE_INVALID; } ctx->have_index = true; } uint16_t old_ref = fbuf_get_uint(ctx->fbuf); file_ref_t new_ref = FILE_INVALID; if (old_ref != FILE_INVALID) { if (unlikely(old_ref >= ctx->n_files)) fatal("corrupt location file reference %x", old_ref); if (ctx->ref_map[old_ref] == FILE_INVALID) { for (unsigned i = 0; i < loc_files.count; i++) { if (strcmp(loc_files.items[i].name_str, ctx->file_map[old_ref]) == 0) ctx->ref_map[old_ref] = loc_files.items[i].ref; } } if (ctx->ref_map[old_ref] == FILE_INVALID) { loc_file_t new = { .linebuf = NULL, .name_str = ctx->file_map[old_ref], .ref = loc_files.count }; APUSH(loc_files, new); ctx->ref_map[old_ref] = new.ref; ctx->file_map[old_ref] = NULL; // Owned by loc_file_t now } new_ref = ctx->ref_map[old_ref]; } ctx->first_line += fbuf_get_int(ctx->fbuf); ctx->line_delta += fbuf_get_int(ctx->fbuf); ctx->first_column += fbuf_get_int(ctx->fbuf); ctx->column_delta += fbuf_get_int(ctx->fbuf); loc->first_line = MIN(ctx->first_line, LINE_INVALID); loc->first_column = MIN(ctx->first_column, COLUMN_INVALID); loc->line_delta = MIN(ctx->line_delta, DELTA_INVALID); loc->column_delta = MIN(ctx->column_delta, DELTA_INVALID); loc->file_ref = new_ref; } //////////////////////////////////////////////////////////////////////////////// // Fancy diagnostics #if DIAG_THEME == DIAG_THEME_CLASSIC #define DEBUG_PREFIX "** Debug: " #define NOTE_PREFIX "** Note: " #define WARNING_PREFIX "$yellow$** Warning:$$ " #define ERROR_PREFIX "$red$** Error:$$ " #define FAILURE_PREFIX "$red$** Failure:$$ " #define FATAL_PREFIX "$red$** Fatal:$$ " #define GUTTER_STYLE "$blue$" #define HINT_STYLE "" #define CARET_STYLE "" #define TRACE_STYLE "" #define TRAILING_BLANK 0 #elif DIAG_THEME == DIAG_THEME_RUST #define DEBUG_PREFIX "$!green$Debug:$$ " #define NOTE_PREFIX "$bold$Note:$$ " #define WARNING_PREFIX "$!yellow$Warning:$$ " #define ERROR_PREFIX "$!red$Error:$$ " #define FAILURE_PREFIX "$!red$Failure:$$ " #define FATAL_PREFIX "$!red$Fatal:$$ " #define GUTTER_STYLE "$!blue$" #define HINT_STYLE "$bold$" #define CARET_STYLE "$bold$" #define TRACE_STYLE "$bold$" #define TRAILING_BLANK 1 #else #error "invalid DIAG_THEME" #endif static const struct { const char *title; const char *section[STD_19 + 1]; } lrm_sections[] = { { "Names", { [STD_08] = "8.1", [STD_93] = "6.1", [STD_19] = "8.1" } }, { "Signal parameters", { [STD_08] = "4.2.2.3", [STD_93] = "2.1.1.2" } }, { "Constant and variable parameters", { [STD_93] = "2.1.1.1", [STD_08] = "4.2.2.2" } }, { "Object aliases", { [STD_93] = "4.3.3.1", [STD_08] = "6.6.2" } }, { "Case statement", { [STD_93] = "8.8", [STD_08] = "10.9" } }, { "Elaboration of a declarative part", { [STD_93] = "12.3", [STD_08] = "14.4" } }, { "Process statement", { [STD_93] = "9.2", [STD_08] = "11.3" } }, { "Entity statement part", { [STD_93] = "1.1.3", [STD_08] = "3.2.4" } }, { "Qualified expressions", { [STD_08] = "9.3.5" } }, { "Interface package declarations", { [STD_08] = "6.5.5" } }, { "Selected names", { [STD_08] = "8.3", [STD_93] = "6.3" } }, { "Simple variable assignments", { [STD_08] = "10.6.2" } }, { "Configuration declarations", { [STD_08] = "3.4", [STD_93] = "1.4" } }, { "Formal parameter lists", { [STD_19] = "4.2.2.1", [STD_08] = "4.2.2.1", [STD_93] = "2.1.1" } }, { "Protected type declarations", { [STD_08] = "5.6.2", [STD_02] = "3.5.1" } }, { "Type conversions", { [STD_93] = "7.3.5", [STD_08] = "9.3.6" } }, { "External names", { [STD_08] = "8.7" } }, { "Port clauses", { [STD_08] = "6.5.6.3" } }, { "Subprogram instantiation declarations", { [STD_08] = "4.4" } }, { "Incomplete type declarations", { [STD_08] = "5.4.2", [STD_93] = "3.3.1", [STD_19] = "5.4.2" } }, { "String literals", { [STD_93] = "13.6", [STD_08] = "15.7" } }, { "Simple signal assignments", { [STD_93] = "8.4", [STD_08] = "10.5.2" } }, { "Basic identifiers", { [STD_93] = "13.3.1", [STD_08] = "15.4.2" } }, { "Concurrent signal assignment statements", { [STD_93] = "9.5", [STD_08] = "11.6" } }, { "Elaboration of a declaration", { [STD_08] = "14.4.2", [STD_93] = "12.3.1" } }, { "Package bodies", { [STD_08] = "4.8", [STD_93] = "2.6" } }, { "Interface type declarations", { [STD_08] = "6.5.3", [STD_19] = "6.5.3" } }, { "Conformance rules", { [STD_08] = "4.10", [STD_93] = "2.7" } }, { "Executing a simple assignment statement", { [STD_08] = "10.5.2.2", [STD_93] = "8.4.1" } }, { "Subprogram bodies", { [STD_08] = "4.3", [STD_93] = "2.2" } }, { "Index contraints and discrete ranges", { [STD_93] = "3.2.1.1", [STD_08] = "5.3.2.2" } }, { "Aggregates", { [STD_08] = "9.3.3", [STD_93] = "7.3.2" } }, { "Interface object declarations", { [STD_08] = "6.5.2", [STD_93] = "4.3.2" } }, }; diag_t *diag_new(diag_level_t level, const loc_t *loc) { diag_t *d = xcalloc(sizeof(diag_t)); d->msg = tb_new(); d->level = level; d->color = color_terminal() && consumer_fn == NULL; d->source = loc != NULL && !loc_invalid_p(loc); d->suppress = false; d->prefix = true; if (!loc_invalid_p(loc)) { diag_hint_t hint = { .loc = *loc }; APUSH(d->hints, hint); } // Callback could create new diagnostics static __thread bool entered = false; if (!entered) { entered = true; for (int i = 0; i < MAX_HINT_RECS; i++) { if (hint_recs[i].fn != NULL) (*hint_recs[i].fn)(d, hint_recs[i].context); } entered = false; } return d; } void diag_clear(diag_t *d) { d->prefix = false; ACLEAR(d->hints); ACLEAR(d->trace); tb_rewind(d->msg); } void diag_vprintf(diag_t *d, const char *fmt, va_list ap) { if (strchr(fmt, '$') != 0) { char *buf LOCAL; if (d->color) buf = color_vasprintf(fmt, ap); else buf = strip_color(fmt, ap); tb_cat(d->msg, buf); } else tb_vprintf(d->msg, fmt, ap); } void diag_printf(diag_t *d, const char *fmt, ...) { va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); } void diag_write(diag_t *d, const char *str, size_t len) { tb_catn(d->msg, str, len); } text_buf_t *diag_text_buf(diag_t *d) { return d->msg; } void diag_vhint(diag_t *d, const loc_t *loc, const char *fmt, va_list ap) { char *text; if (strchr(fmt, '$') != 0) { if (d->color) text = color_vasprintf(fmt, ap); else text = strip_color(fmt, ap); } else text = xvasprintf(fmt, ap); if (!loc_invalid_p(loc)) { for (int i = 0; i < d->hints.count; i++) { diag_hint_t *hint = &(d->hints.items[i]); if (loc_eq(loc, &(hint->loc))) { free(hint->text); hint->text = text; return; } } d->source = true; } diag_hint_t h = { .loc = loc ? *loc : LOC_INVALID, .text = text, .priority = -(d->hints.count), .kind = HINT_NOTE, }; APUSH(d->hints, h); } void diag_hint(diag_t *d, const loc_t *loc, const char *fmt, ...) { va_list ap; va_start(ap, fmt); diag_vhint(d, loc, fmt, ap); va_end(ap); } void diag_trace(diag_t *d, const loc_t *loc, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *text; if (strchr(fmt, '$') != 0) { if (d->color) text = color_vasprintf(fmt, ap); else text = strip_color(fmt, ap); } else text = xvasprintf(fmt, ap); va_end(ap); diag_hint_t h = { .loc = loc ? *loc : LOC_INVALID, .text = text, .priority = d->hints.count, }; APUSH(d->trace, h); if (loc != NULL && d->hints.count == 0) { diag_hint_t hint = { .loc = *loc }; APUSH(d->hints, hint); } } void diag_lrm(diag_t *d, vhdl_standard_t std, const char *section) { const char *title = NULL; for (int i = 0; i < ARRAY_LEN(lrm_sections); i++) { const char *s = lrm_sections[i].section[std]; if (s != NULL && strcmp(s, section) == 0) { // Prefer the section number from the current standard const char *ss = lrm_sections[i].section[standard()]; if (ss != NULL) { std = standard(); section = ss; } title = lrm_sections[i].title; break; } } LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "IEEE Std 1076-%s section %s", standard_text(std), section); if (title != NULL) tb_printf(tb, " \"%s\"", title); diag_hint_t h = { .loc = LOC_INVALID, .text = tb_claim(tb), .priority = d->hints.count, .kind = HINT_HELP }; APUSH(d->hints, h); } static void diag_putc_utf8(unsigned char ch, FILE *f) { if (ch >= 128 && utf8_terminal()) { // Convert ISO-8859-1 internal encoding to UTF-8 fputc(0xc2 + (ch > 0xbf), f); fputc((ch & 0x3f) + 0x80, f); } else if ((ch < 0x20 || ch == 0x7f) && ch != '\r' && ch != '\n' && ch != '\t' && ch != '\e') { if (utf8_terminal()) { // On unicode terminals emit the corresponding control picture // code point otherwise silently drop it fputc(0xe2, f); fputc(0x90, f); if (ch == 0x7f) // DEL fputc(0xa1, f); else fputc(0x80 + ch, f); } } else fputc(ch, f); } static void diag_print_utf8(const char *str, size_t len, FILE *f) { const unsigned char *ustr = (const unsigned char *)str; bool have_non_utf8 = false; for (const unsigned char *p = ustr; p < ustr + len; p++) { if (have_non_utf8) diag_putc_utf8(*p, f); else if (*p == '\033') continue; // Do not replace ANSI escapes else if (*p >= 128 || *p < 0x20 || *p == 0x7f) { fwrite(str, 1, p - ustr, f); diag_putc_utf8(*p, f); have_non_utf8 = true; } } if (!have_non_utf8) fwrite(str, 1, len, f); } static void diag_wrap_lines(const char *str, size_t len, int left, FILE *f) { const int right = terminal_width(); if (right == 0 || left + len < right) { diag_print_utf8(str, len, f); return; } const char *p = str, *begin = str; for (int col = left, escape = 0; *p != '\0'; p++) { if (*p == '\033') escape = 1; else if (escape) { if (*p == 'm') escape = 0; } else if (col + 1 >= right && p - begin + 1 < right - left) { fprintf(f, "\n%*s", left, ""); col = left + p - begin; } else if (isspace_iso88591(*p)) { diag_print_utf8(begin, p - begin + 1, f); if (*p == '\n') { fprintf(f, "%*s", left, ""); col = left; } else col++; begin = p + 1; } else ++col; } if (begin < p) diag_print_utf8(begin, p - begin, f); } static int diag_compar(const void *_a, const void *_b) { const diag_hint_t *a = _a, *b = _b; assert(a->loc.file_ref == b->loc.file_ref); return a->loc.first_line - b->loc.first_line; } static void diag_emit_loc(const loc_t *loc, FILE *f) { const char *file = loc_file_str(loc); const char *abspath = loc_abs_path(loc); if (abspath != file) color_fprintf(f, "$link:file://%s#%u\07%s:%u$", abspath, loc->first_line, file, loc->first_line); else fprintf(f, "%s:%u", file, loc->first_line); } static void diag_emit_hints(diag_t *d, FILE *f) { int fwidth = 0; const char *linebuf = NULL; bool need_gap = false; loc_t loc0 = d->hints.items[0].loc; if (loc0.file_ref == FILE_INVALID) goto other_files; int same_file = 0, line_max = 0, line_min = INT_MAX; for (int i = 0; i < d->hints.count; i++) { if (d->hints.items[i].loc.file_ref == loc0.file_ref) { same_file++; const int first_line = d->hints.items[i].loc.first_line; line_max = MAX(first_line, line_max); line_min = MIN(first_line, line_min); } } // Move all diagnostics from the first file to the front of the list for (int i = 0; i < d->hints.count; i++) { if (d->hints.items[i].loc.file_ref != loc0.file_ref) { for (int j = i + 1; j < d->hints.count; j++) { if (d->hints.items[j].loc.file_ref == loc0.file_ref) { diag_hint_t tmp = d->hints.items[j]; d->hints.items[j] = d->hints.items[i]; d->hints.items[i] = tmp; break; } } } } qsort(d->hints.items, same_file, sizeof(diag_hint_t), diag_compar); if (d->source) linebuf = loc_get_source(&(d->hints.items[0].loc)); if (linebuf == NULL) fwidth = 3; else { for (int n = line_max; n > 0; n /= 10, fwidth++) ; } if (!d->source) goto other_files; color_fprintf(f, "%*s$blue$ > $$", fwidth, ""); diag_emit_loc(&loc0, f); if (linebuf == NULL) { color_fprintf(f, "\n"); d->source = false; // Cannot get original source code goto other_files; } color_fprintf(f, "\n%*s " GUTTER_STYLE " |$$\n", fwidth, ""); need_gap = true; const char *p = linebuf; for (int i = line_min, h = 0; h < d->hints.count; i++) { diag_hint_t *hint = &(d->hints.items[h]); while (hint->loc.file_ref != loc0.file_ref) { if (h + 1 == d->hints.count) goto other_files; else hint = &(d->hints.items[++h]); } if (hint->loc.first_line > i + 2) { // Skip some lines color_fprintf(f, " " GUTTER_STYLE "...$$\n"); for (; i < hint->loc.first_line; i++) { if ((p = strchr(p, '\n')) == NULL) return; p++; // Skip newline } } color_fprintf(f, " " GUTTER_STYLE "%*.u |$$ $cyan$", fwidth, i); int first_col = hint->loc.first_column; for (int col = 0, n = 0; *p != '\0' && *p != '\n'; p++, n++) { if (n == hint->loc.first_column) first_col = col; if (*p == '\r') continue; else if (*p == '\t') { do { fputc(' ', f); col++; } while (col % 8 != 0); } else if (isprint_iso88591(*p)) { diag_putc_utf8(*p, f); col++; } } color_fprintf(f, "$$\n"); p++; // Skip newline if (hint->loc.first_line == i) { color_fprintf(f, "%*s " GUTTER_STYLE " |$$ ", fwidth, ""); color_fprintf(f, CARET_STYLE "$green$"); color_fprintf(f, "%*s", first_col, ""); int ncarets = 1; if (hint->loc.line_delta == 0 && hint->loc.column_delta != DELTA_INVALID) ncarets = hint->loc.column_delta + 1; const int hintcol = fwidth + hint->loc.first_column + ncarets + 4; while (ncarets--) fputc('^', f); const char *text = hint->text; if (text == NULL && same_file > 1 && hint->priority == 0 && d->level >= DIAG_ERROR) text = "error occurred here"; if (text != NULL) { if (hintcol + strlen(text) >= MAX(terminal_width(), 80)) color_fprintf(f, "$$\n%*s " GUTTER_STYLE " |$$%*s", fwidth, "", hint->loc.first_column, ""); color_fprintf(f, "$$$green$ %s$$\n", text); } else color_fprintf(f, "$$\n"); // Only support one hint per line for (; h < d->hints.count && d->hints.items[h].loc.first_line == i; h++) ; } } other_files: for (int i = 0; i < d->hints.count; i++) { diag_hint_t *hint = &(d->hints.items[i]); if (hint->loc.file_ref == loc0.file_ref && d->source) continue; // Printed above else if (hint->text == NULL) continue; if (need_gap) { color_fprintf(f, "%*s " GUTTER_STYLE " |$$\n", fwidth, ""); need_gap = false; } int col = color_fprintf(f, "%*s", fwidth, ""); if (linebuf != NULL) col += color_fprintf(f, " " GUTTER_STYLE " = $$"); if (col == 0) col += color_fprintf(f, NOTE_PREFIX); else col += color_fprintf(f, HINT_STYLE "%s:$$ ", hint->kind == HINT_HELP ? "Help" : "Note"); diag_wrap_lines(hint->text, strlen(hint->text), col, f); fputc('\n', f); if (!loc_invalid_p(&(hint->loc))) { color_fprintf(f, "%*s $blue$>$$ ", fwidth, ""); diag_emit_loc(&(hint->loc), f); fputc('\n', f); } } } static void diag_emit_trace(diag_t *d, FILE *f) { // Do not show a stack trace if it just repeats the initial location if (d->trace.count == 1 && d->hints.count > 0 && d->source) { const loc_t hloc0 = d->hints.items[0].loc; const loc_t tloc0 = d->trace.items[0].loc; if (tloc0.file_ref == hloc0.file_ref || tloc0.first_line == hloc0.first_line) return; } #if TRAILING_BLANK fputc('\n', f); #endif const int fwidth UNUSED = 6; for (int i = 0; i < d->trace.count; i++) { diag_hint_t *hint = &(d->trace.items[i]); fprintf(f, " " TRACE_STYLE "%s", hint->text); if (!loc_invalid_p(&(hint->loc))) { color_fprintf(f, " at "); diag_emit_loc(&(hint->loc), f); } fputc('\n', f); } } static void diag_format_compact(diag_t *d, FILE *f) { if (d->hints.count > 0) { loc_t *loc = &(d->hints.items[0].loc); if (!loc_invalid_p(loc)) { loc_file_t *file_data = loc_file_data(loc); fprintf(f, "%s:%d:%d: ", file_data->name_str, loc->first_line, loc->first_column + 1); } } switch (d->level) { case DIAG_DEBUG: fprintf(f, "debug: "); break; case DIAG_NOTE: fprintf(f, "note: "); break; case DIAG_WARN: fprintf(f, "warning: "); break; case DIAG_ERROR: fprintf(f, "error: "); break; case DIAG_FAILURE: fprintf(f, "failure: "); break; case DIAG_FATAL: fprintf(f, "fatal: "); break; } diag_print_utf8(tb_get(d->msg), tb_len(d->msg), f); fputc('\n', f); } static inline bool diag_has_message(diag_t *d) { return tb_len(d->msg) > 0; } static void diag_format_full(diag_t *d, FILE *f) { if (diag_has_message(d)) { int col = 0; if (d->prefix) { switch (d->level) { case DIAG_DEBUG: col = color_fprintf(f, DEBUG_PREFIX); break; case DIAG_NOTE: col = color_fprintf(f, NOTE_PREFIX); break; case DIAG_WARN: col = color_fprintf(f, WARNING_PREFIX); break; case DIAG_ERROR: col = color_fprintf(f, ERROR_PREFIX); break; case DIAG_FAILURE: col = color_fprintf(f, FAILURE_PREFIX); break; case DIAG_FATAL: col = color_fprintf(f, FATAL_PREFIX); break; } } diag_wrap_lines(tb_get(d->msg), tb_len(d->msg), col, f); fputc('\n', f); } if (d->hints.count > 0) diag_emit_hints(d, f); if (d->trace.count > 0) diag_emit_trace(d, f); #if TRAILING_BLANK if (d->trace.count > 0 || d->hints.count > 0) fputc('\n', f); #endif fflush(f); } void diag_femit(diag_t *d, FILE *f) { if (d->suppress) goto cleanup; else if (consumer_fn != NULL && d->level > DIAG_DEBUG) (*consumer_fn)(d, consumer_ctx); else if (d->level == DIAG_DEBUG && opt_get_int(OPT_UNIT_TEST) && diag_has_message(d)) goto cleanup; else { // The stderr and stdout streams are often redirected to the same // file so ensure that the output appears in a logical order if (f == stdout) fflush(stderr); else if (f == stderr) fflush(stdout); SCOPED_LOCK(diag_lock); if (get_message_style() == MESSAGE_COMPACT) diag_format_compact(d, f); else diag_format_full(d, f); } const unsigned count = relaxed_add(&n_diags[d->level], 1); if (d->level == DIAG_ERROR && count == error_limit) fatal("too many errors, giving up"); cleanup: for (int i = 0; i < d->hints.count; i++) free(d->hints.items[i].text); ACLEAR(d->hints); for (int i = 0; i < d->trace.count; i++) free(d->trace.items[i].text); ACLEAR(d->trace); tb_free(d->msg); free(d); } void diag_emit(diag_t *d) { const diag_level_t stderr_level = opt_get_int(OPT_STDERR_LEVEL); diag_femit(d, d->level >= stderr_level ? stderr : stdout); } void diag_show_source(diag_t *d, bool show) { d->source = show; } void diag_suppress(diag_t *d, bool suppress) { d->suppress = suppress; } void diag_set_consumer(diag_consumer_t fn, void *context) { consumer_fn = fn; consumer_ctx = context; } const char *diag_get_text(diag_t *d) { return tb_get(d->msg); } const char *diag_get_hint(diag_t *d, int nth) { if (d->hints.items[0].text == NULL) nth++; assert(nth < d->hints.count); return d->hints.items[nth].text; } const char *diag_get_trace(diag_t *d, int nth) { assert(nth < d->trace.count); return d->trace.items[nth].text; } const loc_t *diag_get_loc(diag_t *d) { if (d->hints.count > 0) return &(d->hints.items[0].loc); else return NULL; } int diag_hints(diag_t *d) { if (d->hints.items && d->hints.items[0].text == NULL) return d->hints.count - 1; else return d->hints.count; } int diag_traces(diag_t *d) { return d->trace.count; } void diag_add_hint_fn(diag_hint_fn_t fn, void *context) { int idx = 0; for (; idx < MAX_HINT_RECS; idx++) { if (hint_recs[idx].fn == NULL) break; } if (idx == MAX_HINT_RECS) fatal_trace("too many active hint callbacks"); hint_recs[idx].fn = fn; hint_recs[idx].context = context; } void diag_remove_hint_fn(diag_hint_fn_t fn) { for (int i = 0; i < MAX_HINT_RECS; i++) { if (hint_recs[i].fn == fn) { hint_recs[i].fn = NULL; hint_recs[i].context = NULL; return; } } fatal_trace("hint function %p not registered", fn); } unsigned diag_count(diag_level_t level) { int sum = 0; for (int i = level; i <= DIAG_FATAL; i++) sum += relaxed_load(&n_diags[i]); return sum; } unsigned error_count(void) { return diag_count(DIAG_ERROR); } void reset_error_count(void) { for (int i = 0; i <= DIAG_FATAL; i++) relaxed_store(&n_diags[i], 0); } unsigned set_error_limit(unsigned limit) { const unsigned old = error_limit; error_limit = limit; return old; } void fmt_loc(FILE *f, const loc_t *loc) { // Legacy interface for debugging only diag_t *d = diag_new(DIAG_DEBUG, loc); diag_consumer_t old = consumer_fn; consumer_fn = NULL; diag_femit(d, f); consumer_fn = old; } void wrapped_vprintf(const char *fmt, va_list ap) { char *text LOCAL = NULL; if (strchr(fmt, '$') != 0) text = color_vasprintf(fmt, ap); else text = xvasprintf(fmt, ap); diag_wrap_lines(text, strlen(text), 0, stdout); } void wrapped_printf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); wrapped_vprintf(fmt, ap); va_end(ap); } diag_t *_pedantic_diag(const loc_t *loc, int *warned, bool *error) { const bool relaxed = opt_get_int(OPT_RELAXED); if (!relaxed || !*warned) { const diag_level_t level = relaxed ? DIAG_WARN : DIAG_ERROR; diag_t *d = diag_new(level, loc); if (level == DIAG_ERROR) diag_hint(d, NULL, "the $bold$--relaxed$$ option downgrades this " "to a warning"); *warned = 1; if (error) *error = !relaxed; return d; } else return NULL; } nvc-r1.17.1/src/diag.h000066400000000000000000000100501504111170000143770ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _DIAG_H #define _DIAG_H #include "prim.h" #include "util.h" #include "common.h" #include #include #include #ifdef __MINGW32__ #undef SEVERITY_ERROR #endif typedef uint16_t file_ref_t; struct loc { unsigned first_line : 20; unsigned first_column : 12; unsigned line_delta : 8; unsigned column_delta : 8; unsigned file_ref : 16; }; STATIC_ASSERT(sizeof(loc_t) == 8); #define LINE_INVALID 0xfffff #define COLUMN_INVALID 0xfff #define FILE_INVALID 0xffff #define DELTA_INVALID 0xff #define LOC_INVALID ((loc_t) { \ LINE_INVALID, COLUMN_INVALID, \ DELTA_INVALID, DELTA_INVALID, \ FILE_INVALID \ }) void fmt_loc(FILE *f, const loc_t *loc); const char *loc_file_str(const loc_t *loc); loc_t get_loc(unsigned first_line, unsigned first_column, unsigned last_line, unsigned last_column, file_ref_t file_ref); bool loc_invalid_p(const loc_t *loc); file_ref_t loc_file_ref(const char *name, const char *linebuf); bool loc_eq(const loc_t *a, const loc_t *b); const char *loc_get_source(const loc_t *loc); loc_wr_ctx_t *loc_write_begin(fbuf_t *f); void loc_write(const loc_t *loc, loc_wr_ctx_t *ctx); void loc_write_end(loc_wr_ctx_t *ctx); loc_rd_ctx_t *loc_read_begin(fbuf_t *f); void loc_read(loc_t *loc, loc_rd_ctx_t *ctx); void loc_read_end(loc_rd_ctx_t *ctx); typedef enum { DIAG_DEBUG, DIAG_NOTE, DIAG_WARN, DIAG_ERROR, DIAG_FAILURE, DIAG_FATAL, } diag_level_t; // Error callback for use in unit tests typedef void (*diag_consumer_t)(diag_t *, void *); void diag_set_consumer(diag_consumer_t fn, void *); typedef void (*diag_hint_fn_t)(diag_t *, void *); void diag_add_hint_fn(diag_hint_fn_t fn, void *context); void diag_remove_hint_fn(diag_hint_fn_t fn); diag_t *diag_new(diag_level_t level, const loc_t *loc); void diag_printf(diag_t *d, const char *fmt, ...) __attribute__((format(printf, 2, 3))); void diag_vprintf(diag_t *d, const char *fmt, va_list ap); void diag_write(diag_t *d, const char *str, size_t len); text_buf_t *diag_text_buf(diag_t *d); void diag_hint(diag_t *d, const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 3, 4))); void diag_vhint(diag_t *d, const loc_t *loc, const char *fmt, va_list ap); void diag_trace(diag_t *d, const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 3, 4))); void diag_lrm(diag_t *d, vhdl_standard_t std, const char *section); void diag_show_source(diag_t *d, bool show); void diag_emit(diag_t *d); void diag_femit(diag_t *d, FILE *f); void diag_suppress(diag_t *d, bool suppress); void diag_clear(diag_t *d); unsigned diag_count(diag_level_t level); unsigned error_count(void); void reset_error_count(void); unsigned set_error_limit(unsigned limit); void wrapped_printf(const char *fmt, ...); void wrapped_vprintf(const char *fmt, va_list ap); #define pedantic_diag(loc) ({ \ static int _warned = 0; \ _pedantic_diag(loc, &_warned, NULL); \ }) diag_t *_pedantic_diag(const loc_t *loc, int *warned, bool *error); // Accessors for use in unit tests const char *diag_get_text(diag_t *d); const char *diag_get_hint(diag_t *d, int nth); const char *diag_get_trace(diag_t *d, int nth); const loc_t *diag_get_loc(diag_t *d); int diag_hints(diag_t *d); int diag_traces(diag_t *d); #endif // _DIAG_H nvc-r1.17.1/src/driver.c000066400000000000000000000275211504111170000147740ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "driver.h" #include "hash.h" #include "ident.h" #include "mask.h" #include "option.h" #include "phase.h" #include "tree.h" #include "type.h" #include #include #define DRIVER_PAGE_SIZE 128 typedef struct _driver_page driver_page_t; typedef struct _driver_page { driver_page_t *next; unsigned count; driver_info_t members[DRIVER_PAGE_SIZE]; } driver_page_t; typedef struct _driver_set { hash_t *map; driver_page_t *pages; } driver_set_t; typedef struct { driver_set_t *ds; tree_t proc; bool tentative; } proc_params_t; static driver_info_t *alloc_driver_info(driver_set_t *ds) { if (ds->pages == NULL || ds->pages->count == DRIVER_PAGE_SIZE) { driver_page_t *p = xmalloc(sizeof(driver_page_t)); p->next = ds->pages; p->count = 0; ds->pages = p; } return &(ds->pages->members[ds->pages->count++]); } static void drives_signal(driver_set_t *ds, tree_t where, tree_t expr, tree_t view, bool tentative) { if (tree_kind(expr) == T_AGGREGATE) { const int nassocs = tree_assocs(expr); for (int i = 0; i < nassocs; i++) { tree_t e = tree_value(tree_assoc(expr, i)); drives_signal(ds, where, e, NULL, tentative); } return; } tree_t prefix = longest_static_prefix(expr); driver_info_t *last = NULL; tree_t ref = name_to_ref(prefix), decl = NULL; if (ref != NULL) { if (tree_kind((decl = tree_ref(ref))) == T_PARAM_DECL) { // Assignment to procedure parameter: this is handled at the // call site instead return; } driver_info_t *chain = hash_get(ds->map, where); for (; chain; last = chain, chain = chain->chain_proc) { if (chain->where != where || chain->decl != decl) continue; else if (tree_kind(chain->prefix) == T_REF) return; // Already driving full signal else if (same_tree(prefix, chain->prefix)) return; } } else if (tree_kind(prefix) != T_EXTERNAL_NAME) return; driver_info_t *di = alloc_driver_info(ds); di->chain_decl = NULL; di->chain_proc = NULL; di->decl = decl; di->prefix = prefix; di->where = where; di->view = view; di->tentative = tentative; if (last == NULL) hash_put(ds->map, where, di); else last->chain_proc = di; if (decl != NULL) { driver_info_t *decl_head = hash_get(ds->map, decl); if (decl_head == NULL) hash_put(ds->map, decl, di); else { for (; decl_head->chain_decl; decl_head = decl_head->chain_decl); decl_head->chain_decl = di; } } } static void driver_proc_cb(tree_t t, void *ctx) { proc_params_t *params = ctx; switch (tree_kind(t)) { case T_SIGNAL_ASSIGN: case T_DUMMY_DRIVER: drives_signal(params->ds, params->proc, tree_target(t), NULL, params->tentative); break; case T_PCALL: case T_PROT_PCALL: // LRM 08 section 4.2.2.3: a process statement contains a driver // for each actual signal associated with a formal signal // parameter of mode out or inout in a subprogram call. { tree_t decl = tree_ref(t); const int nports = tree_ports(decl); for (int i = 0; i < nports; i++) { tree_t p = tree_port(decl, i); if (tree_class(p) != C_SIGNAL) continue; const port_mode_t mode = tree_subkind(p); if (mode == PORT_OUT || mode == PORT_INOUT) { tree_t arg = tree_param(t, i); assert(tree_subkind(arg) == P_POS); drives_signal(params->ds, params->proc, tree_value(arg), NULL, params->tentative); } else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { tree_t arg = tree_param(t, i); assert(tree_subkind(arg) == P_POS); drives_signal(params->ds, params->proc, tree_value(arg), tree_value(p), params->tentative); } } } break; default: break; } } static void visit_port_map(driver_set_t *ds, tree_t unit, tree_t inst, bool tentative) { const int nparams = tree_params(inst); for (int i = 0; i < nparams; i++) { tree_t map = tree_param(inst, i); tree_t port; if (tree_subkind(map) == P_POS) port = tree_port(unit, tree_pos(map)); else { tree_t name = tree_name(map); switch (tree_kind(name)) { case T_CONV_FUNC: case T_TYPE_CONV: name = tree_value(name); break; default: break; } port = tree_ref(name_to_ref(name)); } switch (tree_subkind(port)) { case PORT_OUT: case PORT_INOUT: drives_signal(ds, inst, tree_value(map), NULL, tentative); break; case PORT_ARRAY_VIEW: case PORT_RECORD_VIEW: drives_signal(ds, inst, tree_value(map), tree_value(port), tentative); break; } } } static void visit_instance(driver_set_t *ds, tree_t inst, bool tentative) { tree_t unit = primary_unit_of(tree_ref(inst)); visit_port_map(ds, unit, inst, tentative); } static void visit_block(driver_set_t *ds, tree_t b, bool tentative) { const int nstmts = tree_stmts(b); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(b, i); switch (tree_kind(s)) { case T_PROCESS: { proc_params_t params = { .ds = ds, .proc = s, .tentative = tentative, }; tree_visit(s, driver_proc_cb, ¶ms); } break; case T_BLOCK: visit_port_map(ds, s, s, tentative); visit_block(ds, s, tentative); break; case T_FOR_GENERATE: visit_block(ds, s, true); break; case T_IF_GENERATE: { const int nconds = tree_conds(s); for (int i = 0; i < nconds; i++) visit_block(ds, tree_cond(s, i), true); } break; case T_CASE_GENERATE: { const int nalts = tree_stmts(s); for (int i = 0; i < nalts; i++) { tree_t a = tree_stmt(s, i); assert(tree_kind(a) == T_ALTERNATIVE); visit_block(ds, a, true); } } break; case T_INSTANCE: visit_instance(ds, s, tentative); break; default: break; } } } driver_set_t *find_drivers(tree_t where) { driver_set_t *ds = xcalloc(sizeof(driver_set_t)); ds->map = hash_new(128); switch (tree_kind(where)) { case T_ARCH: case T_BLOCK: case T_FOR_GENERATE: case T_COND_STMT: case T_ALTERNATIVE: visit_block(ds, where, false); break; case T_BINDING: visit_port_map(ds, primary_unit_of(tree_ref(where)), where, false); break; default: fatal_trace("cannot find drivers in %s", tree_kind_str(tree_kind(where))); } if (opt_get_int(OPT_DRIVER_VERBOSE)) dump_drivers(ds); return ds; } void free_drivers(driver_set_t *ds) { for (driver_page_t *p = ds->pages, *tmp; p; p = tmp) { tmp = p->next; free(p); } hash_free(ds->map); free(ds); } driver_info_t *get_drivers(driver_set_t *ds, tree_t what) { return hash_get(ds->map, what); } bool has_unique_driver(driver_set_t *ds, tree_t what) { // True if signal has exactly one driver for each sub-element driver_info_t *di = get_drivers(ds, what); if (di == NULL) return false; // First pass: look for assignments to the full signal bool saw_ref = false, saw_multiple = false; tree_t proc = di->where; for (driver_info_t *it = di; it; it = it->chain_decl) { if (it->tentative) return false; else if (it->where != proc) saw_multiple = true; else if (tree_kind(it->prefix) == T_REF) saw_ref = true; } if (saw_ref && !saw_multiple) return true; type_t type = tree_type(what); if (type_is_unconstrained(type)) return false; int64_t length = 0, left = 0, right = 0; range_kind_t rkind = RANGE_ERROR; if (type_is_array(type) && dimension_of(type) == 1) { tree_t r = range_of(type, 0); if (folded_length(r, &length)) { left = assume_int(tree_left(r)); right = assume_int(tree_right(r)); rkind = tree_subkind(r); } } else if (type_is_record(type)) length = type_fields(type); if (length == 0) return false; // Second pass: look for assignments to disjoint sub-elements bit_mask_t mask = {}; mask_init(&mask, length); bool covered = false; for (driver_info_t *it = di; it; it = it->chain_decl) { const tree_kind_t kind = tree_kind(it->prefix); if (kind != T_ARRAY_REF && kind != T_ARRAY_SLICE && kind != T_RECORD_REF) goto out_free; tree_t value = tree_value(it->prefix); if (tree_kind(value) != T_REF) goto out_free; assert(tree_ref(value) == what); switch (kind) { case T_ARRAY_REF: { assert(tree_params(it->prefix) == 1); tree_t p0 = tree_value(tree_param(it->prefix, 0)); int64_t ival; if (!folded_int(p0, &ival)) goto out_free; const int zero = rkind == RANGE_TO ? ival - left : ival - right; if (mask_test(&mask, zero)) goto out_free; mask_set(&mask, zero); } break; case T_ARRAY_SLICE: { tree_t r = tree_range(it->prefix, 0); int64_t low, high; if (!folded_bounds(r, &low, &high) || high < low) goto out_free; const int count = high - low + 1; const int zero = rkind == RANGE_TO ? low - left : low - right; if (mask_test_range(&mask, zero, count)) goto out_free; mask_set_range(&mask, zero, count); } break; case T_RECORD_REF: { const int pos = tree_pos(tree_ref(it->prefix)); if (mask_test(&mask, pos)) goto out_free; mask_set(&mask, pos); } break; default: goto out_free; } } covered = (mask_popcount(&mask) == length); out_free: mask_free(&mask); return covered; } LCOV_EXCL_START void dump_drivers(driver_set_t *ds) { const void *key; void *value; for (hash_iter_t it = HASH_BEGIN; hash_iter(ds->map, &it, &key, &value); ) { tree_t tree = (tree_t)key; driver_info_t *di = value; const tree_kind_t kind = tree_kind(tree); if (kind != T_PROCESS && kind != T_INSTANCE) continue; printf("%s: { ", istr(tree_ident(tree))); for (; di; di = di->chain_proc) { vhdl_dump(di->prefix, 0); if (di->view) printf("<%s>", type_pp(tree_type(di->view))); if (di->tentative) printf("?"); if (di->chain_proc) printf(", "); } printf(" }\n"); } } LCOV_EXCL_STOP nvc-r1.17.1/src/driver.h000066400000000000000000000024201504111170000147700ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _DRIVER_H #define _DRIVER_H #include "prim.h" typedef struct _driver_info driver_info_t; typedef struct _driver_info { driver_info_t *chain_proc; driver_info_t *chain_decl; tree_t decl; tree_t where; tree_t prefix; tree_t view; bool tentative; } driver_info_t; driver_set_t *find_drivers(tree_t where); driver_info_t *get_drivers(driver_set_t *ds, tree_t what); bool has_unique_driver(driver_set_t *ds, tree_t what); void free_drivers(driver_set_t *ds); void dump_drivers(driver_set_t *ds); #endif // _DRIVER_H nvc-r1.17.1/src/dump.c000066400000000000000000001307601504111170000144460ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "hash.h" #include "ident.h" #include "phase.h" #include "psl/psl-phase.h" #include "tree.h" #include "type.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include #include #include #include #define DUMP_TYPE_HINT 0 #define DUMP_ADDRESS 0 #define DUMP_STATICNESS 0 #define DUMP_GEN_NAMES 0 static void dump_expr(tree_t t); static void dump_stmt(tree_t t, int indent); static void dump_port(tree_t t, int indent); static void dump_decl(tree_t t, int indent); static void dump_decls(tree_t t, int indent); static void dump_type(type_t type); static void dump_package(tree_t t, int indent); static void dump_package_body(tree_t t, int indent); static void dump_constraint(tree_t t); static void dump_elem_constraints(type_t type); static void dump_psl(tree_t t, int indent); typedef tree_t (*get_fn_t)(tree_t, unsigned); static void tab(int indent) { print_syntax("%*s", indent, ""); } static void cannot_dump(tree_t t, const char *hint) { print_syntax("\n"); fflush(stdout); fatal("cannot dump %s kind %s", hint, tree_kind_str(tree_kind(t))); } static void dump_param(tree_t p) { switch (tree_subkind(p)) { case P_POS: break; case P_NAMED: dump_expr(tree_name(p)); print_syntax(" => "); break; } dump_expr(tree_value(p)); } static void dump_params(tree_t t, get_fn_t get, int n, const char *prefix) { if (n > 0) { if (prefix != NULL) { print_syntax(prefix, ""); print_syntax(" "); } print_syntax("("); for (int i = 0; i < n; i++) { if (i > 0) print_syntax(", "); dump_param((*get)(t, i)); } print_syntax(")"); } } static void dump_range(tree_t r) { switch (tree_subkind(r)) { case RANGE_TO: dump_expr(tree_left(r)); print_syntax(" #to "); dump_expr(tree_right(r)); break; case RANGE_DOWNTO: dump_expr(tree_left(r)); print_syntax(" #downto "); dump_expr(tree_right(r)); break; case RANGE_EXPR: case RANGE_ERROR: if (tree_has_value(r)) dump_expr(tree_value(r)); return; } } static void dump_type_hint(tree_t t) { #if DUMP_TYPE_HINT static int nested = 0; if (++nested == 1 && tree_has_type(t)) { color_printf("$red$$<$/*"); dump_type(tree_type(t)); color_printf("$>$$red$*/$$"); } --nested; #endif } static void dump_address(tree_t t) { #if DUMP_ADDRESS uint32_t a = (uint32_t)((uintptr_t)tree_arena(t) >> 2); a = (a ^ 61) ^ (a >> 16); a = a + (a << 3); a = a ^ (a >> 4); a = a * UINT32_C(0x27d4eb2d); a = a ^ (a >> 15); const int r = 1 + a % 5; const int g = 1 + (a >> 8) % 5; const int b = 1 + (a >> 16) % 5; const int color = 16 + 36*r + 6*g + b; char *LOCAL fmt = xasprintf("$!#%d${%%p:%s}$$", color, tree_kind_str(tree_kind(t))); color_printf(fmt, t); #endif } static void dump_waveform(tree_t w) { if (tree_has_value(w)) dump_expr(tree_value(w)); else print_syntax("#null"); if (tree_has_delay(w)) { print_syntax(" #after "); dump_expr(tree_delay(w)); } } static void dump_external_name(tree_t t) { print_syntax("<< #%s ", class_str(tree_class(t))); const int nparts = tree_parts(t); for (int i = 0; i < nparts; i++) { tree_t part = tree_part(t, i); switch (tree_subkind(part)) { case PE_ABSOLUTE: print_syntax("."); break; case PE_SIMPLE: print_syntax("%s%s", istr(tree_ident(part)), i + 1 < nparts ? "." : ""); break; case PE_CARET: print_syntax("^."); break; case PE_GENERATE: print_syntax("%s(", istr(tree_ident(part))); dump_expr(tree_value(part)); print_syntax(")."); break; } } print_syntax(" : "); dump_type(tree_type(t)); print_syntax(" >>"); } static void dump_expr(tree_t t) { switch (tree_kind(t)) { case T_PROT_FCALL: dump_expr(tree_name(t)); print_syntax("."); // Fall-through case T_FCALL: if (tree_has_ref(t)) { tree_t decl = tree_ref(t); dump_address(decl); print_syntax("%s", istr(tree_ident(decl))); } else print_syntax("%s", istr(tree_ident(t))); dump_params(t, tree_param, tree_params(t), NULL); #if DUMP_STATICNESS if (tree_flags(t) & TREE_F_LOCALLY_STATIC) color_printf("$red$/* locally static */$$"); else if (tree_flags(t) & TREE_F_GLOBALLY_STATIC) color_printf("$red$/* globally static */$$"); #endif break; case T_CONV_FUNC: if (tree_has_ref(t)) { tree_t decl = tree_ref(t); dump_address(decl); print_syntax("%s", istr(tree_ident(decl))); } else print_syntax("%s", istr(tree_ident(t))); print_syntax("("); dump_expr(tree_value(t)); print_syntax(")"); break; case T_LITERAL: switch (tree_subkind(t)) { case L_INT: print_syntax("%"PRIi64, tree_ival(t)); break; case L_PHYSICAL: if (tree_has_ident(t)) print_syntax("%"PRIi64" %s", tree_ival(t), istr(tree_ident(t))); else print_syntax("%"PRIi64, tree_ival(t)); break; case L_REAL: print_syntax("%lf", tree_dval(t)); break; case L_NULL: print_syntax("#null"); break; default: should_not_reach_here(); } break; case T_STRING: { print_syntax("\""); const int nchars = tree_chars(t); for (int i = 0; i < nchars; i++) { ident_t rune = tree_ident(tree_char(t, i)); if (ident_char(rune, 0) == '\'') print_syntax("%c", ident_char(rune, 1)); else print_syntax("\" & %s & \"", istr(rune)); } print_syntax("\""); } break; case T_NEW: print_syntax("#new "); dump_expr(tree_value(t)); break; case T_ALL: if (tree_has_value(t)) { dump_expr(tree_value(t)); print_syntax(".#all"); } else print_syntax("#all"); break; case T_TYPE_REF: dump_type(tree_type(t)); break; case T_AGGREGATE: print_syntax("("); for (unsigned i = 0; i < tree_assocs(t); i++) { if (i > 0) print_syntax(", "); tree_t a = tree_assoc(t, i); tree_t value = tree_value(a); switch (tree_subkind(a)) { case A_CONCAT: print_syntax("/* concat */"); // Fall-through case A_POS: dump_expr(value); break; case A_NAMED: dump_expr(tree_name(a)); print_syntax(" => "); dump_expr(value); break; case A_OTHERS: print_syntax("#others "); if (tree_ranges(a) > 0) { print_syntax("/*"); dump_range(tree_range(a, 0)); print_syntax("*/ "); } print_syntax("=> "); dump_expr(value); break; case A_SLICE: print_syntax("/* slice */"); // Fall-through case A_RANGE: dump_range(tree_range(a, 0)); print_syntax(" => "); dump_expr(value); break; default: should_not_reach_here(); } } print_syntax(")"); break; case T_REF: if (tree_has_ref(t)) { tree_t decl = tree_ref(t); dump_address(decl); print_syntax("%s", istr(tree_ident(decl))); } else print_syntax("%s", istr(tree_ident(t))); break; case T_ATTR_REF: dump_expr(tree_name(t)); print_syntax("'%s", istr(tree_ident(t))); if (tree_params(t) > 0) dump_params(t, tree_param, tree_params(t), NULL); break; case T_EXTERNAL_NAME: dump_external_name(t); break; case T_ARRAY_REF: dump_expr(tree_value(t)); dump_params(t, tree_param, tree_params(t), NULL); break; case T_ARRAY_SLICE: dump_expr(tree_value(t)); print_syntax("("); dump_range(tree_range(t, 0)); print_syntax(")"); break; case T_RECORD_REF: dump_expr(tree_value(t)); print_syntax(".%s", istr(tree_ident(t))); break; case T_TYPE_CONV: dump_type(tree_type(t)); print_syntax("("); dump_expr(tree_value(t)); print_syntax(")"); break; case T_QUALIFIED: if (tree_has_value(t)) { print_syntax("%s'(", istr(type_ident(tree_type(t)))); dump_expr(tree_value(t)); print_syntax(")"); } else dump_type(tree_type(t)); break; case T_OPEN: print_syntax("#open"); break; case T_BOX: print_syntax("<>"); break; case T_WAVEFORM: dump_waveform(t); break; case T_PACKAGE_MAP: print_syntax("%s ", istr(tree_ident(t))); switch (tree_subkind(t)) { case PACKAGE_MAP_BOX: print_syntax("#generic #map (<>)"); break; case PACKAGE_MAP_DEFAULT: print_syntax("#generic map (#default)"); break; case PACKAGE_MAP_MATCHING: dump_params(t, tree_genmap, tree_genmaps(t), "#generic #map"); break; } return; case T_COND_VALUE: for (int i = 0; i < tree_conds(t); i++) { tree_t c = tree_cond(t, i); if (i > 0) print_syntax(" #else "); if (tree_has_result(c)) dump_expr(tree_result(c)); else print_syntax("#unaffected"); if (tree_has_value(c)) { print_syntax(" #when "); dump_expr(tree_value(c)); } } break; case T_INERTIAL: print_syntax("#inertial "); dump_expr(tree_value(t)); break; default: cannot_dump(t, "expr"); } dump_type_hint(t); } static void dump_record_elem_constraint(tree_t t) { print_syntax("%s", istr(tree_ident(t))); type_t ftype = tree_type(t); if (type_has_constraint(ftype)) dump_constraint(type_constraint(ftype)); dump_elem_constraints(ftype); } static void dump_constraint(tree_t t) { const int nranges = tree_ranges(t); switch (tree_subkind(t)) { case C_RANGE: print_syntax(" #range "); dump_range(tree_range(t, 0)); break; case C_INDEX: print_syntax("("); for (int i = 0; i < nranges; i++) { if (i > 0) print_syntax(", "); dump_range(tree_range(t, i)); } print_syntax(")"); break; case C_RECORD: print_syntax("("); for (int i = 0; i < nranges; i++) { if (i > 0) print_syntax(", "); dump_record_elem_constraint(tree_range(t, i)); } print_syntax(")"); break; } } static void dump_elem_constraints(type_t type) { if (type_is_array(type) && type_has_elem(type)) { type_t elem = type_elem(type); if (is_anonymous_subtype(elem)) { // Anonymous subtype created for element constraints if (type_has_constraint(elem)) dump_constraint(type_constraint(elem)); else print_syntax("(#open)"); dump_elem_constraints(elem); } } } static void dump_type(type_t type) { if (is_anonymous_subtype(type)) { // Anonymous subtype print_syntax("%s", type_pp(type)); if (type_ident(type) == type_ident(type_base(type))) { if (type_has_constraint(type)) dump_constraint(type_constraint(type)); } dump_elem_constraints(type); } else if (type_is_none(type)) print_syntax("/* error */"); else print_syntax("%s", type_pp(type)); } static void dump_arguments(tree_t t, int indent, const char *trailer) { const int nports = tree_ports(t); if (nports > 0) { print_syntax(" ("); if (nports > 1) { print_syntax("\n"); for (int i = 0; i < nports; i++) { if (i > 0) print_syntax(";\n"); dump_port(tree_port(t, i), indent + 4); } } else dump_port(tree_port(t, 0), 1); print_syntax(" )%s", trailer); } } static void dump_ports(tree_t t, int indent) { const int nports = tree_ports(t); if (nports > 0) { tab(indent); print_syntax("#port ("); if (nports > 1) { print_syntax("\n"); for (unsigned i = 0; i < nports; i++) { if (i > 0) print_syntax(";\n"); dump_port(tree_port(t, i), indent + 2); } } else dump_port(tree_port(t, 0), 1); print_syntax(" );\n"); } } static void dump_generics(tree_t t, int indent, const char *trailer) { const int ngenerics = tree_generics(t); if (ngenerics > 0) { tab(indent); print_syntax("#generic ("); if (ngenerics > 1) { print_syntax("\n"); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(t, i); dump_port(g, indent + 2); if (i + 1 == ngenerics && (tree_flags(g) & TREE_F_PREDEFINED)) { print_syntax(";\n"); tab(indent - 1); } else if (i + 1 < ngenerics) print_syntax(";\n"); } } else dump_port(tree_generic(t, 0), 1); print_syntax(" )%s", trailer); } } static void dump_port_map(tree_t t, int indent, const char *trailer) { const int nparams = tree_params(t); if (nparams > 0) { tab(indent); dump_params(t, tree_param, nparams, "#port #map"); print_syntax("%s", trailer); } } static void dump_generic_map(tree_t t, int indent, const char *trailer) { const int ngenmaps = tree_genmaps(t); if (ngenmaps > 0) { tab(indent); dump_params(t, tree_genmap, ngenmaps, "#generic #map"); print_syntax("%s", trailer); } } static void dump_binding(tree_t t, int indent) { dump_address(t); print_syntax("#use %s", istr(tree_ident(t))); if (tree_has_ident2(t)) print_syntax("(%s)", istr(tree_ident2(t))); if (tree_genmaps(t) > 0 || tree_params(t) > 0) print_syntax("\n"); dump_generic_map(t, indent + 2, tree_params(t) > 0 ? "\n" : ""); dump_port_map(t, indent + 2, ""); print_syntax(";\n"); } static void dump_stmts(tree_t t, int indent) { bool last_was_newline = false; const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(t, i); const tree_kind_t kind = tree_kind(s); bool needs_newline; if (kind == T_VERILOG) { const vlog_kind_t vkind = vlog_kind(tree_vlog(s)); needs_newline = (vkind == V_ALWAYS || vkind == V_INITIAL); } else needs_newline = (kind == T_BLOCK || kind == T_PROCESS || kind == T_INSTANCE); if (needs_newline && i > 0 && !last_was_newline) print_syntax("\n"); dump_stmt(s, indent); if (needs_newline && i + 1 < nstmts) { print_syntax("\n"); last_was_newline = true; } else last_was_newline = false; } } static void dump_block(tree_t t, int indent) { dump_decls(t, indent + 2); tab(indent); print_syntax("#begin\n"); dump_stmts(t, indent + 2); } static void dump_wait_level(tree_t t) { const tree_flags_t flags = tree_flags(t); if (flags & TREE_F_NEVER_WAITS) print_syntax(" -- Never waits"); else if (flags & TREE_F_HAS_WAIT) print_syntax(" -- Contains wait statement"); } static void dump_type_decl(tree_t t, int indent) { type_t type = tree_type(t); const type_kind_t kind = type_kind(type); print_syntax("#type %s", istr(tree_ident(t))); if (kind == T_INCOMPLETE) { print_syntax(";\n"); return; } print_syntax(" #is "); if (type_is_integer(type) || type_is_real(type)) { print_syntax("#range "); dump_range(type_dim(type, 0)); } else if (type_is_physical(type)) { print_syntax("#range "); dump_range(type_dim(type, 0)); print_syntax("\n"); tab(indent + 2); print_syntax("#units\n"); { const int nunits = type_units(type); for (int i = 0; i < nunits; i++) { tree_t u = type_unit(type, i); tab(indent + 4); print_syntax("%s = ", istr(tree_ident(u))); dump_expr(tree_value(u)); print_syntax(";\n"); } } tab(indent + 2); print_syntax("#end #units"); } else if (type_is_array(type)) { print_syntax("#array "); if (kind == T_ARRAY) { print_syntax("("); const int nindex = type_indexes(type); for (int i = 0; i < nindex; i++) { if (i > 0) print_syntax(", "); dump_type(type_index(type, i)); print_syntax(" #range <>"); } print_syntax(")"); } else if (kind == T_SUBTYPE) { if (type_has_constraint(type)) dump_constraint(type_constraint(type)); } else { print_syntax("("); const int ndims = type_dims(type); for (int i = 0; i < ndims; i++) { if (i > 0) print_syntax(", "); dump_range(type_dim(type, i)); } print_syntax(")"); } print_syntax(" #of "); dump_type(type_elem(type)); } else if (type_is_record(type)) { print_syntax("#record\n"); const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) dump_decl(type_field(type, i), indent + 2); tab(indent); print_syntax("#end #record"); } else if (kind == T_ENUM) { print_syntax("("); for (unsigned i = 0; i < type_enum_literals(type); i++) { if (i > 0) print_syntax(", "); print_syntax("%s", istr(tree_ident(type_enum_literal(type, i)))); } print_syntax(")"); } else if (kind == T_INCOMPLETE) ; else dump_type(type); print_syntax(";\n"); } static void dump_subtype_decl(tree_t t, int indent) { type_t type = tree_type(t); print_syntax("#subtype %s #is ", istr(tree_ident(t))); if (type_has_resolution(type)) { dump_expr(type_resolution(type)); print_syntax(" "); } print_syntax("%s", type_pp(type_base(type))); if (type_has_constraint(type)) dump_constraint(type_constraint(type)); dump_elem_constraints(type); print_syntax(";\n"); } static void dump_component(tree_t t, int indent) { print_syntax("#component %s #is\n", istr(tree_ident(t))); dump_generics(t, indent + 2, ";\n"); dump_ports(t, indent + 2); print_syntax("#end #component;\n"); } static void dump_use(tree_t t) { print_syntax("#use %s", istr(tree_ident(t))); if (tree_has_ident2(t)) print_syntax(".%s", istr(tree_ident2(t))); print_syntax(";\n"); } static void dump_attr_spec(tree_t t) { print_syntax("#attribute %s #of ", istr(tree_ident(t))); switch (tree_subkind(t)) { case SPEC_EXACT: print_syntax("%s", istr(tree_ident2(t))); break; case SPEC_ALL: print_syntax("#all"); break; case SPEC_OTHERS: print_syntax("#others"); break; } print_syntax(" : #%s #is ", class_str(tree_class(t))); dump_expr(tree_value(t)); print_syntax(";\n"); } static void dump_view_decl(tree_t t, int indent) { type_t type = tree_type(t); print_syntax("#view %s #of ", istr(tree_ident(t))); dump_type(type_designated(type)); print_syntax(" #is\n"); const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { tree_t elem = type_field(type, i); tab(indent + 2); print_syntax("%s : #%s;\n", istr(tree_ident(elem)), port_mode_str(tree_subkind(elem))); } tab(indent); print_syntax("#end #view;\n"); } static void dump_decl(tree_t t, int indent) { tab(indent); const tree_kind_t kind = tree_kind(t); if (kind != T_HIER) dump_address(t); switch (kind) { case T_IMPLICIT_SIGNAL: print_syntax("/* implicit */ "); // Fall-through case T_SIGNAL_DECL: print_syntax("#signal %s : ", istr(tree_ident(t))); break; case T_VAR_DECL: print_syntax("#variable %s : ", istr(tree_ident(t))); break; case T_CONST_DECL: print_syntax("#constant %s : ", istr(tree_ident(t))); break; case T_GENERIC_DECL: // Loop variable in for-generate statement print_syntax("/* loop variable */ %s : ", istr(tree_ident(t))); break; case T_FIELD_DECL: print_syntax("%s : ", istr(tree_ident(t))); break; case T_TYPE_DECL: dump_type_decl(t, indent); return; case T_SUBTYPE_DECL: dump_subtype_decl(t, indent); return; case T_SPEC: if (tree_has_ident(t)) print_syntax("#for %s", istr(tree_ident(t))); else print_syntax("#for #others"); if (tree_has_ref(t)) print_syntax(" : %s", istr(tree_ident(tree_ref(t)))); print_syntax("\n"); tab(indent + 2); dump_binding(tree_value(t), indent + 2); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #for;\n"); return; case T_BLOCK_CONFIG: print_syntax("#for %s\n", istr(tree_ident(t))); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #for;\n"); return; case T_ENUM_LIT: print_syntax("%s", istr(tree_ident(t))); return; case T_ALIAS: if (tree_flags(t) & TREE_F_PREDEFINED) print_syntax("-- predefined "); print_syntax("#alias %s", istr(tree_ident(t))); if (tree_has_type(t)) { print_syntax(" : "); dump_type(tree_type(t)); } print_syntax(" #is "); dump_expr(tree_value(t)); print_syntax(";\n"); return; case T_ATTR_SPEC: dump_attr_spec(t); return; case T_ATTR_DECL: print_syntax("#attribute %s : ", istr(tree_ident(t))); dump_type(tree_type(t)); print_syntax(";\n"); return; case T_FUNC_DECL: if (tree_flags(t) & TREE_F_PREDEFINED) print_syntax("-- predefined %s\n", type_pp(tree_type(t))); else { print_syntax("#function %s", istr(tree_ident(t))); dump_generics(t, indent + 2, ""); dump_arguments(t, indent, ""); print_syntax(" #return "); dump_type(type_result(tree_type(t))); print_syntax(";\n"); if (tree_has_ident2(t)) { tab(indent + 2); print_syntax("-- %s\n", istr(tree_ident2(t))); } } return; case T_FUNC_INST: case T_FUNC_BODY: print_syntax("#function %s", istr(tree_ident(t))); dump_type_hint(t); dump_generics(t, indent + 2, tree_ports(t) > 0 ? "\n" : ""); if (tree_kind(t) == T_FUNC_INST) dump_generic_map(t, indent + 2, tree_ports(t) > 0 ? "\n" : ""); dump_arguments(t, indent, ""); print_syntax(" #return "); dump_type(type_result(tree_type(t))); print_syntax(" #is\n"); if (tree_has_ident2(t)) { tab(indent + 2); print_syntax("-- %s\n", istr(tree_ident2(t))); } dump_block(t, indent); tab(indent); print_syntax("#end #function;\n"); return; case T_PROC_DECL: if (tree_flags(t) & TREE_F_PREDEFINED) print_syntax("-- predefined %s\n", type_pp(tree_type(t))); else { print_syntax("#procedure %s", istr(tree_ident(t))); dump_generics(t, indent + 2, tree_ports(t) > 0 ? "\n" : ""); dump_arguments(t, indent, ""); print_syntax(";"); dump_wait_level(t); print_syntax("\n"); if (tree_has_ident2(t)) { tab(indent + 2); print_syntax("-- %s\n", istr(tree_ident2(t))); } } return; case T_PROC_INST: case T_PROC_BODY: print_syntax("#procedure %s", istr(tree_ident(t))); dump_type_hint(t); dump_generics(t, indent + 2, tree_ports(t) > 0 ? "\n" : ""); if (tree_kind(t) == T_PROC_INST) dump_generic_map(t, indent + 2, tree_ports(t) > 0 ? "\n" : ""); dump_arguments(t, indent, ""); print_syntax(" #is"); dump_wait_level(t); print_syntax("\n"); if (tree_has_ident2(t)) { tab(indent + 2); print_syntax("-- %s\n", istr(tree_ident2(t))); } dump_block(t, indent); tab(indent); print_syntax("#end #procedure;\n"); return; case T_HIER: { const char *kind = "Scope"; switch (tree_subkind(t)) { case T_ARCH: kind = "Instance"; break; case T_IF_GENERATE: kind = "If generate"; break; case T_FOR_GENERATE: kind = "For generate"; break; case T_BLOCK: kind = "Block"; break; } print_syntax("-- %s %s\n", kind, istr(tree_ident2(t))); } return; case T_COMPONENT: dump_component(t, indent); return; case T_PROT_DECL: print_syntax("#type %s #is #protected\n", istr(tree_ident(t))); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #protected;\n"); return; case T_PROT_BODY: print_syntax("#type %s #is #protected #body\n", istr(tree_ident(t))); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #protected #body;\n"); return; case T_FILE_DECL: print_syntax("#file %s : ", istr(tree_ident(t))); dump_type(tree_type(t)); if (tree_has_value(t)) { print_syntax(" #open "); dump_expr(tree_file_mode(t)); print_syntax(" #is "); dump_expr(tree_value(t)); } print_syntax(";\n"); return; case T_USE: dump_use(t); return; case T_PACKAGE: case T_PACK_INST: dump_package(t, indent); return; case T_PACK_BODY: dump_package_body(t, indent); return; case T_PSL_DECL: case T_PSL_DIRECT: dump_psl(t, 0); print_syntax(";\n"); return; case T_VIEW_DECL: dump_view_decl(t, 0); return; case T_VERILOG: vlog_dump(tree_vlog(t), indent); return; default: cannot_dump(t, "decl"); } dump_type(tree_type(t)); if (tree_kind(t) != T_FIELD_DECL && tree_has_value(t)) { print_syntax(" := "); dump_expr(tree_value(t)); } print_syntax(";\n"); } static void dump_waveforms(tree_t t) { const int nwaves = tree_waveforms(t); for (int i = 0; i < nwaves; i++) { if (i > 0) print_syntax(", "); dump_waveform(tree_waveform(t, i)); } } static void dump_alternative(tree_t t, int indent) { tab(indent); print_syntax("#when "); if (tree_has_ident(t)) print_syntax("%s: ", istr(tree_ident(t))); for (unsigned i = 0; i < tree_assocs(t); i++) { if (i > 0) print_syntax("| "); tree_t a = tree_assoc(t, i); switch (tree_subkind(a)) { case A_NAMED: dump_expr(tree_name(a)); break; case A_OTHERS: print_syntax("#others"); break; case A_RANGE: dump_range(tree_range(a, 0)); break; } } print_syntax(" =>\n"); if (tree_decls(t) > 0) { dump_decls(t, indent + 4); tab(indent + 2); print_syntax("#begin\n"); dump_stmts(t, indent + 4); tab(indent + 2); print_syntax("#end;\n"); } else dump_stmts(t, indent + 2); } static void dump_psl(tree_t t, int indent) { if (standard() < STD_08) print_syntax("-- psl "); psl_dump(tree_psl(t)); } static void dump_instance(tree_t t, int indent) { switch (tree_class(t)) { case C_ENTITY: print_syntax("#entity "); break; case C_COMPONENT: print_syntax("#component "); break; case C_CONFIGURATION: print_syntax("#configuration "); break; default: break; } print_syntax("%s", istr(tree_ident2(t))); const int nparams = tree_params(t); const int ngenmaps = tree_genmaps(t); if (tree_has_spec(t)) { tree_t spec = tree_spec(t); if (tree_has_value(spec)) { tree_t bind = tree_value(spec); LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, istr(tree_ident(bind))); if (tree_has_ident2(bind)) tb_printf(tb, "(%s)", istr(tree_ident2(bind))); print_syntax(" -- bound to %s\n", tb_get(tb)); } } else if (nparams > 0 || ngenmaps > 0) print_syntax("\n"); dump_generic_map(t, indent + 2, nparams > 0 ? "\n" : ""); dump_port_map(t, indent + 2, ""); print_syntax(";\n"); } static void dump_stmt(tree_t t, int indent) { const tree_kind_t kind = tree_kind(t); if (kind == T_VERILOG) { vlog_dump(tree_vlog(t), indent); return; } tab(indent); if (tree_has_ident(t)) { const char *label = istr(tree_ident(t)); #if !DUMP_GEN_NAMES if (label[0] != '_') // Skip generated labels #endif print_syntax("%s: ", label); } switch (tree_kind(t)) { case T_PROCESS: dump_address(t); if (tree_flags(t) & TREE_F_POSTPONED) print_syntax("#postponed "); print_syntax("#process "); if (tree_triggers(t) > 0) { print_syntax("("); for (unsigned i = 0; i < tree_triggers(t); i++) { if (i > 0) print_syntax(", "); dump_expr(tree_trigger(t, i)); } print_syntax(") "); } print_syntax("#is\n"); dump_decls(t, indent + 2); tab(indent); print_syntax("#begin\n"); dump_stmts(t, indent + 2); tab(indent); print_syntax("#end #process;\n"); return; case T_SIGNAL_ASSIGN: dump_expr(tree_target(t)); print_syntax(" <= #reject "); if (tree_has_reject(t)) dump_expr(tree_reject(t)); else print_syntax("0 ps"); print_syntax(" #inertial "); dump_waveforms(t); break; case T_FORCE: dump_expr(tree_target(t)); print_syntax(" <= #force "); dump_expr(tree_value(t)); break; case T_RELEASE: dump_expr(tree_target(t)); print_syntax(" <= #release"); break; case T_VAR_ASSIGN: dump_expr(tree_target(t)); print_syntax(" := "); dump_expr(tree_value(t)); break; case T_WAIT: print_syntax("#wait"); if (tree_triggers(t) > 0) { print_syntax(" #on "); for (unsigned i = 0; i < tree_triggers(t); i++) { if (i > 0) print_syntax(", "); dump_expr(tree_trigger(t, i)); } } if (tree_has_value(t)) { print_syntax(" #until "); dump_expr(tree_value(t)); } if (tree_has_delay(t)) { print_syntax(" #for "); dump_expr(tree_delay(t)); } print_syntax(";"); if (tree_flags(t) & TREE_F_STATIC_WAIT) print_syntax(" -- static"); print_syntax("\n"); return; case T_BLOCK: dump_address(t); print_syntax("#block #is\n"); dump_generics(t, indent + 2, ";\n"); dump_generic_map(t, indent + 2, ";\n"); dump_ports(t, indent + 2); dump_port_map(t, indent + 2, ";\n"); dump_block(t, indent); tab(indent); print_syntax("#end #block;\n"); return; case T_SEQUENCE: print_syntax("#block #is\n"); dump_block(t, indent); tab(indent); print_syntax("#end #block;\n"); return; case T_ASSERT: print_syntax("#assert "); dump_expr(tree_value(t)); if (tree_has_message(t)) { print_syntax(" #report "); dump_expr(tree_message(t)); } if (tree_has_severity(t)) { print_syntax(" #severity "); dump_expr(tree_severity(t)); } break; case T_REPORT: print_syntax("#report "); dump_expr(tree_message(t)); if (tree_has_severity(t)) { print_syntax(" #severity "); dump_expr(tree_severity(t)); } break; case T_WHILE: print_syntax("#while "); dump_expr(tree_value(t)); print_syntax(" "); // Fall-through case T_LOOP: print_syntax("#loop\n"); dump_stmts(t, indent + 2); tab(indent); print_syntax("#end #loop"); break; case T_IF: for (unsigned i = 0; i < tree_conds(t); i++) { tree_t c = tree_cond(t, i); if (tree_has_value(c)) { if (i > 0) tab(indent); print_syntax(i > 0 ? "#elsif " : "#if "); dump_expr(tree_value(c)); print_syntax(" #then\n"); } else { tab(indent); print_syntax("#else\n"); } dump_stmts(c, indent + 2); } tab(indent); print_syntax("#end #if"); break; case T_EXIT: print_syntax("#exit %s", istr(tree_ident2(t))); if (tree_has_value(t)) { print_syntax(" #when "); dump_expr(tree_value(t)); } break; case T_CASE: case T_MATCH_CASE: { const char *suffix = tree_kind(t) == T_MATCH_CASE ? "?" : ""; print_syntax("#case%s ", suffix); dump_expr(tree_value(t)); print_syntax(" #is\n"); const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) dump_alternative(tree_stmt(t, i), indent + 2); tab(indent); print_syntax("#end #case%s", suffix); } break; case T_RETURN: print_syntax("#return"); if (tree_has_value(t)) { print_syntax(" "); dump_expr(tree_value(t)); } break; case T_COND_RETURN: print_syntax("#return #when "); dump_expr(tree_value(t)); break; case T_FOR: print_syntax("#for %s #in ", istr(tree_ident(tree_decl(t, 0)))); dump_range(tree_range(t, 0)); print_syntax(" #loop\n"); dump_stmts(t, indent + 2); tab(indent); print_syntax("#end #for"); break; case T_PROT_PCALL: dump_expr(tree_name(t)); print_syntax("."); // Fall-through case T_PCALL: if (tree_has_ref(t)) { tree_t decl = tree_ref(t); dump_address(decl); print_syntax("%s", istr(tree_ident(decl))); } else print_syntax("%s", istr(tree_ident2(t))); dump_params(t, tree_param, tree_params(t), NULL); break; case T_FOR_GENERATE: print_syntax("#for %s #in ", istr(tree_ident(tree_decl(t, 0)))); dump_range(tree_range(t, 0)); print_syntax(" #generate\n"); dump_decls(t, indent + 2); tab(indent); print_syntax("#begin\n"); dump_stmts(t, indent + 2); tab(indent); print_syntax("#end #generate"); break; case T_CASE_GENERATE: { print_syntax("#case "); dump_expr(tree_value(t)); print_syntax(" #generate\n"); const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) dump_alternative(tree_stmt(t, i), indent + 2); print_syntax("#end #generate"); tab(indent); } break; case T_IF_GENERATE: for (unsigned i = 0; i < tree_conds(t); i++) { tree_t c = tree_cond(t, i); if (tree_has_value(c)) { if (i > 0) tab(indent); print_syntax(i > 0 ? "#elsif " : "#if "); dump_expr(tree_value(c)); print_syntax(" #generate\n"); } else { tab(indent); print_syntax("#else\n"); } for (unsigned i = 0; i < tree_stmts(c); i++) dump_stmt(tree_stmt(c, i), indent + 2); } tab(indent); print_syntax("#end #generate"); break; case T_INSTANCE: dump_instance(t, indent); return; case T_NEXT: print_syntax("#next"); if (tree_has_value(t)) { print_syntax(" #when "); dump_expr(tree_value(t)); } break; case T_NULL: print_syntax("#null"); break; case T_COND_ASSIGN: dump_expr(tree_target(t)); print_syntax(" <= "); if (tree_has_guard(t)) print_syntax("#guarded "); for (int i = 0; i < tree_conds(t); i++) { tree_t c = tree_cond(t, i); dump_waveforms(tree_stmt(c, 0)); if (tree_has_value(c)) { print_syntax(" #when "); dump_expr(tree_value(c)); } } break; case T_SELECT: print_syntax(" <= "); if (tree_has_guard(t)) print_syntax("#guarded "); color_printf("$red$/* TODO: T_SELECT */$$"); break; case T_CONCURRENT: if (tree_flags(t) & TREE_F_POSTPONED) print_syntax("#postponed "); dump_stmt(tree_stmt(t, 0), 0); return; case T_DUMMY_DRIVER: print_syntax("-- dummy driver for "); dump_expr(tree_target(t)); print_syntax("\n"); return; case T_PSL_DIRECT: dump_psl(t, indent); break; default: cannot_dump(t, "stmt"); } print_syntax(";\n"); } static void dump_port(tree_t t, int indent) { tab(indent); dump_address(t); if (tree_flags(t) & TREE_F_PREDEFINED) print_syntax("-- predefined "); const class_t class = tree_class(t); print_syntax("#%s %s", class_str(class), istr(tree_ident(t))); const port_mode_t mode = tree_subkind(t); type_t type = get_type_or_null(t); if (class == C_PACKAGE) { print_syntax(" #is #new "); dump_expr(tree_value(t)); } else if (class == C_TYPE && type_kind(type) == T_GENERIC) { print_syntax(" #is "); switch (type_subkind(type)) { case GTYPE_PRIVATE: print_syntax("#private"); break; case GTYPE_SCALAR: print_syntax("<>"); break; case GTYPE_DISCRETE: print_syntax("(<>)"); break; case GTYPE_INTEGER: print_syntax("#range <>"); break; case GTYPE_PHYSICAL: print_syntax("#units <>"); break; case GTYPE_FLOATING: print_syntax("#range <> . <>"); break; case GTYPE_ARRAY: { print_syntax("#array ("); const int nindex = type_indexes(type); for (int i = 0; i < nindex; i++) { if (i > 0) print_syntax(", "); dump_type(type_index(type, i)); print_syntax(" #range <>"); } print_syntax(") #of "); dump_type(type_elem(type)); } break; case GTYPE_ACCESS: print_syntax("#access .."); break; case GTYPE_FILE: print_syntax("#file #of .."); break; } } else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { print_syntax(" : #view "); dump_expr(tree_value(t)); } else { static const char *map[] = { "??", "in", "out", "inout", "buffer", "linkage" }; print_syntax(" : #%s ", map[mode]); dump_type(type); if (tree_has_value(t)) { print_syntax(" := "); dump_expr(tree_value(t)); } } } static void dump_context(tree_t t, int indent) { const int nctx = tree_contexts(t); for (int i = 0; i < nctx; i++) { tree_t c = tree_context(t, i); switch (tree_kind(c)) { case T_LIBRARY: switch (is_well_known(tree_ident(c))) { case W_STD: case W_WORK: break; default: print_syntax("#library %s;\n", istr(tree_ident(c))); } break; case T_USE: dump_use(c); break; case T_CONTEXT_REF: print_syntax("#context %s;\n", istr(tree_ident(t))); break; default: break; } tab(indent); } if (nctx > 0) { print_syntax("\n"); tab(indent); } } static void dump_elab(tree_t t) { dump_context(t, 0); dump_address(t); print_syntax("#entity %s #is\n#end #entity;\n\n", istr(tree_ident(t))); print_syntax("#architecture #elab #of %s #is\n", istr(tree_ident(t))); dump_decls(t, 2); print_syntax("#begin\n"); for (unsigned i = 0; i < tree_stmts(t); i++) dump_stmt(tree_stmt(t, i), 2); print_syntax("#end #architecture;\n\n"); } static void dump_entity(tree_t t) { dump_context(t, 0); dump_address(t); print_syntax("#entity %s #is\n", istr(tree_ident(t))); dump_generics(t, 2, ";\n"); dump_ports(t, 2); dump_decls(t, 2); if (tree_stmts(t) > 0) { print_syntax("#begin\n"); for (unsigned i = 0; i < tree_stmts(t); i++) { dump_stmt(tree_stmt(t, i), 2); } } print_syntax("#end #entity;\n\n"); } static void dump_decls(tree_t t, int indent) { const int ndecls = tree_decls(t); bool was_body = false; for (unsigned i = 0; i < ndecls; i++) { tree_t d = tree_decl(t, i); tree_kind_t dkind = tree_kind(d); const bool is_body = dkind == T_FUNC_BODY || dkind == T_PROT_BODY || dkind == T_PROC_BODY; if ((was_body && !is_body) || (is_body && i > 0)) print_syntax("\n"); was_body = is_body; dump_decl(d, indent); } } static void dump_arch(tree_t t) { dump_context(t, 0); dump_address(t); print_syntax("#architecture %s #of %s #is\n", istr(tree_ident(t)), istr(tree_ident2(t))); dump_decls(t, 2); print_syntax("#begin\n"); dump_stmts(t, 2); print_syntax("#end #architecture;\n\n"); } static void dump_package(tree_t t, int indent) { dump_context(t, indent); dump_address(t); print_syntax("#package %s #is\n", istr(tree_ident(t))); if (tree_kind(t) == T_PACK_INST && tree_has_ref(t)) { tab(indent); print_syntax(" -- Instantiated from %s\n", istr(tree_ident(tree_ref(t)))); } dump_generics(t, indent + 2, ";\n"); dump_generic_map(t, indent + 2, ";\n"); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #package;\n\n"); } static void dump_package_body(tree_t t, int indent) { dump_context(t, indent); dump_address(t); print_syntax("#package #body %s #is\n", istr(tree_ident(t))); dump_decls(t, indent + 2); tab(indent); print_syntax("#end #package #body;\n\n"); } static void dump_configuration(tree_t t) { dump_address(t); print_syntax("#configuration %s #of %s #is\n", istr(tree_ident(t)), istr(tree_ident2(t))); dump_decls(t, 2); print_syntax("#end #configuration\n"); } void vhdl_dump(tree_t t, int indent) { switch (tree_kind(t)) { case T_ELAB: dump_elab(t); break; case T_ENTITY: dump_entity(t); break; case T_ARCH: dump_arch(t); break; case T_PACKAGE: case T_PACK_INST: dump_package(t, indent); break; case T_PACK_BODY: dump_package_body(t, indent); break; case T_CONFIGURATION: dump_configuration(t); break; case T_REF: case T_FCALL: case T_PROT_FCALL: case T_LITERAL: case T_AGGREGATE: case T_ARRAY_REF: case T_ARRAY_SLICE: case T_TYPE_CONV: case T_RECORD_REF: case T_ATTR_REF: case T_CONV_FUNC: case T_QUALIFIED: case T_EXTERNAL_NAME: case T_STRING: case T_PACKAGE_MAP: case T_TYPE_REF: dump_expr(t); break; case T_INSTANCE: case T_FOR_GENERATE: case T_CASE_GENERATE: case T_BLOCK: case T_PROCESS: case T_CASE: case T_FOR: case T_SIGNAL_ASSIGN: case T_IF: case T_WAIT: case T_PSL_DIRECT: case T_VAR_ASSIGN: case T_RETURN: case T_ASSERT: case T_WHILE: case T_LOOP: case T_SEQUENCE: case T_PCALL: dump_stmt(t, indent); break; case T_CONST_DECL: case T_VAR_DECL: case T_SIGNAL_DECL: case T_TYPE_DECL: case T_FIELD_DECL: case T_FUNC_DECL: case T_PROC_BODY: case T_FUNC_BODY: case T_PROC_DECL: case T_ATTR_DECL: case T_ATTR_SPEC: case T_ENUM_LIT: case T_COMPONENT: case T_BLOCK_CONFIG: case T_SPEC: case T_ALIAS: case T_FUNC_INST: case T_PROC_INST: case T_SUBTYPE_DECL: case T_VIEW_DECL: dump_decl(t, indent); break; case T_PORT_DECL: case T_GENERIC_DECL: case T_PARAM_DECL: dump_port(t, indent); break; case T_RANGE: dump_range(t); break; case T_BINDING: dump_binding(t, indent); break; case T_PARAM: dump_param(t); break; case T_CONSTRAINT: dump_constraint(t); break; case T_ELEM_CONSTRAINT: dump_record_elem_constraint(t); break; case T_ALTERNATIVE: dump_alternative(t, indent); break; default: cannot_dump(t, "tree"); } } void dump(tree_t t) { vhdl_dump(t, 0); print_syntax("\r"); } nvc-r1.17.1/src/elab.c000066400000000000000000002102301504111170000143730ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "driver.h" #include "eval.h" #include "hash.h" #include "inst.h" #include "lib.h" #include "lower.h" #include "mask.h" #include "object.h" #include "option.h" #include "phase.h" #include "psl/psl-phase.h" #include "rt/model.h" #include "rt/structs.h" #include "thread.h" #include "type.h" #include "vlog/vlog-defs.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include #include #include #include #define MAX_DEPTH 127 // Limited by vcode type indexes typedef A(tree_t) tree_list_t; typedef struct _elab_ctx elab_ctx_t; typedef struct _generic_list generic_list_t; typedef struct _elab_instance elab_instance_t; typedef struct _elab_ctx { const elab_ctx_t *parent; tree_t out; object_t *root; tree_t inst; tree_t config; ident_t dotted; ident_t prefix[2]; lib_t library; hash_t *generics; jit_t *jit; unit_registry_t *registry; mir_context_t *mir; lower_unit_t *lowered; cover_data_t *cover; sdf_file_t *sdf; driver_set_t *drivers; hash_t *modcache; rt_model_t *model; rt_scope_t *scope; unsigned depth; } elab_ctx_t; typedef struct { ident_t search; ident_t chosen; timestamp_t mtime; } lib_search_params_t; typedef struct { tree_t comp; tree_t *result; } synth_binding_params_t; typedef struct _generic_list { generic_list_t *next; ident_t name; char *value; } generic_list_t; typedef struct { tree_t wrap; tree_t entity; vlog_node_t module; elab_instance_t *instances; } mod_cache_t; typedef struct _elab_instance { elab_instance_t *next; mod_cache_t *module; vlog_node_t body; tree_t block; tree_t wrap; } elab_instance_t; static void elab_block(tree_t t, const elab_ctx_t *ctx); static void elab_stmts(tree_t t, const elab_ctx_t *ctx); static void elab_decls(tree_t t, const elab_ctx_t *ctx); static void elab_push_scope(tree_t t, elab_ctx_t *ctx); static void elab_pop_scope(elab_ctx_t *ctx); static void elab_verilog_stmts(vlog_node_t v, const elab_ctx_t *ctx); static generic_list_t *generic_override = NULL; static lib_t elab_find_lib(ident_t name, const elab_ctx_t *ctx) { ident_t lib_name = ident_until(name, '.'); if (lib_name == well_known(W_WORK)) return ctx->library; else return lib_require(lib_name); } static void elab_find_arch_cb(lib_t lib, ident_t name, int kind, void *context) { lib_search_params_t *params = context; ident_t prefix = ident_until(name, '-'); if (kind != T_ARCH || prefix != params->search) return; const timestamp_t new_mtime = lib_get_mtime(lib, name); if (params->chosen == NULL) { params->chosen = name; params->mtime = new_mtime; } else if (new_mtime > params->mtime) { params->chosen = name; params->mtime = new_mtime; } else if (new_mtime == params->mtime) { // Use source file line numbers to break the tie tree_t old_unit = lib_get(lib, params->chosen); tree_t new_unit = lib_get(lib, name); if (old_unit == NULL) params->chosen = name; else if (new_unit != NULL) { const loc_t *old_loc = tree_loc(old_unit); const loc_t *new_loc = tree_loc(new_unit); if (old_loc->file_ref != new_loc->file_ref) warnf("cannot determine which of %s and %s is most recently " "modified", istr(params->chosen), istr(name)); else if (new_loc->first_line >= old_loc->first_line) params->chosen = name; } } } static tree_t elab_pick_arch(const loc_t *loc, tree_t entity, const elab_ctx_t *ctx) { // When an explicit architecture name is not given select the most // recently analysed architecture of this entity ident_t name = tree_ident(entity); lib_t lib = elab_find_lib(name, ctx); ident_t search_name = ident_prefix(lib_name(lib), ident_rfrom(name, '.'), '.'); lib_search_params_t params = { .search = search_name }; lib_walk_index(lib, elab_find_arch_cb, ¶ms); if (params.chosen == NULL) fatal_at(loc, "no suitable architecture for %s", istr(search_name)); return lib_get(lib, params.chosen); } static tree_t elab_copy(tree_t t, const elab_ctx_t *ctx) { tree_list_t roots = AINIT; switch (tree_kind(t)) { case T_ARCH: APUSH(roots, tree_primary(t)); APUSH(roots, t); // Architecture must be processed last break; case T_BLOCK_CONFIG: { tree_t arch = tree_ref(t); assert(tree_kind(arch) == T_ARCH); APUSH(roots, tree_primary(arch)); APUSH(roots, arch); APUSH(roots, t); } break; default: fatal_trace("unexpected %s in elab_copy", tree_kind_str(tree_kind(t))); } tree_global_flags_t gflags = 0; for (int i = 0; i < roots.count; i++) gflags |= tree_global_flags(roots.items[i]); new_instance(roots.items, roots.count, ctx->dotted, ctx->prefix, ARRAY_LEN(ctx->prefix)); tree_t copy = roots.items[roots.count - 1]; ACLEAR(roots); tree_set_global_flags(copy, gflags); return copy; } static void elab_subprogram_prefix(tree_t arch, elab_ctx_t *ctx) { // Get the prefix of unit that will need to be rewritten in // subprogram names assert(tree_kind(arch) == T_ARCH); // The order is important here because the architecture name is // prefixed with the entity ctx->prefix[0] = tree_ident(arch); ctx->prefix[1] = tree_ident(tree_primary(arch)); } static mod_cache_t *elab_cached_module(vlog_node_t mod, const elab_ctx_t *ctx) { assert(is_top_level(mod)); mod_cache_t *mc = hash_get(ctx->modcache, mod); if (mc != NULL) return mc; mc = xcalloc(sizeof(mod_cache_t)); mc->module = mod; mc->wrap = tree_new(T_VERILOG); tree_set_loc(mc->wrap, vlog_loc(mod)); tree_set_ident(mc->wrap, vlog_ident(mod)); tree_set_vlog(mc->wrap, mod); hash_put(ctx->modcache, mod, mc); return mc; } static elab_instance_t *elab_new_instance(vlog_node_t mod, vlog_node_t inst, const elab_ctx_t *ctx) { assert(is_top_level(mod)); mod_cache_t *mc = elab_cached_module(mod, ctx); elab_instance_t *ei = xcalloc(sizeof(elab_instance_t)); ei->next = mc->instances; ei->module = mc; ei->body = vlog_new_instance(mod, inst, ctx->dotted); ei->wrap = tree_new(T_VERILOG); tree_set_loc(ei->wrap, vlog_loc(mod)); tree_set_ident(ei->wrap, vlog_ident(mod)); tree_set_vlog(ei->wrap, ei->body); ei->block = tree_new(T_BLOCK); tree_set_loc(ei->block, vlog_loc(inst)); tree_set_ident(ei->block, vlog_ident(inst)); vlog_trans(ei->body, ei->block); mc->instances = ei; return ei; } static bool elab_synth_binding_cb(lib_t lib, void *__ctx) { synth_binding_params_t *params = __ctx; ident_t name = ident_prefix(lib_name(lib), tree_ident(params->comp), '.'); *(params->result) = lib_get(lib, name); return *(params->result) == NULL; } static tree_t elab_to_vhdl(type_t from, type_t to) { static struct { const verilog_type_t from_id; const ieee_type_t to_id; const char *const func; type_t from; type_t to; tree_t decl; } table[] = { { VERILOG_LOGIC, IEEE_STD_LOGIC, "NVC.VERILOG.TO_VHDL(" T_LOGIC ")U" }, { VERILOG_NET_VALUE, IEEE_STD_LOGIC, "NVC.VERILOG.TO_VHDL(" T_NET_VALUE ")U" }, { VERILOG_WIRE_ARRAY, IEEE_STD_ULOGIC_VECTOR, "NVC.VERILOG.TO_VHDL(" T_WIRE_ARRAY ")Y" }, { VERILOG_WIRE_ARRAY, IEEE_STD_LOGIC_VECTOR, "NVC.VERILOG.TO_VHDL(" T_WIRE_ARRAY ")Y" }, }; INIT_ONCE({ for (int i = 0; i < ARRAY_LEN(table); i++) { table[i].from = verilog_type(table[i].from_id); table[i].to = ieee_type(table[i].to_id); table[i].decl = verilog_func(ident_new(table[i].func)); } }); for (int i = 0; i < ARRAY_LEN(table); i++) { if (type_eq(table[i].from, from) && type_eq(table[i].to, to)) return table[i].decl; } return NULL; } static tree_t elab_to_verilog(type_t from, type_t to) { static struct { const ieee_type_t from_id; const verilog_type_t to_id; const char *const func; type_t from; type_t to; tree_t decl; } table[] = { { IEEE_STD_ULOGIC, VERILOG_LOGIC, "NVC.VERILOG.TO_VERILOG(U)" T_LOGIC }, { IEEE_STD_ULOGIC, VERILOG_NET_VALUE, "NVC.VERILOG.TO_VERILOG(U)" T_NET_VALUE }, { IEEE_STD_ULOGIC_VECTOR, VERILOG_WIRE_ARRAY, "NVC.VERILOG.TO_VERILOG(Y)" T_NET_ARRAY }, { IEEE_STD_LOGIC_VECTOR, VERILOG_WIRE_ARRAY, "NVC.VERILOG.TO_VERILOG(Y)" T_NET_ARRAY }, }; INIT_ONCE({ for (int i = 0; i < ARRAY_LEN(table); i++) { table[i].from = ieee_type(table[i].from_id); table[i].to = verilog_type(table[i].to_id); table[i].decl = verilog_func(ident_new(table[i].func)); } }); for (int i = 0; i < ARRAY_LEN(table); i++) { if (type_eq(table[i].from, from) && type_eq(table[i].to, to)) return table[i].decl; } return NULL; } static tree_t elab_mixed_binding(tree_t comp, mod_cache_t *mc) { assert(tree_kind(comp) == T_COMPONENT); if (mc->entity == NULL) { mc->entity = tree_new(T_ENTITY); tree_set_ident(mc->entity, vlog_ident(mc->module)); tree_set_loc(mc->entity, vlog_loc(mc->module)); vlog_trans(mc->module, mc->entity); } tree_t bind = tree_new(T_BINDING); tree_set_ident(bind, vlog_ident(mc->module)); tree_set_loc(bind, tree_loc(comp)); tree_set_ref(bind, mc->wrap); tree_set_class(bind, C_ENTITY); const int vhdl_nports = tree_ports(comp); const int vlog_nports = vlog_ports(mc->module); bit_mask_t have; mask_init(&have, vhdl_nports); bool have_named = false; for (int i = 0; i < vlog_nports; i++) { vlog_node_t ref = vlog_port(mc->module, i); assert(vlog_kind(ref) == V_REF); vlog_node_t mport = vlog_ref(ref); assert(vlog_kind(mport) == V_PORT_DECL); ident_t name = vlog_ident2(mport); tree_t vport = tree_port(mc->entity, i); assert(tree_ident(vport) == vlog_ident(mport)); tree_t cport = NULL; for (int j = 0; j < vhdl_nports; j++) { tree_t pj = tree_port(comp, j); if (ident_casecmp(tree_ident(pj), name)) { cport = pj; mask_set(&have, j); break; } } if (cport == NULL) { error_at(tree_loc(comp), "missing matching VHDL port declaration for " "Verilog port '%s' in component %s", istr(vlog_ident(mport)), istr(tree_ident(comp))); return NULL; } type_t btype = tree_type(cport); type_t vtype = tree_type(vport); if (vlog_subkind(mport) == V_PORT_INPUT) { tree_t func = elab_to_verilog(btype, vtype); if (func == NULL) { error_at(tree_loc(cport), "cannot connect VHDL signal with type " "%s to Verilog input port '%s'", type_pp(btype), istr(vlog_ident(mport))); return NULL; } tree_t conv = tree_new(T_CONV_FUNC); tree_set_loc(conv, tree_loc(cport)); tree_set_ref(conv, func); tree_set_ident(conv, tree_ident(func)); tree_set_type(conv, type_result(tree_type(func))); tree_set_value(conv, make_ref(cport)); if (have_named) add_param(bind, conv, P_NAMED, make_ref(vport)); else add_param(bind, conv, P_POS, NULL); } else { tree_t func = elab_to_vhdl(vtype, btype); if (func == NULL) { error_at(tree_loc(cport), "cannot connect VHDL signal with type " "%s to Verilog output port '%s'", type_pp(btype), istr(vlog_ident(mport))); return NULL; } tree_t conv = tree_new(T_CONV_FUNC); tree_set_loc(conv, tree_loc(cport)); tree_set_ref(conv, func); tree_set_ident(conv, tree_ident(func)); tree_set_type(conv, type_result(tree_type(func))); tree_set_value(conv, make_ref(vport)); add_param(bind, make_ref(cport), P_NAMED, conv); have_named = true; } } for (int i = 0; i < vhdl_nports; i++) { if (!mask_test(&have, i)) { tree_t p = tree_port(comp, i); diag_t *d = diag_new(DIAG_ERROR, tree_loc(p)); diag_printf(d, "port %s not found in Verilog module %s", istr(tree_ident(p)), istr(vlog_ident2(mc->module))); diag_emit(d); } } mask_free(&have); const int vhdl_ngenerics = tree_generics(comp); const int vlog_ndecls = vlog_decls(mc->module); mask_init(&have, vhdl_ngenerics); for (int i = 0, nth = 0; i < vlog_ndecls; i++) { vlog_node_t d = vlog_decl(mc->module, i); if (vlog_kind(d) != V_PARAM_DECL) continue; ident_t name = vlog_ident(d); tree_t eg = tree_generic(mc->entity, nth++); assert(tree_ident(eg) == name); tree_t cg = NULL; for (int j = 0; j < vhdl_ngenerics; j++) { tree_t gj = tree_generic(comp, j); if (ident_casecmp(tree_ident(gj), name)) { cg = gj; mask_set(&have, j); break; } } if (cg == NULL) { error_at(tree_loc(comp), "missing matching VHDL generic declaration " "for Verilog parameter '%s' in component %s", istr(name), istr(tree_ident(comp))); return NULL; } type_t ctype = tree_type(cg); type_t etype = tree_type(eg); assert(type_eq(etype, std_type(NULL, STD_INTEGER))); if (!type_eq(ctype, etype)) { error_at(tree_loc(cg), "generic %s should have type %s to match " "corresponding Verilog parameter", istr(tree_ident(cg)), type_pp(etype)); return NULL; } tree_t map = tree_new(T_PARAM); tree_set_subkind(map, P_POS); tree_set_pos(map, tree_genmaps(bind)); tree_set_value(map, make_ref(cg)); tree_add_genmap(bind, map); } for (int i = 0; i < vhdl_ngenerics; i++) { if (!mask_test(&have, i)) { tree_t g = tree_generic(comp, i); diag_t *d = diag_new(DIAG_ERROR, tree_loc(g)); diag_printf(d, "generic %s not found in Verilog module %s", istr(tree_ident(g)), istr(vlog_ident2(mc->module))); diag_emit(d); } } mask_free(&have); return bind; } static tree_t elab_verilog_conversion(type_t from, type_t to) { static struct { const verilog_type_t from_id; const verilog_type_t to_id; const char *const func; type_t from; type_t to; tree_t decl; } table[] = { { VERILOG_NET_VALUE, VERILOG_LOGIC, "NVC.VERILOG.TO_LOGIC(" T_NET_VALUE ")" T_LOGIC }, { VERILOG_NET_ARRAY, VERILOG_LOGIC_ARRAY, "NVC.VERILOG.TO_LOGIC(" T_NET_ARRAY ")" T_LOGIC_ARRAY }, { VERILOG_WIRE_ARRAY, VERILOG_LOGIC_ARRAY, "NVC.VERILOG.TO_LOGIC(" T_WIRE_ARRAY ")" T_LOGIC_ARRAY }, { VERILOG_LOGIC, VERILOG_NET_VALUE, "NVC.VERILOG.TO_NET(" T_LOGIC ")" T_NET_VALUE }, { VERILOG_LOGIC_ARRAY, VERILOG_NET_ARRAY, "NVC.VERILOG.TO_NET(" T_LOGIC_ARRAY ")" T_NET_ARRAY }, { VERILOG_LOGIC_ARRAY, VERILOG_WIRE_ARRAY, "NVC.VERILOG.TO_NET(" T_LOGIC_ARRAY ")" T_WIRE_ARRAY }, }; INIT_ONCE({ for (int i = 0; i < ARRAY_LEN(table); i++) { table[i].from = verilog_type(table[i].from_id); table[i].to = verilog_type(table[i].to_id); table[i].decl = verilog_func(ident_new(table[i].func)); } }); for (int i = 0; i < ARRAY_LEN(table); i++) { if (type_eq(table[i].from, from) && type_eq(table[i].to, to)) return table[i].decl; } return NULL; } static tree_t elab_verilog_binding(vlog_node_t inst, elab_instance_t *ei, const elab_ctx_t *ctx) { assert(vlog_kind(inst) == V_MOD_INST); tree_t bind = tree_new(T_BINDING); tree_set_ident(bind, vlog_ident(ei->body)); tree_set_loc(bind, vlog_loc(inst)); tree_set_ref(bind, ei->module->wrap); tree_set_class(bind, C_ENTITY); const int nports = vlog_ports(ei->body); const int nparams = vlog_params(inst); const int outports = tree_ports(ctx->out); const int outdecls = tree_decls(ctx->out); if (nports != nparams) { error_at(vlog_loc(inst), "expected %d port connections for module %s " "but found %d", nports, istr(vlog_ident2(ei->body)), nparams); return NULL; } bool have_named = false; for (int i = 0; i < nports; i++) { vlog_node_t conn = vlog_param(inst, i); assert(vlog_kind(conn) == V_PORT_CONN); vlog_node_t expr = vlog_value(conn); ident_t id = vlog_ident(expr); tree_t decl = NULL; for (int j = 0; j < outports; j++) { tree_t p = tree_port(ctx->out, j); if (tree_ident(p) == id) { decl = p; break; } } if (decl == NULL) { for (int j = 0; j < outdecls; j++) { tree_t d = tree_decl(ctx->out, j); if (tree_ident(d) == id) { decl = d; break; } } } assert(decl != NULL); tree_t port = tree_port(ei->block, i); type_t dtype = tree_type(decl); type_t ptype = tree_type(port); if (type_eq(dtype, ptype)) { if (have_named) add_param(bind, make_ref(decl), P_NAMED, make_ref(port)); else add_param(bind, make_ref(decl), P_POS, NULL); } else if (tree_subkind(port) == PORT_IN) { tree_t func = elab_verilog_conversion(dtype, ptype); assert(func != NULL); tree_t conv = tree_new(T_CONV_FUNC); tree_set_loc(conv, vlog_loc(conn)); tree_set_ref(conv, func); tree_set_ident(conv, tree_ident(func)); tree_set_type(conv, type_result(tree_type(func))); tree_set_value(conv, make_ref(decl)); if (have_named) add_param(bind, conv, P_NAMED, make_ref(port)); else add_param(bind, conv, P_POS, NULL); } else { tree_t func = elab_verilog_conversion(ptype, dtype); assert(func != NULL); tree_t conv = tree_new(T_CONV_FUNC); tree_set_loc(conv, vlog_loc(conn)); tree_set_ref(conv, func); tree_set_ident(conv, tree_ident(func)); tree_set_type(conv, type_result(tree_type(func))); tree_set_value(conv, make_ref(port)); add_param(bind, make_ref(decl), P_NAMED, conv); have_named = true; } } return bind; } static tree_t elab_default_binding(tree_t inst, const elab_ctx_t *ctx) { // Default binding indication is described in LRM 93 section 5.2.2 tree_t comp = tree_ref(inst); ident_t full_i = tree_ident(comp); ident_t lib_i = ident_until(full_i, '.'); lib_t lib = NULL; bool synth_binding = true; if (lib_i == full_i) { lib = ctx->library; full_i = ident_prefix(lib_name(lib), full_i, '.'); } else { synth_binding = false; lib = elab_find_lib(lib_i, ctx); // Strip out the component package name, if any full_i = ident_prefix(lib_i, ident_rfrom(full_i, '.'), '.'); } object_t *obj = lib_get_generic(lib, full_i, NULL); vlog_node_t mod = vlog_from_object(obj); if (mod != NULL) { mod_cache_t *mc = elab_cached_module(mod, ctx); return elab_mixed_binding(comp, mc); } tree_t entity = tree_from_object(obj); if (entity == NULL && synth_binding) { // This is not correct according to the LRM but matches the // behaviour of many synthesis tools synth_binding_params_t params = { .comp = comp, .result = &entity }; lib_for_all(elab_synth_binding_cb, ¶ms); } if (entity == NULL) { warn_at(tree_loc(inst), "cannot find entity for component %s " "without binding indication", istr(tree_ident(comp))); return NULL; } tree_t arch = elab_pick_arch(tree_loc(comp), entity, ctx); // Check entity is compatible with component declaration tree_t bind = tree_new(T_BINDING); tree_set_ident(bind, tree_ident(arch)); tree_set_loc(bind, tree_loc(arch)); tree_set_ref(bind, arch); tree_set_class(bind, C_ENTITY); const int c_ngenerics = tree_generics(comp); const int e_ngenerics = tree_generics(entity); for (int i = 0; i < e_ngenerics; i++) { tree_t eg = tree_generic(entity, i); tree_t match = NULL; for (int j = 0; j < c_ngenerics; j++) { tree_t cg = tree_generic(comp, j); if (ident_casecmp(tree_ident(eg), tree_ident(cg))) { match = cg; break; } } tree_t value; if (match != NULL) { const class_t class = tree_class(eg); if (class != tree_class(match)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "generic %s in component %s has class %s which is " "incompatible with class %s in entity %s", istr(tree_ident(match)), istr(tree_ident(comp)), class_str(tree_class(match)), class_str(class), istr(tree_ident(entity))); diag_hint(d, tree_loc(match), "declaration of generic %s in " "component", istr(tree_ident(match))); diag_hint(d, tree_loc(eg), "declaration of generic %s in entity", istr(tree_ident(eg))); diag_emit(d); return NULL; } else if (class == C_PACKAGE) { value = tree_new(T_REF); tree_set_ident(value, tree_ident(match)); tree_set_ref(value, match); } else { type_t ctype = tree_type(match); type_t etype = tree_type(eg); if (!type_eq(ctype, etype)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "generic %s in component %s has type %s which is " "incompatible with type %s in entity %s", istr(tree_ident(match)), istr(tree_ident(comp)), type_pp2(ctype, etype), type_pp2(etype, ctype), istr(tree_ident(entity))); diag_hint(d, tree_loc(match), "declaration of generic %s in " "component", istr(tree_ident(match))); diag_hint(d, tree_loc(eg), "declaration of generic %s in entity", istr(tree_ident(eg))); diag_emit(d); return NULL; } value = make_ref(match); } } else if (tree_has_value(eg)) { tree_t def = tree_value(eg); if (is_literal(def)) value = def; else { tree_t open = tree_new(T_OPEN); tree_set_loc(open, tree_loc(eg)); tree_set_type(open, tree_type(eg)); value = open; } } else { diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "generic %s in entity %s without a default value " "has no corresponding generic in component %s", istr(tree_ident(eg)), istr(tree_ident(entity)), istr(tree_ident(comp))); diag_hint(d, tree_loc(eg), "declaration of generic %s in entity", istr(tree_ident(eg))); diag_emit(d); return NULL; } tree_t map = tree_new(T_PARAM); tree_set_loc(map, tree_loc(inst)); tree_set_value(map, value); tree_set_subkind(map, P_POS); tree_set_pos(map, i); tree_add_genmap(bind, map); } const int c_nports = tree_ports(comp); const int e_nports = tree_ports(entity); for (int i = 0; i < e_nports; i++) { tree_t ep = tree_port(entity, i); tree_t match = NULL; for (int j = 0; j < c_nports; j++) { tree_t cp = tree_port(comp, j); if (ident_casecmp(tree_ident(ep), tree_ident(cp))) { match = cp; break; } } tree_t value; if (match != NULL) { type_t ctype = tree_type(match); type_t etype = tree_type(ep); if (!type_eq(ctype, etype)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "port %s in component %s has type %s which is " "incompatible with type %s in entity %s", istr(tree_ident(match)), istr(tree_ident(comp)), type_pp2(ctype, etype), type_pp2(etype, ctype), istr(tree_ident(entity))); diag_hint(d, tree_loc(match), "declaration of port %s in component", istr(tree_ident(match))); diag_hint(d, tree_loc(ep), "declaration of port %s in entity", istr(tree_ident(ep))); diag_emit(d); return NULL; } value = make_ref(match); } else { const bool open_ok = tree_has_value(ep) || (tree_subkind(ep) == PORT_OUT && !type_is_unconstrained(tree_type(ep))); if (open_ok) { tree_t open = tree_new(T_OPEN); tree_set_loc(open, tree_loc(ep)); tree_set_type(open, tree_type(ep)); value = open; } else { diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "port %s in entity %s without a default value " "has no corresponding port in component %s", istr(tree_ident(ep)), istr(tree_ident(entity)), istr(tree_ident(comp))); diag_hint(d, tree_loc(ep), "port %s declared here", istr(tree_ident(ep))); diag_emit(d); return NULL; } } add_param(bind, value, P_POS, NULL); } return bind; } static void elab_write_generic(text_buf_t *tb, tree_t value) { switch (tree_kind(value)) { case T_LITERAL: switch (tree_subkind(value)) { case L_INT: tb_printf(tb, "%"PRIi64, tree_ival(value)); break; case L_REAL: tb_printf(tb, "%lf", tree_dval(value)); break; case L_PHYSICAL: tb_printf(tb, "%"PRIi64" %s", tree_ival(value), istr(tree_ident(value))); break; } break; case T_STRING: { tb_printf(tb, "\""); const int nchars = tree_chars(value); for (int i = 0; i < nchars; i++) tb_append(tb, ident_char(tree_ident(tree_char(value, i)), 1)); tb_printf(tb, "\""); } break; case T_AGGREGATE: { tb_append(tb, '('); const int nassocs = tree_assocs(value); for (int i = 0; i < nassocs; i++) { if (i > 0) tb_cat(tb, ", "); elab_write_generic(tb, tree_value(tree_assoc(value, i))); } tb_append(tb, ')'); } break; case T_REF: if (is_subprogram(tree_ref(value))) tb_printf(tb, "%s", type_pp(tree_type(value))); else tb_printf(tb, "%s", istr(tree_ident(value))); break; case T_TYPE_CONV: case T_QUALIFIED: elab_write_generic(tb, tree_value(value)); break; case T_TYPE_REF: tb_printf(tb, "%s", type_pp(tree_type(value))); break; case T_OPEN: tb_cat(tb, "OPEN"); break; default: tb_printf(tb, "..."); DEBUG_ONLY(tb_cat(tb, tree_kind_str(tree_kind(value)))); } } static void elab_hint_fn(diag_t *d, void *arg) { tree_t t = arg; diag_hint(d, tree_loc(t), "while elaborating instance %s", istr(tree_ident(t))); tree_t unit = tree_ref(t); const tree_kind_t kind = tree_kind(unit); if (kind == T_CONFIGURATION || kind == T_ARCH) unit = tree_primary(unit); const int ngenerics = tree_genmaps(t); for (int i = 0; i < ngenerics; i++) { tree_t p = tree_genmap(t, i); ident_t name = NULL; switch (tree_subkind(p)) { case P_POS: name = tree_ident(tree_generic(unit, tree_pos(p))); break; case P_NAMED: name = tree_ident(tree_name(p)); break; default: continue; } LOCAL_TEXT_BUF tb = tb_new(); elab_write_generic(tb, tree_value(p)); diag_hint(d, NULL, "generic %s => %s", istr(name), tb_get(tb)); } } static void elab_ports(tree_t entity, tree_t bind, const elab_ctx_t *ctx) { const int nports = tree_ports(entity); const int nparams = tree_params(bind); bool have_named = false; for (int i = 0; i < nports; i++) { tree_t p = tree_port(entity, i), map = NULL; ident_t pname = tree_ident(p); if (i < nparams && !have_named) { tree_t m = tree_param(bind, i); if (tree_subkind(m) == P_POS) { assert(tree_pos(m) == i); tree_add_param(ctx->out, m); map = m; } } if (map == NULL) { for (int j = 0; j < nparams; j++) { tree_t m = tree_param(bind, j); if (tree_subkind(m) == P_NAMED) { tree_t name = tree_name(m), ref; bool is_conv = false; switch (tree_kind(name)) { case T_TYPE_CONV: case T_CONV_FUNC: is_conv = true; ref = name_to_ref(tree_value(name)); break; default: ref = name_to_ref(name); break; } assert(ref != NULL); if (tree_ident(ref) != pname) continue; map = tree_new(T_PARAM); tree_set_loc(map, tree_loc(m)); tree_set_value(map, tree_value(m)); tree_add_param(ctx->out, map); if (!have_named && !is_conv && ref == name) { tree_set_subkind(map, P_POS); tree_set_pos(map, i); break; } else { tree_set_subkind(map, P_NAMED); tree_set_name(map, change_ref(tree_name(m), p)); have_named = true; } } } } if (map == NULL) { map = tree_new(T_PARAM); tree_set_loc(map, tree_loc(p)); if (have_named) { tree_set_subkind(map, P_NAMED); tree_set_name(map, make_ref(p)); } else { tree_set_subkind(map, P_POS); tree_set_pos(map, i); } tree_t open = tree_new(T_OPEN); tree_set_type(open, tree_type(p)); tree_set_loc(open, tree_loc(p)); tree_set_value(map, open); tree_add_param(ctx->out, map); } tree_add_port(ctx->out, p); } } static tree_t elab_parse_generic_string(tree_t generic, const char *str) { type_t type = tree_type(generic); parsed_value_t value; if (!parse_value(type, str, &value)) fatal("failed to parse \"%s\" as type %s for generic %s", str, type_pp(type), istr(tree_ident(generic))); if (type_is_enum(type)) { type_t base = type_base_recur(type); tree_t lit = type_enum_literal(base, value.integer); tree_t result = tree_new(T_REF); tree_set_type(result, type); tree_set_ident(result, ident_new(str)); tree_set_ref(result, lit); tree_set_loc(result, tree_loc(generic)); return result; } else if (type_is_integer(type)) { tree_t result = tree_new(T_LITERAL); tree_set_subkind(result, L_INT); tree_set_type(result, type); tree_set_ival(result, value.integer); tree_set_loc(result, tree_loc(generic)); return result; } else if (type_is_real(type)) { tree_t result = tree_new(T_LITERAL); tree_set_subkind(result, L_REAL); tree_set_type(result, type); tree_set_dval(result, value.real); tree_set_loc(result, tree_loc(generic)); return result; } else if (type_is_physical(type)) { tree_t result = tree_new(T_LITERAL); tree_set_subkind(result, L_PHYSICAL); tree_set_type(result, type); tree_set_ival(result, value.integer); tree_set_loc(result, tree_loc(generic)); return result; } else if (type_is_character_array(type)) { tree_t t = tree_new(T_STRING); tree_set_loc(t, tree_loc(generic)); type_t elem = type_base_recur(type_elem(type)); for (int i = 0; i < value.enums->count; i++) { tree_t lit = type_enum_literal(elem, value.enums->values[i]); tree_t ref = tree_new(T_REF); tree_set_ident(ref, tree_ident(lit)); tree_set_ref(ref, lit); tree_add_char(t, ref); } free(value.enums); tree_set_type(t, subtype_for_string(t, type)); return t; } else fatal("cannot override generic %s of type %s", istr(tree_ident(generic)), type_pp(type)); } static tree_t elab_find_generic_override(tree_t g, const elab_ctx_t *ctx) { if (generic_override == NULL) return NULL; ident_t qual = tree_ident(g); for (const elab_ctx_t *e = ctx; e->inst; e = e->parent) qual = ident_prefix(tree_ident(e->inst), qual, '.'); generic_list_t **it, *tmp; for (it = &generic_override; *it && (*it)->name != qual; it = &((*it)->next)) ; if (*it == NULL) return NULL; tree_t value = elab_parse_generic_string(g, (*it)->value); *it = (tmp = (*it))->next; free(tmp->value); free(tmp); return value; } static void elab_generics(tree_t entity, tree_t bind, elab_ctx_t *ctx) { const int ngenerics = tree_generics(entity); const int ngenmaps = tree_genmaps(bind); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(entity, i); tree_add_generic(ctx->out, g); tree_t map = NULL; if (i < ngenmaps) { map = tree_genmap(bind, i); assert(tree_subkind(map) == P_POS); assert(tree_pos(map) == i); } else if (tree_has_value(g)) { map = tree_new(T_PARAM); tree_set_loc(map, tree_loc(g)); tree_set_subkind(map, P_POS); tree_set_pos(map, i); tree_set_value(map, tree_value(g)); } tree_t override = elab_find_generic_override(g, ctx); if (override != NULL) { map = tree_new(T_PARAM); tree_set_subkind(map, P_POS); tree_set_pos(map, i); tree_set_value(map, override); } if (map == NULL) { error_at(tree_loc(bind), "missing value for generic %s with no " "default", istr(tree_ident(g))); continue; } tree_t value = tree_value(map); switch (tree_kind(value)) { case T_REF: if (tree_kind(tree_ref(value)) == T_ENUM_LIT) break; else if (tree_class(g) == C_PACKAGE) break; // Fall-through case T_ARRAY_REF: case T_RECORD_REF: case T_FCALL: if (type_is_scalar(tree_type(value))) { void *context = NULL; if (ctx->parent->scope->kind != SCOPE_ROOT) context = *mptr_get(ctx->parent->scope->privdata); tree_t folded = eval_try_fold(ctx->jit, value, ctx->registry, ctx->parent->lowered, context); if (folded != value) { tree_t m = tree_new(T_PARAM); tree_set_loc(m, tree_loc(map)); tree_set_subkind(m, P_POS); tree_set_pos(m, tree_pos(map)); tree_set_value(m, (value = folded)); map = m; } } break; default: break; } tree_add_genmap(ctx->out, map); if (is_literal(value)) { // These values can be safely substituted for all references to // the generic name if (ctx->generics == NULL) ctx->generics = hash_new(ngenerics * 2); hash_put(ctx->generics, g, value); } } } static void elab_map_generic_type(type_t generic, type_t actual, hash_t *map) { assert(type_kind(generic) == T_GENERIC); switch (type_subkind(generic)) { case GTYPE_ARRAY: { type_t gelem = type_elem(generic); if (type_kind(gelem) == T_GENERIC && !type_has_ident(gelem)) elab_map_generic_type(gelem, type_elem(actual), map); const int ndims = type_indexes(generic); for (int i = 0; i < ndims; i++) { type_t index = type_index(generic, i); if (type_kind(index) == T_GENERIC && !type_has_ident(index)) elab_map_generic_type(index, index_type_of(actual, i), map); } } break; } hash_put(map, generic, actual); } static void elab_instance_fixup(tree_t arch, const elab_ctx_t *ctx) { if (standard() < STD_08) return; hash_t *map = NULL; const int ngenerics = tree_generics(ctx->out); assert(tree_genmaps(ctx->out) == ngenerics); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(ctx->out, i); const class_t class = tree_class(g); if (class == C_CONSTANT) continue; else if (map == NULL) map = hash_new(64); tree_t value = tree_value(tree_genmap(ctx->out, i)); switch (class) { case C_TYPE: elab_map_generic_type(tree_type(g), tree_type(value), map); break; case C_PACKAGE: { tree_t formal = tree_ref(tree_value(g)); tree_t actual = tree_ref(value); const int ndecls = tree_decls(formal); for (int i = 0; i < ndecls; i++) { tree_t gd = tree_decl(formal, i); tree_t ad = tree_decl(actual, i); assert(tree_kind(gd) == tree_kind(ad)); hash_put(map, gd, ad); if (is_type_decl(gd)) hash_put(map, tree_type(gd), tree_type(ad)); } const int ngenerics = tree_generics(formal); for (int i = 0; i < ngenerics; i++) { tree_t fg = tree_generic(formal, i); tree_t ag = tree_generic(actual, i); switch (tree_class(fg)) { case C_FUNCTION: case C_PROCEDURE: { // Get the actual subprogram from the generic map assert(ngenerics == tree_genmaps(actual)); tree_t ref = tree_value(tree_genmap(actual, i)); assert(tree_kind(ref) == T_REF); hash_put(map, fg, tree_ref(ref)); } break; case C_TYPE: hash_put(map, tree_type(fg), tree_type(ag)); break; case C_PACKAGE: // TODO: this should be processed recursively default: hash_put(map, fg, ag); break; } } hash_put(map, g, actual); } break; case C_FUNCTION: case C_PROCEDURE: hash_put(map, g, tree_ref(value)); break; default: break; } } if (map == NULL) return; instance_fixup(arch, map); hash_free(map); } static void elab_context(tree_t t) { const int nctx = tree_contexts(t); for (int i = 0; i < nctx; i++) { // Make sure any referenced libraries are loaded to allow synth // binding to search for entities in them tree_t c = tree_context(t, i); if (tree_kind(c) == T_LIBRARY) lib_require(tree_ident(c)); } } static void elab_inherit_context(elab_ctx_t *ctx, const elab_ctx_t *parent) { ctx->parent = parent; ctx->jit = parent->jit; ctx->registry = parent->registry; ctx->mir = parent->mir; ctx->root = parent->root; ctx->dotted = ctx->dotted ?: parent->dotted; ctx->library = ctx->library ?: parent->library; ctx->out = ctx->out ?: parent->out; ctx->cover = parent->cover; ctx->sdf = parent->sdf; ctx->inst = ctx->inst ?: parent->inst; ctx->modcache = parent->modcache; ctx->depth = parent->depth + 1; ctx->model = parent->model; } static driver_set_t *elab_driver_set(const elab_ctx_t *ctx) { if (ctx->drivers != NULL) return ctx->drivers; else if (ctx->parent != NULL) return elab_driver_set(ctx->parent); else return NULL; } static void elab_lower(tree_t b, const elab_instance_t *ei, elab_ctx_t *ctx) { if (ei != NULL) vlog_lower_block(ctx->mir, ctx->parent->dotted, b); else ctx->lowered = lower_instance(ctx->registry, ctx->parent->lowered, elab_driver_set(ctx), ctx->cover, b); if (ctx->inst != NULL) diag_add_hint_fn(elab_hint_fn, ctx->inst); ctx->scope = create_scope(ctx->model, b, ctx->parent->scope); if (ctx->inst != NULL) diag_remove_hint_fn(elab_hint_fn); } static void elab_verilog_module(tree_t bind, ident_t label, const elab_instance_t *ei, const elab_ctx_t *ctx) { ident_t ndotted = ident_prefix(ctx->dotted, label, '.'); elab_ctx_t new_ctx = { .dotted = ndotted, }; elab_inherit_context(&new_ctx, ctx); tree_t b = tree_new(T_BLOCK); tree_set_ident(b, label); tree_set_loc(b, tree_loc(ctx->out)); tree_add_stmt(ctx->out, b); new_ctx.out = b; elab_push_scope(ei->wrap, &new_ctx); if (bind != NULL) elab_ports(ei->block, bind, &new_ctx); if (error_count() == 0) elab_decls(ei->block, &new_ctx); if (error_count() == 0) { new_ctx.drivers = find_drivers(ei->block); elab_lower(b, ei, &new_ctx); } if (error_count() == 0) elab_verilog_stmts(ei->body, &new_ctx); elab_pop_scope(&new_ctx); } static void elab_verilog_instance_list(vlog_node_t v, const elab_ctx_t *ctx) { ident_t modname = vlog_ident(v); ident_t libname = lib_name(ctx->library); text_buf_t *tb = tb_new(); tb_istr(tb, libname); tb_append(tb, '.'); tb_istr(tb, modname); tb_upcase(tb); ident_t qual = ident_new(tb_get(tb)); object_t *obj = lib_get_generic(ctx->library, qual, NULL); if (obj == NULL) { error_at(vlog_loc(v), "module %s not found in library %s", istr(modname), istr(libname)); return; } vlog_node_t mod = vlog_from_object(obj); if (mod == NULL) { error_at(&obj->loc, "unit %s is not a Verilog module", istr(qual)); return; } else if (vlog_ident2(mod) != modname) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(v)); diag_printf(d, "name of Verilog module %s in library unit %s " "does not match name %s in module instance %s", istr(vlog_ident2(mod)), istr(qual), istr(modname), istr(vlog_ident(vlog_stmt(v, 0)))); diag_hint(d, NULL, "this tool does not preserve case sensitivity " "in module names"); diag_emit(d); return; } elab_instance_t *ei = elab_new_instance(mod, v, ctx); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { vlog_node_t inst = vlog_stmt(v, i); assert(vlog_kind(inst) == V_MOD_INST); tree_t bind = elab_verilog_binding(inst, ei, ctx); if (bind != NULL) elab_verilog_module(bind, vlog_ident(inst), ei, ctx); } } static void elab_verilog_stmts(vlog_node_t v, const elab_ctx_t *ctx) { const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { vlog_node_t s = vlog_stmt(v, i); const vlog_kind_t kind = vlog_kind(s); switch (kind) { case V_INST_LIST: elab_verilog_instance_list(s, ctx); break; case V_INITIAL: case V_ALWAYS: case V_ASSIGN: case V_UDP_TABLE: case V_GATE_INST: { ident_t name = vlog_ident(s); ident_t sym = ident_prefix(ctx->dotted, name, '.'); tree_t w = tree_new(T_VERILOG); tree_set_ident(w, name); tree_set_loc(w, vlog_loc(s)); tree_set_vlog(w, s); tree_add_stmt(ctx->out, w); if (kind == V_UDP_TABLE) mir_defer(ctx->mir, sym, ctx->dotted, MIR_UNIT_PROCESS, vlog_lower_udp, vlog_to_object(v)); else mir_defer(ctx->mir, sym, ctx->dotted, MIR_UNIT_PROCESS, vlog_lower_deferred, vlog_to_object(s)); } break; case V_BLOCK: // TODO: should create a block in hierarchy elab_verilog_stmts(s, ctx); break; case V_IF_GENERATE: error_at(vlog_loc(s), "if-generate construct could not be " "evaluated at elaboration time"); break; default: fatal_at(vlog_loc(s), "sorry, this Verilog statement is not " "currently supported"); } } } static void elab_architecture(tree_t bind, tree_t arch, tree_t config, const elab_ctx_t *ctx) { tree_t inst = NULL; ident_t label; switch (tree_kind(bind)) { case T_BINDING: label = ident_rfrom(tree_ident(tree_primary(arch)), '.'); break; case T_INSTANCE: label = tree_ident(bind); inst = bind; break; default: fatal_trace("unexpected binding kind %s in elab_architecture", tree_kind_str(tree_kind(bind))); } ident_t ndotted = ident_prefix(ctx->dotted, label, '.'); elab_ctx_t new_ctx = { .dotted = ndotted, .inst = inst, }; elab_inherit_context(&new_ctx, ctx); tree_t b = tree_new(T_BLOCK); tree_set_ident(b, label); tree_set_loc(b, tree_loc(bind)); tree_add_stmt(ctx->out, b); new_ctx.out = b; new_ctx.library = lib_require(ident_until(tree_ident(arch), '.')); elab_subprogram_prefix(arch, &new_ctx); tree_t arch_copy; if (config != NULL) { assert(tree_ref(config) == arch); new_ctx.config = elab_copy(config, &new_ctx); arch_copy = tree_ref(new_ctx.config); } else arch_copy = elab_copy(arch, &new_ctx); tree_t entity = tree_primary(arch_copy); elab_push_scope(arch, &new_ctx); elab_context(entity); elab_context(arch_copy); elab_generics(entity, bind, &new_ctx); elab_instance_fixup(arch_copy, &new_ctx); simplify_global(arch_copy, new_ctx.generics, ctx->jit, ctx->registry, ctx->mir); elab_ports(entity, bind, &new_ctx); elab_decls(entity, &new_ctx); if (error_count() == 0) elab_decls(arch_copy, &new_ctx); if (error_count() == 0) { new_ctx.drivers = find_drivers(arch_copy); elab_lower(b, NULL, &new_ctx); elab_stmts(entity, &new_ctx); elab_stmts(arch_copy, &new_ctx); } elab_pop_scope(&new_ctx); } static tree_t elab_find_spec(tree_t inst, const elab_ctx_t *ctx) { if (tree_has_spec(inst)) return tree_spec(inst); else if (ctx->config == NULL) return NULL; assert(tree_kind(ctx->config) == T_BLOCK_CONFIG); tree_t spec = NULL; const int ndecls = tree_decls(ctx->config); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(ctx->config, i); if (tree_kind(d) != T_SPEC) continue; else if (tree_ident2(d) != tree_ident2(inst)) continue; bool apply = false; if (tree_has_ident(d)) { ident_t match = tree_ident(d); apply = (match == tree_ident(inst) || match == well_known(W_ALL)); } else if (spec == NULL) apply = true; if (apply) spec = d; } return spec; } static void elab_component(tree_t inst, tree_t comp, const elab_ctx_t *ctx) { tree_t arch = NULL, config = NULL, bind = NULL, spec; if ((spec = elab_find_spec(inst, ctx)) && tree_has_value(spec)) { bind = tree_value(spec); assert(tree_kind(bind) == T_BINDING); const int ndecls = tree_decls(spec); if (ndecls == 0) { tree_t unit = tree_ref(bind); switch (tree_kind(unit)) { case T_ENTITY: arch = elab_pick_arch(tree_loc(inst), unit, ctx); break; case T_CONFIGURATION: config = tree_decl(unit, 0); assert(tree_kind(config) == T_BLOCK_CONFIG); arch = tree_ref(config); break; case T_ARCH: arch = unit; break; default: fatal_at(tree_loc(bind), "sorry, this form of binding indication " "is not supported yet"); } } else { assert(ndecls == 1); config = tree_decl(spec, 0); assert(tree_kind(config) == T_BLOCK_CONFIG); arch = tree_ref(config); } } else if (spec == NULL && (bind = elab_default_binding(inst, ctx))) arch = tree_ref(bind); // Must create a unique instance if type or package generics present const int ngenerics = tree_generics(comp); for (int i = 0; i < ngenerics; i++) { if (tree_class(tree_generic(comp, i)) != C_CONSTANT) { tree_t roots[] = { comp, bind }; new_instance(roots, bind ? 2 : 1, ctx->dotted, ctx->prefix, ARRAY_LEN(ctx->prefix)); comp = roots[0]; bind = roots[1]; break; } } ident_t ndotted = ident_prefix(ctx->dotted, tree_ident(inst), '.'); elab_ctx_t new_ctx = { .dotted = ndotted, .inst = inst, }; elab_inherit_context(&new_ctx, ctx); tree_t b = tree_new(T_BLOCK); tree_set_ident(b, tree_ident(inst)); tree_set_loc(b, tree_loc(inst)); tree_add_stmt(ctx->out, b); new_ctx.out = b; elab_push_scope(comp, &new_ctx); elab_generics(comp, inst, &new_ctx); if (bind != NULL) elab_instance_fixup(bind, &new_ctx); elab_instance_fixup(comp, &new_ctx); elab_ports(comp, inst, &new_ctx); if (bind != NULL && tree_kind(arch) != T_VERILOG) new_ctx.drivers = find_drivers(bind); if (error_count() == 0) elab_lower(b, NULL, &new_ctx); if (error_count() > 0 || arch == NULL) ; // Unbound architecture else if (tree_kind(arch) == T_VERILOG) { vlog_node_t mod = tree_vlog(arch); vlog_node_t stmt = vlog_new(V_MOD_INST); vlog_set_ident(stmt, vlog_ident2(mod)); vlog_node_t list = vlog_new(V_INST_LIST); vlog_set_ident(list, vlog_ident2(mod)); vlog_add_stmt(list, stmt); const int ngenmaps = tree_genmaps(bind); for (int i = 0; i < ngenmaps; i++) { tree_t decl = tree_ref(tree_value(tree_genmap(bind, i))); assert(tree_kind(decl) == T_GENERIC_DECL); tree_t map = hash_get(new_ctx.generics, decl); if (map == NULL) fatal_at(tree_loc(inst), "cannot get value of generic %s", istr(tree_ident(decl))); const int64_t ival = assume_int(map); // TODO: have some better way of constructing these char buf[64]; checked_sprintf(buf, sizeof(buf), "%lld", llabs(ival)); number_t n = number_new(buf, NULL); if (ival < 0) n = number_negate(n); vlog_node_t num = vlog_new(V_NUMBER); vlog_set_number(num, n); vlog_node_t pa = vlog_new(V_PARAM_ASSIGN); vlog_set_value(pa, num); vlog_add_param(list, pa); } elab_instance_t *ei = elab_new_instance(mod, list, &new_ctx); elab_verilog_module(bind, vlog_ident2(mod), ei, &new_ctx); } else elab_architecture(bind, arch, config, &new_ctx); elab_pop_scope(&new_ctx); } static tree_t elab_block_config(tree_t block, const elab_ctx_t *ctx) { if (ctx->config == NULL) return NULL; ident_t label = tree_ident(block); const int ndecls = tree_decls(ctx->config); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(ctx->config, i); if (tree_kind(d) != T_BLOCK_CONFIG) continue; else if (tree_ident(d) == label) return d; } return NULL; } static void elab_instance(tree_t t, const elab_ctx_t *ctx) { if (ctx->depth == MAX_DEPTH) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "maximum instantiation depth of %d reached", MAX_DEPTH); diag_hint(d, NULL, "this is likely caused by unbounded recursion"); diag_emit(d); return; } tree_t ref = tree_ref(t); switch (tree_kind(ref)) { case T_ENTITY: { tree_t arch = elab_pick_arch(tree_loc(t), ref, ctx); elab_architecture(t, arch, NULL, ctx); } break; case T_ARCH: elab_architecture(t, ref, NULL, ctx); break; case T_COMPONENT: elab_component(t, ref, ctx); break; case T_CONFIGURATION: { tree_t config = tree_decl(ref, 0); assert(tree_kind(config) == T_BLOCK_CONFIG); tree_t arch = tree_ref(config); elab_architecture(t, arch, config, ctx); } break; default: fatal_trace("unexpected tree kind %s in elab_instance", tree_kind_str(tree_kind(ref))); } } static void elab_decls(tree_t t, const elab_ctx_t *ctx) { const int ndecls = tree_decls(t); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(t, i); switch (tree_kind(d)) { case T_SIGNAL_DECL: case T_IMPLICIT_SIGNAL: case T_ALIAS: case T_FILE_DECL: case T_VAR_DECL: case T_CONST_DECL: case T_FUNC_BODY: case T_PROC_BODY: case T_FUNC_INST: case T_PROC_INST: case T_PROT_DECL: case T_PROT_BODY: case T_TYPE_DECL: case T_SUBTYPE_DECL: case T_PACK_BODY: case T_PACKAGE: case T_PACK_INST: case T_PSL_DECL: case T_ATTR_SPEC: case T_VERILOG: tree_add_decl(ctx->out, d); break; case T_FUNC_DECL: case T_PROC_DECL: if (!is_open_coded_builtin(tree_subkind(d))) tree_add_decl(ctx->out, d); break; default: break; } } } static void elab_push_scope(tree_t t, elab_ctx_t *ctx) { tree_t h = tree_new(T_HIER); tree_set_loc(h, tree_loc(t)); tree_set_subkind(h, tree_kind(t)); tree_set_ref(h, t); tree_set_ident(h, ctx->dotted); tree_set_ident2(h, ctx->dotted); tree_add_decl(ctx->out, h); } static void elab_pop_scope(elab_ctx_t *ctx) { if (ctx->generics != NULL) hash_free(ctx->generics); if (ctx->drivers != NULL) free_drivers(ctx->drivers); if (ctx->lowered != NULL) unit_registry_finalise(ctx->registry, ctx->lowered); } static inline tree_t elab_eval_expr(tree_t t, const elab_ctx_t *ctx) { void *context = *mptr_get(ctx->scope->privdata); return eval_must_fold(ctx->jit, t, ctx->registry, ctx->lowered, context); } static bool elab_copy_genvar_cb(tree_t t, void *ctx) { tree_t genvar = ctx; return tree_kind(t) == T_REF && tree_ref(t) == genvar; } static void elab_generate_range(tree_t r, int64_t *low, int64_t *high, const elab_ctx_t *ctx) { if (tree_subkind(r) == RANGE_EXPR) { tree_t value = tree_value(r); assert(tree_kind(value) == T_ATTR_REF); tree_t tmp = tree_new(T_ATTR_REF); tree_set_name(tmp, tree_name(value)); tree_set_type(tmp, tree_type(r)); tree_set_subkind(tmp, ATTR_LOW); tree_t tlow = elab_eval_expr(tmp, ctx); if (folded_int(tlow, low)) { tree_set_subkind(tmp, ATTR_HIGH); tree_t thigh = elab_eval_expr(tmp, ctx); if (folded_int(thigh, high)) return; } error_at(tree_loc(r), "generate range is not static"); *low = *high = 0; } else if (!folded_bounds(r, low, high)) { tree_t left = elab_eval_expr(tree_left(r), ctx); tree_t right = elab_eval_expr(tree_right(r), ctx); int64_t ileft, iright; if (folded_int(left, &ileft) && folded_int(right, &iright)) { const bool asc = (tree_subkind(r) == RANGE_TO); *low = asc ? ileft : iright; *high = asc ? iright : ileft; } else { error_at(tree_loc(r), "generate range is not static"); *low = *high = 0; } } } static void elab_for_generate(tree_t t, const elab_ctx_t *ctx) { int64_t low, high; elab_generate_range(tree_range(t, 0), &low, &high, ctx); tree_t g = tree_decl(t, 0); assert(tree_kind(g) == T_GENERIC_DECL); ident_t base = tree_ident(t); for (int64_t i = low; i <= high; i++) { LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, istr(base)); tb_printf(tb, "(%"PRIi64")", i); ident_t id = ident_new(tb_get(tb)); tree_t b = tree_new(T_BLOCK); tree_set_loc(b, tree_loc(t)); tree_set_ident(b, id); tree_set_loc(b, tree_loc(t)); tree_add_stmt(ctx->out, b); tree_t map = tree_new(T_PARAM); tree_set_subkind(map, P_POS); tree_set_loc(map, tree_loc(g)); tree_set_value(map, get_int_lit(g, NULL, i)); tree_add_generic(b, g); tree_add_genmap(b, map); ident_t ndotted = ident_prefix(ctx->dotted, id, '.'); elab_ctx_t new_ctx = { .out = b, .dotted = ndotted, .generics = hash_new(16), .config = elab_block_config(t, ctx), }; elab_inherit_context(&new_ctx, ctx); new_ctx.prefix[0] = ident_prefix(ctx->dotted, base, '.'); tree_t roots[] = { t }; copy_with_renaming(roots, 1, elab_copy_genvar_cb, NULL, g, ndotted, new_ctx.prefix, ARRAY_LEN(new_ctx.prefix)); tree_t copy = roots[0]; elab_push_scope(t, &new_ctx); hash_put(new_ctx.generics, g, tree_value(map)); simplify_global(copy, new_ctx.generics, new_ctx.jit, new_ctx.registry, new_ctx.mir); new_ctx.drivers = find_drivers(copy); if (error_count() == 0) elab_decls(copy, &new_ctx); if (error_count() == 0) { elab_lower(b, NULL, &new_ctx); elab_stmts(copy, &new_ctx); } elab_pop_scope(&new_ctx); } } static bool elab_generate_test(tree_t value, const elab_ctx_t *ctx) { bool test; if (folded_bool(value, &test)) return test; tree_t folded = elab_eval_expr(value, ctx); if (folded_bool(folded, &test)) return test; error_at(tree_loc(value), "generate expression is not static"); return false; } static void elab_if_generate(tree_t t, const elab_ctx_t *ctx) { const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) { tree_t cond = tree_cond(t, i); if (!tree_has_value(cond) || elab_generate_test(tree_value(cond), ctx)) { tree_t b = tree_new(T_BLOCK); tree_set_loc(b, tree_loc(cond)); tree_set_ident(b, tree_ident(cond)); tree_add_stmt(ctx->out, b); ident_t name = tree_ident(cond); ident_t ndotted = ident_prefix(ctx->dotted, name, '.'); elab_ctx_t new_ctx = { .out = b, .dotted = ndotted, .config = elab_block_config(cond, ctx), }; elab_inherit_context(&new_ctx, ctx); elab_push_scope(t, &new_ctx); elab_decls(cond, &new_ctx); new_ctx.drivers = find_drivers(cond); if (error_count() == 0) { elab_lower(b, NULL, &new_ctx); elab_stmts(cond, &new_ctx); } elab_pop_scope(&new_ctx); return; } } } static void elab_case_generate(tree_t t, const elab_ctx_t *ctx) { void *context = *mptr_get(ctx->scope->privdata); tree_t chosen = eval_case(ctx->jit, t, ctx->lowered, context); if (chosen == NULL) return; ident_t id = tree_has_ident(chosen) ? tree_ident(chosen) : tree_ident(t); tree_t b = tree_new(T_BLOCK); tree_set_loc(b, tree_loc(chosen)); tree_set_ident(b, id); tree_add_stmt(ctx->out, b); ident_t ndotted = ident_prefix(ctx->dotted, id, '.'); elab_ctx_t new_ctx = { .out = b, .dotted = ndotted, }; elab_inherit_context(&new_ctx, ctx); elab_push_scope(t, &new_ctx); elab_decls(chosen, &new_ctx); new_ctx.drivers = find_drivers(chosen); if (error_count() == 0) { elab_lower(b, NULL, &new_ctx); elab_stmts(chosen, &new_ctx); } elab_pop_scope(&new_ctx); } static void elab_process(tree_t t, const elab_ctx_t *ctx) { if (error_count() == 0) lower_process(ctx->lowered, t, elab_driver_set(ctx)); tree_add_stmt(ctx->out, t); } static void elab_psl(tree_t t, const elab_ctx_t *ctx) { if (error_count() == 0) psl_lower_directive(ctx->registry, ctx->lowered, ctx->cover, t); tree_add_stmt(ctx->out, t); } static void elab_stmts(tree_t t, const elab_ctx_t *ctx) { const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(t, i); switch (tree_kind(s)) { case T_INSTANCE: elab_instance(s, ctx); break; case T_BLOCK: elab_block(s, ctx); break; case T_FOR_GENERATE: elab_for_generate(s, ctx); break; case T_IF_GENERATE: elab_if_generate(s, ctx); break; case T_CASE_GENERATE: elab_case_generate(s, ctx); break; case T_PROCESS: elab_process(s, ctx); break; case T_PSL_DIRECT: elab_psl(s, ctx); break; default: fatal_trace("unexpected statement %s", tree_kind_str(tree_kind(s))); } } } static void elab_block(tree_t t, const elab_ctx_t *ctx) { ident_t id = tree_ident(t); tree_t b = tree_new(T_BLOCK); tree_set_ident(b, id); tree_set_loc(b, tree_loc(t)); tree_add_stmt(ctx->out, b); ident_t ndotted = ident_prefix(ctx->dotted, id, '.'); elab_ctx_t new_ctx = { .out = b, .dotted = ndotted, .config = elab_block_config(t, ctx), }; elab_inherit_context(&new_ctx, ctx); const int base_errors = error_count(); elab_push_scope(t, &new_ctx); elab_generics(t, t, &new_ctx); elab_ports(t, t, &new_ctx); elab_decls(t, &new_ctx); if (error_count() == base_errors) { elab_lower(b, NULL, &new_ctx); elab_stmts(t, &new_ctx); } elab_pop_scope(&new_ctx); } static tree_t elab_top_level_binding(tree_t arch, const elab_ctx_t *ctx) { tree_t bind = tree_new(T_BINDING); tree_set_ident(bind, tree_ident(arch)); tree_set_loc(bind, tree_loc(arch)); tree_set_ref(bind, arch); tree_set_class(bind, C_ENTITY); tree_t entity = tree_primary(arch); const int ngenerics = tree_generics(entity); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(entity, i); ident_t name = tree_ident(g); if (tree_flags(g) & TREE_F_PREDEFINED) continue; // Predefined generic subprograms else if (tree_class(g) != C_CONSTANT) { error_at(tree_loc(g), "only constant top-level generics are " "supported"); continue; } tree_t value = elab_find_generic_override(g, ctx); if (value == NULL && tree_has_value(g)) value = tree_value(g); else if (value == NULL) { error_at(tree_loc(g), "generic %s of top-level entity must have " "default value or be specified using -gNAME=VALUE", istr(name)); continue; } tree_t map = tree_new(T_PARAM); tree_set_subkind(map, P_POS); tree_set_pos(map, i); tree_set_value(map, value); tree_add_genmap(bind, map); } const int nports = tree_ports(entity); for (int i = 0; i < nports; i++) { tree_t p = tree_port(entity, i); tree_t m = tree_new(T_PARAM); tree_set_subkind(m, P_POS); tree_set_pos(m, i); if (tree_subkind(p) == PORT_IN && tree_has_value(p)) tree_set_value(m, tree_value(p)); else { type_t type = tree_type(p); if (type_is_unconstrained(type)) error_at(tree_loc(p), "unconnected top-level port %s cannot have " "unconstrained type %s", istr(tree_ident(p)), type_pp(type)); tree_t open = tree_new(T_OPEN); tree_set_type(open, type); tree_set_loc(open, tree_loc(p)); tree_set_value(m, open); } tree_add_param(bind, m); } return bind; } void elab_set_generic(const char *name, const char *value) { ident_t id = ident_new(name); for (generic_list_t *it = generic_override; it != NULL; it = it->next) { if (it->name == id) fatal("generic %s already has value '%s'", name, it->value); } generic_list_t *new = xmalloc(sizeof(generic_list_t)); new->name = id; new->value = xstrdup(value); new->next = generic_override; generic_override = new; } static void elab_vhdl_root_cb(void *arg) { elab_ctx_t *ctx = arg; tree_t vhdl = tree_from_object(ctx->root); assert(vhdl != NULL); tree_t arch, config = NULL; switch (tree_kind(vhdl)) { case T_ENTITY: arch = elab_pick_arch(&ctx->root->loc, vhdl, ctx); break; case T_ARCH: arch = vhdl; break; case T_CONFIGURATION: config = tree_decl(vhdl, 0); assert(tree_kind(config) == T_BLOCK_CONFIG); arch = tree_ref(config); break; default: fatal("%s is not a suitable top-level unit", istr(tree_ident(vhdl))); } tree_t bind = elab_top_level_binding(arch, ctx); if (error_count() == 0) elab_architecture(bind, arch, config, ctx); } static void elab_verilog_root_cb(void *arg) { elab_ctx_t *ctx = arg; vlog_node_t vlog = vlog_from_object(ctx->root); assert(vlog != NULL); ident_t label = vlog_ident2(vlog); vlog_node_t stmt = vlog_new(V_MOD_INST); vlog_set_ident(stmt, label); vlog_node_t list = vlog_new(V_INST_LIST); vlog_set_ident(list, label); vlog_add_stmt(list, stmt); elab_instance_t *ei = elab_new_instance(vlog, list, ctx); elab_verilog_module(NULL, label, ei, ctx); } tree_t elab(object_t *top, jit_t *jit, unit_registry_t *ur, mir_context_t *mc, cover_data_t *cover, sdf_file_t *sdf, rt_model_t *m) { make_new_arena(); ident_t name = NULL; tree_t vhdl = tree_from_object(top); if (vhdl != NULL) name = ident_prefix(tree_ident(vhdl), well_known(W_ELAB), '.'); vlog_node_t vlog = vlog_from_object(top); if (vlog != NULL) name = ident_prefix(vlog_ident(vlog), well_known(W_ELAB), '.'); if (vhdl == NULL && vlog == NULL) fatal("top level is not a VHDL design unit or Verilog module"); tree_t e = tree_new(T_ELAB); tree_set_ident(e, name); tree_set_loc(e, &(top->loc)); lib_t work = lib_work(); elab_ctx_t ctx = { .out = e, .root = top, .cover = cover, .library = work, .jit = jit, .sdf = sdf, .registry = ur, .mir = mc, .modcache = hash_new(16), .dotted = lib_name(work), .model = m, .scope = create_scope(m, e, NULL), }; if (vhdl != NULL) call_with_model(m, elab_vhdl_root_cb, &ctx); else call_with_model(m, elab_verilog_root_cb, &ctx); const void *key; void *value; for (hash_iter_t it = HASH_BEGIN; hash_iter(ctx.modcache, &it, &key, &value); ) free(value); hash_free(ctx.modcache); if (error_count() > 0) return NULL; if (opt_get_verbose(OPT_ELAB_VERBOSE, NULL)) dump(e); for (generic_list_t *it = generic_override; it != NULL; it = it->next) warnf("generic value for %s not used", istr(it->name)); ident_t b0_name = tree_ident(tree_stmt(e, 0)); ident_t vu_name = ident_prefix(lib_name(ctx.library), b0_name, '.'); unit_registry_flush(ur, vu_name); freeze_global_arena(); return e; } nvc-r1.17.1/src/eval.c000066400000000000000000000341471504111170000144320ustar00rootroot00000000000000// // Copyright (C) 2013-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "eval.h" #include "hash.h" #include "ident.h" #include "jit/jit-ffi.h" #include "jit/jit.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "option.h" #include "phase.h" #include "rt/assert.h" #include "tree.h" #include "type.h" #include "vcode.h" #include #include #include #include #include #include static const char *eval_expr_name(tree_t expr) { const tree_kind_t kind = tree_kind(expr); if (kind == T_FCALL) return istr(tree_ident(expr)); else return tree_kind_str(kind); } static tree_t eval_value_to_tree(jit_scalar_t value, type_t type, const loc_t *loc) { tree_t tree = NULL; if (type_is_enum(type)) { type_t base = type_base_recur(type); if ((unsigned)value.integer >= type_enum_literals(base)) fatal_at(loc, "enum position %"PRIi64" out of range for type %s", value.integer, type_pp(base)); tree_t lit = type_enum_literal(base, value.integer); tree = tree_new(T_REF); tree_set_ref(tree, lit); tree_set_ident(tree, tree_ident(lit)); } else if (type_is_integer(type)) { tree = tree_new(T_LITERAL); tree_set_subkind(tree, L_INT); tree_set_ival(tree, value.integer); } else if (type_is_real(type)) { tree = tree_new(T_LITERAL); tree_set_subkind(tree, L_REAL); tree_set_dval(tree, value.real); } else if (type_is_physical(type)) { tree = tree_new(T_LITERAL); tree_set_subkind(tree, L_PHYSICAL); tree_set_ival(tree, value.integer); } else fatal_trace("cannot convert 0x%"PRIx64" to %s", value.integer, type_pp(type)); tree_set_type(tree, type); tree_set_loc(tree, loc); return tree; } static void *thunk_result_cb(jit_scalar_t *args, void *user) { tree_t expr = user; type_t type = tree_type(expr); const loc_t *loc = tree_loc(expr); if (type_is_array(type)) { assert(dimension_of(type) == 1); type_t elem = type_elem(type); assert(type_is_scalar(elem)); type_t base = type_base_recur(elem); bool all_chars = true; tree_t *lits LOCAL = NULL; if (type_is_enum(elem)) { const int nlits = type_enum_literals(base); lits = xcalloc_array(nlits, sizeof(tree_t)); } else all_chars = false; range_kind_t dir; int64_t length, ileft, iright; if (!type_const_bounds(type)) { length = ffi_array_length(args[2].integer); dir = ffi_array_dir(args[2].integer); ileft = args[1].integer; iright = ffi_array_right(args[1].integer, args[2].integer); } else { tree_t r = range_of(type, 0); if (!folded_length(r, &length)) fatal_at(loc, "cannot determine static length of array"); dir = tree_subkind(r); ileft = assume_int(tree_left(r)); iright = assume_int(tree_right(r)); } const int bytes = (type_bit_width(elem) + 7) / 8; tree_t *elts LOCAL = xmalloc_array(length, sizeof(tree_t)); for (int i = 0; i < length; i++) { #define UNPACK_VALUE(type) do { \ value.integer = ((type *)args[0].pointer)[i]; \ } while (0); jit_scalar_t value = { .integer = 0 }; FOR_ALL_SIZES(bytes, UNPACK_VALUE); if (lits != NULL) { assert(value.integer >= 0); if (lits[value.integer] == NULL) { tree_t li = type_enum_literal(base, value.integer); lits[value.integer] = make_ref(li); all_chars &= ident_char(tree_ident(li), 0) == '\''; } elts[i] = lits[value.integer]; } else elts[i] = eval_value_to_tree(value, elem, loc); } type_t sub = type_new(T_SUBTYPE); type_set_base(sub, type); type_t index_type = index_type_of(type, 0); tree_t left = NULL, right = NULL; if (type_is_enum(index_type)) { left = get_enum_lit(expr, index_type, ileft); right = get_enum_lit(expr, index_type, iright); } else { left = get_int_lit(expr, index_type, ileft); right = get_int_lit(expr, index_type, iright); } tree_t r = tree_new(T_RANGE); tree_set_subkind(r, dir); tree_set_left(r, left); tree_set_right(r, right); tree_set_loc(r, loc); tree_set_type(r, index_type); tree_t c = tree_new(T_CONSTRAINT); tree_set_subkind(c, C_INDEX); tree_add_range(c, r); tree_set_loc(c, loc); type_set_constraint(sub, c); if (all_chars) { tree_t tree = tree_new(T_STRING); for (int i = 0; i < length; i++) tree_add_char(tree, elts[i]); tree_set_loc(tree, loc); tree_set_type(tree, sub); return tree; } else { tree_t tree = tree_new(T_AGGREGATE); tree_set_type(tree, sub); tree_set_loc(tree, loc); for (int i = 0; i < length; i++) { tree_t a = tree_new(T_ASSOC); tree_set_loc(a, loc); tree_set_subkind(a, A_POS); tree_set_pos(a, i); tree_set_value(a, elts[i]); tree_add_assoc(tree, a); } return tree; } } else return eval_value_to_tree(args[0], tree_type(expr), tree_loc(expr)); } static tree_t eval_do_fold(jit_t *jit, tree_t expr, lower_unit_t *parent, unit_registry_t *registry, void *context) { vcode_unit_t thunk; if (parent != NULL) thunk = lower_thunk_in_context(registry, expr, parent); else thunk = lower_global_thunk(registry, expr); if (thunk == NULL) return expr; const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL); tree_t result = jit_call_thunk(jit, thunk, context, thunk_result_cb, expr); vcode_unit_unref(thunk); thunk = NULL; if (result != NULL) { if (verbose) { LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(result); capture_syntax(NULL); tb_strip(tb); debugf("evaluating %s returned %s", eval_expr_name(expr), tb_get(tb)); } return result; } else if (verbose) { diag_t *d = diag_new(DIAG_DEBUG, tree_loc(expr)); diag_printf(d, "failed to evaluate %s", eval_expr_name(expr)); diag_emit(d); } return expr; } tree_t eval_try_fold(jit_t *jit, tree_t expr, unit_registry_t *registry, lower_unit_t *parent, void *context) { const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL); jit_set_silent(jit, !verbose); tree_t result = eval_do_fold(jit, expr, parent, registry, context); jit_set_silent(jit, false); jit_reset_exit_status(jit); clear_vhdl_assert(); return result; } tree_t eval_must_fold(jit_t *jit, tree_t expr, unit_registry_t *registry, lower_unit_t *parent, void *context) { return eval_do_fold(jit, expr, parent, registry, context); } static bool eval_not_possible(tree_t t, const char *why) { if (opt_get_verbose(OPT_EVAL_VERBOSE, NULL)) warn_at(tree_loc(t), "%s prevents constant folding", why); return false; } bool eval_possible(tree_t t, unit_registry_t *ur, mir_context_t *mc) { switch (tree_kind(t)) { case T_FCALL: { const tree_flags_t flags = tree_flags(t); if (!(flags & (TREE_F_LOCALLY_STATIC | TREE_F_GLOBALLY_STATIC))) return eval_not_possible(t, "non-static expression"); tree_t decl = tree_ref(t); const subprogram_kind_t kind = tree_subkind(decl); if (tree_flags(decl) & TREE_F_IMPURE) return eval_not_possible(t, "call to impure function"); else if (kind != S_USER && !is_open_coded_builtin(kind) && unit_registry_get(ur, tree_ident2(decl)) == NULL && mir_get_unit(mc, tree_ident2(decl)) == NULL) return eval_not_possible(t, "not yet lowered predef"); else if (kind == S_USER && !is_package(tree_container(decl))) return eval_not_possible(t, "subprogram not in package"); const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { tree_t p = tree_value(tree_param(t, i)); if (!eval_possible(p, ur, mc)) return false; else if (tree_kind(p) == T_FCALL && type_is_scalar(tree_type(p))) return false; // Would have been folded already if possible } return true; } case T_LITERAL: case T_STRING: case T_OPEN: return true; case T_TYPE_CONV: case T_QUALIFIED: { tree_t value = tree_value(t); if (tree_kind(value) == T_FCALL) return false; // Would have been folded already if possible return eval_possible(value, ur, mc); } case T_REF: { tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_UNIT_DECL: case T_ENUM_LIT: return true; case T_CONST_DECL: if (tree_has_value(decl)) return eval_possible(tree_value(decl), ur, mc); else return false; default: return eval_not_possible(t, "reference"); } } case T_RECORD_REF: return eval_possible(tree_value(t), ur, mc); case T_ARRAY_REF: { const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!eval_possible(tree_value(tree_param(t, i)), ur, mc)) return false; } return eval_possible(tree_value(t), ur, mc); } case T_AGGREGATE: { const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { if (!eval_possible(tree_value(tree_assoc(t, i)), ur, mc)) return false; } // Check for missing choices in constrained array aggregates type_t composite_type = tree_type(t); if (type_is_array(composite_type) && !type_is_unconstrained(composite_type)) { int64_t count = 0, elem_count = 0; bool known_elem_count = false; bool has_others = false; bool has_range = false; for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); const assoc_kind_t akind = tree_subkind(a); switch (akind) { case A_NAMED: case A_POS: known_elem_count = true; elem_count = 1; break; case A_RANGE: known_elem_count = false; has_range = true; break; case A_OTHERS: known_elem_count = false; has_others = true; break; case A_SLICE: case A_CONCAT: { type_t v_type = tree_type(tree_value(a)); known_elem_count = true; if (type_is_unconstrained(v_type)) known_elem_count = false; else if (!folded_length(range_of(v_type, 0), &elem_count)) known_elem_count = false; break; } } if (known_elem_count) count += elem_count; } if (has_range) // Range could overlap, defer to bounds check return eval_not_possible(t, "range as choice"); if (!has_others) { int64_t type_count; if (folded_length(range_of(composite_type, 0), &type_count)) if (count != type_count) return eval_not_possible(t, "missing choice"); } } return true; } case T_ATTR_REF: { if (tree_subkind(t) == ATTR_USER) return eval_not_possible(t, "user defined attribute"); if (!eval_possible(tree_name(t), ur, mc)) return false; const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!eval_possible(tree_value(tree_param(t, i)), ur, mc)) return false; } return true; } default: return eval_not_possible(t, tree_kind_str(tree_kind(t))); } } static void *case_result_cb(jit_scalar_t *args, void *user) { jit_scalar_t *result = user; result->integer = args[0].integer; return result; } tree_t eval_case(jit_t *jit, tree_t stmt, lower_unit_t *parent, void *context) { assert(tree_kind(stmt) == T_CASE_GENERATE); vcode_unit_t thunk = lower_case_generate_thunk(parent, stmt); jit_scalar_t result = { .integer = -1 }; if (jit_call_thunk(jit, thunk, context, case_result_cb, &result) == NULL) error_at(tree_loc(tree_value(stmt)), "generate expression is not static"); vcode_unit_unref(thunk); if (result.integer == -1) return NULL; else return tree_stmt(stmt, result.integer); } void *eval_instance(jit_t *jit, ident_t name, void *context) { jit_handle_t h = jit_lazy_compile(jit, name); if (h == JIT_HANDLE_INVALID) fatal_trace("failed to compile instance %s", istr(name)); jit_scalar_t result; if (!jit_try_call(jit, h, &result, context, context)) return NULL; return result.pointer; } nvc-r1.17.1/src/eval.h000066400000000000000000000023741504111170000144340ustar00rootroot00000000000000// // Copyright (C) 2021-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _EVAL_H #define _EVAL_H #include "prim.h" #include "phase.h" tree_t eval_try_fold(jit_t *jit, tree_t expr, unit_registry_t *registry, lower_unit_t *parent, void *context); tree_t eval_must_fold(jit_t *jit, tree_t expr, unit_registry_t *registry, lower_unit_t *parent, void *context); bool eval_possible(tree_t t, unit_registry_t *ur, mir_context_t *mc); tree_t eval_case(jit_t *jit, tree_t stmt, lower_unit_t *parent, void *context); void *eval_instance(jit_t *jit, ident_t name, void *context); #endif // _EVAL_H nvc-r1.17.1/src/fbuf.c000066400000000000000000000450011504111170000144140ustar00rootroot00000000000000// // Copyright (C) 2014-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "fbuf.h" #include "fastlz.h" #include #include #include #include #include #include #include #include #ifdef HAVE_AVX2 #include #endif #define DEFAULT_ZIP FBUF_ZIP_ZSTD #define SPILL_SIZE 65536 #define BLOCK_SIZE (SPILL_SIZE - (SPILL_SIZE / 16)) #define FBUF_HEADER_SZ 20 #if DEBUG #define ASSERT_AVAIL(f, n) do { \ if (unlikely((f)->rptr + (n) > (f)->origsz)) \ fatal_trace("read past end of decompressed file %s", \ f->fname); \ } while (0); #else #define ASSERT_AVAIL(f, n) #endif typedef struct _adler32 adler32_t; typedef void (*adler32_update_t)(adler32_t *, uint8_t *, size_t); typedef struct _adler32 { unsigned long s1; unsigned long s2; adler32_update_t update; } adler32_t; typedef struct { fbuf_cs_t algo; uint32_t expect; union { adler32_t adler32; } u; } cs_state_t; struct _fbuf { fbuf_mode_t mode; char *fname; FILE *file; uint8_t *wbuf; size_t wpend; size_t wtotal; uint8_t *rbuf; size_t rptr; size_t origsz; fbuf_t *next; fbuf_t *prev; cs_state_t checksum; fbuf_zip_t zip; ZSTD_CCtx *zstd; uint8_t *zbuf; size_t zbufsz; }; static fbuf_t *open_list = NULL; #define ADLER_MOD 65521 #define ADLER_CHUNK_LEN_32 5552 #define ADLER_CHUNK_LEN_SIMD_32 (ADLER_CHUNK_LEN_32/32)*32 #if HAVE_AVX2 // AX2 implementation based on // https://wooo.sh/articles/adler32.html __attribute__((target("avx2"))) static inline uint32_t avx2_reduce_add_8x32(__m256i v) { __m128i sum128 = _mm_add_epi32(_mm256_castsi256_si128(v), _mm256_extracti128_si256(v, 1)); __m128i hi64 = _mm_unpackhi_epi64(sum128, sum128); __m128i sum64 = _mm_add_epi32(hi64, sum128); __m128i hi32 = _mm_shuffle_epi32(sum64, _MM_SHUFFLE(2, 3, 0, 1)); __m128i sum32 = _mm_add_epi32(sum64, hi32); return _mm_cvtsi128_si32(sum32); } __attribute__((target("avx2"))) static void adler32_update_avx2(adler32_t *state, uint8_t *data, size_t length) { const __m256i zero_v = _mm256_setzero_si256(); const __m256i one_epi16_v = _mm256_set1_epi16(1); const __m256i coeff_v = _mm256_set_epi8( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 ); uint32_t sum = state->s1; uint32_t sum2 = state->s2; while (length >= 32) { size_t chunk_len = length; chunk_len -= chunk_len % 32; if (chunk_len > ADLER_CHUNK_LEN_SIMD_32) chunk_len = ADLER_CHUNK_LEN_SIMD_32; length -= chunk_len; __m256i sum_v = _mm256_setzero_si256(); __m256i sum2_v = _mm256_setzero_si256(); uint8_t *chunk_end = data + chunk_len; while (data < chunk_end) { __m256i chunk_v = _mm256_loadu_si256((__m256i *)data); data += 32; __m256i mad = _mm256_maddubs_epi16(chunk_v, coeff_v); sum2_v = _mm256_add_epi32(sum2_v, _mm256_madd_epi16(mad, one_epi16_v)); sum2_v = _mm256_add_epi32(sum2_v, _mm256_slli_epi32(sum_v, 5)); sum_v = _mm256_add_epi32(sum_v, _mm256_sad_epu8(chunk_v, zero_v)); } sum2 += sum * chunk_len; sum2 += avx2_reduce_add_8x32(sum2_v); sum += avx2_reduce_add_8x32(sum_v); sum %= ADLER_MOD; sum2 %= ADLER_MOD; } while (length) { size_t chunk_len = length; if (chunk_len > ADLER_CHUNK_LEN_32) chunk_len = ADLER_CHUNK_LEN_32; length -= chunk_len; const uint8_t *chunk_end = data + chunk_len; for (; data != chunk_end; data++) { sum += *data; sum2 += sum; } sum %= ADLER_MOD; sum2 %= ADLER_MOD; } state->s1 = sum; state->s2 = sum2; } #endif // HAVE_AVX2 static void adler32_update(adler32_t *state, uint8_t *input, size_t length) { // Public domain implementation from // https://github.com/weidai11/cryptopp/blob/master/adler32.cpp unsigned long s1 = state->s1; unsigned long s2 = state->s2; if (length % 8 != 0) { do { s1 += *input++; s2 += s1; length--; } while (length % 8 != 0); if (s1 >= ADLER_MOD) s1 -= ADLER_MOD; s2 %= ADLER_MOD; } while (length > 0) { s1 += input[0]; s2 += s1; s1 += input[1]; s2 += s1; s1 += input[2]; s2 += s1; s1 += input[3]; s2 += s1; s1 += input[4]; s2 += s1; s1 += input[5]; s2 += s1; s1 += input[6]; s2 += s1; s1 += input[7]; s2 += s1; length -= 8; input += 8; if (s1 >= ADLER_MOD) s1 -= ADLER_MOD; if (length % 0x8000 == 0) s2 %= ADLER_MOD; } assert(s1 < ADLER_MOD); assert(s2 < ADLER_MOD); state->s1 = s1; state->s2 = s2; } static void checksum_init(cs_state_t *state, fbuf_cs_t algo) { state->expect = 0; switch ((state->algo = algo)) { case FBUF_CS_NONE: break; case FBUF_CS_ADLER32: state->u.adler32.s1 = 1; state->u.adler32.s2 = 0; #if HAVE_AVX2 if (__builtin_cpu_supports("avx2")) state->u.adler32.update = adler32_update_avx2; else state->u.adler32.update = adler32_update; #else state->u.adler32.update = adler32_update; #endif break; } } static void checksum_update(cs_state_t *state, uint8_t *input, size_t length) { switch (state->algo) { case FBUF_CS_NONE: break; case FBUF_CS_ADLER32: (*state->u.adler32.update)(&(state->u.adler32), input, length); break; } } static uint32_t checksum_finish(cs_state_t *state) { switch (state->algo) { case FBUF_CS_ADLER32: return (state->u.adler32.s1 << 16) | state->u.adler32.s2; default: return 0; } } void fbuf_cleanup(void) { for (fbuf_t *it = open_list; it != NULL; it = it->next) { fclose(it->file); if (it->mode == FBUF_OUT) remove(it->fname); } } static void fbuf_write_raw(fbuf_t *f, const uint8_t *bytes, size_t count) { if (fwrite(bytes, count, 1, f->file) != 1) fatal_errno("%s: fwrite", f->fname); } static void fbuf_read_raw(fbuf_t *f, uint8_t *bytes, size_t count) { if (fread(bytes, count, 1, f->file) != 1) fatal_errno("%s: fread", f->fname); } static void fbuf_write_header(fbuf_t *f) { const uint8_t header[FBUF_HEADER_SZ] = { 'F', 'B', 'U', 'F', // Magic number "FBUF" f->zip, // Compression format f->checksum.algo, // Checksum algorithm FBUF_HEADER_SZ, // Header size 0, // Unused 0, 0, 0, 0, // Decompressed length 0, 0, 0, 0, // Checksum 0, 0, 0, 0, // Compressed length }; fbuf_write_raw(f, header, sizeof(header)); } static void fbuf_update_header(fbuf_t *f, uint32_t checksum) { off_t len = ftello(f->file); if (len == -1) fatal_errno("%s: ftell", f->fname); if (fseek(f->file, 8, SEEK_SET) != 0) fatal_errno("%s: fseek", f->fname); const uint8_t bytes[12] = { PACK_BE32(f->wtotal), PACK_BE32(checksum), PACK_BE32(len), }; fbuf_write_raw(f, bytes, ARRAY_LEN(bytes)); } static void fbuf_decompress_fastlz(fbuf_t *f, uint8_t *rmap, size_t bufsz) { for (uint8_t *dst = f->rbuf, *src = rmap; dst < f->rbuf + f->origsz;) { const uint32_t blksz = UNPACK_BE32(src); if (blksz > SPILL_SIZE) fatal("file %s has invalid compression format", f->fname); src += sizeof(uint32_t); if (src + blksz > (uint8_t *)rmap + bufsz) fatal_trace("read past end of compressed file %s", f->fname); const int ret = fastlz_decompress(src, blksz, dst, SPILL_SIZE); if (ret == 0) fatal("file %s has invalid compression format", f->fname); checksum_update(&(f->checksum), dst, ret); dst += ret; src += blksz; } } static void fbuf_decompress_zstd(fbuf_t *f, uint8_t *rmap, size_t bufsz) { size_t dsize = ZSTD_decompress(f->rbuf, f->origsz, rmap, bufsz); if (ZSTD_isError(dsize)) fatal("ZSTD decompress failed: %s: %s", f->fname, ZSTD_getErrorName(dsize)); if (dsize != f->origsz) fatal("%s inconsistent size %zu vs %zu", f->fname, dsize, f->origsz); checksum_update(&(f->checksum), f->rbuf, f->origsz); } static void fbuf_decompress(fbuf_t *f) { uint8_t header[16]; file_info_t info; if (!get_handle_info(fileno(f->file), &info)) fatal_errno("%s: cannot get file info", f->fname); if (info.size < sizeof(header)) fatal("%s is not a valid compressed data file", f->fname); fbuf_read_raw(f, header, sizeof(header)); if (memcmp(header, "FBUF", 4)) fatal("%s: file created with an older version of NVC", f->fname); if (header[5] != f->checksum.algo) fatal("%s has was created with unexpected checksum algorithm %c", f->fname, header[5]); const uint32_t len = UNPACK_BE32(header + 8); const uint32_t checksum = UNPACK_BE32(header + 12); uint8_t header_sz = header[6]; if (header_sz == 0) header_sz = 16; // Compatibility with 1.8 and earlier uint32_t filesz = info.size; if (header_sz > 16) { // XXX: added in 1.10 uint8_t header2[4]; fbuf_read_raw(f, header2, sizeof(header2)); filesz = UNPACK_BE32(header2); } size_t userheader = 0; if (header_sz > 20) { // XXX: added (and removed!) in 1.10 uint8_t header3[4]; fbuf_read_raw(f, header3, sizeof(header3)); userheader = UNPACK_BE32(header3); } if (filesz > info.size) fatal("%s has inconsistent compressed size %u vs file size %zu", f->fname, filesz, info.size); uint8_t *rmap = map_file(fileno(f->file), filesz); f->origsz = len; f->checksum.expect = checksum; f->rbuf = xmalloc(f->origsz); uint8_t *payload = rmap + header_sz + userheader; const size_t payloadsz = filesz - header_sz - userheader; switch (header[4]) { case FBUF_ZIP_FASTLZ: fbuf_decompress_fastlz(f, payload, payloadsz); break; case FBUF_ZIP_NONE: memcpy(f->rbuf, payload, f->origsz); checksum_update(&(f->checksum), f->rbuf, f->origsz); break; case FBUF_ZIP_ZSTD: fbuf_decompress_zstd(f, payload, payloadsz); break; default: fatal("%s was created with unexpected compression algorithm %c", f->fname, header[4]); } unmap_file(rmap, filesz); } fbuf_t *fbuf_open(const char *file, fbuf_mode_t mode, fbuf_cs_t csum) { FILE *h = fopen(file, mode == FBUF_OUT ? "wb" : "rb"); if (h == NULL) return NULL; fbuf_t *f = xcalloc(sizeof(struct _fbuf)); f->file = h; f->fname = xstrdup(file); f->mode = mode; f->next = open_list; f->zip = DEFAULT_ZIP; checksum_init(&(f->checksum), csum); if (f->zip == FBUF_ZIP_ZSTD && mode == FBUF_OUT) { if ((f->zstd = ZSTD_createCCtx()) == NULL) fatal_trace("ZSTD_createCCtx() failed"); size_t rc = ZSTD_CCtx_setParameter(f->zstd, ZSTD_c_compressionLevel, 3); if (ZSTD_isError(rc)) fatal("failed to set ZSTD compression level: %s", ZSTD_getErrorName(rc)); f->zbufsz = ZSTD_CStreamOutSize(); f->zbuf = xmalloc(f->zbufsz); } if (mode == FBUF_OUT) { f->wbuf = xmalloc(SPILL_SIZE); fbuf_write_header(f); } else fbuf_decompress(f); if (open_list != NULL) open_list->prev = f; return (open_list = f); } const char *fbuf_file_name(fbuf_t *f) { return f->fname; } int fbuf_file_handle(fbuf_t *f) { return fileno(f->file); } static void fbuf_compress_fastlz(fbuf_t *f) { uint8_t out[SPILL_SIZE]; const int ret = fastlz_compress_level(2, f->wbuf, f->wpend, out); assert((ret > 0) && (ret < SPILL_SIZE)); const uint8_t blksz[4] = { PACK_BE32(ret) }; fbuf_write_raw(f, blksz, 4); fbuf_write_raw(f, out, ret); } static void fbuf_compress_zstd(fbuf_t *f, bool end) { ZSTD_EndDirective mode = end ? ZSTD_e_end : ZSTD_e_continue; ZSTD_inBuffer input = { f->wbuf, f->wpend, 0 }; bool finished; do { ZSTD_outBuffer output = { f->zbuf, f->zbufsz, 0 }; size_t remaining = ZSTD_compressStream2(f->zstd, &output, &input, mode); if (ZSTD_isError(remaining)) fatal("ZSTD compress failed: %s", ZSTD_getErrorName(remaining)); if (output.pos > 0) fbuf_write_raw(f, f->zbuf, output.pos); finished = end ? (remaining == 0) : (input.pos == input.size); } while (!finished); assert(input.pos == input.size); } static void fbuf_maybe_flush(fbuf_t *f, size_t more, bool end) { assert(more <= BLOCK_SIZE); if (f->wpend + more > BLOCK_SIZE) { if (f->zip == FBUF_ZIP_FASTLZ && f->wpend < 16) { // Write dummy bytes at end to meet fastlz block size requirement memset(f->wbuf + f->wpend, '\0', 16 - f->wpend); f->wpend = 16; } checksum_update(&(f->checksum), f->wbuf, f->wpend); switch (f->zip) { case FBUF_ZIP_FASTLZ: fbuf_compress_fastlz(f); break; case FBUF_ZIP_NONE: fbuf_write_raw(f, f->wbuf, f->wpend); break; case FBUF_ZIP_ZSTD: fbuf_compress_zstd(f, end); break; default: fatal_trace("unsupported compression algorithm %c", f->zip); } f->wtotal += f->wpend; f->wpend = 0; } } void fbuf_close(fbuf_t *f, uint32_t *checksum) { if (f->wbuf != NULL) fbuf_maybe_flush(f, BLOCK_SIZE, true); const uint32_t cs = checksum_finish(&(f->checksum)); if (f->mode == FBUF_IN && cs != f->checksum.expect) fatal("%s: incorrect checksum %08x, expected %08x", f->fname, cs, f->checksum.expect); if (checksum != NULL) *checksum = cs; if (f->rbuf != NULL) free(f->rbuf); if (f->wbuf != NULL) { fbuf_update_header(f, cs); free(f->wbuf); } fclose(f->file); if (f->prev == NULL) { assert(f == open_list); if (f->next != NULL) f->next->prev = NULL; open_list = f->next; } else { f->prev->next = f->next; if (f->next != NULL) f->next->prev = f->prev; } if (checksum != NULL) *checksum = checksum_finish(&(f->checksum)); if (f->zstd != NULL) ZSTD_freeCCtx(f->zstd); free(f->zbuf); free(f->fname); free(f); } void fbuf_put_uint(fbuf_t *f, uint64_t val) { fbuf_maybe_flush(f, 10, false); do { uint8_t enc = val & 0x7f; val >>= 7; if (val) enc |= 0x80; *(f->wbuf + f->wpend++) = enc; } while (val); } void fbuf_put_int(fbuf_t *f, int64_t val) { uint64_t zz = ((uint64_t)val << 1) ^ (val >> 63); // Zig-zag encoding fbuf_put_uint(f, zz); } void write_u32(uint32_t u, fbuf_t *f) { fbuf_maybe_flush(f, 4, false); *(f->wbuf + f->wpend++) = (u >> 0) & UINT32_C(0xff); *(f->wbuf + f->wpend++) = (u >> 8) & UINT32_C(0xff); *(f->wbuf + f->wpend++) = (u >> 16) & UINT32_C(0xff); *(f->wbuf + f->wpend++) = (u >> 24) & UINT32_C(0xff); } void write_u64(uint64_t u, fbuf_t *f) { fbuf_maybe_flush(f, 8, false); *(f->wbuf + f->wpend++) = (u >> 0) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 8) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 16) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 24) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 32) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 40) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 48) & UINT64_C(0xff); *(f->wbuf + f->wpend++) = (u >> 56) & UINT64_C(0xff); } void write_u16(uint16_t s, fbuf_t *f) { fbuf_maybe_flush(f, 2, false); *(f->wbuf + f->wpend++) = (s >> 0) & UINT16_C(0xff); *(f->wbuf + f->wpend++) = (s >> 8) & UINT16_C(0xff); } void write_u8(uint8_t u, fbuf_t *f) { fbuf_maybe_flush(f, 1, false); *(f->wbuf + f->wpend++) = u; } void write_raw(const void *buf, size_t len, fbuf_t *f) { fbuf_maybe_flush(f, len, false); memcpy(f->wbuf + f->wpend, buf, len); f->wpend += len; } void write_double(double d, fbuf_t *f) { union { double d; uint64_t i; } u; u.d = d; write_u64(u.i, f); } uint64_t fbuf_get_uint(fbuf_t *f) { ASSERT_AVAIL(f, 1); const uint8_t b0 = *(f->rbuf + f->rptr++); if (!(b0 & 0x80)) return b0; uint64_t val = b0 & 0x7f; int shift = 7; uint8_t byte; do { ASSERT_AVAIL(f, 1); byte = *(f->rbuf + f->rptr++); val |= (uint64_t)(byte & 0x7f) << shift; shift += 7; } while (byte & 0x80); return val; } int64_t fbuf_get_int(fbuf_t *f) { uint64_t zz = fbuf_get_uint(f); return (zz >> 1) ^ -(zz & 1); } uint32_t read_u32(fbuf_t *f) { ASSERT_AVAIL(f, 4); uint32_t val = 0; val |= (uint32_t)*(f->rbuf + f->rptr++) << 0; val |= (uint32_t)*(f->rbuf + f->rptr++) << 8; val |= (uint32_t)*(f->rbuf + f->rptr++) << 16; val |= (uint32_t)*(f->rbuf + f->rptr++) << 24; return val; } uint16_t read_u16(fbuf_t *f) { ASSERT_AVAIL(f, 2); uint16_t val = 0; val |= (uint16_t)*(f->rbuf + f->rptr++) << 0; val |= (uint16_t)*(f->rbuf + f->rptr++) << 8; return val; } uint8_t read_u8(fbuf_t *f) { ASSERT_AVAIL(f, 1); return *(f->rbuf + f->rptr++); } uint64_t read_u64(fbuf_t *f) { ASSERT_AVAIL(f, 8); uint64_t val = 0; val |= (uint64_t)*(f->rbuf + f->rptr++) << 0; val |= (uint64_t)*(f->rbuf + f->rptr++) << 8; val |= (uint64_t)*(f->rbuf + f->rptr++) << 16; val |= (uint64_t)*(f->rbuf + f->rptr++) << 24; val |= (uint64_t)*(f->rbuf + f->rptr++) << 32; val |= (uint64_t)*(f->rbuf + f->rptr++) << 40; val |= (uint64_t)*(f->rbuf + f->rptr++) << 48; val |= (uint64_t)*(f->rbuf + f->rptr++) << 56; return val; } void read_raw(void *buf, size_t len, fbuf_t *f) { ASSERT_AVAIL(f, len); memcpy(buf, f->rbuf + f->rptr, len); f->rptr += len; } double read_double(fbuf_t *f) { union { uint64_t i; double d; } u; u.i = read_u64(f); return u.d; } nvc-r1.17.1/src/fbuf.h000066400000000000000000000035361504111170000144300ustar00rootroot00000000000000// // Copyright (C) 2013-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _FBUF_H #define _FBUF_H #include "util.h" // // Compressed binary file input/output // typedef enum { FBUF_IN, FBUF_OUT } fbuf_mode_t; typedef enum { FBUF_CS_NONE = '-', FBUF_CS_ADLER32 = 'A', } fbuf_cs_t; typedef enum { FBUF_ZIP_NONE = '-', FBUF_ZIP_FASTLZ = 'F', FBUF_ZIP_ZSTD = 'Z', } fbuf_zip_t; fbuf_t *fbuf_open(const char *file, fbuf_mode_t mode, fbuf_cs_t csum); void fbuf_close(fbuf_t *f, uint32_t *checksum); void fbuf_cleanup(void); const char *fbuf_file_name(fbuf_t *f); int fbuf_file_handle(fbuf_t *f); int64_t fbuf_get_int(fbuf_t *f); uint64_t fbuf_get_uint(fbuf_t *f); void fbuf_put_uint(fbuf_t *f, uint64_t val); void fbuf_put_int(fbuf_t *f, int64_t val); void write_u32(uint32_t u, fbuf_t *f); void write_u16(uint16_t s, fbuf_t *f); void write_u64(uint64_t i, fbuf_t *f); void write_u8(uint8_t u, fbuf_t *f); void write_raw(const void *buf, size_t len, fbuf_t *f); void write_double(double d, fbuf_t *f); uint32_t read_u32(fbuf_t *f); uint16_t read_u16(fbuf_t *f); uint64_t read_u64(fbuf_t *f); uint8_t read_u8(fbuf_t *f); void read_raw(void *buf, size_t len, fbuf_t *f); double read_double(fbuf_t *f); #endif // _FBUF_H nvc-r1.17.1/src/hash.c000066400000000000000000000534611504111170000144260ustar00rootroot00000000000000// // Copyright (C) 2013-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "hash.h" #include "thread.h" #include #include #include //////////////////////////////////////////////////////////////////////////////// // Hash table of pointers to pointers struct _hash { unsigned size; unsigned members; void **values; const void **keys; }; static inline int hash_slot(unsigned size, const void *key) { assert(key != NULL); return mix_bits_64((uintptr_t)key) & (size - 1); } hash_t *hash_new(int size) { hash_t *h = xmalloc(sizeof(hash_t)); h->size = next_power_of_2(size); h->members = 0; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (const void **)(mem + (h->size * sizeof(void *))); return h; } void hash_free(hash_t *h) { if (h != NULL) { free(h->values); free(h); } } bool hash_put(hash_t *h, const void *key, void *value) { if (unlikely(h->members > h->size / 2)) { // Rebuild the hash table with a larger size // This is expensive so a conservative initial size should be chosen const int old_size = h->size; h->size *= 2; const void **old_keys = h->keys; void **old_values = h->values; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (const void **)(mem + (h->size * sizeof(void *))); h->members = 0; for (int i = 0; i < old_size; i++) { if (old_keys[i] != NULL && old_values[i] != NULL) { int slot = hash_slot(h->size, old_keys[i]); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) { h->values[slot] = old_values[i]; h->keys[slot] = old_keys[i]; h->members++; break; } else assert(h->keys[slot] != old_keys[i]); } } } free(old_values); } int slot = hash_slot(h->size, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key) { h->values[slot] = value; return true; } else if (h->keys[slot] == NULL) { h->values[slot] = value; h->keys[slot] = key; h->members++; break; } } return false; } void hash_delete(hash_t *h, const void *key) { int slot = hash_slot(h->size, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key) { h->values[slot] = NULL; return; } else if (h->keys[slot] == NULL) return; } } void *hash_get(hash_t *h, const void *key) { int slot = hash_slot(h->size, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key) return h->values[slot]; else if (h->keys[slot] == NULL) return NULL; } } bool hash_iter(hash_t *h, hash_iter_t *now, const void **key, void **value) { assert(*now != HASH_END); while (*now < h->size) { const unsigned old = (*now)++; if (h->keys[old] != NULL && h->values[old] != NULL) { *key = h->keys[old]; *value = h->values[old]; return true; } } *now = HASH_END; return false; } unsigned hash_members(hash_t *h) { return h->members; } //////////////////////////////////////////////////////////////////////////////// // Hash table of strings to pointers struct _shash { unsigned size; unsigned members; void **values; char **keys; }; static inline int shash_slot(shash_t *h, const char *key) { assert(key != NULL); // DJB2 hash function from here: // http://www.cse.yorku.ca/~oz/hash.html uint32_t hash = 5381; int c; while ((c = *key++)) hash = ((hash << 5) + hash) + c; return mix_bits_32(hash) & (h->size - 1); } shash_t *shash_new(int size) { shash_t *h = xmalloc(sizeof(shash_t)); h->size = next_power_of_2(size); h->members = 0; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (char **)(mem + (h->size * sizeof(void *))); return h; } void shash_free(shash_t *h) { if (h == NULL) return; for (unsigned i = 0; i < h->size; i++) { if (h->keys[i] != NULL) free(h->keys[i]); } free(h->values); free(h); } static void shash_put_copy(shash_t *h, char *key, void *value) { int slot = shash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) { h->values[slot] = value; h->keys[slot] = key; h->members++; break; } else if (strcmp(h->keys[slot], key) == 0) { h->values[slot] = value; return; } } } void shash_put(shash_t *h, const char *key, void *value) { if (unlikely(h->members > h->size / 2)) { // Rebuild the hash table with a larger size const int old_size = h->size; h->size *= 2; char **old_keys = h->keys; void **old_values = h->values; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (char **)(mem + (h->size * sizeof(void *))); h->members = 0; for (int i = 0; i < old_size; i++) { if (old_keys[i] != NULL) shash_put_copy(h, old_keys[i], old_values[i]); } free(old_values); } shash_put_copy(h, xstrdup(key), value); } void *shash_get(shash_t *h, const char *key) { int slot = shash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) return NULL; else if (strcmp(h->keys[slot], key) == 0) return h->values[slot]; } } void shash_delete(shash_t *h, const void *key) { int slot = shash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) return; else if (strcmp(h->keys[slot], key) == 0) { h->values[slot] = NULL; return; } } } bool shash_iter(shash_t *h, hash_iter_t *now, const char **key, void **value) { assert(*now != HASH_END); while (*now < h->size) { const unsigned old = (*now)++; if (h->keys[old] != NULL && h->values[old] != NULL) { *key = h->keys[old]; *value = h->values[old]; return true; } } *now = HASH_END; return false; } //////////////////////////////////////////////////////////////////////////////// // Hash of unsigned integers to pointers struct _ihash { unsigned size; unsigned members; void **values; uint64_t *keys; uint64_t *mask; uint64_t cachekey; void *cacheval; }; static inline int ihash_slot(ihash_t *h, uint64_t key) { key = (key ^ (key >> 30)) * UINT64_C(0xbf58476d1ce4e5b9); key = (key ^ (key >> 27)) * UINT64_C(0x94d049bb133111eb); key = key ^ (key >> 31); return key & (h->size - 1); } ihash_t *ihash_new(int size) { ihash_t *h = xmalloc(sizeof(ihash_t)); h->size = next_power_of_2(size); h->members = 0; const size_t bytes = h->size * sizeof(void *) + h->size * sizeof(uint64_t) + (h->size + 63 / 64) * sizeof(uint64_t); char *mem = xcalloc(bytes); h->values = (void **)mem; h->keys = (uint64_t *)(mem + (h->size * sizeof(void *))); h->mask = (uint64_t *)(mem + (h->size * sizeof(void *)) + (h->size * sizeof(uint64_t))); return h; } void ihash_free(ihash_t *h) { if (h != NULL) { free(h->values); free(h); } } void ihash_put(ihash_t *h, uint64_t key, void *value) { if (unlikely(h->members > h->size / 2)) { // Rebuild the hash table with a larger size const int old_size = h->size; h->size *= 2; uint64_t *old_keys = h->keys; uint64_t *old_mask = h->mask; void **old_values = h->values; const size_t bytes = h->size * sizeof(void *) + h->size * sizeof(uint64_t) + (ALIGN_UP(h->size, 64) / 64) * sizeof(uint64_t); char *mem = xcalloc(bytes); h->values = (void **)mem; h->keys = (uint64_t *)(mem + (h->size * sizeof(void *))); h->mask = (uint64_t *)(mem + (h->size * sizeof(void *)) + (h->size * sizeof(uint64_t))); h->members = 0; for (int i = 0; i < old_size; i++) { if (old_mask[i / 64] & (UINT64_C(1) << (i % 64))) ihash_put(h, old_keys[i], old_values[i]); } free(old_values); } h->cachekey = key; h->cacheval = value; int slot = ihash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (!(h->mask[slot / 64] & (UINT64_C(1) << (slot % 64)))) { h->values[slot] = value; h->keys[slot] = key; h->mask[slot / 64] |= (UINT64_C(1) << (slot % 64)); h->members++; break; } else if (h->keys[slot] == key) { h->values[slot] = value; assert(h->mask[slot / 64] & (UINT64_C(1) << (slot % 64))); return; } } } void *ihash_get(ihash_t *h, uint64_t key) { if (h->members > 0 && key == h->cachekey) return h->cacheval; h->cachekey = key; int slot = ihash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (!(h->mask[slot / 64] & (UINT64_C(1) << (slot % 64)))) return (h->cacheval = NULL); else if (h->keys[slot] == key) return (h->cacheval = h->values[slot]); } } //////////////////////////////////////////////////////////////////////////////// // Set of pointers implemented as a hash table struct _hset { unsigned size; unsigned members; const void **keys; }; hset_t *hset_new(int size) { hset_t *h = xmalloc(sizeof(hset_t)); h->size = next_power_of_2(size); h->members = 0; h->keys = xcalloc_array(h->size, sizeof(void *)); return h; } void hset_free(hset_t *h) { if (h != NULL) { free(h->keys); free(h); } } void hset_insert(hset_t *h, const void *key) { if (unlikely(h->members > h->size / 2)) { const int old_size = h->size; h->size *= 2; const void **old_keys = h->keys; h->keys = xcalloc_array(h->size, sizeof(void *)); h->members = 0; for (int i = 0; i < old_size; i++) { if (old_keys[i] != NULL) hset_insert(h, old_keys[i]); } free(old_keys); } int slot = hash_slot(h->size, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key) return; else if (h->keys[slot] == NULL) { h->keys[slot] = key; h->members++; break; } } } bool hset_contains(hset_t *h, const void *key) { int slot = hash_slot(h->size, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key) return true; else if (h->keys[slot] == NULL) return false; } } //////////////////////////////////////////////////////////////////////////////// // Hash table that supports concurrent updates typedef struct _chash_node chash_node_t; typedef struct { void *tagged_key; void *value; } chash_slot_t; typedef struct { size_t size; chash_slot_t slots[0]; } chash_tab_t; struct _chash_node { chash_node_t *chain; const void *key; void *value; }; struct _chash { chash_tab_t *tab; chash_tab_t *resizing; size_t members; }; typedef enum { FREE_MARKER, BUSY_MARKER, INUSE_MARKER, MOVED_MARKER, } chash_marker_t; chash_t *chash_new(int size) { const int roundup = next_power_of_2(size); chash_tab_t *tab = xcalloc_flex(sizeof(chash_tab_t), roundup, sizeof(chash_slot_t)); tab->size = roundup; chash_t *h = xcalloc(sizeof(chash_t)); store_release(&h->resizing, tab); store_release(&h->tab, tab); return h; } static void chash_wait_for_resize(chash_t *h) { for (;;) { chash_tab_t *from = atomic_load(&h->tab); chash_tab_t *to = atomic_load(&h->resizing); if (from == to) break; thread_sleep(10); } } void chash_free(chash_t *h) { if (h == NULL) return; chash_wait_for_resize(h); free(h->tab); free(h); } static void chash_copy_table(chash_tab_t *from, chash_tab_t *to) { for (int i = 0; i < from->size; i++) { for (;;) { void *const tagged_key = load_acquire(&from->slots[i].tagged_key); const chash_marker_t marker = pointer_tag(tagged_key); const void *key = untag_pointer(tagged_key, void); switch (marker) { case BUSY_MARKER: spin_wait(); continue; case INUSE_MARKER: { for (int j = hash_slot(to->size, key);; j = (j + 1) & (to->size - 1)) { void *exist = load_acquire(&(to->slots[j].tagged_key)); if (exist == NULL) { to->slots[j].value = from->slots[i].value; store_release(&(to->slots[j].tagged_key), tagged_key); break; } else assert(exist != tagged_key); } } break; case FREE_MARKER: break; default: should_not_reach_here(); } void *moved = tag_pointer(key, MOVED_MARKER); if (atomic_cas(&(from->slots[i].tagged_key), tagged_key, moved)) break; else assert(marker == FREE_MARKER); // Raced to move free slot } } } static void chash_grow_table(chash_t *h, chash_tab_t *cur) { chash_tab_t *newtab = xcalloc_flex(sizeof(chash_tab_t), cur->size * 2, sizeof(chash_slot_t)); newtab->size = cur->size * 2; if (atomic_cas(&h->resizing, cur, newtab)) { chash_copy_table(cur, newtab); assert(atomic_load(&h->resizing) == newtab); if (!atomic_cas(&h->tab, cur, newtab)) should_not_reach_here(); async_free(cur); } else { free(newtab); chash_wait_for_resize(h); } } static bool chash_try_put(chash_t *h, const void *key, void *value) { chash_tab_t *tab = load_acquire(&h->tab); assert(is_power_of_2(tab->size)); if (relaxed_load(&h->members) > tab->size / 2) { chash_grow_table(h, tab); return false; } for (int i = hash_slot(tab->size, key);; i = (i + 1) & (tab->size - 1)) { void *const tagged_key = load_acquire(&tab->slots[i].tagged_key); const chash_marker_t marker = pointer_tag(tagged_key); switch (marker) { case BUSY_MARKER: spin_wait(); return false; case FREE_MARKER: { void *busy = tag_pointer(NULL, BUSY_MARKER); if (atomic_cas(&tab->slots[i].tagged_key, NULL, busy)) { tab->slots[i].value = value; void *inuse = tag_pointer(key, INUSE_MARKER); store_release(&tab->slots[i].tagged_key, inuse); relaxed_add(&h->members, 1); return true; } else { spin_wait(); return false; } } case INUSE_MARKER: if (untag_pointer(tagged_key, void) == key) { // Must CAS to busy here to avoid lost update due to // concurrent move void *busy = tag_pointer(key, BUSY_MARKER); if (atomic_cas(&tab->slots[i].tagged_key, tagged_key, busy)) { tab->slots[i].value = value; store_release(&tab->slots[i].tagged_key, tagged_key); return true; } else { spin_wait(); return false; } } else break; case MOVED_MARKER: chash_wait_for_resize(h); return false; } } } void chash_put(chash_t *h, const void *key, void *value) { while (!chash_try_put(h, key, value)); } static bool chash_try_cas(chash_t *h, const void *key, void *cmp, void **value) { chash_tab_t *tab = load_acquire(&h->tab); assert(is_power_of_2(tab->size)); if (relaxed_load(&h->members) > tab->size / 2) { chash_grow_table(h, tab); return false; } for (int i = hash_slot(tab->size, key);; i = (i + 1) & (tab->size - 1)) { void *const tagged_key = load_acquire(&tab->slots[i].tagged_key); const chash_marker_t marker = pointer_tag(tagged_key); switch (marker) { case BUSY_MARKER: spin_wait(); return false; case INUSE_MARKER: if (untag_pointer(tagged_key, void) != key) break; // Fall-through case FREE_MARKER: { void *busy = tag_pointer(key, BUSY_MARKER); if (atomic_cas(&tab->slots[i].tagged_key, tagged_key, busy)) { void *new = *value; if ((*value = tab->slots[i].value) == cmp) tab->slots[i].value = new; void *inuse = tag_pointer(key, INUSE_MARKER); store_release(&tab->slots[i].tagged_key, inuse); return true; } else { spin_wait(); return false; } } case MOVED_MARKER: chash_wait_for_resize(h); return false; } } } void *chash_cas(chash_t *h, const void *key, void *cmp, void *value) { while (!chash_try_cas(h, key, cmp, &value)); return value; } static bool chash_try_get(chash_t *h, const void *key, void **value) { chash_tab_t *tab = load_acquire(&h->tab); assert(is_power_of_2(tab->size)); for (int i = hash_slot(tab->size, key);; i = (i + 1) & (tab->size - 1)) { void *const tagged_key = load_acquire(&tab->slots[i].tagged_key); const chash_marker_t marker = pointer_tag(tagged_key); switch (marker) { case BUSY_MARKER: spin_wait(); return false; case FREE_MARKER: *value = NULL; return true; case INUSE_MARKER: if (untag_pointer(tagged_key, void) == key) { *value = tab->slots[i].value; return true; } else break; case MOVED_MARKER: chash_wait_for_resize(h); return false; } } } void *chash_get(chash_t *h, const void *key) { void *value; while (!chash_try_get(h, key, &value)); return value; } void chash_iter(chash_t *h, hash_iter_fn_t fn) { chash_tab_t *tab = load_acquire(&h->tab); for (int pos = 0; pos < tab->size;) { void *const tagged_key = load_acquire(&tab->slots[pos].tagged_key); const chash_marker_t marker = pointer_tag(tagged_key); switch (marker) { case BUSY_MARKER: spin_wait(); continue; case FREE_MARKER: break; case MOVED_MARKER: case INUSE_MARKER: (*fn)(untag_pointer(tagged_key, void), tab->slots[pos].value); break; } pos++; } } //////////////////////////////////////////////////////////////////////////////// // Generic hash table struct _ghash { unsigned size; unsigned members; ghash_hash_fn_t hash_fn; ghash_cmp_fn_t cmp_fn; void **values; const void **keys; }; static inline int ghash_slot(ghash_t *h, const char *key) { assert(key != NULL); const uint64_t hash = (*h->hash_fn)(key); return mix_bits_64(hash) & (h->size - 1); } ghash_t *ghash_new(int size, ghash_hash_fn_t hash_fn, ghash_cmp_fn_t cmp_fn) { ghash_t *h = xmalloc(sizeof(ghash_t)); h->size = next_power_of_2(size); h->members = 0; h->hash_fn = hash_fn; h->cmp_fn = cmp_fn; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (const void **)(mem + (h->size * sizeof(void *))); return h; } void ghash_free(ghash_t *h) { if (h != NULL) { free(h->values); free(h); } } void ghash_put(ghash_t *h, const void *key, void *value) { if (unlikely(h->members > h->size / 2)) { // Rebuild the hash table with a larger size const int old_size = h->size; h->size *= 2; const void **old_keys = h->keys; void **old_values = h->values; char *mem = xcalloc(h->size * 2 * sizeof(void *)); h->values = (void **)mem; h->keys = (const void **)(mem + (h->size * sizeof(void *))); h->members = 0; for (int i = 0; i < old_size; i++) { if (old_keys[i] != NULL) ghash_put(h, old_keys[i], old_values[i]); } free(old_values); } int slot = ghash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) { h->values[slot] = value; h->keys[slot] = key; h->members++; break; } else if (h->keys[slot] == key || (*h->cmp_fn)(h->keys[slot], key)) h->values[slot] = value; } } void *ghash_get(ghash_t *h, const void *key) { int slot = ghash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == NULL) return NULL; else if (h->keys[slot] == key || (*h->cmp_fn)(h->keys[slot], key)) return h->values[slot]; } } void ghash_delete(ghash_t *h, const void *key) { int slot = ghash_slot(h, key); for (; ; slot = (slot + 1) & (h->size - 1)) { if (h->keys[slot] == key || (*h->cmp_fn)(h->keys[slot], key)) { h->values[slot] = NULL; return; } else if (h->keys[slot] == NULL) return; } } nvc-r1.17.1/src/hash.h000066400000000000000000000047341504111170000144320ustar00rootroot00000000000000// // Copyright (C) 2013-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _HASH_H #define _HASH_H #include "util.h" #include "prim.h" #include typedef unsigned hash_iter_t; #define HASH_BEGIN 0 #define HASH_END UINT_MAX hash_t *hash_new(int size); void hash_free(hash_t *h); bool hash_put(hash_t *h, const void *key, void *value); void *hash_get(hash_t *h, const void *key); void hash_delete(hash_t *h, const void *key); bool hash_iter(hash_t *h, hash_iter_t *now, const void **key, void **value); unsigned hash_members(hash_t *h); shash_t *shash_new(int size); void shash_free(shash_t *h); void shash_put(shash_t *h, const char *key, void *value); void *shash_get(shash_t *h, const char *key); void shash_delete(shash_t *h, const void *key); bool shash_iter(shash_t *h, hash_iter_t *now, const char **key, void **value); ihash_t *ihash_new(int size); void ihash_free(ihash_t *h); void ihash_put(ihash_t *h, uint64_t key, void *value); void *ihash_get(ihash_t *h, uint64_t key); hset_t *hset_new(int size); void hset_free(hset_t *h); void hset_insert(hset_t *h, const void *key); bool hset_contains(hset_t *h, const void *key); typedef uint32_t (*ghash_hash_fn_t)(const void *key); typedef bool (*ghash_cmp_fn_t)(const void *a, const void *b); ghash_t *ghash_new(int size, ghash_hash_fn_t hash_fn, ghash_cmp_fn_t cmp_fn); void ghash_free(ghash_t *h); void ghash_put(ghash_t *h, const void *key, void *value); void *ghash_get(ghash_t *h, const void *key); void ghash_delete(ghash_t *h, const void *key); typedef void (*hash_iter_fn_t)(const void *, void *); chash_t *chash_new(int size); void chash_free(chash_t *h); void chash_put(chash_t *h, const void *key, void *value); void *chash_cas(chash_t *h, const void *key, void *cmp, void *value); void *chash_get(chash_t *h, const void *key); void chash_iter(chash_t *h, hash_iter_fn_t fn); #endif // _HASH_H nvc-r1.17.1/src/ident.c000066400000000000000000000445251504111170000146070ustar00rootroot00000000000000// // Copyright (C) 2011-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "fbuf.h" #include "ident.h" #include "thread.h" #include #include #include #include #include #include #include #ifdef ARCH_X86_64 #include #endif #define HASH_INIT 5381; typedef uint32_t hash_state_t; #define INITIAL_SIZE 1024 #define REPROBE_LIMIT 20 #define MOVED_TAG 1 #define MAX_LEN UINT16_MAX #define PRINT_STATS 0 struct ident_rd_ctx { fbuf_t *file; size_t cache_sz; size_t cache_alloc; ident_t *cache; char *scratch; size_t scratch_sz; }; struct ident_wr_ctx { fbuf_t *file; uint32_t next_index; uint16_t generation; }; struct _ident { hash_state_t hash[2]; uint32_t write_index; uint16_t write_gen; uint16_t length; char bytes[0]; }; STATIC_ASSERT(offsetof(struct _ident, bytes) == 16); typedef struct { size_t size; ident_t slots[0]; } ident_tab_t; static ident_tab_t *table = NULL; static ident_tab_t *resizing = NULL; static inline int hash_update(hash_state_t *state, const char *key, int nchars) { // DJB2 hash function from here: // http://www.cse.yorku.ca/~oz/hash.html hash_state_t hash = *state; const char *p = key; for (; p < key + nchars && *p; p++) hash = ((hash << 5) + hash) + *p; *state = hash; return p - key; } static ident_t ident_alloc(size_t len, hash_state_t hash) { const size_t aligned = ALIGN_UP(len + 1, 16); ident_t id = xcalloc_flex(sizeof(struct _ident), aligned, sizeof(char)); id->length = len; id->write_gen = 0; id->write_index = 0; id->hash[0] = hash; return id; } static inline bool ident_install(ident_t *where, ident_t new, size_t len) { if (unlikely(len >= MAX_LEN)) fatal("identifier '%s' too long", new->bytes); if (atomic_cas(where, NULL, new)) return true; else { free(new); return false; } } static void copy_table(ident_tab_t *from, ident_tab_t *to) { for (int i = 0; i < from->size; i++) { for (;;) { ident_t id = load_acquire(&(from->slots[i])); assert(pointer_tag(id) != MOVED_TAG); if (id != NULL) { for (int slot = id->hash[0] & (to->size - 1), j = 1;; slot = (slot + j) & (to->size - 1), j++) { ident_t exist = load_acquire(&(to->slots[slot])); if (exist == NULL) { store_release(&(to->slots[slot]), id); break; } else assert(exist != id); } } if (atomic_cas(&(from->slots[i]), id, tag_pointer(id, MOVED_TAG))) break; } } } static void wait_for_resize(void) { for (;;) { ident_tab_t *from = atomic_load(&table); ident_tab_t *to = atomic_load(&resizing); if (from == to) break; // We could help to resize the table here but the extra complexity // doesn't seem worth it thread_sleep(10); } } static void finish_resizing(ident_tab_t *old, ident_tab_t *new) { assert(atomic_load(&resizing) == new); if (!atomic_cas(&table, old, new)) fatal_trace("bug in concurrent resize protocol"); async_free(old); } static ident_tab_t *get_table(void) { ident_tab_t *cur = atomic_load(&table); if (unlikely(cur == NULL)) { ident_tab_t *newtab = xcalloc_flex(sizeof(ident_tab_t), INITIAL_SIZE, sizeof(ident_t)); newtab->size = INITIAL_SIZE; if (atomic_cas(&resizing, NULL, newtab)) { finish_resizing(NULL, newtab); return newtab; } else { free(newtab); wait_for_resize(); return atomic_load(&table); } } else return cur; } static void grow_table(ident_tab_t *cur) { ident_tab_t *newtab = xcalloc_flex(sizeof(ident_tab_t), cur->size * 2, sizeof(ident_t)); newtab->size = cur->size * 2; if (atomic_cas(&resizing, cur, newtab)) { copy_table(cur, newtab); finish_resizing(cur, newtab); } else { free(newtab); wait_for_resize(); } } static ident_t ident_from_bytes(const char *str, hash_state_t hash, size_t len) { hash = mix_bits_32(hash); for (;;) { ident_tab_t *cur = get_table(); for (int reprobe = 0, i = 1, slot = hash & (cur->size - 1);; slot = (slot + i) & (cur->size - 1), i++) { ident_t *ptr = &(cur->slots[slot]); ident_t id = load_acquire(ptr); if (pointer_tag(id) == MOVED_TAG) { wait_for_resize(); break; } else if (id == NULL) { ident_t new = ident_alloc(len, hash); memcpy(new->bytes, str, len); if (ident_install(ptr, new, len)) return new; else break; } else if (id->length == len && id->hash[0] == hash && memcmp(id->bytes, str, len) == 0) return id; if (++reprobe == REPROBE_LIMIT) { grow_table(cur); break; } } } } static ident_t ident_from_byte_vec(hash_state_t hash, bool uniq, int nparts, const char *str_vec[nparts], const size_t len_vec[nparts]) { hash = mix_bits_32(hash); size_t len = 0; for (int i = 0; i < nparts; i++) len += len_vec[i]; for (;;) { ident_tab_t *cur = get_table(); for (int reprobe = 0, i = 1, slot = hash & (cur->size - 1);; slot = (slot + i) & (cur->size - 1), i++) { ident_t *ptr = &(cur->slots[slot]); ident_t id = load_acquire(ptr); if (pointer_tag(id) == MOVED_TAG) { wait_for_resize(); break; } else if (id == NULL) { ident_t new = ident_alloc(len, hash); char *p = new->bytes; for (int i = 0; i < nparts; p += len_vec[i++]) memcpy(p, str_vec[i], len_vec[i]); if (ident_install(ptr, new, len)) return new; else break; } else if (id->length == len) { int pos = 0; for (const char *p = id->bytes; pos < nparts && memcmp(p, str_vec[pos], len_vec[pos]) == 0; p += len_vec[pos++]); if (pos == nparts) return uniq ? NULL : id; } if (++reprobe == REPROBE_LIMIT) { grow_table(cur); break; } } } } ident_t ident_new(const char *str) { assert(str != NULL); assert(*str != '\0'); hash_state_t hash = HASH_INIT; int len = hash_update(&hash, str, MAX_LEN); return ident_from_bytes(str, hash, len); } ident_t ident_new_n(const char *str, size_t len) { assert(str != NULL); assert(len > 0); hash_state_t hash = HASH_INIT; hash_update(&hash, str, len); return ident_from_bytes(str, hash, len); } const char *istr(ident_t ident) { return ident ? ident->bytes : NULL; } ident_wr_ctx_t ident_write_begin(fbuf_t *f) { static uint16_t ident_wr_gen = 1; assert(ident_wr_gen > 0); struct ident_wr_ctx *ctx = xcalloc(sizeof(struct ident_wr_ctx)); ctx->file = f; ctx->generation = ident_wr_gen++; ctx->next_index = 1; // Skip over null ident return ctx; } void ident_write_end(ident_wr_ctx_t ctx) { free(ctx); } void ident_write(ident_t ident, ident_wr_ctx_t ctx) { if (ident == NULL) fbuf_put_int(ctx->file, 1); // TODO: change this to zero else if (ident->write_gen == ctx->generation) fbuf_put_int(ctx->file, ident->write_index + 1); else { fbuf_put_int(ctx->file, -ident->length); assert(ident->bytes[ident->length] == '\0'); write_raw(ident->bytes, ident->length, ctx->file); ident->write_gen = ctx->generation; ident->write_index = ctx->next_index++; assert(ctx->next_index != UINT32_MAX); } } ident_rd_ctx_t ident_read_begin(fbuf_t *f) { struct ident_rd_ctx *ctx = xcalloc(sizeof(struct ident_rd_ctx)); ctx->file = f; ctx->cache_alloc = 256; ctx->cache_sz = 0; ctx->cache = xmalloc_array(ctx->cache_alloc, sizeof(ident_t)); ctx->scratch_sz = 128; ctx->scratch = xmalloc(ctx->scratch_sz); // First index is implicit null ctx->cache[ctx->cache_sz++] = NULL; return ctx; } void ident_read_end(ident_rd_ctx_t ctx) { free(ctx->scratch); free(ctx->cache); free(ctx); } ident_t ident_read(ident_rd_ctx_t ctx) { const int32_t index = fbuf_get_int(ctx->file); if (index < 0) { if (unlikely(-index + 1 > ctx->scratch_sz)) { ctx->scratch_sz = MAX(-index + 1, (ctx->scratch_sz * 3) / 2); ctx->scratch = xrealloc(ctx->scratch, ctx->scratch_sz); } read_raw(ctx->scratch, -index, ctx->file); ctx->scratch[-index] = '\0'; if (unlikely(ctx->cache_sz == ctx->cache_alloc)) { ctx->cache_alloc *= 2; ctx->cache = xrealloc(ctx->cache, ctx->cache_alloc * sizeof(ident_t)); } return (ctx->cache[ctx->cache_sz++] = ident_new(ctx->scratch)); } else if (likely(index > 0 && index - 1 < ctx->cache_sz)) return ctx->cache[index - 1]; else fatal_trace("ident index in %s is corrupt: index=%d cache_sz=%d", fbuf_file_name(ctx->file), index, (int)ctx->cache_sz); } ident_t ident_uniq(const char *fmt, ...) { va_list ap, ap2; va_start(ap, fmt); va_copy(ap2, ap); char buf[64], *prefix = buf; size_t req = vsnprintf(buf, ARRAY_LEN(buf), fmt, ap); if (req + 1 > ARRAY_LEN(buf)) { prefix = xmalloc(req + 1); vsnprintf(prefix, req + 1, fmt, ap2); } va_end(ap); va_end(ap2); hash_state_t base_hash = HASH_INIT; int len = hash_update(&base_hash, prefix, MAX_LEN); assert(len == req); static volatile int counter = 0; char suffix[16] = ""; for (;;) { hash_state_t hash = base_hash; int sufflen = hash_update(&hash, suffix, ARRAY_LEN(suffix)); const char *str_vec[] = { prefix, suffix }; const size_t len_vec[] = { len, sufflen }; ident_t new = ident_from_byte_vec(hash, true, 2, str_vec, len_vec); if (new != NULL) { if (prefix != buf) free(prefix); return new; } checked_sprintf(suffix, sizeof(suffix), "%d", relaxed_add(&counter, 1)); } } ident_t ident_sprintf(const char *fmt, ...) { va_list ap, ap2; va_start(ap, fmt); va_copy(ap2, ap); char buf[64]; size_t req = vsnprintf(buf, sizeof(buf), fmt, ap); ident_t result; if (req + 1 > sizeof(buf)) { char *buf2 = xmalloc(req + 1); vsnprintf(buf2, req + 1, fmt, ap2); result = ident_new(buf2); free(buf2); } else result = ident_new(buf); va_end(ap); va_end(ap2); return result; } ident_t ident_prefix(ident_t a, ident_t b, char sep) { if (a == NULL) return b; else if (b == NULL) return a; else if (sep == '\0') { hash_state_t hash = HASH_INIT; hash_update(&hash, a->bytes, a->length); hash_update(&hash, b->bytes, b->length); const char *str_vec[] = { a->bytes, b->bytes }; const size_t len_vec[] = { a->length, b->length }; return ident_from_byte_vec(hash, false, 2, str_vec, len_vec); } else { hash_state_t hash = HASH_INIT; hash_update(&hash, a->bytes, a->length); hash_update(&hash, &sep, 1); hash_update(&hash, b->bytes, b->length); const char *str_vec[] = { a->bytes, &sep, b->bytes }; const size_t len_vec[] = { a->length, 1, b->length }; return ident_from_byte_vec(hash, false, 3, str_vec, len_vec); } } bool ident_starts_with(ident_t a, ident_t b) { return b != NULL && (a == b || strncmp(a->bytes, b->bytes, b->length) == 0); } char ident_char(ident_t i, unsigned n) { assert(i != NULL); assert(n < i->length); return i->bytes[n]; } int ident_pos(ident_t i, char ch) { assert(i != NULL); for (int pos = 0; pos < i->length; pos++) { if (i->bytes[pos] == ch) return pos; } return -1; } size_t ident_len(ident_t i) { return i == NULL ? 0 : i->length; } ident_t ident_until(ident_t i, char c) { assert(i != NULL); int pos = 0; for (; pos < i->length && i->bytes[pos] != c; pos++); if (pos == i->length) return i; hash_state_t hash = HASH_INIT; hash_update(&hash, i->bytes, pos); return ident_from_bytes(i->bytes, hash, pos); } ident_t ident_runtil(ident_t i, char c) { assert(i != NULL); int pos = i->length; for (; pos >= 0 && i->bytes[pos] != c; pos--); if (pos < 0) return i; hash_state_t hash = HASH_INIT; hash_update(&hash, i->bytes, pos); return ident_from_bytes(i->bytes, hash, pos); } ident_t ident_from(ident_t i, char c) { assert(i != NULL); int pos = 0; for (; pos < i->length && i->bytes[pos] != c; pos++); if (pos == i->length) return NULL; hash_state_t hash = HASH_INIT; hash_update(&hash, i->bytes + pos + 1, i->length - pos - 1); return ident_from_bytes(i->bytes + pos + 1, hash, i->length - pos - 1); } ident_t ident_rfrom(ident_t i, char c) { assert(i != NULL); int pos = i->length; for (; pos >= 0 && i->bytes[pos] != c; pos--); if (pos < 0) return i; hash_state_t hash = HASH_INIT; hash_update(&hash, i->bytes + pos + 1, i->length - pos - 1); return ident_from_bytes(i->bytes + pos + 1, hash, i->length - pos - 1); } bool icmp(ident_t i, const char *s) { if (i == NULL || s == NULL) return i == NULL && s == NULL; return strcmp(i->bytes, s) == 0; } int ident_compare(ident_t a, ident_t b) { return strcmp(a->bytes, b->bytes); } static bool ident_glob_walk(const char *str, const char *g) { if (*str == '\0') return *g == '\0'; else if (*g == '\0') return false; else if (*g == '*') return ident_glob_walk(str + 1, g) || ident_glob_walk(str + 1, g + 1); else if (*str == *g) return ident_glob_walk(str + 1, g + 1); else return false; } bool ident_glob(ident_t i, const char *glob, int length) { assert(i != NULL); return ident_glob_walk(i->bytes, glob); } ident_t ident_downcase(ident_t i) { assert(i != NULL); char small[64], *big = NULL, *buf = small; if (i->length >= ARRAY_LEN(small)) buf = big = xmalloc(i->length + 1); for (int pos = 0; pos < i->length; pos++) buf[pos] = tolower_iso88591(i->bytes[pos]); buf[i->length] = '\0'; hash_state_t hash = HASH_INIT; hash_update(&hash, buf, i->length); ident_t result = ident_from_bytes(buf, hash, i->length); if (big != NULL) free(big); return result; } ident_t ident_walk_selected(ident_t *it) { if (*it == NULL) return NULL; ident_t i = *it; char escape = '\0'; int pos = 0; for (; pos < i->length; pos++) { if (i->bytes[pos] == '.' && escape == '\0') break; else if (i->bytes[pos] == '\'' && escape != '\\') escape = escape == '\'' ? '\0' : '\''; else if (i->bytes[pos] == '\\' && escape != '\'') escape = escape == '\\' ? '\0' : '\\'; } if (pos == i->length) { *it = NULL; return i; } hash_state_t hash = HASH_INIT; hash_update(&hash, i->bytes + pos + 1, i->length - pos - 1); *it = ident_from_bytes(i->bytes + pos + 1, hash, i->length - pos - 1); hash = HASH_INIT; hash_update(&hash, i->bytes, pos); return ident_from_bytes(i->bytes, hash, pos); } int ident_distance(ident_t a, ident_t b) { const int n = b->length; const int m = a->length; const char *s = a->bytes, *t = b->bytes; int mem[2 * (n + 1)], *v0 = mem, *v1 = mem + n + 1; for (int i = 0; i <= n; i++) v0[i] = i; for (int i = 0; i < m; i++) { v1[0] = i + 1; for (int j = 0; j < n; j++) { const int dc = v0[j + 1] + 1; const int ic = v1[j] + 1; const int sc = (s[i] == t[j] ? v0[j] : v0[j] + 1); v1[j + 1] = MIN(dc, MIN(ic, sc)); } int *tmp = v0; v0 = v1; v1 = tmp; } return v0[n]; } uint32_t ident_hash(ident_t i) { return i->hash[0]; } uint32_t ident_casehash(ident_t i) { if (i->hash[1] != 0) return i->hash[1]; hash_state_t hash = HASH_INIT; for (int n = 0; n < i->length; n++) hash = ((hash << 5) + hash) + toupper_iso88591(i->bytes[n]); return (i->hash[1] = mix_bits_32(hash)); } bool ident_casecmp(ident_t a, ident_t b) { if (a == b) return true; else if (a->length != b->length) return false; #ifdef ARCH_X86_64 __m128i lower = _mm_set1_epi8('a' - 1); __m128i upper = _mm_set1_epi8('z' + 1); __m128i delta = _mm_set1_epi8('a' - 'A'); for (int pos = 0; pos < a->length; pos += 16) { __m128i av = _mm_load_si128((const __m128i *)(a->bytes + pos)); __m128i bv = _mm_load_si128((const __m128i *)(b->bytes + pos)); __m128i a_mask = _mm_and_si128(_mm_cmpgt_epi8(av, lower), _mm_cmplt_epi8(av, upper)); __m128i b_mask = _mm_and_si128(_mm_cmpgt_epi8(bv, lower), _mm_cmplt_epi8(bv, upper)); __m128i a_toupper = _mm_sub_epi8(av, _mm_and_si128(a_mask, delta)); __m128i b_toupper = _mm_sub_epi8(bv, _mm_and_si128(b_mask, delta)); __m128i cmp = _mm_cmpeq_epi8(a_toupper, b_toupper); if (_mm_movemask_epi8(cmp) != 0xffff) return false; } #else for (int i = 0; i < a->length; i++) { if (toupper_iso88591(a->bytes[i]) != toupper_iso88591(b->bytes[i])) return false; } #endif return true; } #if PRINT_STATS __attribute__((destructor)) static void print_ident_stats(void) { ident_tab_t *tab = atomic_load(&table); size_t count = 0; for (size_t i = 0; i < tab->size; i++) { if (tab->slots[i] != NULL) count++; } debugf("%zd unique identifiers in size %zd table", count, tab->size); } #endif nvc-r1.17.1/src/ident.h000066400000000000000000000060121504111170000146010ustar00rootroot00000000000000// // Copyright (C) 2011-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _IDENT_H #define _IDENT_H #include "prim.h" // Intern a string as an identifier. ident_t ident_new(const char *str); ident_t ident_new_n(const char *str, size_t len); // Generate a unique identifier with the given prefix. ident_t ident_uniq(const char *prefix, ...) __attribute__((format(printf, 1, 2))); ident_t ident_sprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); // Create a new identifier which is a prepended to b separated // by a dot. ident_t ident_prefix(ident_t a, ident_t b, char sep); // True if identifier a starts with b bool ident_starts_with(ident_t a, ident_t b); // Return the Nth character of an identifier char ident_char(ident_t i, unsigned n); // Return the first position of character ch or -1 int ident_pos(ident_t i, char ch); // Number of characters in the identifier size_t ident_len(ident_t i); // Return the prefix of i that does not include c ident_t ident_until(ident_t i, char c); // Return the prefix of i up to the final c ident_t ident_runtil(ident_t i, char c); // Return the suffix of i from the final c ident_t ident_rfrom(ident_t i, char c); // Return the suffix of i from the first c ident_t ident_from(ident_t i, char c); // Compare identifier against a NULL-terminated string bool icmp(ident_t i, const char *s); // Compare two identifiers for lexical ordering int ident_compare(ident_t a, ident_t b); // Compare identifier against a pattern containing wildcards // Length is optional and may be set to -1 but improves performance // if set to the length of glob bool ident_glob(ident_t i, const char *glob, int length); uint32_t ident_hash(ident_t i); uint32_t ident_casehash(ident_t i); bool ident_casecmp(ident_t a, ident_t b); // Convert an indentifier to lower case ident_t ident_downcase(ident_t i); // Iterate through dot-separated name components ident_t ident_walk_selected(ident_t *i); // Convert an identifier reference to a NULL-terminated string const char *istr(ident_t ident); // Compute Levenshtein distance between two identifiers int ident_distance(ident_t a, ident_t b); ident_wr_ctx_t ident_write_begin(fbuf_t *f); void ident_write(ident_t ident, ident_wr_ctx_t ctx); void ident_write_end(ident_wr_ctx_t ctx); ident_rd_ctx_t ident_read_begin(fbuf_t *f); ident_t ident_read(ident_rd_ctx_t ctx); void ident_read_end(ident_rd_ctx_t ctx); #endif // _IDENT_H nvc-r1.17.1/src/inst.c000066400000000000000000000256121504111170000144550ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "inst.h" #include "phase.h" #include "type.h" #include "tree.h" #include typedef A(tree_t) tree_list_t; typedef A(type_t) type_list_t; typedef struct { tree_list_t copied_subs; type_list_t copied_types; } copy_ctx_t; static void collect_decls(tree_t t, hset_t **decls, tree_list_t *roots); static void tree_copy_cb(tree_t t, void *__ctx) { copy_ctx_t *ctx = __ctx; if (is_subprogram(t)) APUSH(ctx->copied_subs, t); } static void type_copy_cb(type_t type, void *__ctx) { copy_ctx_t *ctx = __ctx; if (type_has_ident(type)) APUSH(ctx->copied_types, type); } void copy_with_renaming(tree_t *roots, int nroots, tree_copy_pred_t tree_pred, type_copy_pred_t type_pred, void *context, ident_t dotted, const ident_t *prefixes, int nprefix) { copy_ctx_t copy_ctx = {}; tree_copy(roots, nroots, tree_pred, type_pred, context, tree_copy_cb, type_copy_cb, ©_ctx); // Change the name of any copied types to reflect the new hiearchy for (int i = 0; i < copy_ctx.copied_types.count; i++) { type_t type = copy_ctx.copied_types.items[i]; ident_t orig = type_ident(type); for (int j = 0; j < nprefix; j++) { if (ident_starts_with(orig, prefixes[j])) { LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, istr(dotted)); tb_cat(tb, istr(orig) + ident_len(prefixes[j])); type_set_ident(type, ident_new(tb_get(tb))); break; } } } ACLEAR(copy_ctx.copied_types); // Change the mangled name of copied subprograms so that copies in // different instances do not collide for (int i = 0; i < copy_ctx.copied_subs.count; i++) { tree_t decl = copy_ctx.copied_subs.items[i]; if (tree_kind(decl) == T_GENERIC_DECL) continue; // Does not yet have mangled name else if (is_open_coded_builtin(tree_subkind(decl))) continue; // Has no mangled name ident_t orig = tree_ident2(decl); for (int j = 0; j < nprefix; j++) { if (ident_starts_with(orig, prefixes[j])) { ident_t prefix = ident_runtil(orig, '('); LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, istr(dotted)); tb_cat(tb, istr(prefix) + ident_len(prefixes[j])); const tree_kind_t kind = tree_kind(decl); const bool is_func = kind == T_FUNC_BODY || kind == T_FUNC_DECL; const int nports = tree_ports(decl); if (nports > 0 || is_func) tb_append(tb, '('); for (int k = 0; k < nports; k++) { tree_t p = tree_port(decl, k); if (tree_class(p) == C_SIGNAL) tb_printf(tb, "s"); mangle_one_type(tb, tree_type(p)); } if (nports > 0 || is_func) tb_printf(tb, ")"); if (is_func) mangle_one_type(tb, type_result(tree_type(decl))); if (tree_flags(decl) & TREE_F_PREDEFINED) tb_cat(tb, "$predef"); ident_t mangled = ident_new(tb_get(tb)); tree_set_ident2(decl, mangled); break; } } } ACLEAR(copy_ctx.copied_subs); } static bool instantiate_should_copy_type(type_t type, void *__ctx) { hset_t *decls = __ctx; if (decls == NULL || type_kind(type) == T_SUBTYPE) return false; else return hset_contains(decls, type); } static bool instantiate_should_copy_tree(tree_t t, void *__ctx) { hset_t *decls = __ctx; switch (tree_kind(t)) { case T_INSTANCE: return true; case T_FCALL: // Globally static expressions should be copied and folded if ((tree_flags(t) & TREE_F_GLOBALLY_STATIC) && type_is_scalar(tree_type(t))) return true; else if (tree_has_ref(t) && tree_kind(tree_ref(t)) == T_GENERIC_DECL) return true; // Call to generic subprogram else return false; case T_PACKAGE: case T_PACK_BODY: return true; case T_FUNC_DECL: case T_PROC_DECL: return !(tree_flags(t) & TREE_F_PREDEFINED); case T_FUNC_BODY: case T_PROC_BODY: case T_FUNC_INST: case T_PROC_INST: return true; case T_CONST_DECL: case T_VAR_DECL: case T_GENERIC_DECL: case T_SIGNAL_DECL: // Make a unique copy of all public declarations in the package return decls != NULL && hset_contains(decls, t); case T_REF: return tree_has_ref(t) && tree_kind(tree_ref(t)) == T_GENERIC_DECL; default: return false; } } static void collect_generic_types(hset_t **decls, type_t type) { hset_insert(*decls, type); // Also collect any anonymous generic types switch (type_subkind(type)) { case GTYPE_ARRAY: { type_t elem = type_elem(type); if (type_kind(elem) == T_GENERIC && !type_has_ident(elem)) collect_generic_types(decls, elem); const int nindex = type_indexes(type); for (int i = 0; i < nindex; i++) { type_t index = type_index(type, i); if (type_kind(index) == T_GENERIC && !type_has_ident(index)) collect_generic_types(decls, index); } } break; default: break; } } static void collect_generics(tree_t t, hset_t **decls, tree_list_t *roots) { const int ngenerics = tree_generics(t); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(t, i); const class_t class = tree_class(g); if (class == C_CONSTANT) continue; else if (*decls == NULL) *decls = hset_new(64); // If the uninstantiated unit has any package generics then we // need to copy those too in order to fix up the types switch (tree_class(g)) { case C_PACKAGE: { tree_t ref = tree_value(g); if (tree_has_ref(ref)) { tree_t pack = tree_ref(ref); assert(is_uninstantiated_package(pack)); collect_generics(pack, decls, roots); collect_decls(pack, decls, roots); APUSH(*roots, pack); } } break; case C_TYPE: collect_generic_types(decls, tree_type(g)); break; default: break; } } } static void collect_decls(tree_t t, hset_t **decls, tree_list_t *roots) { if (*decls == NULL) *decls = hset_new(64); switch (tree_kind(t)) { case T_PACKAGE: case T_FUNC_BODY: case T_FUNC_DECL: case T_PROC_BODY: case T_PROC_DECL: { // Must make a unique copy of all package generics const int ngenerics = tree_generics(t); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(t, i); hset_insert(*decls, g); } } break; default: break; } const int ndecls = tree_decls(t); for (int i = 0 ; i < ndecls; i++) { tree_t d = tree_decl(t, i); hset_insert(*decls, d); switch (tree_kind(d)) { case T_PACKAGE: collect_generics(d, decls, roots); // Fall-through case T_PACK_BODY: case T_PACK_INST: collect_decls(d, decls, roots); break; case T_TYPE_DECL: hset_insert(*decls, type_base_recur(tree_type(d))); break; case T_PROT_DECL: case T_PROT_BODY: hset_insert(*decls, tree_type(d)); collect_decls(d, decls, roots); break; default: break; } } } void new_instance(tree_t *roots, int nroots, ident_t dotted, const ident_t *prefixes, int nprefix) { tree_list_t troots = AINIT; for (int i = 0; i < nroots; i++) APUSH(troots, roots[i]); hset_t *decls = NULL; for (int i = 0; i < nroots; i++) { switch (tree_kind(roots[i])) { case T_ENTITY: case T_FUNC_DECL: case T_PROC_DECL: case T_COMPONENT: collect_generics(roots[i], &decls, &troots); break; case T_PACKAGE: case T_FUNC_BODY: case T_PROC_BODY: case T_FUNC_INST: case T_PROC_INST: collect_generics(roots[i], &decls, &troots); collect_decls(roots[i], &decls, &troots); break; case T_PACK_BODY: collect_decls(roots[i], &decls, &troots); break; default: break; } } copy_with_renaming(troots.items, troots.count, instantiate_should_copy_tree, instantiate_should_copy_type, decls, dotted, prefixes, nprefix); for (int i = 0; i < nroots; i++) roots[i] = troots.items[i]; ACLEAR(troots); if (decls != NULL) hset_free(decls); } static type_t rewrite_generic_types_cb(type_t type, void *__ctx) { hash_t *map = __ctx; return hash_get(map, type) ?: type; } static tree_t instance_fixup_cb(tree_t t, void *__ctx) { hash_t *map = __ctx; switch (tree_kind(t)) { case T_REF: if (tree_flags(t) & (TREE_F_FORMAL_NAME | TREE_F_ATTR_PREFIX)) return t; // Do not rewrite names in generic maps // Fall-through case T_FCALL: case T_PCALL: case T_PROT_FCALL: case T_PROT_PCALL: if (tree_has_ref(t)) { tree_t new = hash_get(map, tree_ref(t)); if (new == NULL) return t; else if (is_literal(new)) return new; else tree_set_ref(t, new); } break; case T_VAR_DECL: case T_SIGNAL_DECL: case T_CONST_DECL: { type_t type = tree_type(t); if (type_is_unconstrained(type) && !tree_has_value(t)) error_at(tree_loc(t), "declaration of %s %s cannot have " "unconstrained type %s", class_str(class_of(t)), istr(tree_ident(t)), type_pp(type)); } break; default: break; } return t; } static void instance_hint_cb(diag_t *d, void *ctx) { tree_t inst = ctx; diag_hint(d, tree_loc(inst), "while instantiating %s", istr(tree_ident(inst))); } void instance_fixup(tree_t inst, hash_t *map) { diag_add_hint_fn(instance_hint_cb, inst); tree_rewrite(inst, NULL, instance_fixup_cb, rewrite_generic_types_cb, map); diag_remove_hint_fn(instance_hint_cb); } nvc-r1.17.1/src/inst.h000066400000000000000000000022401504111170000144520ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _INST_H #define _INST_H #include "prim.h" #include "tree.h" void new_instance(tree_t *roots, int nroots, ident_t dotted, const ident_t *prefixes, int nprefix); void instance_fixup(tree_t inst, hash_t *map); void copy_with_renaming(tree_t *roots, int nroots, tree_copy_pred_t tree_pred, type_copy_pred_t type_pred, void *context, ident_t dotted, const ident_t *prefixes, int nprefix); #endif // _INST_H nvc-r1.17.1/src/jit/000077500000000000000000000000001504111170000141145ustar00rootroot00000000000000nvc-r1.17.1/src/jit/Makemodule.am000066400000000000000000000010211504111170000165100ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/jit/jit.h \ src/jit/jit-priv.h \ src/jit/jit-core.c \ src/jit/jit-irgen.c \ src/jit/jit-dump.c \ src/jit/jit-interp.c \ src/jit/jit-exits.h \ src/jit/jit-exits.c \ src/jit/jit-optim.c \ src/jit/jit-ffi.h \ src/jit/jit-ffi.c \ src/jit/jit-code.c \ src/jit/jit-pack.c \ src/jit/jit-layout.h \ src/jit/jit-layout.c \ src/jit/jit-intrin.c if ARCH_X86_64 lib_libnvc_a_SOURCES += src/jit/jit-x86.c endif if ENABLE_LLVM lib_libnvc_a_SOURCES += src/jit/jit-llvm.c src/jit/jit-llvm.h endif nvc-r1.17.1/src/jit/jit-code.c000066400000000000000000001221361504111170000157630ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "cpustate.h" #include "debug.h" #include "hash.h" #include "ident.h" #include "jit/jit-priv.h" #include "option.h" #include "thread.h" #include #include #include #include #include #include #include #if defined __MINGW32__ #include #elif defined __APPLE__ #include #include #include #include #include #include #else #include #endif #ifdef HAVE_CAPSTONE #include #endif #ifndef R_AARCH64_MOVW_UABS_G0_NC #define R_AARCH64_MOVW_UABS_G0_NC 264 #endif #ifndef R_AARCH64_MOVW_UABS_G1_NC #define R_AARCH64_MOVW_UABS_G1_NC 266 #endif #ifndef R_AARCH64_MOVW_UABS_G2_NC #define R_AARCH64_MOVW_UABS_G2_NC 268 #endif #ifndef R_AARCH64_MOVW_UABS_G3 #define R_AARCH64_MOVW_UABS_G3 269 #endif #ifndef SHT_X86_64_UNWIND #define SHT_X86_64_UNWIND 0x70000001 #endif #ifndef IMAGE_REL_ARM64_BRANCH26 #define IMAGE_REL_ARM64_BRANCH26 0x03 #endif #ifndef IMAGE_REL_ARM64_ADDR32NB #define IMAGE_REL_ARM64_ADDR32NB 0x02 #endif #ifndef IMAGE_REL_ARM64_PAGEBASE_REL21 #define IMAGE_REL_ARM64_PAGEBASE_REL21 0x04 #endif #ifndef IMAGE_REL_ARM64_PAGEOFFSET_12A #define IMAGE_REL_ARM64_PAGEOFFSET_12A 0x06 #endif #ifndef IMAGE_REL_ARM64_PAGEOFFSET_12L #define IMAGE_REL_ARM64_PAGEOFFSET_12L 0x07 #endif #define CODE_PAGE_ALIGN 4096 #define CODE_PAGE_SIZE 0x400000 #define THREAD_CACHE_SIZE 0x10000 #define CODE_BLOB_ALIGN 256 #define MIN_BLOB_SIZE 0x4000 #define __IMM64(x) __IMM32(x), __IMM32((x) >> 32) #define __IMM32(x) __IMM16(x), __IMM16((x) >> 16) #define __IMM16(x) (x) & 0xff, ((x) >> 8) & 0xff STATIC_ASSERT(MIN_BLOB_SIZE <= THREAD_CACHE_SIZE); STATIC_ASSERT(MIN_BLOB_SIZE % CODE_BLOB_ALIGN == 0); STATIC_ASSERT(CODE_PAGE_SIZE % THREAD_CACHE_SIZE == 0); typedef struct _code_page code_page_t; typedef struct { uintptr_t addr; char *text; } code_comment_t; typedef struct { unsigned count; unsigned max; code_comment_t *comments; } code_debug_t; typedef struct _code_span { code_cache_t *owner; code_span_t *next; ident_t name; uint8_t *base; void *entry; size_t size; #ifdef DEBUG code_debug_t debug; #endif } code_span_t; typedef struct _patch_list { patch_list_t *next; uint8_t *wptr; jit_label_t label; code_patch_fn_t fn; } patch_list_t; typedef struct _code_page { code_cache_t *owner; code_page_t *next; uint8_t *mem; } code_page_t; typedef struct _code_cache { nvc_lock_t lock; code_page_t *pages; code_span_t *spans; code_span_t *freelist[MAX_THREADS]; code_span_t *globalfree; shash_t *symbols; FILE *perfmap; #ifdef HAVE_CAPSTONE csh capstone; #endif #ifdef DEBUG size_t used; #endif } code_cache_t; static void code_disassemble(code_span_t *span, uintptr_t mark, struct cpu_state *cpu); static void code_cache_unwinder(uintptr_t addr, debug_frame_t *frame, void *context) { code_cache_t *code = context; const uint8_t *pc = (uint8_t *)addr; for (code_span_t *span = code->spans; span; span = span->next) { if (pc >= span->base && pc < span->base + span->size) { frame->kind = FRAME_VHDL; frame->disp = pc - span->base; frame->symbol = istr(span->name); } } } static void code_fault_handler(int sig, void *addr, struct cpu_state *cpu, void *context) { code_page_t *page = context; const uint8_t *pc = (uint8_t *)cpu->pc; if (pc < page->mem || pc > page->mem + CODE_PAGE_SIZE) return; uintptr_t mark = cpu->pc; #ifndef __MINGW32__ if (sig == SIGTRAP) mark--; // Point to faulting instruction #endif for (code_span_t *span = page->owner->spans; span; span = span->next) { if (pc >= span->base && pc < span->base + span->size && span->name) code_disassemble(span, mark, cpu); } } #ifdef DEBUG static bool code_cache_contains(code_cache_t *code, uint8_t *base, size_t size) { assert_lock_held(&code->lock); for (code_page_t *p = code->pages; p; p = p->next) { if (base >= p->mem && base + size <= p->mem + CODE_PAGE_SIZE) return true; } return false; } #endif static code_span_t *code_span_new(code_cache_t *code, ident_t name, uint8_t *base, size_t size) { SCOPED_LOCK(code->lock); assert(code_cache_contains(code, base, size)); code_span_t *span = xcalloc(sizeof(code_span_t)); span->name = name; span->next = code->spans; span->base = base; span->entry = base; span->size = size; span->owner = code; code->spans = span; return span; } static void code_page_new(code_cache_t *code) { assert_lock_held(&code->lock); code_page_t *page = xcalloc(sizeof(code_page_t)); page->owner = code; page->next = code->pages; page->mem = map_jit_pages(CODE_PAGE_ALIGN, CODE_PAGE_SIZE); add_fault_handler(code_fault_handler, page); debug_add_unwinder(page->mem, CODE_PAGE_SIZE, code_cache_unwinder, code); code->pages = page; code_span_t *span = xcalloc(sizeof(code_span_t)); span->next = code->spans; span->base = page->mem; span->size = CODE_PAGE_SIZE; span->owner = code; code->globalfree = code->spans = span; } code_cache_t *code_cache_new(void) { code_cache_t *code = xcalloc(sizeof(code_cache_t)); { SCOPED_LOCK(code->lock); code_page_new(code); } #ifdef HAVE_CAPSTONE #if defined ARCH_X86_64 if (cs_open(CS_ARCH_X86, CS_MODE_64, &(code->capstone)) != CS_ERR_OK) fatal_trace("failed to init capstone for x86_64"); #elif defined ARCH_ARM64 if (cs_open(CS_ARCH_ARM64, CS_MODE_ARM, &(code->capstone)) != CS_ERR_OK) fatal_trace("failed to init capstone for Arm64"); #else #error Cannot configure capstone for this architecture #endif if (cs_option(code->capstone, CS_OPT_DETAIL, 1) != CS_ERR_OK) fatal_trace("failed to set capstone detailed mode"); #endif shash_t *s = shash_new(32); extern void __nvc_putpriv(jit_handle_t, void *); extern void __nvc_sched_waveform(jit_anchor_t *, jit_scalar_t *, tlab_t *); extern void __nvc_sched_process(jit_anchor_t *, jit_scalar_t *, tlab_t *); extern void __nvc_test_event(jit_anchor_t *, jit_scalar_t *, tlab_t *); extern void __nvc_last_event(jit_anchor_t *, jit_scalar_t *, tlab_t *); extern void __nvc_pack(const uint8_t *, int32_t, jit_scalar_t *); extern void __nvc_unpack(uint64_t, uint64_t, jit_scalar_t *); shash_put(s, "__nvc_sched_waveform", &__nvc_sched_waveform); shash_put(s, "__nvc_sched_process", &__nvc_sched_process); shash_put(s, "__nvc_test_event", &__nvc_test_event); shash_put(s, "__nvc_last_event", &__nvc_last_event); shash_put(s, "__nvc_mspace_alloc", &__nvc_mspace_alloc); shash_put(s, "__nvc_putpriv", &__nvc_putpriv); shash_put(s, "__nvc_do_exit", &__nvc_do_exit); shash_put(s, "__nvc_pack", &__nvc_pack); shash_put(s, "__nvc_unpack", &__nvc_unpack); shash_put(s, "memmove", &memmove); shash_put(s, "memcpy", &memcpy); shash_put(s, "memset", &memset); shash_put(s, "pow", &pow); #if defined __APPLE__ && defined ARCH_ARM64 shash_put(s, "bzero", &bzero); #elif defined __APPLE__ && defined ARCH_X86_64 shash_put(s, "__bzero", &bzero); #elif defined __MINGW32__ && defined ARCH_X86_64 extern void ___chkstk_ms(void); shash_put(s, "___chkstk_ms", &___chkstk_ms); #endif store_release(&code->symbols, s); return code; } void code_cache_free(code_cache_t *code) { for (code_page_t *it = code->pages, *tmp; it; it = tmp) { debug_remove_unwinder(it->mem); remove_fault_handler(code_fault_handler, it); nvc_munmap(it->mem, CODE_PAGE_SIZE); tmp = it->next; free(it); } for (code_span_t *it = code->spans, *tmp; it; it = tmp) { tmp = it->next; DEBUG_ONLY(free(it->debug.comments)); free(it); } #ifdef HAVE_CAPSTONE cs_close(&(code->capstone)); #endif #ifdef DEBUG if (code->used > 0) debugf("JIT code footprint: %zu bytes", code->used); #endif shash_free(code->symbols); free(code); } #ifdef HAVE_CAPSTONE static int code_print_spaces(int col, int tab) { for (; col < tab; col++) fputc(' ', stdout); return col; } #endif #if defined DEBUG && HAVE_CAPSTONE static int code_comment_compare(const void *a, const void *b) { const code_comment_t *ca = a; const code_comment_t *cb = b; if (ca->addr < cb->addr) return -1; else if (ca->addr > cb->addr) return 1; else return 0; } #endif static void code_disassemble(code_span_t *span, uintptr_t mark, struct cpu_state *cpu) { SCOPED_LOCK(span->owner->lock); printf("--"); const int namelen = ident_len(span->name); for (int i = 0; i < 72 - namelen; i++) fputc('-', stdout); printf(" %s ----\n", istr(span->name)); #ifdef HAVE_CAPSTONE cs_insn *insn = cs_malloc(span->owner->capstone); #ifdef DEBUG qsort(span->debug.comments, span->debug.count, sizeof(code_comment_t), code_comment_compare); code_comment_t *comment = span->debug.comments; #endif const uint8_t *const eptr = span->base + span->size; for (const uint8_t *ptr = span->base; ptr < eptr; ) { uint64_t address = (uint64_t)ptr; #ifdef DEBUG for (; comment < span->debug.comments + span->debug.count && comment->addr <= address; comment++) printf("%30s;; %s\n", "", comment->text); #endif int zeros = 0; for (const uint8_t *zp = ptr; zp < eptr && *zp == 0; zp++, zeros++); if (zeros > 8 || zeros == eptr - ptr) { printf("%30s;; skipping %d zero bytes\n", "", zeros); ptr += zeros; continue; } size_t size = eptr - ptr; int col = 0; if (cs_disasm_iter(span->owner->capstone, &ptr, &size, &address, insn)) { char hex1[33], *p = hex1; for (size_t k = 0; k < insn->size; k++) p += checked_sprintf(p, hex1 + sizeof(hex1) - p, "%02x", insn->bytes[k]); col = printf("%-12" PRIx64 " %-16.16s %s %s", insn->address, hex1, insn->mnemonic, insn->op_str); #ifdef ARCH_X86_64 if (strcmp(insn->mnemonic, "movabs") == 0) { const cs_x86_op *src = &(insn->detail->x86.operands[1]); if (src->type == X86_OP_IMM) { const char *sym = debug_symbol_name((void *)src->imm); if (sym != NULL) { col = code_print_spaces(col, 60); col += printf(" ; %s", sym); } } } #endif if (strlen(hex1) > 16) col = printf("\n%15s -%-16s", "", hex1 + 16) - 1; } else { #ifdef ARCH_ARM64 col = printf("%-12" PRIx64 " %-16.08x %s 0x%08x", (uint64_t)ptr, *(uint32_t *)ptr, ".word", *(uint32_t *)ptr); ptr += 4; #else col = printf("%-12" PRIx64 " %-16.02x %s 0x%02x", (uint64_t)ptr, *ptr, ".byte", *ptr); ptr++; #endif } if (mark != 0 && (ptr >= eptr || address > mark)) { col = code_print_spaces(col, 66); printf("<=============\n"); if (cpu != NULL) { #ifdef ARCH_X86_64 const char *names[] = { "RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15" }; for (int i = 0; i < ARRAY_LEN(names); i++) printf("\t%s\t%"PRIxPTR"\n", names[i], cpu->regs[i]); #else for (int i = 0; i < 32; i++) printf("\tR%d\t%"PRIxPTR"\n", i, cpu->regs[i]); #endif } mark = 0; } else printf("\n"); } cs_free(insn, 1); #else jit_hexdump(span->base, span->size, 16, (void *)mark, ""); #endif for (int i = 0; i < 80; i++) fputc('-', stdout); printf("\n"); fflush(stdout); } static void code_write_perf_map(code_span_t *span) { SCOPED_LOCK(span->owner->lock); if (span->owner->perfmap == NULL) { char *fname LOCAL = xasprintf("/tmp/perf-%d.map", getpid()); if ((span->owner->perfmap = fopen(fname, "w")) == NULL) { warnf("cannot create %s: %s", fname, last_os_error()); opt_set_int(OPT_PERF_MAP, 0); return; } else debugf("writing perf map to %s", fname); } fprintf(span->owner->perfmap, "%p 0x%zx %s\n", span->base, span->size, istr(span->name)); fflush(span->owner->perfmap); } code_blob_t *code_blob_new(code_cache_t *code, ident_t name, size_t hint) { code_span_t **freeptr = &(code->freelist[thread_id()]); code_span_t *free = relaxed_load(freeptr); if (free == NULL) { free = code_span_new(code, NULL, code->pages->mem, 0); relaxed_store(freeptr, free); } const size_t reqsz = hint ?: MIN_BLOB_SIZE; if (free->size < reqsz) { SCOPED_LOCK(code->lock); #ifdef DEBUG if (free->size > 0) debugf("thread %d needs new code cache from global free list " "(requested %zu bytes, wasted %zu bytes)", thread_id(), reqsz, free->size); #endif const size_t chunksz = MAX(reqsz, THREAD_CACHE_SIZE); const size_t alignedsz = ALIGN_UP(chunksz, CODE_BLOB_ALIGN); if (alignedsz > code->globalfree->size) { DEBUG_ONLY(debugf("requesting new %d byte code page", CODE_PAGE_SIZE)); code_page_new(code); assert(code->globalfree->size == CODE_PAGE_SIZE); } const size_t take = MIN(code->globalfree->size, alignedsz); free->size = take; free->base = code->globalfree->base; code->globalfree->base += take; code->globalfree->size -= take; } assert(reqsz <= free->size); assert(((uintptr_t)free->base & (CODE_BLOB_ALIGN - 1)) == 0); code_span_t *span = code_span_new(code, name, free->base, free->size); free->base += span->size; free->size -= span->size; code_blob_t *blob = xcalloc(sizeof(code_blob_t)); blob->span = span; blob->wptr = span->base; thread_wx_mode(WX_WRITE); return blob; } void code_blob_finalise(code_blob_t *blob, jit_entry_fn_t *entry) { code_span_t *span = blob->span; span->size = blob->wptr - span->base; code_span_t *freespan = relaxed_load(&(span->owner->freelist[thread_id()])); assert(freespan->size == 0); ihash_free(blob->labels); blob->labels = NULL; if (unlikely(blob->patches != NULL)) fatal_trace("not all labels in %s were patched", istr(span->name)); else if (unlikely(blob->overflow)) { // Return all the memory freespan->size = freespan->base - span->base; freespan->base = span->base; free(blob); return; } else if (span->size == 0) fatal_trace("code span %s is empty", istr(span->name)); uint8_t *aligned = ALIGN_UP(blob->wptr, CODE_BLOB_ALIGN); freespan->size = freespan->base - aligned; freespan->base = aligned; if (opt_get_verbose(OPT_ASM_VERBOSE, istr(span->name))) { color_printf("\n$bold$$blue$"); code_disassemble(span, 0, NULL); color_printf("$$\n"); } __builtin___clear_cache((char *)span->base, (char *)blob->wptr); thread_wx_mode(WX_EXECUTE); store_release(entry, (jit_entry_fn_t)span->entry); DEBUG_ONLY(relaxed_add(&span->owner->used, span->size)); free(blob); if (opt_get_int(OPT_PERF_MAP)) code_write_perf_map(span); } __attribute__((cold, noinline)) static void code_blob_overflow(code_blob_t *blob) { warnf("JIT code buffer for %s too small", istr(blob->span->name)); for (patch_list_t *it = blob->patches, *tmp; it; it = tmp) { tmp = it->next; free(it); } blob->patches = NULL; blob->overflow = true; } void code_blob_emit(code_blob_t *blob, const uint8_t *bytes, size_t len) { if (unlikely(blob->overflow)) return; else if (unlikely(blob->wptr + len > blob->span->base + blob->span->size)) { code_blob_overflow(blob); return; } memcpy(blob->wptr, bytes, len); blob->wptr += len; } void code_blob_align(code_blob_t *blob, unsigned align) { #ifdef ARCH_X86_64 const uint8_t pad[] = { 0x90 }; #else const uint8_t pad[] = { 0x00 }; #endif assert(is_power_of_2(align)); assert(align % ARRAY_LEN(pad) == 0); while (((uintptr_t)blob->wptr & (align - 1)) && !blob->overflow) code_blob_emit(blob, pad, ARRAY_LEN(pad)); } void code_blob_mark(code_blob_t *blob, jit_label_t label) { if (unlikely(blob->overflow)) return; else if (blob->labels == NULL) blob->labels = ihash_new(256); ihash_put(blob->labels, label, blob->wptr); for (patch_list_t **p = &(blob->patches); *p; ) { if ((*p)->label == label) { patch_list_t *next = (*p)->next; (*(*p)->fn)(blob, label, (*p)->wptr, blob->wptr); free(*p); *p = next; } else p = &((*p)->next); } } void code_blob_patch(code_blob_t *blob, jit_label_t label, code_patch_fn_t fn) { void *ptr = NULL; if (unlikely(blob->overflow)) return; else if (blob->labels != NULL && (ptr = ihash_get(blob->labels, label))) (*fn)(blob, label, blob->wptr, ptr); else { patch_list_t *new = xmalloc(sizeof(patch_list_t)); new->next = blob->patches; new->fn = fn; new->label = label; new->wptr = blob->wptr; blob->patches = new; } } #ifdef DEBUG static void code_blob_print_value(text_buf_t *tb, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: tb_printf(tb, "R%d", value.reg); break; case JIT_VALUE_INT64: if (value.int64 < 4096) tb_printf(tb, "#%"PRIi64, value.int64); else tb_printf(tb, "#0x%"PRIx64, value.int64); break; case JIT_VALUE_DOUBLE: tb_printf(tb, "%%%g", value.dval); break; case JIT_ADDR_CPOOL: tb_printf(tb, "[CP+%"PRIi64"]", value.int64); break; case JIT_ADDR_REG: tb_printf(tb, "[R%d", value.reg); if (value.disp != 0) tb_printf(tb, "+%d", value.disp); tb_cat(tb, "]"); break; case JIT_ADDR_ABS: tb_printf(tb, "[#%016"PRIx64"]", value.int64); break; case JIT_ADDR_COVER: tb_printf(tb, "@%"PRIi64, value.int64); break; case JIT_VALUE_LABEL: tb_printf(tb, "%d", value.label); break; case JIT_VALUE_HANDLE: tb_printf(tb, "<%d>", value.handle); break; case JIT_VALUE_EXIT: tb_printf(tb, "%s", jit_exit_name(value.exit)); break; case JIT_VALUE_LOC: tb_printf(tb, "<%s:%d>", loc_file_str(&value.loc), value.loc.first_line); break; case JIT_VALUE_LOCUS: tb_printf(tb, "%p", value.locus); break; case JIT_VALUE_VPOS: tb_printf(tb, "%u:%u", value.vpos.block, value.vpos.op); break; default: tb_cat(tb, "???"); } } static void code_blob_add_comment(code_blob_t *blob, uintptr_t addr, char *text) { code_debug_t *dbg = &(blob->span->debug); if (dbg->count == dbg->max) { dbg->max = MAX(128, dbg->max * 2); dbg->comments = xrealloc_array(dbg->comments, dbg->max, sizeof(code_comment_t)); } dbg->comments[dbg->count].addr = addr; dbg->comments[dbg->count].text = text; dbg->count++; } void code_blob_print_ir(code_blob_t *blob, jit_ir_t *ir) { LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "%s%s", jit_op_name(ir->op), jit_cc_name(ir->cc)); if (ir->size != JIT_SZ_UNSPEC) tb_printf(tb, ".%d", 1 << (3 + ir->size)); tb_printf(tb, "%*.s", (int)MAX(0, 10 - tb_len(tb)), ""); if (ir->result != JIT_REG_INVALID) tb_printf(tb, "R%d", ir->result); if (ir->arg1.kind != JIT_VALUE_INVALID) { if (ir->result != JIT_REG_INVALID) tb_cat(tb, ", "); code_blob_print_value(tb, ir->arg1); } if (ir->arg2.kind != JIT_VALUE_INVALID) { tb_cat(tb, ", "); code_blob_print_value(tb, ir->arg2); } code_blob_add_comment(blob, (uintptr_t)blob->wptr, tb_claim(tb)); } void code_blob_printf(code_blob_t *blob, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *text = xvasprintf(fmt, ap); code_blob_add_comment(blob, (uintptr_t)blob->wptr, text); va_end(ap); } __attribute__((format(printf, 3, 4))) static void debug_reloc(code_blob_t *blob, void *patch, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *text = xvasprintf(fmt, ap); code_blob_add_comment(blob, (uintptr_t)patch, text); va_end(ap); } #else #define debug_reloc(...) #endif // DEBUG #ifdef ARCH_ARM64 static void arm64_patch_page_offset21(code_blob_t *blob, uint32_t *patch, void *ptr) { switch ((*patch >> 23) & 0x7f) { case 0b1111010: // LDR (immediate, SIMD&FP) case 0b1110010: // LDR (immediate) assert(*patch & (1 << 30)); // Quadword assert(((uintptr_t)ptr & 7) == 0); *patch |= (((uintptr_t)ptr & 0xfff) >> 3) << 10; break; case 0b0100010: // ADD (immediate) *patch |= ((uintptr_t)ptr & 0xfff) << 10; break; default: blob->span->size = blob->wptr - blob->span->base; code_disassemble(blob->span, (uintptr_t)patch, NULL); fatal_trace("cannot patch instruction"); } } static void arm64_patch_page_base_rel21(uint32_t *patch, void *ptr) { const intptr_t dst_page = (intptr_t)ptr & ~UINT64_C(0xfff); const intptr_t src_page = (intptr_t)patch & ~UINT64_C(0xfff); const intptr_t upper21 = (dst_page - src_page) >> 12; assert((upper21 & ~UINT64_C(0x1fffff)) == 0); *(uint32_t *)patch |= (upper21 & 3) << 29; *(uint32_t *)patch |= ((upper21 >> 2) & 0x7ffff) << 5; } #endif static void *code_emit_trampoline(code_blob_t *blob, void *dest) { #if defined ARCH_X86_64 const uint8_t veneer[] = { 0x48, 0xb8, __IMM64((uintptr_t)dest), // MOVABS RAX, dest 0xff, 0xe0 // CALL RAX }; #elif defined ARCH_ARM64 const uint8_t veneer[] = { 0x50, 0x00, 0x00, 0x58, // LDR X16, [PC+8] 0x00, 0x02, 0x1f, 0xd6, // BR X16 __IMM64((uintptr_t)dest) }; #else should_not_reach_here(); #endif void *prev = memmem(blob->veneers, blob->wptr - blob->veneers, veneer, ARRAY_LEN(veneer)); if (prev != NULL) return prev; else { DEBUG_ONLY(code_blob_printf(blob, "Trampoline for %p", dest)); void *addr = blob->wptr; code_blob_emit(blob, veneer, ARRAY_LEN(veneer)); return addr; } } #if !defined __MINGW32__ && !defined __APPLE__ static void *code_emit_got(code_blob_t *blob, void *dest) { const uint8_t data[] = { __IMM64((uintptr_t)dest) }; void *prev = memmem(blob->veneers, blob->veneers - blob->wptr, data, ARRAY_LEN(data)); if (prev != NULL) return prev; else { DEBUG_ONLY(code_blob_printf(blob, "GOT entry for %p", dest)); void *addr = blob->wptr; code_blob_emit(blob, data, ARRAY_LEN(data)); return addr; } } #endif #if defined __MINGW32__ static void code_load_pe(code_blob_t *blob, const void *data, size_t size) { const IMAGE_FILE_HEADER *imghdr = data; switch (imghdr->Machine) { case IMAGE_FILE_MACHINE_AMD64: case IMAGE_FILE_MACHINE_ARM64: break; default: fatal_trace("unknown target machine %x", imghdr->Machine); } const IMAGE_SYMBOL *symtab = data + imghdr->PointerToSymbolTable; const char *strtab = data + imghdr->PointerToSymbolTable + imghdr->NumberOfSymbols * sizeof(IMAGE_SYMBOL); const IMAGE_SECTION_HEADER *sections = data + IMAGE_SIZEOF_FILE_HEADER + imghdr->SizeOfOptionalHeader; void **load_addr LOCAL = xmalloc_array(imghdr->NumberOfSections, sizeof(void *)); for (int i = 0; i < imghdr->NumberOfSections; i++) { if ((sections[i].Characteristics & IMAGE_SCN_CNT_CODE) || (sections[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)) { const int align = sections[i].Characteristics & IMAGE_SCN_ALIGN_MASK; code_blob_align(blob, 1 << ((align >> 20) - 1)); load_addr[i] = blob->wptr; code_blob_emit(blob, data + sections[i].PointerToRawData, sections[i].SizeOfRawData); } else if ((sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) && sections[i].Misc.VirtualSize > 0) fatal_trace("non-empty BSS not supported"); } if (blob->overflow) return; // Relocations might point outside of code span blob->veneers = blob->wptr; shash_t *external = load_acquire(&blob->span->owner->symbols); for (int i = 0; i < imghdr->NumberOfSections; i++) { const IMAGE_RELOCATION *relocs = data + sections[i].PointerToRelocations; for (int j = 0; j < sections[i].NumberOfRelocations; j++) { const char *name = NULL; char tmp[9]; assert(relocs[j].SymbolTableIndex < imghdr->NumberOfSymbols); const IMAGE_SYMBOL *sym = symtab + relocs[j].SymbolTableIndex; if (sym->N.Name.Short) { memcpy(tmp, sym->N.ShortName, 8); tmp[8] = '\0'; name = tmp; } else name = strtab + sym->N.Name.Long; void *ptr = NULL; if (sym->SectionNumber > 0) { assert(sym->SectionNumber - 1 < imghdr->NumberOfSections); ptr = load_addr[sym->SectionNumber - 1] + sym->Value; } else ptr = shash_get(external, name); if (ptr == NULL && icmp(blob->span->name, name)) ptr = blob->span->base; if (ptr == NULL) fatal_trace("failed to resolve symbol %s", name); void *patch = load_addr[i] + relocs[j].VirtualAddress; assert((uint8_t *)patch >= blob->span->base); assert((uint8_t *)patch < blob->span->base + blob->span->size); switch (relocs[j].Type) { #if defined ARCH_X86_64 case IMAGE_REL_AMD64_ADDR64: *(uint64_t *)patch += (uint64_t)ptr; break; case IMAGE_REL_AMD64_ADDR32NB: *(uint32_t *)patch += (uint32_t)(ptr - (void *)blob->span->base); break; #elif defined ARCH_ARM64 case IMAGE_REL_ARM64_BRANCH26: { void *veneer = code_emit_trampoline(blob, ptr); const ptrdiff_t pcrel = (veneer - patch) >> 2; *(uint32_t *)patch &= ~0x3ffffff; *(uint32_t *)patch |= pcrel & 0x3ffffff; } break; case IMAGE_REL_ARM64_ADDR32NB: *(uint32_t *)patch += (uint32_t)(ptr - (void *)blob->span->base); break; case IMAGE_REL_ARM64_PAGEBASE_REL21: arm64_patch_page_base_rel21(patch, ptr); break; case IMAGE_REL_ARM64_PAGEOFFSET_12A: case IMAGE_REL_ARM64_PAGEOFFSET_12L: arm64_patch_page_offset21(blob, patch, ptr); break; #endif default: blob->span->size = blob->wptr - blob->span->base; code_disassemble(blob->span, (uintptr_t)patch, NULL); fatal_trace("cannot handle relocation type %d for symbol %s", relocs[j].Type, name); } } if (strncmp((const char *)sections[i].Name, ".pdata", IMAGE_SIZEOF_SHORT_NAME) == 0) { assert(sections[i].SizeOfRawData % sizeof(RUNTIME_FUNCTION) == 0); const int count = sections[i].SizeOfRawData / sizeof(RUNTIME_FUNCTION); const DWORD64 base = (DWORD64)blob->span->base; // TODO: we should also call RtlDeleteFunctionTable at some point if (!RtlAddFunctionTable(load_addr[i], count, base)) fatal_trace("RtlAddFunctionTable failed: %s", last_os_error()); } } for (int i = 0; i < imghdr->NumberOfSymbols; i++) { const IMAGE_SYMBOL *sym = &(symtab[i]); if (sym->SectionNumber == 0 || sym->N.Name.Short) continue; else if ((sym->Type >> 4) != IMAGE_SYM_DTYPE_FUNCTION) continue; else if (icmp(blob->span->name, strtab + sym->N.Name.Long)) { blob->span->entry = load_addr[sym->SectionNumber - 1] + sym->Value; break; } } } #elif defined __APPLE__ static void code_load_macho(code_blob_t *blob, const void *data, size_t size) { const void *rptr = data; const struct mach_header_64 *fhdr = rptr; rptr += sizeof(struct mach_header_64); if (fhdr->magic != MH_MAGIC_64) fatal_trace("bad Mach-O magic %x", fhdr->magic); const struct segment_command_64 *seg = NULL; const struct symtab_command *symtab = NULL; void **load_addr LOCAL = NULL; for (int i = 0; i < fhdr->ncmds; i++) { const struct load_command *load = rptr; switch (load->cmd) { case LC_SEGMENT_64: { seg = rptr; load_addr = xmalloc_array(seg->nsects, sizeof(void *)); for (int j = 0; j < seg->nsects; j++) { const struct section_64 *sec = (void *)seg + sizeof(struct segment_command_64) + j * sizeof(struct section_64); code_blob_align(blob, 1 << sec->align); load_addr[j] = blob->wptr; DEBUG_ONLY(code_blob_printf(blob, "%s", sec->sectname)); code_blob_emit(blob, data + sec->offset, sec->size); } } break; case LC_SYMTAB: symtab = rptr; assert(symtab->cmdsize == sizeof(struct symtab_command)); break; case LC_DATA_IN_CODE: case LC_LINKER_OPTIMIZATION_HINT: case LC_BUILD_VERSION: case LC_DYSYMTAB: break; default: warnf("unrecognised load command 0x%0x", load->cmd); } rptr += load->cmdsize; } assert(rptr == data + sizeof(struct mach_header_64) + fhdr->sizeofcmds); if (blob->overflow) return; // Relocations might point outside of code span blob->veneers = blob->wptr; assert(seg != NULL); assert(symtab != NULL); shash_t *external = load_acquire(&blob->span->owner->symbols); for (int i = 0; i < seg->nsects; i++) { const struct section_64 *sec = (void *)seg + sizeof(struct segment_command_64) + i * sizeof(struct section_64); uint32_t addend = 0; for (int j = 0; j < sec->nreloc; j++) { const struct relocation_info *rel = data + sec->reloff + j * sizeof(struct relocation_info); const char *name = NULL; void *ptr = NULL; if (rel->r_extern) { assert(rel->r_symbolnum < symtab->nsyms); const struct nlist_64 *nl = data + symtab->symoff + rel->r_symbolnum * sizeof(struct nlist_64); name = data + symtab->stroff + nl->n_un.n_strx; if (nl->n_type & N_EXT) { if (icmp(blob->span->name, name + 1)) ptr = blob->span->base; else if ((ptr = shash_get(external, name + 1)) == NULL) fatal_trace("failed to resolve symbol %s", name + 1); } else if (nl->n_sect != NO_SECT) ptr = blob->span->base + nl->n_value; } else ptr = blob->span->base; ptr += addend; addend = 0; void *patch = load_addr[i] + rel->r_address; assert((uint8_t *)patch >= blob->span->base); assert((uint8_t *)patch < blob->span->base + blob->span->size); switch (rel->r_type) { #ifdef ARCH_ARM64 case ARM64_RELOC_UNSIGNED: assert(rel->r_length == 3); *(void **)patch = ptr; break; case ARM64_RELOC_SUBTRACTOR: break; // What is this? case ARM64_RELOC_GOT_LOAD_PAGEOFF12: case ARM64_RELOC_PAGEOFF12: arm64_patch_page_offset21(blob, patch, ptr); break; case ARM64_RELOC_GOT_LOAD_PAGE21: case ARM64_RELOC_PAGE21: arm64_patch_page_base_rel21(patch, ptr); break; case ARM64_RELOC_BRANCH26: { void *veneer = code_emit_trampoline(blob, ptr); const ptrdiff_t pcrel = (veneer - patch) >> 2; debug_reloc(blob, patch, "ARM64_RELOC_BRANCH26 %s PC%+"PRIiPTR, name, pcrel); *(uint32_t *)patch &= ~0x3ffffff; *(uint32_t *)patch |= pcrel & 0x3ffffff; } break; case ARM64_RELOC_ADDEND: addend = rel->r_symbolnum; break; #elif defined ARCH_X86_64 case X86_64_RELOC_UNSIGNED: *(uint64_t *)patch += (uint64_t)ptr; break; case X86_64_RELOC_BRANCH: *(uint32_t *)patch += (uint32_t)(ptr - patch - 4); break; #endif default: blob->span->size = blob->wptr - blob->span->base; code_disassemble(blob->span, (uintptr_t)patch, NULL); fatal_trace("cannot handle relocation type %d for symbol %s", rel->r_type, name); } } } for (int i = 0; i < symtab->nsyms; i++) { const struct nlist_64 *sym = data + symtab->symoff + i * sizeof(struct nlist_64); if (sym->n_sect == NO_SECT || (sym->n_type & N_TYPE) != N_SECT) continue; const char *name = data + symtab->stroff + sym->n_un.n_strx; if (name[0] == '_' && icmp(blob->span->name, name + 1)) { blob->span->entry = load_addr[sym->n_sect - 1] + sym->n_value; break; } } } #elif !defined __MINGW32__ static void code_load_elf(code_blob_t *blob, const void *data, size_t size) { const Elf64_Ehdr *ehdr = data; if (ehdr->e_ident[EI_MAG0] != ELFMAG0 || ehdr->e_ident[EI_MAG1] != ELFMAG1 || ehdr->e_ident[EI_MAG2] != ELFMAG2 || ehdr->e_ident[EI_MAG3] != ELFMAG3) fatal_trace("bad ELF magic"); else if (ehdr->e_shentsize != sizeof(Elf64_Shdr)) fatal_trace("bad section header size %d != %zu", ehdr->e_shentsize, sizeof(Elf64_Shdr)); const Elf64_Shdr *strtab_hdr = data + ehdr->e_shoff + ehdr->e_shstrndx * ehdr->e_shentsize; const char *strtab = data + strtab_hdr->sh_offset; void **load_addr LOCAL = xcalloc_array(ehdr->e_shnum, sizeof(void *)); for (int i = 0; i < ehdr->e_shnum; i++) { const Elf64_Shdr *shdr = data + ehdr->e_shoff + i * ehdr->e_shentsize; switch (shdr->sh_type) { case SHT_PROGBITS: if (shdr->sh_flags & SHF_ALLOC) { code_blob_align(blob, shdr->sh_addralign); load_addr[i] = blob->wptr; DEBUG_ONLY(code_blob_printf(blob, "%s", strtab + shdr->sh_name)); code_blob_emit(blob, data + shdr->sh_offset, shdr->sh_size); } break; case SHT_RELA: // Handled in second pass break; case SHT_NULL: case SHT_STRTAB: case SHT_X86_64_UNWIND: break; case SHT_SYMTAB: for (int i = 0; i < shdr->sh_size / shdr->sh_entsize; i++) { const Elf64_Sym *sym = data + shdr->sh_offset + i * shdr->sh_entsize; if (ELF64_ST_TYPE(sym->st_info) != STT_FUNC) continue; else if (!icmp(blob->span->name, strtab + sym->st_name)) continue; else if (load_addr[sym->st_shndx] == NULL) fatal_trace("missing section %d for symbol %s", sym->st_shndx, strtab + sym->st_name); else { blob->span->entry = load_addr[sym->st_shndx] + sym->st_value; break; } } break; default: warnf("ignoring ELF section %s with type %x", strtab + shdr->sh_name, shdr->sh_type); } } if (blob->overflow) return; // Relocations might point outside of code span blob->veneers = blob->wptr; shash_t *external = load_acquire(&blob->span->owner->symbols); for (int i = 0; i < ehdr->e_shnum; i++) { const Elf64_Shdr *shdr = data + ehdr->e_shoff + i * ehdr->e_shentsize; if (shdr->sh_type != SHT_RELA) continue; const Elf64_Shdr *mod = data + ehdr->e_shoff + shdr->sh_info * ehdr->e_shentsize; if (mod->sh_type != SHT_PROGBITS || !(mod->sh_flags & SHF_ALLOC)) continue; else if (load_addr[shdr->sh_info] == NULL) fatal_trace("section %s not loaded", strtab + mod->sh_name); const Elf64_Shdr *symtab = data + ehdr->e_shoff + shdr->sh_link * ehdr->e_shentsize; if (symtab->sh_type != SHT_SYMTAB) fatal_trace("section %s is not a symbol table", strtab + symtab->sh_name); const Elf64_Rela *endp = data + shdr->sh_offset + shdr->sh_size; for (const Elf64_Rela *r = data + shdr->sh_offset; r < endp; r++) { const Elf64_Sym *sym = data + symtab->sh_offset + ELF64_R_SYM(r->r_info) * symtab->sh_entsize; void *ptr = NULL; switch (ELF64_ST_TYPE(sym->st_info)) { case STT_NOTYPE: case STT_FUNC: if (sym->st_shndx == 0) ptr = shash_get(external, strtab + sym->st_name); else ptr = load_addr[sym->st_shndx] + sym->st_value; break; case STT_SECTION: ptr = load_addr[sym->st_shndx]; break; default: fatal_trace("cannot handle ELF symbol type %d", ELF64_ST_TYPE(sym->st_info)); } if (ptr == NULL) fatal_trace("cannot resolve symbol %s type %d", strtab + sym->st_name, ELF64_ST_TYPE(sym->st_info)); void *patch = load_addr[shdr->sh_info] + r->r_offset; assert(r->r_offset < mod->sh_size); switch (ELF64_R_TYPE(r->r_info)) { case R_X86_64_64: debug_reloc(blob, patch, "R_X86_64_64 %s", strtab + sym->st_name); *(uint64_t *)patch = (uint64_t)ptr + r->r_addend; break; case R_X86_64_PC32: { const ptrdiff_t pcrel = ptr + r->r_addend - patch; debug_reloc(blob, patch, "R_X86_64_PC32 %s PC%+"PRIiPTR, strtab + sym->st_name, pcrel); assert(pcrel >= INT32_MIN && pcrel <= INT32_MAX); *(uint32_t *)patch = pcrel; } break; case R_X86_64_GOTPCREL: { void *got = code_emit_got(blob, ptr); const ptrdiff_t pcrel = got + r->r_addend - patch; debug_reloc(blob, patch, "R_X86_64_GOTPCREL %s PC%+"PRIiPTR, strtab + sym->st_name, pcrel); assert(pcrel >= INT32_MIN && pcrel <= INT32_MAX); *(uint32_t *)patch = pcrel; } break; case R_X86_64_PLT32: { void *veneer = code_emit_trampoline(blob, ptr); const ptrdiff_t pcrel = veneer + r->r_addend - patch; debug_reloc(blob, patch, "R_X86_64_PLT32 %s PC%+"PRIiPTR, strtab + sym->st_name, pcrel); assert(pcrel >= INT32_MIN && pcrel <= INT32_MAX); *(uint32_t *)patch = pcrel; } break; case R_AARCH64_CALL26: { void *veneer = code_emit_trampoline(blob, ptr); const ptrdiff_t pcrel = (veneer + r->r_addend - patch) >> 2; *(uint32_t *)patch &= ~0x3ffffff; *(uint32_t *)patch |= pcrel & 0x3ffffff; } break; case R_AARCH64_PREL64: *(uint64_t *)patch = ptr + r->r_addend - patch; break; case R_AARCH64_MOVW_UABS_G0_NC: *(uint32_t *)patch |= (((uintptr_t)ptr + r->r_addend) & 0xffff) << 5; break; case R_AARCH64_MOVW_UABS_G1_NC: *(uint32_t *)patch |= ((((uintptr_t)ptr + r->r_addend) >> 16) & 0xffff) << 5; break; case R_AARCH64_MOVW_UABS_G2_NC: *(uint32_t *)patch |= ((((uintptr_t)ptr + r->r_addend) >> 32) & 0xffff) << 5; break; case R_AARCH64_MOVW_UABS_G3: *(uint32_t *)patch |= ((((uintptr_t)ptr + r->r_addend) >> 48) & 0xffff) << 5; break; default: blob->span->size = blob->wptr - blob->span->base; code_disassemble(blob->span, (uintptr_t)patch, NULL); fatal_trace("cannot handle relocation type %ld for symbol %s", ELF64_R_TYPE(r->r_info), strtab + sym->st_name); } } } } #endif void code_load_object(code_blob_t *blob, const void *data, size_t size) { #if defined __APPLE__ code_load_macho(blob, data, size); #elif defined __MINGW32__ code_load_pe(blob, data, size); #else code_load_elf(blob, data, size); #endif } nvc-r1.17.1/src/jit/jit-core.c000066400000000000000000001147361504111170000160100ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "debug.h" #include "diag.h" #include "hash.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "object.h" #include "option.h" #include "rt/model.h" #include "rt/mspace.h" #include "rt/structs.h" #include "thread.h" #include "tree.h" #include "type.h" #include "vcode.h" #include #include #include #include #include #include #include #define FUNC_HASH_SZ 1024 #define FUNC_LIST_SZ 512 #define COMPILE_TIMEOUT 10000 typedef struct _jit_cover_page jit_cover_page_t; typedef struct _jit_tier { jit_tier_t *next; int threshold; jit_plugin_t plugin; void *context; } jit_tier_t; typedef struct { size_t length; jit_func_t *items[0]; } func_array_t; typedef struct _aot_dll { jit_dll_t *dll; jit_pack_t *pack; } aot_dll_t; typedef struct { reloc_kind_t kind; union { uintptr_t off; void *ptr; }; } aot_reloc_t; // The code generator knows the layout of this struct typedef struct { jit_entry_fn_t entry; const char *strtab; const uint8_t *debug; const uint8_t *cpool; aot_reloc_t relocs[0]; } aot_descr_t; typedef struct _jit_cover_page { jit_cover_page_t *next; unsigned ntags; int32_t tags[]; } jit_cover_page_t; typedef struct _jit { chash_t *index; mspace_t *mspace; void *lower_ctx; bool silent; bool shutdown; int exit_status; jit_tier_t *tiers; aot_dll_t *aotlib; jit_pack_t *pack; func_array_t *funcs; unsigned next_handle; nvc_lock_t lock; jit_cover_page_t *cover_pages; int32_t *cover_mem; jit_irq_fn_t interrupt; void *interrupt_ctx; unit_registry_t *registry; mir_context_t *mir; } jit_t; static void jit_transition(jit_t *j, jit_state_t from, jit_state_t to); static void jit_oom_cb(mspace_t *m, size_t size) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "out of memory attempting to allocate %zu byte object", size); const size_t heapsize = opt_get_size(OPT_HEAP_SIZE); diag_hint(d, NULL, "the current heap size is %zu bytes which you can " "increase with the $bold$-H$$ option, for example $bold$-H %zum$$", heapsize, MAX(1, (heapsize * 2) / 1024 / 1024)); diag_emit(d); jit_abort_with_status(EXIT_FAILURE); } static inline jit_thread_local_t **jit_thread_local_ptr(void) { #ifdef USE_EMUTLS static jit_thread_local_t *local = NULL; assert(thread_id() == 0); #else static __thread jit_thread_local_t *local = NULL; #endif return &local; } jit_thread_local_t *jit_thread_local(void) { jit_thread_local_t **ptr = jit_thread_local_ptr(); if (unlikely(*ptr == NULL)) { *ptr = xcalloc(sizeof(jit_thread_local_t)); (*ptr)->state = JIT_IDLE; } return *ptr; } jit_t *jit_new(unit_registry_t *ur, mir_context_t *mc) { jit_t *j = xcalloc(sizeof(jit_t)); j->registry = ur; j->index = chash_new(FUNC_HASH_SZ); j->mspace = mspace_new(opt_get_size(OPT_HEAP_SIZE)); j->exit_status = INT_MIN; j->mir = mc; j->funcs = xcalloc_flex(sizeof(func_array_t), FUNC_LIST_SZ, sizeof(jit_func_t *)); j->funcs->length = FUNC_LIST_SZ; mspace_set_oom_handler(j->mspace, jit_oom_cb); // Ensure we can resolve symbols from the executable ffi_load_dll(NULL); return j; } static void jit_free_func(jit_func_t *f) { mptr_free(f->jit->mspace, &(f->privdata)); free(f->irbuf); free(f->linktab); if (f->owns_cpool) free(f->cpool); free(f); } void jit_free(jit_t *j) { store_release(&j->shutdown, true); async_barrier(); aot_dll_t *libs[] = { j->aotlib }; for (int i = 0; i < ARRAY_LEN(libs); i++) { if (libs[i] != NULL) { ffi_unload_dll(libs[i]->dll); jit_pack_free(libs[i]->pack); free(libs[i]); } } if (j->pack != NULL) jit_pack_free(j->pack); for (int i = 0; i < j->next_handle; i++) jit_free_func(j->funcs->items[i]); free(j->funcs); for (jit_cover_page_t *p = j->cover_pages, *tmp; p; p = tmp) { tmp = p->next; free(p); } for (jit_tier_t *it = j->tiers, *tmp; it; it = tmp) { tmp = it->next; (*it->plugin.cleanup)(it->context); free(it); } mspace_destroy(j->mspace); chash_free(j->index); free(j); } bool jit_is_shutdown(jit_t *j) { return load_acquire(&j->shutdown); } mspace_t *jit_get_mspace(jit_t *j) { return j->mspace; } void *jit_mspace_alloc(size_t size) { jit_thread_local_t *thread = jit_thread_local(); assert(thread->state == JIT_RUNNING); return mspace_alloc(thread->jit->mspace, size); } static void jit_install(jit_t *j, jit_func_t *f) { assert_lock_held(&(j->lock)); func_array_t *list = j->funcs; if (f->handle >= list->length) { const size_t newlen = MAX(f->handle + 1, list->length * 2); func_array_t *new = xcalloc_flex(sizeof(func_array_t), newlen, sizeof(jit_func_t *)); new->length = newlen; for (size_t i = 0; i < list->length; i++) new->items[i] = list->items[i]; // Synchronises with load_acquire in jit_get_func store_release(&(j->funcs), new); async_free(list); list = new; } // Synchronises with load_acquire in jit_get_func store_release(&(list->items[f->handle]), f); chash_put(j->index, f->name, f); } static jit_handle_t jit_lazy_compile_locked(jit_t *j, ident_t name) { assert_lock_held(&j->lock); jit_func_t *f = chash_get(j->index, name); if (f != NULL) return f->handle; aot_descr_t *descr = NULL; if (j->aotlib != NULL) { LOCAL_TEXT_BUF tb = safe_symbol(name); tb_cat(tb, ".descr"); aot_dll_t *try[] = { j->aotlib }; for (int i = 0; i < ARRAY_LEN(try); i++) { if (try[i] == NULL) continue; else if ((descr = ffi_find_symbol(try[i]->dll, tb_get(tb)))) { jit_pack_put(try[i]->pack, name, descr->cpool, descr->strtab, descr->debug); break; } } } jit_entry_fn_t entry = jit_bind_intrinsic(name) ?: (descr ? descr->entry : jit_interp); f = xcalloc(sizeof(jit_func_t)); f->name = name; f->state = descr ? JIT_FUNC_COMPILING : JIT_FUNC_PLACEHOLDER; f->jit = j; f->handle = j->next_handle++; f->next_tier = j->tiers; f->hotness = f->next_tier ? f->next_tier->threshold : 0; f->entry = entry; // Install now to allow circular references in relocations jit_install(j, f); if (descr != NULL) { for (aot_reloc_t *r = descr->relocs; r->kind != RELOC_NULL; r++) { const char *str = descr->strtab + r->off; if (r->kind == RELOC_COVER) { // TODO: get rid of the double indirection here by // allocating coverage memory earlier r->ptr = &(j->cover_mem); } else if (r->kind == RELOC_PROCESSED) { // Detect musl libc brokenness diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "shared library containing %s was not properly " "unloaded", istr(f->name)); diag_hint(d, NULL, "this is probably because your libc does not " "implement dlclose(3) correctly"); diag_hint(d, NULL, "run the $bold$-e$$ and $bold$-r$$ steps in " "separate commands as a workaround"); diag_emit(d); fatal_exit(1); } else { jit_handle_t h = jit_lazy_compile_locked(j, ident_new(str)); if (h == JIT_HANDLE_INVALID) fatal_trace("relocation against invalid function %s", str); switch (r->kind) { case RELOC_FUNC: r->ptr = jit_get_func(j, h); break; case RELOC_HANDLE: r->ptr = (void *)(uintptr_t)h; break; case RELOC_PRIVDATA: r->ptr = jit_get_privdata_ptr(j, jit_get_func(j, h)); break; default: fatal_trace("unhandled relocation kind %d", r->kind); } } r->kind = RELOC_PROCESSED; } store_release(&f->state, JIT_FUNC_READY); } return f->handle; } jit_handle_t jit_lazy_compile(jit_t *j, ident_t name) { jit_func_t *f = chash_get(j->index, name); if (f != NULL) return f->handle; SCOPED_LOCK(j->lock); return jit_lazy_compile_locked(j, name); } jit_func_t *jit_get_func(jit_t *j, jit_handle_t handle) { assert(handle != JIT_HANDLE_INVALID); // Synchronises with store_release in jit_install func_array_t *list = load_acquire(&(j->funcs)); assert(handle < list->length); // Synchronises with store_release in jit_install jit_func_t *f = load_acquire(&(list->items[handle])); assert(f != NULL); return f; } static inline bool jit_fill_from_aot(jit_func_t *f, aot_dll_t *lib) { return lib != NULL && jit_pack_fill(lib->pack, f->jit, f); } __attribute__((noreturn)) static void jit_missing_unit(jit_func_t *f) { tree_t unit = lib_get_qualified(f->name); if (unit != NULL && tree_kind(unit) == T_PACKAGE) jit_msg(tree_loc(unit), DIAG_FATAL, "missing body for package %s", istr(f->name)); else jit_msg(NULL, DIAG_FATAL, "missing body for %s", istr(f->name)); __builtin_unreachable(); } void jit_fill_irbuf(jit_func_t *f) { const func_state_t state = load_acquire(&(f->state)); switch (state) { case JIT_FUNC_READY: if (f->irbuf != NULL) return; // Fall-through case JIT_FUNC_PLACEHOLDER: if (atomic_cas(&(f->state), state, JIT_FUNC_COMPILING)) break; // Fall-through case JIT_FUNC_COMPILING: // Another thread is compiling this function for (int timeout = 0; load_acquire(&(f->state)) != JIT_FUNC_READY; ) { if (++timeout % COMPILE_TIMEOUT == 0) warnf("waiting for %s to finish compiling", istr(f->name)); thread_sleep(100); } return; case JIT_FUNC_ERROR: jit_missing_unit(f); break; default: fatal_trace("illegal function state for %s", istr(f->name)); } assert(f->irbuf == NULL); #ifndef USE_EMUTLS const jit_state_t oldstate = jit_thread_local()->state; jit_transition(f->jit, oldstate, JIT_COMPILING); #endif if (jit_fill_from_aot(f, f->jit->aotlib)) goto done; if (f->jit->pack != NULL && jit_pack_fill(f->jit->pack, f->jit, f)) goto done; mir_unit_t *mu = mir_get_unit(f->jit->mir, f->name); if (mu == NULL && f->jit->registry != NULL) { // Unit registry and MIR import is not thread-safe SCOPED_LOCK(f->jit->lock); (void)unit_registry_get(f->jit->registry, f->name); mu = mir_get_unit(f->jit->mir, f->name); } if (mu == NULL) { store_release(&(f->state), JIT_FUNC_ERROR); jit_missing_unit(f); } jit_irgen(f, mu); done: #ifndef USE_EMUTLS jit_transition(f->jit, JIT_COMPILING, oldstate); #endif } jit_handle_t jit_compile(jit_t *j, ident_t name) { jit_handle_t handle = jit_lazy_compile(j, name); if (handle == JIT_HANDLE_INVALID) return handle; jit_func_t *f = jit_get_func(j, handle); jit_fill_irbuf(f); return handle; } void *jit_link(jit_t *j, jit_handle_t handle) { if (handle == JIT_HANDLE_INVALID) return NULL; jit_func_t *f = jit_get_func(j, handle); if (f->privdata != MPTR_INVALID) return *mptr_get(f->privdata); f->privdata = mptr_new(j->mspace, "privdata"); jit_fill_irbuf(f); tlab_t tlab = jit_null_tlab(j); jit_scalar_t p1 = { .pointer = NULL }, p2 = p1, result; if (!jit_fastcall(j, f->handle, &result, p1, p2, &tlab)) { error_at(&(f->object->loc), "failed to initialise %s", istr(f->name)); result.pointer = NULL; } else if (result.pointer == NULL) fatal_trace("link %s returned NULL", istr(f->name)); else if (f->privdata == MPTR_INVALID) fatal_trace("cannot link unit %s", istr(f->name)); // Initialisation should save the context pointer assert(result.pointer == *mptr_get(f->privdata)); return result.pointer; } void **jit_get_privdata_ptr(jit_t *j, jit_func_t *f) { if (f->privdata == MPTR_INVALID) f->privdata = mptr_new(j->mspace, "privdata"); return mptr_get(f->privdata); } void *jit_get_frame_var(jit_t *j, jit_handle_t handle, ident_t name) { jit_func_t *f = jit_get_func(j, handle); if (f->privdata == MPTR_INVALID) fatal_trace("%s not linked", istr(f->name)); jit_fill_irbuf(f); for (int i = 0; i < f->nvars; i++) { if (f->linktab[i].name == name) return *mptr_get(f->privdata) + f->linktab[i].offset; } fatal_trace("%s has no variable %s", istr(f->name), istr(name)); } static void jit_emit_trace(diag_t *d, const loc_t *loc, object_t *enclosing, const char *symbol) { tree_t tree = tree_from_object(enclosing); if (tree != NULL) { switch (tree_kind(tree)) { case T_PROCESS: { rt_proc_t *proc = get_active_proc(); const char *name = istr(proc ? proc->name : tree_ident(tree)); diag_trace(d, loc, "Process$$ %s", name); } break; case T_ATTR_SPEC: assert(ident_casecmp(tree_ident(tree), well_known(W_FOREIGN))); diag_trace(d, loc, "Subprogram$$ %s", type_pp(tree_type(tree_ref(tree)))); break; case T_FUNC_BODY: case T_FUNC_DECL: diag_trace(d, loc, "Function$$ %s", type_pp(tree_type(tree))); break; case T_PROC_BODY: case T_PROC_DECL: diag_trace(d, loc, "Procedure$$ %s", type_pp(tree_type(tree))); break; case T_TYPE_DECL: if (strstr(symbol, "$value")) diag_trace(d, loc, "Attribute$$ %s'VALUE", istr(tree_ident(tree))); else diag_trace(d, loc, "Type$$ %s", istr(tree_ident(tree))); break; case T_BLOCK: diag_trace(d, loc, "Process$$ (init)"); break; case T_PACKAGE: case T_PACK_BODY: case T_PACK_INST: diag_trace(d, loc, "Package$$ %s", istr(tree_ident(tree))); break; case T_INERTIAL: diag_trace(d, loc, "Equivalent process"); break; case T_TYPE_CONV: diag_trace(d, loc, "Type conversion %s", type_pp(tree_type(tree))); break; case T_PARAM_DECL: diag_trace(d, loc, "Parameter %s", istr(tree_ident(tree))); break; case T_PARAM: diag_trace(d, loc, "Port conversion"); break; default: { const char *class = class_str(class_of(tree)); diag_trace(d, loc, "%c%s %s", toupper_iso88591(class[0]), class + 1, istr(tree_ident(tree))); } break; } } } jit_stack_trace_t *jit_stack_trace(void) { jit_thread_local_t *thread = jit_thread_local(); int count = 0; for (jit_anchor_t *a = thread->anchor; a; a = a->caller) count++; jit_stack_trace_t *stack = xmalloc_flex(sizeof(jit_stack_trace_t), count, sizeof(jit_frame_t)); stack->count = count; jit_frame_t *frame = stack->frames; for (jit_anchor_t *a = thread->anchor; a; a = a->caller, frame++) { frame->loc = LOC_INVALID; frame->symbol = a->func->name; frame->object = NULL; #ifdef USE_EMUTLS if (load_acquire(&a->func->state) == JIT_FUNC_COMPILING) continue; // Cannot use jit_transition in jit_fill_irbuf #endif jit_fill_irbuf(a->func); frame->object = a->func->object; // Scan backwards to find the last debug info assert(a->irpos < a->func->nirs); frame->loc = frame->object ? frame->object->loc : LOC_INVALID; for (jit_ir_t *ir = &(a->func->irbuf[a->irpos]); ir >= a->func->irbuf; ir--) { if (ir->op == J_DEBUG) { frame->loc = ir->arg1.loc; break; } else if (ir->target) break; } } return stack; } static void jit_diag_cb(diag_t *d, void *arg) { jit_t *j = arg; if (j->silent) { diag_suppress(d, true); return; } else if (unlikely(jit_thread_local()->state != JIT_RUNNING)) fatal_trace("JIT diag callback called when not running"); jit_stack_trace_t *stack LOCAL = jit_stack_trace(); for (int i = 0; i < stack->count; i++) { jit_frame_t *frame = &(stack->frames[i]); if (frame->object != NULL) jit_emit_trace(d, &(frame->loc), frame->object, istr(frame->symbol)); else diag_trace(d, &(frame->loc), "%s", istr(frame->symbol)); } } static void jit_transition(jit_t *j, jit_state_t from, jit_state_t to) { jit_thread_local_t *thread = jit_thread_local(); #ifdef DEBUG if (thread->state != from) fatal_trace("expected thread state %d but have %d", from, thread->state); #endif thread->state = to; switch (to) { case JIT_RUNNING: if (from != JIT_RUNNING) { diag_add_hint_fn(jit_diag_cb, j); thread->jit = j; } else assert(thread->jit == j); break; case JIT_IDLE: if (from == JIT_RUNNING) { diag_remove_hint_fn(jit_diag_cb); thread->jit = NULL; } break; case JIT_COMPILING: if (from == JIT_RUNNING) { diag_remove_hint_fn(jit_diag_cb); thread->jit = NULL; } break; } } static bool jit_try_vcall(jit_t *j, jit_func_t *f, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *volatile thread = jit_thread_local(); volatile const jit_state_t oldstate = thread->state; const int rc = jit_setjmp(thread->abort_env); if (rc == 0) { thread->jmp_buf_valid = 1; jit_transition(j, oldstate, JIT_RUNNING); jit_entry_fn_t entry = load_acquire(&f->entry); (*entry)(f, NULL, args, tlab); jit_transition(j, JIT_RUNNING, oldstate); thread->jmp_buf_valid = 0; thread->anchor = NULL; return true; } else { jit_transition(j, JIT_RUNNING, oldstate); thread->jmp_buf_valid = 0; thread->anchor = NULL; return false; } } static void jit_unpack_args(jit_func_t *f, jit_scalar_t *args, va_list ap) { jit_fill_irbuf(f); // Ensure FFI spec is set int wptr = 0; for (int i = 1; ffi_spec_has(f->spec, i); i++) { switch (ffi_spec_get(f->spec, i)) { case FFI_POINTER: args[wptr++].pointer = va_arg(ap, void *); break; case FFI_FLOAT: args[wptr++].real = va_arg(ap, double); break; case FFI_UARRAY: args[wptr++].pointer = va_arg(ap, void *); args[wptr++].integer = va_arg(ap, int32_t); args[wptr++].integer = va_arg(ap, int32_t); break; case FFI_INT8: case FFI_INT16: case FFI_INT32: args[wptr++].integer = va_arg(ap, int32_t); break; case FFI_UINT8: case FFI_UINT16: case FFI_UINT32: args[wptr++].integer = va_arg(ap, uint32_t); break; default: args[wptr++].integer = va_arg(ap, int64_t); break; } } } bool jit_try_call(jit_t *j, jit_handle_t handle, jit_scalar_t *result, ...) { va_list ap; va_start(ap, result); jit_func_t *f = jit_get_func(j, handle); jit_scalar_t args[JIT_MAX_ARGS]; jit_unpack_args(f, args, ap); va_end(ap); tlab_t tlab = jit_null_tlab(j); if (!jit_try_vcall(j, f, args, &tlab)) return false; *result = args[0]; return true; } jit_scalar_t jit_call(jit_t *j, jit_handle_t handle, ...) { va_list ap; va_start(ap, handle); jit_func_t *f = jit_get_func(j, handle); jit_scalar_t args[JIT_MAX_ARGS]; jit_unpack_args(f, args, ap); va_end(ap); tlab_t tlab = jit_null_tlab(j); if (!jit_try_vcall(j, f, args, &tlab)) fatal_trace("call to %s failed", istr(jit_get_func(j, handle)->name)); return args[0]; } bool jit_fastcall(jit_t *j, jit_handle_t handle, jit_scalar_t *result, jit_scalar_t p1, jit_scalar_t p2, tlab_t *tlab) { jit_func_t *f = jit_get_func(j, handle); jit_scalar_t args[JIT_MAX_ARGS]; args[0] = p1; args[1] = p2; if (!jit_try_vcall(j, f, args, tlab)) return false; *result = args[0]; return true; } bool jit_vfastcall(jit_t *j, jit_handle_t handle, const jit_scalar_t *inargs, unsigned nargs, jit_scalar_t *results, unsigned nresults, tlab_t *tlab) { jit_func_t *f = jit_get_func(j, handle); jit_scalar_t args[JIT_MAX_ARGS]; memcpy(args, inargs, nargs * sizeof(jit_scalar_t)); if (!jit_try_vcall(j, f, args, tlab)) return false; memcpy(results, args, nresults * sizeof(jit_scalar_t)); return true; } void *jit_call_thunk(jit_t *j, vcode_unit_t unit, void *context, thunk_result_fn_t fn, void *arg) { assert(vcode_unit_kind(unit) == VCODE_UNIT_THUNK); jit_func_t *f = xcalloc(sizeof(jit_func_t)); f->state = JIT_FUNC_COMPILING; f->jit = j; f->handle = JIT_HANDLE_INVALID; f->entry = jit_interp; f->object = vcode_unit_object(unit); mir_unit_t *mu = mir_import(f->jit->mir, unit); jit_irgen(f, mu); mir_unit_free(mu); jit_scalar_t args[JIT_MAX_ARGS]; args[0].pointer = context; tlab_t tlab = jit_null_tlab(j); void *user = NULL; if (jit_try_vcall(j, f, args, &tlab)) user = (*fn)(args, arg); jit_free_func(f); return user; } tlab_t jit_null_tlab(jit_t *j) { tlab_t t = { .mspace = j->mspace }; return t; } void jit_set_silent(jit_t *j, bool silent) { j->silent = silent; } static aot_dll_t *load_dll_internal(jit_t *j, const char *path) { uint32_t abi_version = 0; aot_dll_t *lib = xcalloc(sizeof(aot_dll_t)); lib->pack = jit_pack_new(); lib->dll = ffi_load_dll(path); uint32_t *p = ffi_find_symbol(lib->dll, "__nvc_abi_version"); if (p == NULL) warnf("%s: cannot find symbol __nvc_abi_version", path); else abi_version = *p; if (abi_version != RT_ABI_VERSION) fatal("%s: ABI version %d does not match current version %d", path, abi_version, RT_ABI_VERSION); if (opt_get_int(OPT_JIT_LOG)) debugf("loaded AOT library from %s", path); return lib; } void jit_load_dll(jit_t *j, ident_t name) { lib_t lib = lib_require(ident_until(name, '.')); LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "_%s", istr(name)); if (opt_get_int(OPT_NO_SAVE)) tb_printf(tb, ".%d", getpid()); tb_cat(tb, "." DLL_EXT); char so_path[PATH_MAX]; lib_realpath(lib, tb_get(tb), so_path, sizeof(so_path)); if (access(so_path, F_OK) != 0) return; if (j->aotlib != NULL) fatal_trace("AOT library already loaded"); j->aotlib = load_dll_internal(j, so_path); } void jit_load_pack(jit_t *j, FILE *f) { assert(j->pack == NULL); j->pack = jit_read_pack(f); } void jit_msg(const loc_t *where, diag_level_t level, const char *fmt, ...) { diag_t *d = diag_new(level, where); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); if (level == DIAG_FATAL) jit_abort_with_status(EXIT_FAILURE); } void jit_abort(void) { jit_thread_local_t *thread = jit_thread_local(); switch (thread->state) { case JIT_IDLE: case JIT_COMPILING: fatal_exit(1); break; case JIT_RUNNING: if (thread->jmp_buf_valid) jit_longjmp(thread->abort_env, 1); else { const int code = atomic_load(&thread->jit->exit_status); fatal_exit(code); } break; } __builtin_unreachable(); } void jit_abort_with_status(int code) { assert(code != INT_MIN); jit_thread_local_t *thread = jit_thread_local(); if (thread->jit != NULL) atomic_store(&(thread->jit->exit_status), code); jit_abort(); } void jit_reset_exit_status(jit_t *j) { atomic_store(&(j->exit_status), INT_MIN); } bool jit_exit_status(jit_t *j, int *status) { if (j->exit_status != INT_MIN) { *status = j->exit_status; return true; } else return false; } static void jit_async_cgen(void *context, void *arg) { jit_func_t *f = context; jit_tier_t *tier = arg; if (!jit_is_shutdown(f->jit)) (*tier->plugin.cgen)(f->jit, f->handle, tier->context); } void jit_tier_up(jit_func_t *f) { assert(f->hotness <= 0); assert(f->next_tier != NULL); if (opt_get_int(OPT_JIT_ASYNC)) async_do(jit_async_cgen, f, f->next_tier); else (f->next_tier->plugin.cgen)(f->jit, f->handle, f->next_tier->context); f->hotness = 0; f->next_tier = NULL; } void jit_add_tier(jit_t *j, int threshold, const jit_plugin_t *plugin) { assert(threshold > 0); jit_tier_t *t = xcalloc(sizeof(jit_tier_t)); t->next = j->tiers; t->threshold = threshold; t->plugin = *plugin; t->context = (*plugin->init)(j); j->tiers = t; } ident_t jit_get_name(jit_t *j, jit_handle_t handle) { return jit_get_func(j, handle)->name; } object_t *jit_get_object(jit_t *j, jit_handle_t handle) { jit_func_t *f = jit_get_func(j, handle); jit_fill_irbuf(f); return f->object; } bool jit_writes_flags(jit_ir_t *ir) { return ir->op == J_CMP || ir->op == J_FCMP || ir->op == J_CCMP || ir->op == J_FCCMP || (ir->op == J_ADD && ir->cc != JIT_CC_NONE) || (ir->op == J_SUB && ir->cc != JIT_CC_NONE) || (ir->op == J_MUL && ir->cc != JIT_CC_NONE) || (ir->op == MACRO_EXP && ir->cc != JIT_CC_NONE); } bool jit_reads_flags(jit_ir_t *ir) { return (ir->op == J_JUMP && ir->cc != JIT_CC_NONE) || ir->op == J_CSET || ir->op == J_CSEL || ir->op == J_CCMP || ir->op == J_FCCMP; } jit_handle_t jit_assemble(jit_t *j, ident_t name, const char *text) { jit_func_t *f = chash_get(j->index, name); if (f != NULL) return f->handle; SCOPED_LOCK(j->lock); f = xcalloc(sizeof(jit_func_t)); f->name = name; f->state = JIT_FUNC_READY; f->jit = j; f->handle = j->next_handle++; f->next_tier = j->tiers; f->hotness = f->next_tier ? f->next_tier->threshold : 0; f->entry = jit_interp; jit_install(j, f); enum { LABEL, INS, CCSIZE, RESULT, ARG1, ARG2, NEWLINE, CP } state = LABEL; static const struct { const char *name; jit_op_t op; int nresult; int nargs; } optab[] = { { "MOV", J_MOV, 1, 1 }, { "ADD", J_ADD, 1, 2 }, { "SUB", J_SUB, 1, 2 }, { "MUL", J_MUL, 1, 2 }, { "DIV", J_DIV, 1, 2 }, { "REM", J_REM, 1, 2 }, { "RECV", J_RECV, 1, 1 }, { "SEND", J_SEND, 0, 2 }, { "RET", J_RET, 0, 0 }, { "CMP", J_CMP, 0, 2 }, { "CCMP", J_CCMP, 0, 2 }, { "JUMP", J_JUMP, 0, 1 }, { "CSEL", J_CSEL, 1, 2 }, { "CSET", J_CSET, 1, 0 }, { "NOP", J_NOP, 0, 0 }, { "CLAMP", J_CLAMP, 1, 1 }, { "CALL", J_CALL, 0, 1 }, { "STORE", J_STORE, 0, 2 }, { "LOAD", J_LOAD, 1, 1 }, { "ULOAD", J_ULOAD, 1, 1 }, { "SHL", J_SHL, 1, 2 }, { "ASR", J_ASR, 1, 2 }, { "LEA", J_LEA, 1, 1 }, { "AND", J_AND, 1, 2 }, { "OR", J_OR, 1, 2 }, { "XOR", J_XOR, 1, 2 }, { "NOT", J_NOT, 1, 1 }, { "NEG", J_NEG, 1, 1 }, { "FADD", J_FADD, 1, 2 }, { "FSUB", J_FSUB, 1, 2 }, { "FMUL", J_FMUL, 1, 2 }, { "FDIV", J_FDIV, 1, 2 }, { "FNEG", J_FNEG, 1, 1 }, { "FCMP", J_FCMP, 0, 2 }, { "FCVTNS", J_FCVTNS, 1, 1 }, { "SCVTF", J_SCVTF, 1, 1 }, { "$EXIT", MACRO_EXIT, 0, 1 }, { "$COPY", MACRO_COPY, 1, 2 }, { "$MOVE", MACRO_MOVE, 1, 2 }, { "$CASE", MACRO_CASE, 1, 2 }, { "$SALLOC", MACRO_SALLOC, 1, 2 }, { "$LALLOC", MACRO_LALLOC, 1, 1 }, { "$BZERO", MACRO_BZERO, 1, 1 }, { "$MEMSET", MACRO_MEMSET, 1, 2 }, { "$EXP", MACRO_EXP, 1, 2 }, { "$FEXP", MACRO_FEXP, 1, 2 }, }; static const struct { const char *name; jit_cc_t cc; } cctab[] = { { "T", JIT_CC_T }, { "F", JIT_CC_F }, { "EQ", JIT_CC_EQ }, { "O", JIT_CC_O }, { "C", JIT_CC_C }, { "LT", JIT_CC_LT }, { "LE", JIT_CC_LE }, { "GT", JIT_CC_GT }, { "GE", JIT_CC_GE }, }; const unsigned bufsz = 128; f->irbuf = xcalloc_array(bufsz, sizeof(jit_ir_t)); SCOPED_A(int) lpatch = AINIT; int *labels LOCAL = NULL, maxlabel = 0; jit_ir_t *ir = NULL; int nresult = 0, nargs = 0, cpoolptr = 0; char *copy LOCAL = xstrdup(text); for (char *tok = strtok(copy, " \r\t"); tok; tok = strtok(NULL, " \r\t")) { again: switch (state) { case LABEL: assert(f->nirs < bufsz); ir = &(f->irbuf[f->nirs++]); if (tok[0] == 'L' && isdigit((int)tok[1])) { char *eptr = NULL; const int lab = strtol(tok + 1, &eptr, 10); if (*eptr != ':') fatal_trace("cannot parse label '%s'", tok); if (lab > maxlabel) { maxlabel = next_power_of_2(lab); labels = xrealloc_array(labels, maxlabel + 1, sizeof(int)); } ir->target = 1; labels[lab] = ir - f->irbuf; state = INS; } else if (isdigit((int)tok[1])) { state = CP; goto again; } else { state = INS; goto again; } break; case INS: { char *dot = strchr(tok, '.'); if (dot != NULL) *dot++ = '\0'; int ipos = 0; for (; ipos < ARRAY_LEN(optab) && strcmp(optab[ipos].name, tok); ipos++) ; if (ipos == ARRAY_LEN(optab)) fatal_trace("illegal instruction %s", tok); nargs = optab[ipos].nargs; nresult = optab[ipos].nresult; ir->op = optab[ipos].op; ir->size = JIT_SZ_UNSPEC; ir->result = JIT_REG_INVALID; if (dot != NULL) { tok = dot; state = CCSIZE; goto again; } state = nresult > 0 ? RESULT : (nargs > 0 ? ARG1 : NEWLINE); } break; case CCSIZE: { char *dot = strchr(tok, '.'); if (dot != NULL) *dot++ = '\0'; if (isdigit((int)tok[0])) { switch (atoi(tok)) { case 8: ir->size = JIT_SZ_8; break; case 16: ir->size = JIT_SZ_16; break; case 32: ir->size = JIT_SZ_32; break; case 64: ir->size = JIT_SZ_64; break; default: fatal_trace("illegal operation size %s", tok); } } else { int cpos = 0; for (; cpos < ARRAY_LEN(cctab) && strcmp(cctab[cpos].name, tok); cpos++) ; if (cpos == ARRAY_LEN(cctab)) fatal_trace("illegal condition code %s", tok); ir->cc = cctab[cpos].cc; } if (dot != NULL) { tok = dot; state = CCSIZE; goto again; } state = nresult > 0 ? RESULT : (nargs > 0 ? ARG1 : NEWLINE); } break; case RESULT: if (tok[0] != 'R') fatal_trace("expected register name but got '%s'", tok); ir->result = atoi(tok + 1); f->nregs = MAX(ir->result + 1, f->nregs); state = nargs > 0 ? ARG1 : NEWLINE; break; case ARG1: case ARG2: { jit_value_t arg; size_t toklen = strlen(tok); if (tok[0] == 'R') { arg.kind = JIT_VALUE_REG; arg.reg = atoi(tok + 1); f->nregs = MAX(arg.reg + 1, f->nregs); } else if (tok[0] == '#') { arg.kind = JIT_VALUE_INT64; arg.int64 = strtoll(tok + 1, NULL, 0); } else if (tok[0] == '%') { arg.kind = JIT_VALUE_DOUBLE; arg.dval = strtod(tok + 1, NULL); } else if (tok[0] == 'L') { APUSH(lpatch, ir - f->irbuf); arg.kind = JIT_VALUE_LABEL; arg.label = atoi(tok + 1); } else if (tok[0] == '[' && tok[1] == 'R') { char *eptr = NULL; arg.kind = JIT_ADDR_REG; arg.reg = strtol(tok + 2, &eptr, 0); if (*eptr == '+' || *eptr == '-') arg.disp = strtol(eptr, &eptr, 0); else arg.disp = 0; if (*eptr != ']') fatal_trace("invalid address %s", tok); f->nregs = MAX(arg.reg + 1, f->nregs); } else if (tok[0] == '[' && tok[1] == 'C' && tok[2] == 'P') { char *eptr = NULL; arg.int64 = strtol(tok + 4, &eptr, 0); arg.kind = JIT_ADDR_CPOOL; if (tok[3] != '+' || *eptr != ']') fatal_trace("invalid address %s", tok); } else if (tok[0] == '<' && tok[toklen - 1] == '>') { tok[toklen - 1] = '\0'; arg.kind = JIT_VALUE_HANDLE; arg.handle = jit_lazy_compile(j, ident_new(tok + 1)); } else if (tok[0] == '\n') fatal_trace("got newline, expecting argument"); else fatal_trace("cannot parse argument '%s'", tok); if (state == ARG1) ir->arg1 = arg; else ir->arg2 = arg; state = state == ARG1 && nargs > 1 ? ARG2 : NEWLINE; } break; case NEWLINE: if (*tok != '\n') fatal_trace("expected newline, got '%s'", tok); if (ir->op == MACRO_SALLOC) f->framesz += ALIGN_UP(ir->arg2.int64, 8); state = LABEL; if (*++tok != '\0') goto again; break; case CP: { if (*tok == '\n' && *++tok == '\0') continue; char *eptr = NULL; unsigned long byte = strtoul(tok, &eptr, 16); if (*eptr != '\0' || byte >= 256) fatal_trace("invalid constant pool value '%s'", tok); if (f->cpool == NULL) f->cpool = xmalloc((f->cpoolsz = 64)); else if (cpoolptr == f->cpoolsz) fatal_trace("constant pool overflow"); f->cpool[cpoolptr++] = byte; } break; } } f->cpoolsz = cpoolptr; for (int i = 0; i < lpatch.count; i++) { jit_ir_t *ir = &(f->irbuf[lpatch.items[i]]); if (ir->arg1.kind == JIT_VALUE_LABEL) ir->arg1.label = labels[ir->arg1.label]; else ir->arg2.label = labels[ir->arg2.label]; } return f->handle; } bool jit_will_abort(jit_ir_t *ir) { if (ir->op == MACRO_EXIT) { return ir->arg1.exit == JIT_EXIT_INDEX_FAIL || ir->arg1.exit == JIT_EXIT_OVERFLOW || ir->arg1.exit == JIT_EXIT_NULL_DEREF || ir->arg1.exit == JIT_EXIT_UNREACHABLE || ir->arg1.exit == JIT_EXIT_LENGTH_FAIL || ir->arg1.exit == JIT_EXIT_DIV_ZERO || ir->arg1.exit == JIT_EXIT_EXPONENT_FAIL || ir->arg1.exit == JIT_EXIT_RANGE_FAIL; } else return ir->op == J_TRAP; } int32_t *jit_get_cover_mem(jit_t *j, int mintags) { if (j->cover_pages == NULL || mintags > j->cover_pages->ntags) { const int roundup = MAX(16, next_power_of_2(mintags)); jit_cover_page_t *new = xcalloc_flex(sizeof(jit_cover_page_t), roundup, sizeof(int32_t)); new->next = j->cover_pages; new->ntags = roundup; j->cover_pages = new; j->cover_mem = new->tags; } return j->cover_mem; } int32_t *jit_sync_cover_mem(jit_t *j, int mintags) { int32_t *tags = jit_get_cover_mem(j, mintags); for (jit_cover_page_t *p = j->cover_pages->next; p; p = p->next) { assert(p->ntags < mintags); for (int i = 0; i < p->ntags; i++) { tags[i] += p->tags[i]; p->tags[i] = 0; } } return tags; } int32_t *jit_get_cover_ptr(jit_t *j, jit_value_t addr) { assert(addr.kind == JIT_ADDR_COVER); int32_t *base = jit_get_cover_mem(j, addr.int64 + 1); assert(base != NULL); return base + addr.int64; } void jit_interrupt(jit_t *j, jit_irq_fn_t fn, void *ctx) { relaxed_store(&j->interrupt_ctx, ctx); if (!atomic_cas(&j->interrupt, NULL, fn)) fatal_exit(1); } __attribute__((cold, noinline)) static void jit_handle_interrupt(jit_t *j) { jit_irq_fn_t fn = load_acquire(&j->interrupt); if (!atomic_cas(&j->interrupt, fn, NULL)) return; (*fn)(j, relaxed_load(&j->interrupt_ctx)); } void jit_check_interrupt(jit_t *j) { if (unlikely(relaxed_load(&j->interrupt) != NULL)) jit_handle_interrupt(j); } void jit_reset(jit_t *j) { SCOPED_LOCK(j->lock); for (int i = 0; i < j->next_handle; i++) { jit_func_t *f = j->funcs->items[i]; if (f->privdata != MPTR_INVALID) *mptr_get(f->privdata) = NULL; } jit_reset_exit_status(j); } jit_t *jit_for_thread(void) { jit_thread_local_t *thread = jit_thread_local(); if (unlikely(thread->jit == NULL)) fatal_trace("thread not attached to JIT"); return thread->jit; } jit_thread_local_t *jit_attach_thread(jit_anchor_t *anchor) { jit_thread_local_t *thread = *jit_thread_local_ptr(); assert(thread != NULL); thread->anchor = anchor; jit_check_interrupt(thread->jit); return thread; } nvc-r1.17.1/src/jit/jit-dump.c000066400000000000000000000302021504111170000160060ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "jit/jit-priv.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "object.h" #include "psl/psl-node.h" #include "vlog/vlog-node.h" #include #include #include // LCOV_EXCL_START ///////////////////////////////////////////////////////////// typedef struct { ihash_t *labels; int next_label; int next_ir; int lpend; jit_t *jit; jit_func_t *func; jit_cfg_t *cfg; jit_label_t label; bool cpool; } jit_dump_t; const char *jit_op_name(jit_op_t op) { if (op >= __MACRO_BASE) { static const char *names[] = { "$COPY", "$GALLOC", "$EXIT", "$FEXP", "$EXP", "$BZERO", "$GETPRIV", "$PUTPRIV", "$LALLOC", "$SALLOC", "$CASE", "$TRIM", "$MOVE", "$MEMSET", "$REEXEC", "$SADD", "$PACK", "$UNPACK", }; assert(op - __MACRO_BASE < ARRAY_LEN(names)); return names[op - __MACRO_BASE]; } else { static const char *names[] = { "SEND", "RECV", "ADD", "RET", "TRAP", "ULOAD", "STORE", "JUMP", "CMP", "CSET", "SUB", "MOV", "FADD", "MUL", "FMUL", "CALL", "NEG", "LOAD", "CSEL", "LEA", "NOT", "DIV", "FDIV", "SCVTF", "FNEG", "FCVTNS", "FCMP", "AND", "OR", "XOR", "FSUB", "REM", "DEBUG", "NOP", "ASR", "SHL", "CLAMP", "CCMP", "FCCMP", }; assert(op < ARRAY_LEN(names)); return names[op]; } } const char *jit_cc_name(jit_cc_t cc) { static const char *names[] = { "", ".T", ".F", ".EQ", ".NE", ".LT", ".GE", ".GT", ".LE", ".O", ".NO", ".C", ".NC" }; assert(cc < ARRAY_LEN(names)); return names[cc]; } const char *jit_exit_name(jit_exit_t exit) { static const char *names[] = { "INDEX_FAIL", "OVERFLOW", "NULL_DEREF", "LENGTH_FAIL", "UNREACHABLE", "DIV_ZERO", "EXPONENT_FAIL", "REPORT", "ASSERT_FAIL", "RANGE_FAIL", "FUNC_WAIT", "INIT_SIGNAL", "DRIVE_SIGNAL", "SCHED_WAVEFORM", "SCHED_PROCESS", "TEST_EVENT", "TEST_ACTIVE", "SCHED_EVENT", "FILE_OPEN", "FILE_READ", "FILE_WRITE", "DEBUG_OUT", "ALIAS_SIGNAL", "MAP_SIGNAL", "MAP_CONST", "RESOLVE_SIGNAL", "LAST_EVENT", "LAST_ACTIVE", "DISCONNECT", "FORCE", "RELEASE", "PUSH_SCOPE", "POP_SCOPE", "IMPLICIT_SIGNAL", "DRIVING", "DRIVING_VALUE", "CLAIM_TLAB", "COVER_TOGGLE", "PROCESS_INIT", "CLEAR_EVENT", "ENTER_STATE", "REFLECT_VALUE", "REFLECT_SUBTYPE", "FUNCTION_TRIGGER", "ADD_TRIGGER", "TRANSFER_SIGNAL", "PORT_CONVERSION", "CONVERT_IN", "CONVERT_OUT", "BIND_FOREIGN", "OR_TRIGGER", "CMP_TRIGGER", "INSTANCE_NAME", "DEPOSIT_SIGNAL", "MAP_IMPLICIT", "BIND_EXTERNAL", "SYSCALL", "PUT_CONVERSION", "DIR_FAIL", }; assert(exit < ARRAY_LEN(names)); return names[exit]; } static int jit_dump_label(jit_dump_t *d, jit_label_t label) { void *map = ihash_get(d->labels, label); if (map == NULL) ihash_put(d->labels, label, (map = (void *)(uintptr_t)++(d->next_label))); return printf("L%d", (int)(uintptr_t)map); } static int jit_dump_reg(jit_reg_t reg) { if (reg == JIT_REG_INVALID) return printf("RINVALID"); else return printf("R%d", reg); } static int jit_dump_value(jit_dump_t *d, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: return jit_dump_reg(value.reg); case JIT_VALUE_INT64: if (value.int64 < 4096) return printf("#%"PRIi64, value.int64); else return printf("#0x%"PRIx64, value.int64); case JIT_VALUE_DOUBLE: return printf("%%%g", value.dval); case JIT_ADDR_CPOOL: return printf("[CP+%"PRIi64"]", value.int64); case JIT_ADDR_REG: { int num = printf("["); num += jit_dump_reg(value.reg); if (value.disp != 0) num += printf("+%d", value.disp); num += printf("]"); return num; } case JIT_ADDR_ABS: return printf("[#%016"PRIx64"]", value.int64); case JIT_ADDR_COVER: return printf("[$TAG:%"PRIi64"]", value.int64); case JIT_VALUE_LABEL: if (value.label == JIT_LABEL_INVALID) return printf("???"); else return jit_dump_label(d, value.label); case JIT_VALUE_HANDLE: if (value.handle == JIT_HANDLE_INVALID) return printf("<\?\?\?>"); else return printf("<%s>", istr(jit_get_func(d->jit, value.handle)->name)); case JIT_VALUE_EXIT: return printf("%s", jit_exit_name(value.exit)); case JIT_VALUE_LOC: return printf("<%s:%d>", loc_file_str(&value.loc), value.loc.first_line); case JIT_VALUE_LOCUS: { object_t *obj = value.locus; switch (obj->tag) { case OBJECT_TAG_TREE: return printf("%s@%p", tree_kind_str(obj->kind), obj); case OBJECT_TAG_VLOG: return printf("%s@%p", vlog_kind_str(obj->kind), obj); case OBJECT_TAG_PSL: return printf("%s@%p", psl_kind_str(obj->kind), obj); default: return printf("%d@%p", obj->kind, obj); } } case JIT_VALUE_VPOS: return printf("%u:%u", value.vpos.block, value.vpos.op); case JIT_VALUE_INVALID: return printf("???"); } return 0; } static void jit_dump_regset(jit_dump_t *d, bit_mask_t *m) { printf("{"); for (int i = 0, nth = 0; i < d->func->nregs + 1; i++) { if (mask_test(m, i)) { if (nth++ > 0) fputc(',', stdout); if (i == d->func->nregs) fputs("FLAGS", stdout); else printf("R%d", i); } } printf("}"); } static void jit_dump_ir(jit_dump_t *d, jit_ir_t *ir) { if (d->cfg != NULL) { const int pos = ir - d->func->irbuf; jit_block_t *bb = jit_block_for(d->cfg, pos); if (pos == bb->first) { printf("\t;; BB%"PRIiPTR, bb - d->cfg->blocks); if (bb->in.count > 0) { printf(" in:"); for (int i = 0; i < bb->in.count; i++) printf("%s%d", i > 0 ? "," : "", jit_get_edge(&bb->in, i)); if (mask_popcount(&bb->livein) > 0) { printf(" "); jit_dump_regset(d, &bb->livein); } } if (bb->out.count > 0) { printf(" out:"); for (int i = 0; i < bb->out.count; i++) printf("%s%d", i > 0 ? "," : "", jit_get_edge(&bb->out, i)); if (mask_popcount(&bb->liveout) > 0) { printf(" "); jit_dump_regset(d, &bb->liveout); } } if (mask_popcount(&bb->varkill) > 0) { printf(" kill:"); jit_dump_regset(d, &bb->varkill); } if (bb->aborts) printf(" aborts"); else if (bb->returns) printf(" returns"); printf("\n"); } } int col = 0; col += printf("\t%s%s", jit_op_name(ir->op), jit_cc_name(ir->cc)); if (ir->size != JIT_SZ_UNSPEC) col += printf(".%d", 1 << (3 + ir->size)); col += printf("%*.s", (int)MAX(0, 15 - col), ""); if (ir->result != JIT_REG_INVALID) col += printf("R%d", ir->result); if (ir->arg1.kind != JIT_VALUE_INVALID) { if (ir->result != JIT_REG_INVALID) col += printf(", "); col += jit_dump_value(d, ir->arg1); if (ir->arg2.kind != JIT_VALUE_INVALID) { col += printf(", "); col += jit_dump_value(d, ir->arg2); } } printf("\n"); } static void jit_do_dump(jit_dump_t *d, jit_func_t *f) { printf("------------------------------------------------------------\n"); printf("%s:\n", istr(f->name)); if (f->framesz > 0) printf("\t;; Frame size: %u bytes\n", f->framesz); d->labels = ihash_new(128); for (int i = 0; i < f->nirs; i++) { if (i == d->label) color_printf("$!red$"); if (f->irbuf[i].target) { jit_dump_label(d, i); printf(":"); } jit_dump_ir(d, &(f->irbuf[i])); if (i == d->label) color_printf("$$"); } ihash_free(d->labels); if (d->cpool && f->cpoolsz > 0) { printf("\n"); jit_hexdump(f->cpool, f->cpoolsz, 16, NULL, "\t"); } printf("------------------------------------------------------------\n\n"); fflush(stdout); } void jit_dump_with_mark(jit_func_t *f, jit_label_t label) { jit_dump_t d = { .jit = f->jit, .func = f, .label = label, }; jit_do_dump(&d, f); } void jit_dump_with_cfg(jit_func_t *f, jit_cfg_t *cfg) { jit_dump_t d = { .jit = f->jit, .func = f, .label = JIT_LABEL_INVALID, .cfg = cfg, }; jit_do_dump(&d, f); } void jit_dump(jit_func_t *f) { jit_dump_t d = { .jit = f->jit, .func = f, .label = JIT_LABEL_INVALID, .cpool = true, }; jit_do_dump(&d, f); } static void jit_interleaved_cb(mir_unit_t *mu, mir_block_t b, mir_value_t n, void *ctx) { jit_dump_t *d = ctx; for (; d->next_ir < d->func->nirs; d->next_ir++) { jit_ir_t *ir = &(d->func->irbuf[d->next_ir]); if (ir->op == J_DEBUG) { if (ir->target) d->lpend = d->next_ir; if (mir_is_null(b) || mir_is_null(n)) continue; // Flush else if (ir->arg2.vpos.block != b.id || ir->arg2.vpos.op != n.id) break; } else { color_printf("$#42$"); if (ir->target || d->lpend >= 0) { jit_dump_label(d, d->lpend < 0 ? d->next_ir : d->lpend); printf(":"); d->lpend = -1; } jit_dump_ir(d, ir); color_printf("$$"); } } } static const mir_annotate_t jit_annot = { .end_node = jit_interleaved_cb, }; void jit_dump_interleaved(jit_func_t *f, mir_unit_t *mu) { jit_dump_t d = { .labels = ihash_new(128), .jit = f->jit, .func = f, .lpend = -1, }; mir_set_cursor(mu, MIR_NULL_BLOCK, 0); mir_annotate(mu, &jit_annot, &d); jit_interleaved_cb(mu, MIR_NULL_BLOCK, MIR_NULL_VALUE, &d); ihash_free(d.labels); if (f->cpoolsz > 0) { jit_hexdump(f->cpool, f->cpoolsz, 16, NULL, "\t"); printf("\n"); } } __attribute__((no_sanitize_address)) void jit_hexdump(const unsigned char *data, size_t sz, int blocksz, const void *highlight, const char *prefix) { for (int i = 0, ndups = 0; i < sz; i += blocksz) { if (i > 0 && i + blocksz < sz) { bool dup = true; for (int j = 0; j < blocksz; j++) { if (data[i + j] != data[i - blocksz + j]) { dup = false; break; } } if (dup) { ndups++; continue; } } if (ndups > 0) { printf("%s\t... skipped %d identical bytes ...\n", prefix, ndups * blocksz); ndups = 0; } fputs(prefix, stdout); for (int j = 0; j < blocksz; j++) { if (i + j < sz) { if (highlight != NULL) fputc(&(data[i + j]) == highlight ? '>' : ' ', stdout); printf("%02x", data[i + j]); if (highlight == NULL) fputc(' ', stdout); } else printf(" "); if (j % 4 == 3) printf(" "); } printf("|"); for (int j = 0; j < blocksz; j++) { if (i + j < sz) { const int byte = data[i + j]; printf("%c", isprint(byte) ? byte : '.'); } else printf(" "); } printf("|\n"); } } // LCOV_EXCL_STOP ////////////////////////////////////////////////////////////// nvc-r1.17.1/src/jit/jit-exits.c000066400000000000000000000676601504111170000162170ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "jit/jit-exits.h" #include "jit/jit-ffi.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "lib.h" #include "object.h" #include "psl/psl-node.h" #include "rt/assert.h" #include "rt/mspace.h" #include "rt/rt.h" #include "rt/structs.h" #include "type.h" #include #include #include #include #include #include #include #include void x_index_fail(int64_t value, int64_t left, int64_t right, int8_t dir, tree_t where, tree_t hint) { type_t type = tree_type(hint); LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, "index "); to_string(tb, type, value); tb_printf(tb, " outside of %s range ", type_pp(type)); to_string(tb, type, left); tb_cat(tb, dir == RANGE_TO ? " to " : " downto "); to_string(tb, type, right); jit_msg(tree_loc(where), DIAG_FATAL, "%s", tb_get(tb)); } void x_length_fail(int64_t left, int64_t right, int32_t dim, tree_t where) { const tree_kind_t kind = tree_kind(where); LOCAL_TEXT_BUF tb = tb_new(); switch (kind) { case T_PORT_DECL: case T_GENERIC_DECL: case T_PARAM_DECL: case T_PARAM: tb_cat(tb, "actual"); break; case T_CASE: case T_MATCH_CASE: tb_cat(tb, "expression"); break; case T_ASSOC: tb_cat(tb, "choice"); break; case T_AGGREGATE: tb_cat(tb, "aggregate"); break; case T_EXTERNAL_NAME: { tree_t last = tree_part(where, tree_parts(where) - 1); tb_printf(tb, "object %s", istr(tree_ident(last))); } break; default: tb_cat(tb, "value"); break; } tb_printf(tb, " length %"PRIi64, right); if (dim > 0) tb_printf(tb, " for dimension %d", dim); tb_cat(tb, " does not match "); switch (kind) { case T_PORT_DECL: tb_printf(tb, "port %s", istr(tree_ident(where))); break; case T_PARAM_DECL: tb_printf(tb, "parameter %s", istr(tree_ident(where))); break; case T_GENERIC_DECL: tb_printf(tb, "generic %s", istr(tree_ident(where))); break; case T_VAR_DECL: tb_printf(tb, "variable %s", istr(tree_ident(where))); break; case T_CONST_DECL: tb_printf(tb, "constant %s", istr(tree_ident(where))); break; case T_SIGNAL_DECL: tb_printf(tb, "signal %s", istr(tree_ident(where))); break; case T_REF: tb_printf(tb, "%s %s", class_str(class_of(where)), istr(tree_ident(where))); break; case T_FIELD_DECL: tb_printf(tb, "field %s", istr(tree_ident(where))); break; case T_ALIAS: tb_printf(tb, "alias %s", istr(tree_ident(where))); break; case T_CASE: case T_MATCH_CASE: tb_cat(tb, "case choice"); break; case T_ASSOC: tb_cat(tb, "expected"); break; case T_PARAM: tb_cat(tb, "formal"); break; case T_EXTERNAL_NAME: tb_cat(tb, "external name subtype indication"); break; case T_TYPE_CONV: case T_ATTR_REF: case T_AGGREGATE: tb_printf(tb, "subtype %s", type_pp(tree_type(where))); break; default: tb_cat(tb, "target"); break; } tb_printf(tb, " length %"PRIi64, left); jit_msg(tree_loc(where), DIAG_FATAL, "%s", tb_get(tb)); } void x_dir_fail(range_kind_t value, range_kind_t dir, tree_t where) { assert(tree_kind(where) == T_RANGE); assert(value == RANGE_TO || value == RANGE_DOWNTO); assert(dir == RANGE_TO || dir == RANGE_DOWNTO); const char *map[] = { "TO", "DOWNTO" }; jit_msg(tree_loc(where), DIAG_FATAL, "range direction of slice %s does " "not match prefix %s", map[value], map[dir]); } void x_range_fail(int64_t value, int64_t left, int64_t right, int8_t dir, tree_t where, tree_t hint) { // Hint tree may be an array type conversion type_t type = type_elem_recur(tree_type(hint)); LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, "value "); to_string(tb, type, value); tb_printf(tb, " outside of %s range ", type_pp(type)); to_string(tb, type, left); tb_cat(tb, dir == RANGE_TO ? " to " : " downto "); to_string(tb, type, right); switch (tree_kind(hint)) { case T_SIGNAL_DECL: case T_CONST_DECL: case T_VAR_DECL: case T_REF: tb_printf(tb, " for %s %s", class_str(class_of(hint)), istr(tree_ident(hint))); break; case T_PORT_DECL: tb_printf(tb, " for port %s", istr(tree_ident(hint))); break; case T_PARAM_DECL: tb_printf(tb, " for parameter %s", istr(tree_ident(hint))); break; case T_GENERIC_DECL: tb_printf(tb, " for generic %s", istr(tree_ident(hint))); break; case T_ATTR_REF: tb_printf(tb, " for attribute '%s", istr(tree_ident(hint))); break; default: break; } jit_msg(tree_loc(where), DIAG_FATAL, "%s", tb_get(tb)); } void x_exponent_fail(int64_t value, tree_t where) { jit_msg(tree_loc(where), DIAG_FATAL, "negative exponent %"PRIi64 " only allowed for floating-point types", value); } void x_overflow(int64_t lhs, int64_t rhs, tree_t where) { LOCAL_TEXT_BUF tb = tb_new(); if (tree_kind(where) == T_FCALL) { switch (tree_subkind(tree_ref(where))) { case S_ADD: tb_printf(tb, "%"PRIi64" + %"PRIi64, lhs, rhs); break; case S_MUL: tb_printf(tb, "%"PRIi64" * %"PRIi64, lhs, rhs); break; case S_SUB: tb_printf(tb, "%"PRIi64" - %"PRIi64, lhs, rhs); break; case S_NEGATE: tb_printf(tb, "-(%"PRIi64")", lhs); break; case S_EXP: tb_printf(tb, "%"PRIi64" ** %"PRIi64, lhs, rhs); break; } } jit_msg(tree_loc(where), DIAG_FATAL, "result of %s cannot be represented as %s", tb_get(tb), type_pp(tree_type(where))); } void x_null_deref(tree_t where) { jit_msg(tree_loc(where), DIAG_FATAL, "null access dereference"); } void x_div_zero(tree_t where) { jit_msg(tree_loc(where), DIAG_FATAL, "division by zero"); } void x_unreachable(tree_t where) { if (where != NULL && tree_kind(where) == T_FUNC_BODY) jit_msg(tree_loc(where), DIAG_FATAL, "function %s did not return a value", istr(tree_ident(where))); else jit_msg(NULL, DIAG_FATAL, "executed unreachable instruction"); } void x_func_wait(void) { jit_stack_trace_t *trace = jit_stack_trace(); tree_t inner = tree_from_object(trace->frames[0].object); free(trace); const char *what; switch (tree_kind(inner)) { case T_PROC_BODY: what = "call to protected type method"; break; case T_PROCESS: what = "process with sensitivity list"; break; default: what = "function call"; } jit_msg(NULL, DIAG_FATAL, "cannot wait inside %s", what); } //////////////////////////////////////////////////////////////////////////////// // Entry point from interpreter or JIT compiled code DLLEXPORT void __nvc_sched_waveform(jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(anchor); sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; jit_scalar_t value = { .integer = args[3].integer }; int64_t after = args[4].integer; int64_t reject = args[5].integer; bool scalar = args[6].integer; if (scalar) x_sched_waveform_s(shared, offset, value.integer, after, reject); else x_sched_waveform(shared, offset, value.pointer, count, after, reject); thread->anchor = NULL; } DLLEXPORT void __nvc_test_event(jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(anchor); sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; args[0].integer = x_test_net_event(shared, offset, count); thread->anchor = NULL; } DLLEXPORT void __nvc_last_event(jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(anchor); sig_shared_t *shared = args[0].pointer; uint32_t offset = args[1].integer; uint32_t count = args[2].integer; args[0].integer = x_last_event(shared, offset, count); thread->anchor = NULL; } DLLEXPORT void __nvc_sched_process(jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(anchor); int64_t after = args[0].integer; x_sched_process(after); thread->anchor = NULL; } DLLEXPORT void __nvc_do_exit(jit_exit_t which, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(anchor); switch (which) { case JIT_EXIT_ASSERT_FAIL: { uint8_t *msg = args[0].pointer; int32_t len = args[1].integer; int32_t severity = args[2].integer; int64_t hint_left = args[3].integer; int64_t hint_right = args[4].integer; int8_t hint_valid = args[5].integer; object_t *where = args[6].pointer; x_assert_fail(msg, len, severity, hint_left, hint_right, hint_valid, where); } break; case JIT_EXIT_REPORT: { uint8_t *msg = args[0].pointer; int32_t len = args[1].integer; int32_t severity = args[2].integer; object_t *where = args[3].pointer; x_report(msg, len, severity, where); } break; case JIT_EXIT_INIT_SIGNAL: { int64_t count = args[0].integer; int32_t size = args[1].integer; jit_scalar_t value = { .integer = args[2].integer }; int32_t flags = args[3].integer; tree_t where = args[4].pointer; int32_t offset = args[5].integer; bool scalar = args[6].integer; args[0].pointer = x_init_signal(count, size, value, scalar, flags, where, offset); } break; case JIT_EXIT_IMPLICIT_SIGNAL: { int32_t count = args[0].integer; int32_t size = args[1].integer; tree_t where = args[2].pointer; int32_t kind = args[3].integer; jit_handle_t handle = args[4].integer; void *context = args[5].pointer; int64_t delay = args[6].integer; ffi_closure_t closure = { handle, context }; args[0].pointer = x_implicit_signal(count, size, where, kind, &closure, delay); } break; case JIT_EXIT_RESOLVE_SIGNAL: { sig_shared_t *shared = args[0].pointer; jit_handle_t handle = *(jit_handle_t *)(args[1].pointer + 0); void *context = *(void **)(args[1].pointer + 8); int32_t nlits = *(int64_t *)(args[1].pointer + 16); int32_t flags = *(int32_t *)(args[1].pointer + 24); x_resolve_signal(shared, handle, context, nlits, flags); } break; case JIT_EXIT_DRIVE_SIGNAL: { sig_shared_t *ss = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; x_drive_signal(ss, offset, count); } break; case JIT_EXIT_TRANSFER_SIGNAL: { sig_shared_t *target = args[0].pointer; int32_t toffset = args[1].integer; sig_shared_t *source = args[2].pointer; int32_t soffset = args[3].integer; int32_t count = args[4].integer; int64_t after = args[5].integer; int64_t reject = args[6].integer; x_transfer_signal(target, toffset, source, soffset, count, after, reject); } break; case JIT_EXIT_MAP_SIGNAL: { sig_shared_t *src_ss = args[0].pointer; uint32_t src_offset = args[1].integer; sig_shared_t *dst_ss = args[2].pointer; uint32_t dst_offset = args[3].integer; uint32_t count = args[4].integer; x_map_signal(src_ss, src_offset, dst_ss, dst_offset, count); } break; case JIT_EXIT_MAP_CONST: { sig_shared_t *dst_ss = args[0].pointer; uint32_t dst_offset = args[1].integer; jit_scalar_t initval = { .integer = args[2].integer }; uint32_t dst_count = args[3].integer; bool scalar = args[4].integer; const void *vptr = scalar ? &initval.integer : initval.pointer; x_map_const(dst_ss, dst_offset, vptr, dst_count); } break; case JIT_EXIT_MAP_IMPLICIT: { sig_shared_t *src_ss = args[0].pointer; uint32_t src_offset = args[1].integer; sig_shared_t *dst_ss = args[2].pointer; uint32_t dst_offset = args[3].integer; uint32_t count = args[4].integer; x_map_implicit(src_ss, src_offset, dst_ss, dst_offset, count); } break; case JIT_EXIT_SCHED_PROCESS: __nvc_sched_process(anchor, args, tlab); break; case JIT_EXIT_SCHED_WAVEFORM: __nvc_sched_waveform(anchor, args, tlab); break; case JIT_EXIT_SCHED_EVENT: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; x_sched_event(shared, offset, count); } break; case JIT_EXIT_ALIAS_SIGNAL: { sig_shared_t *ss = args[0].pointer; tree_t where = args[1].pointer; x_alias_signal(ss, where); } break; case JIT_EXIT_DISCONNECT: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; int64_t reject = args[3].integer; int64_t after = args[4].integer; x_disconnect(shared, offset, count, after, reject); } break; case JIT_EXIT_UNREACHABLE: { tree_t where = args[0].pointer; x_unreachable(where); } break; case JIT_EXIT_OVERFLOW: { int32_t lhs = args[0].integer; int32_t rhs = args[1].integer; tree_t where = args[2].pointer; x_overflow(lhs, rhs, where); } break; case JIT_EXIT_INDEX_FAIL: { int64_t value = args[0].integer; int64_t left = args[1].integer; int64_t right = args[2].integer; range_kind_t dir = args[3].integer; tree_t where = args[4].pointer; tree_t hint = args[5].pointer; x_index_fail(value, left, right, dir, where, hint); } break; case JIT_EXIT_RANGE_FAIL: { int64_t value = args[0].integer; int64_t left = args[1].integer; int64_t right = args[2].integer; range_kind_t dir = args[3].integer; tree_t where = args[4].pointer; tree_t hint = args[5].pointer; x_range_fail(value, left, right, dir, where, hint); } break; case JIT_EXIT_FORCE: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; jit_scalar_t value = { .integer = args[3].integer }; bool scalar = args[4].integer; if (scalar) x_force(shared, offset, count, &value.integer); else x_force(shared, offset, count, value.pointer); } break; case JIT_EXIT_RELEASE: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; x_release(shared, offset, count); } break; case JIT_EXIT_DEPOSIT_SIGNAL: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; jit_scalar_t value = { .integer = args[3].integer }; bool scalar = args[4].integer; if (scalar) x_deposit_signal(shared, offset, count, &value.integer); else x_deposit_signal(shared, offset, count, value.pointer); } break; case JIT_EXIT_PUT_CONVERSION: { rt_conv_func_t *cf = args[0].pointer; sig_shared_t *shared = args[1].pointer; int32_t offset = args[2].integer; int32_t count = args[3].integer; jit_scalar_t value = { .integer = args[4].integer }; bool scalar = args[5].integer; if (scalar) x_put_conversion(cf, shared, offset, count, &value.integer); else x_put_conversion(cf, shared, offset, count, value.pointer); } break; case JIT_EXIT_PUSH_SCOPE: { tree_t where = args[0].pointer; int32_t size = args[1].integer; rt_scope_kind_t kind = args[2].integer; x_push_scope(where, size, kind); } break; case JIT_EXIT_POP_SCOPE: x_pop_scope(); break; case JIT_EXIT_FUNC_WAIT: x_func_wait(); break; case JIT_EXIT_DIV_ZERO: { tree_t where = args[0].pointer; x_div_zero(where); } break; case JIT_EXIT_LENGTH_FAIL: { int32_t left = args[0].integer; int32_t right = args[1].integer; int32_t dim = args[2].integer; tree_t where = args[3].pointer; x_length_fail(left, right, dim, where); } break; case JIT_EXIT_DIR_FAIL: { range_kind_t value = args[0].integer; range_kind_t dir = args[1].integer; tree_t where = args[2].pointer; x_dir_fail(value, dir, where); } break; case JIT_EXIT_NULL_DEREF: { tree_t where = args[0].pointer; x_null_deref(where); } break; case JIT_EXIT_EXPONENT_FAIL: { int32_t value = args[0].integer; tree_t where = args[1].pointer; x_exponent_fail(value, where); } break; case JIT_EXIT_FILE_OPEN: { int8_t *status = args[0].pointer; void **_fp = args[1].pointer; uint8_t *name_bytes = args[2].pointer; int32_t name_len = args[3].integer; int32_t mode = args[4].integer; x_file_open(status, _fp, name_bytes, name_len, mode); } break; case JIT_EXIT_FILE_READ: { void **_fp = args[0].pointer; uint8_t *data = args[1].pointer; int64_t size = args[2].integer; int64_t count = args[3].integer; args[0].integer = x_file_read(_fp, data, size, count); } break; case JIT_EXIT_FILE_WRITE: { void **_fp = args[0].pointer; jit_scalar_t data = { .integer = args[1].integer }; size_t size = args[2].integer; size_t count = args[3].integer; bool scalar = args[4].integer; if (scalar) x_file_write(_fp, &data.integer, size, count); else x_file_write(_fp, data.pointer, size, count); } break; case JIT_EXIT_DEBUG_OUT: { int64_t value = args[0].integer; debugf("DEBUG %"PRIi64, value); } break; case JIT_EXIT_LAST_EVENT: __nvc_last_event(anchor, args, tlab); break; case JIT_EXIT_LAST_ACTIVE: { sig_shared_t *shared = args[0].pointer; uint32_t offset = args[1].integer; uint32_t count = args[2].integer; args[0].integer = x_last_active(shared, offset, count); } break; case JIT_EXIT_TEST_EVENT: __nvc_test_event(anchor, args, tlab); break; case JIT_EXIT_TEST_ACTIVE: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; args[0].integer = x_test_net_active(shared, offset, count); } break; case JIT_EXIT_DRIVING: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; args[0].integer = x_driving(shared, offset, count); } break; case JIT_EXIT_DRIVING_VALUE: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; args[0].pointer = x_driving_value(shared, offset, count); } break; case JIT_EXIT_COVER_TOGGLE: { sig_shared_t *shared = args[0].pointer; int32_t tag = args[1].integer; x_cover_setup_toggle_cb(shared, tag); } break; case JIT_EXIT_COVER_STATE: { sig_shared_t *shared = args[0].pointer; int64_t low = args[1].integer; int32_t tag = args[2].integer; x_cover_setup_state_cb(shared, low, tag); } break; case JIT_EXIT_PROCESS_INIT: { jit_handle_t handle = args[0].integer; tree_t where = args[1].pointer; x_process_init(handle, where); } break; case JIT_EXIT_CLEAR_EVENT: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int32_t count = args[2].integer; x_clear_event(shared, offset, count); } break; case JIT_EXIT_ENTER_STATE: { int32_t state = args[0].integer; bool strong = !!args[1].integer; x_enter_state(state, strong); } break; case JIT_EXIT_REFLECT_VALUE: { void *context = args[0].pointer; jit_scalar_t value = args[1]; tree_t where = args[2].pointer; args[0].pointer = x_reflect_value(context, value, where, args + 3); } break; case JIT_EXIT_REFLECT_SUBTYPE: { void *context = args[0].pointer; tree_t where = args[1].pointer; args[0].pointer = x_reflect_subtype(context, where, args + 3); } break; case JIT_EXIT_FUNCTION_TRIGGER: { jit_handle_t handle = args[0].integer; unsigned nargs = args[1].integer; args[0].pointer = x_function_trigger(handle, nargs, args + 2); } break; case JIT_EXIT_OR_TRIGGER: { void *left = args[0].pointer; void *right = args[1].pointer; args[0].pointer = x_or_trigger(left, right); } break; case JIT_EXIT_CMP_TRIGGER: { sig_shared_t *shared = args[0].pointer; int32_t offset = args[1].integer; int64_t right = args[2].integer; args[0].pointer = x_cmp_trigger(shared, offset, right); } break; case JIT_EXIT_ADD_TRIGGER: { void *trigger = args[0].pointer; if (trigger != NULL) x_add_trigger(trigger); } break; case JIT_EXIT_PORT_CONVERSION: { jit_handle_t handle1 = args[0].integer; void *context1 = args[1].pointer; jit_handle_t handle2 = args[2].integer; void *context2 = args[3].pointer; ffi_closure_t driving = { handle1, context1 }; ffi_closure_t effective = { handle2, context2 }; args[0].pointer = x_port_conversion(&driving, &effective); } break; case JIT_EXIT_CONVERT_IN: { void *conv = args[0].pointer; sig_shared_t *shared = args[1].pointer; int32_t offset = args[2].integer; int32_t count = args[3].integer; if (conv != NULL) x_convert_in(conv, shared, offset, count); } break; case JIT_EXIT_CONVERT_OUT: { void *conv = args[0].pointer; sig_shared_t *shared = args[1].pointer; int32_t offset = args[2].integer; int32_t count = args[3].integer; if (conv != NULL) x_convert_out(conv, shared, offset, count); } break; case JIT_EXIT_BIND_FOREIGN: { const uint8_t *spec = args[0].pointer; size_t length = args[1].integer; tree_t where = args[2].pointer; jit_bind_foreign(anchor->func, spec, length, where); } break; case JIT_EXIT_INSTANCE_NAME: { const attr_kind_t kind = args[0].integer; LOCAL_TEXT_BUF tb = tb_new(); x_instance_name(kind, tb); ffi_return_string(tb_get(tb), args, tlab); } break; case JIT_EXIT_BIND_EXTERNAL: { tree_t where = args[0].pointer; jit_handle_t scope = args[1].integer; x_bind_external(where, scope, args); } break; case JIT_EXIT_SYSCALL: { vlog_node_t where = args[0].pointer; jit_do_syscall(where, anchor, args, tlab); } break; default: fatal_trace("unhandled exit %s", jit_exit_name(which)); } thread->anchor = NULL; } //////////////////////////////////////////////////////////////////////////////// // Entry points from AOT compiled code DLLEXPORT void _debug_out(intptr_t val, int32_t reg) { printf("DEBUG: r%d val=%"PRIxPTR"\n", reg, val); fflush(stdout); } DLLEXPORT void _debug_dump(const uint8_t *ptr, int32_t len) { printf("---- %p ----\n", ptr); if (ptr != NULL) { for (int i = 0; i < len; i++) printf("%02x%c", ptr[i], (i % 8 == 7) ? '\n' : ' '); if (len % 8 != 0) printf("\n"); } fflush(stdout); } DLLEXPORT void *__nvc_mspace_alloc(uintptr_t size, jit_anchor_t *anchor) { jit_thread_local_t *thread = jit_attach_thread(anchor); if (unlikely(size > UINT32_MAX)) { jit_msg(NULL, DIAG_FATAL, "attempting to allocate %zu byte object " "which is larger than the maximum supported %u bytes", size, UINT32_MAX); __builtin_unreachable(); } else if (size == 0) size = 1; // Never return a NULL pointer void *ptr = jit_mspace_alloc(size); thread->anchor = NULL; return ptr; } DLLEXPORT void __nvc_putpriv(jit_handle_t handle, void *data) { jit_t *j = jit_for_thread(); jit_func_t *f = jit_get_func(j, handle); store_release(jit_get_privdata_ptr(j, f), data); } DLLEXPORT object_t *__nvc_get_object(const char *unit, ptrdiff_t offset) { return object_from_locus(ident_new(unit), offset, lib_load_handler); } DLLEXPORT void __nvc_pack(const uint8_t *src, int32_t size, jit_scalar_t *args) { assert(size <= 64); // TODO uint64_t abits = 0, bbits = 0; for (size_t i = 0; i < size; i++) { abits = (abits << 1) | (src[i] & 1); bbits = (bbits << 1) | ((src[i] >> 1) & 1); } args[0].integer = abits; args[1].integer = bbits; } DLLEXPORT void __nvc_unpack(uint64_t abits, uint64_t bbits, jit_scalar_t *args) { uint8_t *dest = args[0].pointer; size_t size = args[1].integer; uint8_t strength = args[2].integer; for (size_t i = 0; i < size; i++, abits >>= 1, bbits >>= 1) dest[size - i - 1] = (abits & 1) | ((bbits & 1) << 1) | strength; } nvc-r1.17.1/src/jit/jit-exits.h000066400000000000000000000133601504111170000162100ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_EXITS_H #define _JIT_EXITS_H #include "prim.h" #include "jit/jit.h" #include "jit/jit-ffi.h" #include "rt/rt.h" #define WEAK __attribute__((weak)) void x_sched_process(int64_t delay); void x_drive_signal(sig_shared_t *ss, uint32_t offset, int32_t count); sig_shared_t *x_init_signal(int64_t count, uint32_t size, jit_scalar_t value, bool scalar, uint32_t flags, tree_t where, int32_t offset); void x_sched_waveform(sig_shared_t *ss, uint32_t offset, void *values, int32_t count, int64_t after, int64_t reject); void x_transfer_signal(sig_shared_t *target_ss, uint32_t toffset, sig_shared_t *source_ss, uint32_t soffset, int32_t count, int64_t after, int64_t reject); int32_t x_test_net_event(sig_shared_t *ss, uint32_t offset, int32_t count); int32_t x_test_net_active(sig_shared_t *ss, uint32_t offset, int32_t count); void x_sched_event(sig_shared_t *ss, uint32_t offset, int32_t count); void x_alias_signal(sig_shared_t *ss, tree_t where); void x_sched_waveform_s(sig_shared_t *ss, uint32_t offset, uint64_t scalar, int64_t after, int64_t reject); void x_file_open(int8_t *status, void **_fp, const uint8_t *name_bytes, int32_t name_len, int8_t mode); void x_file_write(void **_fp, void *data, int64_t size, int64_t count); int64_t x_file_read(void **_fp, void *data, int64_t size, int64_t count); void x_index_fail(int64_t value, int64_t left, int64_t right, int8_t dir, tree_t where, tree_t hint); void x_length_fail(int64_t left, int64_t right, int32_t dim, tree_t where); void x_range_fail(int64_t value, int64_t left, int64_t right, int8_t dir, tree_t where, tree_t hint); void x_exponent_fail(int64_t value, tree_t where); void x_overflow(int64_t lhs, int64_t rhs, tree_t where); void x_null_deref(tree_t where); void x_div_zero(tree_t where); void x_assert_fail(const uint8_t *msg, int32_t msg_len, int8_t severity, int64_t hint_left, int64_t hint_right, int8_t hint_valid, object_t *where); void x_report(const uint8_t *msg, int32_t msg_len, int8_t severity, object_t *where); int64_t x_last_event(sig_shared_t *ss, uint32_t offset, int32_t count); int64_t x_last_active(sig_shared_t *ss, uint32_t offset, int32_t count); void x_map_signal(sig_shared_t *src_ss, uint32_t src_offset, sig_shared_t *dst_ss, uint32_t dst_offset, uint32_t count); void x_map_const(sig_shared_t *ss, uint32_t offset, const uint8_t *values, uint32_t count); void x_map_implicit(sig_shared_t *src_ss, uint32_t src_offset, sig_shared_t *dst_ss, uint32_t dst_offset, uint32_t count); void x_push_scope(tree_t where, int32_t size, rt_scope_kind_t kind); void x_pop_scope(void); bool x_driving(sig_shared_t *ss, uint32_t offset, int32_t count); void *x_driving_value(sig_shared_t *ss, uint32_t offset, int32_t count); sig_shared_t *x_implicit_signal(uint32_t count, uint32_t size, tree_t where, implicit_kind_t kind, ffi_closure_t *closure, int64_t delay); void x_disconnect(sig_shared_t *ss, uint32_t offset, int32_t count, int64_t after, int64_t reject); void x_force(sig_shared_t *ss, uint32_t offset, int32_t count, void *values); void x_release(sig_shared_t *ss, uint32_t offset, int32_t count); void x_deposit_signal(sig_shared_t *ss, uint32_t offset, int32_t count, void *values); void x_put_conversion(rt_conv_func_t *cf, sig_shared_t *ss, uint32_t offset, int32_t count, void *values); void x_resolve_signal(sig_shared_t *ss, jit_handle_t handle, void *context, int32_t nlits, int32_t flags); void x_unreachable(tree_t where); void x_cover_setup_toggle_cb(sig_shared_t *ss, int32_t tag); void x_cover_setup_state_cb(sig_shared_t *ss, int64_t low, int32_t tag); void x_process_init(jit_handle_t handle, tree_t where); void x_clear_event(sig_shared_t *ss, uint32_t offset, int32_t count); void x_enter_state(int32_t state, bool strong); void *x_reflect_value(void *context, jit_scalar_t value, tree_t where, const jit_scalar_t *bounds); void *x_reflect_subtype(void *context, tree_t where, const jit_scalar_t *bounds); void *x_function_trigger(jit_handle_t handle, unsigned nargs, const jit_scalar_t *args); void *x_or_trigger(void *left, void *right); void *x_cmp_trigger(sig_shared_t *ss, uint32_t offset, int64_t right); void x_add_trigger(void *ptr); void *x_port_conversion(const ffi_closure_t *driving, const ffi_closure_t *effective); void x_convert_in(void *ptr, sig_shared_t *ss, uint32_t offset, int32_t count); void x_convert_out(void *ptr, sig_shared_t *ss, uint32_t offset, int32_t count); void x_bind_external(tree_t where, jit_handle_t scope, jit_scalar_t *result); void x_instance_name(attr_kind_t kind, text_buf_t *tb); #endif // _JIT_EXITS_H nvc-r1.17.1/src/jit/jit-ffi.c000066400000000000000000000332011504111170000156070ustar00rootroot00000000000000// // Copyright (C) 2021-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "jit/jit-ffi.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "option.h" #include "thread.h" #include "type.h" #include "vhpi/vhpi-util.h" #include "vpi/vpi-model.h" #include "vlog/vlog-node.h" #include #include #include #include #include #ifdef __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #else #include #endif typedef enum { GHDL_ARG_DROP, GHDL_ARG_PASS, GHDL_ARG_LENGTH, } ghdl_arg_t; typedef struct { ffi_cif cif; void *ptr; unsigned nvhdl; unsigned nforeign; ghdl_arg_t args[0]; } ghdl_ffi_t; typedef struct _jit_dll { jit_dll_t *next; char *path; #ifdef __MINGW32__ HMODULE handle; #else void *handle; #endif } jit_dll_t; static jit_dll_t *dlls; ffi_uarray_t ffi_wrap(void *ptr, int64_t left, int64_t right) { // Assumes ascending range const int64_t length = right < left ? 0 : right - left + 1; ffi_uarray_t u = { .ptr = ptr, .dims = { [0] = { .left = left, .length = length } } }; return u; } void ffi_return_string(const char *str, jit_scalar_t *args, tlab_t *tlab) { const size_t len = strlen(str); void *mem = tlab_alloc(tlab, len); memcpy(mem, str, len); args[0].pointer = mem; args[1].integer = 1; args[2].integer = len; } bool ffi_is_integral(ffi_type_t type) { return type == FFI_INT8 || type == FFI_INT16 || type == FFI_INT32 || type == FFI_INT64 || type == FFI_UINT8 || type == FFI_UINT16 || type == FFI_UINT32; } static jit_dll_t *ffi_load_exe(void) { if (dlls != NULL) return dlls; // First entry is always the executable #ifdef __MINGW32__ HMODULE libc_handle = GetModuleHandle("ucrtbase.dll"); if (libc_handle == NULL && !(libc_handle = GetModuleHandle("msvcrt.dll"))) fatal("failed to get handle to ucrtbase.dll or msvcrt.dll"); char *libc_path = xmalloc(MAX_PATH); if (!GetModuleFileName(libc_handle, libc_path, MAX_PATH)) fatal("failed to get C runtime library path: %s", last_os_error()); DEBUG_ONLY(debugf("C runtime library: %s", libc_path)); jit_dll_t *libc = xcalloc(sizeof(jit_dll_t)); libc->next = dlls; libc->handle = libc_handle; libc->path = libc_path; dlls = libc; HMODULE exe_handle = GetModuleHandle(NULL); if (exe_handle == NULL) fatal("failed to get handle to main process"); #else void *exe_handle = dlopen(NULL, RTLD_NOW); if (exe_handle == NULL) fatal("%s", dlerror()); #endif LOCAL_TEXT_BUF tb = tb_new(); get_exe_path(tb); jit_dll_t *dll = xcalloc(sizeof(jit_dll_t)); dll->next = dlls; dll->handle = exe_handle; dll->path = tb_claim(tb); return (dlls = dll); } jit_dll_t *ffi_load_dll(const char *path) { if (path == NULL) return ffi_load_exe(); char *abs = realpath(path, NULL); if (abs == NULL) fatal_errno("%s", path); for (jit_dll_t *it = dlls; it; it = it->next) { if (strcmp(it->path, abs) == 0) { free(abs); return it; } } if (opt_get_verbose(OPT_JIT_VERBOSE, NULL)) debugf("loading shared library %s", path); #ifdef __MINGW32__ HMODULE handle = LoadLibrary(abs); if (handle == NULL) fatal_errno("failed to load %s", abs); #else void *handle = dlopen(abs, RTLD_LAZY); if (handle == NULL) fatal("%s", dlerror()); #endif if (dlls == NULL) ffi_load_exe(); // First time initialisation jit_dll_t *dll = xcalloc(sizeof(jit_dll_t)); dll->handle = handle; dll->path = abs; jit_dll_t **where; for (where = &dlls; *where != NULL; where = &((*where)->next)); return (*where = dll); } void ffi_unload_dll(jit_dll_t *dll) { #ifdef __MINGW32__ FreeLibrary(dll->handle); #else dlclose(dll->handle); #endif free(dll->path); jit_dll_t **prev; for (prev = &dlls; *prev != dll; prev = &((*prev)->next)) ; *prev = dll->next; free(dll); } void *ffi_find_symbol(jit_dll_t *dll, const char *name) { if (name == NULL) return NULL; else if (dll == NULL) { for (jit_dll_t *it = dlls; it; it = it->next) { void *p = ffi_find_symbol(it, name); if (p != NULL) return p; } return NULL; } else { #ifdef __MINGW32__ return (void *)(uintptr_t)GetProcAddress(dll->handle, name); #else return dlsym(dll->handle, name); #endif } } ffi_spec_t ffi_spec_new(const ffi_type_t *types, size_t count) { assert(count > 0); #ifdef DEBUG for (int i = 0; i < count; i++) assert(isalpha(types[i])); #endif ffi_spec_t spec = {}; if (count < 7) { memcpy(spec.embed, types, count); spec.count = count; } else spec.ext = types; return spec; } static void jit_internal_entry(jit_func_t *f, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(caller); ffi_internal_t fn = *jit_get_privdata_ptr(f->jit, f); if (unlikely(fn == NULL)) { // JIT has been reset, need to elaborate again f->entry = jit_interp; jit_interp(f, caller, args, tlab); } else (*fn)(args, tlab); thread->anchor = NULL; } static void jit_vhpi_entry(jit_func_t *f, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(caller); vhpiHandleT handle = *jit_get_privdata_ptr(f->jit, f); if (unlikely(handle == NULL)) { // JIT has been reset, need to elaborate again f->entry = jit_interp; jit_interp(f, caller, args, tlab); } else vhpi_call_foreign(handle, args, tlab); thread->anchor = NULL; } static void jit_ghdl_entry(jit_func_t *f, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { jit_thread_local_t *thread = jit_attach_thread(caller); ghdl_ffi_t *gffi = *jit_get_privdata_ptr(f->jit, f); if (unlikely(gffi == NULL)) { // JIT has been reset, need to elaborate again f->entry = jit_interp; jit_interp(f, caller, args, tlab); } else { void *aptrs[gffi->nforeign]; int opos = 0; for (int ipos = 0; ipos < gffi->nvhdl; ipos++) { switch (gffi->args[ipos]) { case GHDL_ARG_DROP: break; case GHDL_ARG_PASS: aptrs[opos++] = &(args[ipos].integer); break; case GHDL_ARG_LENGTH: args[ipos].integer = ffi_array_length(args[ipos].integer); aptrs[opos++] = &(args[ipos].integer); break; } } intmax_t result = 0; ffi_call(&(gffi->cif), gffi->ptr, &result, aptrs); args[0].integer = result; } thread->anchor = NULL; } static ffi_type *ghdl_ffi_result_type(type_t type) { type_t base = type_base_recur(type); switch (type_kind(base)) { case T_INTEGER: case T_ENUM: case T_PHYSICAL: { switch (type_byte_width(base)) { case 8: return &ffi_type_sint64; case 4: return &ffi_type_sint32; case 2: return &ffi_type_sint16; case 1: return &ffi_type_sint8; } } break; case T_REAL: return &ffi_type_double; default: break; } jit_msg(NULL, DIAG_FATAL, "cannot return type %s using GHDL " "VHPIDIRECT calling convention", type_pp(type)); return &ffi_type_void; } static void ghdl_ffi_add_arg(ghdl_ffi_t *gffi, ffi_type **types, type_t type) { type_t base = type_base_recur(type); switch (type_kind(base)) { case T_INTEGER: case T_ENUM: case T_PHYSICAL: { gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; switch (type_byte_width(base)) { case 8: types[gffi->nforeign++] = &ffi_type_sint64; return; case 4: types[gffi->nforeign++] = &ffi_type_sint32; return; case 2: types[gffi->nforeign++] = &ffi_type_sint16; return; case 1: types[gffi->nforeign++] = &ffi_type_sint8; return; } } break; case T_REAL: gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; types[gffi->nforeign++] = &ffi_type_double; return; case T_RECORD: gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; types[gffi->nforeign++] = &ffi_type_pointer; return; case T_ARRAY: if (dimension_of(type) > 1) break; else if (type_is_unconstrained(type)) { gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; // Data pointer types[gffi->nforeign++] = &ffi_type_pointer; gffi->args[gffi->nvhdl++] = GHDL_ARG_DROP; // Left index gffi->args[gffi->nvhdl++] = GHDL_ARG_LENGTH; // Array length types[gffi->nforeign++] = &ffi_type_sint64; return; } else { gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; types[gffi->nforeign++] = &ffi_type_pointer; return; } default: break; } jit_msg(NULL, DIAG_FATAL, "cannot pass type %s using GHDL " "VHPIDIRECT calling convention", type_pp(type)); } static void *ffi_prepare_ghdl(tree_t decl, const char *symbol) { assert(tree_kind(decl) == T_ATTR_SPEC); tree_t sub = tree_ref(decl); const int nports = tree_ports(sub); const size_t ghdl_ffi_sz = sizeof(ghdl_ffi_t) + (2 + nports*3) * sizeof(ghdl_arg_t); ghdl_ffi_t *gffi = jit_mspace_alloc(ghdl_ffi_sz + nports * 2 * sizeof(ffi_type *)); ffi_type **types = (void *)gffi + ghdl_ffi_sz; ffi_type *ret; type_t type = tree_type(sub); if (type_has_result(type)) ret = ghdl_ffi_result_type(type_result(type)); else ret = &ffi_type_void; if ((gffi->ptr = ffi_find_symbol(NULL, symbol)) == NULL) jit_msg(NULL, DIAG_FATAL, "foreign function %s not found", symbol); gffi->nvhdl = gffi->nforeign = 0; gffi->args[gffi->nvhdl++] = GHDL_ARG_DROP; // Drop context argument if (!type_has_result(type)) gffi->args[gffi->nvhdl++] = GHDL_ARG_DROP; // Drop state argument for (int i = 0; i < nports; i++) { tree_t p = tree_port(sub, i); if (tree_class(p) == C_SIGNAL) jit_msg(tree_loc(p), DIAG_FATAL, "SIGNAL parameters are not " "supported for VHPIDIRECT subprograms using the GHDL " "calling convention"); else if (tree_subkind(p) != PORT_IN) { types[gffi->nforeign++] = &ffi_type_pointer; gffi->args[gffi->nvhdl++] = GHDL_ARG_PASS; } else ghdl_ffi_add_arg(gffi, types, tree_type(p)); } assert(gffi->nvhdl <= 2 + nports * 3); assert(gffi->nforeign <= nports * 2); if (ffi_prep_cif(&(gffi->cif), FFI_DEFAULT_ABI, gffi->nforeign, ret, types) != FFI_OK) fatal("ffi_prep_cif failed for %s", type_pp(type)); return gffi; } void jit_bind_foreign(jit_func_t *f, const uint8_t *spec, size_t length, tree_t where) { char *tmp LOCAL = null_terminate(spec, length), *p = strtok(tmp, " "); if (strcmp(p, "VHPIDIRECT") == 0 || strcmp(p, "GHDL") == 0) { p = strtok(NULL, " "); if (p != NULL) { // The object library specifier is silently ignored char *p2 = strtok(NULL, " "); if (p2 != NULL) p = p2; } *jit_get_privdata_ptr(f->jit, f) = ffi_prepare_ghdl(where, p); assert(f->entry != jit_ghdl_entry); // Should only be called once f->entry = jit_ghdl_entry; } else if (strcmp(p, "VHPI") == 0) { const char *obj_lib = strtok(NULL, " "); if (obj_lib == NULL) jit_msg(NULL, DIAG_FATAL, "missing object library name"); const char *model = strtok(NULL, " "); if (model == NULL) jit_msg(NULL, DIAG_FATAL, "missing model name"); vhpiHandleT handle = vhpi_bind_foreign(obj_lib, model, where); if (handle == NULL) jit_msg(NULL, DIAG_FATAL, "foreign subprogram %s/%s not registered", obj_lib, model); *jit_get_privdata_ptr(f->jit, f) = handle; assert(f->entry != jit_vhpi_entry); // Should only be called once f->entry = jit_vhpi_entry; } else if (strcmp(p, "INTERNAL") == 0) { p = strtok(NULL, " "); jit_dll_t *exe = ffi_load_exe(); ffi_internal_t fn = ffi_find_symbol(exe, p); if (fn == NULL) jit_msg(NULL, DIAG_FATAL, "missing internal symbol %s", p); *jit_get_privdata_ptr(f->jit, f) = fn; assert(f->entry != jit_internal_entry); // Should only be called once f->entry = jit_internal_entry; } else { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "failed to parse FOREIGN attribute"); diag_hint(d, NULL, "expecting specification to start with " "VHPIDIRECT or GHDL"); diag_emit(d); jit_abort_with_status(1); } } void jit_do_syscall(vlog_node_t where, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { ident_t name = vlog_ident(where); vpiHandle handle = vpi_bind_foreign(name, where); if (handle == NULL) jit_msg(NULL, DIAG_FATAL, "system task %s not registered", istr(name)); vpi_call_foreign(handle, args, tlab); } nvc-r1.17.1/src/jit/jit-ffi.h000066400000000000000000000050121504111170000156130ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_FFI_H #define _JIT_FFI_H #include "prim.h" #include "jit/jit.h" typedef char ffi_type_t; #define FFI_VOID 'v' #define FFI_INT8 'b' #define FFI_INT16 'w' #define FFI_INT32 'd' #define FFI_INT64 'q' #define FFI_UINT8 'B' #define FFI_UINT16 'W' #define FFI_UINT32 'D' #define FFI_FLOAT 'f' #define FFI_POINTER 'p' #define FFI_UARRAY 'u' #define FFI_SIGNAL 's' typedef union { struct { ffi_type_t embed[7]; uint8_t count; }; const ffi_type_t *ext; uint64_t bits; } ffi_spec_t; STATIC_ASSERT(sizeof(ffi_spec_t) == 8); #define ffi_spec_valid(s) ((s).bits != 0) #define ffi_spec_get(s, n) ((s).count ? (s).embed[(n)] : s.ext[(n)]) #define ffi_spec_has(s, n) \ (((s).count == 0 && (s).ext && (s).ext[(n)]) || (n) < (s).count) // The code generator knows the layout of this struct typedef struct { int64_t left; int64_t length; } ffi_dim_t; // The code generator knows the layout of this struct typedef struct _ffi_uarray { void *ptr; ffi_dim_t dims[1]; // Flexible member } ffi_uarray_t; #define ffi_array_length(d1) ((d1) ^ ((d1) >> 63)) #define ffi_array_right(d0, d1) ((d0 + d1) + (d1 < 0 ? 2 : -1)) #define ffi_array_dir(d1) (d1 < 0) // The code generator knows the layout of this struct typedef struct _ffi_closure { jit_handle_t handle; void *context; } ffi_closure_t; ffi_spec_t ffi_spec_new(const ffi_type_t *types, size_t count); ffi_uarray_t ffi_wrap(void *ptr, int64_t left, int64_t right); void ffi_return_string(const char *str, jit_scalar_t *args, tlab_t *tlab); bool ffi_is_integral(ffi_type_t type); typedef struct _jit_dll jit_dll_t; typedef void (*ffi_internal_t)(jit_scalar_t *, tlab_t *); jit_dll_t *ffi_load_dll(const char *path); void ffi_unload_dll(jit_dll_t *dll); void *ffi_find_symbol(jit_dll_t *dll, const char *name); #endif // _JIT_FFI_H nvc-r1.17.1/src/jit/jit-interp.c000066400000000000000000001013041504111170000163440ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "jit/jit-exits.h" #include "jit/jit-priv.h" #include "jit/jit-ffi.h" #include "rt/mspace.h" #include "tree.h" #include "type.h" #include #include #include #include #include #include typedef struct _jit_interp { jit_scalar_t *args; jit_scalar_t *regs; unsigned nargs; unsigned pc; jit_func_t *func; unsigned char *frame; unsigned flags; mspace_t *mspace; jit_anchor_t *anchor; tlab_t *tlab; } jit_interp_t; #ifdef DEBUG #define JIT_ASSERT(expr) do { \ if (unlikely(!(expr))) { \ interp_dump(state); \ fatal_trace("assertion '%s' failed", #expr); \ } \ } while (0) #define CANNOT_HANDLE(value) do { \ interp_dump(state); \ fatal_trace("cannot handle value kind %d", value.kind); \ } while (0) #else #define JIT_ASSERT(expr) #define CANNOT_HANDLE(value) __builtin_unreachable() #endif #define FOR_EACH_SIZE(sz, macro) do { \ assert((sz) != JIT_SZ_UNSPEC); \ switch ((sz)) { \ case JIT_SZ_8: macro(int8_t); break; \ case JIT_SZ_16: macro(int16_t); break; \ case JIT_SZ_32: macro(int32_t); break; \ case JIT_SZ_64: macro(int64_t); break; \ default: break; \ } \ } while (0) static void interp_dump_reg(jit_interp_t *state, int64_t ival) { printf("%"PRIx64, ival); if ((ival >= -256 && ival < 0) || (ival >= 10 && ival < 256)) printf(" (%"PRIi64")\n", ival); else if (ival >= (intptr_t)state->func->cpool && ival < (intptr_t)state->func->cpool + state->func->cpoolsz) { printf(" ==> cpool pointer\n"); jit_hexdump((void *)(intptr_t)ival, 8, 8, NULL, "\t\t\t"); } else { size_t size; void *base; if ((base = mspace_find(state->mspace, (void *)(intptr_t)ival, &size))) { if (size == 0) color_printf("$!red$ ==> bad mspace object$$\n"); else { printf(" ==> %zu byte mspace object\n", size); jit_hexdump(base, size, 8, (void *)(intptr_t)ival, "\t\t\t"); } } else printf("\n"); } } static void interp_dump(jit_interp_t *state) { jit_dump_with_mark(state->func, state->pc - 1); printf("Arguments:\n"); for (int i = 0; i < state->nargs; i++) { printf("\tA%d\t", i); interp_dump_reg(state, state->args[i].integer); } printf("\nRegisters:\n"); for (int i = 0; i < state->func->nregs; i++) { printf("\tR%d\t", i); interp_dump_reg(state, state->regs[i].integer); } printf("\nFlags: %c\n", state->flags ? 'T' : 'F'); if (state->func->framesz > 0) { printf("\nFrame:\n"); jit_hexdump(state->frame, state->func->framesz, 16, NULL, "\t"); } if (state->func->cpoolsz > 0) { printf("\nConstant pool:\n"); jit_hexdump(state->func->cpool, state->func->cpoolsz, 16, NULL, "\t"); } printf("\n"); fflush(stdout); } __attribute__((always_inline)) static inline int64_t interp_get_int(jit_interp_t *state, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: JIT_ASSERT(value.reg < state->func->nregs); return state->regs[value.reg].integer; case JIT_VALUE_INT64: case JIT_VALUE_DOUBLE: case JIT_ADDR_ABS: return value.int64; default: CANNOT_HANDLE(value); } } __attribute__((always_inline)) static inline double interp_get_real(jit_interp_t *state, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: JIT_ASSERT(value.reg < state->func->nregs); return state->regs[value.reg].real; case JIT_VALUE_INT64: case JIT_VALUE_DOUBLE: return value.dval; default: CANNOT_HANDLE(value); } } __attribute__((always_inline)) static inline void *interp_get_pointer(jit_interp_t *state, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: JIT_ASSERT(value.reg < state->func->nregs); return state->regs[value.reg].pointer; case JIT_ADDR_CPOOL: JIT_ASSERT(value.int64 >= 0 && value.int64 <= state->func->cpoolsz); return state->func->cpool + value.int64; case JIT_ADDR_REG: JIT_ASSERT(value.reg < state->func->nregs); return state->regs[value.reg].pointer + value.disp; case JIT_ADDR_ABS: return (void *)(intptr_t)value.int64; case JIT_ADDR_COVER: return jit_get_cover_ptr(state->func->jit, value); default: CANNOT_HANDLE(value); } } __attribute__((always_inline)) static inline jit_scalar_t interp_get_scalar(jit_interp_t *state, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: JIT_ASSERT(value.reg < state->func->nregs); return state->regs[value.reg]; case JIT_VALUE_INT64: return (jit_scalar_t){ .integer = value.int64 }; case JIT_VALUE_DOUBLE: return (jit_scalar_t){ .real = value.dval }; case JIT_VALUE_LABEL: return (jit_scalar_t){ .integer = value.label }; case JIT_VALUE_HANDLE: return (jit_scalar_t){ .integer = value.handle }; case JIT_VALUE_LOCUS: return (jit_scalar_t){ .pointer = value.locus }; case JIT_ADDR_CPOOL: JIT_ASSERT(value.int64 >= 0 && value.int64 <= state->func->cpoolsz); return (jit_scalar_t){ .pointer = state->func->cpool + value.int64 }; case JIT_ADDR_REG: JIT_ASSERT(value.reg < state->func->nregs); return (jit_scalar_t){ .pointer = state->regs[value.reg].pointer + value.disp }; case JIT_ADDR_ABS: return (jit_scalar_t){ .pointer = (void *)(intptr_t)value.int64 }; case JIT_ADDR_COVER: return (jit_scalar_t){ .pointer = jit_get_cover_ptr(state->func->jit, value) }; default: CANNOT_HANDLE(value); } } static void interp_recv(jit_interp_t *state, jit_ir_t *ir) { JIT_ASSERT(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; JIT_ASSERT(nth < JIT_MAX_ARGS); state->regs[ir->result] = state->args[nth]; state->nargs = MAX(state->nargs, nth + 1); } static void interp_send(jit_interp_t *state, jit_ir_t *ir) { JIT_ASSERT(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; JIT_ASSERT(nth < JIT_MAX_ARGS); state->args[nth] = interp_get_scalar(state, ir->arg2); state->nargs = MAX(state->nargs, nth + 1); } static void interp_and(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 & arg2; } static void interp_or(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 | arg2; } static void interp_xor(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 ^ arg2; } static void interp_mul(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); if (ir->cc == JIT_CC_O) { int overflow = 0; #define MUL_OVERFLOW(type) do { \ type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_mul_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, MUL_OVERFLOW); state->flags = overflow; } else if (ir->cc == JIT_CC_C) { int overflow = 0; #define UMUL_OVERFLOW(type) do { \ u##type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_mul_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, UMUL_OVERFLOW); state->flags = overflow; } else state->regs[ir->result].integer = arg1 * arg2; } static void interp_fmul(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); state->regs[ir->result].real = arg1 * arg2; } static void interp_div(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 / arg2; } static void interp_fdiv(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); state->regs[ir->result].real = arg1 / arg2; } static void interp_sub(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); if (ir->cc == JIT_CC_O) { int overflow = 0; #define SUB_OVERFLOW(type) do { \ type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_sub_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, SUB_OVERFLOW); state->flags = overflow; } else if (ir->cc == JIT_CC_C) { int overflow = 0; #define USUB_OVERFLOW(type) do { \ u##type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_sub_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, USUB_OVERFLOW); state->flags = overflow; } else state->regs[ir->result].integer = arg1 - arg2; } static void interp_fsub(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); state->regs[ir->result].real = arg1 - arg2; } static void interp_add(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); if (ir->cc == JIT_CC_O) { int overflow = 0; #define ADD_OVERFLOW(type) do { \ type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_add_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, ADD_OVERFLOW); state->flags = overflow; } else if (ir->cc == JIT_CC_C) { int overflow = 0; #define UADD_OVERFLOW(type) do { \ u##type i1 = arg1, i2 = arg2, i0; \ overflow = __builtin_add_overflow(i1, i2, &i0); \ state->regs[ir->result].integer = i0; \ } while (0) FOR_EACH_SIZE(ir->size, UADD_OVERFLOW); state->flags = overflow; } else state->regs[ir->result].integer = arg1 + arg2; } static void interp_fadd(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); state->regs[ir->result].real = arg1 + arg2; } static void interp_shl(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 << arg2; } static void interp_asr(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = arg1 >> arg2; } static void interp_store(jit_interp_t *state, jit_ir_t *ir) { jit_scalar_t arg1 = interp_get_scalar(state, ir->arg1); void *arg2 = interp_get_pointer(state, ir->arg2); JIT_ASSERT(ir->size != JIT_SZ_UNSPEC); JIT_ASSERT(arg2 != NULL); JIT_ASSERT((intptr_t)arg2 >= 4096); switch (ir->size) { case JIT_SZ_8: *(uint8_t *)arg2 = (uint8_t)arg1.integer; break; case JIT_SZ_16: *(uint16_t *)arg2 = (uint16_t)arg1.integer; break; case JIT_SZ_32: *(uint32_t *)arg2 = (uint32_t)arg1.integer; break; case JIT_SZ_64: *(uint64_t *)arg2 = arg1.integer; break; case JIT_SZ_UNSPEC: break; } } static void interp_uload(jit_interp_t *state, jit_ir_t *ir) { void *arg1 = interp_get_pointer(state, ir->arg1); JIT_ASSERT(ir->size != JIT_SZ_UNSPEC); JIT_ASSERT(arg1 != NULL); JIT_ASSERT((intptr_t)arg1 >= 4096); switch (ir->size) { case JIT_SZ_8: state->regs[ir->result].integer = *(uint8_t *)arg1; break; case JIT_SZ_16: state->regs[ir->result].integer = *(uint16_t *)arg1; break; case JIT_SZ_32: state->regs[ir->result].integer = *(uint32_t *)arg1; break; case JIT_SZ_64: state->regs[ir->result].integer = *(uint64_t *)arg1; break; case JIT_SZ_UNSPEC: break; } } static void interp_load(jit_interp_t *state, jit_ir_t *ir) { void *arg1 = interp_get_pointer(state, ir->arg1); JIT_ASSERT(ir->size != JIT_SZ_UNSPEC); JIT_ASSERT(arg1 != NULL); JIT_ASSERT((intptr_t)arg1 >= 4096); switch (ir->size) { case JIT_SZ_8: state->regs[ir->result].integer = *(int8_t *)arg1; break; case JIT_SZ_16: state->regs[ir->result].integer = *(int16_t *)arg1; break; case JIT_SZ_32: state->regs[ir->result].integer = *(int32_t *)arg1; break; case JIT_SZ_64: state->regs[ir->result].integer = *(int64_t *)arg1; break; case JIT_SZ_UNSPEC: break; } } static void interp_cmp(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); switch (ir->cc) { case JIT_CC_EQ: state->flags = (arg1 == arg2); break; case JIT_CC_NE: state->flags = (arg1 != arg2); break; case JIT_CC_LT: state->flags = (arg1 < arg2); break; case JIT_CC_GT: state->flags = (arg1 > arg2); break; case JIT_CC_LE: state->flags = (arg1 <= arg2); break; case JIT_CC_GE: state->flags = (arg1 >= arg2); break; default: state->flags = 0; break; } } static void interp_ccmp(jit_interp_t *state, jit_ir_t *ir) { const int64_t arg1 = interp_get_int(state, ir->arg1); const int64_t arg2 = interp_get_int(state, ir->arg2); switch (ir->cc) { case JIT_CC_EQ: state->flags &= (arg1 == arg2); break; case JIT_CC_NE: state->flags &= (arg1 != arg2); break; case JIT_CC_LT: state->flags &= (arg1 < arg2); break; case JIT_CC_GT: state->flags &= (arg1 > arg2); break; case JIT_CC_LE: state->flags &= (arg1 <= arg2); break; case JIT_CC_GE: state->flags &= (arg1 >= arg2); break; default: state->flags = 0; break; } } static void interp_fcmp(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); switch (ir->cc) { case JIT_CC_EQ: state->flags = (arg1 == arg2); break; case JIT_CC_NE: state->flags = (arg1 != arg2); break; case JIT_CC_LT: state->flags = (arg1 < arg2); break; case JIT_CC_GT: state->flags = (arg1 > arg2); break; case JIT_CC_LE: state->flags = (arg1 <= arg2); break; case JIT_CC_GE: state->flags = (arg1 >= arg2); break; default: state->flags = 0; break; } } static void interp_fccmp(jit_interp_t *state, jit_ir_t *ir) { const double arg1 = interp_get_real(state, ir->arg1); const double arg2 = interp_get_real(state, ir->arg2); switch (ir->cc) { case JIT_CC_EQ: state->flags &= (arg1 == arg2); break; case JIT_CC_NE: state->flags &= (arg1 != arg2); break; case JIT_CC_LT: state->flags &= (arg1 < arg2); break; case JIT_CC_GT: state->flags &= (arg1 > arg2); break; case JIT_CC_LE: state->flags &= (arg1 <= arg2); break; case JIT_CC_GE: state->flags &= (arg1 >= arg2); break; default: state->flags = 0; break; } } static void interp_rem(jit_interp_t *state, jit_ir_t *ir) { const int64_t x = interp_get_int(state, ir->arg1); const int64_t y = interp_get_int(state, ir->arg2); state->regs[ir->result].integer = x - (x / y) * y; } static void interp_clamp(jit_interp_t *state, jit_ir_t *ir) { const int64_t value = interp_get_int(state, ir->arg1); state->regs[ir->result].integer = value < 0 ? 0 : value; } static void interp_cset(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].integer = !!(state->flags); } static void interp_branch_to(jit_interp_t *state, jit_value_t label) { JIT_ASSERT(label.kind == JIT_VALUE_LABEL); state->pc = label.label; JIT_ASSERT(state->pc < state->func->nirs); } static void interp_jump(jit_interp_t *state, jit_ir_t *ir) { switch (ir->cc) { case JIT_CC_NONE: interp_branch_to(state, ir->arg1); break; case JIT_CC_T: if (state->flags) interp_branch_to(state, ir->arg1); break; case JIT_CC_F: if (!state->flags) interp_branch_to(state, ir->arg1); break; default: interp_dump(state); fatal_trace("unhandled jump condition code"); } } static void interp_trap(jit_interp_t *state, jit_ir_t *ir) { interp_dump(state); fatal_trace("executed trap opcode"); } static void interp_call(jit_interp_t *state, jit_ir_t *ir) { JIT_ASSERT(ir->arg1.kind == JIT_VALUE_HANDLE); state->anchor->irpos = ir - state->func->irbuf; if (ir->arg1.handle == JIT_HANDLE_INVALID) { jit_dump_with_mark(state->func, state->anchor->irpos); jit_msg(NULL, DIAG_FATAL, "missing definition for subprogram"); } else { jit_func_t *f = jit_get_func(state->func->jit, ir->arg1.handle); jit_entry_fn_t entry = load_acquire(&f->entry); (*entry)(f, state->anchor, state->args, state->tlab); } } static void interp_mov(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result] = interp_get_scalar(state, ir->arg1); } static void interp_csel(jit_interp_t *state, jit_ir_t *ir) { if (state->flags) state->regs[ir->result].integer = interp_get_int(state, ir->arg1); else state->regs[ir->result].integer = interp_get_int(state, ir->arg2); } static void interp_neg(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].integer = -interp_get_int(state, ir->arg1); } static void interp_fneg(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].real = -interp_get_real(state, ir->arg1); } static void interp_not(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].integer = !interp_get_int(state, ir->arg1); } static void interp_scvtf(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].real = interp_get_int(state, ir->arg1); } static void interp_fcvtns(jit_interp_t *state, jit_ir_t *ir) { const double f = interp_get_real(state, ir->arg1); state->regs[ir->result].integer = (int64_t)(f + copysign(0.5, f)); } static void interp_lea(jit_interp_t *state, jit_ir_t *ir) { state->regs[ir->result].pointer = interp_get_pointer(state, ir->arg1); } static void interp_fexp(jit_interp_t *state, jit_ir_t *ir) { const double x = interp_get_real(state, ir->arg1); const double y = interp_get_real(state, ir->arg2); state->regs[ir->result].real = pow(x, y); } static void interp_exp(jit_interp_t *state, jit_ir_t *ir) { const int64_t x = interp_get_int(state, ir->arg1); const int64_t y = interp_get_int(state, ir->arg2); if (ir->cc == JIT_CC_O) { int overflow = 0, xo = 0; #define EXP_OVERFLOW(type) do { \ type xt = x, yt = y, r = 1; \ while (yt) { \ if (yt & 1) \ overflow |= xo || __builtin_mul_overflow(r, xt, &r); \ yt >>= 1; \ xo |= __builtin_mul_overflow(xt, xt, &xt); \ } \ state->regs[ir->result].integer = r; \ } while (0) FOR_EACH_SIZE(ir->size, EXP_OVERFLOW); state->flags = overflow; } else if (ir->cc == JIT_CC_C) { int overflow = 0, xo = 0; #define UEXP_OVERFLOW(type) do { \ u##type xt = x, yt = y, r = 1; \ while (yt) { \ if (yt & 1) \ overflow |= xo || __builtin_mul_overflow(r, xt, &r); \ yt >>= 1; \ xo |= __builtin_mul_overflow(xt, xt, &xt); \ } \ state->regs[ir->result].integer = r; \ } while (0) FOR_EACH_SIZE(ir->size, UEXP_OVERFLOW); state->flags = overflow; } else state->regs[ir->result].integer = ipow(x, y); } static void interp_copy(jit_interp_t *state, jit_ir_t *ir) { const size_t count = state->regs[ir->result].integer; void *dest = interp_get_pointer(state, ir->arg1); const void *src = interp_get_pointer(state, ir->arg2); JIT_ASSERT((uintptr_t)dest >= 4096 || count == 0); JIT_ASSERT((uintptr_t)src >= 4096 || count == 0); JIT_ASSERT(dest + count <= src || src + count <= dest); memcpy(dest, src, count); } static void interp_move(jit_interp_t *state, jit_ir_t *ir) { const size_t count = state->regs[ir->result].integer; void *dest = interp_get_pointer(state, ir->arg1); const void *src = interp_get_pointer(state, ir->arg2); JIT_ASSERT((uintptr_t)dest >= 4096 || count == 0); JIT_ASSERT((uintptr_t)src >= 4096 || count == 0); memmove(dest, src, count); } static void interp_bzero(jit_interp_t *state, jit_ir_t *ir) { const size_t count = state->regs[ir->result].integer; void *dest = interp_get_pointer(state, ir->arg1); memset(dest, '\0', count); } static void interp_memset(jit_interp_t *state, jit_ir_t *ir) { const size_t bytes = state->regs[ir->result].integer; void *dest = interp_get_pointer(state, ir->arg1); const uint64_t value = interp_get_int(state, ir->arg2); JIT_ASSERT(dest != NULL); #define MEMSET_LOOP(type) do { \ JIT_ASSERT(bytes % sizeof(type) == 0); \ type *eptr = dest + bytes; \ for (type *p = dest; p < eptr; p++) \ *p = value; \ } while (0) FOR_EACH_SIZE(ir->size, MEMSET_LOOP); } static void interp_galloc(jit_interp_t *state, jit_ir_t *ir) { jit_thread_local_t *thread = jit_thread_local(); thread->anchor = state->anchor; state->anchor->irpos = ir - state->func->irbuf; uint64_t bytes = interp_get_int(state, ir->arg1); if (bytes > UINT32_MAX) jit_msg(NULL, DIAG_FATAL, "attempting to allocate %"PRIu64" byte object " "which is larger than the maximum supported %u bytes", bytes, UINT32_MAX); else if (bytes == 0) bytes = 1; // Never return a NULL pointer state->regs[ir->result].pointer = mspace_alloc(state->mspace, bytes); thread->anchor = NULL; } static void interp_lalloc(jit_interp_t *state, jit_ir_t *ir) { jit_thread_local_t *thread = jit_thread_local(); thread->anchor = state->anchor; state->anchor->irpos = ir - state->func->irbuf; const size_t bytes = interp_get_int(state, ir->arg1); state->regs[ir->result].pointer = tlab_alloc(state->tlab, bytes); thread->anchor = NULL; } static void interp_salloc(jit_interp_t *state, jit_ir_t *ir) { assert(ir->arg1.int64 + ir->arg2.int64 <= state->func->framesz); state->regs[ir->result].pointer = state->frame + ir->arg1.int64; } static void interp_exit(jit_interp_t *state, jit_ir_t *ir) { state->anchor->irpos = ir - state->func->irbuf; __nvc_do_exit(ir->arg1.exit, state->anchor, state->args, state->tlab); } static void interp_getpriv(jit_interp_t *state, jit_ir_t *ir) { JIT_ASSERT(ir->arg1.kind == JIT_VALUE_HANDLE); jit_func_t *f = jit_get_func(state->func->jit, ir->arg1.handle); void *ptr = load_acquire(jit_get_privdata_ptr(state->func->jit, f)); state->regs[ir->result].pointer = ptr; } static void interp_putpriv(jit_interp_t *state, jit_ir_t *ir) { JIT_ASSERT(ir->arg1.kind == JIT_VALUE_HANDLE); jit_func_t *f = jit_get_func(state->func->jit, ir->arg1.handle); void *ptr = interp_get_pointer(state, ir->arg2); store_release(jit_get_privdata_ptr(state->func->jit, f), ptr); } static void interp_case(jit_interp_t *state, jit_ir_t *ir) { jit_scalar_t test = state->regs[ir->result]; const int64_t cmp = interp_get_int(state, ir->arg1); if (test.integer == cmp) interp_branch_to(state, ir->arg2); } static void interp_trim(jit_interp_t *state, jit_ir_t *ir) { assert(state->tlab->alloc >= state->anchor->watermark); state->tlab->alloc = state->anchor->watermark; } static void interp_reexec(jit_interp_t *state, jit_ir_t *ir) { jit_entry_fn_t entry = load_acquire(&state->func->entry); (*entry)(state->func, state->anchor->caller, state->args, state->tlab); } static void interp_sadd(jit_interp_t *state, jit_ir_t *ir) { const void *ptr = interp_get_pointer(state, ir->arg1); const int64_t addend = interp_get_int(state, ir->arg2); #define SADD(type) do { \ u##type cur = *(u##type *)ptr; \ *(u##type *)ptr = saturate_add(cur, addend); \ } while (0) FOR_EACH_SIZE(ir->size, SADD); } static void interp_pack(jit_interp_t *state, jit_ir_t *ir) { const uint8_t *src = interp_get_pointer(state, ir->arg1); const size_t size = interp_get_int(state, ir->arg2); assert(size <= 64); // TODO uint64_t abits = 0, bbits = 0; for (size_t i = 0; i < size; i++) { abits = (abits << 1) | (src[i] & 1); bbits = (bbits << 1) | ((src[i] >> 1) & 1); } state->args[0].integer = abits; state->args[1].integer = bbits; } static void interp_unpack(jit_interp_t *state, jit_ir_t *ir) { uint8_t *dest = state->args[0].pointer; size_t size = state->args[1].integer; uint8_t strength = state->args[2].integer; uint64_t abits = interp_get_int(state, ir->arg1); uint64_t bbits = interp_get_int(state, ir->arg2); for (size_t i = 0; i < size; i++, abits >>= 1, bbits >>= 1) dest[size - i - 1] = (abits & 1) | ((bbits & 1) << 1) | strength; } static void interp_loop(jit_interp_t *state) { for (;;) { JIT_ASSERT(state->pc < state->func->nirs); jit_ir_t *ir = &(state->func->irbuf[state->pc++]); switch (ir->op) { case J_RECV: interp_recv(state, ir); break; case J_SEND: interp_send(state, ir); break; case J_AND: interp_and(state, ir); break; case J_OR: interp_or(state, ir); break; case J_XOR: interp_xor(state, ir); break; case J_SUB: interp_sub(state, ir); break; case J_FSUB: interp_fsub(state, ir); break; case J_ADD: interp_add(state, ir); break; case J_FADD: interp_fadd(state, ir); break; case J_MUL: interp_mul(state, ir); break; case J_FMUL: interp_fmul(state, ir); break; case J_DIV: interp_div(state, ir); break; case J_FDIV: interp_fdiv(state, ir); break; case J_SHL: interp_shl(state, ir); break; case J_ASR: interp_asr(state, ir); break; case J_RET: return; case J_STORE: interp_store(state, ir); break; case J_ULOAD: interp_uload(state, ir); break; case J_LOAD: interp_load(state, ir); break; case J_CMP: interp_cmp(state, ir); break; case J_CCMP: interp_ccmp(state, ir); break; case J_FCMP: interp_fcmp(state, ir); break; case J_FCCMP: interp_fccmp(state, ir); break; case J_CSET: interp_cset(state, ir); break; case J_JUMP: interp_jump(state, ir); break; case J_TRAP: interp_trap(state, ir); break; case J_CALL: interp_call(state, ir); break; case J_MOV: interp_mov(state, ir); break; case J_CSEL: interp_csel(state, ir); break; case J_NEG: interp_neg(state, ir); break; case J_FNEG: interp_fneg(state, ir); break; case J_NOT: interp_not(state, ir); break; case J_SCVTF: interp_scvtf(state, ir); break; case J_FCVTNS: interp_fcvtns(state, ir); break; case J_LEA: interp_lea(state, ir); break; case J_REM: interp_rem(state, ir); break; case J_CLAMP: interp_clamp(state, ir); break; case J_DEBUG: case J_NOP: break; case MACRO_COPY: interp_copy(state, ir); break; case MACRO_MOVE: interp_move(state, ir); break; case MACRO_BZERO: interp_bzero(state, ir); break; case MACRO_MEMSET: interp_memset(state, ir); break; case MACRO_GALLOC: interp_galloc(state, ir); break; case MACRO_LALLOC: interp_lalloc(state, ir); break; case MACRO_SALLOC: interp_salloc(state, ir); break; case MACRO_EXIT: interp_exit(state, ir); break; case MACRO_FEXP: interp_fexp(state, ir); break; case MACRO_EXP: interp_exp(state, ir); break; case MACRO_GETPRIV: interp_getpriv(state, ir); break; case MACRO_PUTPRIV: interp_putpriv(state, ir); break; case MACRO_CASE: interp_case(state, ir); break; case MACRO_TRIM: interp_trim(state, ir); break; case MACRO_REEXEC: interp_reexec(state, ir); return; case MACRO_SADD: interp_sadd(state, ir); break; case MACRO_PACK: interp_pack(state, ir); break; case MACRO_UNPACK: interp_unpack(state, ir); break; default: interp_dump(state); fatal_trace("cannot interpret opcode %s", jit_op_name(ir->op)); } } } void jit_interp(jit_func_t *f, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { jit_entry_fn_t entry = load_acquire(&f->entry); if (unlikely(entry != jit_interp)) { // Raced with a code generation thread installing a compiled // version of this function return (*entry)(f, caller, args, tlab); } jit_fill_irbuf(f); if (f->next_tier && --(f->hotness) <= 0) jit_tier_up(f); jit_anchor_t anchor = { .caller = caller, .func = f, .watermark = tlab->alloc, }; // Using VLAs here as we need these allocated on the stack so the // mspace GC can scan them jit_scalar_t regs[f->nregs + 1]; unsigned char frame[f->framesz + 1]; #ifdef DEBUG memset(regs, 0xde, sizeof(jit_scalar_t) * f->nregs); memset(frame, 0xde, f->framesz); #endif jit_interp_t state = { .args = args, .regs = regs, .nargs = 0, .pc = 0, .func = f, .frame = frame, .mspace = jit_get_mspace(f->jit), .anchor = &anchor, .tlab = tlab, }; interp_loop(&state); } nvc-r1.17.1/src/jit/jit-intrin.c000066400000000000000000002034761504111170000163630ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "ident.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "option.h" #include "rt/assert.h" #include "thread.h" #include #include #include #include #ifdef ARCH_ARM64 #define HAVE_NEON #endif #ifdef HAVE_AVX2 #include #endif #ifdef HAVE_NEON #include #endif #if defined __GNUC__ && !defined __clang__ #pragma GCC optimize ("O2") #endif typedef enum { CPU_AVX2 = 0x1, CPU_SSE41 = 0x2, CPU_NEON = 0x04, } cpu_feature_t; typedef struct { const char *name; jit_entry_fn_t entry; cpu_feature_t feature; ident_t ident; } jit_intrinsic_t; typedef enum { _U = 0x0, _X = 0x1, _0 = 0x2, _1 = 0x3, _Z = 0x4, _W = 0x5, _L = 0x6, _H = 0x7, _DC = 0x8 } std_ulogic_t; #define IS_01(x) \ _Generic((x), \ uint64_t: (((x) & UINT64_C(0x0e0e0e0e0e0e0e0e)) \ == UINT64_C(0x0202020202020202)), \ uint8_t: ((x) & 0xe) == 0x02) __attribute__((aligned(16))) static const uint8_t cvt_to_x01[16] = { _X, _X, _0, _1, _X, _X, _0, _1, _X, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; static const uint8_t xor_table[16][16] = { // -------------------------------------------------- // | U X 0 1 Z W L H - | | // -------------------------------------------------- { _U, _U, _U, _U, _U, _U, _U, _U, _U }, // | U | { _U, _X, _X, _X, _X, _X, _X, _X, _X }, // | X | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | 0 | { _U, _X, _1, _0, _X, _X, _1, _0, _X }, // | 1 | { _U, _X, _X, _X, _X, _X, _X, _X, _X }, // | Z | { _U, _X, _X, _X, _X, _X, _X, _X, _X }, // | W | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | L | { _U, _X, _1, _0, _X, _X, _1, _0, _X }, // | H | { _U, _X, _X, _X, _X, _X, _X, _X, _X }, // | - | }; static const uint8_t and_table[16][16] = { // --------------------------------------------------- // | U X 0 1 Z W L H - | | // --------------------------------------------------- { _U, _U, _0, _U, _U, _U, _0, _U, _U }, // | U | { _U, _X, _0, _X, _X, _X, _0, _X, _X }, // | X | { _0, _0, _0, _0, _0, _0, _0, _0, _0 }, // | 0 | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | 1 | { _U, _X, _0, _X, _X, _X, _0, _X, _X }, // | Z | { _U, _X, _0, _X, _X, _X, _0, _X, _X }, // | W | { _0, _0, _0, _0, _0, _0, _0, _0, _0 }, // | L | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | H | { _U, _X, _0, _X, _X, _X, _0, _X, _X }, // | - | }; static const uint8_t or_table[16][16] = { // --------------------------------------------------- // | U X 0 1 Z W L H - | | // --------------------------------------------------- { _U, _U, _U, _1, _U, _U, _U, _1, _U }, // | U | { _U, _X, _X, _1, _X, _X, _X, _1, _X }, // | X | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | 0 | { _1, _1, _1, _1, _1, _1, _1, _1, _1 }, // | 1 | { _U, _X, _X, _1, _X, _X, _X, _1, _X }, // | Z | { _U, _X, _X, _1, _X, _X, _X, _1, _X }, // | W | { _U, _X, _0, _1, _X, _X, _0, _1, _X }, // | L | { _1, _1, _1, _1, _1, _1, _1, _1, _1 }, // | H | { _U, _X, _X, _1, _X, _X, _X, _1, _X }, // | - | }; #if defined HAVE_SSE41 static const uint8_t not_table[1][16] = { // --------------------------------------------------- // | U X 0 1 Z W L H - | | { _U, _X, _1, _0, _X, _X, _1, _0, _X }, }; #endif #if defined HAVE_SSE41 || defined HAVE_NEON // Compressed lookup tables for vectorised intrinsics. Note the // vectorised intrinsics all rely on being able to read up to // OVERRUN_MARGIN (defined in src/rt/mspace.c) bytes beyond the end of // the input arrays. __attribute__((aligned(16))) static const uint8_t compress_left[16] = { _U, _X, _0, _1, _X, _X, _0, _1, _X, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; __attribute__((aligned(16))) static const uint8_t compress_right[16] = { _U << 2, _X << 2, _0 << 2, _1 << 2, _X << 2, _X << 2, _0 << 2, _1 << 2, _X << 2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; __attribute__((aligned(16))) static const uint8_t small_or_table[4][4] = { // ----------------------------- // | U X 0 1 | | // ----------------------------- { _U, _U, _U, _1 }, // | U | { _U, _X, _X, _1 }, // | X | { _U, _X, _0, _1 }, // | 0 | { _1, _1, _1, _1 }, // | 1 | }; __attribute__((aligned(16))) static const uint8_t small_and_table[4][4] = { // ----------------------------- // | U X 0 1 | | // ----------------------------- { _U, _U, _0, _U }, // | U | { _U, _X, _0, _X }, // | X | { _0, _0, _0, _0 }, // | 0 | { _U, _X, _0, _1 }, // | 1 | }; __attribute__((aligned(16))) static const uint8_t small_xor_table[4][4] = { // ----------------------------- // | U X 0 1 | | // ----------------------------- { _U, _U, _U, _U }, // | U | { _U, _X, _X, _X }, // | X | { _U, _X, _0, _1 }, // | 0 | { _U, _X, _1, _0 }, // | 1 | }; __attribute__((aligned(16))) static const uint8_t lane_iota[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; #endif __attribute__((always_inline)) static inline void *__tlab_alloc(tlab_t *t, size_t size, size_t align) { assert(t->alloc <= t->limit); assert((t->alloc & (sizeof(double) - 1)) == 0); assert(align % sizeof(double) == 0); const size_t alignup = ALIGN_UP(size, sizeof(double)); const size_t base = ALIGN_UP(t->alloc, align); if (likely(base + alignup <= t->limit)) { t->alloc = base + alignup; return t->data + base; } else return mspace_alloc(t->mspace, size); } __attribute__((always_inline)) static inline uint32_t __tlab_mark(tlab_t *t) { return t->alloc; } __attribute__((always_inline)) static inline void __tlab_restore(tlab_t *t, uint32_t mark) { assert(mark <= t->alloc); t->alloc = mark; } #if 0 static void print_bits(const char *tag, const uint8_t *bits, size_t size) { static const char map[] = "UX01ZWLH-"; printf("%s: ", tag); for (int i = 0; i < size; i++) printf("%c", map[bits[i]]); printf("\n"); } #endif #if 0 __attribute__((target("sse4.1"))) static void print_m128i(const char *tag, __m128i vec) { uint8_t bytes[16]; memcpy(bytes, &vec, sizeof(vec)); printf("%s:", tag); for (int i = 0; i < 16; i++) printf(" %02x", bytes[i]); printf("\n"); } #endif __attribute__((cold, noinline)) static void ieee_msg_v(jit_func_t *func, jit_anchor_t *caller, vhdl_severity_t severity, const char *fmt, va_list ap) { jit_anchor_t frame = { .caller = caller, .func = func }; jit_thread_local_t *thread = jit_thread_local(); thread->anchor = &frame; diag_t *d = diag_new(get_diag_severity(severity), NULL); diag_vprintf(d, fmt, ap); diag_show_source(d, false); emit_vhdl_diag(d, severity); thread->anchor = NULL; } __attribute__((cold, noinline)) static void __ieee_msg(jit_func_t *func, jit_anchor_t *caller, vhdl_severity_t severity, const char *fmt, ...) { va_list ap; va_start(ap, fmt); ieee_msg_v(func, caller, severity, fmt, ap); va_end(ap); } __attribute__((cold, noinline)) static void ieee_warn(jit_func_t *func, jit_anchor_t *caller, const char *fmt, ...) { if (opt_get_int(OPT_IEEE_WARNINGS) != IEEE_WARNINGS_ON) return; va_list ap; va_start(ap, fmt); ieee_msg_v(func, caller, SEVERITY_WARNING, fmt, ap); va_end(ap); } __attribute__((always_inline)) static inline void __invert_bits(const uint8_t *input, int size, uint8_t *result) { for (int i = 0; i < size; i++) { assert(input[i] == _0 || input[i] == _1); result[i] = input[i] ^ 1; } } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void std_to_x01_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = args[3].integer ^ (args[3].integer >> 63); const uint8_t *input = args[1].pointer; uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(size, 16), 16); __m128i lookup = _mm_load_si128((const __m128i *)cvt_to_x01); for (int pos = 0; pos < size; pos += 16) { __m128i in = _mm_loadu_si128((const __m128i *)(input + pos)); __m128i out = _mm_shuffle_epi8(lookup, in); _mm_store_si128((__m128i *)(result + pos), out); } args[0].pointer = result; args[1].integer = size - 1; args[2].integer = ~size; } #endif static void std_to_x01(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = args[3].integer ^ (args[3].integer >> 63); const uint8_t *input = args[1].pointer; uint8_t *result = __tlab_alloc(tlab, size, 8); for (int i = 0; i < size; i++) result[i] = cvt_to_x01[input[i]]; args[0].pointer = result; args[1].integer = size - 1; args[2].integer = ~size; } __attribute__((always_inline)) static inline bool __all_01(const void *vec, int size) { int pos = 0; for (; pos + 7 < size; pos += 8) { const uint64_t u64 = unaligned_load(vec + pos, uint64_t); if (!IS_01(u64)) return false; } for (; pos < size; pos++) { const uint8_t u8 = *(const uint8_t *)(vec + pos); if (!IS_01(u8)) return false; } return true; } __attribute__((cold, noinline)) static uint8_t *ieee_to_01_slow(tlab_t *tlab, const uint8_t *input, int size, uint8_t xmap) { uint8_t *result = __tlab_alloc(tlab, size, 8); bool bad = false; for (int i = 0; i < size; i++) { const uint8_t elt = input[i]; if (elt == _1 || elt == _H) result[i] = _1; else if (elt == _0 || elt == _L) result[i] = _0; else bad = true; } if (bad) memset(result, xmap, size); return result; } __attribute__((always_inline)) static inline uint8_t *__to_01(tlab_t *tlab, const uint8_t *input, int size, uint8_t xmap) { assert(size > 0); if (__all_01(input, size)) return (uint8_t *)input; else return ieee_to_01_slow(tlab, input, size, xmap); } static void ieee_to_01(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = args[3].integer ^ (args[3].integer >> 63); const uint8_t *input = args[1].pointer; const uint8_t xmap = args[4].integer; if (size == 0) { ieee_warn(func, anchor, "NUMERIC_STD.TO_01: null detected, returning NAU"); args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { args[0].pointer = __to_01(tlab, input, size, xmap); args[1].integer = size - 1; args[2].integer = ~size; } } __attribute__((always_inline)) static inline uint8_t *__resize_unsigned(tlab_t *tlab, const void *input, int size, int newsize) { if (newsize < 1) return NULL; else if (size >= newsize) return (uint8_t *)input + size - newsize; else { uint8_t *result = __tlab_alloc(tlab, newsize, 8); const int pad = newsize - size; memset(result, _0, pad); memcpy(result + pad, input, size); return result; } } __attribute__((always_inline)) static inline uint8_t *__resize_signed(tlab_t *tlab, const void *input, int size, int newsize) { if (newsize < 1) return NULL; else if (size == newsize) return (uint8_t *)input; else if (size == 0) { uint8_t *result = __tlab_alloc(tlab, newsize, 8); memset(result, _0, newsize); return result; } else { const int bound = MIN(size, newsize) - 1; assert(bound >= 0); uint8_t *result = __tlab_alloc(tlab, newsize, 8); memset(result, *(uint8_t *)input, newsize - bound); memcpy(result + newsize - bound, input + size - bound, bound); return result; } } static void ieee_resize_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = args[3].integer ^ (args[3].integer >> 63); const int newsize = args[4].integer; const uint8_t *input = args[1].pointer; args[0].pointer = __resize_unsigned(tlab, input, size, newsize); args[1].integer = newsize - 1; args[2].integer = ~newsize; } static void ieee_resize_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = args[3].integer ^ (args[3].integer >> 63); const int newsize = args[4].integer; const uint8_t *input = args[1].pointer; args[0].pointer = __resize_signed(tlab, input, size, newsize); args[1].integer = newsize - 1; args[2].integer = ~newsize; } __attribute__((always_inline)) static inline uint8_t __pack_low_bits(const void* vec) { uint64_t bits = unaligned_load(vec, uint64_t); bits &= UINT64_C(0x0101010101010101); bits *= UINT64_C(0x8040201008040201); return bits >> 56; } __attribute__((always_inline)) static inline void __spread_bits(void* vec, uint8_t packed) { const uint64_t spread1 = packed * UINT64_C(0x0000040010004001); const uint64_t mask1 = spread1 & UINT64_C(0x0001000100010001); const uint64_t spread2 = packed * UINT64_C(0x0002000800200080); const uint64_t mask2 = spread2 & UINT64_C(0x0100010001000100); const uint64_t bits = mask1 | mask2 | UINT64_C(0x0202020202020202); const uint64_t swap = __builtin_bswap64(bits); memcpy(vec, &swap, sizeof(swap)); } __attribute__((always_inline)) static inline void __ieee_packed_add(const uint8_t *left, const uint8_t *right, int size, int carry, uint8_t *result) { int pos = size - 8; for (; pos > 0; pos -= 8) { const unsigned lbyte = __pack_low_bits(left + pos); const unsigned rbyte = __pack_low_bits(right + pos); const unsigned sum = lbyte + rbyte + carry; __spread_bits(result + pos, sum); carry = !!(sum & 0x100); } for (; pos + 8 > 0; pos--) { const unsigned lbit = left[pos + 7] & 1; const unsigned rbit = right[pos + 7] & 1; const unsigned sum = lbit + rbit + carry; result[pos + 7] = (sum & 1) | 0x02; carry = !!(sum & 2); } } __attribute__((always_inline)) static inline uint8_t *__to_unsigned(jit_func_t *func, jit_anchor_t *anchor, tlab_t *tlab, int64_t arg, int size) { const int roundup = (size + 7) & ~7; uint8_t *result = __tlab_alloc(tlab, roundup, 8); int last = 0; for (int pos = roundup - 8; pos >= 0; pos -= 8, arg >>= 8) __spread_bits(result + pos, (last = (arg & 0xff))); const uint8_t spill_mask = ~((1 << (8 - roundup + size)) - 1); if (unlikely(arg != 0 || (last & spill_mask))) ieee_warn(func, anchor, "NUMERIC_STD.TO_UNSIGNED: vector truncated"); return result + roundup - size; } static void ieee_plus_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = MAX(lsize, rsize); if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { left = __resize_unsigned(tlab, left, lsize, size); right = __resize_unsigned(tlab, right, rsize, size); left = __to_01(tlab, left, size, _X); right = __to_01(tlab, right, size, _X); if (left[0] == _X) args[0].pointer = left; else if (right[0] == _X) args[0].pointer = right; else { uint8_t *result = __tlab_alloc(tlab, size, 8); __ieee_packed_add(left, right, size, 0, result); args[0].pointer = result; } args[1].integer = size - 1; args[2].integer = ~size; } } __attribute__((noinline)) static void ieee_plus_unsigned_natural(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int size = ffi_array_length(args[3].integer); uint8_t *left = args[1].pointer; const uint64_t right = args[4].integer; // Must be unconditional to generate warning on truncation uint8_t *result = __to_unsigned(func, anchor, tlab, right, size); if (size == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { left = __to_01(tlab, left, size, _X); if (left[0] == _X || right == 0) args[0].pointer = left; else { __ieee_packed_add(left, result, size, 0, result); args[0].pointer = result; } args[1].integer = size - 1; args[2].integer = ~size; } } __attribute__((always_inline)) static inline void __commute_vector_scalar(jit_scalar_t *args) { jit_scalar_t tmp = args[1]; args[1] = args[2]; args[2] = args[3]; args[3] = args[4]; args[4] = tmp; } static void ieee_plus_natural_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { __commute_vector_scalar(args); ieee_plus_unsigned_natural(func, anchor, args, tlab); } static void ieee_plus_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = MAX(lsize, rsize); if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { left = __resize_signed(tlab, left, lsize, size); right = __resize_signed(tlab, right, rsize, size); left = __to_01(tlab, left, size, _X); right = __to_01(tlab, right, size, _X); if (left[0] == _X) args[0].pointer = left; else if (right[0] == _X) args[0].pointer = right; else { uint8_t *result = __tlab_alloc(tlab, size, 8); __ieee_packed_add(left, right, size, 0, result); args[0].pointer = result; } args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_minus_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = MAX(lsize, rsize); if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { left = __resize_unsigned(tlab, left, lsize, size); right = __resize_unsigned(tlab, right, rsize, size); left = __to_01(tlab, left, size, _X); right = __to_01(tlab, right, size, _X); if (left[0] == _X) args[0].pointer = left; else if (right[0] == _X) args[0].pointer = right; else { uint8_t *result = __tlab_alloc(tlab, size, 8); __invert_bits(right, size, result); __ieee_packed_add(left, result, size, 1, result); args[0].pointer = result; } args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_minus_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = MAX(lsize, rsize); if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { left = __resize_signed(tlab, left, lsize, size); right = __resize_signed(tlab, right, rsize, size); left = __to_01(tlab, left, size, _X); right = __to_01(tlab, right, size, _X); if (left[0] == _X) args[0].pointer = left; else if (right[0] == _X) args[0].pointer = right; else { uint8_t *result = __tlab_alloc(tlab, size, 8); __invert_bits(right, size, result); __ieee_packed_add(left, result, size, 1, result); args[0].pointer = result; } args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_mul_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = lsize + rsize; if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { uint8_t *result = __tlab_alloc(tlab, size, 8); const uint32_t mark = __tlab_mark(tlab); left = __to_01(tlab, left, lsize, _X); right = __to_01(tlab, right, rsize, _X); if (left[0] == _X || right[0] == _X) memset(result, _X, size); else { memset(result, _0, size); uint8_t *adval = __resize_unsigned(tlab, right, rsize, size); for (int i = lsize - 1, shift = 0; i >= 0; i--, shift++) { if (left[i] == _1) { // Delay left-shift until value needed memmove(adval, adval + shift, size - shift); memset(adval + size - shift, _0, shift); shift = 0; __ieee_packed_add(result, adval, size, 0, result); } } } __tlab_restore(tlab, mark); args[0].pointer = result; args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_mul_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; const int size = lsize + rsize; if (lsize == 0 || rsize == 0) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { uint8_t *result = __tlab_alloc(tlab, size, 8); const uint32_t mark = __tlab_mark(tlab); left = __to_01(tlab, left, lsize, _X); right = __to_01(tlab, right, rsize, _X); if (left[0] == _X || right[0] == _X) memset(result, _X, size); else { memset(result, _0, size); uint8_t *adval = __resize_signed(tlab, right, rsize, size); for (int i = lsize - 1, shift = 0; i >= 0; i--, shift++) { if (left[i] == _1) { // Delay left-shift until value needed memmove(adval, adval + shift, size - shift); memset(adval + size - shift, _0, shift); shift = 0; if (i == 0) __invert_bits(adval, size, adval); __ieee_packed_add(result, adval, size, i == 0, result); } } } __tlab_restore(tlab, mark); args[0].pointer = result; args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_divmod(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t *num = args[2].pointer; const int num_size = ffi_array_length(args[4].integer); uint8_t *denom = args[5].pointer; const int denom_size = ffi_array_length(args[7].integer); uint8_t *xquot = args[8].pointer; uint8_t *xremain = args[11].pointer; assert(ffi_array_length(args[10].integer) == num_size); assert(ffi_array_length(args[13].integer) == denom_size); const uint32_t mark = __tlab_mark(tlab); uint8_t *temp = __tlab_alloc(tlab, num_size + 1, 16); temp[0] = _0; memcpy(temp + 1, num, num_size); const int quot_size = MAX(num_size, denom_size); uint8_t *quot = __tlab_alloc(tlab, quot_size, 16); memset(quot, _0, quot_size); int topbit = -1; for (int j = denom_size - 1; j >= 0; j--) { if (denom[denom_size - 1 - j] == _1) { topbit = j; break; } } if (unlikely(topbit < 0)) __ieee_msg(func, anchor, SEVERITY_ERROR, "NUMERIC_STD.DIVMOD: DIV, MOD, or REM by zero"); else { uint8_t *denom2 = __tlab_alloc(tlab, topbit + 2, 16); denom2[0] = _0; memcpy(denom2 + 1, denom + denom_size - 1 - topbit , topbit + 1); uint8_t *denom3 = __tlab_alloc(tlab, topbit + 2, 16); __invert_bits(denom2, topbit + 2, denom3); for (int j = num_size - (topbit + 1); j >= 0; j--) { uint8_t *slice = temp + num_size - (topbit + j + 1); int pos = 0; for (; pos < topbit + 1 && slice[pos] == denom2[pos]; pos++); if (slice[pos] >= denom2[pos]) { __ieee_packed_add(slice, denom3, topbit + 2, 1, slice); quot[quot_size - 1 - j] = _1; } } } memcpy(xquot, quot + quot_size - num_size, num_size); if (denom_size > num_size + 1) { memset(xremain, _0, denom_size - (num_size + 1)); memcpy(xremain + denom_size - (num_size + 1), temp, num_size + 1); } else memcpy(xremain, temp + num_size + 1 - denom_size, denom_size); __tlab_restore(tlab, mark); } static bool ieee_unsigned_cmp(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab, uint8_t *lbyte, uint8_t *rbyte, const char *op) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; args[0].integer = 0; // Return FALSE by default if (lsize < 1 || rsize < 1) { ieee_warn(func, anchor, "NUMERIC_STD.\"%s\": null argument detected, " "returning FALSE", op); return false; } const uint32_t mark = __tlab_mark(tlab); left = __to_01(tlab, left, lsize, _X); right = __to_01(tlab, right, rsize, _X); if (left[0] == _X || right[0] == _X) { ieee_warn(func, anchor, "NUMERIC_STD.\"%s\": metavalue detected, " "returning FALSE", op); __tlab_restore(tlab, mark); return false; } const int size = MAX(lsize, rsize); left = __resize_unsigned(tlab, left, lsize, size); right = __resize_unsigned(tlab, right, rsize, size); int pos = 0; for (; pos < size - 1 && left[pos] == right[pos]; pos++); *lbyte = left[pos]; *rbyte = right[pos]; __tlab_restore(tlab, mark); return true; } static void ieee_less_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t left, right; if (!ieee_unsigned_cmp(func, anchor, args, tlab, &left, &right, "<")) return; args[0].integer = left < right; } static void ieee_greater_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t left, right; if (!ieee_unsigned_cmp(func, anchor, args, tlab, &left, &right, ">")) return; args[0].integer = left > right; } static void ieee_geq_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t left, right; if (!ieee_unsigned_cmp(func, anchor, args, tlab, &left, &right, ">=")) return; args[0].integer = left >= right; } static void ieee_leq_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t left, right; if (!ieee_unsigned_cmp(func, anchor, args, tlab, &left, &right, "<=")) return; args[0].integer = left <= right; } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void ieee_and_vector_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"and\": arguments of overloaded 'and' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); __m128i left_tbl = _mm_load_si128((const __m128i *)compress_left); __m128i right_tbl = _mm_load_si128((const __m128i *)compress_right); __m128i and_tbl = _mm_load_si128((const __m128i *)small_and_table); for (int pos = 0; pos < lsize; pos += 16) { __m128i left1 = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(right + pos)); __m128i left2 = _mm_shuffle_epi8(left_tbl, left1); __m128i right2 = _mm_shuffle_epi8(right_tbl, right1); __m128i comb = _mm_or_si128(left2, right2); __m128i and = _mm_shuffle_epi8(and_tbl, comb); _mm_store_si128((__m128i *)(result + pos), and); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif #ifdef HAVE_NEON static void ieee_and_vector_neon(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"and\": arguments of overloaded 'and' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); uint8x16_t left_tbl = vld1q_u8(compress_left); uint8x16_t right_tbl = vld1q_u8(compress_right); uint8x16_t and_tbl = vld1q_u8((const uint8_t *)small_and_table); for (int pos = 0; pos < lsize; pos += 16) { uint8x16_t left1 = vld1q_u8(left + pos); uint8x16_t right1 = vld1q_u8(right + pos); uint8x16_t left2 = vqtbl1q_u8(left_tbl, left1); uint8x16_t right2 = vqtbl1q_u8(right_tbl, right1); uint8x16_t comb = vorrq_u8(left2, right2); uint8x16_t and = vqtbl1q_u8(and_tbl, comb); vst1q_u8(result + pos, and); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif static void ieee_and_vector(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"and\": arguments of overloaded 'and' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, lsize, 8); for (int pos = 0; pos < lsize; pos++) result[pos] = and_table[left[pos]][right[pos]]; args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void ieee_or_vector_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"or\": arguments of overloaded 'or' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); __m128i left_tbl = _mm_load_si128((const __m128i *)compress_left); __m128i right_tbl = _mm_load_si128((const __m128i *)compress_right); __m128i or_tbl = _mm_load_si128((const __m128i *)small_or_table); for (int pos = 0; pos < lsize; pos += 16) { __m128i left1 = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(right + pos)); __m128i left2 = _mm_shuffle_epi8(left_tbl, left1); __m128i right2 = _mm_shuffle_epi8(right_tbl, right1); __m128i comb = _mm_or_si128(left2, right2); __m128i orr = _mm_shuffle_epi8(or_tbl, comb); _mm_store_si128((__m128i *)(result + pos), orr); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif #ifdef HAVE_NEON static void ieee_or_vector_neon(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"or\": arguments of overloaded 'or' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); uint8x16_t left_tbl = vld1q_u8(compress_left); uint8x16_t right_tbl = vld1q_u8(compress_right); uint8x16_t or_tbl = vld1q_u8((const uint8_t *)small_or_table); for (int pos = 0; pos < lsize; pos += 16) { uint8x16_t left1 = vld1q_u8(left + pos); uint8x16_t right1 = vld1q_u8(right + pos); uint8x16_t left2 = vqtbl1q_u8(left_tbl, left1); uint8x16_t right2 = vqtbl1q_u8(right_tbl, right1); uint8x16_t comb = vorrq_u8(left2, right2); uint8x16_t orr = vqtbl1q_u8(or_tbl, comb); vst1q_u8(result + pos, orr); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif static void ieee_or_vector(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"or\": arguments of overloaded 'or' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); for (int pos = 0; pos < lsize; pos++) result[pos] = or_table[left[pos]][right[pos]]; args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void ieee_xor_vector_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"xor\": arguments of overloaded 'xor' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); __m128i left_tbl = _mm_load_si128((const __m128i *)compress_left); __m128i right_tbl = _mm_load_si128((const __m128i *)compress_right); __m128i xor_tbl = _mm_load_si128((const __m128i *)small_xor_table); for (int pos = 0; pos < lsize; pos += 16) { __m128i left1 = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(right + pos)); __m128i left2 = _mm_shuffle_epi8(left_tbl, left1); __m128i right2 = _mm_shuffle_epi8(right_tbl, right1); __m128i comb = _mm_or_si128(left2, right2); __m128i xor = _mm_shuffle_epi8(xor_tbl, comb); _mm_store_si128((__m128i *)(result + pos), xor); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif #ifdef HAVE_NEON static void ieee_xor_vector_neon(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"xor\": arguments of overloaded 'xor' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); uint8x16_t left_tbl = vld1q_u8(compress_left); uint8x16_t right_tbl = vld1q_u8(compress_right); uint8x16_t xor_tbl = vld1q_u8((const uint8_t *)small_xor_table); for (int pos = 0; pos < lsize; pos += 16) { uint8x16_t left1 = vld1q_u8(left + pos); uint8x16_t right1 = vld1q_u8(right + pos); uint8x16_t left2 = vqtbl1q_u8(left_tbl, left1); uint8x16_t right2 = vqtbl1q_u8(right_tbl, right1); uint8x16_t comb = vorrq_u8(left2, right2); uint8x16_t xor = vqtbl1q_u8(xor_tbl, comb); vst1q_u8(result + pos, xor); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #endif static void std_xor_vector(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; if (unlikely(lsize != rsize)) __ieee_msg(func, anchor, SEVERITY_FAILURE, "STD_LOGIC_1164.\"xor\": arguments of overloaded 'xor' " "operator are not of the same length"); else { uint8_t *result = __tlab_alloc(tlab, lsize, 8); for (int pos = 0; pos < lsize; pos++) result[pos] = xor_table[left[pos]][right[pos]]; args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void ieee_not_vector_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); uint8_t *left = args[1].pointer; uint8_t *result = __tlab_alloc(tlab, ALIGN_UP(lsize, 16), 16); __m128i not_tbl = _mm_load_si128((const __m128i *)not_table); for (int pos = 0; pos < lsize; pos += 16) { __m128i input = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i output = _mm_shuffle_epi8(not_tbl, input); _mm_store_si128((__m128i *)(result + pos), output); } args[0].pointer = result; args[1].integer = 1; args[2].integer = lsize; } #endif static void ieee_to_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int64_t size = args[2].integer; uint64_t arg = args[1].integer; if (size < 1) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { args[0].pointer = __to_unsigned(func, anchor, tlab, arg, size); args[1].integer = size - 1; args[2].integer = ~size; } } static void ieee_to_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int64_t size = args[2].integer; int64_t arg = args[1].integer; if (size < 1) { args[0].pointer = NULL; args[1].integer = 0; args[2].integer = -1; } else { const int roundup = (size + 7) & ~7; uint8_t *result = __tlab_alloc(tlab, roundup, 8), last = 0; for (int pos = roundup - 8; pos >= 0; pos -= 8, arg >>= 8) __spread_bits(result + pos, (last = (arg & 0xff))); const uint8_t spill_mask = ~((1 << (8 - roundup + size)) - 1); if (unlikely((arg != 0 && arg != -1) || (arg == 0 && result[roundup - size] == _1) || (arg == -1 && result[roundup - size] == _0) || (arg == 0 && (last & spill_mask) != 0) || (arg == -1 && (last & spill_mask) != spill_mask))) ieee_warn(func, anchor, "NUMERIC_STD.TO_SIGNED: vector truncated"); args[0].pointer = result + roundup - size; args[1].integer = size - 1; args[2].integer = ~size; } } __attribute__((always_inline)) static inline bool __is_x(uint8_t arg) { return arg == _U || arg == _X || arg == _Z || arg == _W || arg == _DC; } __attribute__((always_inline)) static inline void __make_binary(jit_func_t *func, jit_anchor_t *anchor, tlab_t *tlab, const uint8_t *input, uint8_t *result, int size) { static const uint8_t tbl_BINARY[] = { _X, _X, _0, _1, _X, _X, _0, _1, _X }; for (int i = 0; i < size; i++) { if (unlikely(__is_x(input[i]))) { ieee_warn(func, anchor, "There is an 'U'|'X'|'W'|'Z'|'-' in an " "arithmetic operand, the result will be 'X'(es)."); memset(result, _X, size); break; } result[i] = tbl_BINARY[input[i]]; } } __attribute__((cold, noreturn, noinline)) static void __synopsys_failure(jit_func_t *func, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab) { // Synopsys subprograms handle edge cases poorly: punt to the // interpreter to generate the error message func->entry = jit_interp; jit_interp(func, caller, args, tlab); fatal_trace("should not return here"); } __attribute__((always_inline)) static inline const uint8_t *__conv_unsigned(jit_func_t *func, jit_anchor_t *anchor, tlab_t *tlab, const void *input, int oldsize, int size) { assert(size > 0); if (oldsize == size && __all_01(input, oldsize)) return input; const int maxsize = MAX(oldsize, size); const int pad = size - oldsize; uint8_t *result = __tlab_alloc(tlab, maxsize, 8); __make_binary(func, anchor, tlab, input, result + pad, oldsize); if (unlikely(result[pad] == _X)) memset(result, _X, size); else memset(result, _0, pad); return result; } __attribute__((always_inline)) static inline const uint8_t *__conv_signed(jit_func_t *func, jit_anchor_t *anchor, tlab_t *tlab, const void *input, int oldsize, int size) { assert(size > 0); if (oldsize == size && __all_01(input, oldsize)) return input; const int maxsize = MAX(oldsize, size); const int pad = size - oldsize; uint8_t *result = __tlab_alloc(tlab, maxsize, 8); __make_binary(func, anchor, tlab, input, result + pad, oldsize); if (unlikely(result[pad] == _X)) memset(result, _X, size); else memset(result, *(uint8_t *)input, pad); return result; } static void synopsys_plus_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; const int length = MAX(lsize, rsize); uint8_t *result = __tlab_alloc(tlab, length, 8); if (unlikely(length == 0)) __synopsys_failure(func, anchor, args, tlab); left = __conv_unsigned(func, anchor, tlab, left, lsize, length); right = __conv_unsigned(func, anchor, tlab, right, rsize, length); if (unlikely(left[0] == _X || right[0] == _X)) memset(result, _X, length); else __ieee_packed_add(left, right, length, 0, result); args[0].pointer = result; args[1].integer = length - 1; args[2].integer = ~length; } static void synopsys_plus_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; const int length = MAX(lsize, rsize); uint8_t *result = __tlab_alloc(tlab, length, 8); if (unlikely(length == 0)) __synopsys_failure(func, anchor, args, tlab); left = __conv_signed(func, anchor, tlab, left, lsize, length); right = __conv_signed(func, anchor, tlab, right, rsize, length); if (unlikely(left[0] == _X || right[0] == _X)) memset(result, _X, length); else __ieee_packed_add(left, right, length, 0, result); args[0].pointer = result; args[1].integer = length - 1; args[2].integer = ~length; } static void synopsys_plus_unsigned_logic(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t right[] = { args[4].integer }; args[4].pointer = right; args[5].integer = 0; args[6].integer = 1; synopsys_plus_unsigned(func, anchor, args, tlab); } static void synopsys_plus_logic_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { uint8_t left[] = { args[1].integer }; args[6].integer = args[4].integer; args[5].integer = args[3].integer; args[4].pointer = args[2].pointer; args[1].pointer = left; args[2].integer = 0; args[3].integer = 1; synopsys_plus_unsigned(func, anchor, args, tlab); } static void synopsys_minus_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; const int length = MAX(lsize, rsize); uint8_t *result = __tlab_alloc(tlab, length, 8); if (unlikely(length == 0)) __synopsys_failure(func, anchor, args, tlab); left = __conv_unsigned(func, anchor, tlab, left, lsize, length); right = __conv_unsigned(func, anchor, tlab, right, rsize, length); if (unlikely(left[0] == _X || right[0] == _X)) memset(result, _X, length); else { __invert_bits(right, length, result); __ieee_packed_add(left, result, length, 1, result); } args[0].pointer = result; args[1].integer = length - 1; args[2].integer = ~length; } static void synopsys_mul_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; if (unlikely(lsize == 0 || rsize == 0)) __synopsys_failure(func, anchor, args, tlab); left = __conv_unsigned(func, anchor, tlab, left, lsize, lsize); right = __conv_unsigned(func, anchor, tlab, right, rsize, rsize); const int length = lsize + rsize; uint8_t *pa = __tlab_alloc(tlab, length, 8); if (unlikely(left[0] == _X || right[0] == _X)) memset(pa, _X, length); else { const uint32_t mark = __tlab_mark(tlab); uint8_t *ba = __tlab_alloc(tlab, length, 8); memset(pa, _0, length); memset(ba, _0, length - rsize); memcpy(ba + length - rsize, right, rsize); for (int i = lsize - 1, shift = 0; i >= 0; i--, shift++) { if (left[i] == _1) { // Delay left-shift until value needed memmove(ba, ba + shift, length - shift); memset(ba + length - shift, _0, shift); shift = 0; __ieee_packed_add(pa, ba, length, 0, pa); } } __tlab_restore(tlab, mark); } args[0].pointer = pa; args[1].integer = length - 1; args[2].integer = ~length; } static void synopsys_mul_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; if (unlikely(lsize == 0 || rsize == 0)) __synopsys_failure(func, anchor, args, tlab); left = __conv_signed(func, anchor, tlab, left, lsize, lsize); right = __conv_signed(func, anchor, tlab, right, rsize, rsize); const int length = lsize + rsize; uint8_t *pa = __tlab_alloc(tlab, length, 8); if (unlikely(left[0] == _X || right[0] == _X)) memset(pa, _X, length); else { const uint32_t mark = __tlab_mark(tlab); uint8_t *ba = __tlab_alloc(tlab, length, 8); memset(pa, _0, length); memset(ba, right[0], length - rsize); memcpy(ba + length - rsize, right, rsize); for (int i = lsize - 1, shift = 0; i >= 0; i--, shift++) { if (left[i] == _1) { // Delay left-shift until value needed memmove(ba, ba + shift, length - shift); memset(ba + length - shift, _0, shift); shift = 0; if (i == 0) __invert_bits(ba, length, ba); __ieee_packed_add(pa, ba, length, i == 0, pa); } } __tlab_restore(tlab, mark); } args[0].pointer = pa; args[1].integer = length - 1; args[2].integer = ~length; } static void synopsys_eql_unsigned(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; const int length = MAX(lsize, rsize); if (unlikely(length == 0)) __synopsys_failure(func, anchor, args, tlab); const uint32_t mark = __tlab_mark(tlab); left = __conv_unsigned(func, anchor, tlab, left, lsize, length); right = __conv_unsigned(func, anchor, tlab, right, rsize, length); args[0].integer = (memcmp(left, right, length) == 0); __tlab_restore(tlab, mark); } static void synopsys_eql_signed(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); const uint8_t *left = args[1].pointer; const uint8_t *right = args[4].pointer; const int length = MAX(lsize, rsize); if (unlikely(length == 0)) __synopsys_failure(func, anchor, args, tlab); const uint32_t mark = __tlab_mark(tlab); left = __conv_signed(func, anchor, tlab, left, lsize, length); right = __conv_signed(func, anchor, tlab, right, rsize, length); args[0].integer = (memcmp(left, right, length) == 0); __tlab_restore(tlab, mark); } #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) static void byte_vector_equal_sse41(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; args[0].integer = 0; if (lsize != rsize) return; __m128i allmask = _mm_set1_epi8(0xff); int pos = 0; for (; pos + 15 < lsize; pos += 16) { __m128i left1 = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(right + pos)); __m128i xor = _mm_xor_si128(left1, right1); if (!_mm_test_all_zeros(xor, allmask)) return; } if (pos < lsize) { __m128i iota = _mm_load_si128((const __m128i *)lane_iota); __m128i mask = _mm_cmplt_epi8(iota, _mm_set1_epi8(lsize - pos)); __m128i left1 = _mm_loadu_si128((const __m128i *)(left + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(right + pos)); __m128i xor = _mm_xor_si128(left1, right1); if (!_mm_test_all_zeros(xor, mask)) return; } args[0].integer = 1; } #endif #ifdef HAVE_NEON static void byte_vector_equal_neon(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; args[0].integer = 0; if (lsize != rsize) return; int pos = 0; for (; pos + 15 < lsize; pos += 16) { uint8x16_t left1 = vld1q_u8(left + pos); uint8x16_t right1 = vld1q_u8(right + pos); uint8x16_t xor = veorq_u8(left1, right1); uint64x2_t cast = vreinterpretq_u64_u8(xor); if (vgetq_lane_u64(cast, 0) || vgetq_lane_u64(cast, 1)) return; } if (pos < lsize) { uint8x16_t iota = vld1q_u8(lane_iota); uint8x16_t mask = vcltq_u8(iota, vdupq_n_u8(lsize - pos)); uint8x16_t left1 = vld1q_u8(left + pos); uint8x16_t right1 = vld1q_u8(right + pos); uint8x16_t xor = veorq_u8(left1, right1); uint8x16_t and = vandq_u8(xor, mask); uint64x2_t cast = vreinterpretq_u64_u8(and); if (vgetq_lane_u64(cast, 0) || vgetq_lane_u64(cast, 1)) return; } args[0].integer = 1; } #endif static void byte_vector_equal(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { const int lsize = ffi_array_length(args[3].integer); const int rsize = ffi_array_length(args[6].integer); uint8_t *left = args[1].pointer; uint8_t *right = args[4].pointer; args[0].integer = (lsize == rsize) && (memcmp(left, right, lsize) == 0); } static void ieee_math_sin(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = sin(args[1].real); } static void ieee_math_cos(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = cos(args[1].real); } static void ieee_math_log(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = log(args[1].real); } static void ieee_math_log2(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = log2(args[1].real); } static void ieee_math_log10(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = log10(args[1].real); } static void ieee_math_round(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = round(args[1].real); } static void ieee_math_trunc(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = trunc(args[1].real); } static void ieee_math_floor(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = floor(args[1].real); } static void ieee_math_pow_real(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = pow(args[1].real, args[2].real); } static void ieee_math_pow_integer(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = pow((double)args[1].integer, args[2].real); } static void ieee_math_exp(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { args[0].real = exp(args[1].real); } static void std_textio_consume(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { ffi_uarray_t **line = args[2].pointer; const int nchars = args[3].integer; assert(*line != NULL); const int length = ffi_array_length((*line)->dims[0].length); assert(nchars <= length); (*line)->ptr += nchars; (*line)->dims[0].left = 1; (*line)->dims[0].length = length - nchars; args[0].pointer = NULL; } static void std_textio_shrink(jit_func_t *func, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab) { ffi_uarray_t **line = args[2].pointer; const int nchars = args[3].integer; assert(*line != NULL); (*line)->dims[0].left = 1; (*line)->dims[0].length = nchars; args[0].pointer = NULL; } #define UU "36IEEE.NUMERIC_STD.UNRESOLVED_UNSIGNED" #define U "25IEEE.NUMERIC_STD.UNSIGNED" #define US "34IEEE.NUMERIC_STD.UNRESOLVED_SIGNED" #define S "23IEEE.NUMERIC_STD.SIGNED" #define NS "IEEE.NUMERIC_STD." #define SL "IEEE.STD_LOGIC_1164." #define MR "IEEE.MATH_REAL." #define ST "STD.STANDARD." #define TI "STD.TEXTIO." #define LN "15STD.TEXTIO.LINE" #define SA "IEEE.STD_LOGIC_ARITH." #define SU "IEEE.STD_LOGIC_UNSIGNED." #define SS "IEEE.STD_LOGIC_SIGNED." #define AU "29IEEE.STD_LOGIC_ARITH.UNSIGNED" #define AS "27IEEE.STD_LOGIC_ARITH.SIGNED" static jit_intrinsic_t intrinsic_list[] = { { NS "\"+\"(" U U ")" U, ieee_plus_unsigned }, { NS "\"+\"(" UU UU ")" UU, ieee_plus_unsigned }, { NS "\"+\"(" U "N)" U, ieee_plus_unsigned_natural }, { NS "\"+\"(" UU "N)" UU, ieee_plus_unsigned_natural }, { NS "\"+\"(N" U ")" U, ieee_plus_natural_unsigned }, { NS "\"+\"(N" UU ")" UU, ieee_plus_natural_unsigned }, { NS "\"+\"(" S S ")" S, ieee_plus_signed }, { NS "\"+\"(" US US ")" US, ieee_plus_signed }, { NS "\"-\"(" U U ")" U, ieee_minus_unsigned }, { NS "\"-\"(" UU UU ")" UU, ieee_minus_unsigned }, { NS "\"-\"(" S S ")" S, ieee_minus_signed }, { NS "\"-\"(" US US ")" US, ieee_minus_signed }, { NS "\"*\"(" U U ")" U, ieee_mul_unsigned }, { NS "\"*\"(" UU UU ")" UU, ieee_mul_unsigned }, { NS "\"*\"(" S S ")" S, ieee_mul_signed }, { NS "\"*\"(" US US ")" US, ieee_mul_signed }, { NS "DIVMOD(" UU UU UU UU ")", ieee_divmod }, { NS "DIVMOD(" U U U U ")", ieee_divmod }, { NS "\"<\"(" U U ")B", ieee_less_unsigned }, { NS "\"<\"(" UU UU ")B" , ieee_less_unsigned }, { NS "\">\"(" U U ")B", ieee_greater_unsigned }, { NS "\">\"(" UU UU ")B" , ieee_greater_unsigned }, { NS "\">=\"(" U U ")B", ieee_geq_unsigned }, { NS "\">=\"(" UU UU ")B" , ieee_geq_unsigned }, { NS "\"<=\"(" U U ")B", ieee_leq_unsigned }, { NS "\"<=\"(" UU UU ")B" , ieee_leq_unsigned }, #ifdef HAVE_SSE41 { SL "TO_X01(V)V", std_to_x01_sse41, CPU_SSE41 }, { SL "TO_X01(Y)Y", std_to_x01_sse41, CPU_SSE41 }, #endif { SL "TO_X01(V)V", std_to_x01 }, { SL "TO_X01(Y)Y", std_to_x01 }, { NS "TO_01(" U "L)" U, ieee_to_01 }, { NS "TO_01(" UU "U)" UU, ieee_to_01 }, { NS "TO_01(" S "L)" U, ieee_to_01 }, { NS "TO_01(" US "U)" UU, ieee_to_01 }, { NS "RESIZE(" U "N)" U, ieee_resize_unsigned }, { NS "RESIZE(" UU "N)" UU, ieee_resize_unsigned }, { NS "RESIZE(" S "N)" S, ieee_resize_signed }, { NS "RESIZE(" US "N)" US, ieee_resize_signed }, #ifdef HAVE_SSE41 { SL "\"and\"(VV)V", ieee_and_vector_sse41, CPU_SSE41 }, { SL "\"and\"(YY)Y", ieee_and_vector_sse41, CPU_SSE41 }, #endif #ifdef HAVE_NEON { SL "\"and\"(VV)V", ieee_and_vector_neon, CPU_NEON }, { SL "\"and\"(YY)Y", ieee_and_vector_neon, CPU_NEON }, #endif { SL "\"and\"(VV)V", ieee_and_vector }, { SL "\"and\"(YY)Y", ieee_and_vector }, #ifdef HAVE_SSE41 { SL "\"or\"(VV)V", ieee_or_vector_sse41, CPU_SSE41 }, { SL "\"or\"(YY)Y", ieee_or_vector_sse41, CPU_SSE41 }, #endif #ifdef HAVE_NEON { SL "\"or\"(VV)V", ieee_or_vector_neon, CPU_NEON }, { SL "\"or\"(YY)Y", ieee_or_vector_neon, CPU_NEON }, #endif { SL "\"or\"(VV)V", ieee_or_vector }, { SL "\"or\"(YY)Y", ieee_or_vector }, #ifdef HAVE_SSE41 { SL "\"xor\"(VV)V", ieee_xor_vector_sse41, CPU_SSE41 }, { SL "\"xor\"(YY)Y", ieee_xor_vector_sse41, CPU_SSE41 }, #endif #ifdef HAVE_NEON { SL "\"xor\"(VV)V", ieee_xor_vector_neon, CPU_NEON }, { SL "\"xor\"(YY)Y", ieee_xor_vector_neon, CPU_NEON }, #endif { SL "\"xor\"(VV)V", std_xor_vector }, { SL "\"xor\"(YY)Y", std_xor_vector }, #ifdef HAVE_SSE41 { SL "\"not\"(V)V", ieee_not_vector_sse41, CPU_SSE41 }, { SL "\"not\"(Y)Y", ieee_not_vector_sse41, CPU_SSE41 }, #endif { NS "TO_UNSIGNED(NN)" U, ieee_to_unsigned }, { NS "TO_UNSIGNED(NN)" UU, ieee_to_unsigned }, { NS "TO_SIGNED(IN)" S, ieee_to_signed }, { NS "TO_SIGNED(IN)" US, ieee_to_signed }, #ifdef HAVE_SSE41 { SL "\"=\"(VV)B$predef", byte_vector_equal_sse41, CPU_SSE41 }, { SL "\"=\"(YY)B$predef", byte_vector_equal_sse41, CPU_SSE41 }, { ST "\"=\"(QQ)B$predef", byte_vector_equal_sse41, CPU_SSE41 }, { ST "\"=\"(SS)B$predef", byte_vector_equal_sse41, CPU_SSE41 }, #endif #ifdef HAVE_NEON { SL "\"=\"(VV)B$predef", byte_vector_equal_neon, CPU_NEON }, { SL "\"=\"(YY)B$predef", byte_vector_equal_neon, CPU_NEON }, { ST "\"=\"(QQ)B$predef", byte_vector_equal_neon, CPU_NEON }, { ST "\"=\"(SS)B$predef", byte_vector_equal_neon, CPU_NEON }, #endif { SL "\"=\"(VV)B$predef", byte_vector_equal }, { SL "\"=\"(YY)B$predef", byte_vector_equal }, { ST "\"=\"(QQ)B$predef", byte_vector_equal }, { ST "\"=\"(SS)B$predef", byte_vector_equal }, { MR "SIN(R)R", ieee_math_sin }, { MR "COS(R)R", ieee_math_cos }, { MR "LOG(R)R", ieee_math_log }, { MR "LOG2(R)R", ieee_math_log2 }, { MR "LOG10(R)R", ieee_math_log10 }, { MR "ROUND(R)R", ieee_math_round }, { MR "TRUNC(R)R", ieee_math_trunc }, { MR "FLOOR(R)R", ieee_math_floor }, { MR "\"**\"(RR)R", ieee_math_pow_real }, { MR "\"**\"(IR)R", ieee_math_pow_integer }, { MR "EXP(R)R", ieee_math_exp }, { TI "CONSUME(" LN "N)", std_textio_consume }, { TI "SHRINK(" LN "N)", std_textio_shrink }, { SA "\"+\"(" AU AU ")" AU, synopsys_plus_unsigned }, { SA "\"+\"(" AU AU ")V", synopsys_plus_unsigned }, { SU "\"+\"(VV)V", synopsys_plus_unsigned }, { SU "\"+\"(YY)Y", synopsys_plus_unsigned }, { SA "\"+\"(" AS AS ")" AS, synopsys_plus_signed }, { SA "\"+\"(" AS AS ")V", synopsys_plus_signed }, { SS "\"+\"(VV)V", synopsys_plus_signed }, { SS "\"+\"(YY)Y", synopsys_plus_signed }, { SA "\"+\"(" AU "U)" AU, synopsys_plus_unsigned_logic }, { SA "\"+\"(" AU "U)V", synopsys_plus_unsigned_logic }, { SU "\"+\"(VL)V", synopsys_plus_unsigned_logic }, { SU "\"+\"(YL)Y", synopsys_plus_unsigned_logic }, { SA "\"+\"(U" AU ")" AU, synopsys_plus_logic_unsigned }, { SA "\"+\"(U" AU ")V", synopsys_plus_logic_unsigned }, { SU "\"+\"(LV)V", synopsys_plus_logic_unsigned }, { SU "\"+\"(LY)Y", synopsys_plus_logic_unsigned }, { SA "\"-\"(" AU AU ")" AU, synopsys_minus_unsigned }, { SA "\"-\"(" AU AU ")V", synopsys_minus_unsigned }, { SU "\"-\"(VV)V", synopsys_minus_unsigned }, { SU "\"-\"(YY)Y", synopsys_minus_unsigned }, { SA "\"*\"(" AU AU ")" AU, synopsys_mul_unsigned }, { SA "\"*\"(" AU AU ")V", synopsys_mul_unsigned }, { SU "\"*\"(VV)V", synopsys_mul_unsigned }, { SU "\"*\"(YY)Y", synopsys_mul_unsigned }, { SA "\"*\"(" AS AS ")" AS, synopsys_mul_signed }, { SA "\"*\"(" AS AS ")V", synopsys_mul_signed }, { SS "\"*\"(VV)V", synopsys_mul_signed }, { SS "\"*\"(YY)Y", synopsys_mul_signed }, { SA "\"=\"(" AU AU ")B", synopsys_eql_unsigned }, { SA "\"=\"(" AU AU ")B", synopsys_eql_unsigned }, { SU "\"=\"(VV)B", synopsys_eql_unsigned }, { SU "\"=\"(YY)B", synopsys_eql_unsigned }, { SA "\"=\"(" AS AS ")B", synopsys_eql_signed }, { SA "\"=\"(" AS AS ")B", synopsys_eql_signed }, { SS "\"=\"(VV)B", synopsys_eql_signed }, { SS "\"=\"(YY)B", synopsys_eql_signed }, { NULL, NULL } }; jit_entry_fn_t jit_bind_intrinsic(ident_t name) { INIT_ONCE({ const bool want_intrinsics = !!opt_get_int(OPT_JIT_INTRINSICS); #if ASAN_ENABLED const bool want_vector = false; // Reads past end of input (benign) #else const bool want_vector = !!opt_get_int(OPT_VECTOR_INTRINSICS); #endif cpu_feature_t mask = 0; #if HAVE_AVX2 if (want_vector && __builtin_cpu_supports("avx2")) mask |= CPU_AVX2; #endif #ifdef HAVE_SSE41 if (want_vector && __builtin_cpu_supports("sse4.1")) mask |= CPU_SSE41; #endif #ifdef HAVE_NEON if (want_vector) mask |= CPU_NEON; #endif for (jit_intrinsic_t *it = intrinsic_list; it->name; it++) { if (it->feature && !(it->feature & mask)) continue; else if (want_intrinsics) it->ident = ident_new(it->name); } }); for (const jit_intrinsic_t *it = intrinsic_list; it->name; it++) { if (it->ident == name) return it->entry; } return NULL; } nvc-r1.17.1/src/jit/jit-irgen.c000066400000000000000000004172521504111170000161630ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "cov/cov-api.h" #include "diag.h" #include "jit/jit-ffi.h" #include "jit/jit-ffi.h" #include "jit/jit-priv.h" #include "mask.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "option.h" #include "rt/rt.h" #include "tree.h" #include #include #include #include #include typedef struct _irgen_label irgen_label_t; typedef struct _patch_list patch_list_t; #define PATCH_CHUNK_SZ 4 #define MAX_STACK_ALLOC 65536 #define DEDUP_PREFIX 16384 struct _patch_list { patch_list_t *next; unsigned count; unsigned offsets[PATCH_CHUNK_SZ]; }; struct _irgen_label { jit_label_t label; unsigned uses; patch_list_t patchlist; irgen_label_t *next; }; typedef struct { jit_func_t *func; jit_value_t *vars; jit_value_t *params; jit_reg_t next_reg; jit_value_t *map; irgen_label_t *labels; irgen_label_t **blocks; mir_unit_t *mu; size_t cpoolptr; size_t oldptr; jit_value_t statereg; jit_value_t contextarg; mir_value_t flags; mir_block_t curblock; unsigned bufsz; bool used_tlab; bool stateless; bool needs_context; } jit_irgen_t; //////////////////////////////////////////////////////////////////////////////// // IR emission static inline jit_value_t jit_value_from_reg(jit_reg_t reg) { jit_value_t value = { .kind = JIT_VALUE_REG, .reg = reg }; return value; } static inline jit_value_t jit_value_from_int64(int64_t immed) { jit_value_t value = { .kind = JIT_VALUE_INT64, .int64 = immed }; return value; } static inline jit_value_t jit_value_from_double(double immed) { return (jit_value_t){ .kind = JIT_VALUE_DOUBLE, .dval = immed }; } static inline jit_value_t jit_value_from_cpool_addr(int offset) { jit_value_t value = { .kind = JIT_ADDR_CPOOL, .int64 = offset }; return value; } static inline jit_value_t jit_value_from_loc(const loc_t *loc) { jit_value_t value = { .kind = JIT_VALUE_LOC, .loc = *loc }; return value; } static inline jit_value_t jit_null_ptr(void) { jit_value_t value = { .kind = JIT_ADDR_ABS, .int64 = 0 }; return value; } static inline jit_reg_t jit_value_as_reg(jit_value_t value) { assert(value.kind == JIT_VALUE_REG); return value.reg; } static inline bool jit_value_is_addr(jit_value_t value) { switch (value.kind) { case JIT_ADDR_ABS: case JIT_ADDR_CPOOL: case JIT_ADDR_REG: return true; default: return false; } } static jit_value_t jit_addr_from_value(jit_value_t value, int32_t disp) { switch (value.kind) { case JIT_VALUE_REG: return (jit_value_t){ .kind = JIT_ADDR_REG, .disp = disp, .reg = value.reg }; case JIT_VALUE_INT64: case JIT_ADDR_ABS: return (jit_value_t){ .kind = JIT_ADDR_ABS, .int64 = value.int64 + disp }; case JIT_ADDR_CPOOL: return (jit_value_t){ .kind = value.kind, .int64 = value.int64 + disp }; case JIT_ADDR_REG: return (jit_value_t){ .kind = JIT_ADDR_REG, .disp = value.disp + disp, .reg = value.reg }; default: fatal_trace("cannot convert value kind %d to address", value.kind); } } static jit_value_t jit_addr_from_cover_tag(uint32_t tag) { return (jit_value_t){ .kind = JIT_ADDR_COVER, .int64 = tag, }; } static jit_value_t jit_value_from_label(irgen_label_t *l) { return (jit_value_t){ .kind = JIT_VALUE_LABEL, .label = l->label }; } static jit_value_t jit_value_from_handle(jit_handle_t handle) { return (jit_value_t){ .kind = JIT_VALUE_HANDLE, .handle = handle }; } static jit_value_t jit_value_from_exit(jit_exit_t exit) { return (jit_value_t){ .kind = JIT_VALUE_EXIT, .exit = exit }; } static jit_ir_t *irgen_append(jit_irgen_t *g) { if (g->func->nirs == g->bufsz) { g->bufsz = MAX(g->bufsz * 2, 1024); g->func->irbuf = xrealloc_array(g->func->irbuf, g->bufsz, sizeof(jit_ir_t)); } return &(g->func->irbuf[g->func->nirs++]); } static jit_reg_t irgen_alloc_reg(jit_irgen_t *g) { if (unlikely(g->next_reg == JIT_REG_INVALID)) fatal("unit %s is too big to compile", istr(g->func->name)); else return g->next_reg++; } static irgen_label_t *irgen_alloc_label(jit_irgen_t *g) { irgen_label_t *l = xcalloc(sizeof(irgen_label_t)); l->next = g->labels; l->label = JIT_LABEL_INVALID; return (g->labels = l); } static void irgen_bind_label(jit_irgen_t *g, irgen_label_t *l) { assert(l->label == JIT_LABEL_INVALID); l->label = g->func->nirs; for (patch_list_t *p = &(l->patchlist); p; p = p->next) { for (int i = 0; i < p->count; i++) { jit_ir_t *ir = &(g->func->irbuf[p->offsets[i]]); if (ir->arg1.kind == JIT_VALUE_LABEL) ir->arg1.label = l->label; else if (ir->arg2.kind == JIT_VALUE_LABEL) ir->arg2.label = l->label; else fatal_trace("cannot find label argument to patch"); } } for (patch_list_t *p = l->patchlist.next, *tmp; p; p = tmp) { tmp = p->next; free(p); } } static jit_cc_t irgen_get_jit_cc(mir_cmp_t cmp) { switch (cmp) { case MIR_CMP_EQ: return JIT_CC_EQ; case MIR_CMP_NEQ: return JIT_CC_NE; case MIR_CMP_LT: return JIT_CC_LT; case MIR_CMP_GT: return JIT_CC_GT; case MIR_CMP_LEQ: return JIT_CC_LE; case MIR_CMP_GEQ: return JIT_CC_GE; default: return JIT_CC_NONE; } } static void irgen_emit_nullary(jit_irgen_t *g, jit_op_t op, jit_cc_t cc, jit_reg_t result) { jit_ir_t *ir = irgen_append(g); ir->op = op; ir->size = JIT_SZ_UNSPEC; ir->cc = cc; ir->target = 0; ir->result = result; ir->arg1.kind = JIT_VALUE_INVALID; ir->arg2.kind = JIT_VALUE_INVALID; } static jit_ir_t *irgen_emit_unary(jit_irgen_t *g, jit_op_t op, jit_size_t sz, jit_cc_t cc, jit_reg_t result, jit_value_t arg) { jit_ir_t *ir = irgen_append(g); ir->op = op; ir->size = sz; ir->cc = cc; ir->target = 0; ir->result = result; ir->arg1 = arg; ir->arg2.kind = JIT_VALUE_INVALID; return ir; } static jit_ir_t *irgen_emit_binary(jit_irgen_t *g, jit_op_t op, jit_size_t sz, jit_cc_t cc, jit_reg_t result, jit_value_t arg1, jit_value_t arg2) { jit_ir_t *ir = irgen_append(g); ir->op = op; ir->size = sz; ir->cc = cc; ir->target = 0; ir->size = sz; ir->result = result; ir->arg1 = arg1; ir->arg2 = arg2; return ir; } static void irgen_patch_label(jit_irgen_t *g, jit_ir_t *ir, irgen_label_t *l) { if (l->label == JIT_LABEL_INVALID) { patch_list_t *p = &(l->patchlist); for (; p->count == PATCH_CHUNK_SZ; p = p->next) { if (p->next == NULL) p->next = xcalloc(sizeof(patch_list_t)); } p->offsets[p->count++] = ir - g->func->irbuf; } l->uses++; } static jit_value_t j_recv(jit_irgen_t *g, int pos) { assert(pos < JIT_MAX_ARGS); jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_RECV, JIT_SZ_UNSPEC, JIT_CC_NONE, r, jit_value_from_int64(pos)); return jit_value_from_reg(r); } static void j_send(jit_irgen_t *g, int pos, jit_value_t value) { assert(pos < JIT_MAX_ARGS); irgen_emit_binary(g, J_SEND, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, jit_value_from_int64(pos), value); } static void j_ret(jit_irgen_t *g) { irgen_emit_nullary(g, J_RET, JIT_CC_NONE, JIT_REG_INVALID); g->flags = MIR_NULL_VALUE; } __attribute__((unused)) static void j_trap(jit_irgen_t *g) { irgen_emit_nullary(g, J_TRAP, JIT_CC_NONE, JIT_REG_INVALID); } static void j_jump(jit_irgen_t *g, jit_cc_t cc, irgen_label_t *l) { jit_ir_t *ir = irgen_emit_unary(g, J_JUMP, JIT_SZ_UNSPEC, cc, JIT_REG_INVALID, jit_value_from_label(l)); irgen_patch_label(g, ir, l); } static void j_call(jit_irgen_t *g, jit_handle_t handle) { irgen_emit_unary(g, J_CALL, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, jit_value_from_handle(handle)); g->flags = MIR_NULL_VALUE; } static jit_value_t j_neg(jit_irgen_t *g, jit_value_t arg) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_NEG, JIT_SZ_UNSPEC, JIT_CC_NONE, r, arg); return jit_value_from_reg(r); } static jit_value_t j_fneg(jit_irgen_t *g, jit_value_t arg) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_FNEG, JIT_SZ_UNSPEC, JIT_CC_NONE, r, arg); return jit_value_from_reg(r); } static jit_value_t j_rem(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_REM, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_not(jit_irgen_t *g, jit_value_t arg) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_NOT, JIT_SZ_UNSPEC, JIT_CC_NONE, r, arg); return jit_value_from_reg(r); } static jit_value_t j_and(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_AND, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_or(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_OR, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_xor(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_XOR, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_asr(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_ASR, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_shl(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_SHL, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_add(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_ADD, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_adds(jit_irgen_t *g, jit_size_t sz, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_ADD, sz, cc, r, lhs, rhs); g->flags = MIR_NULL_VALUE; return jit_value_from_reg(r); } static jit_value_t j_fadd(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_FADD, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_mul(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_MUL, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_muls(jit_irgen_t *g, jit_size_t sz, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_MUL, sz, cc, r, lhs, rhs); g->flags = MIR_NULL_VALUE; return jit_value_from_reg(r); } static jit_value_t j_fmul(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_FMUL, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_div(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_DIV, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_fdiv(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_FDIV, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_sub(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_SUB, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t j_subs(jit_irgen_t *g, jit_size_t sz, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_SUB, sz, cc, r, lhs, rhs); g->flags = MIR_NULL_VALUE; return jit_value_from_reg(r); } static jit_value_t j_fsub(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_FSUB, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static void j_cmp(jit_irgen_t *g, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { irgen_emit_binary(g, J_CMP, JIT_SZ_UNSPEC, cc, JIT_REG_INVALID, lhs, rhs); g->flags = MIR_NULL_VALUE; } static void j_ccmp(jit_irgen_t *g, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { irgen_emit_binary(g, J_CCMP, JIT_SZ_UNSPEC, cc, JIT_REG_INVALID, lhs, rhs); g->flags = MIR_NULL_VALUE; } static void j_fcmp(jit_irgen_t *g, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { irgen_emit_binary(g, J_FCMP, JIT_SZ_UNSPEC, cc, JIT_REG_INVALID, lhs, rhs); g->flags = MIR_NULL_VALUE; } static void j_fccmp(jit_irgen_t *g, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { irgen_emit_binary(g, J_FCCMP, JIT_SZ_UNSPEC, cc, JIT_REG_INVALID, lhs, rhs); g->flags = MIR_NULL_VALUE; } static jit_value_t j_cset(jit_irgen_t *g) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_nullary(g, J_CSET, JIT_CC_NONE, r); return jit_value_from_reg(r); } static jit_value_t j_uload(jit_irgen_t *g, jit_size_t sz, jit_value_t addr) { assert(jit_value_is_addr(addr)); jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_ULOAD, sz, JIT_CC_NONE, r, addr); return jit_value_from_reg(r); } static jit_value_t j_load(jit_irgen_t *g, jit_size_t sz, jit_value_t addr) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_LOAD, sz, JIT_CC_NONE, r, addr); return jit_value_from_reg(r); } static void j_store(jit_irgen_t *g, jit_size_t sz, jit_value_t value, jit_value_t addr) { assert(!jit_value_is_addr(value)); irgen_emit_binary(g, J_STORE, sz, JIT_CC_NONE, JIT_REG_INVALID, value, addr); } static void j_mov(jit_irgen_t *g, jit_reg_t dest, jit_value_t value) { assert(!jit_value_is_addr(value)); irgen_emit_unary(g, J_MOV, JIT_SZ_UNSPEC, JIT_CC_NONE, dest, value); } static jit_value_t j_lea(jit_irgen_t *g, jit_value_t addr) { assert(jit_value_is_addr(addr)); jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_LEA, JIT_SZ_UNSPEC, JIT_CC_NONE, r, addr); return jit_value_from_reg(r); } static jit_value_t j_scvtf(jit_irgen_t *g, jit_value_t value) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_SCVTF, JIT_SZ_UNSPEC, JIT_CC_NONE, r, value); return jit_value_from_reg(r); } static jit_value_t j_fcvtns(jit_irgen_t *g, jit_value_t value) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_FCVTNS, JIT_SZ_UNSPEC, JIT_CC_NONE, r, value); return jit_value_from_reg(r); } static jit_value_t j_csel(jit_irgen_t *g, jit_value_t iftrue, jit_value_t iffalse) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, J_CSEL, JIT_SZ_UNSPEC, JIT_CC_NONE, r, iftrue, iffalse); return jit_value_from_reg(r); } static jit_value_t j_clamp(jit_irgen_t *g, jit_value_t value) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, J_CLAMP, JIT_SZ_UNSPEC, JIT_CC_NONE, r, value); return jit_value_from_reg(r); } #if 0 static void macro_copy(jit_irgen_t *g, jit_value_t dest, jit_value_t src, jit_reg_t count) { irgen_emit_binary(g, MACRO_COPY, JIT_SZ_UNSPEC, JIT_CC_NONE, count, dest, src); } #endif static void macro_move(jit_irgen_t *g, jit_value_t dest, jit_value_t src, jit_reg_t count) { irgen_emit_binary(g, MACRO_MOVE, JIT_SZ_UNSPEC, JIT_CC_NONE, count, dest, src); } static void macro_bzero(jit_irgen_t *g, jit_value_t dest, jit_reg_t count) { assert(jit_value_is_addr(dest)); irgen_emit_unary(g, MACRO_BZERO, JIT_SZ_UNSPEC, JIT_CC_NONE, count, dest); } static void macro_memset(jit_irgen_t *g, jit_size_t sz, jit_value_t dest, jit_value_t value, jit_reg_t count) { assert(jit_value_is_addr(dest)); irgen_emit_binary(g, MACRO_MEMSET, sz, JIT_CC_NONE, count, dest, value); } static jit_value_t macro_galloc(jit_irgen_t *g, jit_value_t bytes) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, MACRO_GALLOC, JIT_SZ_UNSPEC, JIT_CC_NONE, r, bytes); return jit_value_from_reg(r); } static jit_value_t macro_lalloc(jit_irgen_t *g, jit_value_t bytes) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, MACRO_LALLOC, JIT_SZ_UNSPEC, JIT_CC_NONE, r, bytes); return jit_value_from_reg(r); } static jit_value_t macro_salloc(jit_irgen_t *g, size_t size) { jit_reg_t r = irgen_alloc_reg(g); jit_value_t arg1 = jit_value_from_int64(g->func->framesz); jit_value_t arg2 = jit_value_from_int64(size); irgen_emit_binary(g, MACRO_SALLOC, JIT_SZ_UNSPEC, JIT_CC_NONE, r, arg1, arg2); g->func->framesz += ALIGN_UP(size, 8); return jit_value_from_reg(r); } static void macro_exit(jit_irgen_t *g, jit_exit_t exit) { irgen_emit_unary(g, MACRO_EXIT, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, jit_value_from_exit(exit)); g->flags = MIR_NULL_VALUE; } static jit_value_t macro_fexp(jit_irgen_t *g, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, MACRO_FEXP, JIT_SZ_UNSPEC, JIT_CC_NONE, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t macro_exp(jit_irgen_t *g, jit_size_t sz, jit_cc_t cc, jit_value_t lhs, jit_value_t rhs) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_binary(g, MACRO_EXP, sz, cc, r, lhs, rhs); return jit_value_from_reg(r); } static jit_value_t macro_getpriv(jit_irgen_t *g, jit_handle_t handle) { jit_reg_t r = irgen_alloc_reg(g); irgen_emit_unary(g, MACRO_GETPRIV, JIT_SZ_UNSPEC, JIT_CC_NONE, r, jit_value_from_handle(handle)); return jit_value_from_reg(r); } static void macro_putpriv(jit_irgen_t *g, jit_handle_t handle, jit_value_t ptr) { irgen_emit_binary(g, MACRO_PUTPRIV, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, jit_value_from_handle(handle), ptr); } static void macro_case(jit_irgen_t *g, jit_reg_t test, jit_value_t cmp, irgen_label_t *l) { jit_ir_t *ir = irgen_emit_binary(g, MACRO_CASE, JIT_SZ_UNSPEC, JIT_CC_NONE, test, cmp, jit_value_from_label(l)); irgen_patch_label(g, ir, l); } static void macro_trim(jit_irgen_t *g) { irgen_emit_nullary(g, MACRO_TRIM, JIT_CC_NONE, JIT_REG_INVALID); } static void macro_reexec(jit_irgen_t *g) { irgen_emit_nullary(g, MACRO_REEXEC, JIT_CC_NONE, JIT_REG_INVALID); g->flags = MIR_NULL_VALUE; } static void macro_sadd(jit_irgen_t *g, jit_size_t sz, jit_value_t addr, jit_value_t addend) { irgen_emit_binary(g, MACRO_SADD, sz, JIT_CC_NONE, JIT_REG_INVALID, addr, addend); } static void macro_pack(jit_irgen_t *g, jit_value_t ptr, jit_value_t size) { irgen_emit_binary(g, MACRO_PACK, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, ptr, size); } static void macro_unpack(jit_irgen_t *g, jit_value_t abits, jit_value_t bbits) { irgen_emit_binary(g, MACRO_UNPACK, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, abits, bbits); } //////////////////////////////////////////////////////////////////////////////// // MIR to JIT IR lowering static int irgen_slots_for_type(jit_irgen_t *g, mir_type_t type) { if (mir_is_null(type)) return 1; // Untyped constants switch (mir_get_class(g->mu, type)) { case MIR_TYPE_UARRAY: // Always passed around scalarised if (mir_get_class(g->mu, mir_get_elem(g->mu, type)) == MIR_TYPE_SIGNAL) return 2 + mir_get_dims(g->mu, type) * 2; else return 1 + mir_get_dims(g->mu, type) * 2; case MIR_TYPE_SIGNAL: // Signal pointer plus offset return 2; case MIR_TYPE_CLOSURE: // Function pointer, context return 2; case MIR_TYPE_RESOLUTION: // Closure slots plus nlits, and flags (this is silly) return 4; case MIR_TYPE_VEC4: return 2; default: // Passed by pointer or fits in 64-bit register return 1; } } static int irgen_repr_bits(mir_repr_t repr) { switch (repr) { case MIR_REPR_U1: return 1; case MIR_REPR_U8: case MIR_REPR_I8: return 8; case MIR_REPR_U16: case MIR_REPR_I16: return 16; case MIR_REPR_U32: case MIR_REPR_I32: return 32; case MIR_REPR_U64: case MIR_REPR_I64: return 64; default: return -1; } } static bool irgen_repr_signed(mir_repr_t repr) { return repr == MIR_REPR_I8 || repr == MIR_REPR_I16 || repr == MIR_REPR_I32 || repr == MIR_REPR_I64; } static int irgen_align_of(jit_irgen_t *g, mir_type_t type) { switch (mir_get_class(g->mu, type)) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: { const int bits = irgen_repr_bits(mir_get_repr(g->mu, type)); return ALIGN_UP(bits, 8) / 8; } case MIR_TYPE_REAL: case MIR_TYPE_RECORD: return sizeof(double); case MIR_TYPE_POINTER: case MIR_TYPE_ACCESS: case MIR_TYPE_UARRAY: case MIR_TYPE_SIGNAL: case MIR_TYPE_CONTEXT: case MIR_TYPE_TRIGGER: case MIR_TYPE_RESOLUTION: return sizeof(void *); case MIR_TYPE_VEC4: case MIR_TYPE_VEC2: return sizeof(uint64_t); case MIR_TYPE_FILE: return sizeof(uint32_t); case MIR_TYPE_CARRAY: return irgen_align_of(g, mir_get_elem(g->mu, type)); default: fatal_trace("cannot handle type %d in irgen_align_of", mir_get_class(g->mu, type)); } } static int irgen_size_bits(jit_irgen_t *g, mir_type_t type) { switch (mir_get_class(g->mu, type)) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: return irgen_repr_bits(mir_get_repr(g->mu, type)); case MIR_TYPE_REAL: return sizeof(double) * 8; case MIR_TYPE_POINTER: case MIR_TYPE_ACCESS: case MIR_TYPE_CONTEXT: case MIR_TYPE_TRIGGER: return sizeof(void *) * 8; case MIR_TYPE_FILE: return sizeof(uint32_t) * 8; default: fatal_trace("cannot handle type %d in irgen_size_bits", mir_get_class(g->mu, type)); } } static int irgen_size_bytes(jit_irgen_t *g, mir_type_t type) { switch (mir_get_class(g->mu, type)) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: { const int bits = irgen_size_bits(g, type); return ALIGN_UP(bits, 8) / 8; } case MIR_TYPE_REAL: return sizeof(double); case MIR_TYPE_CARRAY: { mir_type_t elem = mir_get_elem(g->mu, type); return mir_get_size(g->mu, type) * irgen_size_bytes(g, elem); } case MIR_TYPE_RECORD: { // TODO: cache this size_t nfields, bytes = 0; const mir_type_t *fields = mir_get_fields(g->mu, type, &nfields); for (int i = 0; i < nfields; i++) { const int fb = irgen_size_bytes(g, fields[i]); const int align = irgen_align_of(g, fields[i]); bytes = ALIGN_UP(bytes, align); bytes += fb; } return ALIGN_UP(bytes, sizeof(double)); } case MIR_TYPE_UARRAY: { const int ndims = mir_get_dims(g->mu, type); if (mir_get_class(g->mu, mir_get_elem(g->mu, type)) == MIR_TYPE_SIGNAL) return 2*sizeof(void *) + 2 * sizeof(int64_t) * ndims; else return sizeof(void *) + 2 * sizeof(int64_t) * ndims; } case MIR_TYPE_ACCESS: case MIR_TYPE_POINTER: case MIR_TYPE_CONTEXT: case MIR_TYPE_TRIGGER: return sizeof(void *); case MIR_TYPE_FILE: return sizeof(uint32_t); case MIR_TYPE_SIGNAL: return sizeof(void *) + sizeof(int32_t); case MIR_TYPE_RESOLUTION: return 2*sizeof(void *) + sizeof(int64_t) + sizeof(int32_t); case MIR_TYPE_VEC2: return sizeof(uint64_t); case MIR_TYPE_VEC4: return 2*sizeof(uint64_t); default: fatal_trace("cannot handle type %d in irgen_size_bytes", mir_get_class(g->mu, type)); } } static jit_size_t irgen_jit_size(jit_irgen_t *g, mir_type_t type) { const int bits = irgen_size_bits(g, type); switch (bits) { case 1: case 8: return JIT_SZ_8; case 16: return JIT_SZ_16; case 32: return JIT_SZ_32; case 64: return JIT_SZ_64; default: fatal_trace("illegal operand size %d", bits); } } static jit_value_t irgen_get_value(jit_irgen_t *g, mir_value_t value) { assert(!mir_is_null(value)); switch (value.tag) { case MIR_TAG_NODE: assert(g->map[value.id].kind != JIT_VALUE_INVALID); return g->map[value.id]; case MIR_TAG_CONST: { int64_t cval; if (mir_get_const(g->mu, value, &cval)) return jit_value_from_int64(cval); should_not_reach_here(); } case MIR_TAG_VAR: return g->vars[value.id]; case MIR_TAG_PARAM: return g->params[value.id]; default: DEBUG_ONLY(mir_dump(g->mu)); should_not_reach_here(); } } static jit_value_t irgen_get_arg(jit_irgen_t *g, mir_value_t n, int arg) { return irgen_get_value(g, mir_get_arg(g->mu, n, arg)); } static unsigned irgen_get_enum(jit_irgen_t *g, mir_value_t n, int arg) { mir_value_t value = mir_get_arg(g->mu, n, arg); assert(value.tag == MIR_TAG_ENUM); return value.id; } static int64_t irgen_get_const(jit_irgen_t *g, mir_value_t n, int arg) { mir_value_t value = mir_get_arg(g->mu, n, arg); int64_t result; if (mir_get_const(g->mu, value, &result)) return result; #ifdef DEBUG mir_dump(g->mu); fatal_trace("argument %d is not constant", arg); #else should_not_reach_here(); #endif } static jit_value_t irgen_lea(jit_irgen_t *g, jit_value_t addr) { switch (addr.kind) { case JIT_ADDR_REG: if (addr.disp == 0) return jit_value_from_reg(addr.reg); else return j_lea(g, addr); case JIT_ADDR_CPOOL: return j_lea(g, addr); case JIT_ADDR_ABS: return jit_value_from_int64(addr.int64); case JIT_VALUE_REG: case JIT_VALUE_INT64: return addr; default: fatal_trace("cannot load address of value kind %d", addr.kind); } } static jit_reg_t irgen_as_reg(jit_irgen_t *g, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: return value.reg; case JIT_ADDR_REG: case JIT_ADDR_CPOOL: case JIT_ADDR_ABS: return jit_value_as_reg(irgen_lea(g, value)); default: { jit_reg_t r = irgen_alloc_reg(g); j_mov(g, r, value); return r; } } } static jit_value_t irgen_is_scalar(jit_irgen_t *g, mir_value_t n, int arg) { mir_value_t value = mir_get_arg(g->mu, n, arg); return jit_value_from_int64(!mir_is(g->mu, value, MIR_TYPE_POINTER)); } static jit_value_t irgen_get_context(jit_irgen_t *g) { if (g->statereg.kind != JIT_VALUE_INVALID) return j_load(g, JIT_SZ_PTR, jit_addr_from_value(g->statereg, 0)); else if (g->contextarg.kind != JIT_VALUE_INVALID) return g->contextarg; else return g->params[mir_get_param(g->mu, 0).id]; } static size_t irgen_append_cpool(jit_irgen_t *g, size_t sz, int align) { if (g->cpoolptr + sz + align - 1 > g->func->cpoolsz) { g->func->cpoolsz = MAX(128, MAX((g->func->cpoolsz * 3) / 2, g->cpoolptr + sz + align - 1)); g->func->cpool = xrealloc(g->func->cpool, g->func->cpoolsz); g->func->owns_cpool = true; } const size_t result = ALIGN_UP(g->cpoolptr, align); g->oldptr = result; g->cpoolptr = result + sz; return result; } static jit_value_t irgen_dedup_cpool(jit_irgen_t *g) { unsigned char *dup = memmem(g->func->cpool, MIN(g->oldptr, DEDUP_PREFIX), g->func->cpool + g->oldptr, g->cpoolptr - g->oldptr); if (dup != NULL) { g->cpoolptr = g->oldptr; return jit_value_from_cpool_addr(dup - g->func->cpool); } else return jit_value_from_cpool_addr(g->oldptr); } static void irgen_emit_debuginfo(jit_irgen_t *g, mir_value_t n) { jit_value_t arg1 = jit_value_from_loc(mir_get_loc(g->mu, n)); jit_value_t arg2 = { .kind = JIT_VALUE_VPOS, .vpos = { .block = g->curblock.id, .op = n.id } }; if (g->func->nirs > 0 && g->func->irbuf[g->func->nirs - 1].op == J_DEBUG) { jit_ir_t *prev = &(g->func->irbuf[g->func->nirs - 1]); prev->arg1 = arg1; prev->arg2 = arg2; } else irgen_emit_binary(g, J_DEBUG, JIT_SZ_UNSPEC, JIT_CC_NONE, JIT_REG_INVALID, arg1, arg2); } static ffi_type_t irgen_ffi_type(jit_irgen_t *g, mir_type_t type) { if (mir_is_null(type)) return FFI_VOID; switch (mir_get_class(g->mu, type)) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: switch (mir_get_repr(g->mu, type)) { case MIR_REPR_U1: case MIR_REPR_U8: return FFI_UINT8; case MIR_REPR_I8: return FFI_INT8; case MIR_REPR_I16: return FFI_INT16; case MIR_REPR_U16: return FFI_UINT16; case MIR_REPR_I32: return FFI_INT32; case MIR_REPR_U32: return FFI_UINT32; default: return FFI_INT64; } case MIR_TYPE_REAL: return FFI_FLOAT; case MIR_TYPE_CARRAY: case MIR_TYPE_RECORD: case MIR_TYPE_POINTER: case MIR_TYPE_CONTEXT: case MIR_TYPE_ACCESS: case MIR_TYPE_LOCUS: case MIR_TYPE_CONVERSION: return FFI_POINTER; case MIR_TYPE_FILE: return FFI_UINT32; case MIR_TYPE_UARRAY: return FFI_UARRAY; case MIR_TYPE_SIGNAL: return FFI_SIGNAL; default: fatal_trace("cannot handle type %d in irgen_ffi_type", mir_get_class(g->mu, type)); } } static jit_handle_t irgen_get_handle(jit_irgen_t *g, mir_value_t n, int arg) { ident_t func = mir_get_name(g->mu, mir_get_arg(g->mu, n, arg)); jit_handle_t handle = jit_lazy_compile(g->func->jit, func); if (handle == JIT_HANDLE_INVALID) fatal_at(mir_get_loc(g->mu, n), "missing definition for %s", istr(func)); return handle; } static jit_value_t irgen_state_ptr(jit_irgen_t *g) { assert(g->statereg.kind != JIT_VALUE_INVALID); return jit_addr_from_value(g->statereg, 2 * sizeof(void *)); } static jit_value_t irgen_pcall_ptr(jit_irgen_t *g) { assert(g->statereg.kind != JIT_VALUE_INVALID); return jit_addr_from_value(g->statereg, 1 * sizeof(void *)); } static void irgen_op_null(jit_irgen_t *g, mir_value_t n) { switch (mir_get_class(g->mu, mir_get_type(g->mu, n))) { case MIR_TYPE_POINTER: case MIR_TYPE_ACCESS: case MIR_TYPE_CONTEXT: g->map[n.id] = jit_null_ptr(); break; case MIR_TYPE_FILE: g->map[n.id] = jit_value_from_int64(0); break; default: should_not_reach_here(); } } static void irgen_op_const(jit_irgen_t *g, mir_value_t n) { int64_t cval; if (mir_get_const(g->mu, n, &cval)) g->map[n.id] = jit_value_from_int64(cval); else should_not_reach_here(); } static void irgen_op_const_real(jit_irgen_t *g, mir_value_t n) { double val; if (mir_get_const_real(g->mu, n, &val)) g->map[n.id] = jit_value_from_double(val); else should_not_reach_here(); } static void irgen_op_const_vec(jit_irgen_t *g, mir_value_t n) { uint64_t abits, bbits; mir_get_bits(g->mu, n, &abits, &bbits); if (mir_is(g->mu, n, MIR_TYPE_VEC2)) { assert(bbits == 0); g->map[n.id] = jit_value_from_int64(abits); } else { // Registers must be contiguous jit_reg_t areg = irgen_alloc_reg(g); j_mov(g, areg, jit_value_from_int64(abits)); jit_reg_t breg = irgen_alloc_reg(g); j_mov(g, breg, jit_value_from_int64(bbits)); g->map[n.id] = jit_value_from_reg(areg); } } static void irgen_copy_const(jit_irgen_t *g, unsigned char *p, jit_value_t value, int bytes) { switch (value.kind) { case JIT_VALUE_INT64: switch (bytes) { case 1: *(uint8_t *)p = (uint8_t)value.int64; break; case 2: *(uint16_t *)p = (uint16_t)value.int64; break; case 4: *(uint32_t *)p = (uint32_t)value.int64; break; case 8: *(uint64_t *)p = (uint64_t)value.int64; break; default: fatal_trace("cannot handle value size %d", bytes); } break; case JIT_VALUE_DOUBLE: assert(bytes == sizeof(double)); *(double *)p = value.dval; break; case JIT_ADDR_CPOOL: assert(value.int64 >= 0 && value.int64 + bytes <= g->func->cpoolsz); memcpy(p, g->func->cpool + value.int64, bytes); break; case JIT_ADDR_ABS: assert(value.int64 == 0); switch (bytes) { case sizeof(void *): *(uintptr_t *)p = (uintptr_t)value.int64; break; case 0: break; default: should_not_reach_here(); } break; default: fatal_trace("cannot handle value kind %d", value.kind); } } static void irgen_op_const_array(jit_irgen_t *g, mir_value_t n) { mir_type_t type = mir_get_type(g->mu, n); mir_type_t elem = mir_get_elem(g->mu, type); const int elemsz = irgen_size_bytes(g, elem); const int align = irgen_align_of(g, elem); const int count = mir_get_size(g->mu, type); if (count > 0) { const size_t offset = irgen_append_cpool(g, elemsz * count, align); unsigned char *p = g->func->cpool + offset; for (int i = 0; i < count; i++, p += elemsz) { jit_value_t elem = irgen_get_arg(g, n, i); irgen_copy_const(g, p, elem, elemsz); } g->map[n.id] = irgen_dedup_cpool(g); } else g->map[n.id] = jit_null_ptr(); } static void irgen_op_const_rep(jit_irgen_t *g, mir_value_t n) { mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, n)); const int count = irgen_get_const(g, n, 1); jit_value_t value = irgen_get_arg(g, n, 0); const int elemsz = irgen_size_bytes(g, elem); const int align = irgen_align_of(g, elem); const size_t offset = irgen_append_cpool(g, elemsz * count, align); unsigned char *p = g->func->cpool + offset; for (int i = 0; i < count; i++, p += elemsz) irgen_copy_const(g, p, value, elemsz); g->map[n.id] = irgen_dedup_cpool(g); } static void irgen_op_const_record(jit_irgen_t *g, mir_value_t n) { mir_type_t type = mir_get_type(g->mu, n); size_t nfields; const mir_type_t *fields = mir_get_fields(g->mu, type, &nfields); const int sz = irgen_size_bytes(g, type); const int align = irgen_align_of(g, type); const size_t offset = irgen_append_cpool(g, sz, align); unsigned char *p = g->func->cpool + offset; for (int i = 0; i < nfields; i++) { jit_value_t elem = irgen_get_arg(g, n, i); const int bytes = irgen_size_bytes(g, fields[i]); const int align = irgen_align_of(g, fields[i]); while (p != ALIGN_UP(p, align)) *p++ = 0; // Pad to field alignment irgen_copy_const(g, p, elem, bytes); p += bytes; } assert(g->func->cpool + offset + sz - p < sizeof(double)); g->map[n.id] = jit_value_from_cpool_addr(offset); } static void irgen_op_address_of(jit_irgen_t *g, mir_value_t n) { // No-op g->map[n.id] = irgen_get_arg(g, n, 0); } static void irgen_op_copy(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); mir_type_t elem = mir_get_type(g->mu, n); jit_value_t bytes; if (mir_count_args(g->mu, n) > 2) { jit_value_t arg2 = irgen_get_arg(g, n, 2); const int scale = irgen_size_bytes(g, elem); bytes = j_mul(g, arg2, jit_value_from_int64(scale)); } else bytes = jit_value_from_int64(irgen_size_bytes(g, elem)); jit_value_t dest = jit_addr_from_value(arg0, 0); jit_value_t src = jit_addr_from_value(arg1, 0); macro_move(g, dest, src, irgen_as_reg(g, bytes)); } static void irgen_op_set(jit_irgen_t *g, mir_value_t n) { jit_value_t base = irgen_get_arg(g, n, 0); jit_value_t value = irgen_get_arg(g, n, 1); jit_value_t length = irgen_get_arg(g, n, 2); mir_type_t type = mir_get_type(g->mu, n); jit_value_t addr = jit_addr_from_value(base, 0); jit_value_t scale = jit_value_from_int64(irgen_size_bytes(g, type)); jit_value_t bytes = j_mul(g, length, scale); jit_reg_t bytes_r = jit_value_as_reg(bytes); if (value.kind == JIT_VALUE_INT64 && value.int64 == 0) macro_bzero(g, addr, bytes_r); else if (value.kind == JIT_VALUE_DOUBLE) { jit_value_t bits = jit_value_from_int64(value.int64); macro_memset(g, irgen_jit_size(g, type), addr, bits, bytes_r); } else macro_memset(g, irgen_jit_size(g, type), addr, value, bytes_r); } static void irgen_send_args(jit_irgen_t *g, mir_value_t n, int first) { const int nargs = mir_count_args(g->mu, n); jit_value_t spill = { .kind = JIT_VALUE_INVALID }; int32_t spilloff = 0; for (int i = 0, pslot = first; i < nargs; i++) { mir_value_t arg = mir_get_arg(g->mu, n, i); if (arg.tag == MIR_TAG_LINKAGE || arg.tag == MIR_TAG_BLOCK) continue; // Skip function name and resume block int slots = irgen_slots_for_type(g, mir_get_type(g->mu, arg)); if (pslot + slots >= JIT_MAX_ARGS - 1) { // Large number of arguments spill to the heap if (spill.kind == JIT_VALUE_INVALID) { size_t size = slots * sizeof(jit_scalar_t); for (int j = i + 1; j < nargs; j++) { mir_type_t type = mir_get_type(g->mu, mir_get_arg(g->mu, n, j)); size += irgen_slots_for_type(g, type) * sizeof(jit_scalar_t); } spill = macro_lalloc(g, jit_value_from_int64(size)); j_send(g, JIT_MAX_ARGS - 1, spill); pslot = JIT_MAX_ARGS; g->used_tlab = true; } jit_reg_t base = irgen_as_reg(g, irgen_get_value(g, arg)); for (int j = 0; j < slots; j++, spilloff += sizeof(jit_scalar_t)) { jit_value_t ptr = jit_addr_from_value(spill, spilloff); j_store(g, JIT_SZ_64, jit_value_from_reg(base + j), ptr); } } else if (slots > 1) { jit_reg_t base = jit_value_as_reg(irgen_get_value(g, arg)); for (int j = 0; j < slots; j++) j_send(g, pslot++, jit_value_from_reg(base + j)); } else j_send(g, pslot++, irgen_get_value(g, arg)); } } static void irgen_op_return(jit_irgen_t *g, mir_value_t n) { switch (mir_get_kind(g->mu)) { case MIR_UNIT_PROCESS: if (g->statereg.kind != JIT_VALUE_INVALID) { // Set up for first call to process after reset jit_value_t ptr = irgen_state_ptr(g); j_store(g, JIT_SZ_32, jit_value_from_int64(1), ptr); j_send(g, 0, g->statereg); } else j_send(g, 0, jit_null_ptr()); // Stateless process break; case MIR_UNIT_PROCEDURE: j_send(g, 0, jit_null_ptr()); macro_trim(g); break; case MIR_UNIT_INSTANCE: case MIR_UNIT_PROTECTED: case MIR_UNIT_PACKAGE: j_send(g, 0, g->statereg); break; case MIR_UNIT_PROPERTY: if (mir_count_args(g->mu, n) > 0) irgen_send_args(g, n, 1); if (g->statereg.kind != JIT_VALUE_INVALID) j_send(g, 0, g->statereg); else j_send(g, 0, jit_null_ptr()); // Stateless property break; case MIR_UNIT_FUNCTION: case MIR_UNIT_THUNK: if (mir_count_args(g->mu, n) > 0) irgen_send_args(g, n, 0); else j_send(g, 0, jit_null_ptr()); // Procedure compiled as function if (g->used_tlab) { const mir_mem_t mem = mir_get_mem(g->mu, mir_get_arg(g->mu, n, 0)); if (mem <= MIR_MEM_CONST) macro_trim(g); else if (mem == MIR_MEM_STACK) { mir_dump(g->mu); fatal_trace("returning pointer to stack allocation"); } } break; } j_ret(g); } static void irgen_op_not(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); g->map[n.id] = j_not(g, arg0); } static void irgen_op_and(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); g->map[n.id] = j_and(g, arg0, arg1); } static void irgen_op_or(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); g->map[n.id] = j_or(g, arg0, arg1); } static void irgen_op_xor(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); g->map[n.id] = j_xor(g, arg0, arg1); } static void irgen_op_trap_add(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); mir_type_t type = mir_get_type(g->mu, n); jit_size_t sz = irgen_jit_size(g, type); mir_repr_t repr = mir_get_repr(g->mu, type); jit_cc_t cc = irgen_repr_signed(repr) ? JIT_CC_O : JIT_CC_C; g->map[n.id] = j_adds(g, sz, cc, arg0, arg1); irgen_label_t *l_pass = irgen_alloc_label(g); j_jump(g, JIT_CC_F, l_pass); j_send(g, 0, arg0); j_send(g, 1, arg1); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_OVERFLOW); irgen_bind_label(g, l_pass); } static void irgen_op_add(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (mir_is(g->mu, n, MIR_TYPE_REAL)) g->map[n.id] = j_fadd(g, arg0, arg1); else g->map[n.id] = j_add(g, arg0, arg1); } static void irgen_op_trap_mul(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); mir_type_t type = mir_get_type(g->mu, n); jit_size_t sz = irgen_jit_size(g, type); mir_repr_t repr = mir_get_repr(g->mu, type); jit_cc_t cc = irgen_repr_signed(repr) ? JIT_CC_O : JIT_CC_C; g->map[n.id] = j_muls(g, sz, cc, arg0, arg1); irgen_label_t *l_pass = irgen_alloc_label(g); j_jump(g, JIT_CC_F, l_pass); j_send(g, 0, arg0); j_send(g, 1, arg1); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_OVERFLOW); irgen_bind_label(g, l_pass); } static void irgen_op_mul(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (mir_is(g->mu, n, MIR_TYPE_REAL)) g->map[n.id] = j_fmul(g, arg0, arg1); else g->map[n.id] = j_mul(g, arg0, arg1); } static void irgen_op_div(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (mir_is(g->mu, n, MIR_TYPE_REAL)) g->map[n.id] = j_fdiv(g, arg0, arg1); else g->map[n.id] = j_div(g, arg0, arg1); } static void irgen_op_exp(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (mir_is(g->mu, n, MIR_TYPE_REAL)) g->map[n.id] = macro_fexp(g, arg0, arg1); else g->map[n.id] = macro_exp(g, JIT_SZ_UNSPEC, JIT_CC_NONE, arg0, arg1); } static void irgen_op_trap_exp(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); mir_type_t type = mir_get_type(g->mu, n); jit_size_t sz = irgen_jit_size(g, type); mir_repr_t repr = mir_get_repr(g->mu, type); jit_cc_t cc = irgen_repr_signed(repr) ? JIT_CC_O : JIT_CC_C; g->map[n.id] = macro_exp(g, sz, cc, arg0, arg1); irgen_label_t *l_pass = irgen_alloc_label(g); j_jump(g, JIT_CC_F, l_pass); j_send(g, 0, arg0); j_send(g, 1, arg1); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_OVERFLOW); irgen_bind_label(g, l_pass); } static void irgen_op_sub(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (mir_is(g->mu, n, MIR_TYPE_REAL)) g->map[n.id] = j_fsub(g, arg0, arg1); else g->map[n.id] = j_sub(g, arg0, arg1); } static void irgen_op_trap_sub(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); mir_type_t type = mir_get_type(g->mu, n); jit_size_t sz = irgen_jit_size(g, type); mir_repr_t repr = mir_get_repr(g->mu, type); jit_cc_t cc = irgen_repr_signed(repr) ? JIT_CC_O : JIT_CC_C; g->map[n.id] = j_subs(g, sz, cc, arg0, arg1); irgen_label_t *l_pass = irgen_alloc_label(g); j_jump(g, JIT_CC_F, l_pass); j_send(g, 0, arg0); j_send(g, 1, arg1); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_OVERFLOW); irgen_bind_label(g, l_pass); } static void irgen_op_neg(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); if (mir_is_integral(g->mu, n)) g->map[n.id] = j_neg(g, arg0); else g->map[n.id] = j_fneg(g, arg0); } static void irgen_op_trap_neg(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); int64_t cmp; switch (irgen_jit_size(g, mir_get_type(g->mu, n))) { case JIT_SZ_8: cmp = INT8_MIN; break; case JIT_SZ_16: cmp = INT16_MIN; break; case JIT_SZ_32: cmp = INT32_MIN; break; case JIT_SZ_64: cmp = INT64_MIN; break; default: cmp = 0; } irgen_label_t *cont = irgen_alloc_label(g); j_cmp(g, JIT_CC_GT, arg0, jit_value_from_int64(cmp)); j_jump(g, JIT_CC_T, cont); j_send(g, 0, arg0); j_send(g, 1, jit_value_from_int64(0)); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_OVERFLOW); irgen_bind_label(g, cont); g->map[n.id] = j_neg(g, arg0); } static void irgen_op_abs(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); if (mir_is(g->mu, n, MIR_TYPE_REAL)) { jit_value_t neg = j_fneg(g, arg0); j_fcmp(g, JIT_CC_LT, arg0, jit_value_from_double(0.0)); g->map[n.id] = j_csel(g, neg, arg0); } else { jit_value_t neg = j_neg(g, arg0); j_cmp(g, JIT_CC_LT, arg0, jit_value_from_int64(0)); g->map[n.id] = j_csel(g, neg, arg0); } } static void irgen_op_mod(jit_irgen_t *g, mir_value_t n) { jit_value_t numer = irgen_get_arg(g, n, 0); jit_value_t denom = irgen_get_arg(g, n, 1); // Calculate the following: // // long r = numer % denom; // if ((r > 0 && denom < 0) || (r < 0 && denom > 0)) // r = r + denom; jit_value_t r = j_rem(g, numer, denom); irgen_label_t *l1 = irgen_alloc_label(g); irgen_label_t *l2 = irgen_alloc_label(g); jit_value_t zero = jit_value_from_int64(0); j_cmp(g, JIT_CC_GT, r, zero); j_ccmp(g, JIT_CC_LT, denom, zero); j_jump(g, JIT_CC_T, l1); j_cmp(g, JIT_CC_LT, r, zero); j_ccmp(g, JIT_CC_GT, denom, zero); j_jump(g, JIT_CC_F, l2); irgen_bind_label(g, l1); jit_value_t r2 = j_add(g, r, denom); j_mov(g, jit_value_as_reg(r), r2); irgen_bind_label(g, l2); g->map[n.id] = r; } static void irgen_op_rem(jit_irgen_t *g, mir_value_t n) { jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); g->map[n.id] = j_rem(g, arg0, arg1); } static void irgen_op_cmp(jit_irgen_t *g, mir_value_t n) { mir_value_t arg1 = mir_get_arg(g->mu, n, 1); jit_value_t left = irgen_get_value(g, arg1); jit_value_t right = irgen_get_arg(g, n, 2); jit_cc_t cc = irgen_get_jit_cc(irgen_get_enum(g, n, 0)); if (mir_is(g->mu, arg1, MIR_TYPE_REAL)) j_fcmp(g, cc, left, right); else j_cmp(g, cc, left, right); g->map[n.id] = j_cset(g); g->flags = n; } static jit_value_t irgen_load_addr(jit_irgen_t *g, mir_type_t type, jit_value_t ptr) { jit_value_t addr = jit_addr_from_value(ptr, 0); switch (mir_get_class(g->mu, type)) { case MIR_TYPE_OFFSET: case MIR_TYPE_INT: if (irgen_repr_signed(mir_get_repr(g->mu, type))) return j_load(g, irgen_jit_size(g, type), addr); else return j_uload(g, irgen_jit_size(g, type), addr); case MIR_TYPE_REAL: return j_load(g, JIT_SZ_64, addr); case MIR_TYPE_ACCESS: case MIR_TYPE_POINTER: case MIR_TYPE_CONTEXT: case MIR_TYPE_TRIGGER: return j_load(g, JIT_SZ_PTR, addr); case MIR_TYPE_FILE: return j_load(g, JIT_SZ_32, addr); case MIR_TYPE_SIGNAL: { jit_value_t shared = j_load(g, JIT_SZ_PTR, addr); addr = jit_addr_from_value(addr, sizeof(void *)); j_load(g, JIT_SZ_32, addr); // Offset return shared; } case MIR_TYPE_UARRAY: { const int slots = irgen_slots_for_type(g, mir_get_elem(g->mu, type)); jit_value_t base = j_load(g, JIT_SZ_PTR, addr); addr = jit_addr_from_value(addr, sizeof(void *)); for (int i = 1; i < slots; i++) { j_load(g, JIT_SZ_PTR, addr); addr = jit_addr_from_value(addr, sizeof(void *)); } const int ndims = mir_get_dims(g->mu, type); for (int i = 0; i < 2*ndims; i++) { j_load(g, JIT_SZ_64, addr); addr = jit_addr_from_value(addr, sizeof(int64_t)); } return base; } case MIR_TYPE_RESOLUTION: { jit_value_t base = j_load(g, JIT_SZ_PTR, addr); // Function pointer addr = jit_addr_from_value(addr, sizeof(void *)); j_load(g, JIT_SZ_PTR, addr); // Context addr = jit_addr_from_value(addr, sizeof(void *)); j_load(g, JIT_SZ_64, addr); // Literals addr = jit_addr_from_value(addr, sizeof(int64_t)); j_load(g, JIT_SZ_32, addr); // Flags return base; } case MIR_TYPE_VEC2: return j_load(g, JIT_SZ_64, addr); case MIR_TYPE_VEC4: { jit_value_t base = j_load(g, JIT_SZ_64, addr); addr = jit_addr_from_value(addr, sizeof(uint64_t)); j_load(g, JIT_SZ_PTR, addr); return base; } default: mir_dump(g->mu); fatal_trace("cannot load type kind %d", mir_get_class(g->mu, type)); } } static void irgen_op_load(jit_irgen_t *g, mir_value_t n) { jit_value_t addr = irgen_get_arg(g, n, 0); mir_type_t type = mir_get_type(g->mu, n); g->map[n.id] = irgen_load_addr(g, type, addr); } static void irgen_store_addr(jit_irgen_t *g, mir_type_t type, jit_value_t value, jit_value_t ptr) { jit_value_t addr = jit_addr_from_value(ptr, 0); if (jit_value_is_addr(value)) value = irgen_lea(g, value); // Storing an address switch (mir_get_class(g->mu, type)) { case MIR_TYPE_OFFSET: case MIR_TYPE_INT: case MIR_TYPE_ACCESS: case MIR_TYPE_POINTER: case MIR_TYPE_CONTEXT: case MIR_TYPE_REAL: case MIR_TYPE_TRIGGER: j_store(g, irgen_jit_size(g, type), value, addr); break; case MIR_TYPE_FILE: j_store(g, JIT_SZ_32, value, addr); break; case MIR_TYPE_UARRAY: { const int slots = irgen_slots_for_type(g, mir_get_elem(g->mu, type)); jit_reg_t base = jit_value_as_reg(value); for (int i = 0; i < slots; i++) { j_store(g, JIT_SZ_PTR, jit_value_from_reg(base + i), addr); addr = jit_addr_from_value(addr, sizeof(void *)); } const int ndims = mir_get_dims(g->mu, type); for (int i = 0; i < 2*ndims; i++) { j_store(g, JIT_SZ_64, jit_value_from_reg(base + slots + i), addr); addr = jit_addr_from_value(addr, sizeof(int64_t)); } } break; case MIR_TYPE_SIGNAL: { jit_reg_t base = jit_value_as_reg(value); j_store(g, JIT_SZ_PTR, value, addr); addr = jit_addr_from_value(addr, sizeof(void *)); j_store(g, JIT_SZ_32, jit_value_from_reg(base + 1), addr); } break; case MIR_TYPE_RESOLUTION: { jit_reg_t base = jit_value_as_reg(value); j_store(g, JIT_SZ_PTR, value, addr); // Function pointer addr = jit_addr_from_value(addr, sizeof(void *)); j_store(g, JIT_SZ_PTR, jit_value_from_reg(base + 1), addr); // Context addr = jit_addr_from_value(addr, sizeof(void *)); j_store(g, JIT_SZ_64, jit_value_from_reg(base + 2), addr); // Literals addr = jit_addr_from_value(addr, sizeof(int64_t)); j_store(g, JIT_SZ_32, jit_value_from_reg(base + 3), addr); // Flags } break; case MIR_TYPE_VEC2: j_store(g, JIT_SZ_64, value, addr); break; case MIR_TYPE_VEC4: { jit_reg_t base = jit_value_as_reg(value); j_store(g, JIT_SZ_64, value, addr); addr = jit_addr_from_value(addr, sizeof(uint64_t)); j_store(g, JIT_SZ_PTR, jit_value_from_reg(base + 1), addr); } break; default: fatal_trace("cannot store type kind %d", mir_get_class(g->mu, type)); } } static void irgen_op_store(jit_irgen_t *g, mir_value_t n) { jit_value_t addr = irgen_get_arg(g, n, 0); jit_value_t value = irgen_get_arg(g, n, 1); mir_type_t type = mir_get_type(g->mu, n); irgen_store_addr(g, type, value, addr); } static void irgen_op_locus(jit_irgen_t *g, mir_value_t n) { g->map[n.id] = (jit_value_t){ .kind = JIT_VALUE_LOCUS, .locus = mir_get_locus(g->mu, n), }; } static void irgen_op_wrap(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); jit_value_t ptr = irgen_lea(g, irgen_get_value(g, arg0)); mir_type_t type = mir_get_type(g->mu, arg0); const int ndims = mir_count_args(g->mu, n) / 3; const int slots = irgen_slots_for_type(g, type); // Registers must be contiguous jit_reg_t base = irgen_alloc_reg(g); j_mov(g, base, ptr); for (int i = 1; i < slots; i++) { jit_reg_t slot = irgen_alloc_reg(g); j_mov(g, slot, jit_value_from_reg(jit_value_as_reg(ptr) + i)); } jit_reg_t dims[ndims * 2]; for (int i = 0; i < ndims * 2; i++) dims[i] = irgen_alloc_reg(g); for (int i = 0; i < ndims; i++) { jit_value_t left = irgen_get_arg(g, n, (i * 3) + 1); jit_value_t right = irgen_get_arg(g, n, (i * 3) + 2); jit_value_t dir = irgen_get_arg(g, n, (i * 3) + 3); jit_value_t diff_up = j_sub(g, right, left); jit_value_t diff_down = j_sub(g, left, right); j_cmp(g, JIT_CC_EQ, dir, jit_value_from_int64(RANGE_DOWNTO)); jit_value_t diff = j_csel(g, diff_down, diff_up); jit_value_t length = j_add(g, diff, jit_value_from_int64(1)); jit_value_t clamped = j_clamp(g, length); jit_value_t mask = j_neg(g, dir); jit_value_t signlen = j_xor(g, mask, clamped); j_mov(g, dims[i*2], left); j_mov(g, dims[i*2 + 1], signlen); } g->map[n.id] = jit_value_from_reg(base); } static void irgen_op_uarray_right(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); jit_reg_t base = jit_value_as_reg(irgen_get_value(g, arg0)); mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); const int dim = irgen_get_const(g, n, 1); const int slots = irgen_slots_for_type(g, elem); jit_value_t left = jit_value_from_reg(base + slots + dim*2); jit_value_t length = jit_value_from_reg(base + slots + 1 + dim*2); jit_value_t diff = j_add(g, left, length); j_cmp(g, JIT_CC_LT, length, jit_value_from_int64(0)); jit_value_t adj = j_csel(g, jit_value_from_int64(2), jit_value_from_int64(-1)); g->map[n.id] = j_add(g, diff, adj); } static void irgen_op_uarray_left(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); jit_reg_t base = jit_value_as_reg(irgen_get_value(g, arg0)); mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); const int dim = irgen_get_const(g, n, 1); const int slots = irgen_slots_for_type(g, elem); g->map[n.id] = jit_value_from_reg(base + slots + dim*2); } static void irgen_op_uarray_dir(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); jit_reg_t base = jit_value_as_reg(irgen_get_value(g, arg0)); mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); const int dim = irgen_get_const(g, n, 1); const int slots = irgen_slots_for_type(g, elem); jit_value_t length = jit_value_from_reg(base + slots + 1 + dim*2); j_cmp(g, JIT_CC_LT, length, jit_value_from_int64(0)); STATIC_ASSERT(RANGE_DOWNTO == 1); g->map[n.id] = j_cset(g); g->flags = n; } static void irgen_op_uarray_len(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); jit_reg_t base = jit_value_as_reg(irgen_get_value(g, arg0)); mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); const int dim = irgen_get_const(g, n, 1); const int slots = irgen_slots_for_type(g, elem); jit_value_t length = jit_value_from_reg(base + slots + 1 + dim*2); jit_value_t mask = j_asr(g, length, jit_value_from_int64(63)); g->map[n.id] = j_xor(g, mask, length); } static void irgen_op_unwrap(jit_irgen_t *g, mir_value_t n) { jit_value_t base = irgen_get_arg(g, n, 0); g->map[n.id] = base; } static void irgen_op_array_ref(jit_irgen_t *g, mir_value_t n) { if (mir_is_signal(g->mu, n)) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (arg1.kind == JIT_VALUE_INT64 && arg1.int64 == 0) g->map[n.id] = shared; else { jit_reg_t new = irgen_alloc_reg(g); j_mov(g, new, shared); g->map[n.id] = jit_value_from_reg(new); // Offset must be next sequential register j_add(g, offset, arg1); } } else { assert(mir_is(g->mu, n, MIR_TYPE_POINTER)); mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, n)); const int scale = irgen_size_bytes(g, elem); jit_value_t arg0 = irgen_get_arg(g, n, 0); jit_value_t arg1 = irgen_get_arg(g, n, 1); if (arg1.kind == JIT_VALUE_INT64) g->map[n.id] = jit_addr_from_value(arg0, arg1.int64 * scale); else { jit_value_t scaled = j_mul(g, arg1, jit_value_from_int64(scale)); jit_value_t addr = irgen_lea(g, arg0); g->map[n.id] = j_add(g, addr, scaled); } } } static void irgen_op_record_ref(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); mir_type_t rtype = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); assert(mir_get_class(g->mu, rtype) == MIR_TYPE_RECORD); const int field = irgen_get_const(g, n, 1); size_t nfields; const mir_type_t *ftypes = mir_get_fields(g->mu, rtype, &nfields); assert(field < nfields); // TODO: cache field offsets somewhere? This duplicates irgen_size_bytes int offset = 0; for (int i = 0; i < field; i++) { const int fb = irgen_size_bytes(g, ftypes[i]); const int align = irgen_align_of(g, ftypes[i]); offset = ALIGN_UP(offset, align); offset += fb; } const int align = irgen_align_of(g, ftypes[field]); offset = ALIGN_UP(offset, align); jit_value_t rptr = irgen_get_value(g, arg0); g->map[n.id] = jit_addr_from_value(rptr, offset); } static void irgen_op_context_upref(jit_irgen_t *g, mir_value_t n) { const int hops = irgen_get_const(g, n, 0); if (hops == 0) { assert(g->statereg.kind != JIT_VALUE_INVALID); g->map[n.id] = g->statereg; } else { jit_value_t context = irgen_get_context(g); for (int i = 1; i < hops; i++) context = j_load(g, JIT_SZ_PTR, jit_addr_from_value(context, 0)); g->map[n.id] = context; } } static void irgen_op_var_upref(jit_irgen_t *g, mir_value_t n) { jit_value_t context = irgen_get_context(g); const int hops = irgen_get_const(g, n, 0); const int nth = irgen_get_const(g, n, 2); ident_t unit_name = mir_get_name(g->mu, mir_get_arg(g->mu, n, 1)); for (int i = 1; i < hops; i++) context = j_load(g, JIT_SZ_PTR, jit_addr_from_value(context, 0)); // TODO: maybe we should cache these somewhere? jit_handle_t handle = jit_lazy_compile(g->func->jit, unit_name); jit_func_t *cf = jit_get_func(g->func->jit, handle); // Handle potential circular dependency // TODO: it would be better to avoid this entirely const link_tab_t *tab = load_acquire(&(cf->linktab)); if (tab == NULL) { jit_fill_irbuf(cf); tab = load_acquire(&(cf->linktab)); assert(tab); } assert(nth < cf->nvars); const int offset = tab[nth].offset; g->map[n.id] = jit_addr_from_value(context, offset); } static void irgen_op_cast(jit_irgen_t *g, mir_value_t n) { mir_value_t arg = mir_get_arg(g->mu, n, 0); mir_type_t result_type = mir_get_type(g->mu, n); mir_class_t result_kind = mir_get_class(g->mu, result_type); if (result_kind == MIR_TYPE_REAL && mir_is_integral(g->mu, arg)) g->map[n.id] = j_scvtf(g, irgen_get_value(g, arg)); else if (result_kind == MIR_TYPE_INT && mir_is(g->mu, arg, MIR_TYPE_REAL)) g->map[n.id] = j_fcvtns(g, irgen_get_value(g, arg)); else if ((result_kind == MIR_TYPE_INT || result_kind == MIR_TYPE_OFFSET) && mir_is_integral(g->mu, arg)) { // No sign extension or truncation is necessary as integer // registers are always 64 bits wide g->map[n.id] = irgen_get_value(g, arg); } else if (result_kind == MIR_TYPE_REAL) { // Reals are always represented with IEEE doubles assert(mir_is(g->mu, arg, MIR_TYPE_REAL)); g->map[n.id] = irgen_get_value(g, arg); } else if (result_kind == MIR_TYPE_ACCESS) { // Casting away opaqueness assert(mir_is(g->mu, arg, MIR_TYPE_ACCESS)); g->map[n.id] = irgen_get_value(g, arg); } else if (result_kind == MIR_TYPE_VEC4) { mir_type_t arg_type = mir_get_type(g->mu, arg); jit_value_t abits = irgen_get_value(g, arg), bbits; if (mir_get_class(g->mu, arg_type) == MIR_TYPE_VEC4) bbits = jit_value_from_reg(jit_value_as_reg(abits) + 1); else bbits = jit_value_from_int64(0); const int result_size = mir_get_size(g->mu, result_type); const int arg_size = mir_get_size(g->mu, arg_type); assert(result_size <= 64); // TODO assert(arg_size <= 64); // TODO if (result_size < arg_size) { uint64_t mask = ~UINT64_C(0); if (result_size < 64) mask >>= 64 - result_size; g->map[n.id] = j_and(g, abits, jit_value_from_int64(mask)); j_and(g, bbits, jit_value_from_int64(mask)); } else if (bbits.kind != JIT_VALUE_REG) { jit_reg_t areg = irgen_alloc_reg(g), breg = irgen_alloc_reg(g); j_mov(g, areg, abits); j_mov(g, breg, bbits); g->map[n.id] = jit_value_from_reg(areg); } else g->map[n.id] = abits; // No-op (TODO: sign extend) } else if (result_kind == MIR_TYPE_VEC2 && mir_is(g->mu, arg, MIR_TYPE_VEC4)) { g->map[n.id] = irgen_get_value(g, arg); // No-op (TODO: sign extend) } else if ((result_kind == MIR_TYPE_INT || result_kind == MIR_TYPE_OFFSET) && mir_is_vector(g->mu, arg)) g->map[n.id] = irgen_get_value(g, arg); // No-op (take A-bits) else { mir_dump(g->mu); fatal_trace("unhandled cast"); } } static void irgen_op_range_null(jit_irgen_t *g, mir_value_t n) { jit_value_t left = irgen_get_arg(g, n, 0); jit_value_t right = irgen_get_arg(g, n, 1); irgen_label_t *l_downto = irgen_alloc_label(g); irgen_label_t *l_after = irgen_alloc_label(g); mir_value_t arg2 = mir_get_arg(g->mu, n, 2); if (!mir_equals(arg2, g->flags)) { jit_value_t dir = irgen_get_value(g, arg2); j_cmp(g, JIT_CC_EQ, dir, jit_value_from_int64(RANGE_DOWNTO)); } j_jump(g, JIT_CC_T, l_downto); j_cmp(g, JIT_CC_GT, left, right); j_jump(g, JIT_CC_NONE, l_after); irgen_bind_label(g, l_downto); j_cmp(g, JIT_CC_GT, right, left); irgen_bind_label(g, l_after); g->map[n.id] = j_cset(g); g->flags = n; } static void irgen_op_range_length(jit_irgen_t *g, mir_value_t n) { jit_value_t left = irgen_get_arg(g, n, 0); jit_value_t right = irgen_get_arg(g, n, 1); mir_value_t arg2 = mir_get_arg(g->mu, n, 2); jit_value_t diff; int64_t dconst; if (mir_get_const(g->mu, arg2, &dconst)) { jit_value_t high = dconst == RANGE_TO ? right : left; jit_value_t low = dconst == RANGE_TO ? left : right; diff = j_sub(g, high, low); } else { irgen_label_t *l_downto = irgen_alloc_label(g); irgen_label_t *l_after = irgen_alloc_label(g); if (!mir_equals(arg2, g->flags)) { jit_value_t dir = irgen_get_value(g, arg2); j_cmp(g, JIT_CC_EQ, dir, jit_value_from_int64(RANGE_DOWNTO)); } j_jump(g, JIT_CC_T, l_downto); jit_value_t diff_up = j_sub(g, right, left); j_jump(g, JIT_CC_NONE, l_after); irgen_bind_label(g, l_downto); jit_value_t diff_down = j_sub(g, left, right); irgen_bind_label(g, l_after); diff = j_csel(g, diff_down, diff_up); } jit_value_t length = j_add(g, diff, jit_value_from_int64(1)); jit_value_t clamped = j_clamp(g, length); g->map[n.id] = clamped; } static void irgen_op_cond(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); if (!mir_equals(arg0, g->flags)) { jit_value_t test = irgen_get_value(g, arg0); j_cmp(g, JIT_CC_NE, test, jit_value_from_int64(0)); } mir_block_t t0 = mir_cast_block(mir_get_arg(g->mu, n, 1)); mir_block_t t1 = mir_cast_block(mir_get_arg(g->mu, n, 2)); if (t0.id == g->curblock.id + 1) j_jump(g, JIT_CC_F, g->blocks[t1.id]); else if (t1.id == g->curblock.id + 1) j_jump(g, JIT_CC_T, g->blocks[t0.id]); else { j_jump(g, JIT_CC_T, g->blocks[t0.id]); j_jump(g, JIT_CC_NONE, g->blocks[t1.id]); } } static void irgen_op_case(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); jit_reg_t reg = jit_value_as_reg(value); mir_block_t def = mir_cast_block(mir_get_arg(g->mu, n, 1)); const int nargs = mir_count_args(g->mu, n); for (int i = 2; i < nargs; i += 2) { jit_value_t cmp = irgen_get_arg(g, n, i); mir_block_t b = mir_cast_block(mir_get_arg(g->mu, n, i + 1)); irgen_label_t *l = g->blocks[b.id]; macro_case(g, reg, cmp, l); } j_jump(g, JIT_CC_NONE, g->blocks[def.id]); } static void irgen_op_select(jit_irgen_t *g, mir_value_t n) { jit_value_t iftrue = irgen_get_arg(g, n, 1); jit_value_t iffalse = irgen_get_arg(g, n, 2); mir_value_t arg0 = mir_get_arg(g->mu, n, 0); if (!mir_equals(arg0, g->flags)) { jit_value_t test = irgen_get_arg(g, n, 0); j_cmp(g, JIT_CC_NE, test, jit_value_from_int64(0)); } g->map[n.id] = j_csel(g, iftrue, iffalse); const int slots = irgen_slots_for_type(g, mir_get_type(g->mu, n)); for (int i = 1; i < slots; i++) { jit_value_t iftrue_i = jit_value_from_reg(jit_value_as_reg(iftrue) + i); jit_value_t iffalse_i = jit_value_from_reg(jit_value_as_reg(iffalse) + i); j_csel(g, iftrue_i, iffalse_i); } } static void irgen_op_jump(jit_irgen_t *g, mir_value_t n) { mir_block_t target = mir_cast_block(mir_get_arg(g->mu, n, 0)); j_jump(g, JIT_CC_NONE, g->blocks[target.id]); } static void irgen_op_fcall(jit_irgen_t *g, mir_value_t n) { irgen_emit_debuginfo(g, n); // For stack traces mir_type_t rtype = mir_get_type(g->mu, n); if (mir_is_null(rtype)) { // Must call using procedure calling convention j_send(g, 0, jit_value_from_int64(0)); irgen_send_args(g, n, 1); } else irgen_send_args(g, n, 0); j_call(g, irgen_get_handle(g, n, 0)); if (!mir_is_null(rtype)) { const int slots = irgen_slots_for_type(g, rtype); g->map[n.id] = j_recv(g, 0); for (int i = 1; i < slots; i++) j_recv(g, i); // Must be contiguous registers const mir_class_t rclass = mir_get_class(g->mu, rtype); g->used_tlab |= rclass == MIR_TYPE_UARRAY || rclass == MIR_TYPE_POINTER; } else { irgen_label_t *cont = irgen_alloc_label(g); jit_value_t state = j_recv(g, 0); j_cmp(g, JIT_CC_EQ, state, jit_null_ptr()); j_jump(g, JIT_CC_T, cont); macro_exit(g, JIT_EXIT_FUNC_WAIT); irgen_bind_label(g, cont); } } static void irgen_op_syscall(jit_irgen_t *g, mir_value_t n) { irgen_emit_debuginfo(g, n); // For stack traces irgen_send_args(g, n, 0); macro_exit(g, JIT_EXIT_SYSCALL); mir_type_t rtype = mir_get_type(g->mu, n); if (!mir_is_null(rtype)) { const int slots = irgen_slots_for_type(g, rtype); g->map[n.id] = j_recv(g, 0); for (int i = 1; i < slots; i++) j_recv(g, i); // Must be contiguous registers } } static void irgen_pcall_suspend(jit_irgen_t *g, jit_value_t state, irgen_label_t *cont) { jit_value_t pcall_ptr = irgen_pcall_ptr(g); j_store(g, JIT_SZ_PTR, state, pcall_ptr); j_cmp(g, JIT_CC_EQ, state, jit_null_ptr()); j_jump(g, JIT_CC_T, cont); j_send(g, 0, g->statereg); j_ret(g); } static void irgen_op_pcall(jit_irgen_t *g, mir_value_t n) { irgen_emit_debuginfo(g, n); // For stack traces // First argument to procedure is suspended state j_send(g, 0, jit_value_from_int64(0)); irgen_send_args(g, n, 1); jit_handle_t handle = irgen_get_handle(g, n, 1); j_call(g, handle); irgen_label_t *cont = irgen_alloc_label(g); jit_value_t state = j_recv(g, 0); mir_block_t resume = mir_cast_block(mir_get_arg(g->mu, n, 0)); jit_value_t state_ptr = irgen_state_ptr(g); j_store(g, JIT_SZ_32, jit_value_from_int64(resume.id), state_ptr); irgen_pcall_suspend(g, state, cont); irgen_bind_label(g, cont); j_jump(g, JIT_CC_NONE, g->blocks[resume.id]); } static void irgen_op_resume(jit_irgen_t *g, mir_value_t n) { jit_value_t old_state = j_load(g, JIT_SZ_PTR, irgen_pcall_ptr(g)); irgen_label_t *cont = irgen_alloc_label(g); j_cmp(g, JIT_CC_EQ, old_state, jit_null_ptr()); j_jump(g, JIT_CC_T, cont); jit_handle_t handle = irgen_get_handle(g, n, 0); j_send(g, 0, old_state); j_call(g, handle); jit_value_t new_state = j_recv(g, 0); irgen_pcall_suspend(g, new_state, cont); irgen_bind_label(g, cont); } static void irgen_op_wait(jit_irgen_t *g, mir_value_t n) { if (mir_count_args(g->mu, n) > 1) { jit_value_t after = irgen_get_arg(g, n, 1); j_send(g, 0, after); macro_exit(g, JIT_EXIT_SCHED_PROCESS); } if (g->statereg.kind != JIT_VALUE_INVALID) { mir_block_t target = mir_cast_block(mir_get_arg(g->mu, n, 0)); jit_value_t ptr = irgen_state_ptr(g); j_store(g, JIT_SZ_32, jit_value_from_int64(target.id), ptr); } if (mir_get_kind(g->mu) == MIR_UNIT_PROCEDURE) j_send(g, 0, g->statereg); else j_send(g, 0, jit_value_from_int64(0)); j_ret(g); } static void irgen_op_protected_init(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); irgen_send_args(g, n, 0); j_call(g, handle); g->map[n.id] = j_recv(g, 0); } static void irgen_op_reflect_value(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); jit_value_t context = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); j_send(g, 0, context); j_send(g, 1, value); j_send(g, 2, locus); if (mir_count_args(g->mu, n) > 3) { mir_value_t bounds = mir_get_arg(g->mu, n, 3); const int slots = irgen_slots_for_type(g, mir_get_type(g->mu, bounds)); if (slots > 1) { jit_reg_t base = jit_value_as_reg(irgen_get_value(g, bounds)); for (int j = 0; j < slots; j++) j_send(g, j + 3, jit_value_from_reg(base + j)); } else j_send(g, 3, irgen_get_value(g, bounds)); } else j_send(g, 3, value); macro_exit(g, JIT_EXIT_REFLECT_VALUE); g->map[n.id] = j_recv(g, 0); } static void irgen_op_reflect_subtype(jit_irgen_t *g, mir_value_t n) { jit_value_t context = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); j_send(g, 0, context); j_send(g, 1, locus); if (mir_count_args(g->mu, n) > 2) { mir_value_t bounds = mir_get_arg(g->mu, n, 2); const int slots = irgen_slots_for_type(g, mir_get_type(g->mu, bounds)); if (slots > 1) { jit_reg_t base = jit_value_as_reg(irgen_get_value(g, bounds)); for (int j = 0; j < slots; j++) j_send(g, j + 2, jit_value_from_reg(base + j)); } else j_send(g, 2, irgen_get_value(g, bounds)); } macro_exit(g, JIT_EXIT_REFLECT_SUBTYPE); g->map[n.id] = j_recv(g, 0); } static void irgen_op_process_init(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); j_send(g, 0, jit_value_from_handle(handle)); j_send(g, 1, locus); macro_exit(g, JIT_EXIT_PROCESS_INIT); } static void irgen_op_index_check(jit_irgen_t *g, mir_value_t n) { mir_value_t arg3 = mir_get_arg(g->mu, n, 3); jit_value_t value = irgen_get_arg(g, n, 0); jit_value_t left = irgen_get_arg(g, n, 1); jit_value_t right = irgen_get_arg(g, n, 2); jit_value_t dir = irgen_get_value(g, arg3); jit_value_t locus = irgen_get_arg(g, n, 4); jit_value_t hint = irgen_get_arg(g, n, 5); if (!mir_equals(arg3, g->flags)) j_cmp(g, JIT_CC_EQ, dir, jit_value_from_int64(RANGE_DOWNTO)); jit_value_t low = j_csel(g, right, left); jit_value_t high = j_csel(g, left, right); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_GE, value, low); j_ccmp(g, JIT_CC_LE, value, high); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, value); j_send(g, 1, left); j_send(g, 2, right); j_send(g, 3, dir); j_send(g, 4, locus); j_send(g, 5, hint); macro_exit(g, JIT_EXIT_INDEX_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_dir_check(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); jit_value_t dir = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_EQ, value, dir); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, value); j_send(g, 1, dir); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_DIR_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_range_check(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); mir_value_t arg3 = mir_get_arg(g->mu, n, 3); jit_value_t value = irgen_get_value(g, arg0); jit_value_t left = irgen_get_arg(g, n, 1); jit_value_t right = irgen_get_arg(g, n, 2); jit_value_t dir = irgen_get_value(g, arg3); jit_value_t locus = irgen_get_arg(g, n, 4); jit_value_t hint = irgen_get_arg(g, n, 5); if (!mir_equals(arg3, g->flags)) j_cmp(g, JIT_CC_EQ, dir, jit_value_from_int64(RANGE_DOWNTO)); jit_value_t low = j_csel(g, right, left); jit_value_t high = j_csel(g, left, right); irgen_label_t *l_fail = irgen_alloc_label(g); irgen_label_t *l_pass = irgen_alloc_label(g); if (mir_is(g->mu, arg0, MIR_TYPE_REAL)) { j_fcmp(g, JIT_CC_GE, value, low); j_fccmp(g, JIT_CC_LE, value, high); j_jump(g, JIT_CC_T, l_pass); } else { j_cmp(g, JIT_CC_GE, value, low); j_ccmp(g, JIT_CC_LE, value, high); j_jump(g, JIT_CC_T, l_pass); } irgen_bind_label(g, l_fail); j_send(g, 0, value); j_send(g, 1, left); j_send(g, 2, right); j_send(g, 3, dir); j_send(g, 4, locus); j_send(g, 5, hint); macro_exit(g, JIT_EXIT_RANGE_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_null_check(jit_irgen_t *g, mir_value_t n) { jit_value_t ptr = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_NE, ptr, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, locus); macro_exit(g, JIT_EXIT_NULL_DEREF); irgen_bind_label(g, l_pass); } static void irgen_op_zero_check(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_NE, value, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, locus); macro_exit(g, JIT_EXIT_DIV_ZERO); irgen_bind_label(g, l_pass); } static void irgen_op_exponent_check(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_GE, value, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, value); j_send(g, 1, locus); macro_exit(g, JIT_EXIT_EXPONENT_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_length_check(jit_irgen_t *g, mir_value_t n) { jit_value_t llen = irgen_get_arg(g, n, 0); jit_value_t rlen = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); // TODO: why isn't this encoded with an enum? jit_value_t dim; if (mir_count_args(g->mu, n) > 3) dim = irgen_get_arg(g, n, 3); else dim = jit_value_from_int64(0); irgen_label_t *l_pass = irgen_alloc_label(g); j_cmp(g, JIT_CC_EQ, llen, rlen); j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, llen); j_send(g, 1, rlen); j_send(g, 2, dim); j_send(g, 3, locus); macro_exit(g, JIT_EXIT_LENGTH_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_package_init(jit_irgen_t *g, mir_value_t n) { if (mir_count_args(g->mu, n) > 1) j_send(g, 0, irgen_get_arg(g, n, 1)); else j_send(g, 0, jit_value_from_int64(0)); j_call(g, irgen_get_handle(g, n, 0)); g->map[n.id] = j_recv(g, 0); } static void irgen_op_link_package(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); g->map[n.id] = macro_getpriv(g, handle); } static void irgen_op_link_var(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); jit_value_t context = irgen_get_arg(g, n, 1); ident_t var_name = mir_get_name(g->mu, mir_get_arg(g->mu, n, 2)); jit_func_t *f = jit_get_func(g->func->jit, handle); jit_fill_irbuf(f); link_tab_t *tab = f->linktab; for (; tab < f->linktab + f->nvars; tab++) { if (tab->name == var_name) break; } if (tab == f->linktab + f->nvars) { mir_dump(g->mu); fatal_trace("variable %s not found in unit %s", istr(var_name), istr(f->name)); } g->map[n.id] = jit_addr_from_value(context, tab->offset); } static void irgen_op_new(jit_irgen_t *g, mir_value_t n) { mir_type_t elem = mir_get_elem(g->mu, mir_get_type(g->mu, n)); int headersz = 0; if (mir_get_class(g->mu, elem) == MIR_TYPE_UARRAY) { headersz = irgen_size_bytes(g, elem); elem = mir_get_elem(g->mu, elem); } jit_value_t bytes = jit_value_from_int64(irgen_size_bytes(g, elem)); irgen_emit_debuginfo(g, n); // For out-of-memory stack traces if (mir_count_args(g->mu, n) > 0) bytes = j_mul(g, bytes, irgen_get_arg(g, n, 0)); if (headersz > 0) bytes = j_add(g, bytes, jit_value_from_int64(headersz)); jit_value_t mem = macro_galloc(g, bytes); g->map[n.id] = mem; if (headersz > 0) { // Initialise the header to point at the body jit_value_t ptr = jit_addr_from_value(mem, 0); jit_value_t body = j_add(g, mem, jit_value_from_int64(headersz)); j_store(g, JIT_SZ_PTR, body, ptr); } } static void irgen_op_alloc(jit_irgen_t *g, mir_value_t n) { mir_type_t type = mir_get_pointer(g->mu, mir_get_type(g->mu, n)); const int bytes = irgen_size_bytes(g, type); jit_value_t count = irgen_get_arg(g, n, 0); jit_value_t total = j_mul(g, count, jit_value_from_int64(bytes)); g->map[n.id] = macro_lalloc(g, total); g->used_tlab = true; } static void irgen_op_all(jit_irgen_t *g, mir_value_t n) { jit_value_t arg = irgen_get_arg(g, n, 0); g->map[n.id] = jit_addr_from_value(arg, 0); } static void irgen_op_closure(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); jit_reg_t base = irgen_alloc_reg(g); j_mov(g, base, jit_value_from_handle(handle)); jit_reg_t context = irgen_alloc_reg(g); j_mov(g, context, irgen_get_arg(g, n, 1)); g->map[n.id] = jit_value_from_reg(base); } static void irgen_op_resolution_wrapper(jit_irgen_t *g, mir_value_t n) { jit_value_t closure = irgen_get_arg(g, n, 0); jit_reg_t base = irgen_alloc_reg(g); j_mov(g, base, closure); jit_reg_t context = irgen_alloc_reg(g); j_mov(g, context, jit_value_from_reg(jit_value_as_reg(closure) + 1)); jit_reg_t nlits = irgen_alloc_reg(g); j_mov(g, nlits, irgen_get_arg(g, n, 1)); mir_type_t type = mir_get_base(g->mu, mir_get_type(g->mu, n)); uint32_t flagbits = 0; if (mir_get_class(g->mu, type) == MIR_TYPE_POINTER) flagbits |= R_COMPOSITE; jit_reg_t flags = irgen_alloc_reg(g); j_mov(g, flags, jit_value_from_int64(flagbits)); g->map[n.id] = jit_value_from_reg(base); } static void irgen_op_init_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t count = irgen_get_arg(g, n, 0); jit_value_t size = irgen_get_arg(g, n, 1); jit_value_t value = irgen_get_arg(g, n, 2); jit_value_t flags = irgen_get_arg(g, n, 3); jit_value_t locus = irgen_get_arg(g, n, 4); jit_value_t offset; if (mir_count_args(g->mu, n) > 5) offset = irgen_get_arg(g, n, 5); else offset = jit_value_from_int64(0); jit_value_t scalar = irgen_is_scalar(g, n, 2); j_send(g, 0, count); j_send(g, 1, size); j_send(g, 2, value); j_send(g, 3, flags); j_send(g, 4, locus); j_send(g, 5, offset); j_send(g, 6, scalar); macro_exit(g, JIT_EXIT_INIT_SIGNAL); g->map[n.id] = j_recv(g, 0); // Offset into signal must be next sequential register jit_reg_t next = irgen_alloc_reg(g); j_mov(g, next, jit_value_from_int64(0)); } static void irgen_op_implicit_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t count = irgen_get_arg(g, n, 0); jit_value_t size = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 2); jit_value_t kind = irgen_get_arg(g, n, 3); jit_value_t closure = irgen_get_arg(g, n, 4); jit_value_t context = jit_value_from_reg(jit_value_as_reg(closure) + 1); jit_value_t delay = irgen_get_arg(g, n, 5); j_send(g, 0, count); j_send(g, 1, size); j_send(g, 2, locus); j_send(g, 3, kind); j_send(g, 4, closure); j_send(g, 5, context); j_send(g, 6, delay); macro_exit(g, JIT_EXIT_IMPLICIT_SIGNAL); g->map[n.id] = j_recv(g, 0); // Offset into signal must be next sequential register jit_reg_t next = irgen_alloc_reg(g); j_mov(g, next, jit_value_from_int64(0)); } static void irgen_op_alias_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t locus = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, locus); macro_exit(g, JIT_EXIT_ALIAS_SIGNAL); } static void irgen_op_map_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t src_ss = irgen_get_arg(g, n, 0); jit_value_t src_off = jit_value_from_reg(jit_value_as_reg(src_ss) + 1); jit_value_t dst_ss = irgen_get_arg(g, n, 1); jit_value_t dst_off = jit_value_from_reg(jit_value_as_reg(dst_ss) + 1); jit_value_t count = irgen_get_arg(g, n, 2); j_send(g, 0, src_ss); j_send(g, 1, src_off); j_send(g, 2, dst_ss); j_send(g, 3, dst_off); j_send(g, 4, count); macro_exit(g, JIT_EXIT_MAP_SIGNAL); } static void irgen_op_map_const(jit_irgen_t *g, mir_value_t n) { jit_value_t initval = irgen_get_arg(g, n, 0); jit_value_t dst_ss = irgen_get_arg(g, n, 1); jit_value_t dst_off = jit_value_from_reg(jit_value_as_reg(dst_ss) + 1); jit_value_t dst_count = irgen_get_arg(g, n, 2); jit_value_t scalar = irgen_is_scalar(g, n, 0); j_send(g, 0, dst_ss); j_send(g, 1, dst_off); j_send(g, 2, initval); j_send(g, 3, dst_count); j_send(g, 4, scalar); macro_exit(g, JIT_EXIT_MAP_CONST); } static void irgen_op_map_implicit(jit_irgen_t *g, mir_value_t n) { jit_value_t src_ss = irgen_get_arg(g, n, 0); jit_value_t src_off = jit_value_from_reg(jit_value_as_reg(src_ss) + 1); jit_value_t dst_ss = irgen_get_arg(g, n, 1); jit_value_t dst_off = jit_value_from_reg(jit_value_as_reg(dst_ss) + 1); jit_value_t count = irgen_get_arg(g, n, 2); j_send(g, 0, src_ss); j_send(g, 1, src_off); j_send(g, 2, dst_ss); j_send(g, 3, dst_off); j_send(g, 4, count); macro_exit(g, JIT_EXIT_MAP_IMPLICIT); } static void irgen_op_resolve_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t resfn = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, resfn); macro_exit(g, JIT_EXIT_RESOLVE_SIGNAL); } static void irgen_op_unreachable(jit_irgen_t *g, mir_value_t n) { jit_value_t locus; if (mir_count_args(g->mu, n) > 0) locus = irgen_get_arg(g, n, 0); else locus = jit_value_from_int64(0); j_send(g, 0, locus); macro_exit(g, JIT_EXIT_UNREACHABLE); } static void irgen_op_report(jit_irgen_t *g, mir_value_t n) { jit_value_t severity = irgen_get_arg(g, n, 0); jit_value_t msg = irgen_get_arg(g, n, 1); jit_value_t length = irgen_get_arg(g, n, 2); jit_value_t locus = irgen_get_arg(g, n, 3); j_send(g, 0, msg); j_send(g, 1, length); j_send(g, 2, severity); j_send(g, 3, locus); macro_exit(g, JIT_EXIT_REPORT); } static void irgen_op_assert(jit_irgen_t *g, mir_value_t n) { jit_value_t severity = irgen_get_arg(g, n, 1); jit_value_t locus = irgen_get_arg(g, n, 4); // TODO: having null arguments sucks - why not have optional args? jit_value_t msg = jit_value_from_int64(0); jit_value_t length = jit_value_from_int64(0); if (!mir_is_null(mir_get_arg(g->mu, n, 2))) { msg = irgen_get_arg(g, n, 2); length = irgen_get_arg(g, n, 3); } jit_value_t hint_left, hint_right, hint_valid; if (mir_count_args(g->mu, n) > 5) { hint_left = irgen_get_arg(g, n, 5); hint_right = irgen_get_arg(g, n, 6); hint_valid = jit_value_from_int64(true); } else { hint_left = hint_right = jit_value_from_int64(0); hint_valid = jit_value_from_int64(false); } irgen_label_t *l_pass = irgen_alloc_label(g); mir_value_t arg0 = mir_get_arg(g->mu, n, 0); if (!mir_equals(arg0, g->flags)) { jit_value_t test = irgen_get_value(g, arg0); j_cmp(g, JIT_CC_NE, test, jit_value_from_int64(0)); } j_jump(g, JIT_CC_T, l_pass); j_send(g, 0, msg); j_send(g, 1, length); j_send(g, 2, severity); j_send(g, 3, hint_left); j_send(g, 4, hint_right); j_send(g, 5, hint_valid); j_send(g, 6, locus); macro_exit(g, JIT_EXIT_ASSERT_FAIL); irgen_bind_label(g, l_pass); } static void irgen_op_file_open(jit_irgen_t *g, mir_value_t n) { jit_value_t file = irgen_get_arg(g, n, 0); jit_value_t name = irgen_get_arg(g, n, 1); jit_value_t length = irgen_get_arg(g, n, 2); jit_value_t kind = irgen_get_arg(g, n, 3); irgen_emit_debuginfo(g, n); // For stack traces jit_value_t status = jit_null_ptr(); if (mir_count_args(g->mu, n) == 5) status = irgen_get_arg(g, n, 4); j_send(g, 0, status); j_send(g, 1, file); j_send(g, 2, name); j_send(g, 3, length); j_send(g, 4, kind); macro_exit(g, JIT_EXIT_FILE_OPEN); } static void irgen_op_file_read(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); mir_value_t arg1 = mir_get_arg(g->mu, n, 1); jit_value_t file = irgen_get_value(g, arg0); jit_value_t ptr = irgen_get_value(g, arg1); jit_value_t count = jit_value_from_int64(1); if (mir_count_args(g->mu, n) >= 3) count = irgen_get_arg(g, n, 2); mir_type_t file_type = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); assert(mir_get_class(g->mu, file_type) == MIR_TYPE_FILE); mir_type_t elem_type = mir_get_base(g->mu, file_type); switch (mir_get_class(g->mu, elem_type)) { case MIR_TYPE_UARRAY: case MIR_TYPE_CARRAY: elem_type = mir_get_elem(g->mu, elem_type); break; default: break; } jit_value_t size = jit_value_from_int64(irgen_size_bytes(g, elem_type)); j_send(g, 0, file); j_send(g, 1, ptr); j_send(g, 2, size); j_send(g, 3, count); macro_exit(g, JIT_EXIT_FILE_READ); if (mir_count_args(g->mu, n) >= 4) { mir_value_t arg3 = mir_get_arg(g->mu, n, 3); mir_type_t out_type = mir_get_elem(g->mu, mir_get_type(g->mu, arg3)); jit_size_t out_size = irgen_jit_size(g, out_type); jit_value_t outarg = irgen_get_value(g, arg3); jit_value_t outptr = jit_addr_from_value(outarg, 0); jit_value_t len = j_recv(g, 0); j_store(g, out_size, len, outptr); } } static void irgen_op_file_write(jit_irgen_t *g, mir_value_t n) { mir_value_t arg0 = mir_get_arg(g->mu, n, 0); mir_value_t arg1 = mir_get_arg(g->mu, n, 1); jit_value_t file = irgen_get_value(g, arg0); jit_value_t data = irgen_get_value(g, arg1); jit_value_t count; if (mir_count_args(g->mu, n) > 2) count = irgen_get_arg(g, n, 2); else count = jit_value_from_int64(1); mir_type_t file_type = mir_get_elem(g->mu, mir_get_type(g->mu, arg0)); assert(mir_get_class(g->mu, file_type) == MIR_TYPE_FILE); mir_type_t elem_type = mir_get_base(g->mu, file_type); switch (mir_get_class(g->mu, elem_type)) { case MIR_TYPE_UARRAY: case MIR_TYPE_CARRAY: elem_type = mir_get_elem(g->mu, elem_type); break; default: break; } jit_value_t bytes = jit_value_from_int64(irgen_size_bytes(g, elem_type)); jit_value_t scalar = jit_value_from_int64(mir_is_numeric(g->mu, arg1)); j_send(g, 0, file); j_send(g, 1, data); j_send(g, 2, bytes); j_send(g, 3, count); j_send(g, 4, scalar); macro_exit(g, JIT_EXIT_FILE_WRITE); } static void irgen_op_package_scope(jit_irgen_t *g, mir_value_t n) { jit_value_t locus = irgen_get_arg(g, n, 0); j_send(g, 0, locus); j_send(g, 2, jit_value_from_int64(0)); j_send(g, 2, jit_value_from_int64(SCOPE_PACKAGE)); macro_exit(g, JIT_EXIT_PUSH_SCOPE); } static void irgen_op_array_scope(jit_irgen_t *g, mir_value_t n) { jit_value_t locus = irgen_get_arg(g, n, 0); j_send(g, 0, locus); const int size = irgen_size_bytes(g, mir_get_type(g->mu, n)); j_send(g, 1, jit_value_from_int64(size)); j_send(g, 2, jit_value_from_int64(SCOPE_ARRAY)); macro_exit(g, JIT_EXIT_PUSH_SCOPE); } static void irgen_op_record_scope(jit_irgen_t *g, mir_value_t n) { jit_value_t locus = irgen_get_arg(g, n, 0); j_send(g, 0, locus); const int size = irgen_size_bytes(g, mir_get_type(g->mu, n)); j_send(g, 1, jit_value_from_int64(size)); j_send(g, 2, jit_value_from_int64(SCOPE_RECORD)); macro_exit(g, JIT_EXIT_PUSH_SCOPE); } static void irgen_op_pop_scope(jit_irgen_t *g, mir_value_t n) { macro_exit(g, JIT_EXIT_POP_SCOPE); } static void irgen_op_drive_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_DRIVE_SIGNAL); } static void irgen_op_transfer_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t target = irgen_get_arg(g, n, 0); jit_value_t toffset = jit_value_from_reg(jit_value_as_reg(target) + 1); jit_value_t source = irgen_get_arg(g, n, 1); jit_value_t soffset = jit_value_from_reg(jit_value_as_reg(source) + 1); jit_value_t count = irgen_get_arg(g, n, 2); jit_value_t reject = irgen_get_arg(g, n, 3); jit_value_t after = irgen_get_arg(g, n, 4); j_send(g, 0, target); j_send(g, 1, toffset); j_send(g, 2, source); j_send(g, 3, soffset); j_send(g, 4, count); j_send(g, 5, after); j_send(g, 6, reject); macro_exit(g, JIT_EXIT_TRANSFER_SIGNAL); } static void irgen_op_resolved(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t data_ptr = irgen_lea(g, jit_addr_from_value(shared, 8)); mir_type_t type = mir_get_pointer(g->mu, mir_get_type(g->mu, n)); const int scale = irgen_size_bytes(g, type); jit_value_t scaled = j_mul(g, offset, jit_value_from_int64(scale)); g->map[n.id] = j_add(g, data_ptr, scaled); } static void irgen_op_last_value(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t data_ptr = irgen_lea(g, jit_addr_from_value(shared, 8)); jit_value_t size = j_load(g, JIT_SZ_32, jit_addr_from_value(shared, 0)); jit_value_t last_value = j_add(g, data_ptr, size); mir_type_t type = mir_get_elem(g->mu, mir_get_type(g->mu, n)); const int scale = irgen_size_bytes(g, type); jit_value_t scaled = j_mul(g, offset, jit_value_from_int64(scale)); g->map[n.id] = j_add(g, last_value, scaled); } static void irgen_op_sched_waveform(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); jit_value_t value = irgen_get_arg(g, n, 2); jit_value_t reject = irgen_get_arg(g, n, 3); jit_value_t after = irgen_get_arg(g, n, 4); jit_value_t scalar = irgen_is_scalar(g, n, 2); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); j_send(g, 3, value); j_send(g, 4, after); j_send(g, 5, reject); j_send(g, 6, scalar); macro_exit(g, JIT_EXIT_SCHED_WAVEFORM); } static void irgen_op_disconnect(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); jit_value_t reject = irgen_get_arg(g, n, 2); jit_value_t after = irgen_get_arg(g, n, 3); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); j_send(g, 3, reject); j_send(g, 4, after); macro_exit(g, JIT_EXIT_DISCONNECT); } static void irgen_op_force(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); jit_value_t value = irgen_get_arg(g, n, 2); jit_value_t scalar = irgen_is_scalar(g, n, 2); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); j_send(g, 3, value); j_send(g, 4, scalar); macro_exit(g, JIT_EXIT_FORCE); } static void irgen_op_release(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_RELEASE); } static void irgen_op_deposit_signal(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); jit_value_t value = irgen_get_arg(g, n, 2); jit_value_t scalar = irgen_is_scalar(g, n, 2); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); j_send(g, 3, value); j_send(g, 4, scalar); macro_exit(g, JIT_EXIT_DEPOSIT_SIGNAL); } static void irgen_op_put_conversion(jit_irgen_t *g, mir_value_t n) { jit_value_t cf = irgen_get_arg(g, n, 0); jit_value_t shared = irgen_get_arg(g, n, 1); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 2); jit_value_t value = irgen_get_arg(g, n, 3); jit_value_t scalar = irgen_is_scalar(g, n, 3); j_send(g, 0, cf); j_send(g, 1, shared); j_send(g, 2, offset); j_send(g, 3, count); j_send(g, 4, value); j_send(g, 5, scalar); macro_exit(g, JIT_EXIT_PUT_CONVERSION); } static void irgen_op_sched_event(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_SCHED_EVENT); } static void irgen_op_clear_event(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_CLEAR_EVENT); } static void irgen_op_event(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); jit_value_t flags = j_load(g, JIT_SZ_32, jit_addr_from_value(shared, 4)); jit_value_t cachebit = jit_value_from_int64(SIG_F_CACHE_EVENT); jit_value_t cacheflag = j_and(g, flags, cachebit); irgen_label_t *l_slow = irgen_alloc_label(g); irgen_label_t *l_cont = irgen_alloc_label(g); j_cmp(g, JIT_CC_EQ, cacheflag, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, l_slow); jit_value_t eventbit = jit_value_from_int64(SIG_F_EVENT_FLAG); jit_value_t eventflag = j_and(g, flags, eventbit); jit_value_t shift = jit_value_from_int64(ilog2(SIG_F_EVENT_FLAG)); jit_value_t result = j_asr(g, eventflag, shift); g->map[n.id] = result; j_jump(g, JIT_CC_NONE, l_cont); irgen_bind_label(g, l_slow); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_TEST_EVENT); jit_value_t retval = j_recv(g, 0); j_mov(g, jit_value_as_reg(result), retval); irgen_bind_label(g, l_cont); } static void irgen_op_active(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_TEST_ACTIVE); g->map[n.id] = j_recv(g, 0); } static void irgen_op_debug_out(jit_irgen_t *g, mir_value_t n) { jit_value_t value = irgen_get_arg(g, n, 0); j_send(g, 0, value); macro_exit(g, JIT_EXIT_DEBUG_OUT); } static void irgen_op_last_event(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count; if (mir_count_args(g->mu, n) > 1) count = irgen_get_arg(g, n, 1); else count = jit_value_from_int64(1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_LAST_EVENT); g->map[n.id] = j_recv(g, 0); } static void irgen_op_last_active(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count; if (mir_count_args(g->mu, n) > 1) count = irgen_get_arg(g, n, 1); else count = jit_value_from_int64(1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_LAST_ACTIVE); g->map[n.id] = j_recv(g, 0); } static void irgen_op_driving(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_DRIVING); g->map[n.id] = j_recv(g, 0); } static void irgen_op_driving_value(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count; if (mir_count_args(g->mu, n) > 1) count = irgen_get_arg(g, n, 1); else count = jit_value_from_int64(1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, count); macro_exit(g, JIT_EXIT_DRIVING_VALUE); g->map[n.id] = j_recv(g, 0); } static void irgen_op_cover_increment(jit_irgen_t *g, mir_value_t n) { uint32_t tag = irgen_get_const(g, n, 0); jit_value_t mem = jit_addr_from_cover_tag(tag); macro_sadd(g, JIT_SZ_32, mem, jit_value_from_int64(1)); } static void irgen_op_cover_toggle(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); uint32_t tag = irgen_get_const(g, n, 1); j_send(g, 0, shared); j_send(g, 1, jit_value_from_int64(tag)); macro_exit(g, JIT_EXIT_COVER_TOGGLE); } static void irgen_op_cover_state(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t low = irgen_get_arg(g, n, 1); uint32_t tag = irgen_get_const(g, n, 2); j_send(g, 0, shared); j_send(g, 1, low); j_send(g, 2, jit_value_from_int64(tag)); macro_exit(g, JIT_EXIT_COVER_STATE); } static void irgen_op_enter_state(jit_irgen_t *g, mir_value_t n) { jit_value_t state = irgen_get_arg(g, n, 0); jit_value_t strong; if (mir_count_args(g->mu, n) > 1) strong = irgen_get_arg(g, n, 1); else strong = jit_value_from_int64(0); j_send(g, 0, state); j_send(g, 1, strong); macro_exit(g, JIT_EXIT_ENTER_STATE); } static void irgen_op_function_trigger(jit_irgen_t *g, mir_value_t n) { jit_handle_t handle = irgen_get_handle(g, n, 0); const int nargs = mir_count_args(g->mu, n); int nslots = 0; for (int i = 1; i < nargs; i++) { mir_type_t type = mir_get_type(g->mu, mir_get_arg(g->mu, n, i)); nslots += irgen_slots_for_type(g, type); } j_send(g, 0, jit_value_from_handle(handle)); j_send(g, 1, jit_value_from_int64(nslots)); irgen_send_args(g, n, 2); macro_exit(g, JIT_EXIT_FUNCTION_TRIGGER); g->map[n.id] = j_recv(g, 0); } static void irgen_op_or_trigger(jit_irgen_t *g, mir_value_t n) { jit_value_t left = irgen_get_arg(g, n, 0); jit_value_t right = irgen_get_arg(g, n, 1); j_send(g, 0, left); j_send(g, 1, right); macro_exit(g, JIT_EXIT_OR_TRIGGER); g->map[n.id] = j_recv(g, 0); } static void irgen_op_cmp_trigger(jit_irgen_t *g, mir_value_t n) { jit_value_t shared = irgen_get_arg(g, n, 0); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t right = irgen_get_arg(g, n, 1); j_send(g, 0, shared); j_send(g, 1, offset); j_send(g, 2, right); macro_exit(g, JIT_EXIT_CMP_TRIGGER); g->map[n.id] = j_recv(g, 0); } static void irgen_op_add_trigger(jit_irgen_t *g, mir_value_t n) { jit_value_t trigger = irgen_get_arg(g, n, 0); j_send(g, 0, trigger); macro_exit(g, JIT_EXIT_ADD_TRIGGER); } static void irgen_op_port_conversion(jit_irgen_t *g, mir_value_t n) { jit_value_t closure1 = irgen_get_arg(g, n, 0); jit_value_t context1 = jit_value_from_reg(jit_value_as_reg(closure1) + 1); jit_value_t closure2, context2; if (mir_count_args(g->mu, n) > 1) { closure2 = irgen_get_arg(g, n, 1); context2 = jit_value_from_reg(jit_value_as_reg(closure2) + 1); } else { closure2 = jit_value_from_handle(JIT_HANDLE_INVALID); context2 = jit_value_from_int64(0); } j_send(g, 0, closure1); j_send(g, 1, context1); j_send(g, 2, closure2); j_send(g, 3, context2); macro_exit(g, JIT_EXIT_PORT_CONVERSION); g->map[n.id] = j_recv(g, 0); } static void irgen_op_convert_in(jit_irgen_t *g, mir_value_t n) { jit_value_t conv = irgen_get_arg(g, n, 0); jit_value_t shared = irgen_get_arg(g, n, 1); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 2); j_send(g, 0, conv); j_send(g, 1, shared); j_send(g, 2, offset); j_send(g, 3, count); macro_exit(g, JIT_EXIT_CONVERT_IN); } static void irgen_op_convert_out(jit_irgen_t *g, mir_value_t n) { jit_value_t conv = irgen_get_arg(g, n, 0); jit_value_t shared = irgen_get_arg(g, n, 1); jit_value_t offset = jit_value_from_reg(jit_value_as_reg(shared) + 1); jit_value_t count = irgen_get_arg(g, n, 2); j_send(g, 0, conv); j_send(g, 1, shared); j_send(g, 2, offset); j_send(g, 3, count); macro_exit(g, JIT_EXIT_CONVERT_OUT); } static void irgen_op_bind_foreign(jit_irgen_t *g, mir_value_t n) { jit_value_t spec = irgen_get_arg(g, n, 0); jit_value_t length = irgen_get_arg(g, n, 1); jit_value_t locus; if (mir_count_args(g->mu, n) > 2) locus = irgen_get_arg(g, n, 2); else locus = jit_value_from_int64(0); j_send(g, 0, spec); j_send(g, 1, length); j_send(g, 2, locus); macro_exit(g, JIT_EXIT_BIND_FOREIGN); int pslot = 0; if (mir_is_null(mir_get_result(g->mu))) j_send(g, pslot++, jit_value_from_int64(0)); // Procedure state const int nparams = mir_count_params(g->mu); for (int i = 0; i < nparams; i++) { mir_value_t p = mir_get_param(g->mu, i); const int slots = irgen_slots_for_type(g, mir_get_type(g->mu, p)); if (unlikely(pslot + slots >= JIT_MAX_ARGS)) fatal("foreign subprogram %s requires more than the maximum supported " "%d arguments", istr(mir_get_name(g->mu, MIR_NULL_VALUE)), JIT_MAX_ARGS); jit_value_t r = irgen_get_value(g, p); j_send(g, pslot++, r); for (int j = 1; j < slots; j++) j_send(g, pslot++, jit_value_from_reg(jit_value_as_reg(r) + j)); } macro_reexec(g); } static void irgen_op_instance_name(jit_irgen_t *g, mir_value_t n) { irgen_send_args(g, n, 0); macro_exit(g, JIT_EXIT_INSTANCE_NAME); const int slots = irgen_slots_for_type(g, mir_get_type(g->mu, n)); g->map[n.id] = j_recv(g, 0); for (int i = 1; i < slots; i++) j_recv(g, i); } static void irgen_op_bind_external(jit_irgen_t *g, mir_value_t n) { jit_value_t locus = irgen_get_arg(g, n, 0); jit_handle_t handle = irgen_get_handle(g, n, 1); j_send(g, 0, locus); j_send(g, 1, jit_value_from_handle(handle)); macro_exit(g, JIT_EXIT_BIND_EXTERNAL); g->map[n.id] = j_recv(g, 0); } static void irgen_op_pack(jit_irgen_t *g, mir_value_t n) { assert(mir_is(g->mu, n, MIR_TYPE_VEC4)); // TODO mir_value_t arg = mir_get_arg(g->mu, n, 0); jit_value_t unpacked = irgen_get_value(g, arg); if (mir_is(g->mu, arg, MIR_TYPE_POINTER)) { const int size = mir_get_size(g->mu, mir_get_type(g->mu, n)); macro_pack(g, unpacked, jit_value_from_int64(size)); g->map[n.id] = j_recv(g, 0); j_recv(g, 1); // B-bits } else { jit_value_t one = jit_value_from_int64(1); jit_value_t shifted = j_asr(g, unpacked, one); jit_value_t abits = j_and(g, unpacked, one); jit_value_t bbits = j_and(g, shifted, one); assert(jit_value_as_reg(bbits) == jit_value_as_reg(abits) + 1); g->map[n.id] = abits; (void)bbits; } } static void irgen_op_unpack(jit_irgen_t *g, mir_value_t n) { mir_value_t arg = mir_get_arg(g->mu, n, 0); assert(mir_is(g->mu, arg, MIR_TYPE_VEC4)); jit_value_t strength = jit_value_from_int64(irgen_get_enum(g, n, 1)); jit_value_t abits = irgen_get_value(g, arg); jit_value_t bbits = jit_value_from_reg(jit_value_as_reg(abits) + 1); if (mir_is_scalar(g->mu, n)) { jit_value_t bshift = j_shl(g, bbits, jit_value_from_int64(1)); jit_value_t bits = j_or(g, abits, bshift); g->map[n.id] = j_or(g, bits, strength); } else { const int size = mir_get_size(g->mu, mir_get_type(g->mu, arg)); jit_value_t dest = irgen_get_arg(g, n, 2); j_send(g, 0, dest); j_send(g, 1, jit_value_from_int64(size)); j_send(g, 2, strength); macro_unpack(g, abits, bbits); } } static jit_cc_t irgen_vector_cmp(mir_vec_op_t op) { switch (op) { case MIR_VEC_LT: return JIT_CC_LT; case MIR_VEC_LEQ: return JIT_CC_LE; case MIR_VEC_GT: return JIT_CC_GT; case MIR_VEC_GEQ: return JIT_CC_GE; case MIR_VEC_LOG_EQ: return JIT_CC_EQ; case MIR_VEC_LOG_NEQ: return JIT_CC_NE; default: should_not_reach_here(); } } static void irgen_op_binary(jit_irgen_t *g, mir_value_t n) { mir_value_t left = mir_get_arg(g->mu, n, 1); mir_value_t right = mir_get_arg(g->mu, n, 2); jit_value_t aleft = irgen_get_value(g, left); jit_value_t aright = irgen_get_value(g, right); jit_value_t bleft, bright; if (mir_is(g->mu, left, MIR_TYPE_VEC4)) { bleft = jit_value_from_reg(jit_value_as_reg(aleft) + 1); bright = jit_value_from_reg(jit_value_as_reg(aright) + 1); } else assert(false); // TODO mir_type_t type = mir_get_type(g->mu, n); const int size = mir_get_size(g->mu, type); assert(size <= 64); // TODO (void)size; bool logical = false; jit_value_t abits; const mir_vec_op_t op = irgen_get_enum(g, n, 0); switch (op) { case MIR_VEC_LOG_AND: logical = true; case MIR_VEC_BIT_AND: abits = j_and(g, aleft, aright); break; case MIR_VEC_LOG_OR: logical = true; case MIR_VEC_BIT_OR: abits = j_or(g, aleft, aright); break; case MIR_VEC_BIT_XOR: abits = j_xor(g, aleft, aright); break; case MIR_VEC_ADD: abits = j_add(g, aleft, aright); break; case MIR_VEC_SUB: abits = j_sub(g, aleft, aright); break; case MIR_VEC_MUL: abits = j_mul(g, aleft, aright); break; case MIR_VEC_CASE_EQ: j_cmp(g, JIT_CC_EQ, aleft, aright); j_ccmp(g, JIT_CC_EQ, bleft, bright); abits = j_cset(g); break; case MIR_VEC_CASE_NEQ: j_cmp(g, JIT_CC_EQ, aleft, aright); j_ccmp(g, JIT_CC_EQ, bleft, bright); abits = j_not(g, j_cset(g)); break; case MIR_VEC_LT: case MIR_VEC_LEQ: case MIR_VEC_GT: case MIR_VEC_GEQ: case MIR_VEC_LOG_EQ: case MIR_VEC_LOG_NEQ: j_cmp(g, irgen_vector_cmp(op), aleft, aright); abits = j_cset(g); break; case MIR_VEC_SLL: abits = j_shl(g, aleft, aright); break; default: should_not_reach_here(); } if (logical) { j_cmp(g, JIT_CC_NE, abits, jit_value_from_int64(0)); abits = j_cset(g); } jit_reg_t bbits = irgen_alloc_reg(g); assert(abits.kind == JIT_VALUE_REG); assert(bbits == abits.reg + 1); j_mov(g, bbits, jit_value_from_int64(0)); g->map[n.id] = abits; } static void irgen_op_unary(jit_irgen_t *g, mir_value_t n) { jit_value_t arg = irgen_get_arg(g, n, 1); mir_type_t type = mir_get_type(g->mu, n); const int size = mir_get_size(g->mu, type); assert(size <= 64); // TODO jit_value_t abits; switch (irgen_get_enum(g, n, 0)) { case MIR_VEC_BIT_NOT: { uint64_t mask = ~UINT64_C(0); if (size < 64) mask >>= 64 - size; abits = j_xor(g, arg, jit_value_from_int64(mask)); } break; case MIR_VEC_LOG_NOT: abits = j_not(g, arg); break; case MIR_VEC_SUB: abits = j_neg(g, arg); break; case MIR_VEC_BIT_OR: abits = j_not(g, j_not(g, arg)); break; default: should_not_reach_here(); } jit_reg_t bbits = irgen_alloc_reg(g); assert(abits.kind == JIT_VALUE_REG); assert(bbits == abits.reg + 1); j_mov(g, bbits, jit_value_from_int64(0)); g->map[n.id] = abits; } static void irgen_block(jit_irgen_t *g, mir_block_t block) { irgen_bind_label(g, g->blocks[block.id]); g->flags = MIR_NULL_VALUE; g->curblock = block; const int nops = mir_count_nodes(g->mu, block); for (int i = 0; i < nops; i++) { mir_value_t n = mir_get_node(g->mu, block, i); const mir_op_t op = mir_get_op(g->mu, n); if (op == MIR_OP_COMMENT) continue; #ifdef DEBUG mir_set_cursor(g->mu, block, i); irgen_emit_debuginfo(g, n); #endif switch (op) { case MIR_OP_CONST: irgen_op_const(g, n); break; case MIR_OP_CONST_REAL: irgen_op_const_real(g, n); break; case MIR_OP_CONST_VEC: irgen_op_const_vec(g, n); break; case MIR_OP_CONST_ARRAY: irgen_op_const_array(g, n); break; case MIR_OP_CONST_REP: irgen_op_const_rep(g, n); break; case MIR_OP_CONST_RECORD: irgen_op_const_record(g, n); break; case MIR_OP_ADDRESS_OF: irgen_op_address_of(g, n); break; case MIR_OP_LOCUS: irgen_op_locus(g, n); break; case MIR_OP_TRAP_ADD: irgen_op_trap_add(g, n); break; case MIR_OP_NOT: irgen_op_not(g, n); break; case MIR_OP_AND: irgen_op_and(g, n); break; case MIR_OP_OR: irgen_op_or(g, n); break; case MIR_OP_XOR: irgen_op_xor(g, n); break; case MIR_OP_ADD: irgen_op_add(g, n); break; case MIR_OP_TRAP_MUL: irgen_op_trap_mul(g, n); break; case MIR_OP_MUL: irgen_op_mul(g, n); break; case MIR_OP_DIV: irgen_op_div(g, n); break; case MIR_OP_EXP: irgen_op_exp(g, n); break; case MIR_OP_TRAP_EXP: irgen_op_trap_exp(g, n); break; case MIR_OP_SUB: irgen_op_sub(g, n); break; case MIR_OP_TRAP_SUB: irgen_op_trap_sub(g, n); break; case MIR_OP_NEG: irgen_op_neg(g, n); break; case MIR_OP_TRAP_NEG: irgen_op_trap_neg(g, n); break; case MIR_OP_ABS: irgen_op_abs(g, n); break; case MIR_OP_MOD: irgen_op_mod(g, n); break; case MIR_OP_REM: irgen_op_rem(g, n); break; case MIR_OP_CMP: irgen_op_cmp(g, n); break; case MIR_OP_RETURN: irgen_op_return(g, n); break; case MIR_OP_STORE: irgen_op_store(g, n); break; case MIR_OP_LOAD: irgen_op_load(g, n); break; case MIR_OP_WRAP: irgen_op_wrap(g, n); break; case MIR_OP_UARRAY_LEFT: irgen_op_uarray_left(g, n); break; case MIR_OP_UARRAY_RIGHT: irgen_op_uarray_right(g, n); break; case MIR_OP_UARRAY_DIR: irgen_op_uarray_dir(g, n); break; case MIR_OP_UARRAY_LEN: irgen_op_uarray_len(g, n); break; case MIR_OP_UNWRAP: irgen_op_unwrap(g, n); break; case MIR_OP_CAST: irgen_op_cast(g, n); break; case MIR_OP_RANGE_NULL: irgen_op_range_null(g, n); break; case MIR_OP_RANGE_LENGTH: irgen_op_range_length(g, n); break; case MIR_OP_COND: irgen_op_cond(g, n); break; case MIR_OP_SELECT: irgen_op_select(g, n); break; case MIR_OP_JUMP: irgen_op_jump(g, n); break; case MIR_OP_ARRAY_REF: irgen_op_array_ref(g, n); break; case MIR_OP_CONTEXT_UPREF: irgen_op_context_upref(g, n); break; case MIR_OP_FCALL: irgen_op_fcall(g, n); break; case MIR_OP_PCALL: irgen_op_pcall(g, n); break; case MIR_OP_RESUME: irgen_op_resume(g, n); break; case MIR_OP_SYSCALL: irgen_op_syscall(g, n); break; case MIR_OP_WAIT: irgen_op_wait(g, n); break; case MIR_OP_COPY: irgen_op_copy(g, n); break; case MIR_OP_SET: irgen_op_set(g, n); break; case MIR_OP_VAR_UPREF: irgen_op_var_upref(g, n); break; case MIR_OP_INDEX_CHECK: irgen_op_index_check(g, n); break; case MIR_OP_DIR_CHECK: irgen_op_dir_check(g, n); break; case MIR_OP_RANGE_CHECK: irgen_op_range_check(g, n); break; case MIR_OP_PACKAGE_INIT: irgen_op_package_init(g, n); break; case MIR_OP_LINK_PACKAGE: irgen_op_link_package(g, n); break; case MIR_OP_LINK_VAR: irgen_op_link_var(g, n); break; case MIR_OP_RECORD_REF: irgen_op_record_ref(g, n); break; case MIR_OP_NULL: irgen_op_null(g, n); break; case MIR_OP_NEW: irgen_op_new(g, n); break; case MIR_OP_ALLOC: irgen_op_alloc(g, n); break; case MIR_OP_ALL: irgen_op_all(g, n); break; case MIR_OP_EXPONENT_CHECK: irgen_op_exponent_check(g, n); break; case MIR_OP_NULL_CHECK: irgen_op_null_check(g, n); break; case MIR_OP_ZERO_CHECK: irgen_op_zero_check(g, n); break; case MIR_OP_LENGTH_CHECK: irgen_op_length_check(g, n); break; case MIR_OP_CLOSURE: irgen_op_closure(g, n); break; case MIR_OP_RESOLUTION_WRAPPER: irgen_op_resolution_wrapper(g, n); break; case MIR_OP_INIT_SIGNAL: irgen_op_init_signal(g, n); break; case MIR_OP_IMPLICIT_SIGNAL: irgen_op_implicit_signal(g, n); break; case MIR_OP_ALIAS_SIGNAL: irgen_op_alias_signal(g, n); break; case MIR_OP_MAP_SIGNAL: irgen_op_map_signal(g, n); break; case MIR_OP_MAP_CONST: irgen_op_map_const(g, n); break; case MIR_OP_MAP_IMPLICIT: irgen_op_map_implicit(g, n); break; case MIR_OP_RESOLVE_SIGNAL: irgen_op_resolve_signal(g, n); break; case MIR_OP_UNREACHABLE: irgen_op_unreachable(g, n); break; case MIR_OP_REPORT: irgen_op_report(g, n); break; case MIR_OP_ASSERT: irgen_op_assert(g, n); break; case MIR_OP_CASE: irgen_op_case(g, n); break; case MIR_OP_PROTECTED_INIT: irgen_op_protected_init(g, n); break; case MIR_OP_REFLECT_VALUE: irgen_op_reflect_value(g, n); break; case MIR_OP_REFLECT_SUBTYPE: irgen_op_reflect_subtype(g, n); break; case MIR_OP_PROCESS_INIT: irgen_op_process_init(g, n); break; case MIR_OP_FILE_OPEN: irgen_op_file_open(g, n); break; case MIR_OP_FILE_READ: irgen_op_file_read(g, n); break; case MIR_OP_FILE_WRITE: irgen_op_file_write(g, n); break; case MIR_OP_PACKAGE_SCOPE: irgen_op_package_scope(g, n); break; case MIR_OP_ARRAY_SCOPE: irgen_op_array_scope(g, n); break; case MIR_OP_RECORD_SCOPE: irgen_op_record_scope(g, n); break; case MIR_OP_POP_SCOPE: irgen_op_pop_scope(g, n); break; case MIR_OP_DRIVE_SIGNAL: irgen_op_drive_signal(g, n); break; case MIR_OP_TRANSFER_SIGNAL: irgen_op_transfer_signal(g, n); break; case MIR_OP_RESOLVED: irgen_op_resolved(g, n); break; case MIR_OP_LAST_VALUE: irgen_op_last_value(g, n); break; case MIR_OP_SCHED_WAVEFORM: irgen_op_sched_waveform(g, n); break; case MIR_OP_DISCONNECT: irgen_op_disconnect(g, n); break; case MIR_OP_FORCE: irgen_op_force(g, n); break; case MIR_OP_RELEASE: irgen_op_release(g, n); break; case MIR_OP_DEPOSIT_SIGNAL: irgen_op_deposit_signal(g, n); break; case MIR_OP_PUT_CONVERSION: irgen_op_put_conversion(g, n); break; case MIR_OP_EVENT: irgen_op_event(g, n); break; case MIR_OP_ACTIVE: irgen_op_active(g, n); break; case MIR_OP_SCHED_EVENT: irgen_op_sched_event(g, n); break; case MIR_OP_CLEAR_EVENT: irgen_op_clear_event(g, n); break; case MIR_OP_DEBUG_OUT: irgen_op_debug_out(g, n); break; case MIR_OP_LAST_EVENT: irgen_op_last_event(g, n); break; case MIR_OP_LAST_ACTIVE: irgen_op_last_active(g, n); break; case MIR_OP_DRIVING: irgen_op_driving(g, n); break; case MIR_OP_DRIVING_VALUE: irgen_op_driving_value(g, n); break; case MIR_OP_COVER_STMT: case MIR_OP_COVER_BRANCH: case MIR_OP_COVER_EXPR: irgen_op_cover_increment(g, n); break; case MIR_OP_COVER_TOGGLE: irgen_op_cover_toggle(g, n); break; case MIR_OP_COVER_STATE: irgen_op_cover_state(g, n); break; case MIR_OP_ENTER_STATE: irgen_op_enter_state(g, n); break; case MIR_OP_FUNCTION_TRIGGER: irgen_op_function_trigger(g, n); break; case MIR_OP_OR_TRIGGER: irgen_op_or_trigger(g, n); break; case MIR_OP_CMP_TRIGGER: irgen_op_cmp_trigger(g, n); break; case MIR_OP_ADD_TRIGGER: irgen_op_add_trigger(g, n); break; case MIR_OP_PORT_CONVERSION: irgen_op_port_conversion(g, n); break; case MIR_OP_CONVERT_IN: irgen_op_convert_in(g, n); break; case MIR_OP_CONVERT_OUT: irgen_op_convert_out(g, n); break; case MIR_OP_BIND_FOREIGN: irgen_op_bind_foreign(g, n); break; case MIR_OP_INSTANCE_NAME: irgen_op_instance_name(g, n); break; case MIR_OP_BIND_EXTERNAL: irgen_op_bind_external(g, n); break; case MIR_OP_PACK: irgen_op_pack(g, n); break; case MIR_OP_UNPACK: irgen_op_unpack(g, n); break; case MIR_OP_BINARY: irgen_op_binary(g, n); break; case MIR_OP_UNARY: irgen_op_unary(g, n); break; default: DEBUG_ONLY(mir_dump(g->mu)); fatal_trace("cannot generate JIT IR for MIR op %s", mir_op_string(op)); } } DEBUG_ONLY(if (nops == 0) j_trap(g)); } static void irgen_locals(jit_irgen_t *g) { const int nvars = mir_count_vars(g->mu); g->vars = xmalloc_array(nvars, sizeof(jit_value_t)); bool on_stack; const mir_unit_kind_t kind = mir_get_kind(g->mu); switch (kind) { case MIR_UNIT_PROCESS: case MIR_UNIT_PROPERTY: on_stack = g->stateless; break; case MIR_UNIT_INSTANCE: case MIR_UNIT_PROCEDURE: case MIR_UNIT_PACKAGE: case MIR_UNIT_PROTECTED: on_stack = false; break; default: on_stack = !g->needs_context; break; } if (on_stack) { // Local variables on stack for (int i = 0; i < nvars; i++) { mir_value_t var = mir_get_var(g->mu, i); mir_type_t type = mir_get_var_type(g->mu, var); const int sz = irgen_size_bytes(g, type); if ((mir_get_var_flags(g->mu, var) & MIR_VAR_HEAP) || sz > MAX_STACK_ALLOC) { g->vars[i] = macro_lalloc(g, jit_value_from_int64(sz)); g->used_tlab = true; } else g->vars[i] = macro_salloc(g, sz); } } else { // Local variables on heap size_t sz = 0; sz += sizeof(void *); // Context parameter if (kind == MIR_UNIT_PROCESS || kind == MIR_UNIT_PROCEDURE) { sz += sizeof(void *); // Suspended procedure state sz += sizeof(int32_t); // State number } link_tab_t *linktab = xmalloc_array(nvars, sizeof(link_tab_t)); for (int i = 0; i < nvars; i++) { mir_value_t var = mir_get_var(g->mu, i); mir_type_t type = mir_get_var_type(g->mu, var); const int align = irgen_align_of(g, type); sz = ALIGN_UP(sz, align); linktab[i].name = mir_get_name(g->mu, var); linktab[i].offset = sz; sz += irgen_size_bytes(g, type); } jit_value_t mem; if (kind == MIR_UNIT_PROTECTED) { // Protected types must always be allocated on the global heap // as the result may be stored in an access mem = macro_galloc(g, jit_value_from_int64(sz)); } else { mem = macro_lalloc(g, jit_value_from_int64(sz)); g->used_tlab = true; } if (g->statereg.kind != JIT_VALUE_INVALID) { // A null state was passed in by the caller j_mov(g, jit_value_as_reg(g->statereg), mem); } else g->statereg = mem; for (int i = 0; i < nvars; i++) g->vars[i] = jit_addr_from_value(g->statereg, linktab[i].offset); // Publish the variable offset table early to handle circular references // This may be read by another thread while in the COMPILING state g->func->nvars = nvars; store_release(&(g->func->linktab), linktab); } } static void irgen_params(jit_irgen_t *g, int first) { // We never need more than the first few argument types ffi_type_t types[7]; types[first] = FFI_POINTER; types[0] = FFI_VOID; jit_value_t spill = { .kind = JIT_VALUE_INVALID }; int32_t spilloff = 0; const int nparams = mir_count_params(g->mu); g->params = xmalloc_array(nparams, sizeof(jit_value_t)); for (int i = 0, pslot = first; i < nparams; i++) { mir_value_t p = mir_get_param(g->mu, i); mir_type_t type = mir_get_type(g->mu, p); int slots = irgen_slots_for_type(g, type); if (pslot + slots >= JIT_MAX_ARGS - 1) { // Large number of arguments spill to the heap if (spill.kind == JIT_VALUE_INVALID) { spill = j_recv(g, JIT_MAX_ARGS - 1); pslot = JIT_MAX_ARGS; } jit_value_t ptr = jit_addr_from_value(spill, spilloff); g->params[p.id] = j_load(g, JIT_SZ_64, ptr); spilloff += sizeof(jit_scalar_t); for (int i = 1; i < slots; i++, spilloff += sizeof(jit_scalar_t)) { jit_value_t ptr = jit_addr_from_value(spill, spilloff); j_load(g, JIT_SZ_64, ptr); // Must be contiguous registers } } else { g->params[p.id] = j_recv(g, pslot++); for (int i = 1; i < slots; i++) j_recv(g, pslot++); // Must be contiguous registers } if (i + first + 1 < ARRAY_LEN(types)) types[i + first + 1] = irgen_ffi_type(g, type); } mir_unit_kind_t kind = mir_get_kind(g->mu); if (kind == MIR_UNIT_FUNCTION || kind == MIR_UNIT_THUNK) { mir_type_t rtype = mir_get_result(g->mu); if (!mir_is_null(rtype)) types[0] = irgen_ffi_type(g, rtype); } const int ntypes = MIN(ARRAY_LEN(types), first + nparams + 1); g->func->spec = ffi_spec_new(types, ntypes); } static void irgen_jump_table(jit_irgen_t *g) { g->statereg = j_recv(g, 0); irgen_label_t *cont = irgen_alloc_label(g); j_cmp(g, JIT_CC_EQ, g->statereg, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, cont); jit_value_t state_ptr = irgen_state_ptr(g); jit_value_t state = j_load(g, JIT_SZ_32, state_ptr); jit_reg_t state_reg = jit_value_as_reg(state); const bool is_process = (mir_get_kind(g->mu) == MIR_UNIT_PROCESS); const int nblocks = mir_count_blocks(g->mu); bit_mask_t have; mask_init(&have, nblocks); for (int i = 0; i < nblocks; i++) { mir_block_t b = mir_get_block(g->mu, i); const int num_nodes = mir_count_nodes(g->mu, b); if (num_nodes == 0) continue; mir_value_t last = mir_get_node(g->mu, b, num_nodes - 1); mir_block_t target = MIR_NULL_BLOCK; const mir_op_t last_op = mir_get_op(g->mu, last); if (last_op == MIR_OP_WAIT || last_op == MIR_OP_PCALL) target = mir_cast_block(mir_get_arg(g->mu, last, 0)); else if (is_process && last_op == MIR_OP_RETURN) target = mir_get_block(g->mu, 1); if (mir_is_null(target) || mask_test(&have, target.id)) continue; macro_case(g, state_reg, jit_value_from_int64(target.id), g->blocks[target.id]); mask_set(&have, target.id); } DEBUG_ONLY(j_trap(g)); irgen_bind_label(g, cont); mask_free(&have); } static void irgen_analyse(jit_irgen_t *g) { // A process is stateless if it has no non-temporary variables and // all wait statements resume at the initial block const mir_unit_kind_t kind = mir_get_kind(g->mu); g->stateless = (kind == MIR_UNIT_PROCESS || kind == MIR_UNIT_PROPERTY); const int nvars = mir_count_vars(g->mu); for (int i = 0; i < nvars; i++) { mir_value_t var = mir_get_var(g->mu, i); if (!(mir_get_var_flags(g->mu, var) & MIR_VAR_TEMP)) { g->stateless = false; break; } } const int nblocks = mir_count_blocks(g->mu); for (int i = 0; i < nblocks; i++) { mir_block_t b = mir_get_block(g->mu, i); const int nops = mir_count_nodes(g->mu, b); for (int j = 0; j < nops; j++) { mir_value_t n = mir_get_node(g->mu, b, j); const mir_op_t op = mir_get_op(g->mu, n); if (j == nops - 1 && op == MIR_OP_WAIT) { mir_block_t target = mir_cast_block(mir_get_arg(g->mu, n, 0)); if (target.id != 1) { // This a kludge: remove it when MIR optimises better if (mir_count_nodes(g->mu, target) != 1) g->stateless = false; else { mir_value_t n0 = mir_get_node(g->mu, target, 0); if (mir_get_op(g->mu, n0) != MIR_OP_JUMP) g->stateless = false; else if (mir_cast_block(mir_get_arg(g->mu, n0, 0)).id != 1) g->stateless = false; } } } else if (j == nops - 1 && op == MIR_OP_PCALL) g->stateless = false; else if (op == MIR_OP_CONTEXT_UPREF) { const int hops = irgen_get_const(g, n, 0); if (hops == 0) { g->needs_context = true; g->stateless = false; } } } } } static void irgen_instance_entry(jit_irgen_t *g) { const ffi_type_t types[] = { FFI_POINTER, FFI_POINTER }; g->func->spec = ffi_spec_new(types, ARRAY_LEN(types)); #ifdef DEBUG // Instances should only be initialised once irgen_label_t *cont = irgen_alloc_label(g); jit_value_t priv = macro_getpriv(g, g->func->handle); j_cmp(g, JIT_CC_EQ, priv, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, cont); j_trap(g); irgen_bind_label(g, cont); #endif irgen_locals(g); // Stash context pointer jit_value_t context = j_recv(g, 0); j_store(g, JIT_SZ_PTR, context, jit_addr_from_value(g->statereg, 0)); macro_putpriv(g, g->func->handle, g->statereg); } static void irgen_process_entry(jit_irgen_t *g) { const ffi_type_t types[] = { FFI_POINTER, FFI_POINTER, FFI_POINTER }; g->func->spec = ffi_spec_new(types, ARRAY_LEN(types)); if (!g->stateless) irgen_jump_table(g); irgen_locals(g); if (g->stateless) { g->contextarg = j_recv(g, 1); jit_value_t state = j_recv(g, 0); j_cmp(g, JIT_CC_EQ, state, jit_null_ptr()); j_jump(g, JIT_CC_F, g->blocks[1]); } else { // Stash context pointer jit_value_t context = j_recv(g, 1); j_store(g, JIT_SZ_PTR, context, jit_addr_from_value(g->statereg, 0)); } } static void irgen_property_entry(jit_irgen_t *g) { irgen_params(g, 1); if (g->stateless) irgen_locals(g); jit_value_t state = j_recv(g, 0); j_cmp(g, JIT_CC_EQ, state, jit_null_ptr()); j_jump(g, JIT_CC_F, g->blocks[1]); if (g->stateless) g->contextarg = g->params[0]; else g->statereg = state; if (!g->stateless) { irgen_locals(g); // Stash context pointer jit_value_t context = jit_addr_from_value(g->statereg, 0); j_store(g, JIT_SZ_PTR, g->params[0], context); } } static void irgen_function_entry(jit_irgen_t *g) { const bool is_procedure = mir_is_null(mir_get_result(g->mu)); const int first_param = is_procedure ? 1 : 0; irgen_params(g, first_param); irgen_locals(g); if (g->statereg.kind != JIT_VALUE_INVALID) { // Stash context pointer j_store(g, JIT_SZ_PTR, g->params[0], jit_addr_from_value(g->statereg, 0)); } } static void irgen_procedure_entry(jit_irgen_t *g) { irgen_jump_table(g); irgen_params(g, 1); irgen_locals(g); // Stash context pointer j_store(g, JIT_SZ_PTR, g->params[0], jit_addr_from_value(g->statereg, 0)); } static void irgen_thunk_entry(jit_irgen_t *g) { g->contextarg = j_recv(g, 0); irgen_locals(g); } static void irgen_package_entry(jit_irgen_t *g) { // It's harmless to initialise a package multiple times, just return // the existing context pointer irgen_label_t *cont = irgen_alloc_label(g); jit_value_t priv = macro_getpriv(g, g->func->handle); j_cmp(g, JIT_CC_EQ, priv, jit_value_from_int64(0)); j_jump(g, JIT_CC_T, cont); j_send(g, 0, priv); j_ret(g); irgen_bind_label(g, cont); irgen_locals(g); // Stash context pointer jit_value_t context = j_recv(g, 0); j_store(g, JIT_SZ_PTR, context, jit_addr_from_value(g->statereg, 0)); macro_putpriv(g, g->func->handle, g->statereg); } static void irgen_protected_entry(jit_irgen_t *g) { const ffi_type_t types[] = { FFI_POINTER }; g->func->spec = ffi_spec_new(types, ARRAY_LEN(types)); irgen_params(g, 1); irgen_locals(g); // Stash context pointer jit_value_t context = j_recv(g, 0); j_store(g, JIT_SZ_PTR, context, jit_addr_from_value(g->statereg, 0)); } void jit_irgen(jit_func_t *f, mir_unit_t *mu) { assert(load_acquire(&f->state) == JIT_FUNC_COMPILING); assert(f->irbuf == NULL); const bool debug_log = opt_get_int(OPT_JIT_LOG) && f->name != NULL; const uint64_t start_ticks = debug_log ? get_timestamp_us() : 0; const int num_nodes = mir_count_nodes(mu, MIR_NULL_BLOCK); jit_irgen_t *g = xcalloc(sizeof(jit_irgen_t)); g->func = f; g->map = xmalloc_array(num_nodes, sizeof(jit_value_t)); g->mu = mu; const int nblocks = mir_count_blocks(g->mu); g->blocks = xmalloc_array(nblocks, sizeof(irgen_label_t *)); for (int i = 0; i < nblocks; i++) g->blocks[i] = irgen_alloc_label(g); irgen_analyse(g); switch (mir_get_kind(g->mu)) { case MIR_UNIT_INSTANCE: irgen_instance_entry(g); break; case MIR_UNIT_PROCESS: irgen_process_entry(g); break; case MIR_UNIT_FUNCTION: irgen_function_entry(g); break; case MIR_UNIT_PROCEDURE: irgen_procedure_entry(g); break; case MIR_UNIT_THUNK: irgen_thunk_entry(g); break; case MIR_UNIT_PACKAGE: irgen_package_entry(g); break; case MIR_UNIT_PROTECTED: irgen_protected_entry(g); break; case MIR_UNIT_PROPERTY: irgen_property_entry(g); break; default: should_not_reach_here(); } for (int i = 0; i < nblocks; i++) irgen_block(g, mir_get_block(mu, i)); f->nregs = g->next_reg; f->cpoolsz = g->cpoolptr; f->object = mir_get_object(g->mu); for (irgen_label_t *it = g->labels, *tmp; it; it = tmp) { assert(it->label < g->func->nirs); if (it->uses > 0) g->func->irbuf[it->label].target = 1; tmp = it->next; free(it); } g->labels = NULL; if (mir_get_kind(mu) != MIR_UNIT_THUNK) { jit_do_mem2reg(f); jit_do_lvn(f); jit_do_cprop(f); jit_do_dce(f); jit_delete_nops(f); } // Function can be executed immediately after this store store_release(&(f->state), JIT_FUNC_READY); if (opt_get_verbose(OPT_JIT_VERBOSE, istr(f->name))) { #ifdef DEBUG jit_dump_interleaved(f, mu); #else jit_dump(f); #endif } if (debug_log) { const int ticks = get_timestamp_us() - start_ticks; diag_t *d = diag_new(DIAG_DEBUG, NULL); diag_printf(d, "%s: %d instructions", istr(f->name), f->nirs); if (f->cpoolsz > 0) diag_printf(d, "; %d cpool bytes", f->cpoolsz); diag_printf(d, " [%d us]", ticks); diag_emit(d); } free(g->blocks); free(g->map); free(g->vars); free(g->params); free(g); } nvc-r1.17.1/src/jit/jit-layout.c000066400000000000000000000216741504111170000163730ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "hash.h" #include "jit/jit-layout.h" #include "option.h" #include "thread.h" #include "type.h" #include static int count_sub_elements(type_t type) { if (type_is_array(type)) { if (type_is_unconstrained(type)) return -1; else { const int ndims = dimension_of(type); int length = count_sub_elements(type_elem(type)); for (int i = 0; i < ndims; i++) { tree_t r = range_of(type, i); int64_t dlen; if (!folded_length(r, &dlen)) return -1; length *= dlen; } return length; } } else return 1; } static void print_layout(type_t type, const jit_layout_t *l, bool signal) { color_printf("$blue$%s%s\n size:%d align:%d\n", type_pp(type), signal ? "$" : "", l->size, l->align); for (int i = 0; i < l->nparts; i++) { static const char *map[] = { "data", "bounds", "offset", "external" }; printf(" %d: %-8s offset:%u size:%u align:%u repeat:%u\n", i, map[l->parts[i].class], l->parts[i].offset, l->parts[i].size, l->parts[i].align, l->parts[i].repeat); } color_printf("$$\n"); } const jit_layout_t *layout_of(type_t type) { assert(type_frozen(type)); // Not safe to cache otherwise static hash_t *cache = NULL; INIT_ONCE(cache = hash_new(256)); jit_layout_t *l = hash_get(cache, type); if (l != NULL) return l; if (type_is_integer(type) || type_is_physical(type) || type_is_enum(type)) { l = xcalloc_flex(sizeof(jit_layout_t), 1, sizeof(layout_part_t)); l->nparts = 1; type_t base = type_base_recur(type); tree_t r = type_dim(base, 0); int64_t low, high; if (!folded_bounds(r, &low, &high)) fatal_trace("type %s has unknown bounds", type_pp(type)); const int bits = bits_for_range(low, high); l->parts[0].offset = 0; l->parts[0].size = l->size = ALIGN_UP(bits, 8) / 8; l->parts[0].repeat = 1; l->parts[0].align = l->align = l->parts[0].size; l->parts[0].class = LC_DATA; } else if (type_is_real(type)) { l = xcalloc_flex(sizeof(jit_layout_t), 1, sizeof(layout_part_t)); l->nparts = 1; l->parts[0].offset = 0; l->parts[0].size = l->size = sizeof(double); l->parts[0].repeat = 1; l->parts[0].align = l->align = l->parts[0].size; l->parts[0].class = LC_DATA; } else if (type_is_array(type)) { const int ndims = dimension_of(type); const int nelems = count_sub_elements(type); if (nelems >= 0) { type_t elem = type_elem_recur(type); const jit_layout_t *el = layout_of(elem); l = xcalloc_flex(sizeof(jit_layout_t), 1, sizeof(layout_part_t)); l->nparts = 1; l->size = nelems * el->size; l->align = el->align; l->parts[0].offset = 0; l->parts[0].size = el->size; l->parts[0].repeat = nelems; l->parts[0].align = el->align; l->parts[0].class = LC_DATA; } else if (type_kind(type) == T_SUBTYPE) // Reduce number of cached copies return layout_of(type_base_recur(type)); else { l = xcalloc_flex(sizeof(jit_layout_t), 2, sizeof(layout_part_t)); l->nparts = 2; l->size = sizeof(void *) + ndims * 2 * sizeof(int64_t); l->align = sizeof(void *); l->parts[0].offset = 0; l->parts[0].size = sizeof(void *); l->parts[0].repeat = 1; l->parts[0].align = l->parts[0].size; l->parts[0].class = LC_EXTERNAL; l->parts[1].offset = sizeof(void *); l->parts[1].size = sizeof(int64_t); l->parts[1].repeat = ndims * 2; l->parts[1].align = l->parts[1].size; l->parts[1].class = LC_BOUNDS; } } else if (type_is_record(type)) { const int nfields = type_fields(type); l = xcalloc_flex(sizeof(jit_layout_t), nfields, sizeof(layout_part_t)); l->nparts = nfields; int offset = 0; for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); const jit_layout_t *fl = layout_of(ftype); offset = ALIGN_UP(offset, fl->align); l->parts[i].offset = offset; l->parts[i].size = fl->size; l->parts[i].repeat = 1; l->parts[i].align = fl->align; l->parts[i].class = LC_DATA; offset += fl->size; } l->size = offset; l->align = sizeof(void *); // Matches irgen_align_of } else fatal_trace("cannot get layout for %s", type_pp(type)); if (opt_get_int(OPT_LAYOUT_VERBOSE)) print_layout(type, l, false); hash_put(cache, type, l); return l; } const jit_layout_t *signal_layout_of(type_t type) { assert(type_frozen(type)); // Not safe to cache otherwise static hash_t *cache = NULL; INIT_ONCE(cache = hash_new(256)); jit_layout_t *l = hash_get(cache, type); if (l != NULL) return l; if (type_is_scalar(type)) { l = xcalloc_flex(sizeof(jit_layout_t), 2, sizeof(layout_part_t)); l->nparts = 2; l->size = 16; l->align = 8; // Shared signal data pointer l->parts[0].offset = 0; l->parts[0].size = sizeof(void *); l->parts[0].repeat = 1; l->parts[0].align = sizeof(void *); l->parts[0].class = LC_EXTERNAL; // Offset l->parts[1].offset = 8; l->parts[1].size = 8; l->parts[1].repeat = 1; l->parts[1].align = 8; l->parts[1].class = LC_OFFSET; } else if (type_is_record(type)) { const int nfields = type_fields(type); l = xcalloc_flex(sizeof(jit_layout_t), nfields, sizeof(layout_part_t)); l->nparts = nfields; int offset = 0; for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); const jit_layout_t *fl = signal_layout_of(ftype); offset = ALIGN_UP(offset, fl->align); l->parts[i].offset = offset; l->parts[i].size = fl->size; l->parts[i].repeat = 1; l->parts[i].align = fl->align; l->parts[i].class = LC_DATA; offset += fl->size; } l->size = offset; l->align = sizeof(void *); // Matches irgen_align_of } else if (type_const_bounds(type)) { const bool has_offset = type_is_homogeneous(type); const int nparts = 1 + has_offset; l = xcalloc_flex(sizeof(jit_layout_t), nparts, sizeof(layout_part_t)); l->nparts = nparts; l->align = sizeof(void *); layout_part_t *p = l->parts; // Pointer to signal or record data p->offset = 0; p->size = sizeof(void *); p->repeat = 1; p->align = sizeof(void *); p->class = LC_EXTERNAL; l->size += p->size * p->repeat; p++; if (has_offset) { p->offset = ALIGN_UP(l->size, 8); p->size = 8; p->repeat = 1; p->align = 8; p->class = LC_OFFSET; l->size += p->size * p->repeat; p++; } } else if (type_kind(type) == T_SUBTYPE) // Reduce number of cached copies return signal_layout_of(type_base_recur(type)); else { const bool has_offset = type_is_homogeneous(type); const int ndims = dimension_of(type); const int nparts = 2 + has_offset; l = xcalloc_flex(sizeof(jit_layout_t), nparts, sizeof(layout_part_t)); l->nparts = nparts; l->align = sizeof(void *); layout_part_t *p = l->parts; // Pointer to signal or record data p->offset = 0; p->size = sizeof(void *); p->repeat = 1; p->align = sizeof(void *); p->class = LC_EXTERNAL; l->size += p->size * p->repeat; p++; if (has_offset) { p->offset = ALIGN_UP(l->size, 8); p->size = 8; p->repeat = 1; p->align = 8; p->class = LC_OFFSET; l->size += p->size * p->repeat; p++; } p->offset = ALIGN_UP(l->size, 8); p->size = 8; p->repeat = ndims * 2; p->align = 8; p->class = LC_BOUNDS; l->size += p->size * p->repeat; p++; } if (opt_get_int(OPT_LAYOUT_VERBOSE)) print_layout(type, l, true); hash_put(cache, type, l); return l; } nvc-r1.17.1/src/jit/jit-layout.h000066400000000000000000000024001504111170000163620ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_LAYOUT_H #define _JIT_LAYOUT_H #include "prim.h" #include "util.h" typedef enum { LC_DATA, LC_BOUNDS, LC_OFFSET, LC_EXTERNAL, } layout_class_t; typedef struct { uint32_t offset; uint32_t size; uint32_t repeat; uint16_t align; uint16_t class; } layout_part_t; STATIC_ASSERT(sizeof(layout_part_t) == 16); typedef struct { int nparts; int size; int align; layout_part_t parts[0]; } jit_layout_t; const jit_layout_t *layout_of(type_t type); const jit_layout_t *signal_layout_of(type_t type); #endif // _JIT_LAYOUT_H nvc-r1.17.1/src/jit/jit-llvm.c000066400000000000000000003470031504111170000160250ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "hash.h" #include "ident.h" #include "jit/jit-llvm.h" #include "jit/jit-priv.h" #include "lib.h" #include "object.h" #include "option.h" #include "rt/rt.h" #include "thread.h" #include #include #include #include #include #include #include #include #include #include #include #if LLVM_HAS_PASS_BUILDER #include #else #include #include #endif typedef enum { LLVM_VOID, LLVM_PTR, LLVM_INT1, LLVM_INT8, LLVM_INT16, LLVM_INT32, LLVM_INT64, LLVM_INTPTR, LLVM_DOUBLE, LLVM_PAIR_I8_I1, LLVM_PAIR_I16_I1, LLVM_PAIR_I32_I1, LLVM_PAIR_I64_I1, LLVM_ENTRY_FN, LLVM_ANCHOR, LLVM_TLAB, LLVM_AOT_RELOC, LLVM_STRTAB, LLVM_LAST_TYPE } llvm_type_t; typedef enum { LLVM_ADD_OVERFLOW_S8, LLVM_ADD_OVERFLOW_S16, LLVM_ADD_OVERFLOW_S32, LLVM_ADD_OVERFLOW_S64, LLVM_ADD_OVERFLOW_U8, LLVM_ADD_OVERFLOW_U16, LLVM_ADD_OVERFLOW_U32, LLVM_ADD_OVERFLOW_U64, LLVM_SUB_OVERFLOW_S8, LLVM_SUB_OVERFLOW_S16, LLVM_SUB_OVERFLOW_S32, LLVM_SUB_OVERFLOW_S64, LLVM_SUB_OVERFLOW_U8, LLVM_SUB_OVERFLOW_U16, LLVM_SUB_OVERFLOW_U32, LLVM_SUB_OVERFLOW_U64, LLVM_MUL_OVERFLOW_S8, LLVM_MUL_OVERFLOW_S16, LLVM_MUL_OVERFLOW_S32, LLVM_MUL_OVERFLOW_S64, LLVM_MUL_OVERFLOW_U8, LLVM_MUL_OVERFLOW_U16, LLVM_MUL_OVERFLOW_U32, LLVM_MUL_OVERFLOW_U64, LLVM_EXP_OVERFLOW_S8, LLVM_EXP_OVERFLOW_S16, LLVM_EXP_OVERFLOW_S32, LLVM_EXP_OVERFLOW_S64, LLVM_EXP_OVERFLOW_U8, LLVM_EXP_OVERFLOW_U16, LLVM_EXP_OVERFLOW_U32, LLVM_EXP_OVERFLOW_U64, LLVM_ADD_SAT_U8, LLVM_ADD_SAT_U16, LLVM_ADD_SAT_U32, LLVM_ADD_SAT_U64, LLVM_MEMSET_U8, LLVM_MEMSET_U16, LLVM_MEMSET_U32, LLVM_MEMSET_U64, LLVM_POW_F64, LLVM_COPYSIGN_F64, LLVM_MEMSET_INLINE, LLVM_MEMCPY_INLINE, LLVM_DO_EXIT, LLVM_PUTPRIV, LLVM_MSPACE_ALLOC, LLVM_GET_OBJECT, LLVM_TLAB_ALLOC, LLVM_SCHED_WAVEFORM, LLVM_TEST_EVENT, LLVM_LAST_EVENT, LLVM_SCHED_PROCESS, LLVM_PACK, LLVM_UNPACK, LLVM_LAST_FN, } llvm_fn_t; typedef struct _cgen_func cgen_func_t; typedef struct _cgen_block cgen_block_t; #define DEBUG_METADATA_VERSION 3 #define CLOSED_WORLD 1 #define ARGCACHE_SIZE 6 #define ENABLE_DWARF 0 #if defined __APPLE__ && defined ARCH_ARM64 #define JIT_CODE_MODEL LLVMCodeModelSmall #elif defined __linux__ && defined ARCH_X86_64 #define JIT_CODE_MODEL LLVMCodeModelLarge #else #define JIT_CODE_MODEL LLVMCodeModelJITDefault #endif #if ENABLE_DWARF #define DWARF_ONLY(x) x #else #define DWARF_ONLY(x) #endif typedef struct _llvm_obj { LLVMModuleRef module; LLVMContextRef context; LLVMTargetMachineRef target; LLVMBuilderRef builder; #if ENABLE_DWARF LLVMDIBuilderRef debuginfo; LLVMMetadataRef debugcu; #endif LLVMTargetDataRef data_ref; LLVMTypeRef types[LLVM_LAST_TYPE]; LLVMValueRef fns[LLVM_LAST_FN]; LLVMTypeRef fntypes[LLVM_LAST_FN]; LLVMValueRef strtab; pack_writer_t *pack_writer; } llvm_obj_t; typedef struct _cgen_block { LLVMBasicBlockRef bbref; LLVMValueRef inflags; LLVMValueRef outflags; LLVMValueRef *inregs; LLVMValueRef *outregs; jit_block_t *source; cgen_func_t *func; } cgen_block_t; typedef enum { CGEN_JIT, CGEN_AOT } cgen_mode_t; typedef struct { reloc_kind_t kind; unsigned nth; LLVMValueRef str; uintptr_t key; } cgen_reloc_t; typedef struct _cgen_func { LLVMValueRef llvmfn; LLVMValueRef args; LLVMValueRef argcache[ARGCACHE_SIZE]; LLVMValueRef irpos; LLVMValueRef tlab; LLVMValueRef anchor; LLVMValueRef cpool; LLVMTypeRef cpool_type; LLVMValueRef descr; LLVMTypeRef descr_type; LLVMTypeRef reloc_type; LLVMMetadataRef debugmd; cgen_block_t *blocks; jit_func_t *source; jit_cfg_t *cfg; char *name; loc_t last_loc; bit_mask_t ptr_mask; cgen_mode_t mode; cgen_reloc_t *relocs; } cgen_func_t; typedef enum { FUNC_ATTR_NOUNWIND, FUNC_ATTR_NORETURN, FUNC_ATTR_READONLY, FUNC_ATTR_NOCAPTURE, FUNC_ATTR_BYVAL, FUNC_ATTR_UWTABLE, FUNC_ATTR_NOINLINE, FUNC_ATTR_WRITEONLY, FUNC_ATTR_NONNULL, FUNC_ATTR_COLD, FUNC_ATTR_OPTNONE, FUNC_ATTR_NOALIAS, FUNC_ATTR_INLINE, // Attributes requiring special handling FUNC_ATTR_PRESERVE_FP, FUNC_ATTR_DLLEXPORT, } func_attr_t; #define LLVM_CHECK(op, ...) do { \ LLVMErrorRef error = op(__VA_ARGS__); \ if (unlikely(error != LLVMErrorSuccess)) { \ char *msg = LLVMGetErrorMessage(error); \ fatal(#op " failed: %s", msg); \ } \ } while (0) #ifdef LLVM_HAS_OPAQUE_POINTERS #define PTR(x) x #else #define PTR(x) \ LLVMBuildPointerCast(obj->builder, (x), obj->types[LLVM_PTR], "") #endif //////////////////////////////////////////////////////////////////////////////// // LLVM wrappers static LLVMValueRef llvm_int1(llvm_obj_t *obj, bool b) { return LLVMConstInt(obj->types[LLVM_INT1], b, false); } static LLVMValueRef llvm_int8(llvm_obj_t *obj, int8_t i) { return LLVMConstInt(obj->types[LLVM_INT8], i, false); } static LLVMValueRef llvm_int32(llvm_obj_t *obj, int32_t i) { return LLVMConstInt(obj->types[LLVM_INT32], i, false); } static LLVMValueRef llvm_int64(llvm_obj_t *obj, int64_t i) { return LLVMConstInt(obj->types[LLVM_INT64], i, false); } static LLVMValueRef llvm_intptr(llvm_obj_t *obj, intptr_t i) { return LLVMConstInt(obj->types[LLVM_INTPTR], i, false); } static LLVMValueRef llvm_ptr(llvm_obj_t *obj, void *ptr) { return LLVMConstIntToPtr(llvm_intptr(obj, (intptr_t)ptr), obj->types[LLVM_PTR]); } static LLVMValueRef llvm_real(llvm_obj_t *obj, double r) { return LLVMConstReal(obj->types[LLVM_DOUBLE], r); } static void llvm_add_func_attr(llvm_obj_t *obj, LLVMValueRef fn, func_attr_t attr, int param) { LLVMAttributeRef ref; if (attr == FUNC_ATTR_DLLEXPORT) { #ifdef IMPLIB_REQUIRED LLVMSetDLLStorageClass(fn, LLVMDLLExportStorageClass); #endif return; } else if (attr == FUNC_ATTR_PRESERVE_FP) { ref = LLVMCreateStringAttribute(obj->context, "frame-pointer", 13, "all", 3); } else { const char *names[] = { "nounwind", "noreturn", "readonly", "nocapture", "byval", "uwtable", "noinline", "writeonly", "nonnull", "cold", "optnone", "noalias", "inlinehint", }; assert(attr < ARRAY_LEN(names)); const unsigned kind = LLVMGetEnumAttributeKindForName(names[attr], strlen(names[attr])); if (kind == 0) fatal_trace("Cannot get LLVM attribute for %s", names[attr]); #ifdef LLVM_UWTABLE_HAS_ARGUMENT if (attr == FUNC_ATTR_UWTABLE) ref = LLVMCreateEnumAttribute(obj->context, kind, 2); else #endif ref = LLVMCreateEnumAttribute(obj->context, kind, 0); } LLVMAddAttributeAtIndex(fn, param, ref); } static void llvm_register_types(llvm_obj_t *obj) { obj->types[LLVM_VOID] = LLVMVoidTypeInContext(obj->context); obj->types[LLVM_INT1] = LLVMInt1TypeInContext(obj->context); obj->types[LLVM_INT8] = LLVMInt8TypeInContext(obj->context); obj->types[LLVM_INT16] = LLVMInt16TypeInContext(obj->context); obj->types[LLVM_INT32] = LLVMInt32TypeInContext(obj->context); obj->types[LLVM_INT64] = LLVMInt64TypeInContext(obj->context); obj->types[LLVM_DOUBLE] = LLVMDoubleTypeInContext(obj->context); obj->types[LLVM_INTPTR] = LLVMIntPtrTypeInContext(obj->context, obj->data_ref); #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR] = LLVMPointerTypeInContext(obj->context, 0); #else obj->types[LLVM_PTR] = LLVMPointerType(obj->types[LLVM_INT8], 0); #endif obj->types[LLVM_STRTAB] = LLVMArrayType(obj->types[LLVM_INT8], 0); { LLVMTypeRef fields[] = { obj->types[LLVM_PTR], // Mspace object obj->types[LLVM_INT32], // Allocation pointer obj->types[LLVM_INT32], // Limit pointer LLVMArrayType(obj->types[LLVM_INT8], 0), // Data }; obj->types[LLVM_TLAB] = LLVMStructTypeInContext(obj->context, fields, ARRAY_LEN(fields), false); } { LLVMTypeRef atypes[] = { obj->types[LLVM_PTR], // Function obj->types[LLVM_PTR], // Anchor #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], // Arguments #else LLVMPointerType(obj->types[LLVM_INT64], 0), #endif #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR] // TLAB pointer #else LLVMPointerType(obj->types[LLVM_TLAB], 0) #endif }; obj->types[LLVM_ENTRY_FN] = LLVMFunctionType(obj->types[LLVM_VOID], atypes, ARRAY_LEN(atypes), false); } { LLVMTypeRef fields[] = { obj->types[LLVM_INT32], // Kind obj->types[LLVM_INTPTR], // Data pointer }; obj->types[LLVM_AOT_RELOC] = LLVMStructTypeInContext(obj->context, fields, ARRAY_LEN(fields), false); } { LLVMTypeRef fields[] = { obj->types[LLVM_PTR], // Caller obj->types[LLVM_PTR], // Function obj->types[LLVM_INT32], // IR position obj->types[LLVM_INT32] // TLAB watermark }; obj->types[LLVM_ANCHOR] = LLVMStructTypeInContext(obj->context, fields, ARRAY_LEN(fields), false); } for (jit_size_t sz = JIT_SZ_8; sz <= JIT_SZ_64; sz++) { LLVMTypeRef fields[] = { obj->types[LLVM_INT8 + sz], obj->types[LLVM_INT1] }; llvm_fn_t which = LLVM_PAIR_I8_I1 + sz; obj->types[which] = LLVMStructTypeInContext(obj->context, fields, ARRAY_LEN(fields), false); } } static void llvm_dump_module(LLVMModuleRef module, const char *tag) { size_t length; const char *module_name = LLVMGetModuleIdentifier(module, &length); if (!opt_get_verbose(OPT_LLVM_VERBOSE, module_name)) return; LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "%s.%s.ll", module_name, tag); char *error; if (LLVMPrintModuleToFile(module, tb_get(tb), &error)) fatal("Failed to write LLVM IR file: %s", error); debugf("wrote LLVM IR for %s to %s", module_name, tb_get(tb)); } static void llvm_verify_module(LLVMModuleRef module) { #ifdef DEBUG if (LLVMVerifyModule(module, LLVMPrintMessageAction, NULL)) { size_t len; const char *name = LLVMGetModuleIdentifier(module, &len); fatal("LLVM verification failed for %s", name); } #endif } static void llvm_optimise(LLVMModuleRef module, LLVMTargetMachineRef target, llvm_opt_level_t olevel) { assert(olevel >= LLVM_O0 && olevel <= LLVM_O3); #if LLVM_HAS_PASS_BUILDER LLVMPassBuilderOptionsRef options = LLVMCreatePassBuilderOptions(); LLVMPassBuilderOptionsSetDebugLogging(options, false); LLVMPassBuilderOptionsSetLoopVectorization(options, false); LLVMPassBuilderOptionsSetLoopInterleaving(options, false); LLVMPassBuilderOptionsSetSLPVectorization(options, false); LLVMPassBuilderOptionsSetLoopUnrolling(options, false); LLVMPassBuilderOptionsSetCallGraphProfile(options, false); const char *passes[] = { "default", "default", "default", "default" }; LLVM_CHECK(LLVMRunPasses, module, passes[olevel], target, options); LLVMDisposePassBuilderOptions(options); #else LLVMPassManagerRef fpm = LLVMCreateFunctionPassManagerForModule(module); LLVMPassManagerRef mpm = LLVMCreatePassManager(); LLVMInitializeFunctionPassManager(fpm); for (LLVMValueRef fn = LLVMGetFirstFunction(module); fn != NULL; fn = LLVMGetNextFunction(fn)) LLVMRunFunctionPassManager(fpm, fn); LLVMFinalizeFunctionPassManager(fpm); LLVMDisposePassManager(fpm); LLVMPassManagerBuilderRef builder = LLVMPassManagerBuilderCreate(); LLVMPassManagerBuilderSetOptLevel(builder, olevel); LLVMPassManagerBuilderSetSizeLevel(builder, 0); if (olevel >= 2) LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 50); LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm); LLVMPassManagerBuilderDispose(builder); LLVMRunPassManager(mpm, module); LLVMDisposePassManager(mpm); #endif } static LLVMTargetMachineRef llvm_target_machine(LLVMRelocMode reloc, LLVMCodeModel model) { char *def_triple = LLVMGetDefaultTargetTriple(); char *error; LLVMTargetRef target_ref; if (LLVMGetTargetFromTriple(def_triple, &target_ref, &error)) fatal("failed to get LLVM target for %s: %s", def_triple, error); LLVMTargetMachineRef tm = LLVMCreateTargetMachine(target_ref, def_triple, "", "", LLVMCodeGenLevelDefault, reloc, model); LLVMDisposeMessage(def_triple); return tm; } static LLVMBasicBlockRef llvm_append_block(llvm_obj_t *obj, LLVMValueRef fn, const char *name) { return LLVMAppendBasicBlockInContext(obj->context, fn, name); } static LLVMValueRef llvm_add_fn(llvm_obj_t *obj, const char *name, LLVMTypeRef type) { LLVMValueRef fn = LLVMGetNamedFunction(obj->module, name); if (fn == NULL) fn = LLVMAddFunction(obj->module, name, type); return fn; } static LLVMValueRef llvm_get_fn(llvm_obj_t *obj, llvm_fn_t which) { if (obj->fns[which] != NULL) return obj->fns[which]; LLVMValueRef fn = NULL; switch (which) { case LLVM_ADD_OVERFLOW_S8: case LLVM_ADD_OVERFLOW_S16: case LLVM_ADD_OVERFLOW_S32: case LLVM_ADD_OVERFLOW_S64: { jit_size_t sz = which - LLVM_ADD_OVERFLOW_S8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.sadd.with.overflow.i8", "llvm.sadd.with.overflow.i16", "llvm.sadd.with.overflow.i32", "llvm.sadd.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_ADD_OVERFLOW_U8: case LLVM_ADD_OVERFLOW_U16: case LLVM_ADD_OVERFLOW_U32: case LLVM_ADD_OVERFLOW_U64: { jit_size_t sz = which - LLVM_ADD_OVERFLOW_U8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.uadd.with.overflow.i8", "llvm.uadd.with.overflow.i16", "llvm.uadd.with.overflow.i32", "llvm.uadd.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_SUB_OVERFLOW_S8: case LLVM_SUB_OVERFLOW_S16: case LLVM_SUB_OVERFLOW_S32: case LLVM_SUB_OVERFLOW_S64: { jit_size_t sz = which - LLVM_SUB_OVERFLOW_S8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.ssub.with.overflow.i8", "llvm.ssub.with.overflow.i16", "llvm.ssub.with.overflow.i32", "llvm.ssub.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_SUB_OVERFLOW_U8: case LLVM_SUB_OVERFLOW_U16: case LLVM_SUB_OVERFLOW_U32: case LLVM_SUB_OVERFLOW_U64: { jit_size_t sz = which - LLVM_SUB_OVERFLOW_U8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.usub.with.overflow.i8", "llvm.usub.with.overflow.i16", "llvm.usub.with.overflow.i32", "llvm.usub.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_MUL_OVERFLOW_S8: case LLVM_MUL_OVERFLOW_S16: case LLVM_MUL_OVERFLOW_S32: case LLVM_MUL_OVERFLOW_S64: { jit_size_t sz = which - LLVM_MUL_OVERFLOW_S8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.smul.with.overflow.i8", "llvm.smul.with.overflow.i16", "llvm.smul.with.overflow.i32", "llvm.smul.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_MUL_OVERFLOW_U8: case LLVM_MUL_OVERFLOW_U16: case LLVM_MUL_OVERFLOW_U32: case LLVM_MUL_OVERFLOW_U64: { jit_size_t sz = which - LLVM_MUL_OVERFLOW_U8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.umul.with.overflow.i8", "llvm.umul.with.overflow.i16", "llvm.umul.with.overflow.i32", "llvm.umul.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_EXP_OVERFLOW_S8: case LLVM_EXP_OVERFLOW_S16: case LLVM_EXP_OVERFLOW_S32: case LLVM_EXP_OVERFLOW_S64: { jit_size_t sz = which - LLVM_EXP_OVERFLOW_S8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "nvc.sexp.with.overflow.i16", "nvc.sexp.with.overflow.i16", "nvc.sexp.with.overflow.i32", "nvc.sexp.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; case LLVM_EXP_OVERFLOW_U8: case LLVM_EXP_OVERFLOW_U16: case LLVM_EXP_OVERFLOW_U32: case LLVM_EXP_OVERFLOW_U64: { jit_size_t sz = which - LLVM_EXP_OVERFLOW_U8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(pair_type, args, ARRAY_LEN(args), false); static const char *names[] = { "nvc.uexp.with.overflow.i16", "nvc.uexp.with.overflow.i16", "nvc.uexp.with.overflow.i32", "nvc.uexp.with.overflow.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_ADD_SAT_U8: case LLVM_ADD_SAT_U16: case LLVM_ADD_SAT_U32: case LLVM_ADD_SAT_U64: { jit_size_t sz = which - LLVM_ADD_SAT_U8; LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef args[] = { int_type, int_type }; obj->fntypes[which] = LLVMFunctionType(int_type, args, ARRAY_LEN(args), false); static const char *names[] = { "llvm.uadd.sat.i8", "llvm.uadd.sat.i16", "llvm.uadd.sat.i32", "llvm.uadd.sat.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_MEMSET_U8: case LLVM_MEMSET_U16: case LLVM_MEMSET_U32: case LLVM_MEMSET_U64: { jit_size_t sz = which - LLVM_MEMSET_U8; LLVMTypeRef args[] = { obj->types[LLVM_PTR], obj->types[LLVM_INT8 + sz], obj->types[LLVM_INT64] }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); static const char *names[] = { NULL, // Use regular memset instead "nvc.memset.i16", "nvc.memset.i32", "nvc.memset.i64" }; fn = llvm_add_fn(obj, names[sz], obj->fntypes[which]); } break; case LLVM_POW_F64: { LLVMTypeRef args[] = { obj->types[LLVM_DOUBLE], obj->types[LLVM_DOUBLE] }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_DOUBLE], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "llvm.pow.f64", obj->fntypes[which]); } break; case LLVM_COPYSIGN_F64: { LLVMTypeRef args[] = { obj->types[LLVM_DOUBLE], obj->types[LLVM_DOUBLE] }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_DOUBLE], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "llvm.copysign.f64", obj->fntypes[which]); } break; case LLVM_MEMSET_INLINE: { LLVMTypeRef args[] = { obj->types[LLVM_PTR], obj->types[LLVM_INT8], obj->types[LLVM_INT64], obj->types[LLVM_INT1], }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "llvm.memset.inline.p0.i64", obj->fntypes[which]); } break; case LLVM_MEMCPY_INLINE: { LLVMTypeRef args[] = { obj->types[LLVM_PTR], obj->types[LLVM_PTR], obj->types[LLVM_INT64], obj->types[LLVM_INT1], }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "llvm.memcpy.inline.p0.p0.i64", obj->fntypes[which]); } break; case LLVM_DO_EXIT: { LLVMTypeRef args[] = { obj->types[LLVM_INT32], obj->types[LLVM_PTR], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_INT64], 0), #endif #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_TLAB], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_do_exit", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); llvm_add_func_attr(obj, fn, FUNC_ATTR_READONLY, 2); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 2); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 3); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 4); } break; case LLVM_SCHED_WAVEFORM: case LLVM_TEST_EVENT: case LLVM_LAST_EVENT: case LLVM_SCHED_PROCESS: { LLVMTypeRef args[] = { obj->types[LLVM_PTR], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_INT64], 0), #endif #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_TLAB], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); const char *sym = NULL; switch (which) { case LLVM_SCHED_WAVEFORM: sym = "__nvc_sched_waveform"; break; case LLVM_TEST_EVENT: sym = "__nvc_test_event"; break; case LLVM_LAST_EVENT: sym = "__nvc_last_event"; break; case LLVM_SCHED_PROCESS: sym = "__nvc_sched_process"; break; default: break; } fn = llvm_add_fn(obj, sym, obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); llvm_add_func_attr(obj, fn, FUNC_ATTR_READONLY, 1); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 1); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 2); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 3); } break; case LLVM_PUTPRIV: { LLVMTypeRef args[] = { obj->types[LLVM_INT32], obj->types[LLVM_PTR] }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_putpriv", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; case LLVM_PACK: { LLVMTypeRef args[] = { obj->types[LLVM_PTR], obj->types[LLVM_INT32], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_INT64], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_pack", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; case LLVM_UNPACK: { LLVMTypeRef args[] = { obj->types[LLVM_INT64], obj->types[LLVM_INT64], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_INT64], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_VOID], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_unpack", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; case LLVM_MSPACE_ALLOC: { LLVMTypeRef args[] = { obj->types[LLVM_INTPTR], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_ANCHOR], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_PTR], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_mspace_alloc", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; case LLVM_GET_OBJECT: { LLVMTypeRef args[] = { obj->types[LLVM_PTR], obj->types[LLVM_INTPTR] }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_PTR], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "__nvc_get_object", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOCAPTURE, 1); llvm_add_func_attr(obj, fn, FUNC_ATTR_READONLY, 1); } break; case LLVM_TLAB_ALLOC: { LLVMTypeRef args[] = { #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_TLAB], 0), #endif obj->types[LLVM_INTPTR], #ifdef LLVM_HAS_OPAQUE_POINTERS obj->types[LLVM_PTR], #else LLVMPointerType(obj->types[LLVM_ANCHOR], 0), #endif }; obj->fntypes[which] = LLVMFunctionType(obj->types[LLVM_PTR], args, ARRAY_LEN(args), false); fn = llvm_add_fn(obj, "tlab_alloc", obj->fntypes[which]); llvm_add_func_attr(obj, fn, FUNC_ATTR_NOUNWIND, -1); } break; default: fatal_trace("cannot generate prototype for function %d", which); } return (obj->fns[which] = fn); } static LLVMValueRef llvm_call_fn(llvm_obj_t *obj, llvm_fn_t which, LLVMValueRef *args, unsigned count) { LLVMValueRef fn = llvm_get_fn(obj, which); return LLVMBuildCall2(obj->builder, obj->fntypes[which], fn, args, count, ""); } static LLVMValueRef llvm_const_string(llvm_obj_t *obj, const char *str) { const unsigned off = pack_writer_get_string(obj->pack_writer, str); LLVMValueRef indexes[] = { llvm_int32(obj, 0), llvm_int32(obj, off) }; return LLVMBuildGEP2(obj->builder, obj->types[LLVM_STRTAB], obj->strtab, indexes, ARRAY_LEN(indexes), "string"); } #if ENABLE_DWARF static void llvm_add_module_flag(llvm_obj_t *obj, const char *key, int value) { LLVMAddModuleFlag(obj->module, LLVMModuleFlagBehaviorWarning, key, strlen(key), LLVMValueAsMetadata(llvm_int32(obj, value))); } #endif static bool llvm_is_ptr(LLVMValueRef value) { return LLVMGetTypeKind(LLVMTypeOf(value)) == LLVMPointerTypeKind; } #ifdef DEBUG static void llvm_set_value_name(LLVMValueRef value, const char *name) { size_t curlen; LLVMGetValueName2(value, &curlen); if (curlen == 0) LLVMSetValueName(value, name); } __attribute__((unused)) static void llvm_dump_value(const char *tag, LLVMValueRef value) { fprintf(stderr, "%s: ", tag); fflush(stderr); LLVMDumpValue(value); fprintf(stderr, "\n"); } #endif static void llvm_native_setup(void) { LLVMInitializeNativeTarget(); LLVMInitializeNativeAsmPrinter(); if (!LLVMIsMultithreaded()) fatal("LLVM was built without multithreaded support"); } //////////////////////////////////////////////////////////////////////////////// // JIT IR to LLVM lowering static const char *cgen_reg_name(jit_reg_t reg) { #ifdef DEBUG static volatile int uniq = 0; static __thread char buf[32]; checked_sprintf(buf, sizeof(buf), "R%d.%d", reg, relaxed_add(&uniq, 1)); return buf; #else return ""; #endif } static const char *cgen_arg_name(int nth) { #ifdef DEBUG static volatile int uniq = 0; static __thread char buf[32]; checked_sprintf(buf, sizeof(buf), "A%d.%d", nth, relaxed_add(&uniq, 1)); return buf; #else return ""; #endif } __attribute__((noreturn)) static void cgen_abort(cgen_block_t *cgb, jit_ir_t *ir, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *text LOCAL = xvasprintf(fmt, ap); jit_dump_with_mark(cgb->func->source, ir - cgb->func->source->irbuf); fatal_trace("%s", text); va_end(ap); } static LLVMRealPredicate cgen_real_pred(cgen_block_t *cgb, jit_ir_t *ir) { switch (ir->cc) { case JIT_CC_EQ: return LLVMRealOEQ; case JIT_CC_NE: return LLVMRealONE; case JIT_CC_GT: return LLVMRealOGT; case JIT_CC_LT: return LLVMRealOLT; case JIT_CC_LE: return LLVMRealOLE; case JIT_CC_GE: return LLVMRealOGE; default: cgen_abort(cgb, ir, "unhandled fcmp condition code"); } } static LLVMIntPredicate cgen_int_pred(cgen_block_t *cgb, jit_ir_t *ir) { switch (ir->cc) { case JIT_CC_EQ: return LLVMIntEQ; case JIT_CC_NE: return LLVMIntNE; case JIT_CC_GT: return LLVMIntSGT; case JIT_CC_LT: return LLVMIntSLT; case JIT_CC_LE: return LLVMIntSLE; case JIT_CC_GE: return LLVMIntSGE; default: cgen_abort(cgb, ir, "unhandled cmp condition code"); } } static cgen_reloc_t *cgen_find_reloc(cgen_reloc_t *list, reloc_kind_t kind, int limit, uintptr_t key) { for (int i = 0; i < limit; i++) { if (list[i].kind == kind && list[i].key == key) return &(list[i]); else if (list[i].kind == RELOC_NULL) break; } return NULL; } static LLVMValueRef cgen_load_from_reloc(llvm_obj_t *obj, cgen_func_t *func, reloc_kind_t kind, uintptr_t key) { cgen_reloc_t *reloc = cgen_find_reloc(func->relocs, kind, INT_MAX, key); assert(reloc != NULL); LLVMValueRef array = LLVMBuildStructGEP2(obj->builder, func->descr_type, func->descr, 4, ""); LLVMValueRef indexes[] = { llvm_intptr(obj, 0), llvm_intptr(obj, reloc->nth) }; LLVMValueRef elem = LLVMBuildInBoundsGEP2(obj->builder, func->reloc_type, array, indexes, ARRAY_LEN(indexes), ""); LLVMValueRef ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_AOT_RELOC], elem, 1, ""); return LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], ptr, ""); } static LLVMValueRef cgen_rematerialise_object(llvm_obj_t *obj, cgen_func_t *func, object_t *locus) { if (func->mode == CGEN_AOT) { ident_t module; ptrdiff_t offset; object_locus(locus, &module, &offset); LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, module); LLVMValueRef unit_str = llvm_const_string(obj, tb_get(tb)); LLVMValueRef args[] = { unit_str, llvm_intptr(obj, offset), }; return llvm_call_fn(obj, LLVM_GET_OBJECT, args, ARRAY_LEN(args)); } else return llvm_ptr(obj, locus); } static LLVMValueRef cgen_rematerialise_handle(llvm_obj_t *obj, cgen_func_t *func, jit_handle_t handle) { LLVMValueRef ptr = cgen_load_from_reloc(obj, func, RELOC_HANDLE, handle); LLVMValueRef intptr = LLVMBuildPtrToInt(obj->builder, ptr, obj->types[LLVM_INTPTR], ""); #ifdef DEBUG ident_t name = jit_get_name(func->source->jit, handle); char *valname LOCAL = xasprintf("%s.handle", istr(name)); #else const char *valname = ""; #endif return LLVMBuildTrunc(obj->builder, intptr, obj->types[LLVM_INT32], valname); } static LLVMValueRef cgen_get_value(llvm_obj_t *obj, cgen_block_t *cgb, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: assert(value.reg < cgb->func->source->nregs); assert(cgb->outregs[value.reg] != NULL); return cgb->outregs[value.reg]; case JIT_VALUE_INT64: return llvm_int64(obj, value.int64); case JIT_VALUE_DOUBLE: return llvm_real(obj, value.dval); case JIT_ADDR_CPOOL: assert(value.int64 >= 0 && value.int64 <= cgb->func->source->cpoolsz); if (cgb->func->mode == CGEN_AOT) { LLVMValueRef indexes[] = { llvm_intptr(obj, 0), llvm_intptr(obj, value.int64) }; return LLVMBuildInBoundsGEP2(obj->builder, cgb->func->cpool_type, cgb->func->cpool, indexes, ARRAY_LEN(indexes), ""); } else return llvm_ptr(obj, cgb->func->source->cpool + value.int64); case JIT_ADDR_REG: { assert(value.reg < cgb->func->source->nregs); LLVMValueRef ptr = cgb->outregs[value.reg]; if (value.disp == 0) return ptr; else if (llvm_is_ptr(ptr)) { LLVMValueRef indexes[] = { llvm_intptr(obj, value.disp) }; return LLVMBuildGEP2(obj->builder, obj->types[LLVM_INT8], ptr, indexes, 1, ""); } else { LLVMValueRef disp = llvm_int64(obj, value.disp); return LLVMBuildAdd(obj->builder, ptr, disp, ""); } } case JIT_VALUE_EXIT: return llvm_int32(obj, value.exit); case JIT_VALUE_HANDLE: if (cgb->func->mode == CGEN_AOT && value.handle != JIT_HANDLE_INVALID) return cgen_rematerialise_handle(obj, cgb->func, value.handle); else return llvm_int32(obj, value.handle); case JIT_ADDR_ABS: return llvm_ptr(obj, (void *)(intptr_t)value.int64); case JIT_ADDR_COVER: if (cgb->func->mode == CGEN_AOT) { LLVMValueRef ptr = cgen_load_from_reloc(obj, cgb->func, RELOC_COVER, 0); LLVMValueRef base = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], ptr, ""); LLVMValueRef indexes[] = { llvm_intptr(obj, value.int64) }; return LLVMBuildGEP2(obj->builder, obj->types[LLVM_INT32], base, indexes, 1, ""); } else return llvm_ptr(obj, jit_get_cover_ptr(cgb->func->source->jit, value)); case JIT_VALUE_LOCUS: return cgen_rematerialise_object(obj, cgb->func, value.locus); default: fatal_trace("cannot handle value kind %d", value.kind); } } static LLVMValueRef cgen_coerce_value(llvm_obj_t *obj, cgen_block_t *cgb, jit_value_t value, llvm_type_t type) { LLVMValueRef raw = cgen_get_value(obj, cgb, value); LLVMTypeRef lltype = LLVMTypeOf(raw); switch (type) { case LLVM_PTR: if (LLVMGetTypeKind(lltype) == LLVMIntegerTypeKind) return LLVMBuildIntToPtr(obj->builder, raw, obj->types[LLVM_PTR], ""); else return raw; case LLVM_INTPTR: case LLVM_INT64: case LLVM_INT32: case LLVM_INT16: case LLVM_INT8: case LLVM_INT1: switch (LLVMGetTypeKind(lltype)) { case LLVMPointerTypeKind: return LLVMBuildIntToPtr(obj->builder, raw, obj->types[LLVM_PTR], ""); case LLVMIntegerTypeKind: { const int bits1 = LLVMGetIntTypeWidth(lltype); const int bits2 = LLVMGetIntTypeWidth(obj->types[type]); if (bits2 == 1) { LLVMValueRef zero = LLVMConstInt(lltype, 0, false); return LLVMBuildICmp(obj->builder, LLVMIntNE, raw, zero, ""); } else if (bits1 < bits2) return LLVMBuildSExt(obj->builder, raw, obj->types[type], ""); else if (bits1 == bits2) return raw; else return LLVMBuildTrunc(obj->builder, raw, obj->types[type], ""); } case LLVMDoubleTypeKind: return LLVMBuildBitCast(obj->builder, raw, obj->types[type], ""); default: LLVMDumpType(lltype); fatal_trace("cannot coerce type to integer"); } break; case LLVM_DOUBLE: return LLVMBuildBitCast(obj->builder, raw, obj->types[type], ""); default: return raw; } } static void cgen_pointer_result(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir, LLVMValueRef value) { assert(llvm_is_ptr(value)); if (mask_test(&cgb->func->ptr_mask, ir->result)) { DEBUG_ONLY(llvm_set_value_name(value, cgen_reg_name(ir->result))); cgb->outregs[ir->result] = PTR(value); } else cgb->outregs[ir->result] = LLVMBuildPtrToInt(obj->builder, value, obj->types[LLVM_INT64], cgen_reg_name(ir->result)); } static void cgen_sext_result(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir, LLVMValueRef value) { LLVMTypeRef type = LLVMTypeOf(value); switch (LLVMGetTypeKind(type)) { case LLVMIntegerTypeKind: if (LLVMGetIntTypeWidth(type) == 64) { DEBUG_ONLY(llvm_set_value_name(value, cgen_reg_name(ir->result))); cgb->outregs[ir->result] = value; } else cgb->outregs[ir->result] = LLVMBuildSExt(obj->builder, value, obj->types[LLVM_INT64], cgen_reg_name(ir->result)); break; case LLVMDoubleTypeKind: cgb->outregs[ir->result] = LLVMBuildBitCast(obj->builder, value, obj->types[LLVM_INT64], cgen_reg_name(ir->result)); break; case LLVMPointerTypeKind: cgen_pointer_result(obj, cgb, ir, value); break; default: LLVMDumpType(type); fatal_trace("unhandled LLVM type kind in cgen_sext_result"); } } static void cgen_zext_result(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir, LLVMValueRef value) { LLVMTypeRef type = LLVMTypeOf(value); switch (LLVMGetTypeKind(type)) { case LLVMIntegerTypeKind: if (LLVMGetIntTypeWidth(type) == 64) { DEBUG_ONLY(llvm_set_value_name(value, cgen_reg_name(ir->result))); cgb->outregs[ir->result] = value; } else cgb->outregs[ir->result] = LLVMBuildZExt(obj->builder, value, obj->types[LLVM_INT64], cgen_reg_name(ir->result)); break; default: LLVMDumpType(type); fatal_trace("unhandled LLVM type kind in cgen_sext_result"); } } static void cgen_sync_irpos(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { const unsigned irpos = ir - cgb->func->source->irbuf; LLVMBuildStore(obj->builder, llvm_int32(obj, irpos), cgb->func->irpos); } #if ENABLE_DWARF static void cgen_debug_loc(llvm_obj_t *obj, cgen_func_t *func, const loc_t *loc) { if (loc_eq(loc, &(func->last_loc))) return; LLVMMetadataRef dloc = LLVMDIBuilderCreateDebugLocation( obj->context, loc->first_line, loc->first_column, func->debugmd, NULL); #ifdef LLVM_HAVE_SET_CURRENT_DEBUG_LOCATION_2 LLVMSetCurrentDebugLocation2(obj->builder, dloc); #else LLVMValueRef md = LLVMMetadataAsValue(obj->context, dloc); LLVMSetCurrentDebugLocation(obj->builder, md); #endif } #endif static void cgen_op_recv(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { assert(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; LLVMValueRef ptr; if (nth < ARGCACHE_SIZE) ptr = cgb->func->argcache[nth]; else { assert(nth < JIT_MAX_ARGS); LLVMValueRef indexes[] = { llvm_intptr(obj, nth) }; ptr = LLVMBuildInBoundsGEP2(obj->builder, obj->types[LLVM_INT64], cgb->func->args, indexes, ARRAY_LEN(indexes), cgen_arg_name(nth)); } llvm_type_t type = mask_test(&cgb->func->ptr_mask, ir->result) ? LLVM_PTR : LLVM_INT64; #ifdef LLVM_HAS_OPAQUE_POINTERS LLVMValueRef cast = ptr; #else LLVMTypeRef ptr_type = LLVMPointerType(obj->types[type], 0); LLVMValueRef cast = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); #endif cgb->outregs[ir->result] = LLVMBuildLoad2(obj->builder, obj->types[type], cast, cgen_reg_name(ir->result)); LLVMSetAlignment(cgb->outregs[ir->result], sizeof(int64_t)); } static void cgen_op_send(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { assert(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; LLVMValueRef value = cgen_get_value(obj, cgb, ir->arg2); LLVMValueRef ptr; if (nth < ARGCACHE_SIZE) ptr = cgb->func->argcache[nth]; else { assert(nth < JIT_MAX_ARGS); LLVMValueRef indexes[] = { llvm_int32(obj, nth) }; LLVMTypeRef int64_type = obj->types[LLVM_INT64]; #ifdef LLVM_HAS_OPAQUE_POINTERS LLVMValueRef args_cast = cgb->func->args; #else LLVMTypeRef args_ptr_type = LLVMPointerType(int64_type, 0); LLVMValueRef args_cast = LLVMBuildPointerCast(obj->builder, cgb->func->args, args_ptr_type, ""); #endif ptr = LLVMBuildInBoundsGEP2(obj->builder, int64_type, args_cast, indexes, ARRAY_LEN(indexes), cgen_arg_name(nth)); } #ifdef LLVM_HAS_OPAQUE_POINTERS LLVMValueRef store = LLVMBuildStore(obj->builder, value, ptr); #else LLVMTypeRef ptr_type = LLVMPointerType(LLVMTypeOf(value), 0); LLVMValueRef cast = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); LLVMValueRef store = LLVMBuildStore(obj->builder, value, cast); #endif LLVMSetAlignment(store, sizeof(int64_t)); } static void cgen_op_store(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { llvm_type_t type = LLVM_INT8 + ir->size; LLVMValueRef value = cgen_coerce_value(obj, cgb, ir->arg1, type); LLVMValueRef ptr = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_PTR); #ifdef LLVM_HAS_OPAQUE_POINTERS LLVMValueRef store = LLVMBuildStore(obj->builder, value, ptr); #else LLVMTypeRef ptr_type = LLVMPointerType(LLVMTypeOf(value), 0); LLVMValueRef cast = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); LLVMValueRef store = LLVMBuildStore(obj->builder, value, cast); #endif LLVMSetAlignment(store, 1 << ir->size); } static void cgen_op_load(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef ptr = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); llvm_type_t type = mask_test(&cgb->func->ptr_mask, ir->result) ? LLVM_PTR : LLVM_INT8 + ir->size; #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[type], 0); ptr = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); #endif if (type == LLVM_INT64) { LLVMValueRef value = LLVMBuildLoad2(obj->builder, obj->types[type], ptr, cgen_reg_name(ir->result)); LLVMSetAlignment(value, 1 << ir->size); cgb->outregs[ir->result] = value; } else { LLVMValueRef tmp = LLVMBuildLoad2(obj->builder, obj->types[type], ptr, ""); LLVMSetAlignment(tmp, 1 << ir->size); if (ir->op == J_ULOAD) cgen_zext_result(obj, cgb, ir, tmp); else cgen_sext_result(obj, cgb, ir, tmp); } } static void cgen_op_add(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { llvm_fn_t fn = LLVM_LAST_FN; if (ir->cc == JIT_CC_O) fn = LLVM_ADD_OVERFLOW_S8 + ir->size; else if (ir->cc == JIT_CC_C) fn = LLVM_ADD_OVERFLOW_U8 + ir->size; if (fn != LLVM_LAST_FN) { llvm_type_t type = LLVM_INT8 + ir->size; LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, type); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, type); LLVMValueRef args[] = { arg1, arg2 }; LLVMValueRef pair = llvm_call_fn(obj, fn, args, 2); LLVMValueRef result = LLVMBuildExtractValue(obj->builder, pair, 0, ""); cgb->outflags = LLVMBuildExtractValue(obj->builder, pair, 1, "FLAGS"); if (ir->cc == JIT_CC_C) cgen_zext_result(obj, cgb, ir, result); else cgen_sext_result(obj, cgb, ir, result); } else { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); if (llvm_is_ptr(arg1)) { LLVMValueRef indexes[] = { arg2 }; LLVMValueRef ptr = LLVMBuildGEP2(obj->builder, obj->types[LLVM_INT8], arg1, indexes, 1, ""); cgen_pointer_result(obj, cgb, ir, ptr); } else if (mask_test(&cgb->func->ptr_mask, ir->result)) { LLVMValueRef base = LLVMBuildIntToPtr(obj->builder, arg1, obj->types[LLVM_PTR], ""); LLVMValueRef indexes[] = { arg2 }; LLVMValueRef ptr = LLVMBuildGEP2(obj->builder, obj->types[LLVM_INT8], base, indexes, 1, ""); cgen_pointer_result(obj, cgb, ir, ptr); } else cgb->outregs[ir->result] = LLVMBuildAdd(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } } static void cgen_op_sub(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { llvm_fn_t fn = LLVM_LAST_FN; if (ir->cc == JIT_CC_O) fn = LLVM_SUB_OVERFLOW_S8 + ir->size; else if (ir->cc == JIT_CC_C) fn = LLVM_SUB_OVERFLOW_U8 + ir->size; if (fn != LLVM_LAST_FN) { llvm_type_t type = LLVM_INT8 + ir->size; LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, type); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, type); LLVMValueRef args[] = { arg1, arg2 }; LLVMValueRef pair = llvm_call_fn(obj, fn, args, 2); LLVMValueRef result = LLVMBuildExtractValue(obj->builder, pair, 0, ""); cgb->outflags = LLVMBuildExtractValue(obj->builder, pair, 1, "FLAGS"); if (ir->cc == JIT_CC_C) cgen_zext_result(obj, cgb, ir, result); else cgen_sext_result(obj, cgb, ir, result); } else { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildSub(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } } static void cgen_op_mul(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { llvm_fn_t fn = LLVM_LAST_FN; if (ir->cc == JIT_CC_O) fn = LLVM_MUL_OVERFLOW_S8 + ir->size; else if (ir->cc == JIT_CC_C) fn = LLVM_MUL_OVERFLOW_U8 + ir->size; if (fn != LLVM_LAST_FN) { llvm_type_t type = LLVM_INT8 + ir->size; LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, type); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, type); LLVMValueRef args[] = { arg1, arg2 }; LLVMValueRef pair = llvm_call_fn(obj, fn, args, 2); LLVMValueRef result = LLVMBuildExtractValue(obj->builder, pair, 0, ""); cgb->outflags = LLVMBuildExtractValue(obj->builder, pair, 1, "FLAGS"); if (ir->cc == JIT_CC_C) cgen_zext_result(obj, cgb, ir, result); else cgen_sext_result(obj, cgb, ir, result); } else { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildMul(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } } static void cgen_op_div(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildSDiv(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } static void cgen_op_rem(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildSRem(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } static void cgen_op_shl(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildShl(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } static void cgen_op_asr(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); cgb->outregs[ir->result] = LLVMBuildAShr(obj->builder, arg1, arg2, cgen_reg_name(ir->result)); } static void cgen_op_fadd(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMValueRef real = LLVMBuildFAdd(obj->builder, arg1, arg2, ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_fsub(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMValueRef real = LLVMBuildFSub(obj->builder, arg1, arg2, ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_fmul(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMValueRef real = LLVMBuildFMul(obj->builder, arg1, arg2, ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_fdiv(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMValueRef real = LLVMBuildFDiv(obj->builder, arg1, arg2, ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_fneg(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef real = LLVMBuildFNeg(obj->builder, arg1, ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_fcvtns(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef args[] = { llvm_real(obj, 0.5), arg1 }; LLVMValueRef half = llvm_call_fn(obj, LLVM_COPYSIGN_F64, args, 2); LLVMValueRef rounded = LLVMBuildFAdd(obj->builder, arg1, half, ""); cgb->outregs[ir->result] = LLVMBuildFPToSI(obj->builder, rounded, obj->types[LLVM_INT64], cgen_reg_name(ir->result)); } static void cgen_op_scvtf(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef real = LLVMBuildSIToFP(obj->builder, arg1, obj->types[LLVM_DOUBLE], ""); cgen_sext_result(obj, cgb, ir, real); } static void cgen_op_not(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_INT1); LLVMValueRef logical = LLVMBuildNot(obj->builder, arg1, ""); cgen_zext_result(obj, cgb, ir, logical); } static void cgen_op_and(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); LLVMValueRef logical = LLVMBuildAnd(obj->builder, arg1, arg2, ""); cgen_zext_result(obj, cgb, ir, logical); } static void cgen_op_or(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); LLVMValueRef logical = LLVMBuildOr(obj->builder, arg1, arg2, ""); cgen_zext_result(obj, cgb, ir, logical); } static void cgen_op_xor(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); LLVMValueRef logical = LLVMBuildXor(obj->builder, arg1, arg2, ""); cgen_zext_result(obj, cgb, ir, logical); } static void cgen_op_ret(llvm_obj_t *obj, jit_ir_t *ir) { LLVMBuildRetVoid(obj->builder); } static void cgen_op_jump(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { if (ir->cc == JIT_CC_NONE) { assert(cgb->source->out.count == 1); LLVMBasicBlockRef dest = cgb->func->blocks[jit_get_edge(&(cgb->source->out), 0)].bbref; LLVMBuildBr(obj->builder, dest); } else if (ir->cc == JIT_CC_T) { assert(cgb->source->out.count == 2); LLVMBasicBlockRef dest_t = cgb->func->blocks[jit_get_edge(&(cgb->source->out), 1)].bbref; LLVMBasicBlockRef dest_f = (cgb + 1)->bbref; LLVMBuildCondBr(obj->builder, cgb->outflags, dest_t, dest_f); } else if (ir->cc == JIT_CC_F) { assert(cgb->source->out.count == 2); LLVMBasicBlockRef dest_t = cgb->func->blocks[jit_get_edge(&(cgb->source->out), 1)].bbref; LLVMBasicBlockRef dest_f = (cgb + 1)->bbref; LLVMBuildCondBr(obj->builder, cgb->outflags, dest_f, dest_t); } else cgen_abort(cgb, ir, "unhandled jump condition code"); } static void cgen_op_cmp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); const bool arg1_ptr = llvm_is_ptr(arg1); const bool arg2_ptr = llvm_is_ptr(arg2); if (arg1_ptr && !arg2_ptr) arg2 = LLVMBuildIntToPtr(obj->builder, arg2, obj->types[LLVM_PTR], ""); else if (!arg1_ptr && arg2_ptr) arg1 = LLVMBuildIntToPtr(obj->builder, arg1, obj->types[LLVM_PTR], ""); LLVMIntPredicate pred = cgen_int_pred(cgb, ir); cgb->outflags = LLVMBuildICmp(obj->builder, pred, arg1, arg2, "FLAGS"); } static void cgen_op_ccmp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); const bool arg1_ptr = llvm_is_ptr(arg1); const bool arg2_ptr = llvm_is_ptr(arg2); if (arg1_ptr && !arg2_ptr) arg2 = LLVMBuildIntToPtr(obj->builder, arg2, obj->types[LLVM_PTR], ""); else if (!arg1_ptr && arg2_ptr) arg1 = LLVMBuildIntToPtr(obj->builder, arg1, obj->types[LLVM_PTR], ""); LLVMIntPredicate pred = cgen_int_pred(cgb, ir); LLVMValueRef cmp = LLVMBuildICmp(obj->builder, pred, arg1, arg2, ""); cgb->outflags = LLVMBuildAnd(obj->builder, cgb->outflags, cmp, "FLAGS"); } static void cgen_op_fcmp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMRealPredicate pred = cgen_real_pred(cgb, ir); cgb->outflags = LLVMBuildFCmp(obj->builder, pred, arg1, arg2, "FLAGS"); } static void cgen_op_fccmp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMRealPredicate pred = cgen_real_pred(cgb, ir); LLVMValueRef cmp = LLVMBuildFCmp(obj->builder, pred, arg1, arg2, ""); cgb->outflags = LLVMBuildAnd(obj->builder, cgb->outflags, cmp, "FLAGS"); } static void cgen_op_cset(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { cgen_zext_result(obj, cgb, ir, cgb->outflags); } static void cgen_op_csel(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef arg2 = cgen_get_value(obj, cgb, ir->arg2); LLVMValueRef result = LLVMBuildSelect(obj->builder, cgb->outflags, arg1, arg2, ""); cgen_sext_result(obj, cgb, ir, result); } static void cgen_op_call(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { cgen_sync_irpos(obj, cgb, ir); jit_func_t *callee = jit_get_func(cgb->func->source->jit, ir->arg1.handle); LLVMValueRef entry = NULL, fptr = NULL; if (cgb->func->mode == CGEN_AOT) { cgen_reloc_t *reloc = cgen_find_reloc(cgb->func->relocs, RELOC_FUNC, INT_MAX, ir->arg1.handle); assert(reloc != NULL); LLVMValueRef array = LLVMBuildStructGEP2(obj->builder, cgb->func->descr_type, cgb->func->descr, 4, ""); LLVMValueRef indexes[] = { llvm_intptr(obj, 0), llvm_intptr(obj, reloc->nth) }; LLVMValueRef elem = LLVMBuildInBoundsGEP2(obj->builder, cgb->func->reloc_type, array, indexes, ARRAY_LEN(indexes), ""); LLVMValueRef ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_AOT_RELOC], elem, 1, ""); fptr = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], ptr, ""); #if CLOSED_WORLD // Do not generate direct calls for intrinsics if (relaxed_load(&callee->entry) == jit_interp) { LOCAL_TEXT_BUF symbol = safe_symbol(callee->name); entry = llvm_add_fn(obj, tb_get(symbol), obj->types[LLVM_ENTRY_FN]); } #endif } else fptr = llvm_ptr(obj, callee); if (entry == NULL) { // Must have acquire semantics to synchronise with installing new code entry = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], fptr, "entry"); LLVMSetAlignment(entry, sizeof(void *)); LLVMSetOrdering(entry, LLVMAtomicOrderingAcquire); } #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[LLVM_ENTRY_FN], 0); entry = LLVMBuildPointerCast(obj->builder, entry, ptr_type, ""); #endif LLVMValueRef args[] = { fptr, PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; LLVMBuildCall2(obj->builder, obj->types[LLVM_ENTRY_FN], entry, args, ARRAY_LEN(args), ""); } static void cgen_op_lea(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef ptr = cgen_get_value(obj, cgb, ir->arg1); if (llvm_is_ptr(ptr)) cgen_pointer_result(obj, cgb, ir, ptr); else cgen_zext_result(obj, cgb, ir, ptr); } static void cgen_op_mov(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef value = cgen_get_value(obj, cgb, ir->arg1); cgen_sext_result(obj, cgb, ir, value); } static void cgen_op_neg(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef neg = LLVMBuildNeg(obj->builder, arg1, cgen_reg_name(ir->result)); cgb->outregs[ir->result] = neg; } static void cgen_op_clamp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef zero = llvm_int64(obj, 0); LLVMValueRef isneg = LLVMBuildICmp(obj->builder, LLVMIntSLT, arg1, zero, ""); LLVMValueRef clamp = LLVMBuildSelect(obj->builder, isneg, zero, arg1, ""); cgb->outregs[ir->result] = clamp; } static void cgen_macro_exp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { llvm_fn_t fn = LLVM_EXP_OVERFLOW_S64; if (ir->cc == JIT_CC_O) fn = LLVM_EXP_OVERFLOW_S8 + ir->size; else if (ir->cc == JIT_CC_C) fn = LLVM_EXP_OVERFLOW_U8 + ir->size; llvm_type_t type = LLVM_INT8 + ir->size; LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, type); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, type); LLVMValueRef args[] = { arg1, arg2 }; LLVMValueRef pair = llvm_call_fn(obj, fn, args, 2); LLVMValueRef result = LLVMBuildExtractValue(obj->builder, pair, 0, ""); cgb->outflags = LLVMBuildExtractValue(obj->builder, pair, 1, "FLAGS"); if (ir->cc == JIT_CC_C) cgen_zext_result(obj, cgb, ir, result); else cgen_sext_result(obj, cgb, ir, result); } static void cgen_macro_fexp(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef arg1 = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_DOUBLE); LLVMValueRef arg2 = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_DOUBLE); LLVMValueRef args[] = { arg1, arg2 }; LLVMValueRef real = llvm_call_fn(obj, LLVM_POW_F64, args, 2); cgen_sext_result(obj, cgb, ir, real); } static void cgen_macro_copy(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef count = cgb->outregs[ir->result]; LLVMValueRef dest = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); LLVMValueRef src = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_PTR); #ifdef LLVM_HAS_OPAQUE_POINTERS if (LLVMIsConstant(count) && LLVMConstIntGetZExtValue(count) <= 64) { LLVMValueRef args[] = { dest, src, count, llvm_int1(obj, 0), }; llvm_call_fn(obj, LLVM_MEMCPY_INLINE, args, ARRAY_LEN(args)); } else #endif LLVMBuildMemCpy(obj->builder, dest, 0, src, 0, count); } static void cgen_macro_move(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef count = cgb->outregs[ir->result]; LLVMValueRef dest = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); LLVMValueRef src = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_PTR); LLVMBuildMemMove(obj->builder, dest, 0, src, 0, count); } static void cgen_macro_bzero(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef count = cgb->outregs[ir->result]; LLVMValueRef dest = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); #ifdef LLVM_HAS_OPAQUE_POINTERS if (LLVMIsConstant(count) && LLVMConstIntGetZExtValue(count) <= 64) { LLVMValueRef args[] = { dest, llvm_int8(obj, 0), count, llvm_int1(obj, 0), }; llvm_call_fn(obj, LLVM_MEMSET_INLINE, args, ARRAY_LEN(args)); } else #endif LLVMBuildMemSet(obj->builder, PTR(dest), llvm_int8(obj, 0), count, 0); } static void cgen_macro_memset(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef count = cgb->outregs[ir->result]; LLVMValueRef dest = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); LLVMValueRef value = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_INT8 + ir->size); if (ir->size == JIT_SZ_8) { #ifdef LLVM_HAS_OPAQUE_POINTERSS if (LLVMIsConstant(count) && LLVMConstIntGetZExtValue(count) <= 64) { LLVMValueRef args[] = { dest, value, count, llvm_int1(obj, 0), }; llvm_call_fn(obj, LLVM_MEMSET_INLINE, args, ARRAY_LEN(args)); } else #endif LLVMBuildMemSet(obj->builder, PTR(dest), value, count, 0); } else { LLVMValueRef args[] = { dest, value, count, }; llvm_call_fn(obj, LLVM_MEMSET_U8 + ir->size, args, ARRAY_LEN(args)); } } static void cgen_macro_exit(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { cgen_sync_irpos(obj, cgb, ir); switch (ir->arg1.exit) { case JIT_EXIT_SCHED_WAVEFORM: { LLVMValueRef args[] = { PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; llvm_call_fn(obj, LLVM_SCHED_WAVEFORM, args, ARRAY_LEN(args)); } break; case JIT_EXIT_TEST_EVENT: { LLVMValueRef args[] = { PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; llvm_call_fn(obj, LLVM_TEST_EVENT, args, ARRAY_LEN(args)); } break; case JIT_EXIT_LAST_EVENT: { LLVMValueRef args[] = { PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; llvm_call_fn(obj, LLVM_LAST_EVENT, args, ARRAY_LEN(args)); } break; case JIT_EXIT_SCHED_PROCESS: { LLVMValueRef args[] = { PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; llvm_call_fn(obj, LLVM_SCHED_PROCESS, args, ARRAY_LEN(args)); } break; default: { LLVMValueRef which = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef args[] = { which, PTR(cgb->func->anchor), cgb->func->args, cgb->func->tlab, }; llvm_call_fn(obj, LLVM_DO_EXIT, args, ARRAY_LEN(args)); } break; } } static void cgen_macro_galloc(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { cgen_sync_irpos(obj, cgb, ir); LLVMValueRef size = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef args[] = { LLVMBuildTrunc(obj->builder, size, obj->types[LLVM_INTPTR], ""), cgb->func->anchor }; LLVMValueRef ptr = llvm_call_fn(obj, LLVM_MSPACE_ALLOC, args, ARRAY_LEN(args)); cgen_pointer_result(obj, cgb, ir, ptr); } static void cgen_macro_lalloc(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { cgen_sync_irpos(obj, cgb, ir); LLVMValueRef size = cgen_get_value(obj, cgb, ir->arg1); LLVMValueRef args[] = { cgb->func->tlab, LLVMBuildTrunc(obj->builder, size, obj->types[LLVM_INTPTR], ""), cgb->func->anchor }; LLVMValueRef ptr = llvm_call_fn(obj, LLVM_TLAB_ALLOC, args, ARRAY_LEN(args)); cgen_pointer_result(obj, cgb, ir, ptr); } static void cgen_macro_salloc(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMBasicBlockRef old_bb = LLVMGetInsertBlock(obj->builder); LLVMBasicBlockRef first_bb = LLVMGetFirstBasicBlock(cgb->func->llvmfn); LLVMPositionBuilderAtEnd(obj->builder, first_bb); assert(ir->arg2.kind == JIT_VALUE_INT64); LLVMValueRef ptr; if (ir->arg2.int64 <= 8) ptr = LLVMBuildAlloca(obj->builder, obj->types[LLVM_INT64], ""); else ptr = LLVMBuildArrayAlloca(obj->builder, obj->types[LLVM_INT8], llvm_intptr(obj, ir->arg2.int64), ""); LLVMPositionBuilderAtEnd(obj->builder, old_bb); cgen_pointer_result(obj, cgb, ir, ptr); } static void cgen_macro_getpriv(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef ptrptr; if (cgb->func->mode == CGEN_JIT) { jit_func_t *f = jit_get_func(cgb->func->source->jit, ir->arg1.handle); ptrptr = llvm_ptr(obj, jit_get_privdata_ptr(f->jit, f)); } else ptrptr = cgen_load_from_reloc(obj, cgb->func, RELOC_PRIVDATA, ir->arg1.handle); #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[LLVM_PTR], 0); ptrptr = LLVMBuildPointerCast(obj->builder, ptrptr, ptr_type, ""); #endif LLVMValueRef ptr = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], ptrptr, "p2"); LLVMSetAlignment(ptr, sizeof(void *)); LLVMSetOrdering(ptr, LLVMAtomicOrderingAcquire); cgen_pointer_result(obj, cgb, ir, ptr); } static void cgen_macro_putpriv(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef value = cgen_coerce_value(obj, cgb, ir->arg2, LLVM_PTR); if (cgb->func->mode == CGEN_AOT) { LLVMValueRef ptr = cgen_load_from_reloc(obj, cgb->func, RELOC_PRIVDATA, ir->arg1.handle); #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[LLVM_PTR], 0); ptr = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); #endif LLVMValueRef store = LLVMBuildStore(obj->builder, value, ptr); LLVMSetAlignment(store, sizeof(void *)); LLVMSetOrdering(store, LLVMAtomicOrderingRelease); } else { LLVMValueRef args[] = { cgen_get_value(obj, cgb, ir->arg1), value, }; llvm_call_fn(obj, LLVM_PUTPRIV, args, ARRAY_LEN(args)); } } static void cgen_macro_pack(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef args[] = { cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR), cgen_coerce_value(obj, cgb, ir->arg2, LLVM_INT32), cgb->func->args, }; llvm_call_fn(obj, LLVM_PACK, args, ARRAY_LEN(args)); } static void cgen_macro_unpack(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef args[] = { cgen_get_value(obj, cgb, ir->arg1), cgen_get_value(obj, cgb, ir->arg2), cgb->func->args, }; llvm_call_fn(obj, LLVM_UNPACK, args, ARRAY_LEN(args)); } static void cgen_macro_case(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { jit_ir_t *first = cgb->func->source->irbuf + cgb->source->first; if (ir > first && (ir - 1)->op == MACRO_CASE) return; // Combined into previous $CASE LLVMBasicBlockRef elsebb = (cgb + 1)->bbref; LLVMValueRef test = cgb->outregs[ir->result]; assert(test != NULL); jit_ir_t *last = cgb->func->source->irbuf + cgb->source->last; const int numcases = last - ir + 1; assert(cgb->source->out.count == numcases + 1); LLVMValueRef stmt = LLVMBuildSwitch(obj->builder, test, elsebb, numcases); for (int nth = 0; nth < numcases; ir++, nth++) { assert(ir->op == MACRO_CASE); LLVMValueRef onval = cgen_get_value(obj, cgb, ir->arg1); LLVMBasicBlockRef dest = cgb->func->blocks[jit_get_edge(&(cgb->source->out), nth + 1)].bbref; LLVMAddCase(stmt, onval, dest); } } static void cgen_macro_trim(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef watermark_ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_ANCHOR], cgb->func->anchor, 3, ""); LLVMValueRef watermark = LLVMBuildLoad2(obj->builder, obj->types[LLVM_INT32], watermark_ptr, ""); LLVMValueRef alloc_ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_TLAB], cgb->func->tlab, 2, ""); LLVMBuildStore(obj->builder, watermark, alloc_ptr); } static void cgen_macro_reexec(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef fptr = LLVMGetParam(cgb->func->llvmfn, 0); // Must have acquire semantics to synchronise with installing new code LLVMValueRef entry = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], fptr, "entry"); LLVMSetAlignment(entry, sizeof(void *)); LLVMSetOrdering(entry, LLVMAtomicOrderingAcquire); #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[LLVM_ENTRY_FN], 0); entry = LLVMBuildPointerCast(obj->builder, entry, ptr_type, ""); #endif LLVMValueRef args[] = { fptr, LLVMGetParam(cgb->func->llvmfn, 1), cgb->func->args, cgb->func->tlab, }; LLVMValueRef call = LLVMBuildCall2(obj->builder, obj->types[LLVM_ENTRY_FN], entry, args, ARRAY_LEN(args), ""); LLVMSetTailCall(call, true); LLVMBuildRetVoid(obj->builder); } static void cgen_macro_sadd(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { LLVMValueRef ptr = cgen_coerce_value(obj, cgb, ir->arg1, LLVM_PTR); llvm_type_t type = LLVM_INT8 + ir->size; #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[type], 0); ptr = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); #endif LLVMValueRef cur = LLVMBuildLoad2(obj->builder, obj->types[type], ptr, ""); LLVMValueRef addend = cgen_coerce_value(obj, cgb, ir->arg2, type); LLVMValueRef args[] = { cur, addend }; LLVMValueRef sat = llvm_call_fn(obj, LLVM_ADD_SAT_U8 + ir->size, args, 2); LLVMBuildStore(obj->builder, sat, ptr); } static void cgen_ir(llvm_obj_t *obj, cgen_block_t *cgb, jit_ir_t *ir) { switch (ir->op) { case J_RECV: cgen_op_recv(obj, cgb, ir); break; case J_SEND: cgen_op_send(obj, cgb, ir); break; case J_STORE: cgen_op_store(obj, cgb, ir); break; case J_LOAD: case J_ULOAD: cgen_op_load(obj, cgb, ir); break; case J_ADD: cgen_op_add(obj, cgb, ir); break; case J_SUB: cgen_op_sub(obj, cgb, ir); break; case J_MUL: cgen_op_mul(obj, cgb, ir); break; case J_DIV: cgen_op_div(obj, cgb, ir); break; case J_REM: cgen_op_rem(obj, cgb, ir); break; case J_SHL: cgen_op_shl(obj, cgb, ir); break; case J_ASR: cgen_op_asr(obj, cgb, ir); break; case J_FADD: cgen_op_fadd(obj, cgb, ir); break; case J_FSUB: cgen_op_fsub(obj, cgb, ir); break; case J_FMUL: cgen_op_fmul(obj, cgb, ir); break; case J_FDIV: cgen_op_fdiv(obj, cgb, ir); break; case J_FNEG: cgen_op_fneg(obj, cgb, ir); break; case J_FCVTNS: cgen_op_fcvtns(obj, cgb, ir); break; case J_SCVTF: cgen_op_scvtf(obj, cgb, ir); break; case J_NOT: cgen_op_not(obj, cgb, ir); break; case J_AND: cgen_op_and(obj, cgb, ir); break; case J_OR: cgen_op_or(obj, cgb, ir); break; case J_XOR: cgen_op_xor(obj, cgb, ir); break; case J_RET: cgen_op_ret(obj, ir); break; case J_JUMP: cgen_op_jump(obj, cgb, ir); break; case J_CMP: cgen_op_cmp(obj, cgb, ir); break; case J_CCMP: cgen_op_ccmp(obj, cgb, ir); break; case J_FCMP: cgen_op_fcmp(obj, cgb, ir); break; case J_FCCMP: cgen_op_fccmp(obj, cgb, ir); break; case J_CSET: cgen_op_cset(obj, cgb, ir); break; case J_CSEL: cgen_op_csel(obj, cgb, ir); break; case J_CALL: cgen_op_call(obj, cgb, ir); break; case J_LEA: cgen_op_lea(obj, cgb, ir); break; case J_MOV: cgen_op_mov(obj, cgb, ir); break; case J_NEG: cgen_op_neg(obj, cgb, ir); break; case J_CLAMP: cgen_op_clamp(obj, cgb, ir); break; case J_DEBUG: DWARF_ONLY(cgen_debug_loc(obj, cgb->func, &(ir->arg1.loc))); break; case J_TRAP: case J_NOP: break; case MACRO_EXP: cgen_macro_exp(obj, cgb, ir); break; case MACRO_FEXP: cgen_macro_fexp(obj, cgb, ir); break; case MACRO_COPY: cgen_macro_copy(obj, cgb, ir); break; case MACRO_MOVE: cgen_macro_move(obj, cgb, ir); break; case MACRO_BZERO: cgen_macro_bzero(obj, cgb, ir); break; case MACRO_MEMSET: cgen_macro_memset(obj, cgb, ir); break; case MACRO_EXIT: cgen_macro_exit(obj, cgb, ir); break; case MACRO_GALLOC: cgen_macro_galloc(obj, cgb, ir); break; case MACRO_LALLOC: cgen_macro_lalloc(obj, cgb, ir); break; case MACRO_SALLOC: cgen_macro_salloc(obj, cgb, ir); break; case MACRO_GETPRIV: cgen_macro_getpriv(obj, cgb, ir); break; case MACRO_PUTPRIV: cgen_macro_putpriv(obj, cgb, ir); break; case MACRO_PACK: cgen_macro_pack(obj, cgb, ir); break; case MACRO_UNPACK: cgen_macro_unpack(obj, cgb, ir); break; case MACRO_CASE: cgen_macro_case(obj, cgb, ir); break; case MACRO_TRIM: cgen_macro_trim(obj, cgb, ir); break; case MACRO_REEXEC: cgen_macro_reexec(obj, cgb, ir); break; case MACRO_SADD: cgen_macro_sadd(obj, cgb, ir); break; default: cgen_abort(cgb, ir, "cannot generate LLVM for %s", jit_op_name(ir->op)); } } static void cgen_basic_blocks(llvm_obj_t *obj, cgen_func_t *func, jit_cfg_t *cfg) { func->blocks = xcalloc_array(cfg->nblocks, sizeof(cgen_block_t)); for (int i = 0; i < cfg->nblocks; i++) { #ifdef DEBUG char name[32]; checked_sprintf(name, sizeof(name), "BB%d", i); #else const char *name = ""; #endif cgen_block_t *cgb = &(func->blocks[i]); cgb->bbref = llvm_append_block(obj, func->llvmfn, name); cgb->source = &(cfg->blocks[i]); cgb->func = func; cgb->inregs = xcalloc_array(func->source->nregs, sizeof(LLVMValueRef)); cgb->outregs = xcalloc_array(func->source->nregs, sizeof(LLVMValueRef)); } } static void cgen_frame_anchor(llvm_obj_t *obj, cgen_func_t *func) { LLVMTypeRef type = obj->types[LLVM_ANCHOR]; func->anchor = LLVMBuildAlloca(obj->builder, type, "anchor"); LLVMValueRef func_arg = LLVMGetParam(func->llvmfn, 0); LLVMSetValueName(func_arg, "func"); LLVMValueRef caller_arg = LLVMGetParam(func->llvmfn, 1); LLVMSetValueName(caller_arg, "caller"); LLVMValueRef caller_ptr = LLVMBuildStructGEP2(obj->builder, type, func->anchor, 0, ""); LLVMBuildStore(obj->builder, caller_arg, caller_ptr); LLVMValueRef func_ptr = LLVMBuildStructGEP2(obj->builder, type, func->anchor, 1, ""); LLVMBuildStore(obj->builder, func_arg, func_ptr); LLVMValueRef irpos_ptr = LLVMBuildStructGEP2(obj->builder, type, func->anchor, 2, ""); LLVMBuildStore(obj->builder, llvm_int32(obj, 0), irpos_ptr); LLVMValueRef watermark_ptr = LLVMBuildStructGEP2(obj->builder, type, func->anchor, 3, ""); LLVMValueRef alloc_ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_TLAB], func->tlab, 2, ""); LLVMValueRef alloc = LLVMBuildLoad2(obj->builder, obj->types[LLVM_INT32], alloc_ptr, ""); LLVMBuildStore(obj->builder, alloc, watermark_ptr); } static void cgen_aot_cpool(llvm_obj_t *obj, cgen_func_t *func) { jit_func_t *f = func->source; LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, f->name); tb_cat(tb, ".cpool"); LLVMTypeRef array_type = LLVMArrayType(obj->types[LLVM_INT8], f->cpoolsz); LLVMValueRef global = LLVMAddGlobal(obj->module, array_type, tb_get(tb)); LLVMSetLinkage(global, LLVMPrivateLinkage); LLVMSetGlobalConstant(global, true); LLVMSetUnnamedAddr(global, true); LLVMValueRef *data LOCAL = xmalloc_array(f->cpoolsz, sizeof(LLVMValueRef)); for (int i = 0; i < f->cpoolsz; i++) data[i] = llvm_int8(obj, f->cpool[i]); LLVMValueRef init = LLVMConstArray(obj->types[LLVM_INT8], data, f->cpoolsz); LLVMSetInitializer(global, init); func->cpool = global; func->cpool_type = array_type; } static LLVMValueRef cgen_debug_irbuf(llvm_obj_t *obj, jit_func_t *f) { LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, f->name); tb_cat(tb, ".debug"); size_t size = 0; uint8_t *buf LOCAL = NULL; pack_writer_emit(obj->pack_writer, f->jit, f->handle, &buf, &size); LLVMValueRef *data LOCAL = xmalloc_array(size, sizeof(LLVMValueRef)); for (size_t i = 0; i < size; i++) data[i] = llvm_int8(obj, buf[i]); LLVMTypeRef array_type = LLVMArrayType(obj->types[LLVM_INT8], size); LLVMValueRef global = LLVMAddGlobal(obj->module, array_type, tb_get(tb)); LLVMSetLinkage(global, LLVMPrivateLinkage); LLVMSetGlobalConstant(global, true); LLVMSetUnnamedAddr(global, true); LLVMValueRef init = LLVMConstArray(obj->types[LLVM_INT8], data, size); LLVMSetInitializer(global, init); return global; } static LLVMValueRef cgen_reloc_str(llvm_obj_t *obj, const char *str) { const unsigned off = pack_writer_get_string(obj->pack_writer, str); return llvm_intptr(obj, off); } static void cgen_aot_descr(llvm_obj_t *obj, cgen_func_t *func) { LLVMValueRef irbuf = cgen_debug_irbuf(obj, func->source); A(cgen_reloc_t) relocs = AINIT; for (int i = 0; i < func->source->nirs; i++) { jit_ir_t *ir = &(func->source->irbuf[i]); if (ir->op == J_CALL || ir->op == MACRO_GETPRIV || ir->op == MACRO_PUTPRIV) { // Special handling of JIT_VALUE_HANDLE arguments reloc_kind_t kind = ir->op == J_CALL ? RELOC_FUNC : RELOC_PRIVDATA; if (cgen_find_reloc(relocs.items, kind, relocs.count, ir->arg1.handle) == NULL) { jit_func_t *f = jit_get_func(func->source->jit, ir->arg1.handle); const cgen_reloc_t r = { .kind = kind, .str = cgen_reloc_str(obj, istr(f->name)), .key = ir->arg1.handle, .nth = relocs.count, }; APUSH(relocs, r); } } else { jit_value_t args[2] = { ir->arg1, ir->arg2 }; for (int j = 0; j < ARRAY_LEN(args); j++) { if (args[j].kind == JIT_VALUE_HANDLE && args[j].handle != JIT_HANDLE_INVALID) { if (cgen_find_reloc(relocs.items, RELOC_HANDLE, relocs.count, args[j].handle) == NULL) { ident_t name = jit_get_name(func->source->jit, args[j].handle); const cgen_reloc_t r = { .kind = RELOC_HANDLE, .str = cgen_reloc_str(obj, istr(name)), .key = args[j].handle, .nth = relocs.count, }; APUSH(relocs, r); } } else if (args[j].kind == JIT_ADDR_COVER) { if (cgen_find_reloc(relocs.items, RELOC_COVER, relocs.count, 0) == NULL) { const cgen_reloc_t r = { .kind = RELOC_COVER, .nth = relocs.count, }; APUSH(relocs, r); } } } } } APUSH(relocs, (cgen_reloc_t){ .kind = RELOC_NULL }); func->relocs = relocs.items; func->reloc_type = LLVMArrayType(obj->types[LLVM_AOT_RELOC], relocs.count); LLVMValueRef *reloc_elems LOCAL = xmalloc_array(relocs.count, sizeof(LLVMValueRef)); for (int i = 0; i < relocs.count; i++) { LLVMValueRef fields[] = { llvm_int32(obj, relocs.items[i].kind), relocs.items[i].str ?: llvm_intptr(obj, 0) }; reloc_elems[i] = LLVMConstNamedStruct(obj->types[LLVM_AOT_RELOC], fields, ARRAY_LEN(fields)); } LLVMValueRef reloc_array = LLVMConstArray(obj->types[LLVM_AOT_RELOC], reloc_elems, relocs.count); LLVMTypeRef ftypes[] = { obj->types[LLVM_PTR], // Entry function obj->types[LLVM_PTR], // String table obj->types[LLVM_PTR], // JIT pack buffer obj->types[LLVM_PTR], // Constant pool func->reloc_type // Relocations list }; func->descr_type = LLVMStructTypeInContext(obj->context, ftypes, ARRAY_LEN(ftypes), false); char *name LOCAL = xasprintf("%s.descr", func->name); func->descr = LLVMAddGlobal(obj->module, func->descr_type, name); #ifdef IMPLIB_REQUIRED LLVMSetDLLStorageClass(func->descr, LLVMDLLExportStorageClass); #endif LLVMValueRef fields[] = { PTR(func->llvmfn), PTR(obj->strtab), PTR(irbuf), PTR(func->cpool), reloc_array, }; LLVMValueRef init = LLVMConstNamedStruct(func->descr_type, fields, ARRAY_LEN(fields)); LLVMSetInitializer(func->descr, init); } #if ENABLE_DWARF static LLVMMetadataRef cgen_debug_file(llvm_obj_t *obj, const loc_t *loc) { const char *file_path = loc_file_str(loc) ?: ""; char *basec LOCAL = xstrdup(file_path); char *dirc LOCAL = xstrdup(file_path); const char *file = basename(basec); const size_t file_len = strlen(file); const char *dir = dirname(dirc); const size_t dir_len = strlen(dir); return LLVMDIBuilderCreateFile(obj->debuginfo, file, file_len, dir, dir_len); } #endif static void cgen_must_be_pointer(cgen_func_t *func, jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: case JIT_ADDR_REG: mask_set(&(func->ptr_mask), value.reg); break; default: break; } } static void cgen_pointer_mask(cgen_func_t *func) { mask_init(&(func->ptr_mask), func->source->nregs); for (int i = 0; i < func->source->nirs; i++) { jit_ir_t *ir = &(func->source->irbuf[i]); switch (ir->op) { case J_LOAD: case J_ULOAD: case MACRO_BZERO: case MACRO_SADD: cgen_must_be_pointer(func, ir->arg1); break; case J_STORE: case MACRO_PUTPRIV: cgen_must_be_pointer(func, ir->arg2); break; case MACRO_COPY: case MACRO_MOVE: cgen_must_be_pointer(func, ir->arg1); cgen_must_be_pointer(func, ir->arg2); break; case J_ADD: case J_MOV: // Propagate pointer argument to result if (ir->arg1.kind == JIT_VALUE_REG && mask_test(&(func->ptr_mask), ir->arg1.reg)) mask_set(&(func->ptr_mask), ir->result); break; case J_LEA: case MACRO_GETPRIV: case MACRO_LALLOC: case MACRO_SALLOC: case MACRO_GALLOC: mask_set(&(func->ptr_mask), ir->result); break; default: break; } } } static void cgen_cache_args(llvm_obj_t *obj, cgen_func_t *func) { // Attempt to limit the number of getelementptr instructions // generated for the argument array for (int i = 0; i < ARGCACHE_SIZE; i++) { LLVMValueRef indexes[] = { llvm_int32(obj, i) }; func->argcache[i] = LLVMBuildInBoundsGEP2(obj->builder, obj->types[LLVM_INT64], func->args, indexes, ARRAY_LEN(indexes), cgen_arg_name(i)); } // Also cache the IR position pointer in the anchor func->irpos = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_ANCHOR], func->anchor, 2, "irpos"); } static void cgen_fix_liveout_types(llvm_obj_t *obj, cgen_block_t *cgb) { for (int j = 0; j < cgb->func->source->nregs; j++) { if (!mask_test(&cgb->source->liveout, j)) continue; const bool want_ptr = mask_test(&cgb->func->ptr_mask, j); if (want_ptr && !llvm_is_ptr(cgb->outregs[j])) { LLVMValueRef last = LLVMGetBasicBlockTerminator(cgb->bbref); if (last != NULL) LLVMPositionBuilderBefore(obj->builder, last); cgb->outregs[j] = LLVMBuildIntToPtr(obj->builder, cgb->outregs[j], obj->types[LLVM_PTR], cgen_reg_name(j)); } } } static void cgen_reexecute_guard(llvm_obj_t *obj, cgen_func_t *func, jit_cfg_t *cfg) { // Jump to the real entry if it may be modified at runtime // (e.g. bound to a foreign function) bool has_reexec = false; for (int i = 0; i < cfg->nblocks; i++) { jit_block_t *bb = &(cfg->blocks[i]); if (func->source->irbuf[bb->last].op == MACRO_REEXEC) { has_reexec = true; break; } } if (!has_reexec) return; LLVMValueRef fptr = LLVMGetParam(func->llvmfn, 0); // Must have acquire semantics to synchronise with installing new code LLVMValueRef entry = LLVMBuildLoad2(obj->builder, obj->types[LLVM_PTR], fptr, "entry"); LLVMSetAlignment(entry, sizeof(void *)); LLVMSetOrdering(entry, LLVMAtomicOrderingAcquire); LLVMBasicBlockRef reexec_bb = llvm_append_block(obj, func->llvmfn, "reexec"); LLVMBasicBlockRef cont_bb = llvm_append_block(obj, func->llvmfn, "cont"); LLVMValueRef changed = LLVMBuildICmp(obj->builder, LLVMIntNE, entry, PTR(func->llvmfn), "changed"); LLVMBuildCondBr(obj->builder, changed, reexec_bb, cont_bb); LLVMPositionBuilderAtEnd(obj->builder, reexec_bb); #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(obj->types[LLVM_ENTRY_FN], 0); entry = LLVMBuildPointerCast(obj->builder, entry, ptr_type, ""); #endif LLVMValueRef anchor = LLVMGetParam(func->llvmfn, 1); LLVMValueRef args[] = { fptr, anchor, func->args, func->tlab, }; LLVMValueRef call = LLVMBuildCall2(obj->builder, obj->types[LLVM_ENTRY_FN], entry, args, ARRAY_LEN(args), ""); LLVMSetTailCall(call, true); LLVMBuildRetVoid(obj->builder); LLVMPositionBuilderAtEnd(obj->builder, cont_bb); } static void cgen_function(llvm_obj_t *obj, cgen_func_t *func) { func->llvmfn = llvm_add_fn(obj, func->name, obj->types[LLVM_ENTRY_FN]); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_NOUNWIND, -1); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_UWTABLE, -1); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_DLLEXPORT, -1); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_READONLY, 1); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_NONNULL, 1); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_READONLY, 2); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_NOALIAS, 3); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_NONNULL, 3); llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_NOALIAS, 4); #ifdef PRESERVE_FRAME_POINTER llvm_add_func_attr(obj, func->llvmfn, FUNC_ATTR_PRESERVE_FP, -1); #endif #if ENABLE_DWARF LLVMMetadataRef file_ref = cgen_debug_file(obj, &(func->source->object->loc)); if (obj->debugcu == NULL) { obj->debugcu = LLVMDIBuilderCreateCompileUnit( obj->debuginfo, LLVMDWARFSourceLanguageAda83, file_ref, PACKAGE, sizeof(PACKAGE) - 1, opt_get_int(OPT_OPTIMISE), "", 0, 0, "", 0, LLVMDWARFEmissionFull, 0, false, false #if LLVM_CREATE_CU_HAS_SYSROOT , "/", 1, "", 0 #endif ); } LLVMMetadataRef dtype = LLVMDIBuilderCreateSubroutineType( obj->debuginfo, file_ref, NULL, 0, 0); const size_t namelen = strlen(func->name); func->debugmd = LLVMDIBuilderCreateFunction( obj->debuginfo, obj->debugcu, func->name, namelen, func->name, namelen, file_ref, func->source->object->loc.first_line, dtype, true, true, 1, 0, opt_get_int(OPT_OPTIMISE)); LLVMSetSubprogram(func->llvmfn, func->debugmd); cgen_debug_loc(obj, func, &(func->source->object->loc)); #endif // ENABLE_DWARF if (func->mode == CGEN_AOT) { cgen_aot_cpool(obj, func); cgen_aot_descr(obj, func); } LLVMBasicBlockRef entry_bb = llvm_append_block(obj, func->llvmfn, "entry"); LLVMPositionBuilderAtEnd(obj->builder, entry_bb); func->args = LLVMGetParam(func->llvmfn, 2); LLVMSetValueName(func->args, "args"); func->tlab = LLVMGetParam(func->llvmfn, 3); LLVMSetValueName(func->tlab, "tlab"); cgen_frame_anchor(obj, func); cgen_cache_args(obj, func); jit_cfg_t *cfg = func->cfg = jit_get_cfg(func->source); cgen_reexecute_guard(obj, func, cfg); cgen_basic_blocks(obj, func, cfg); entry_bb = LLVMGetInsertBlock(obj->builder); cgen_pointer_mask(func); cgen_block_t *cgb = func->blocks; LLVMValueRef zero_flag = llvm_int1(obj, false); int maxin = 0; for (int i = 0; i < func->source->nirs; i++) { if (i == cgb->source->first) { LLVMPositionBuilderAtEnd(obj->builder, cgb->bbref); cgen_block_t *dom = NULL; if (cgb->source->in.count == 1) dom = &(func->blocks[jit_get_edge(&cgb->source->in, 0)]); cgb->inflags = zero_flag; if (mask_test(&cgb->source->livein, func->source->nregs)) { if (dom != NULL && dom < cgb) { // Skip generating a phi instruction if there is just // one dominating block assert(dom->outflags != NULL); cgb->inflags = dom->outflags; } else if (cgb->source->in.count > 0) { LLVMTypeRef int1_type = obj->types[LLVM_INT1]; cgb->inflags = LLVMBuildPhi(obj->builder, int1_type, "FLAGS"); } } cgb->outflags = cgb->inflags; for (int j = 0; j < func->source->nregs; j++) { if (mask_test(&cgb->source->livein, j)) { if (dom != NULL && dom < cgb) { assert(dom->outregs[j] != NULL); cgb->inregs[j] = cgb->outregs[j] = dom->outregs[j]; continue; } llvm_type_t type = mask_test(&func->ptr_mask, j) ? LLVM_PTR : LLVM_INT64; const char *name = cgen_reg_name(j); LLVMValueRef init = cgb->source->in.count == 0 ? LLVMConstNull(obj->types[type]) : LLVMBuildPhi(obj->builder, obj->types[type], name); cgb->inregs[j] = cgb->outregs[j] = init; } } maxin = MAX(maxin, cgb->source->in.count); } assert(i >= cgb->source->first && i <= cgb->source->last); cgen_ir(obj, cgb, &(func->source->irbuf[i])); if (i == cgb->source->last) { cgen_fix_liveout_types(obj, cgb); if (LLVMGetBasicBlockTerminator(cgb->bbref) == NULL) { if (cgb->source->aborts) LLVMBuildUnreachable(obj->builder); else { // Fall through to next block assert(!cgb->source->returns); assert(cgb + 1 < func->blocks + cfg->nblocks); LLVMBuildBr(obj->builder, (cgb + 1)->bbref); } } cgb++; } } LLVMValueRef *phi_in LOCAL = xmalloc_array(maxin, sizeof(LLVMValueRef)); LLVMBasicBlockRef *phi_bb LOCAL = xmalloc_array(maxin, sizeof(LLVMBasicBlockRef)); for (int i = 0; i < cfg->nblocks; i++) { jit_block_t *bb = &(cfg->blocks[i]); cgen_block_t *cgb = &(func->blocks[i]); if (bb->in.count == 0) continue; // Flags if (mask_test(&cgb->source->livein, func->source->nregs) && LLVMIsAPHINode(cgb->inflags) && LLVMGetInstructionParent(cgb->inflags) == cgb->bbref) { for (int j = 0; j < bb->in.count; j++) { const int edge = jit_get_edge(&bb->in, j); phi_in[j] = func->blocks[edge].outflags; phi_bb[j] = func->blocks[edge].bbref; } LLVMAddIncoming(cgb->inflags, phi_in, phi_bb, bb->in.count); } // Live-in registers for (int j = 0; j < func->source->nregs; j++) { if (cgb->inregs[j] != NULL && LLVMIsAPHINode(cgb->inregs[j]) && LLVMGetInstructionParent(cgb->inregs[j]) == cgb->bbref) { for (int k = 0; k < bb->in.count; k++) { const int edge = jit_get_edge(&bb->in, k); assert(func->blocks[edge].outregs[j] != NULL); phi_in[k] = func->blocks[edge].outregs[j]; phi_bb[k] = func->blocks[edge].bbref; } LLVMAddIncoming(cgb->inregs[j], phi_in, phi_bb, bb->in.count); } } } for (int i = 0; i < cfg->nblocks; i++) { cgen_block_t *cgb = &(func->blocks[i]); free(cgb->inregs); free(cgb->outregs); cgb->inregs = cgb->outregs = NULL; } LLVMPositionBuilderAtEnd(obj->builder, entry_bb); LLVMBuildBr(obj->builder, func->blocks[0].bbref); jit_free_cfg(cfg); mask_free(&(func->ptr_mask)); free(func->blocks); func->blocks = NULL; free(func->relocs); func->relocs = NULL; } static void cgen_tlab_alloc_body(llvm_obj_t *obj) { LLVMValueRef fn = obj->fns[LLVM_TLAB_ALLOC]; LLVMSetLinkage(fn, LLVMPrivateLinkage); #ifdef PRESERVE_FRAME_POINTER llvm_add_func_attr(obj, fn, FUNC_ATTR_PRESERVE_FP, 0); #endif LLVMBasicBlockRef entry = llvm_append_block(obj, fn, ""); LLVMPositionBuilderAtEnd(obj->builder, entry); LLVMValueRef tlab = LLVMGetParam(fn, 0); LLVMSetValueName(tlab, "tlab"); LLVMValueRef bytes = LLVMGetParam(fn, 1); LLVMSetValueName(bytes, "bytes"); LLVMValueRef anchor = LLVMGetParam(fn, 2); LLVMSetValueName(anchor, "anchor"); LLVMBasicBlockRef fast_bb = llvm_append_block(obj, fn, ""); LLVMBasicBlockRef slow_bb = llvm_append_block(obj, fn, ""); LLVMValueRef alloc_ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_TLAB], tlab, 1, ""); LLVMValueRef limit_ptr = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_TLAB], tlab, 2, ""); LLVMValueRef alloc = LLVMBuildLoad2(obj->builder, obj->types[LLVM_INT32], alloc_ptr, ""); LLVMValueRef limit = LLVMBuildLoad2(obj->builder, obj->types[LLVM_INT32], limit_ptr, ""); LLVMValueRef bytes_trunc = LLVMBuildTrunc(obj->builder, bytes, obj->types[LLVM_INT32], ""); LLVMValueRef align_mask = llvm_int32(obj, RT_ALIGN_MASK); LLVMValueRef align_up = LLVMBuildAnd(obj->builder, LLVMBuildAdd(obj->builder, bytes_trunc, align_mask, ""), LLVMConstNot(align_mask), ""); LLVMValueRef next = LLVMBuildAdd(obj->builder, alloc, align_up, ""); LLVMValueRef over = LLVMBuildICmp(obj->builder, LLVMIntUGT, next, limit, ""); LLVMBuildCondBr(obj->builder, over, slow_bb, fast_bb); LLVMPositionBuilderAtEnd(obj->builder, fast_bb); LLVMBuildStore(obj->builder, next, alloc_ptr); LLVMValueRef base = LLVMBuildStructGEP2(obj->builder, obj->types[LLVM_TLAB], tlab, 3, ""); LLVMValueRef indexes[] = { alloc }; LLVMValueRef fast_ptr = LLVMBuildInBoundsGEP2(obj->builder, obj->types[LLVM_INT8], base, indexes, ARRAY_LEN(indexes), ""); LLVMBuildRet(obj->builder, fast_ptr); LLVMPositionBuilderAtEnd(obj->builder, slow_bb); LLVMValueRef args[] = { bytes, anchor }; LLVMValueRef slow_ptr = llvm_call_fn(obj, LLVM_MSPACE_ALLOC, args, ARRAY_LEN(args)); LLVMBuildRet(obj->builder, slow_ptr); } static void cgen_exp_overflow_body(llvm_obj_t *obj, llvm_fn_t which, jit_size_t sz, llvm_fn_t mulbase) { LLVMValueRef fn = obj->fns[which]; LLVMSetLinkage(fn, LLVMPrivateLinkage); #ifdef PRESERVE_FRAME_POINTER llvm_add_func_attr(obj, fn, FUNC_ATTR_PRESERVE_FP, 0); #endif LLVMBasicBlockRef entry = llvm_append_block(obj, fn, "entry"); LLVMPositionBuilderAtEnd(obj->builder, entry); LLVMValueRef x0 = LLVMGetParam(fn, 0); LLVMSetValueName(x0, "x0"); LLVMValueRef y0 = LLVMGetParam(fn, 1); LLVMSetValueName(y0, "y0"); LLVMTypeRef int_type = obj->types[LLVM_INT8 + sz]; LLVMTypeRef pair_type = obj->types[LLVM_PAIR_I8_I1 + sz]; LLVMValueRef mulfn = llvm_get_fn(obj, mulbase + sz); LLVMTypeRef multype = obj->fntypes[mulbase + sz]; LLVMValueRef zero = LLVMConstInt(int_type, 0, false); LLVMValueRef one = LLVMConstInt(int_type, 1, false); LLVMValueRef r0 = one; LLVMValueRef o0 = llvm_int1(obj, false); LLVMValueRef xo0 = llvm_int1(obj, false); LLVMBasicBlockRef header = llvm_append_block(obj, fn, "header"); LLVMBasicBlockRef body = llvm_append_block(obj, fn, "body"); LLVMBasicBlockRef accum = llvm_append_block(obj, fn, "accum"); LLVMBasicBlockRef tail = llvm_append_block(obj, fn, "tail"); LLVMBasicBlockRef exit = llvm_append_block(obj, fn, "exit"); LLVMBuildBr(obj->builder, header); LLVMPositionBuilderAtEnd(obj->builder, header); LLVMValueRef x1 = LLVMBuildPhi(obj->builder, int_type, "x1"); LLVMValueRef y1 = LLVMBuildPhi(obj->builder, int_type, "y1"); LLVMValueRef r1 = LLVMBuildPhi(obj->builder, int_type, "r1"); LLVMValueRef o1 = LLVMBuildPhi(obj->builder, obj->types[LLVM_INT1], "o1"); LLVMValueRef xo1 = LLVMBuildPhi(obj->builder, obj->types[LLVM_INT1], "xo1"); LLVMValueRef test1 = LLVMBuildICmp(obj->builder, LLVMIntEQ, y1, zero, ""); LLVMBuildCondBr(obj->builder, test1, exit, body); LLVMPositionBuilderAtEnd(obj->builder, body); LLVMValueRef lsb = LLVMBuildAnd(obj->builder, y1, one, ""); LLVMValueRef test2 = LLVMBuildICmp(obj->builder, LLVMIntEQ, lsb, zero, ""); LLVMBuildCondBr(obj->builder, test2, tail, accum); LLVMPositionBuilderAtEnd(obj->builder, accum); LLVMValueRef r2_args[] = { r1, x1 }; LLVMValueRef r2_pair = LLVMBuildCall2(obj->builder, multype, mulfn, r2_args, ARRAY_LEN(r2_args), ""); LLVMValueRef r2 = LLVMBuildExtractValue(obj->builder, r2_pair, 0, "r2"); LLVMValueRef r2_ovf = LLVMBuildExtractValue(obj->builder, r2_pair, 1, ""); LLVMValueRef tmp = LLVMBuildOr(obj->builder, o1, xo1, ""); LLVMValueRef o2 = LLVMBuildOr(obj->builder, tmp, r2_ovf, "o2"); LLVMBuildBr(obj->builder, tail); LLVMPositionBuilderAtEnd(obj->builder, tail); LLVMValueRef r3 = LLVMBuildPhi(obj->builder, int_type, "r3"); LLVMValueRef r3_in[] = { r1, r2 }; LLVMBasicBlockRef r3_bb[] = { body, accum }; LLVMAddIncoming(r3, r3_in, r3_bb, 2); LLVMValueRef o3 = LLVMBuildPhi(obj->builder, obj->types[LLVM_INT1], "o3"); LLVMValueRef o3_in[] = { o1, o2 }; LLVMBasicBlockRef o3_bb[] = { body, accum }; LLVMAddIncoming(o3, o3_in, o3_bb, 2); LLVMValueRef r1_in[] = { r0, r3 }; LLVMBasicBlockRef r1_bb[] = { entry, tail }; LLVMAddIncoming(r1, r1_in, r1_bb, 2); LLVMValueRef y2 = LLVMBuildLShr(obj->builder, y1, one, "y2"); LLVMValueRef x2_args[] = { x1, x1 }; LLVMValueRef x2_pair = LLVMBuildCall2(obj->builder, multype, mulfn, x2_args, ARRAY_LEN(x2_args), ""); LLVMValueRef x2 = LLVMBuildExtractValue(obj->builder, x2_pair, 0, "x2"); LLVMValueRef xo2 = LLVMBuildExtractValue(obj->builder, x2_pair, 1, ""); LLVMValueRef x1_in[] = { x0, x2 }; LLVMBasicBlockRef x1_bb[] = { entry, tail }; LLVMAddIncoming(x1, x1_in, x1_bb, 2); LLVMValueRef y1_in[] = { y0, y2 }; LLVMBasicBlockRef y1_bb[] = { entry, tail }; LLVMAddIncoming(y1, y1_in, y1_bb, 2); LLVMValueRef o1_in[] = { o0, o3 }; LLVMBasicBlockRef o1_bb[] = { entry, tail }; LLVMAddIncoming(o1, o1_in, o1_bb, 2); LLVMValueRef xo1_in[] = { xo0, xo2 }; LLVMBasicBlockRef xo1_bb[] = { entry, tail }; LLVMAddIncoming(xo1, xo1_in, xo1_bb, 2); LLVMBuildBr(obj->builder, header); LLVMPositionBuilderAtEnd(obj->builder, exit); LLVMValueRef pair = LLVMConstNull(pair_type); pair = LLVMBuildInsertValue(obj->builder, pair, r1, 0, ""); pair = LLVMBuildInsertValue(obj->builder, pair, o1, 1, ""); LLVMBuildRet(obj->builder, pair); } static void cgen_memset_body(llvm_obj_t *obj, llvm_fn_t which, jit_size_t sz, llvm_fn_t mulbase) { LLVMValueRef fn = obj->fns[which]; LLVMSetLinkage(fn, LLVMPrivateLinkage); #ifdef PRESERVE_FRAME_POINTER llvm_add_func_attr(obj, fn, FUNC_ATTR_PRESERVE_FP, 0); #endif LLVMBasicBlockRef entry = llvm_append_block(obj, fn, "entry"); LLVMPositionBuilderAtEnd(obj->builder, entry); LLVMValueRef dest = LLVMGetParam(fn, 0); LLVMSetValueName(dest, "dest"); LLVMValueRef value = LLVMGetParam(fn, 1); LLVMSetValueName(value, "value"); LLVMValueRef bytes = LLVMGetParam(fn, 2); LLVMSetValueName(bytes, "bytes"); LLVMValueRef indexes1[] = { bytes }; LLVMValueRef eptr = LLVMBuildGEP2(obj->builder, obj->types[LLVM_INT8], dest, indexes1, 1, "eptr"); LLVMBasicBlockRef body = llvm_append_block(obj, fn, "body"); LLVMBasicBlockRef exit = llvm_append_block(obj, fn, "exit"); LLVMTypeRef type = obj->types[LLVM_INT8 + sz]; LLVMValueRef zero = LLVMBuildIsNull(obj->builder, bytes, ""); LLVMBuildCondBr(obj->builder, zero, exit, body); LLVMPositionBuilderAtEnd(obj->builder, body); LLVMValueRef ptr = LLVMBuildPhi(obj->builder, obj->types[LLVM_PTR], "ptr"); #ifndef LLVM_HAS_OPAQUE_POINTERS LLVMTypeRef ptr_type = LLVMPointerType(type, 0); LLVMValueRef cast = LLVMBuildPointerCast(obj->builder, ptr, ptr_type, ""); #else LLVMValueRef cast = ptr; #endif LLVMBuildStore(obj->builder, value, cast); LLVMValueRef indexes2[] = { llvm_intptr(obj, 1) }; LLVMValueRef next = LLVMBuildGEP2(obj->builder, type, cast, indexes2, 1, ""); LLVMValueRef ptr_in[] = { dest, PTR(next) }; LLVMBasicBlockRef ptr_bb[] = { entry, body }; LLVMAddIncoming(ptr, ptr_in, ptr_bb, 2); LLVMValueRef cont = LLVMBuildICmp(obj->builder, LLVMIntULT, PTR(next), eptr, ""); LLVMBuildCondBr(obj->builder, cont, body, exit); LLVMPositionBuilderAtEnd(obj->builder, exit); LLVMBuildRetVoid(obj->builder); } //////////////////////////////////////////////////////////////////////////////// // JIT plugin interface typedef struct { code_cache_t *code; } llvm_jit_state_t; static void *jit_llvm_init(jit_t *jit) { llvm_native_setup(); llvm_jit_state_t *state = xcalloc(sizeof(llvm_jit_state_t)); state->code = code_cache_new(); return state; } static void jit_llvm_cgen(jit_t *j, jit_handle_t handle, void *context) { llvm_jit_state_t *state = context; jit_func_t *f = jit_get_func(j, handle); #ifdef DEBUG const char *only = getenv("NVC_JIT_ONLY"); if (only != NULL && !icmp(f->name, only)) return; #endif const uint64_t start_us = get_timestamp_us(); LLVMTargetMachineRef tm = llvm_target_machine(LLVMRelocStatic, JIT_CODE_MODEL); llvm_obj_t obj = { .context = LLVMContextCreate(), .target = tm, }; LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, f->name); obj.module = LLVMModuleCreateWithNameInContext(tb_get(tb), obj.context); obj.builder = LLVMCreateBuilderInContext(obj.context); obj.data_ref = LLVMCreateTargetDataLayout(tm); #if ENABLE_DWARF obj.debuginfo = LLVMCreateDIBuilderDisallowUnresolved(obj.module); #endif llvm_register_types(&obj); cgen_func_t func = { .name = tb_claim(tb), .source = f, .mode = CGEN_JIT, }; cgen_function(&obj, &func); llvm_obj_finalise(&obj, LLVM_O0); if (jit_is_shutdown(f->jit)) goto skip_emit; LLVMMemoryBufferRef buf; char *error; if (LLVMTargetMachineEmitToMemoryBuffer(tm, obj.module, LLVMObjectFile, &error, &buf)) fatal("failed to generate native code: %s", error); if (jit_is_shutdown(f->jit)) goto skip_load; const size_t objsz = LLVMGetBufferSize(buf); code_blob_t *blob = code_blob_new(state->code, f->name, objsz); if (blob == NULL) return; const uint8_t *base = blob->wptr; const void *entry_addr = blob->wptr; code_load_object(blob, LLVMGetBufferStart(buf), objsz); const size_t size = blob->wptr - base; code_blob_finalise(blob, &(f->entry)); if (opt_get_int(OPT_JIT_LOG)) { const uint64_t end_us = get_timestamp_us(); debugf("%s at %p [%zu bytes in %"PRIi64" us]", func.name, entry_addr, size, end_us - start_us); } skip_load: LLVMDisposeMemoryBuffer(buf); skip_emit: LLVMDisposeTargetData(obj.data_ref); LLVMDisposeTargetMachine(tm); LLVMDisposeBuilder(obj.builder); DWARF_ONLY(LLVMDisposeDIBuilder(obj.debuginfo)); LLVMContextDispose(obj.context); free(func.name); } static void jit_llvm_cleanup(void *context) { llvm_jit_state_t *state = context; code_cache_free(state->code); free(state); } static const jit_plugin_t jit_llvm = { .init = jit_llvm_init, .cgen = jit_llvm_cgen, .cleanup = jit_llvm_cleanup }; void jit_register_llvm_plugin(jit_t *j) { const int threshold = opt_get_int(OPT_JIT_THRESHOLD); if (threshold > 0) jit_add_tier(j, threshold, &jit_llvm); else if (threshold < 0) warnf("invalid NVC_JIT_THRESOLD setting %d", threshold); } //////////////////////////////////////////////////////////////////////////////// // Ahead-of-time code generation llvm_obj_t *llvm_obj_new(const char *name) { llvm_native_setup(); llvm_obj_t *obj = xcalloc(sizeof(llvm_obj_t)); obj->context = LLVMContextCreate(); obj->module = LLVMModuleCreateWithNameInContext(name, obj->context); obj->builder = LLVMCreateBuilderInContext(obj->context); obj->target = llvm_target_machine(LLVMRelocPIC, LLVMCodeModelDefault); obj->data_ref = LLVMCreateTargetDataLayout(obj->target); obj->pack_writer = pack_writer_new(); #if ENABLE_DWARF obj->debuginfo = LLVMCreateDIBuilderDisallowUnresolved(obj->module); #endif char *triple = LLVMGetTargetMachineTriple(obj->target); LLVMSetTarget(obj->module, triple); LLVMDisposeMessage(triple); LLVMSetModuleDataLayout(obj->module, obj->data_ref); llvm_register_types(obj); #if ENABLE_DWARF llvm_add_module_flag(obj, "Debug Info Version", DEBUG_METADATA_VERSION); #ifdef __APPLE__ llvm_add_module_flag(obj, "Dwarf Version", 2); #else llvm_add_module_flag(obj, "Dwarf Version", 4); #endif #endif obj->strtab = LLVMAddGlobal(obj->module, obj->types[LLVM_STRTAB], "placeholder_strtab"); LLVMSetGlobalConstant(obj->strtab, true); LLVMSetLinkage(obj->strtab, LLVMPrivateLinkage); return obj; } void llvm_add_abi_version(llvm_obj_t *obj) { LLVMValueRef abi_version = LLVMAddGlobal(obj->module, obj->types[LLVM_INT32], "__nvc_abi_version"); LLVMSetInitializer(abi_version, llvm_int32(obj, RT_ABI_VERSION)); LLVMSetGlobalConstant(abi_version, true); #ifdef IMPLIB_REQUIRED LLVMSetDLLStorageClass(abi_version, LLVMDLLExportStorageClass); #endif } void llvm_aot_compile(llvm_obj_t *obj, jit_t *j, jit_handle_t handle) { DEBUG_ONLY(const uint64_t start_us = get_timestamp_us()); jit_func_t *f = jit_get_func(j, handle); jit_fill_irbuf(f); LOCAL_TEXT_BUF tb = safe_symbol(f->name); cgen_func_t func = { .name = tb_claim(tb), .source = f, .mode = CGEN_AOT, }; cgen_function(obj, &func); #ifdef DEBUG const uint64_t end_us = get_timestamp_us(); if (end_us - start_us > 100000) debugf("compiled %s [%"PRIi64" us]", func.name, end_us - start_us); #endif free(func.name); } static void llvm_finalise_string_table(llvm_obj_t *obj) { if (obj->pack_writer == NULL) return; const char *strtab; size_t len; pack_writer_string_table(obj->pack_writer, &strtab, &len); LLVMValueRef init = LLVMConstStringInContext(obj->context, strtab, len - 1, false); LLVMTypeRef array_type = LLVMArrayType(obj->types[LLVM_INT8], len); LLVMValueRef global = LLVMAddGlobal(obj->module, array_type, "strtab"); LLVMSetGlobalConstant(global, true); LLVMSetInitializer(global, init); LLVMSetLinkage(global, LLVMPrivateLinkage); LLVMReplaceAllUsesWith(obj->strtab, global); LLVMDeleteGlobal(obj->strtab); } void llvm_obj_finalise(llvm_obj_t *obj, llvm_opt_level_t olevel) { if (obj->fns[LLVM_TLAB_ALLOC] != NULL) cgen_tlab_alloc_body(obj); for (jit_size_t sz = JIT_SZ_8; sz <= JIT_SZ_64; sz++) { if (obj->fns[LLVM_EXP_OVERFLOW_S8 + sz] != NULL) cgen_exp_overflow_body(obj, LLVM_EXP_OVERFLOW_S8 + sz, sz, LLVM_MUL_OVERFLOW_S8); if (obj->fns[LLVM_EXP_OVERFLOW_U8 + sz] != NULL) cgen_exp_overflow_body(obj, LLVM_EXP_OVERFLOW_U8 + sz, sz, LLVM_MUL_OVERFLOW_U8); if (obj->fns[LLVM_MEMSET_U8 + sz] != NULL) cgen_memset_body(obj, LLVM_MEMSET_U8 + sz, sz, LLVM_MUL_OVERFLOW_U8); } llvm_finalise_string_table(obj); DWARF_ONLY(LLVMDIBuilderFinalize(obj->debuginfo)); llvm_dump_module(obj->module, "initial"); llvm_verify_module(obj->module); llvm_optimise(obj->module, obj->target, olevel); llvm_dump_module(obj->module, "final"); } void llvm_obj_emit(llvm_obj_t *obj, const char *path) { char *error; if (LLVMTargetMachineEmitToFile(obj->target, obj->module, (char *)path, LLVMObjectFile, &error)) fatal("Failed to write object file: %s", error); LLVMDisposeTargetData(obj->data_ref); LLVMDisposeTargetMachine(obj->target); LLVMDisposeBuilder(obj->builder); LLVMDisposeModule(obj->module); LLVMContextDispose(obj->context); pack_writer_free(obj->pack_writer); free(obj); } nvc-r1.17.1/src/jit/jit-llvm.h000066400000000000000000000023461504111170000160300ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_LLVM_H #define _JIT_LLVM_H #include "prim.h" #include "jit/jit.h" void jit_register_llvm_plugin(jit_t *j); typedef struct _llvm_obj llvm_obj_t; typedef enum { LLVM_O0, LLVM_O1, LLVM_O2, LLVM_O3 } llvm_opt_level_t; llvm_obj_t *llvm_obj_new(const char *name); void llvm_add_abi_version(llvm_obj_t *obj); void llvm_aot_compile(llvm_obj_t *obj, jit_t *j, jit_handle_t handle); void llvm_obj_finalise(llvm_obj_t *obj, llvm_opt_level_t level); void llvm_obj_emit(llvm_obj_t *obj, const char *path); #endif // _JIT_LLVM_H nvc-r1.17.1/src/jit/jit-optim.c000066400000000000000000001222101504111170000161720ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "jit/jit-priv.h" #include #include #include #include //////////////////////////////////////////////////////////////////////////////// // Control flow graph construction static bool cfg_is_terminator(jit_func_t *func, jit_ir_t *ir) { if (ir->op == MACRO_CASE) return ir + 1 < func->irbuf + func->nirs && (ir + 1)->op != MACRO_CASE; else return ir->op == J_JUMP || ir->op == J_RET || ir->op == MACRO_REEXEC; } static void cfg_add_one_edge(jit_edge_list_t *list, unsigned edge) { if (list->count < 4) list->u.edges[list->count++] = edge; else if (list->count == 4) { unsigned *ptr = xmalloc_array(16, sizeof(unsigned)); memcpy(ptr, list->u.edges, 4 * sizeof(unsigned)); list->max = 16; list->u.external = ptr; list->u.external[list->count++] = edge; } else if (list->count == list->max) { list->max *= 2; list->u.external = xrealloc_array(list->u.external, list->max, sizeof(unsigned)); list->u.external[list->count++] = edge; } else list->u.external[list->count++] = edge; } static void cfg_add_edge(jit_cfg_t *cfg, jit_block_t *from, jit_block_t *to) { cfg_add_one_edge(&(from->out), to - cfg->blocks); cfg_add_one_edge(&(to->in), from - cfg->blocks); } static jit_reg_t cfg_get_reg(jit_value_t value) { switch (value.kind) { case JIT_VALUE_REG: case JIT_ADDR_REG: return value.reg; default: return JIT_REG_INVALID; } } static inline bool cfg_reads_result(jit_ir_t *ir) { return ir->op == MACRO_COPY || ir->op == MACRO_CASE || ir->op == MACRO_BZERO || ir->op == MACRO_MOVE || ir->op == MACRO_MEMSET; } static inline bool cfg_writes_result(jit_ir_t *ir) { return ir->result != JIT_REG_INVALID && ir->op != MACRO_CASE; } static void cfg_liveness(jit_cfg_t *cfg, jit_func_t *f) { // Algorithm from "Engineering a Compiler" chapter 8.6 for (int i = 0; i < cfg->nblocks; i++) { jit_block_t *b = &(cfg->blocks[i]); mask_init(&b->livein, f->nregs + 1); mask_init(&b->varkill, f->nregs + 1); mask_init(&b->liveout, f->nregs + 1); for (int j = b->first; j <= b->last; j++) { jit_ir_t *ir = &(f->irbuf[j]); jit_reg_t reg1 = cfg_get_reg(ir->arg1); if (reg1 != JIT_REG_INVALID && !mask_test(&b->varkill, reg1)) mask_set(&b->livein, reg1); jit_reg_t reg2 = cfg_get_reg(ir->arg2); if (reg2 != JIT_REG_INVALID && !mask_test(&b->varkill, reg2)) mask_set(&b->livein, reg2); if (cfg_reads_result(ir) && !mask_test(&b->varkill, ir->result)) mask_set(&b->livein, ir->result); if (cfg_writes_result(ir)) mask_set(&b->varkill, ir->result); if (jit_writes_flags(ir)) mask_set(&b->varkill, f->nregs); else if (jit_reads_flags(ir) && !mask_test(&b->varkill, f->nregs)) mask_set(&b->livein, f->nregs); } } bit_mask_t new, tmp; mask_init(&new, f->nregs + 1); mask_init(&tmp, f->nregs + 1); bool changed; do { changed = false; for (int i = cfg->nblocks - 1; i >= 0; i--) { jit_block_t *b = &(cfg->blocks[i]); mask_clearall(&new); for (int j = 0; j < b->out.count; j++) { jit_block_t *succ = &(cfg->blocks[jit_get_edge(&b->out, j)]); mask_copy(&tmp, &succ->liveout); mask_subtract(&tmp, &succ->varkill); mask_union(&tmp, &succ->livein); mask_union(&new, &tmp); } if (!mask_eq(&new, &b->liveout)) { mask_copy(&b->liveout, &new); changed = true; } } } while (changed); // Replaced "upward exposed variables" set with live-in for (int i = 0; i < cfg->nblocks; i++) { jit_block_t *b = &(cfg->blocks[i]); mask_copy(&tmp, &b->liveout); mask_subtract(&tmp, &b->varkill); mask_union(&b->livein, &tmp); } mask_free(&new); mask_free(&tmp); } jit_cfg_t *jit_get_cfg(jit_func_t *f) { int nb = 1; for (int i = 0, first = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->target && i > 0 && first != i) first = i, nb++; if (cfg_is_terminator(f, ir) && i + 1 < f->nirs) first = i + 1, nb++; } jit_cfg_t *cfg = xcalloc_flex(sizeof(jit_cfg_t), nb, sizeof(jit_block_t)); cfg->nblocks = nb; jit_block_t *bb = cfg->blocks; for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->target && i > 0 && bb->first != i) { if (!bb->returns && !bb->aborts) cfg_add_edge(cfg, bb, bb + 1); (++bb)->first = i; } bb->last = i; if (ir->op == J_RET) bb->returns = 1; else if (jit_will_abort(ir)) bb->aborts = 1; if (cfg_is_terminator(f, ir) && i + 1 < f->nirs) { if ((ir->op == J_JUMP && ir->cc != JIT_CC_NONE) || ir->op == MACRO_CASE) cfg_add_edge(cfg, bb, bb + 1); // Fall-through case (++bb)->first = i + 1; } } for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); jit_label_t label = JIT_LABEL_INVALID; if (ir->op == J_JUMP) label = ir->arg1.label; else if (ir->op == MACRO_CASE) label = ir->arg2.label; if (label != JIT_LABEL_INVALID) { assert(label < f->nirs); jit_block_t *from = jit_block_for(cfg, i); jit_block_t *to = jit_block_for(cfg, label); cfg_add_edge(cfg, from, to); } } cfg_liveness(cfg, f); return cfg; } void jit_free_cfg(jit_cfg_t *cfg) { for (int i = 0; i < cfg->nblocks; i++) { jit_block_t *b = &(cfg->blocks[i]); mask_free(&b->livein); mask_free(&b->liveout); mask_free(&b->varkill); if (b->in.max > 4) free(b->in.u.external); if (b->out.max > 4) free(b->out.u.external); } free(cfg); } jit_block_t *jit_block_for(jit_cfg_t *cfg, int pos) { for (int low = 0, high = cfg->nblocks - 1; low <= high; ) { const int mid = (low + high) / 2; jit_block_t *bb = &(cfg->blocks[mid]); if (bb->last < pos) low = mid + 1; else if (bb->first > pos) high = mid - 1; else return bb; } fatal_trace("operation %d is not in any block", pos); } int jit_get_edge(jit_edge_list_t *list, int nth) { assert(nth < list->count); if (list->max <= 4) return list->u.edges[nth]; else return list->u.external[nth]; } //////////////////////////////////////////////////////////////////////////////// // Local value numbering and simple peepholes #define FOR_ALL_JIT_SIZES(size, macro) do { \ switch (size) { \ case JIT_SZ_8: macro(int8_t); break; \ case JIT_SZ_16: macro(int16_t); break; \ case JIT_SZ_32: macro(int32_t); break; \ case JIT_SZ_UNSPEC: \ case JIT_SZ_64: macro(int64_t); break; \ } \ } while (0) typedef unsigned valnum_t; #define VN_INVALID UINT_MAX #define SMALL_CONST 100 #define MAX_CONSTS 32 #define FIRST_VN (SMALL_CONST + MAX_CONSTS) #define TRACK_ARGS 8 #define LVN_REG(r) ((jit_value_t){ .kind = JIT_VALUE_REG, .reg = (r) }) #define LVN_CONST(i) ((jit_value_t){ .kind = JIT_VALUE_INT64, .int64 = (i) }) typedef struct { jit_ir_t *ir; valnum_t vn; } lvn_tab_t; typedef struct { jit_func_t *func; valnum_t *regvn; valnum_t nextvn; lvn_tab_t *hashtab; size_t tabsz; int64_t consttab[MAX_CONSTS]; unsigned nconsts; } lvn_state_t; static void jit_lvn_mov(jit_ir_t *ir, lvn_state_t *state); static inline valnum_t lvn_new_value(lvn_state_t *state) { return state->nextvn++; } static bool lvn_get_const(valnum_t vn, lvn_state_t *state, int64_t *cval) { if (vn < SMALL_CONST) { *cval = vn; return true; } else if (vn < SMALL_CONST + MAX_CONSTS) { *cval = state->consttab[vn - SMALL_CONST]; return true; } else return false; } static bool lvn_is_const(jit_value_t value, lvn_state_t *state, int64_t *cval) { switch (value.kind) { case JIT_VALUE_INT64: *cval = value.int64; return true; case JIT_VALUE_REG: return lvn_get_const(state->regvn[value.reg], state, cval); default: return false; } } static inline bool lvn_can_fold(jit_ir_t *ir, lvn_state_t *state, int64_t *arg1, int64_t *arg2) { return lvn_is_const(ir->arg1, state, arg1) && lvn_is_const(ir->arg2, state, arg2); } static void lvn_convert_mov(jit_ir_t *ir, lvn_state_t *state, jit_value_t value) { ir->op = J_MOV; ir->size = JIT_SZ_UNSPEC; ir->cc = JIT_CC_NONE; ir->arg1 = value; ir->arg2.kind = JIT_VALUE_INVALID; jit_lvn_mov(ir, state); } static void lvn_convert_nop(jit_ir_t *ir) { ir->op = J_NOP; ir->size = JIT_SZ_UNSPEC; ir->cc = JIT_CC_NONE; ir->result = JIT_REG_INVALID; ir->arg1.kind = JIT_VALUE_INVALID; ir->arg2.kind = JIT_VALUE_INVALID; } static valnum_t lvn_value_num(jit_value_t value, lvn_state_t *state) { switch (value.kind) { case JIT_VALUE_REG: if (state->regvn[value.reg] != VN_INVALID) return state->regvn[value.reg]; else return (state->regvn[value.reg] = lvn_new_value(state)); case JIT_VALUE_INT64: if (value.int64 >= 0 && value.int64 < SMALL_CONST) return value.int64; else { for (int i = 0; i < state->nconsts; i++) { if (state->consttab[i] == value.int64) return SMALL_CONST + i; } if (state->nconsts < MAX_CONSTS) { state->consttab[state->nconsts] = value.int64; return SMALL_CONST + state->nconsts++; } else return lvn_new_value(state); } case JIT_VALUE_INVALID: return VN_INVALID; case JIT_VALUE_HANDLE: case JIT_VALUE_DOUBLE: return lvn_new_value(state); default: fatal_trace("cannot handle value kind %d in lvn_value_num", value.kind); } } static inline bool lvn_is_commutative(jit_op_t op) { return op == J_ADD || op == J_MUL || op == J_AND || op == J_OR; } static inline void lvn_kill_flags(lvn_state_t *state) { state->regvn[state->func->nregs] = VN_INVALID; } static void lvn_kill_args(lvn_state_t *state) { for (int i = 0; i < TRACK_ARGS; i++) state->regvn[state->func->nregs + i + 1] = VN_INVALID; } static void lvn_commute_const(jit_ir_t *ir, lvn_state_t *state) { assert(lvn_is_commutative(ir->op)); int64_t cval; if (lvn_is_const(ir->arg1, state, &cval)) { jit_value_t tmp = ir->arg1; ir->arg1 = ir->arg2; ir->arg2 = tmp; } } static void lvn_get_tuple(jit_ir_t *ir, lvn_state_t *state, int tuple[3]) { tuple[0] = ir->op | ir->size << 8 | ir->cc << 11; const valnum_t vn1 = lvn_value_num(ir->arg1, state); const valnum_t vn2 = lvn_value_num(ir->arg2, state); if (lvn_is_commutative(ir->op) && vn1 > vn2) { tuple[1] = vn2; tuple[2] = vn1; } else { tuple[1] = vn1; tuple[2] = vn2; } } static void jit_lvn_generic(jit_ir_t *ir, lvn_state_t *state, valnum_t vn) { assert(ir->result != JIT_REG_INVALID); int tuple[3]; lvn_get_tuple(ir, state, tuple); const uint32_t hash = mix_bits_32(tuple[0]*29 + tuple[1]*1093 + tuple[2]*6037); for (int idx = hash & (state->tabsz - 1), limit = 0, stale = -1; limit < 10; idx = (idx + 1) & (state->tabsz - 1), limit++) { lvn_tab_t *tab = &(state->hashtab[idx]); if (tab->ir == NULL) { if (stale >= 0) // Reuse earlier stale entry if possible tab = &(state->hashtab[stale]); tab->ir = ir; tab->vn = state->regvn[ir->result] = (vn == VN_INVALID ? lvn_new_value(state) : vn); break; } else if (tab->vn != state->regvn[tab->ir->result]) { // Stale entry may be reused if we do not find matching value stale = idx; continue; } else { int cmp[3]; lvn_get_tuple(tab->ir, state, cmp); if (cmp[0] == tuple[0] && cmp[1] == tuple[1] && cmp[2] == tuple[2]) { assert(tab->ir->result != JIT_REG_INVALID); ir->op = J_MOV; ir->size = JIT_SZ_UNSPEC; ir->cc = JIT_CC_NONE; // Propagate constants where possible int64_t cval; if (lvn_get_const(state->regvn[tab->ir->result], state, &cval)) ir->arg1 = LVN_CONST(cval); else ir->arg1 = LVN_REG(tab->ir->result); ir->arg2.kind = JIT_VALUE_INVALID; state->regvn[ir->result] = tab->vn; break; } } } } static void jit_lvn_mul(jit_ir_t *ir, lvn_state_t *state) { if (ir->cc != JIT_CC_NONE) lvn_kill_flags(state); int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) { #define FOLD_MUL(type) do { \ type result; \ if (!__builtin_mul_overflow(lhs, rhs, &result)) { \ lvn_convert_mov(ir, state, LVN_CONST(result)); \ return; \ } \ } while (0) FOR_ALL_JIT_SIZES(ir->size, FOLD_MUL); #undef FOLD_MUL } lvn_commute_const(ir, state); if (lvn_is_const(ir->arg2, state, &rhs)) { if (rhs == 0) { lvn_convert_mov(ir, state, LVN_CONST(0)); return; } else if (rhs == 1) { lvn_convert_mov(ir, state, LVN_REG(ir->arg1.reg)); return; } else if (rhs > 0 && is_power_of_2(rhs) && ir->size == JIT_SZ_UNSPEC) { ir->op = J_SHL; ir->arg2 = LVN_CONST(ilog2(rhs)); jit_lvn_generic(ir, state, VN_INVALID); return; } } jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_div(jit_ir_t *ir, lvn_state_t *state) { if (ir->cc != JIT_CC_NONE) lvn_kill_flags(state); int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs) && rhs != 0) { // XXX: potential bug here with INT_MIN/-1 #define FOLD_DIV(type) do { \ type result = (type)lhs / (type)rhs; \ lvn_convert_mov(ir, state, LVN_CONST(result)); \ return; \ } while (0) FOR_ALL_JIT_SIZES(ir->size, FOLD_DIV); #undef FOLD_DIV } else if (lvn_is_const(ir->arg2, state, &rhs) && rhs == 1) { lvn_convert_mov(ir, state, LVN_REG(ir->arg1.reg)); return; } jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_add(jit_ir_t *ir, lvn_state_t *state) { if (ir->cc != JIT_CC_NONE) lvn_kill_flags(state); int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) { #define FOLD_ADD(type) do { \ type result; \ if (!__builtin_add_overflow(lhs, rhs, &result)) { \ lvn_convert_mov(ir, state, LVN_CONST(result)); \ return; \ } \ } while (0) FOR_ALL_JIT_SIZES(ir->size, FOLD_ADD); #undef FOLD_ADD } lvn_commute_const(ir, state); if (lvn_is_const(ir->arg2, state, &rhs) && rhs == 0) { lvn_convert_mov(ir, state, LVN_REG(ir->arg1.reg)); return; } jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_sub(jit_ir_t *ir, lvn_state_t *state) { if (ir->cc != JIT_CC_NONE) lvn_kill_flags(state); int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) { #define FOLD_SUB(type) do { \ type result; \ if (!__builtin_sub_overflow(lhs, rhs, &result)) { \ lvn_convert_mov(ir, state, LVN_CONST(result)); \ return; \ } \ } while (0) FOR_ALL_JIT_SIZES(ir->size, FOLD_SUB); #undef FOLD_SUB } if (lvn_is_const(ir->arg2, state, &rhs) && rhs == 0) { lvn_convert_mov(ir, state, LVN_REG(ir->arg1.reg)); return; } else if (lvn_is_const(ir->arg1, state, &lhs) && lhs == 0 && ir->cc == JIT_CC_NONE && ir->size == JIT_SZ_UNSPEC) { ir->op = J_NEG; ir->arg1 = ir->arg2; ir->arg2.kind = JIT_VALUE_INVALID; jit_lvn_generic(ir, state, VN_INVALID); return; } jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_neg(jit_ir_t *ir, lvn_state_t *state) { int64_t value; if (lvn_is_const(ir->arg1, state, &value)) lvn_convert_mov(ir, state, LVN_CONST(-value)); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_or(jit_ir_t *ir, lvn_state_t *state) { int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) lvn_convert_mov(ir, state, LVN_CONST(lhs | rhs)); else if (lvn_is_const(ir->arg1, state, &lhs) && lhs == 0) lvn_convert_mov(ir, state, ir->arg2); else if (lvn_is_const(ir->arg2, state, &rhs) && rhs == 0) lvn_convert_mov(ir, state, ir->arg1); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_xor(jit_ir_t *ir, lvn_state_t *state) { int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) lvn_convert_mov(ir, state, LVN_CONST(lhs ^ rhs)); else if (lvn_is_const(ir->arg1, state, &lhs) && lhs == 0) lvn_convert_mov(ir, state, ir->arg2); else if (lvn_is_const(ir->arg2, state, &rhs) && rhs == 0) lvn_convert_mov(ir, state, ir->arg1); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_shl(jit_ir_t *ir, lvn_state_t *state) { int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs) && rhs >= 0 && rhs < 64) lvn_convert_mov(ir, state, LVN_CONST(lhs << rhs)); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_asr(jit_ir_t *ir, lvn_state_t *state) { int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs) && rhs >= 0 && rhs < 64) lvn_convert_mov(ir, state, LVN_CONST(lhs >> rhs)); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_mov(jit_ir_t *ir, lvn_state_t *state) { if (ir->arg1.kind == JIT_VALUE_REG && ir->arg1.reg == ir->result) { lvn_convert_nop(ir); return; } valnum_t vn = lvn_value_num(ir->arg1, state); if (state->regvn[ir->result] == vn) { // Result register already contains this value lvn_convert_nop(ir); return; } jit_lvn_generic(ir, state, vn); } static void jit_lvn_cmp(jit_ir_t *ir, lvn_state_t *state) { int64_t lhs, rhs; if (lvn_can_fold(ir, state, &lhs, &rhs)) { bool result = false; switch (ir->cc) { case JIT_CC_EQ: result = (lhs == rhs); break; case JIT_CC_NE: result = (lhs != rhs); break; case JIT_CC_LT: result = (lhs < rhs); break; case JIT_CC_GT: result = (lhs > rhs); break; case JIT_CC_LE: result = (lhs <= rhs); break; case JIT_CC_GE: result = (lhs >= rhs); break; default: fatal_trace("unhandled condition code in jit_lvn_cmp"); } state->regvn[state->func->nregs] = result; } else state->regvn[state->func->nregs] = VN_INVALID; } static void jit_lvn_ccmp(jit_ir_t *ir, lvn_state_t *state) { const int fconst = state->regvn[state->func->nregs]; if (fconst == 0) lvn_convert_nop(ir); else if (fconst != VN_INVALID) { ir->op = J_CMP; jit_lvn_cmp(ir, state); } else lvn_kill_flags(state); } static void jit_lvn_csel(jit_ir_t *ir, lvn_state_t *state) { const int fconst = state->regvn[state->func->nregs]; if (fconst != VN_INVALID) lvn_convert_mov(ir, state, fconst ? ir->arg1 : ir->arg2); } static void jit_lvn_cset(jit_ir_t *ir, lvn_state_t *state) { const int fconst = state->regvn[state->func->nregs]; if (fconst != VN_INVALID) lvn_convert_mov(ir, state, LVN_CONST(fconst)); } static void jit_lvn_jump(jit_ir_t *ir, lvn_state_t *state) { assert(ir->arg1.label < state->func->nirs); jit_ir_t *dest = &(state->func->irbuf[ir->arg1.label]); const int fconst = state->regvn[state->func->nregs]; if (ir->cc != JIT_CC_NONE && fconst != VN_INVALID) { if (fconst == (ir->cc == JIT_CC_T)) ir->cc = JIT_CC_NONE; else { lvn_convert_nop(ir); return; } } if (dest == ir + 1) lvn_convert_nop(ir); else if (dest->op == J_JUMP && dest->cc == JIT_CC_NONE) ir->arg1 = dest->arg1; // Simple jump threading } static void jit_lvn_clamp(jit_ir_t *ir, lvn_state_t *state) { int64_t value; if (lvn_is_const(ir->arg1, state, &value)) lvn_convert_mov(ir, state, LVN_CONST(value < 0 ? 0 : value)); else jit_lvn_generic(ir, state, VN_INVALID); } static void jit_lvn_recv(jit_ir_t *ir, lvn_state_t *state) { const unsigned nth = ir->arg1.int64; if (nth >= TRACK_ARGS) return; const unsigned vreg = state->func->nregs + 1 + nth; if (state->regvn[vreg] != VN_INVALID) state->regvn[ir->result] = state->regvn[vreg]; else { valnum_t vn = lvn_new_value(state); state->regvn[vreg] = vn; state->regvn[ir->result] = vn; } } static void jit_lvn_send(jit_ir_t *ir, lvn_state_t *state) { const unsigned nth = ir->arg1.int64; if (nth >= TRACK_ARGS) return; else if (ir->arg2.kind != JIT_VALUE_REG) return; const unsigned vreg = state->func->nregs + 1 + nth; valnum_t vn = lvn_value_num(ir->arg2, state); if (vn != VN_INVALID && state->regvn[vreg] == vn) lvn_convert_nop(ir); // Already in argument slot } static void jit_lvn_copy(jit_ir_t *ir, lvn_state_t *state) { if (ir->op == MACRO_MOVE && ir->arg2.kind == JIT_ADDR_CPOOL) ir->op = MACRO_COPY; // Cannot overlap when copying from constant pool int64_t count; if (lvn_get_const(state->regvn[ir->result], state, &count)) { if (count == 0) { lvn_convert_nop(ir); return; } else if (count > 0 && count <= 8 && is_power_of_2(count) && ir->arg2.kind == JIT_ADDR_CPOOL) { // Replace a small copy from the constant pool with a store const void *src = state->func->cpool + ir->arg2.int64; ir->op = J_STORE; ir->arg2 = ir->arg1; ir->result = JIT_REG_INVALID; switch (count) { case 8: ir->size = JIT_SZ_64; ir->arg1 = LVN_CONST(unaligned_load(src, uint64_t)); break; case 4: ir->size = JIT_SZ_32; ir->arg1 = LVN_CONST(unaligned_load(src, uint32_t)); break; case 2: ir->size = JIT_SZ_16; ir->arg1 = LVN_CONST(unaligned_load(src, uint16_t)); break; case 1: ir->size = JIT_SZ_8; ir->arg1 = LVN_CONST(*(uint8_t *)src); break; default: jit_dump_with_mark(state->func, ir - state->func->irbuf); fatal_trace("unhandled constant copy from constant pool"); } return; } } // Clobbers the count register state->regvn[ir->result] = lvn_new_value(state); } static void jit_lvn_bzero(jit_ir_t *ir, lvn_state_t *state) { int64_t count; if (lvn_get_const(state->regvn[ir->result], state, &count)) { if (count == 0) { lvn_convert_nop(ir); return; } else if (count > 0 && count <= 8 && is_power_of_2(count)) { // Convert to a store of zero ir->op = J_STORE; ir->arg2 = ir->arg1; ir->arg1 = LVN_CONST(0); ir->result = JIT_REG_INVALID; ir->size = ilog2(count); return; } } // Clobbers the count register state->regvn[ir->result] = lvn_new_value(state); } static void jit_lvn_memset(jit_ir_t *ir, lvn_state_t *state) { int64_t value; if (lvn_is_const(ir->arg2, state, &value)) { static const uint64_t compress[JIT_SZ_UNSPEC] = { 0x01, 0x0101, 0x01010101, 0x0101010101010101 }; static const uint64_t expand[JIT_SZ_UNSPEC] = { 0x0101010101010101, 0x0001000100010001, 0x100000001, 1, }; static const uint64_t mask[JIT_SZ_UNSPEC] = { 0xff, 0xffff, 0xffffffff, 0xffffffffffffffff }; uint64_t bits = value; if (value == 0) { ir->op = MACRO_BZERO; ir->size = JIT_SZ_UNSPEC; ir->arg2.kind = JIT_VALUE_INVALID; jit_lvn_bzero(ir, state); return; } else if (bits == (bits & 0xff) * compress[ir->size]) { ir->size = JIT_SZ_8; ir->arg2 = LVN_CONST((bits &= 0xff)); } int64_t bytes; if (lvn_get_const(state->regvn[ir->result], state, &bytes)) { if (bytes == 0) { lvn_convert_nop(ir); return; } else if (bytes > 0 && bytes <= 8 && is_power_of_2(bytes)) { // Convert to a store const jit_size_t newsz = ilog2(bytes); ir->op = J_STORE; ir->arg2 = ir->arg1; ir->arg1 = LVN_CONST((bits * expand[ir->size]) & mask[newsz]); ir->result = JIT_REG_INVALID; ir->size = newsz; return; } } } // Clobbers the count register state->regvn[ir->result] = lvn_new_value(state); } static void jit_lvn_exp(jit_ir_t *ir, lvn_state_t *state) { int64_t base, exp; if (ir->cc != JIT_CC_NONE) { lvn_kill_flags(state); jit_lvn_generic(ir, state, VN_INVALID); } else if (lvn_can_fold(ir, state, &base, &exp)) lvn_convert_mov(ir, state, LVN_CONST(ipow(base, exp))); else if (lvn_is_const(ir->arg1, state, &base) && base == 2) { ir->op = J_SHL; ir->arg1.int64 = 1; jit_lvn_generic(ir, state, VN_INVALID); } else jit_lvn_generic(ir, state, VN_INVALID); } void jit_do_lvn(jit_func_t *f) { lvn_state_t state = { .tabsz = next_power_of_2(f->nirs), .func = f, .nextvn = FIRST_VN }; state.regvn = xmalloc_array(f->nregs + 1 + TRACK_ARGS, sizeof(valnum_t)); state.hashtab = xcalloc_array(state.tabsz, sizeof(lvn_tab_t)); bool reset = true; for (jit_ir_t *ir = f->irbuf; ir < f->irbuf + f->nirs; reset = cfg_is_terminator(f, ir), ir++) { if (reset || ir->target) { for (int j = 0; j < f->nregs + 1 + TRACK_ARGS; j++) state.regvn[j] = VN_INVALID; } switch (ir->op) { case J_MUL: jit_lvn_mul(ir, &state); break; case J_DIV: jit_lvn_div(ir, &state); break; case J_ADD: jit_lvn_add(ir, &state); break; case J_SUB: jit_lvn_sub(ir, &state); break; case J_NEG: jit_lvn_neg(ir, &state); break; case J_OR: jit_lvn_or(ir, &state); break; case J_XOR: jit_lvn_xor(ir, &state); break; case J_SHL: jit_lvn_shl(ir, &state); break; case J_ASR: jit_lvn_asr(ir, &state); break; case J_MOV: jit_lvn_mov(ir, &state); break; case J_CMP: jit_lvn_cmp(ir, &state); break; case J_CCMP: jit_lvn_ccmp(ir, &state); break; case J_CSEL: jit_lvn_csel(ir, &state); break; case J_CSET: jit_lvn_cset(ir, &state); break; case J_JUMP: jit_lvn_jump(ir, &state); break; case J_CLAMP: jit_lvn_clamp(ir, &state); break; case J_RECV: jit_lvn_recv(ir, &state); break; case J_SEND: jit_lvn_send(ir, &state); break; case MACRO_MOVE: case MACRO_COPY: jit_lvn_copy(ir, &state); break; case MACRO_BZERO: jit_lvn_bzero(ir, &state); break; case MACRO_MEMSET: jit_lvn_memset(ir, &state); break; case MACRO_EXP: jit_lvn_exp(ir, &state); break; case MACRO_EXIT: case J_CALL: lvn_kill_args(&state); // Fall-through default: if (jit_writes_flags(ir)) state.regvn[f->nregs] = VN_INVALID; if (ir->result != JIT_REG_INVALID) state.regvn[ir->result] = VN_INVALID; } } free(state.regvn); free(state.hashtab); } //////////////////////////////////////////////////////////////////////////////// // Copy propagation void jit_do_cprop(jit_func_t *f) { jit_value_t *map LOCAL = xmalloc_array(f->nregs, sizeof(jit_value_t)); bool reset = true; for (jit_ir_t *ir = f->irbuf; ir < f->irbuf + f->nirs; reset = cfg_is_terminator(f, ir), ir++) { if (reset || ir->target) { for (int j = 0; j < f->nregs; j++) map[j].kind = JIT_VALUE_INVALID; } if (ir->arg1.kind == JIT_VALUE_REG) { jit_value_t copy = map[ir->arg1.reg]; if (copy.kind != JIT_VALUE_INVALID) ir->arg1 = copy; } if (ir->arg2.kind == JIT_VALUE_REG) { jit_value_t copy = map[ir->arg2.reg]; if (copy.kind != JIT_VALUE_INVALID) ir->arg2 = copy; } if (ir->result == JIT_REG_INVALID) continue; else if (ir->op == MACRO_MEMSET || ir->op == MACRO_COPY || ir->op == MACRO_MOVE || ir->op == MACRO_BZERO) continue; // Does not write to result else if (map[ir->result].kind != JIT_VALUE_INVALID) { // Invalidate any existing copies of this register for (int j = 0; j < f->nregs; j++) { if (map[j].kind == JIT_VALUE_REG && map[j].reg == ir->result) map[j].kind = JIT_VALUE_INVALID; } } if (ir->op == J_MOV) { map[ir->result] = ir->arg1; if (ir->arg1.kind == JIT_VALUE_REG) map[ir->arg1.reg] = ir->arg1; } else map[ir->result].kind = JIT_VALUE_INVALID; } } //////////////////////////////////////////////////////////////////////////////// // Dead code elimination typedef struct { int *count; jit_reg_t *renumber; jit_reg_t next; } dce_state_t; static void dce_count_use(jit_value_t value, dce_state_t *state) { if (value.kind == JIT_VALUE_REG || value.kind == JIT_ADDR_REG) { if (state->count[value.reg]++ == 0) state->renumber[value.reg] = state->next++; } } static void dce_renumber(jit_value_t *value, dce_state_t *state) { if (value->kind == JIT_VALUE_REG || value->kind == JIT_ADDR_REG) value->reg = state->renumber[value->reg]; } void jit_do_dce(jit_func_t *f) { dce_state_t state = {}; state.count = xcalloc_array(f->nregs, sizeof(int)); state.renumber = xcalloc_array(f->nregs, sizeof(jit_reg_t)); #ifdef DEBUG for (int i = 0; i < f->nregs; i++) state.renumber[i] = JIT_REG_INVALID; #endif for (jit_ir_t *ir = f->irbuf; ir < f->irbuf + f->nirs; ir++) { dce_count_use(ir->arg1, &state); dce_count_use(ir->arg2, &state); const bool must_keep_result = ir->result != JIT_REG_INVALID && (cfg_reads_result(ir) || jit_writes_flags(ir)); if (must_keep_result && state.count[ir->result]++ == 0) state.renumber[ir->result] = state.next++; } for (jit_ir_t *ir = f->irbuf, *cmp = NULL; ir < f->irbuf + f->nirs; ir++) { dce_renumber(&ir->arg1, &state); dce_renumber(&ir->arg2, &state); if (jit_reads_flags(ir) || cfg_is_terminator(f, ir)) cmp = NULL; // Consumed flags else if (jit_writes_flags(ir)) { if (cmp != NULL) lvn_convert_nop(cmp); // Flags are never read if (ir->op == J_CMP || ir->op == J_FCMP) cmp = ir; else cmp = NULL; } if (ir->result == JIT_REG_INVALID) continue; else if (state.count[ir->result] == 0 && !jit_writes_flags(ir)) lvn_convert_nop(ir); else ir->result = state.renumber[ir->result]; } f->nregs = state.next; free(state.count); free(state.renumber); } //////////////////////////////////////////////////////////////////////////////// // NOP deletion void jit_delete_nops(jit_func_t *f) { jit_label_t *map LOCAL = xmalloc_array(f->nirs, sizeof(jit_label_t)); int wptr = 0; for (jit_ir_t *ir = f->irbuf; ir < f->irbuf + f->nirs; ir++) { map[ir - f->irbuf] = wptr; if (ir->op != J_NOP) { jit_ir_t *dest = f->irbuf + wptr++; if (dest != ir) *dest = *ir; } } for (jit_ir_t *ir = f->irbuf; ir < f->irbuf + f->nirs; ir++) { if (ir->arg1.kind == JIT_VALUE_LABEL) { ir->arg1.label = map[ir->arg1.label]; f->irbuf[ir->arg1.label].target = 1; } if (ir->arg2.kind == JIT_VALUE_LABEL) { ir->arg2.label = map[ir->arg2.label]; f->irbuf[ir->arg2.label].target = 1; } } f->nirs = wptr; } //////////////////////////////////////////////////////////////////////////////// // Memory to register promotion static inline jit_reg_t get_value_reg(jit_value_t value) { switch (value.kind) { case JIT_ADDR_REG: case JIT_VALUE_REG: return value.reg; default: return JIT_REG_INVALID; } } static bool try_promote_allocation(jit_func_t *f, jit_ir_t *alloc) { assert(alloc->arg2.kind == JIT_VALUE_INT64); if (alloc->arg2.int64 > 8 || !is_power_of_2(alloc->arg2.int64)) return false; jit_size_t sz = JIT_SZ_UNSPEC; switch (alloc->arg2.int64) { case 1: sz = JIT_SZ_8; break; case 2: sz = JIT_SZ_16; break; case 4: sz = JIT_SZ_32; break; case 8: sz = JIT_SZ_64; break; } jit_reg_t reg = alloc->result; assert(reg != JIT_REG_INVALID); int first = -1, last = -1; for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->result == reg && ir != alloc) return false; else if (ir->op == J_LOAD || ir->op == J_STORE) { jit_value_t addr = ir->op == J_LOAD ? ir->arg1 : ir->arg2; if (get_value_reg(addr) != reg) continue; else if (addr.disp != 0 || ir->size != sz) return false; else if (ir->op == J_STORE && get_value_reg(ir->arg1) == reg) return false; else if (first == -1) first = last = i; else last = i; } else if (get_value_reg(ir->arg1) == reg) return false; else if (get_value_reg(ir->arg2) == reg) return false; } if (first != -1) { for (jit_ir_t *ir = f->irbuf + first; ir <= f->irbuf + last; ir++) { if (ir->op == J_STORE && get_value_reg(ir->arg2) == reg) { ir->op = J_MOV; ir->size = JIT_SZ_UNSPEC; ir->cc = JIT_CC_NONE; ir->result = reg; ir->arg2.kind = JIT_VALUE_INVALID; } else if (ir->op == J_LOAD && get_value_reg(ir->arg1) == reg) { ir->op = J_MOV; ir->size = JIT_SZ_UNSPEC; ir->cc = JIT_CC_NONE; ir->arg1.kind = JIT_VALUE_REG; ir->arg1.reg = reg; } } } alloc->op = J_NOP; alloc->size = JIT_SZ_UNSPEC; alloc->cc = JIT_CC_NONE; alloc->result = JIT_REG_INVALID; alloc->arg1.kind = JIT_VALUE_INVALID; alloc->arg2.kind = JIT_VALUE_INVALID; return true; } void jit_do_mem2reg(jit_func_t *f) { if (f->framesz == 0) return; int replaced = 0; for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->op == MACRO_SALLOC && try_promote_allocation(f, ir)) replaced++; else if (cfg_is_terminator(f, ir)) break; } if (replaced == 0) return; int newsize = 0; for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->op == MACRO_SALLOC) { assert(ir->arg1.kind == JIT_VALUE_INT64); assert(ir->arg1.int64 >= newsize); ir->arg1.int64 = newsize; assert(ir->arg2.kind == JIT_VALUE_INT64); newsize += ALIGN_UP(ir->arg2.int64, 8); } else if (cfg_is_terminator(f, ir)) break; } assert(newsize <= f->framesz); f->framesz = newsize; } //////////////////////////////////////////////////////////////////////////////// // Register allocation typedef struct { jit_reg_t reg; unsigned first; unsigned last; } lscan_interval_t; static void lscan_grow_range(jit_reg_t reg, lscan_interval_t *li, int pos) { assert(reg != JIT_REG_INVALID); li[reg].first = MIN(li[reg].first, pos); li[reg].last = MAX(li[reg].last, pos); } static void lscan_walk_cfg(jit_func_t *f, jit_cfg_t *cfg, int bi, lscan_interval_t *li, bit_mask_t *visited) { if (mask_test(visited, bi)) return; mask_set(visited, bi); jit_block_t *b = &(cfg->blocks[bi]); for (size_t bit = -1; mask_iter(&b->livein, &bit);) lscan_grow_range(bit, li, b->first); for (int i = b->first; i <= b->last; i++) { jit_ir_t *ir = &(f->irbuf[i]); if (ir->result != JIT_REG_INVALID) lscan_grow_range(ir->result, li, i); if (ir->arg1.kind == JIT_VALUE_REG || ir->arg1.kind == JIT_ADDR_REG) lscan_grow_range(ir->arg1.reg, li, i); if (ir->arg2.kind == JIT_VALUE_REG || ir->arg2.kind == JIT_ADDR_REG) lscan_grow_range(ir->arg2.reg, li, i); } for (size_t bit = -1; mask_iter(&b->liveout, &bit); ) lscan_grow_range(bit, li, b->last); for (int i = 0; i < b->out.count; i++) { const int next = jit_get_edge(&(b->out), i); lscan_walk_cfg(f, cfg, next, li, visited); } } static int lscan_interval_cmp(const void *a, const void *b) { const lscan_interval_t *la = a; const lscan_interval_t *lb = b; if (la->first < lb->first) return -1; else if (la->first > lb->first) return 1; else return 0; } static inline void lscan_shift_active(lscan_interval_t **active, unsigned to, unsigned from, unsigned count) { if (to != from && count == 1) active[to] = active[from]; else if (to != from && count > 1) memmove(active + to, active + from, count * sizeof(lscan_interval_t *)); } int jit_do_lscan(jit_func_t *f, phys_slot_t *slots, uint64_t badmask) { // // Massimiliano Poletto and Vivek Sarkar // Linear Scan Register Allocation // ACM Trans. Program. Lang. Syst., Vol. 21, 5 (sep 1999), 895--913 // https://doi.org/10.1145/330249.330250 // jit_cfg_t *cfg = jit_get_cfg(f); lscan_interval_t *li LOCAL = xmalloc_array(f->nregs, sizeof(lscan_interval_t)); for (int i = 0; i < f->nregs; i++) { li[i].reg = i; li[i].first = UINT_MAX; li[i].last = 0; slots[i] = UINT_MAX; } bit_mask_t visited; mask_init(&visited, cfg->nblocks); lscan_walk_cfg(f, cfg, 0, li, &visited); mask_free(&visited); jit_free_cfg(cfg); qsort(li, f->nregs, sizeof(lscan_interval_t), lscan_interval_cmp); const int Rint = 32 - __builtin_popcountl(badmask & 0xffffffff); uint32_t freeregs = ~(badmask & 0xffffffff); lscan_interval_t **active LOCAL = xmalloc_array(f->nregs, sizeof(lscan_interval_t *)); unsigned nactive = 0, next_spill = STACK_BASE; for (int i = 0; i < f->nregs; i++) { // Expire old intervals int expire = 0; for (; expire < nactive; expire++) { const lscan_interval_t *next = active[expire]; if (next->last >= li[i].first) break; else { assert(slots[next->reg] < STACK_BASE); freeregs |= (1 << slots[next->reg]); } } lscan_shift_active(active, 0, expire, nactive - expire); nactive -= expire; const lscan_interval_t *this = &li[i]; bool allocated = false; if (nactive == Rint) { // Spill at interval const lscan_interval_t *spill = active[nactive - 1]; if (spill->last > this->last) { slots[this->reg] = slots[spill->reg]; slots[spill->reg] = next_spill++; nactive--; allocated = true; } else slots[this->reg] = next_spill++; } else { const int bit = __builtin_ffsl(freeregs) - 1; assert(bit >= 0); assert(freeregs & (1 << bit)); freeregs &= ~(1 << bit); slots[this->reg] = bit; allocated = true; } if (allocated) { // Add to active list, sorted by increasing end point int pos = 0; for (; pos < nactive && active[pos]->last <= li[i].last; pos++) assert(active[pos] != &li[i]); assert(pos < f->nregs); if (pos < nactive) lscan_shift_active(active, pos + 1, pos, nactive - pos); active[pos] = &li[i]; nactive++; } } return next_spill - STACK_BASE; } nvc-r1.17.1/src/jit/jit-pack.c000066400000000000000000000412021504111170000157610ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "fbuf.h" #include "hash.h" #include "ident.h" #include "jit/jit-priv.h" #include "lib.h" #include "object.h" #include #include #include #include typedef struct { ident_t name; const char *strtab; const uint8_t *buf; const uint8_t *rptr; const uint8_t *cpool; loc_t last_loc; } pack_func_t; struct _jit_pack { chash_t *funcs; ZSTD_DCtx *zstd; const void *mmap; size_t map_size; nvc_lock_t zlock; }; typedef struct _pack_writer { text_buf_t *strtab; shash_t *strhash; size_t bufsz; uint8_t *wptr; uint8_t *buf; ZSTD_CCtx *zstd; loc_t last_loc; } pack_writer_t; //////////////////////////////////////////////////////////////////////////////// // JIT bytecode serialisation static inline int encode_number(uint64_t value, uint8_t buf[10]) { int num = 0; do { uint8_t byte = value & 0x7f; value >>= 7; if (value) byte |= 0x80; buf[num++] = byte; } while (value); assert(num <= 10); return num; } static inline uint64_t decode_number(const uint8_t **buf) { const uint8_t b0 = *((*buf)++); if (!(b0 & 0x80)) return b0; uint64_t val = b0 & 0x7f; int shift = 7; uint8_t byte; do { byte = *((*buf)++); val |= (uint64_t)(byte & 0x7f) << shift; shift += 7; } while (byte & 0x80); return val; } static inline void pack_grow(pack_writer_t *pw, size_t minsz) { const size_t used = pw->wptr - pw->buf; if (unlikely(used + minsz > pw->bufsz)) { pw->bufsz = MAX(pw->bufsz + minsz, (3 * pw->bufsz) / 2); pw->buf = xrealloc(pw->buf, pw->bufsz); pw->wptr = pw->buf + used; } } static inline void pack_u8(pack_writer_t *pw, uint8_t value) { pack_grow(pw, 1); *pw->wptr++ = value; } static inline void pack_u16(pack_writer_t *pw, uint16_t value) { pack_grow(pw, 2); *pw->wptr++ = value & 0xff; *pw->wptr++ = value >> 8; } static void pack_uint(pack_writer_t *pw, uint64_t value) { pack_grow(pw, 10); pw->wptr += encode_number(value, pw->wptr); } static inline void pack_int(pack_writer_t *pw, int64_t value) { uint64_t zz = ((uint64_t)value << 1) ^ (value >> 63); // Zig-zag encoding pack_uint(pw, zz); } static void pack_str(pack_writer_t *pw, const char *str) { pack_uint(pw, pack_writer_get_string(pw, str)); } static void pack_loc(pack_writer_t *pw, const loc_t *loc) { if (loc_invalid_p(&pw->last_loc) || loc->file_ref != pw->last_loc.file_ref) { pack_str(pw, loc_file_str(loc)); pack_uint(pw, loc->first_line); pack_uint(pw, loc->first_column); } else { const int line_delta = loc->first_line - pw->last_loc.first_line; const int column_delta = loc->first_column - pw->last_loc.first_column; pack_u8(pw, 0); pack_int(pw, line_delta); pack_int(pw, column_delta); } pw->last_loc = *loc; } static inline void pack_reg(pack_writer_t *pw, jit_reg_t reg) { pack_uint(pw, reg == JIT_REG_INVALID ? 0 : reg + 1); } static inline void pack_double(pack_writer_t *pw, double value) { jit_scalar_t u = { .real = value }; pack_uint(pw, u.integer); } static void pack_handle(pack_writer_t *pw, jit_t *j, jit_handle_t handle) { if (handle == JIT_HANDLE_INVALID) pack_str(pw, NULL); else pack_str(pw, istr(jit_get_func(j, handle)->name)); } static void pack_locus(pack_writer_t *pw, object_t *obj) { ident_t module; ptrdiff_t offset; object_locus(obj, &module, &offset); pack_str(pw, istr(module)); pack_uint(pw, offset); } static void pack_value(pack_writer_t *pw, jit_t *j, jit_value_t value) { if (value.kind == JIT_VALUE_VPOS) { // Not needed anymore pack_u8(pw, JIT_VALUE_INVALID); return; } pack_u8(pw, value.kind); switch (value.kind) { case JIT_VALUE_INVALID: break; case JIT_VALUE_REG: pack_reg(pw, value.reg); break; case JIT_VALUE_INT64: pack_int(pw, value.int64); break; case JIT_VALUE_DOUBLE: pack_double(pw, value.dval); break; case JIT_ADDR_REG: pack_reg(pw, value.reg); pack_uint(pw, value.disp); break; case JIT_ADDR_CPOOL: pack_uint(pw, value.int64); break; case JIT_ADDR_ABS: case JIT_ADDR_COVER: pack_uint(pw, value.int64); break; case JIT_VALUE_LABEL: pack_uint(pw, value.label); break; case JIT_VALUE_HANDLE: pack_handle(pw, j, value.handle); break; case JIT_VALUE_EXIT: pack_u8(pw, value.exit); break; case JIT_VALUE_LOC: pack_loc(pw, &(value.loc)); break; case JIT_VALUE_LOCUS: pack_locus(pw, value.locus); break; default: fatal_trace("cannot handle value kind %d in pack_value", value.kind); } } static void pack_func(pack_writer_t *pw, jit_t *j, jit_func_t *f) { pw->last_loc = LOC_INVALID; pack_uint(pw, f->nirs); pack_uint(pw, f->nregs); pack_uint(pw, f->nvars); pack_uint(pw, f->cpoolsz); pack_uint(pw, f->spec.bits); pack_uint(pw, f->framesz); for (int i = 0; i < f->nvars; i++) { pack_str(pw, istr(f->linktab[i].name)); pack_uint(pw, f->linktab[i].offset); } ident_t module; ptrdiff_t offset; object_locus(f->object, &module, &offset); pack_str(pw, istr(module)); pack_uint(pw, offset); for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); const uint16_t enc = (ir->op << 8) | (ir->size << 5) | (ir->target << 4) | ir->cc; pack_u16(pw, enc); pack_reg(pw, ir->result); pack_value(pw, j, ir->arg1); pack_value(pw, j, ir->arg2); } } pack_writer_t *pack_writer_new(void) { pack_writer_t *pw = xcalloc(sizeof(pack_writer_t)); pw->strhash = shash_new(16); pw->strtab = tb_new(); pw->bufsz = 512; pw->buf = xmalloc(pw->bufsz); pw->wptr = pw->buf; if ((pw->zstd = ZSTD_createCCtx()) == NULL) fatal_trace("ZSTD_createCCtx failed"); tb_append(pw->strtab, '\0'); // Null string is index zero return pw; } unsigned pack_writer_get_string(pack_writer_t *pw, const char *str) { if (str == NULL) return 0; const uintptr_t exist = (uintptr_t)shash_get(pw->strhash, str); if (exist != 0) return exist; const unsigned off = tb_len(pw->strtab); shash_put(pw->strhash, str, (void *)(uintptr_t)off); tb_catn(pw->strtab, str, strlen(str) + 1); return off; } void pack_writer_emit(pack_writer_t *pw, jit_t *j, jit_handle_t handle, uint8_t **buf, size_t *size) { jit_func_t *f = jit_get_func(j, handle); jit_fill_irbuf(f); assert(pw->wptr == pw->buf); pack_func(pw, j, f); const size_t ubufsz = pw->wptr - pw->buf; const size_t zbufsz = ZSTD_compressBound(ubufsz) + 10; uint8_t *zbuf = xmalloc(zbufsz); int start = 0; size_t encsz = ubufsz; do { uint8_t byte = encsz & 0x7f; encsz >>= 7; if (encsz) byte |= 0x80; zbuf[start++] = byte; } while (encsz); const size_t csize = ZSTD_compressCCtx(pw->zstd, zbuf + start, zbufsz - start, pw->buf, ubufsz, 3); if (ZSTD_isError(csize)) fatal("ZSTD compress failed: %s: %s", istr(f->name), ZSTD_getErrorName(csize)); pw->wptr = pw->buf; *buf = zbuf; *size = csize + start; } void pack_writer_string_table(pack_writer_t *pw, const char **tab, size_t *size) { *tab = tb_get(pw->strtab); *size = tb_len(pw->strtab); } void pack_writer_free(pack_writer_t *pw) { ZSTD_freeCCtx(pw->zstd); free(pw->buf); tb_free(pw->strtab); shash_free(pw->strhash); free(pw); } //////////////////////////////////////////////////////////////////////////////// // JIT bytecode loader jit_pack_t *jit_pack_new(void) { jit_pack_t *jp = xcalloc(sizeof(struct _jit_pack)); jp->funcs = chash_new(256); if ((jp->zstd = ZSTD_createDCtx()) == NULL) fatal_trace("ZSTD_createDCtx failed"); return jp; } static void pack_func_free(const void *key, void *value) { pack_func_t *pf = value; free(pf); } void jit_pack_free(jit_pack_t *jp) { if (jp->mmap != NULL) unmap_file((void *)jp->mmap, jp->map_size); ZSTD_freeDCtx(jp->zstd); chash_iter(jp->funcs, pack_func_free); chash_free(jp->funcs); free(jp); } void jit_pack_put(jit_pack_t *jp, ident_t name, const uint8_t *cpool, const char *strtab, const uint8_t *buf) { assert(chash_get(jp->funcs, name) == NULL); pack_func_t *pf = xcalloc(sizeof(pack_func_t)); pf->buf = buf; pf->cpool = cpool; pf->strtab = strtab; chash_put(jp->funcs, name, pf); } static uint64_t unpack_uint(pack_func_t *pf) { return decode_number(&pf->rptr); } static int64_t unpack_int(pack_func_t *pf) { uint64_t zz = unpack_uint(pf); return (zz >> 1) ^ -(zz & 1); } static inline uint16_t unpack_u16(pack_func_t *pf) { uint16_t value = 0; value |= *pf->rptr++; value |= *pf->rptr++ << 8; return value; } static inline jit_reg_t unpack_reg(pack_func_t *pf) { const uint64_t enc = unpack_uint(pf); assert(enc < JIT_REG_INVALID - 1); return enc == 0 ? JIT_REG_INVALID : enc - 1; } static inline double unpack_double(pack_func_t *pf) { jit_scalar_t value = { .integer = unpack_uint(pf) }; return value.real; } static const char *unpack_str(pack_func_t *pf) { const unsigned off = unpack_uint(pf); return off == 0 ? NULL : pf->strtab + off; } static loc_t unpack_loc(pack_func_t *pf) { loc_t loc = pf->last_loc; const char *file = unpack_str(pf); if (file != NULL) { loc.file_ref = loc_file_ref(file, NULL); loc.first_line = unpack_uint(pf); loc.first_column = unpack_uint(pf); loc.column_delta = 0; loc.line_delta = 0; } else { loc.first_line += unpack_int(pf); loc.first_column += unpack_int(pf); } return (pf->last_loc = loc); } static jit_handle_t unpack_handle(pack_func_t *pf, jit_t *j) { const char *str = unpack_str(pf); if (str == NULL) return JIT_HANDLE_INVALID; else return jit_lazy_compile(j, ident_new(str)); } static object_t *unpack_locus(pack_func_t *pf) { ident_t module = ident_new(unpack_str(pf)); ptrdiff_t disp = unpack_uint(pf); return object_from_locus(module, disp, lib_load_handler); } static jit_value_t unpack_value(pack_func_t *pf, jit_t *j) { jit_value_t value; value.kind = *pf->rptr++; switch (value.kind) { case JIT_VALUE_INVALID: break; case JIT_VALUE_REG: value.reg = unpack_reg(pf); break; case JIT_VALUE_INT64: value.int64 = unpack_int(pf); break; case JIT_VALUE_DOUBLE: value.dval = unpack_double(pf); break; case JIT_ADDR_REG: value.reg = unpack_reg(pf); value.disp = unpack_uint(pf); break; case JIT_ADDR_CPOOL: value.int64 = unpack_uint(pf); break; case JIT_ADDR_ABS: case JIT_ADDR_COVER: value.int64 = unpack_uint(pf); break; case JIT_VALUE_LABEL: value.label = unpack_uint(pf); break; case JIT_VALUE_HANDLE: value.handle = unpack_handle(pf, j); break; case JIT_VALUE_EXIT: value.exit = *pf->rptr++; break; case JIT_VALUE_LOC: value.loc = unpack_loc(pf); break; case JIT_VALUE_LOCUS: value.locus = unpack_locus(pf); break; default: fatal_trace("cannot handle value kind %d in unpack_value", value.kind); } return value; } bool jit_pack_fill(jit_pack_t *jp, jit_t *j, jit_func_t *f) { pack_func_t *pf = chash_get(jp->funcs, f->name); if (pf == NULL) return false; assert(load_acquire(&f->state) == JIT_FUNC_COMPILING); size_t ubufsz = 0; int shift = 0, start = 0; uint8_t byte; do { byte = pf->buf[start++]; ubufsz |= (uint64_t)(byte & 0x7f) << shift; shift += 7; } while (byte & 0x80); uint8_t *ubuf LOCAL = xmalloc(ubufsz); size_t framesz = ZSTD_findFrameCompressedSize(pf->buf + start, SIZE_MAX); if (ZSTD_isError(framesz)) fatal("cannot get ZSTD compressed frame size: %s: %s", istr(f->name), ZSTD_getErrorName(framesz)); { SCOPED_LOCK(jp->zlock); size_t dsize = ZSTD_decompressDCtx(jp->zstd, ubuf, ubufsz, pf->buf + start, framesz); if (ZSTD_isError(dsize)) fatal("ZSTD decompress failed: %s: %s", istr(f->name), ZSTD_getErrorName(dsize)); assert(dsize == ubufsz); } pf->rptr = ubuf; pf->last_loc = LOC_INVALID; f->nirs = unpack_uint(pf); f->nregs = unpack_uint(pf); f->nvars = unpack_uint(pf); f->cpoolsz = unpack_uint(pf); f->spec.bits = unpack_uint(pf); f->framesz = unpack_uint(pf); f->cpool = (unsigned char *)pf->cpool; f->irbuf = xmalloc_array(f->nirs, sizeof(jit_ir_t)); if (f->nvars > 0) { f->linktab = xmalloc_array(f->nvars, sizeof(link_tab_t)); for (int i = 0; i < f->nvars; i++) { f->linktab[i].name = ident_new(unpack_str(pf)); f->linktab[i].offset = unpack_uint(pf); } } ident_t module = ident_new(unpack_str(pf)); ptrdiff_t offset = unpack_uint(pf); f->object = object_from_locus(module, offset, lib_load_handler); for (int i = 0; i < f->nirs; i++) { jit_ir_t *ir = &(f->irbuf[i]); const uint16_t enc = unpack_u16(pf); ir->op = enc >> 8; ir->size = (enc >> 5) & 7; ir->target = (enc >> 4) & 1; ir->cc = enc & 0xf; ir->result = unpack_reg(pf); ir->arg1 = unpack_value(pf, j); ir->arg2 = unpack_value(pf, j); } pf->rptr = NULL; store_release(&(f->state), JIT_FUNC_READY); return true; } //////////////////////////////////////////////////////////////////////////////// // Disk storage typedef struct { char magic[4]; uint32_t strtab; } pack_header_t; #define PACK_MAGIC "JIT1" static void write_fully(const void *buf, size_t size, FILE *f) { if (fwrite(buf, size, 1, f) != 1) fatal_errno("fwrite"); } void jit_write_pack(jit_t *j, const ident_t *units, size_t count, FILE *f) { pack_writer_t *pw = pack_writer_new(); pack_header_t header = {}; write_fully(&header, sizeof(header), f); for (size_t i = 0; i < count; i++) { jit_handle_t handle = jit_compile(j, units[i]); uint8_t bytes[10]; const uint32_t name = pack_writer_get_string(pw, istr(units[i])); const int name_nbytes = encode_number(name, bytes); write_fully(bytes, name_nbytes, f); uint8_t *buf; size_t size; pack_writer_emit(pw, j, handle, &buf, &size); const int size_nbytes = encode_number(size, bytes); write_fully(bytes, size_nbytes, f); jit_func_t *func = jit_get_func(j, handle); const int cpool_nbytes = encode_number(func->cpoolsz, bytes); write_fully(bytes, cpool_nbytes, f); write_fully(buf, size, f); if (func->cpoolsz > 0) write_fully(func->cpool, func->cpoolsz, f); } memcpy(header.magic, PACK_MAGIC, sizeof(header.magic)); header.strtab = ftell(f); const char *tab; size_t size; pack_writer_string_table(pw, &tab, &size); write_fully(tab, size, f); rewind(f); write_fully(&header, sizeof(header), f); pack_writer_free(pw); } jit_pack_t *jit_read_pack(FILE *f) { jit_pack_t *jp = jit_pack_new(); file_info_t info; if (!get_handle_info(fileno(f), &info)) fatal("cannot get info for pack file"); jp->mmap = map_file(fileno(f), info.size); jp->map_size = info.size; const pack_header_t *header = jp->mmap; if (memcmp(header->magic, PACK_MAGIC, sizeof(header->magic)) != 0) fatal("bad JIT pack magic"); const char *strtab = jp->mmap + header->strtab; const uint8_t *rptr = jp->mmap + sizeof(pack_header_t); while (rptr < (uint8_t *)jp->mmap + header->strtab) { const uint32_t str = decode_number(&rptr); const uint32_t size = decode_number(&rptr); const uint32_t cpool = decode_number(&rptr); ident_t ident = ident_new(strtab + str); jit_pack_put(jp, ident, rptr + size, strtab, rptr); rptr += size + cpool; } return jp; } nvc-r1.17.1/src/jit/jit-priv.h000066400000000000000000000260241504111170000160350ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_PRIV_H #define _JIT_PRIV_H #include "util.h" #include "jit/jit.h" #include "jit/jit-ffi.h" #include "mask.h" #include "rt/mspace.h" #include "thread.h" #include #include typedef enum { J_SEND, J_RECV, J_ADD, J_RET, J_TRAP, J_ULOAD, J_STORE, J_JUMP, J_CMP, J_CSET, J_SUB, J_MOV, J_FADD, J_MUL, J_FMUL, J_CALL, J_NEG, J_LOAD, J_CSEL, J_LEA, J_NOT, J_DIV, J_FDIV, J_SCVTF, J_FNEG, J_FCVTNS, J_FCMP, J_AND, J_OR, J_XOR, J_FSUB, J_REM, J_DEBUG, J_NOP, J_ASR, J_SHL, J_CLAMP, J_CCMP, J_FCCMP, __MACRO_BASE = 0x80, MACRO_COPY = __MACRO_BASE, MACRO_GALLOC, MACRO_EXIT, MACRO_FEXP, MACRO_EXP, MACRO_BZERO, MACRO_GETPRIV, MACRO_PUTPRIV, MACRO_LALLOC, MACRO_SALLOC, MACRO_CASE, MACRO_TRIM, MACRO_MOVE, MACRO_MEMSET, MACRO_REEXEC, MACRO_SADD, MACRO_PACK, MACRO_UNPACK, } jit_op_t; typedef enum { JIT_SZ_8 = 0, JIT_SZ_16 = 1, JIT_SZ_32 = 2, JIT_SZ_64 = 3, JIT_SZ_PTR = JIT_SZ_64, JIT_SZ_UNSPEC = 7 } jit_size_t; typedef enum { JIT_CC_NONE, JIT_CC_T, JIT_CC_F, JIT_CC_EQ, JIT_CC_NE, JIT_CC_LT, JIT_CC_GE, JIT_CC_GT, JIT_CC_LE, JIT_CC_O, JIT_CC_NO, JIT_CC_C, JIT_CC_NC, } jit_cc_t; typedef enum { JIT_EXIT_INDEX_FAIL, JIT_EXIT_OVERFLOW, JIT_EXIT_NULL_DEREF, JIT_EXIT_LENGTH_FAIL, JIT_EXIT_UNREACHABLE, JIT_EXIT_DIV_ZERO, JIT_EXIT_EXPONENT_FAIL, JIT_EXIT_REPORT, JIT_EXIT_ASSERT_FAIL, JIT_EXIT_RANGE_FAIL, JIT_EXIT_FUNC_WAIT, JIT_EXIT_INIT_SIGNAL, JIT_EXIT_DRIVE_SIGNAL, JIT_EXIT_SCHED_WAVEFORM, JIT_EXIT_SCHED_PROCESS, JIT_EXIT_TEST_EVENT, JIT_EXIT_TEST_ACTIVE, JIT_EXIT_SCHED_EVENT, JIT_EXIT_FILE_OPEN, JIT_EXIT_FILE_READ, JIT_EXIT_FILE_WRITE, JIT_EXIT_DEBUG_OUT, JIT_EXIT_ALIAS_SIGNAL, JIT_EXIT_MAP_SIGNAL, JIT_EXIT_MAP_CONST, JIT_EXIT_RESOLVE_SIGNAL, JIT_EXIT_LAST_EVENT, JIT_EXIT_LAST_ACTIVE, JIT_EXIT_DISCONNECT, JIT_EXIT_FORCE, JIT_EXIT_RELEASE, JIT_EXIT_PUSH_SCOPE, JIT_EXIT_POP_SCOPE, JIT_EXIT_IMPLICIT_SIGNAL, JIT_EXIT_DRIVING, JIT_EXIT_DRIVING_VALUE, JIT_EXIT_COVER_TOGGLE, JIT_EXIT_COVER_STATE, JIT_EXIT_PROCESS_INIT, JIT_EXIT_CLEAR_EVENT, JIT_EXIT_ENTER_STATE, JIT_EXIT_REFLECT_VALUE, JIT_EXIT_REFLECT_SUBTYPE, JIT_EXIT_FUNCTION_TRIGGER, JIT_EXIT_ADD_TRIGGER, JIT_EXIT_TRANSFER_SIGNAL, JIT_EXIT_PORT_CONVERSION, JIT_EXIT_CONVERT_IN, JIT_EXIT_CONVERT_OUT, JIT_EXIT_BIND_FOREIGN, JIT_EXIT_OR_TRIGGER, JIT_EXIT_CMP_TRIGGER, JIT_EXIT_INSTANCE_NAME, JIT_EXIT_DEPOSIT_SIGNAL, JIT_EXIT_MAP_IMPLICIT, JIT_EXIT_BIND_EXTERNAL, JIT_EXIT_SYSCALL, JIT_EXIT_PUT_CONVERSION, JIT_EXIT_DIR_FAIL, } jit_exit_t; typedef uint16_t jit_reg_t; #define JIT_REG_INVALID UINT16_MAX typedef enum { JIT_VALUE_INVALID, JIT_VALUE_REG, JIT_VALUE_INT64, JIT_VALUE_DOUBLE, JIT_ADDR_REG, JIT_ADDR_ABS, JIT_ADDR_CPOOL, JIT_ADDR_COVER, JIT_VALUE_LABEL, JIT_VALUE_HANDLE, JIT_VALUE_EXIT, JIT_VALUE_LOC, JIT_VALUE_VPOS, JIT_VALUE_LOCUS, } jit_value_kind_t; typedef uint32_t jit_label_t; #define JIT_LABEL_INVALID UINT32_MAX typedef struct { uint32_t block; uint32_t op; } jit_vpos_t; typedef struct { jit_value_kind_t kind : 8; int32_t disp; union { jit_reg_t reg; int64_t int64; double dval; jit_label_t label; jit_handle_t handle; jit_exit_t exit; loc_t loc; jit_vpos_t vpos; object_t *locus; }; } jit_value_t; STATIC_ASSERT(sizeof(jit_value_t) == 16); typedef struct { jit_op_t op : 8; jit_size_t size : 3; unsigned target : 1; jit_cc_t cc : 4; jit_reg_t result; jit_value_t arg1; jit_value_t arg2; } jit_ir_t; STATIC_ASSERT(sizeof(jit_ir_t) <= 40); typedef struct _jit_tier jit_tier_t; typedef struct _jit_func jit_func_t; typedef struct _jit_block jit_block_t; typedef struct _jit_anchor jit_anchor_t; typedef void (*jit_entry_fn_t)(jit_func_t *, jit_anchor_t *, jit_scalar_t *, tlab_t *); typedef struct { unsigned count; unsigned max; union { unsigned edges[4]; unsigned *external; } u; } jit_edge_list_t; typedef struct _jit_block { unsigned first; unsigned last; unsigned aborts : 1; unsigned returns : 1; jit_edge_list_t in; jit_edge_list_t out; bit_mask_t livein; bit_mask_t varkill; bit_mask_t liveout; } jit_block_t; typedef struct { unsigned nblocks; jit_block_t blocks[0]; } jit_cfg_t; typedef enum { JIT_FUNC_PLACEHOLDER, JIT_FUNC_COMPILING, JIT_FUNC_READY, JIT_FUNC_ERROR, } func_state_t; typedef enum { RELOC_NULL, RELOC_HANDLE, RELOC_FUNC, RELOC_PRIVDATA, RELOC_COVER, RELOC_PROCESSED, } reloc_kind_t; typedef struct { ident_t name; unsigned offset; } link_tab_t; typedef struct _jit_func { jit_entry_fn_t entry; // Must be first func_state_t state; jit_t *jit; ident_t name; link_tab_t *linktab; mptr_t privdata; jit_ir_t *irbuf; unsigned char *cpool; unsigned framesz; unsigned nirs; unsigned nregs; unsigned nvars; unsigned cpoolsz; bool owns_cpool; jit_handle_t handle; unsigned hotness; jit_tier_t *next_tier; ffi_spec_t spec; object_t *object; } jit_func_t; // The code generator knows the layout of this struct typedef struct _jit_anchor { jit_anchor_t *caller; jit_func_t *func; uint32_t irpos; uint32_t watermark; } jit_anchor_t; typedef enum { JIT_IDLE, JIT_RUNNING, JIT_COMPILING, } jit_state_t; #if defined HAVE___BUILTIN_SETJMP && !defined __clang__ typedef void *jit_jmpbuf_t[5]; #define jit_setjmp(buf) __builtin_setjmp((buf)) #define jit_longjmp(buf, arg) __builtin_longjmp((buf), (arg)) #else typedef sigjmp_buf jit_jmpbuf_t; #define jit_setjmp(buf) sigsetjmp((buf), 0) #define jit_longjmp(buf, arg) siglongjmp((buf), arg) #endif typedef struct { jit_t *jit; jit_state_t state; jit_jmpbuf_t abort_env; volatile sig_atomic_t jmp_buf_valid; jit_anchor_t *anchor; } jit_thread_local_t; typedef struct _code_cache code_cache_t; typedef struct _code_span code_span_t; typedef struct _patch_list patch_list_t; typedef struct { code_span_t *span; jit_func_t *func; uint8_t *wptr; ihash_t *labels; patch_list_t *patches; uint8_t *veneers; bool overflow; } code_blob_t; typedef struct _pack_writer pack_writer_t; #define JIT_MAX_ARGS 64 typedef struct _jit_interp jit_interp_t; void jit_irgen(jit_func_t *f, mir_unit_t *mu); void jit_dump(jit_func_t *f); void jit_dump_with_mark(jit_func_t *f, jit_label_t label); void jit_dump_with_cfg(jit_func_t *f, jit_cfg_t *cfg); void jit_dump_interleaved(jit_func_t *f, mir_unit_t *mu); const char *jit_op_name(jit_op_t op); const char *jit_cc_name(jit_cc_t cc); const char *jit_exit_name(jit_exit_t exit); void jit_interp(jit_func_t *f, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab); jit_func_t *jit_get_func(jit_t *j, jit_handle_t handle); void jit_hexdump(const unsigned char *data, size_t sz, int blocksz, const void *highlight, const char *prefix); void **jit_get_privdata_ptr(jit_t *j, jit_func_t *f); void jit_tier_up(jit_func_t *f); jit_thread_local_t *jit_thread_local(void); void jit_fill_irbuf(jit_func_t *f); int32_t *jit_get_cover_ptr(jit_t *j, jit_value_t addr); jit_entry_fn_t jit_bind_intrinsic(ident_t name); jit_thread_local_t *jit_attach_thread(jit_anchor_t *anchor); jit_cfg_t *jit_get_cfg(jit_func_t *f); void jit_free_cfg(jit_cfg_t *cfg); jit_block_t *jit_block_for(jit_cfg_t *cfg, int pos); int jit_get_edge(jit_edge_list_t *list, int nth); bool jit_will_abort(jit_ir_t *ir); bool jit_writes_flags(jit_ir_t *ir); bool jit_reads_flags(jit_ir_t *ir); void jit_do_lvn(jit_func_t *f); void jit_do_cprop(jit_func_t *f); void jit_do_dce(jit_func_t *f); void jit_delete_nops(jit_func_t *f); void jit_do_mem2reg(jit_func_t *f); typedef unsigned phys_slot_t; #define INT_BASE 0 #define FLOAT_BASE 32 #define STACK_BASE 100 int jit_do_lscan(jit_func_t *f, phys_slot_t *slots, uint64_t badmask); code_cache_t *code_cache_new(void); void code_cache_free(code_cache_t *code); typedef void (*code_patch_fn_t)(code_blob_t *, jit_label_t, uint8_t *, const uint8_t *); code_blob_t *code_blob_new(code_cache_t *code, ident_t name, size_t hint); void code_blob_emit(code_blob_t *blob, const uint8_t *bytes, size_t len); void code_blob_align(code_blob_t *blob, unsigned align); void code_blob_finalise(code_blob_t *blob, jit_entry_fn_t *entry); void code_blob_mark(code_blob_t *blob, jit_label_t label); void code_blob_patch(code_blob_t *blob, jit_label_t label, code_patch_fn_t fn); void code_load_object(code_blob_t *blob, const void *data, size_t size); #ifdef DEBUG __attribute__((format(printf, 2, 3))) void code_blob_printf(code_blob_t *blob, const char *fmt, ...); void code_blob_print_ir(code_blob_t *blob, jit_ir_t *ir); #else #define code_blob_printf(blob, fmt, ...) #define code_blob_print_ir(blob, ir) #endif bool jit_pack_fill(jit_pack_t *jp, jit_t *j, jit_func_t *f); void jit_pack_put(jit_pack_t *jp, ident_t name, const uint8_t *cpool, const char *strtab, const uint8_t *buf); pack_writer_t *pack_writer_new(void); void pack_writer_emit(pack_writer_t *pw, jit_t *j, jit_handle_t handle, uint8_t **buf, size_t *size); unsigned pack_writer_get_string(pack_writer_t *pw, const char *str); void pack_writer_string_table(pack_writer_t *pw, const char **tab, size_t *size); void pack_writer_free(pack_writer_t *pw); void jit_bind_foreign(jit_func_t *f, const uint8_t *spec, size_t length, tree_t where); void jit_do_syscall(vlog_node_t where, jit_anchor_t *caller, jit_scalar_t *args, tlab_t *tlab); DLLEXPORT void __nvc_do_exit(jit_exit_t which, jit_anchor_t *anchor, jit_scalar_t *args, tlab_t *tlab); DLLEXPORT void *__nvc_mspace_alloc(uintptr_t size, jit_anchor_t *anchor); DLLEXPORT void _debug_out(intptr_t val, int32_t reg); #endif // _JIT_PRIV_H nvc-r1.17.1/src/jit/jit-x86.c000066400000000000000000002102421504111170000154720ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "ident.h" #include "option.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "rt/rt.h" #include #include #include #include #include #include typedef enum { EXIT_STUB, CALL_STUB, ALLOC_STUB, FFI_STUB, DEBUG_STUB, TLAB_STUB, FEXP_STUB, ROUND_STUB, NUM_STUBS } jit_x86_stub_t; typedef struct { jit_t *jit; code_cache_t *code; jit_entry_fn_t stubs[NUM_STUBS]; } jit_x86_state_t; // Conservative guess at the number of bytes emitted per IR #define BYTES_PER_IR 16 #define FRAME_FIXED_SIZE 80 // Size of fixed part of call frame #define ANCHOR_OFFSET -24 // Offset of frame anchor from RBP //////////////////////////////////////////////////////////////////////////////// // X86 assembler #define __(...) do { \ const uint8_t __b[] = { __VA_ARGS__ }; \ code_blob_emit(blob, __b, ARRAY_LEN(__b)); \ } while (0) typedef enum { X86_REG, X86_IMM, X86_ADDR, X86_PATCH, X86_XMM, X86_ADDR2, } x86_kind_t; typedef int8_t x86_reg_t; typedef struct { x86_kind_t kind; union { x86_reg_t reg; int64_t imm; struct { x86_reg_t reg; int32_t off; } addr; struct { x86_reg_t reg1; x86_reg_t reg2; int32_t off; } addr2; }; } x86_operand_t; STATIC_ASSERT(sizeof(x86_operand_t) == 16); #define REG(x) ((x86_operand_t){ X86_REG, { .reg = (x) }}) #define XMM(x) ((x86_operand_t){ X86_XMM, { .reg = (x) }}) #define IMM(x) ((x86_operand_t){ X86_IMM, { .imm = (x) }}) #define PTR(x) ((x86_operand_t){ X86_IMM, { .imm = (uintptr_t)(x) }}) #define ADDR(r, o) ((x86_operand_t){ X86_ADDR, { .addr = { (r).reg, (o) }}}) #define ADDR2(r1, r2, o) \ ((x86_operand_t){ X86_ADDR2, { .addr2 = { (r1).reg, (r2).reg, (o) }}}) #define PATCH(n) ((x86_operand_t){ X86_PATCH, { .imm = (n) }}) #define COMBINE(a, b) (((a).kind << 4) | (b).kind) #define REG_REG ((X86_REG << 4) | X86_REG) #define MEM_REG ((X86_ADDR << 4) | X86_REG) #define MEM_IMM ((X86_ADDR << 4) | X86_IMM) #define REG_MEM ((X86_REG << 4) | X86_ADDR) #define REG_IMM ((X86_REG << 4) | X86_IMM) #define XMM_MEM ((X86_XMM << 4) | X86_ADDR) #define MEM_XMM ((X86_ADDR << 4) | X86_XMM) #define REG_XMM ((X86_REG << 4) | X86_XMM) #define XMM_REG ((X86_XMM << 4) | X86_REG) #define XMM_XMM ((X86_XMM << 4) | X86_XMM) #define REG_MEM2 ((X86_REG << 4) | X86_ADDR2) static const x86_operand_t __EAX = REG(0); static const x86_operand_t __ECX = REG(1); static const x86_operand_t __EDX = REG(2); static const x86_operand_t __EBX = REG(3); static const x86_operand_t __ESP = REG(4); static const x86_operand_t __EBP = REG(5); static const x86_operand_t __ESI = REG(6); static const x86_operand_t __EDI = REG(7); static const x86_operand_t __R8 = REG(16); static const x86_operand_t __R9 = REG(17); static const x86_operand_t __R10 = REG(18); static const x86_operand_t __R11 = REG(19); #if 0 static const x86_operand_t __R12 = REG(20); static const x86_operand_t __R13 = REG(21); static const x86_operand_t __R14 = REG(22); static const x86_operand_t __R15 = REG(23); #endif static const x86_operand_t __XMM0 = XMM(0); static const x86_operand_t __XMM1 = XMM(1); #define ARGS_REG __R8 #define TLAB_REG __R9 #define FLAGS_REG __EBX #ifdef __MINGW32__ #define CARG0_REG __ECX #define CARG1_REG __EDX #define CARG2_REG __R8 #define CARG3_REG __R9 #else #define CARG0_REG __EDI #define CARG1_REG __ESI #define CARG2_REG __EDX #define CARG3_REG __ECX #endif typedef enum { __BYTE = 1, __WORD = 2, __DWORD = 4, __QWORD = 8 } x86_size_t; typedef enum { X86_CMP_O = 0x00, X86_CMP_C = 0x02, X86_CMP_EQ = 0x04, X86_CMP_NE = 0x05, X86_CMP_BE = 0x06, X86_CMP_LE = 0x0e, X86_CMP_LT = 0x0c, X86_CMP_GE = 0x0d, X86_CMP_GT = 0x0f, } x86_cmp_t; #define NOP() __(0x90) #define RET() __(0xc3) #define LEAVE() __(0xc9) #define INT3() __(0xcc) #define CQO() __(0x48, 0x99) #define CDQ() __(0x99) #define CWD() __(0x66, 0x99) #define CWDE() __(0x98) #define CDQE() __(0x48, 0x98) #define STD() __(0xfd) #define CLD() __(0xfc) #define PUSH(src) asm_push(blob, (src)) #define POP(dst) asm_pop(blob, (dst)) #define ADD(dst, src, size) asm_add(blob, (dst), (src), (size)) #define SUB(dst, src, size) asm_sub(blob, (dst), (src), (size)) #define MUL(src, size) asm_mul(blob, (src), (size)) #define IMUL(dst, src, size) asm_imul(blob, (dst), (src), (size)) #define IDIV(src, size) asm_idiv(blob, (src), (size)) #define AND(dst, src, size) asm_and(blob, (dst), (src), (size)) #define OR(dst, src, size) asm_or(blob, (dst), (src), (size)) #define SHL(src, size) asm_shl(blob, (src), (size)) #define SAR(src, count, size) asm_sar(blob, (src), (count), (size)) #define XOR(dst, src, size) asm_xor(blob, (dst), (src), (size)) #define NEG(dst, size) asm_neg(blob, (dst), (size)) #define MOV(dst, src, size) asm_mov(blob, (dst), (src), (size)) #define MOVSX(dst, src, dsize, ssize) \ asm_movsx(blob, (dst), (src), (dsize), (ssize)) #define MOVZX(dst, src, dsize, ssize) \ asm_movzx(blob, (dst), (src), (dsize), (ssize)) #define CMOVZ(dst, src, size) \ asm_cmovcc(blob, (dst), (src), (size), X86_CMP_EQ) #define CMOVNZ(dst, src, size) \ asm_cmovcc(blob, (dst), (src), (size), X86_CMP_NE) #define CMOVGT(dst, src, size) \ asm_cmovcc(blob, (dst), (src), (size), X86_CMP_GT) #define CMOVLT(dst, src, size) \ asm_cmovcc(blob, (dst), (src), (size), X86_CMP_LT) #define LEA(dst, addr) asm_lea(blob, (dst), (addr)) #define SETO(dst) asm_setcc(blob, (dst), X86_CMP_O) #define SETC(dst) asm_setcc(blob, (dst), X86_CMP_C) #define SETZ(dst) asm_setcc(blob, (dst), X86_CMP_EQ) #define SETNZ(dst) asm_setcc(blob, (dst), X86_CMP_NE) #define SETLT(dst) asm_setcc(blob, (dst), X86_CMP_LT) #define SETGT(dst) asm_setcc(blob, (dst), X86_CMP_GT) #define SETGE(dst) asm_setcc(blob, (dst), X86_CMP_GE) #define SETLE(dst) asm_setcc(blob, (dst), X86_CMP_LE) #define SETA(dst) asm_setcc(blob, (dst), 0x7) #define SETAE(dst) asm_setcc(blob, (dst), 0x3) #define SETB(dst) asm_setcc(blob, (dst), 0x2) #define SETBE(dst) asm_setcc(blob, (dst), 0x6) #define TEST(src1, src2, size) asm_test(blob, (src1), (src2), (size)) #define CMP(src1, src2, size) asm_cmp(blob, (src1), (src2), (size)) #define CALL(addr) asm_call(blob, (addr)) #define JMP(addr) asm_jmp(blob, (addr)) #define JZ(addr) asm_jcc(blob, (addr), X86_CMP_EQ) #define JNZ(addr) asm_jcc(blob, (addr), X86_CMP_NE) #define JLT(addr) asm_jcc(blob, (addr), X86_CMP_LT) #define JB(addr) asm_jcc(blob, (addr), X86_CMP_C) #define JBE(addr) asm_jcc(blob, (addr), X86_CMP_BE) #define MULSD(dst, src) asm_mulsd(blob, (dst), (src)) #define DIVSD(dst, src) asm_divsd(blob, (dst), (src)) #define ADDSD(dst, src) asm_addsd(blob, (dst), (src)) #define SUBSD(dst, src) asm_subsd(blob, (dst), (src)) #define PXOR(dst, src) asm_pxor(blob, (dst), (src)) #define UCOMISD(src1, src2) asm_ucomisd(blob, (src1), (src2)) #define CVTSD2SI(dst, src, size) asm_cvtsd2si(blob, (dst), (src), (size)) #define CVTSI2SD(dst, src, size) asm_cvtsi2sd(blob, (dst), (src), (size)) #define ROUNDSD(dst, src, mode) asm_roundsd(blob, (dst), (src), (mode)) #define REPSTOS(size) asm_repstos(blob, (size)) #define REPMOVS(size) asm_repmovs(blob, (size)) #define is_imm8(x) ((x) >= INT8_MIN && (x) <= INT8_MAX) #define is_imm16(x) ((x) >= INT16_MIN && (x) <= INT16_MAX) #define is_imm32(x) ((x) >= INT32_MIN && (x) <= INT32_MAX) typedef struct { uint8_t len; uint8_t bytes[15]; } x86_insn_t; __attribute__((always_inline)) static inline void x86_prefix(x86_insn_t *insn, uint8_t b0) { insn->bytes[insn->len++] = b0; } __attribute__((always_inline)) static inline void x86_opcode(x86_insn_t *insn, uint8_t b0) { insn->bytes[insn->len++] = b0; } __attribute__((always_inline)) static inline void x86_opcode_2(x86_insn_t *insn, uint8_t b0, uint8_t b1) { insn->bytes[insn->len++] = b0; insn->bytes[insn->len++] = b1; } __attribute__((always_inline)) static inline void x86_opcode_3(x86_insn_t *insn, uint8_t b0, uint8_t b1, uint8_t b2) { insn->bytes[insn->len++] = b0; insn->bytes[insn->len++] = b1; insn->bytes[insn->len++] = b2; } __attribute__((always_inline)) static inline void x86_imm32(x86_insn_t *insn, int64_t imm) { assert(is_imm32(imm)); insn->bytes[insn->len++] = imm & 0xff; insn->bytes[insn->len++] = (imm >> 8) & 0xff; insn->bytes[insn->len++] = (imm >> 16) & 0xff; insn->bytes[insn->len++] = (imm >> 24) & 0xff; } static inline void x86_imm64(x86_insn_t *insn, int64_t imm) { insn->bytes[insn->len++] = imm & 0xff; insn->bytes[insn->len++] = (imm >> 8) & 0xff; insn->bytes[insn->len++] = (imm >> 16) & 0xff; insn->bytes[insn->len++] = (imm >> 24) & 0xff; insn->bytes[insn->len++] = (imm >> 32) & 0xff; insn->bytes[insn->len++] = (imm >> 40) & 0xff; insn->bytes[insn->len++] = (imm >> 48) & 0xff; insn->bytes[insn->len++] = (imm >> 56) & 0xff; } __attribute__((always_inline)) static inline void x86_imm8(x86_insn_t *insn, int64_t imm) { assert(is_imm8(imm)); insn->bytes[insn->len++] = imm & 0xff; } static void x86_rex(x86_insn_t *insn, x86_size_t size, x86_reg_t modrm_reg, x86_reg_t modrm_rm, x86_reg_t modrm_sib) { const bool want_prefix = // Quadword operation size > __DWORD || // Uses R8 - R15 (modrm_reg & 0x10) || (modrm_sib & 0x10) || (modrm_rm & 0x10) || // Byte operation on SPL, BPL, SIL, DIL (size == __BYTE && ((modrm_rm & 7) >= 4 || ((modrm_reg & 7) >= 4))); if (want_prefix) { const int xsz = size > __DWORD; const int xr = !!(modrm_reg & 0x10); const int xsib = !!(modrm_sib & 0x10); const int xrm = !!(modrm_rm & 0x10); x86_prefix(insn, 0x40 | (xsz << 3) | (xr << 2) | (xsib << 1) | xrm); } } static inline void x86_modrm(x86_insn_t *insn, int m, int r, int rm) { insn->bytes[insn->len++] = ((m & 3) << 6) | ((r & 7) << 3) | (rm & 7); } static inline void x86_sib(x86_insn_t *insn, int s, int i, int b) { insn->bytes[insn->len++] = ((s & 3) << 6) | ((i & 7) << 3) | (b & 7); } static inline void x86_override(x86_insn_t *insn, bool cond) { if (cond) x86_prefix(insn, 0x66); } static inline void x86_emit(code_blob_t *blob, const x86_insn_t *insn) { assert(insn->len <= sizeof(insn->bytes)); code_blob_emit(blob, insn->bytes, insn->len); } static void asm_xor(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_REG); x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode(&insn, 0x33); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_neg(code_blob_t *blob, x86_operand_t dst, x86_size_t size) { x86_insn_t insn = {}; assert(dst.kind == X86_REG); x86_rex(&insn, size, 0, dst.reg, 0); x86_opcode(&insn, 0xf7); x86_modrm(&insn, 3, 3, dst.reg); x86_emit(blob, &insn); } static void asm_lea(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; switch (COMBINE(dst, src)) { case REG_MEM: x86_rex(&insn, __QWORD, dst.reg, src.addr.reg, 0); x86_opcode(&insn, 0x8d); if (is_imm8(src.addr.off)) { x86_modrm(&insn, 1, dst.reg, src.addr.reg); x86_imm8(&insn, src.addr.off); } else { x86_modrm(&insn, 2, dst.reg, src.addr.reg); x86_imm32(&insn, src.addr.off); } break; case REG_MEM2: x86_rex(&insn, __QWORD, dst.reg, src.addr2.reg1, src.addr2.reg2); x86_opcode(&insn, 0x8d); if (src.addr2.off == 0) { x86_modrm(&insn, 0, dst.reg, 4); x86_sib(&insn, 0, src.addr2.reg2, src.addr2.reg1); } else if (is_imm8(src.addr2.off)) { x86_modrm(&insn, 1, dst.reg, 4); x86_sib(&insn, 0, src.addr2.reg2, src.addr2.reg1); x86_imm8(&insn, src.addr2.off); } else fatal_trace("immediate too big for LEA instruction"); break; default: fatal_trace("unhandled operand combination in asm_lea"); } x86_emit(blob, &insn); } static void asm_mov(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; switch (COMBINE(dst, src)) { case REG_REG: if (dst.reg != src.reg) { x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode(&insn, 0x8b); x86_modrm(&insn, 3, dst.reg, src.reg); } break; case MEM_REG: x86_rex(&insn, size, src.reg, dst.addr.reg, 0); x86_override(&insn, size == __WORD); x86_opcode(&insn, size == __BYTE ? 0x88 : 0x89); if (is_imm8(dst.addr.off)) { x86_modrm(&insn, 1, src.reg, dst.addr.reg); x86_imm8(&insn, dst.addr.off); } else { x86_modrm(&insn, 2, src.reg, dst.addr.reg); x86_imm32(&insn, dst.addr.off); } break; case REG_MEM: x86_rex(&insn, size, dst.reg, src.addr.reg, 0); x86_override(&insn, size == __WORD); x86_opcode(&insn, size == __BYTE ? 0x8a : 0x8b); if (is_imm8(src.addr.off)) { x86_modrm(&insn, 1, dst.reg, src.addr.reg); x86_imm8(&insn, src.addr.off); } else { x86_modrm(&insn, 2, dst.reg, src.addr.reg); x86_imm32(&insn, src.addr.off); } break; case XMM_MEM: assert(size == __QWORD); x86_override(&insn, true); x86_rex(&insn, size, dst.reg, src.addr.reg, 0); x86_opcode_2(&insn, 0x0f, 0x6e); if (is_imm8(src.addr.off)) { x86_modrm(&insn, 1, dst.reg, src.addr.reg); x86_imm8(&insn, src.addr.off); } else { x86_modrm(&insn, 2, dst.reg, src.addr.reg); x86_imm32(&insn, src.addr.off); } break; case MEM_XMM: assert(size == __QWORD); x86_override(&insn, true); x86_rex(&insn, size, src.addr.reg, dst.reg, 0); x86_opcode_2(&insn, 0x0f, 0x7e); if (is_imm8(dst.addr.off)) { x86_modrm(&insn, 1, src.reg, dst.addr.reg); x86_imm8(&insn, dst.addr.off); } else { x86_modrm(&insn, 2, src.reg, dst.addr.reg); x86_imm32(&insn, dst.addr.off); } break; case XMM_REG: assert(size == __QWORD); x86_override(&insn, true); x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode_2(&insn, 0x0f, 0x6e); x86_modrm(&insn, 3, dst.reg, src.reg); break; case REG_XMM: assert(size == __QWORD); x86_override(&insn, true); x86_rex(&insn, size, src.reg, dst.reg, 0); x86_opcode_2(&insn, 0x0f, 0x7e); x86_modrm(&insn, 3, src.reg, dst.reg); break; case REG_IMM: if (src.imm == 0) XOR(dst, dst, MIN(size, __DWORD)); else { switch (size) { case __QWORD: if (is_imm32(src.imm)) { if (src.imm > 0) { x86_rex(&insn, __DWORD, 0, dst.reg, 0); x86_opcode(&insn, 0xb8 + (dst.reg & 7)); } else { x86_rex(&insn, __QWORD, 0, dst.reg, 0); x86_opcode(&insn, 0xc7); x86_modrm(&insn, 3, 0, dst.reg); } x86_imm32(&insn, src.imm); } else { x86_rex(&insn, __QWORD, 0, dst.reg, 0); x86_opcode(&insn, 0xb8 + (dst.reg & 7)); x86_imm64(&insn, src.imm); } break; case __DWORD: x86_rex(&insn, __DWORD, 0, dst.reg, 0); x86_opcode(&insn, 0xb8 + (dst.reg & 7)); x86_imm32(&insn, src.imm); break; default: fatal_trace("unhandled immediate size %d in asm_mov", size); } } break; case MEM_IMM: switch (size) { case __QWORD: assert(is_imm32(src.imm)); x86_rex(&insn, size, 0, dst.addr.reg, 0); x86_opcode(&insn, 0xc7); if (is_imm8(dst.addr.off)) { x86_modrm(&insn, 1, 0, dst.addr.reg); x86_imm8(&insn, dst.addr.off); } else { x86_modrm(&insn, 2, 0, dst.addr.reg); x86_imm32(&insn, dst.addr.off); } x86_imm32(&insn, src.imm); break; default: fatal_trace("unhandled immediate size %d in asm_mov", size); } break; default: fatal_trace("unhandled operand combination in asm_mov"); } x86_emit(blob, &insn); } static void asm_movsx(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t dsize, x86_size_t ssize) { x86_insn_t insn = {}; switch (COMBINE(dst, src)) { case REG_REG: x86_rex(&insn, dsize, src.reg, dst.reg, 0); switch (ssize) { case __BYTE: x86_opcode_2(&insn, 0x0f, 0xbe); x86_modrm(&insn, 3, src.reg, dst.reg); break; default: fatal_trace("unhandled source size %d in asm_movsx", ssize); } break; case REG_MEM: x86_rex(&insn, dsize, src.addr.reg, dst.reg, 0); switch (ssize) { case __QWORD: x86_opcode(&insn, 0x8b); break; case __DWORD: x86_opcode(&insn, 0x63); break; case __BYTE: x86_opcode_2(&insn, 0x0f, 0xbe); break; default: fatal_trace("unhandled source size %d in asm_movsx", ssize); } if (is_imm8(src.addr.off)) { x86_modrm(&insn, 1, dst.reg, src.addr.reg); x86_imm8(&insn, src.addr.off); } else { x86_modrm(&insn, 2, dst.reg, src.addr.reg); x86_imm32(&insn, src.addr.off); } break; default: fatal_trace("unhandled operand combination in asm_mov"); } x86_emit(blob, &insn); } static void asm_movzx(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t dsize, x86_size_t ssize) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_MEM); x86_rex(&insn, ssize, dst.reg, src.addr.reg, 0); switch (ssize) { case __QWORD: case __DWORD: x86_opcode(&insn, 0x8b); break; case __WORD: x86_opcode_2(&insn, 0x0f, 0xb7); break; case __BYTE: x86_opcode_2(&insn, 0x0f, 0xb6); break; } if (is_imm8(src.addr.off)) { x86_modrm(&insn, 1, dst.reg, src.addr.reg); x86_imm8(&insn, src.addr.off); } else { x86_modrm(&insn, 2, dst.reg, src.addr.reg); x86_imm32(&insn, src.addr.off); } x86_emit(blob, &insn); } static void asm_cmovcc(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size, x86_cmp_t cmp) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_REG); x86_rex(&insn, size, dst.reg, src.reg, 0); switch (size) { case __DWORD: case __QWORD: x86_opcode_2(&insn, 0x0f, 0x40 + cmp); x86_modrm(&insn, 3, dst.reg, src.reg); break; default: fatal_trace("unhandled size %d in asm_cmovcc", size); } x86_emit(blob, &insn); } static void asm_push(code_blob_t *blob, x86_operand_t src) { x86_insn_t insn = {}; x86_rex(&insn, __DWORD, 0, src.reg, 0); // Actually pushes QWORD x86_opcode(&insn, 0x50 + (src.reg & 7)); x86_emit(blob, &insn); } static void asm_pop(code_blob_t *blob, x86_operand_t dst) { x86_insn_t insn = {}; x86_rex(&insn, __DWORD, 0, dst.reg, 0); // Actually pops QWORD x86_opcode(&insn, 0x58 + (dst.reg & 7)); x86_emit(blob, &insn); } static void asm_add(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; x86_override(&insn, size == __WORD); switch (COMBINE(dst, src)) { case REG_REG: x86_rex(&insn, size, src.reg, dst.reg, 0); x86_opcode(&insn, size == __BYTE ? 0x00 : 0x01); x86_modrm(&insn, 3, src.reg, dst.reg); break; case REG_IMM: x86_rex(&insn, size, 0, dst.reg, 0); if (size == __BYTE) { x86_opcode(&insn, 0x80); x86_modrm(&insn, 3, 0, dst.reg); x86_imm8(&insn, src.imm); } else if (is_imm8(src.imm)) { x86_opcode(&insn, 0x83); x86_modrm(&insn, 3, 0, dst.reg); x86_imm8(&insn, src.imm); } else { x86_opcode(&insn, 0x81); x86_modrm(&insn, 3, 0, dst.reg); x86_imm32(&insn, src.imm); } break; default: fatal_trace("unhandled operand combination in asm_sub"); } x86_emit(blob, &insn); } static void asm_sub(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; x86_override(&insn, size == __WORD); switch (COMBINE(dst, src)) { case REG_REG: x86_rex(&insn, size, src.reg, dst.reg, 0); x86_opcode(&insn, size == __BYTE ? 0x28 : 0x29); x86_modrm(&insn, 3, src.reg, dst.reg); break; case REG_IMM: x86_rex(&insn, size, 0, dst.reg, 0); if (size == __BYTE) { x86_opcode(&insn, 0x80); x86_modrm(&insn, 3, 5, dst.reg); x86_imm8(&insn, src.imm); } else if (is_imm8(src.imm)) { x86_opcode(&insn, 0x83); x86_modrm(&insn, 3, 5, dst.reg); x86_imm8(&insn, src.imm); } else { x86_opcode(&insn, 0x81); x86_modrm(&insn, 3, 5, dst.reg); x86_imm32(&insn, src.imm); } break; default: fatal_trace("unhandled operand combination in asm_sub"); } x86_emit(blob, &insn); } static void asm_mul(code_blob_t *blob, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(src.kind == X86_REG); // No immediate encoding x86_override(&insn, size == __WORD || size == __BYTE); x86_rex(&insn, size, 0, src.reg, 0); x86_opcode(&insn, 0xf7); x86_modrm(&insn, 3, 4, src.reg); x86_emit(blob, &insn); } static void asm_imul(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_REG); x86_override(&insn, size == __WORD || size == __BYTE); x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode_2(&insn, 0x0f, 0xaf); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_idiv(code_blob_t *blob, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(src.kind == X86_REG); x86_override(&insn, size == __WORD || size == __BYTE); x86_rex(&insn, size, 0, src.reg, 0); x86_opcode(&insn, 0xf7); x86_modrm(&insn, 3, 7, src.reg); x86_emit(blob, &insn); } static void asm_and(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; switch (COMBINE(dst, src)) { case REG_IMM: x86_rex(&insn, size, 0, dst.reg, 0); switch (size) { case __QWORD: case __DWORD: if (is_imm8(src.imm)) { x86_opcode(&insn, 0x83); x86_modrm(&insn, 3, 4, dst.reg); x86_imm8(&insn, src.imm); } else { x86_opcode(&insn, 0x81); x86_modrm(&insn, 3, 4, dst.reg); x86_imm32(&insn, src.imm); } break; default: fatal_trace("unhandled size %d in asm_and", size); } break; case REG_REG: x86_rex(&insn, size, src.reg, dst.reg, 0); x86_opcode(&insn, size == __BYTE ? 0x20 : 0x21); x86_modrm(&insn, 3, src.reg, dst.reg); break; default: fatal_trace("unhandled operand combination in asm_and"); } x86_emit(blob, &insn); } static void asm_or(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_REG); x86_rex(&insn, size, src.reg, dst.reg, 0); x86_opcode(&insn, size == __BYTE ? 0x08 : 0x09); x86_modrm(&insn, 3, src.reg, dst.reg); x86_emit(blob, &insn); } static void asm_shl(code_blob_t *blob, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(src.kind == X86_REG); x86_rex(&insn, size, src.reg, 0, 0); x86_opcode(&insn, 0xd3); x86_modrm(&insn, 3, 4, src.reg); x86_emit(blob, &insn); } static void asm_sar(code_blob_t *blob, x86_operand_t src, x86_operand_t count, x86_size_t size) { x86_insn_t insn = {}; switch (COMBINE(src, count)) { case REG_REG: assert(count.reg == __ECX.reg); x86_rex(&insn,size, src.reg, 0, 0); x86_opcode(&insn, 0xd3); x86_modrm(&insn, 3, 7, src.reg); break; case REG_IMM: x86_rex(&insn, size, src.reg, 0, 0); if (count.imm == 1) { x86_opcode(&insn, 0xd1); x86_modrm(&insn, 3, 7, src.reg); } else { x86_opcode(&insn, 0xc1); x86_modrm(&insn, 3, 7, src.reg); x86_imm8(&insn, count.imm); } break; default: fatal_trace("unhandled operand combination in asm_sar"); } x86_emit(blob, &insn); } static void asm_test(code_blob_t *blob, x86_operand_t src1, x86_operand_t src2, x86_size_t size) { x86_insn_t insn = {}; switch (COMBINE(src1, src2)) { case REG_IMM: x86_rex(&insn, size, 0, src1.reg, 0); if (size == __BYTE) { x86_opcode(&insn, 0xf6); x86_modrm(&insn, 3, 0, src1.reg); x86_imm8(&insn, src2.imm); } else { x86_opcode(&insn, 0xf7); x86_modrm(&insn, 3, 0, src1.reg); x86_imm32(&insn, src2.imm); } break; case REG_REG: x86_rex(&insn, size, src2.reg, src1.reg, 0); x86_opcode(&insn, size == __BYTE ? 0x84 : 0x85); x86_modrm(&insn, 3, src2.reg, src1.reg); break; default: fatal_trace("unhandled operand combination in asm_test"); } x86_emit(blob, &insn); } static void asm_cmp(code_blob_t *blob, x86_operand_t src1, x86_operand_t src2, x86_size_t size) { x86_insn_t insn = {}; switch (COMBINE(src1, src2)) { case REG_REG: x86_rex(&insn, size, src2.reg, src1.reg, 0); x86_opcode(&insn, 0x39); x86_modrm(&insn, 3, src2.reg, src1.reg); break; case MEM_REG: x86_rex(&insn, size, src2.reg, src1.addr.reg, 0); x86_opcode(&insn, 0x39); if (is_imm8(src1.addr.off)) { x86_modrm(&insn, 1, src2.reg, src1.reg); x86_imm8(&insn, src1.addr.off); } else { x86_modrm(&insn, 2, src2.reg, src1.reg); x86_imm32(&insn, src1.addr.off); } break; default: fatal_trace("unhandled operand combination in asm_test"); } x86_emit(blob, &insn); } static void asm_setcc(code_blob_t *blob, x86_operand_t dst, x86_cmp_t cmp) { x86_insn_t insn = {}; assert(dst.kind == X86_REG); x86_rex(&insn, 1, 0, dst.reg, 0); x86_opcode_2(&insn, 0x0f, 0x90 + cmp); x86_modrm(&insn, 3, 0, dst.reg); x86_emit(blob, &insn); } static void asm_call(code_blob_t *blob, x86_operand_t addr) { x86_insn_t insn = {}; switch (addr.kind) { case X86_IMM: { const ptrdiff_t rel = (uint8_t *)addr.imm - blob->wptr - 5; x86_opcode(&insn, 0xe8); x86_imm32(&insn, rel); } break; case X86_REG: x86_opcode(&insn, 0xff); x86_modrm(&insn, 3, 2, addr.reg); break; default: fatal_trace("unhandled operand kind in asm_call"); } x86_emit(blob, &insn); } static void asm_jmp(code_blob_t *blob, x86_operand_t addr) { x86_insn_t insn = {}; switch (addr.kind) { case X86_PATCH: if (is_imm8(addr.imm)) { x86_opcode(&insn, 0xeb); x86_imm8(&insn, 8); } else { x86_opcode(&insn, 0xe9); x86_imm32(&insn, __builtin_bswap32(32)); } break; case X86_IMM: if (is_imm8(addr.imm)) { x86_opcode(&insn, 0xeb); x86_imm8(&insn, addr.imm); } else { x86_opcode(&insn, 0xe9); x86_imm32(&insn, addr.imm); } break; default: fatal_trace("unhandled operand kind in asm_jmp"); } x86_emit(blob, &insn); } static void asm_jcc(code_blob_t *blob, x86_operand_t addr, x86_cmp_t cmp) { x86_insn_t insn = {}; switch (addr.kind) { case X86_PATCH: if (is_imm8(addr.imm)) { x86_opcode(&insn, 0x70 + cmp); x86_imm8(&insn, 8); } else { x86_opcode_2(&insn, 0x0f, 0x80 + cmp); x86_imm32(&insn, __builtin_bswap32(32)); } break; case X86_IMM: if (is_imm8(addr.imm)) { x86_opcode(&insn, 0x70 + cmp); x86_imm8(&insn, addr.imm); } else { x86_opcode_2(&insn, 0x0f, 0x80 + cmp); x86_imm32(&insn, addr.imm); } break; default: fatal_trace("unhandled operand kind in asm_jcc"); } x86_emit(blob, &insn); } static void asm_mulsd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_opcode_3(&insn, 0xf2, 0x0f, 0x59); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_divsd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_opcode_3(&insn, 0xf2, 0x0f, 0x5e); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_addsd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_opcode_3(&insn, 0xf2, 0x0f, 0x58); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_subsd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_opcode_3(&insn, 0xf2, 0x0f, 0x5c); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_pxor(code_blob_t *blob, x86_operand_t dst, x86_operand_t src) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_opcode_3(&insn, 0x66, 0x0f, 0xef); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_ucomisd(code_blob_t *blob, x86_operand_t src1, x86_operand_t src2) { x86_insn_t insn = {}; assert(COMBINE(src1, src2) == XMM_XMM); x86_opcode_3(&insn, 0x66, 0x0f, 0x2e); x86_modrm(&insn, 3, src1.reg, src2.reg); x86_emit(blob, &insn); } static void asm_cvtsd2si(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == REG_XMM); x86_prefix(&insn, 0xf2); x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode_2(&insn, 0x0f, 0x2d); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_cvtsi2sd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, x86_size_t size) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_REG); x86_prefix(&insn, 0xf2); x86_rex(&insn, size, dst.reg, src.reg, 0); x86_opcode_2(&insn, 0x0f, 0x2a); x86_modrm(&insn, 3, dst.reg, src.reg); x86_emit(blob, &insn); } static void asm_roundsd(code_blob_t *blob, x86_operand_t dst, x86_operand_t src, uint8_t mode) { x86_insn_t insn = {}; assert(COMBINE(dst, src) == XMM_XMM); x86_override(&insn, true); x86_opcode_3(&insn, 0x0F, 0x3A, 0x0B); x86_modrm(&insn, 3, dst.reg, src.reg); x86_imm8(&insn, mode); x86_emit(blob, &insn); } static void asm_repstos(code_blob_t *blob, x86_size_t size) { x86_insn_t insn = {}; x86_prefix(&insn, 0xf3); x86_rex(&insn, size, 0, 0, 0); x86_override(&insn, size == __WORD); x86_opcode(&insn, size == __BYTE ? 0xaa : 0xab); x86_emit(blob, &insn); } static void asm_repmovs(code_blob_t *blob, x86_size_t size) { x86_insn_t insn = {}; x86_prefix(&insn, 0xf3); x86_rex(&insn, size, 0, 0, 0); x86_override(&insn, size == __WORD); x86_opcode(&insn, size == __BYTE ? 0xa4 : 0xa5); x86_emit(blob, &insn); } //////////////////////////////////////////////////////////////////////////////// // JIT IR to X86 assembly lowering static void jit_x86_push_call_clobbered(code_blob_t *blob) { PUSH(__ECX); PUSH(__EDX); #ifndef __MINGW32__ PUSH(__ESI); PUSH(__EDI); #endif PUSH(__R8); PUSH(__R9); PUSH(__R10); PUSH(__R11); } static void jit_x86_pop_call_clobbered(code_blob_t *blob) { POP(__R11); POP(__R10); POP(__R9); POP(__R8); #ifndef __MINGW32__ POP(__EDI); POP(__ESI); #endif POP(__EDX); POP(__ECX); } static x86_operand_t jit_x86_locals(code_blob_t *blob, ptrdiff_t off) { const ptrdiff_t locals = FRAME_FIXED_SIZE + blob->func->nregs*8 + blob->func->framesz; return ADDR(__EBP, -locals + off); } static x86_operand_t jit_x86_spill_slot(code_blob_t *blob, unsigned slot) { assert(slot >= STACK_BASE); const ptrdiff_t off = (slot - STACK_BASE) * sizeof(int64_t); return jit_x86_locals(blob, -off); } static void jit_x86_get_reg(code_blob_t *blob, x86_operand_t dst, jit_reg_t reg, const phys_slot_t *slots) { if (slots[reg] >= STACK_BASE) MOV(dst, jit_x86_spill_slot(blob, slots[reg]), __QWORD); else { assert(slots[reg] < FLOAT_BASE); MOV(dst, REG(slots[reg]), __QWORD); } } static void jit_x86_get_copy(code_blob_t *blob, x86_operand_t dst, jit_value_t src, const phys_slot_t *slots) { switch (src.kind) { case JIT_VALUE_REG: jit_x86_get_reg(blob, dst, src.reg, slots); break; case JIT_VALUE_INT64: case JIT_ADDR_ABS: MOV(dst, IMM(src.int64), __QWORD); break; case JIT_VALUE_HANDLE: MOV(dst, IMM(src.handle), __DWORD); break; case JIT_VALUE_DOUBLE: MOV(__EAX, IMM(src.int64), __QWORD); MOV(dst, __EAX, __QWORD); break; case JIT_VALUE_LOCUS: MOV(dst, PTR(src.locus), __QWORD); break; case JIT_ADDR_REG: if (src.disp == 0) jit_x86_get_reg(blob, dst, src.reg, slots); else if (slots[src.reg] >= STACK_BASE) { MOV(dst, jit_x86_spill_slot(blob, slots[src.reg]), __QWORD); LEA(dst, ADDR(dst, src.disp)); } else LEA(dst, ADDR(REG(slots[src.reg]), src.disp)); break; case JIT_ADDR_CPOOL: MOV(dst, PTR(blob->func->cpool + src.int64), __QWORD); break; case JIT_ADDR_COVER: MOV(dst, PTR(jit_get_cover_ptr(blob->func->jit, src)), __QWORD); break; default: fatal_trace("cannot handle value kind %d in jit_x86_get", src.kind); } } static x86_operand_t jit_x86_get(code_blob_t *blob, x86_operand_t tmp, jit_value_t src, const phys_slot_t *slots) { switch (src.kind) { case JIT_VALUE_REG: if (slots[src.reg] < FLOAT_BASE) return REG(slots[src.reg]); else { jit_x86_get_reg(blob, tmp, src.reg, slots); return tmp; } case JIT_VALUE_INT64: if (is_imm32(src.int64)) return IMM(src.int64); // Fall-through case JIT_ADDR_ABS: jit_x86_get_copy(blob, tmp, src, slots); return tmp; case JIT_VALUE_HANDLE: MOV(tmp, IMM(src.handle), __DWORD); return tmp; case JIT_VALUE_DOUBLE: MOV(tmp, IMM(src.int64), __QWORD); return tmp; case JIT_VALUE_LOCUS: MOV(tmp, PTR(src.locus), __QWORD); return tmp; case JIT_ADDR_REG: jit_x86_get_copy(blob, tmp, src, slots); return tmp; case JIT_ADDR_CPOOL: MOV(tmp, PTR(blob->func->cpool + src.int64), __QWORD); return tmp; case JIT_ADDR_COVER: MOV(tmp, PTR(jit_get_cover_ptr(blob->func->jit, src)), __QWORD); return tmp; default: fatal_trace("cannot handle value kind %d in jit_x86_get", src.kind); } } static x86_operand_t jit_x86_get_addr(code_blob_t *blob, jit_value_t addr, x86_operand_t tmp, const phys_slot_t *slots) { switch (addr.kind) { case JIT_ADDR_REG: jit_x86_get_reg(blob, tmp, addr.reg, slots); return ADDR(tmp, addr.disp); case JIT_ADDR_CPOOL: MOV(tmp, PTR(blob->func->cpool + addr.int64), __QWORD); return ADDR(tmp, 0); case JIT_ADDR_ABS: MOV(tmp, IMM(addr.int64), __QWORD); return ADDR(tmp, 0); case JIT_ADDR_COVER: MOV(tmp, PTR(jit_get_cover_ptr(blob->func->jit, addr)), __QWORD); return ADDR(tmp, 0); default: fatal_trace("cannot handle value kind %d in jit_x86_get_addr", addr.kind); } } static void jit_x86_patch(code_blob_t *blob, jit_label_t label, uint8_t *wptr, const uint8_t *dest) { const int size = *(wptr - 1); assert(size == 8 || size == 32); const ptrdiff_t rel = dest - wptr; if (unlikely(size == 8 && !is_imm8(rel))) fatal_trace("relative displacement %"PRIiPTR" does not fit " "in 8-bit immediate", rel); if (size == 32) { *(wptr - 1) = (rel >> 24) & 0xff; *(wptr - 2) = (rel >> 16) & 0xff; *(wptr - 3) = (rel >> 8) & 0xff; *(wptr - 4) = rel & 0xff; } else *(wptr - 1) = rel; } static void jit_x86_put(code_blob_t *blob, jit_reg_t dst, x86_operand_t src, const phys_slot_t *slots) { if (slots[dst] >= STACK_BASE) { x86_operand_t addr = jit_x86_spill_slot(blob, slots[dst]); MOV(addr, src, __QWORD); } else { assert(slots[dst] < FLOAT_BASE); MOV(REG(slots[dst]), src, __QWORD); } } static void jit_x86_set_flags(code_blob_t *blob, jit_ir_t *ir) { switch (ir->cc) { case JIT_CC_O: SETO(FLAGS_REG); break; case JIT_CC_C: SETC(FLAGS_REG); break; case JIT_CC_EQ: SETZ(FLAGS_REG); break; case JIT_CC_NE: SETNZ(FLAGS_REG); break; case JIT_CC_LT: SETLT(FLAGS_REG); break; case JIT_CC_GT: SETGT(FLAGS_REG); break; case JIT_CC_LE: SETLE(FLAGS_REG); break; case JIT_CC_GE: SETGE(FLAGS_REG); break; case JIT_CC_NONE: break; default: fatal_trace("unhandled JIT comparison code %d", ir->cc); } } static void jit_x86_sext(code_blob_t *blob, x86_operand_t reg, x86_size_t size) { assert(reg.reg == __EAX.reg); switch (size) { case __BYTE: MOVSX(reg, reg, __QWORD, __BYTE); break; case __WORD: CWDE(); // Fall-through case __DWORD: CDQE(); break; default: break; } } static x86_size_t jit_x86_size(jit_ir_t *ir) { switch (ir->size) { case JIT_SZ_8: return __BYTE; case JIT_SZ_16: return __WORD; case JIT_SZ_32: return __DWORD; default: return __QWORD; } } #ifdef DEBUG __attribute__((unused)) static void jit_x86_debug_out(code_blob_t *blob, jit_x86_state_t *state, x86_operand_t value, jit_reg_t reg) { MOV(__EAX, value, __QWORD); MOV(__ECX, IMM(reg), __DWORD); CALL(PTR(state->stubs[DEBUG_STUB])); } #endif static void jit_x86_recv(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { assert(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; MOV(__EAX, ADDR(ARGS_REG, nth * sizeof(int64_t)), __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_send(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { assert(ir->arg1.kind == JIT_VALUE_INT64); const int nth = ir->arg1.int64; x86_operand_t src = jit_x86_get(blob, __EAX, ir->arg2, slots); MOV(ADDR(ARGS_REG, nth * sizeof(int64_t)), src, __QWORD); } static void jit_x86_add(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); const x86_size_t size = jit_x86_size(ir); ADD(__EAX, rhs, size); jit_x86_set_flags(blob, ir); jit_x86_sext(blob, __EAX, size); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_sub(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); const x86_size_t size = jit_x86_size(ir); SUB(__EAX, rhs, size); jit_x86_set_flags(blob, ir); jit_x86_sext(blob, __EAX, size); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_mul(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); // No immediate version const x86_size_t size = jit_x86_size(ir); if (ir->cc == JIT_CC_O) IMUL(__EAX, __ECX, size); else MUL(__ECX, size); jit_x86_set_flags(blob, ir); jit_x86_sext(blob, __EAX, size); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_rem(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); const x86_size_t size = jit_x86_size(ir); switch (size) { case __WORD: CWD(); break; case __DWORD: CDQ(); break; default: CQO(); break; } IDIV(rhs, size); MOV(__EAX, __EDX, MAX(size, __DWORD)); jit_x86_sext(blob, __EAX, size); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_div(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); const x86_size_t size = jit_x86_size(ir); switch (size) { case __WORD: CWD(); break; case __DWORD: CDQ(); break; default: CQO(); break; } IDIV(rhs, size); jit_x86_sext(blob, __EAX, size); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_neg(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); NEG(__EAX, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_not(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { x86_operand_t src = jit_x86_get(blob, __ECX, ir->arg1, slots); XOR(__EAX, __EAX, __DWORD); TEST(src, src, __BYTE); SETZ(__EAX); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_and(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); AND(__EAX, rhs, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_or(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); OR(__EAX, rhs, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_xor(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); XOR(__EAX, rhs, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_mov(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { x86_operand_t src = jit_x86_get(blob, __EAX, ir->arg1, slots); jit_x86_put(blob, ir->result, src, slots); } static void jit_x86_clamp(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { x86_operand_t src = jit_x86_get(blob, __ECX, ir->arg1, slots); XOR(__EAX, __EAX, __DWORD); TEST(src, src, __QWORD); CMOVGT(__EAX, src, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_jump(code_blob_t *blob, jit_ir_t *ir) { const int this = ir - blob->func->irbuf; const int distance = (this - ir->arg1.label) * BYTES_PER_IR; if (ir->cc == JIT_CC_NONE) JMP(PATCH(distance)); else if (ir->cc == JIT_CC_T) { TEST(FLAGS_REG, IMM(1), __BYTE); JNZ(PATCH(distance)); } else if (ir->cc == JIT_CC_F) { TEST(FLAGS_REG, IMM(1), __BYTE); JZ(PATCH(distance)); } else fatal_trace("invalid JUMP condition code"); code_blob_patch(blob, ir->arg1.label, jit_x86_patch); } static void jit_x86_ret(code_blob_t *blob, jit_ir_t *ir) { jit_ir_t *endir = blob->func->irbuf + blob->func->nirs; if (ir + 1 < endir) { const int distance = (endir - ir) * BYTES_PER_IR; JMP(PATCH(distance)); code_blob_patch(blob, JIT_LABEL_INVALID, jit_x86_patch); } } static void jit_x86_load(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { x86_operand_t addr = jit_x86_get_addr(blob, ir->arg1, __ECX, slots); MOVSX(__EAX, addr, __QWORD, jit_x86_size(ir)); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_uload(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { x86_operand_t addr = jit_x86_get_addr(blob, ir->arg1, __ECX, slots); MOVZX(__EAX, addr, __QWORD, jit_x86_size(ir)); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_store(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t addr = jit_x86_get_addr(blob, ir->arg2, __ECX, slots); MOV(addr, __EAX, jit_x86_size(ir)); } static void jit_x86_lea(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_cmp(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); CMP(__EAX, __ECX, __QWORD); jit_x86_set_flags(blob, ir); } static void jit_x86_ccmp(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { // TODO: move this below JZ jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); TEST(FLAGS_REG, IMM(1), __BYTE); JZ(IMM(6)); CMP(__EAX, __ECX, __QWORD); jit_x86_set_flags(blob, ir); } static void jit_x86_cset(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_put(blob, ir->result, FLAGS_REG, slots); } static void jit_x86_csel(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); x86_operand_t rhs = jit_x86_get(blob, __ECX, ir->arg2, slots); TEST(FLAGS_REG, FLAGS_REG, __BYTE); CMOVZ(__EAX, rhs, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_call(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir) { jit_func_t *f = jit_get_func(state->jit, ir->arg1.handle); MOV(__EAX, PTR(f), __QWORD); CALL(PTR(state->stubs[CALL_STUB])); } static void jit_x86_shl(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); SHL(__EAX, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_asr(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); SAR(__EAX, __ECX, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_trap(code_blob_t *blob, jit_ir_t *ir) { INT3(); } static void jit_x86_fmul(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); MULSD(__XMM0, __XMM1); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_fdiv(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); DIVSD(__XMM0, __XMM1); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_fadd(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); ADDSD(__XMM0, __XMM1); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_fsub(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); SUBSD(__XMM0, __XMM1); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_fneg(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); PXOR(__XMM1, __XMM1); SUBSD(__XMM1, __XMM0); jit_x86_put(blob, ir->result, __XMM1, slots); } static void jit_x86_fcmp(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); UCOMISD(__XMM0, __XMM1); switch (ir->cc) { case JIT_CC_LT: SETB(FLAGS_REG); break; case JIT_CC_LE: SETBE(FLAGS_REG); break; case JIT_CC_GT: SETA(FLAGS_REG); break; case JIT_CC_GE: SETAE(FLAGS_REG); break; case JIT_CC_EQ: SETZ(FLAGS_REG); break; case JIT_CC_NE: SETNZ(FLAGS_REG); break; default: fatal_trace("unhandled FCMP comparison code %d", ir->cc); } } static void jit_x86_fcvtns(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); if (__builtin_cpu_supports("sse4.1")) ROUNDSD(__XMM0, __XMM0, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC); else CALL(PTR(state->stubs[ROUND_STUB])); CVTSD2SI(__EAX, __XMM0, __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_scvtf(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); CVTSI2SD(__XMM0, __EAX, __QWORD); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_macro_exit(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir) { MOV(__EAX, IMM(ir->arg1.exit), __DWORD); CALL(PTR(state->stubs[EXIT_STUB])); #ifdef DEBUG if (jit_will_abort(ir)) INT3(); #endif } static void jit_x86_macro_salloc(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { assert(ir->arg1.int64 + ir->arg2.int64 <= blob->func->framesz); x86_operand_t addr = jit_x86_locals(blob, ir->arg1.int64); LEA(__EAX, addr); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_macro_lalloc(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); CALL(PTR(state->stubs[TLAB_STUB])); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_macro_galloc(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); CALL(PTR(state->stubs[ALLOC_STUB])); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_macro_bzero(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EDI, ir->arg1, slots); jit_x86_get_reg(blob, __ECX, ir->result, slots); XOR(__EAX, __EAX, __DWORD); REPSTOS(__BYTE); } static void jit_x86_macro_copy(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { PUSH(__ESI); jit_x86_get_copy(blob, __EDI, ir->arg1, slots); jit_x86_get_copy(blob, __ESI, ir->arg2, slots); jit_x86_get_reg(blob, __ECX, ir->result, slots); REPMOVS(__BYTE); POP(__ESI); } static void jit_x86_macro_move(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { PUSH(__ESI); jit_x86_get_copy(blob, __EDI, ir->arg1, slots); jit_x86_get_copy(blob, __ESI, ir->arg2, slots); jit_x86_get_reg(blob, __ECX, ir->result, slots); CMP(__EDI, __ESI, __QWORD); JB(IMM(19)); // Source before destination LEA(__EAX, ADDR2(__EDI, __ECX, -1)); CMP(__EAX, __ESI, __QWORD); JBE(IMM(9)); // Destination end before source // Overlap MOV(__EDI, __EAX, __QWORD); LEA(__ESI, ADDR2(__ESI, __ECX, -1)); STD(); REPMOVS(__BYTE); CLD(); POP(__ESI); } static void jit_x86_macro_memset(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EDI, ir->arg1, slots); jit_x86_get_copy(blob, __EAX, ir->arg2, slots); jit_x86_get_reg(blob, __ECX, ir->result, slots); switch (ir->size) { case JIT_SZ_64: SAR(__ECX, IMM(3), __DWORD); REPSTOS(__QWORD); break; case JIT_SZ_32: SAR(__ECX, IMM(2), __DWORD); REPSTOS(__DWORD); break; case JIT_SZ_16: SAR(__ECX, IMM(1), __DWORD); REPSTOS(__WORD); break; default: REPSTOS(__BYTE); break; } } static void jit_x86_macro_getpriv(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_func_t *f = jit_get_func(blob->func->jit, ir->arg1.handle); void **ptr = jit_get_privdata_ptr(blob->func->jit, f); MOV(__EAX, IMM((intptr_t)ptr), __QWORD); MOV(__EAX, ADDR(__EAX, 0), __QWORD); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_macro_putpriv(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_func_t *f = jit_get_func(blob->func->jit, ir->arg1.handle); void **ptr = jit_get_privdata_ptr(blob->func->jit, f); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); MOV(__EAX, IMM((intptr_t)ptr), __QWORD); MOV(ADDR(__EAX, 0), __ECX, __QWORD); } static void jit_x86_macro_case(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EAX, ir->arg1, slots); // Reuse test value from preceding $CASE macro if possible if (ir == blob->func->irbuf || (ir - 1)->op != MACRO_CASE || (ir - 1)->result != ir->result) jit_x86_get_reg(blob, __ECX, ir->result, slots); CMP(__EAX, __ECX, __QWORD); const int this = ir - blob->func->irbuf; const int distance = (this - ir->arg2.label) * BYTES_PER_IR; JZ(PATCH(distance)); code_blob_patch(blob, ir->arg2.label, jit_x86_patch); } static void jit_x86_macro_exp(code_blob_t *blob, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __EDI, ir->arg1, slots); jit_x86_get_copy(blob, __ECX, ir->arg2, slots); TEST(__ECX, __ECX, __QWORD); MOV(__EAX, IMM(1), __DWORD); JZ(IMM(18)); TEST(__ECX, IMM(1), __BYTE); JZ(IMM(4)); IMUL(__EAX, __EDI, __QWORD); IMUL(__EDI, __EDI, __QWORD); SAR(__ECX, IMM(1), __QWORD); JNZ(IMM(-18)); jit_x86_put(blob, ir->result, __EAX, slots); } static void jit_x86_macro_fexp(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir, const phys_slot_t *slots) { jit_x86_get_copy(blob, __XMM0, ir->arg1, slots); jit_x86_get_copy(blob, __XMM1, ir->arg2, slots); CALL(PTR(state->stubs[FEXP_STUB])); jit_x86_put(blob, ir->result, __XMM0, slots); } static void jit_x86_macro_trim(code_blob_t *blob, jit_ir_t *ir) { const ptrdiff_t off = offsetof(jit_anchor_t, watermark); MOV(__EAX, ADDR(__EBP, ANCHOR_OFFSET + off), __DWORD); MOV(ADDR(TLAB_REG, offsetof(tlab_t, alloc)), __EAX, __DWORD); } static void jit_x86_op(code_blob_t *blob, jit_x86_state_t *state, jit_ir_t *ir, const phys_slot_t *slots) { switch (ir->op) { case J_RECV: jit_x86_recv(blob, ir, slots); break; case J_SEND: jit_x86_send(blob, ir, slots); break; case J_ADD: jit_x86_add(blob, ir, slots); break; case J_SUB: jit_x86_sub(blob, ir, slots); break; case J_MUL: jit_x86_mul(blob, ir, slots); break; case J_REM: jit_x86_rem(blob, ir, slots); break; case J_DIV: jit_x86_div(blob, ir, slots); break; case J_NEG: jit_x86_neg(blob, ir, slots); break; case J_CLAMP: jit_x86_clamp(blob, ir, slots); break; case J_MOV: jit_x86_mov(blob, ir, slots); break; case J_NOT: jit_x86_not(blob, ir, slots); break; case J_AND: jit_x86_and(blob, ir, slots); break; case J_OR: jit_x86_or(blob, ir, slots); break; case J_XOR: jit_x86_xor(blob, ir, slots); break; case J_DEBUG: case J_NOP: break; case J_JUMP: jit_x86_jump(blob, ir); break; case J_RET: jit_x86_ret(blob, ir); break; case J_LOAD: jit_x86_load(blob, ir, slots); break; case J_ULOAD: jit_x86_uload(blob, ir, slots); break; case J_STORE: jit_x86_store(blob, ir, slots); break; case J_LEA: jit_x86_lea(blob, ir, slots); break; case J_CMP: jit_x86_cmp(blob, ir, slots); break; case J_CCMP: jit_x86_ccmp(blob, ir, slots); break; case J_CSET: jit_x86_cset(blob, ir, slots); break; case J_CSEL: jit_x86_csel(blob, ir, slots); break; case J_CALL: jit_x86_call(blob, state, ir); break; case J_SHL: jit_x86_shl(blob, ir, slots); break; case J_ASR: jit_x86_asr(blob, ir, slots); break; case J_TRAP: jit_x86_trap(blob, ir); break; case J_FMUL: jit_x86_fmul(blob, ir, slots); break; case J_FADD: jit_x86_fadd(blob, ir, slots); break; case J_FSUB: jit_x86_fsub(blob, ir, slots); break; case J_FDIV: jit_x86_fdiv(blob, ir, slots); break; case J_FNEG: jit_x86_fneg(blob, ir, slots); break; case J_FCMP: jit_x86_fcmp(blob, ir, slots); break; case J_FCVTNS: jit_x86_fcvtns(blob, state, ir, slots); break; case J_SCVTF: jit_x86_scvtf(blob, ir, slots); break; case MACRO_EXIT: jit_x86_macro_exit(blob, state, ir); break; case MACRO_SALLOC: jit_x86_macro_salloc(blob, ir, slots); break; case MACRO_LALLOC: jit_x86_macro_lalloc(blob, state, ir, slots); break; case MACRO_GALLOC: jit_x86_macro_galloc(blob, state, ir, slots); break; case MACRO_BZERO: jit_x86_macro_bzero(blob, ir, slots); break; case MACRO_COPY: jit_x86_macro_copy(blob, ir, slots); break; case MACRO_MOVE: jit_x86_macro_move(blob, ir, slots); break; case MACRO_MEMSET: jit_x86_macro_memset(blob, ir, slots); break; case MACRO_GETPRIV: jit_x86_macro_getpriv(blob, ir, slots); break; case MACRO_PUTPRIV: jit_x86_macro_putpriv(blob, ir, slots); break; case MACRO_CASE: jit_x86_macro_case(blob, ir, slots); break; case MACRO_EXP: jit_x86_macro_exp(blob, ir, slots); break; case MACRO_FEXP: jit_x86_macro_fexp(blob, state, ir, slots); break; case MACRO_TRIM: jit_x86_macro_trim(blob, ir); break; default: jit_dump_with_mark(blob->func, ir - blob->func->irbuf); fatal_trace("unhandled opcode %s in x86 backend", jit_op_name(ir->op)); } } static void jit_x86_cgen(jit_t *j, jit_handle_t handle, void *context) { jit_x86_state_t *state = context; jit_func_t *f = jit_get_func(j, handle); #ifdef DEBUG const char *only = getenv("NVC_JIT_ONLY"); if (only != NULL && !icmp(f->name, only)) return; #endif code_blob_t *blob = code_blob_new(state->code, f->name, 0); if (blob == NULL) return; blob->func = f; const uint64_t allowmask = (1 << __R10.reg) | (1 << __R11.reg); phys_slot_t *slots LOCAL = xmalloc_array(f->nregs, sizeof(phys_slot_t)); const int spills = jit_do_lscan(f, slots, ~allowmask); PUSH(__EBP); MOV(__EBP, __ESP, __QWORD); // Frame layout // // |-------------------| // +8 | Caller's PC | // |-------------------| // 0 | Saved RBP | <--- RBP // |-------------------| // -4 | TLAB watermark | // -8 | IR position | // -16 | Function pointer | // -24 | Caller's anchor | <--- Frame anchor // |-------------------| // -32 | Saved RBX | // | Saved RDI (Win) | // | Saved RSI (Win) | // | Saved R12 | // | Saved R13 | // | Saved R14 | // -80 | Saved R15 | // |-------------------| <--- End of fixed frame // | Local variables | // . . // |-------------------| // | Spill slots | // . . // |-------------------| <--- RSP const size_t framebytes = f->framesz + spills * sizeof(int64_t) + FRAME_FIXED_SIZE; const size_t framesz = ALIGN_UP(framebytes, 16); SUB(__ESP, IMM(framesz*2), __QWORD); // Callee saves MOV(ADDR(__EBP, -32), __EBX, __QWORD); #ifdef __MINGW32__ MOV(ADDR(__EBP, -40), __EDI, __QWORD); MOV(ADDR(__EBP, -48), __ESI, __QWORD); #endif #if 0 // Not currently used MOV(ADDR(__EBP, -56), __R12, __QWORD); MOV(ADDR(__EBP, -64), __R13, __QWORD); MOV(ADDR(__EBP, -72), __R14, __QWORD); MOV(ADDR(__EBP, -80), __R15, __QWORD); #endif XOR(FLAGS_REG, FLAGS_REG, __DWORD); // Shuffle incoming arguments MOV(ARGS_REG, CARG2_REG, __QWORD); MOV(TLAB_REG, CARG3_REG, __QWORD); // Build frame anchor MOV(ADDR(__EBP, -24), CARG1_REG, __QWORD); MOV(ADDR(__EBP, -16), CARG0_REG, __QWORD); MOV(ADDR(__EBP, -8), FLAGS_REG, __DWORD); MOV(__EAX, ADDR(TLAB_REG, offsetof(tlab_t, alloc)), __DWORD); MOV(ADDR(__EBP, -4), __EAX, __DWORD); STATIC_ASSERT(ANCHOR_OFFSET == -24); for (int i = 0; i < f->nirs; i++) { if (f->irbuf[i].target) code_blob_mark(blob, i); code_blob_print_ir(blob, &(f->irbuf[i])); jit_x86_op(blob, state, &(f->irbuf[i]), slots); } code_blob_mark(blob, JIT_LABEL_INVALID); MOV(__EBX, ADDR(__EBP, -32), __QWORD); #ifdef __MINGW32__ MOV(__EDI, ADDR(__EBP, -40), __QWORD); MOV(__ESI, ADDR(__EBP, -48), __QWORD); #endif #if 0 MOV(__R12, ADDR(__EBP, -56), __QWORD); MOV(__R13, ADDR(__EBP, -64), __QWORD); MOV(__R14, ADDR(__EBP, -72), __QWORD); MOV(__R15, ADDR(__EBP, -80), __QWORD); #endif LEAVE(); RET(); code_blob_finalise(blob, &(f->entry)); } static void jit_x86_gen_exit_stub(jit_x86_state_t *state) { ident_t name = ident_new("exit stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); // Exit number in EAX MOV(CARG0_REG, __EAX, __DWORD); LEA(CARG1_REG, ADDR(__EBP, ANCHOR_OFFSET)); MOV(CARG2_REG, ARGS_REG, __QWORD); MOV(CARG3_REG, TLAB_REG, __QWORD); MOV(__EAX, PTR(__nvc_do_exit), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[EXIT_STUB])); } static void jit_x86_gen_call_stub(jit_x86_state_t *state) { ident_t name = ident_new("call stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); MOV(CARG0_REG, __EAX, __QWORD); LEA(CARG1_REG, ADDR(__EBP, ANCHOR_OFFSET)); MOV(CARG2_REG, ARGS_REG, __QWORD); MOV(CARG3_REG, TLAB_REG, __QWORD); MOV(__EAX, ADDR(__EAX, offsetof(jit_func_t, entry)), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[CALL_STUB])); } static void jit_x86_gen_alloc_stub(jit_x86_state_t *state) { ident_t name = ident_new("alloc stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); // Size in EAX MOV(CARG0_REG, __EAX, __DWORD); LEA(CARG1_REG, ADDR(__EBP, ANCHOR_OFFSET)); MOV(__EAX, PTR(__nvc_mspace_alloc), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[ALLOC_STUB])); } static void jit_x86_gen_tlab_stub(jit_x86_state_t *state) { ident_t name = ident_new("tlab stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); // Fast path: allocate from TLAB MOV(__ECX, ADDR(TLAB_REG, offsetof(tlab_t, alloc)), __DWORD); MOV(__EDI, __ECX, __DWORD); ADD(__EDI, __EAX, __DWORD); ADD(__EDI, IMM(RT_ALIGN_MASK), __DWORD); AND(__EDI, IMM(~RT_ALIGN_MASK), __DWORD); CMP(ADDR(TLAB_REG, offsetof(tlab_t, limit)), __EDI, __DWORD); JLT(IMM(12)); MOV(ADDR(TLAB_REG, offsetof(tlab_t, alloc)), __EDI, __DWORD); LEA(__EAX, ADDR(TLAB_REG, offsetof(tlab_t, data))); ADD(__EAX, __ECX, __QWORD); RET(); // Slow path: call into runtime SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); MOV(CARG0_REG, __EAX, __DWORD); LEA(CARG1_REG, ADDR(__EBP, ANCHOR_OFFSET)); MOV(__EAX, PTR(__nvc_mspace_alloc), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[TLAB_STUB])); } #if DEBUG static void jit_x86_gen_debug_stub(jit_x86_state_t *state) { ident_t name = ident_new("debug stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); MOV(CARG0_REG, __EAX, __QWORD); // Value MOV(CARG1_REG, __ECX, __DWORD); // Register number MOV(__EAX, PTR(_debug_out), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[DEBUG_STUB])); } #endif static void jit_x86_gen_fexp_stub(jit_x86_state_t *state) { ident_t name = ident_new("fexp stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); MOV(__EAX, PTR(pow), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[FEXP_STUB])); } static void jit_x86_gen_round_stub(jit_x86_state_t *state) { ident_t name = ident_new("round stub"); code_blob_t *blob = code_blob_new(state->code, name, 0); SUB(__ESP, IMM(8), __QWORD); // Ensure stack aligned jit_x86_push_call_clobbered(blob); MOV(__EAX, PTR(round), __QWORD); CALL(__EAX); jit_x86_pop_call_clobbered(blob); ADD(__ESP, IMM(8), __QWORD); RET(); code_blob_finalise(blob, &(state->stubs[ROUND_STUB])); } static void *jit_x86_init(jit_t *jit) { jit_x86_state_t *state = xcalloc(sizeof(jit_x86_state_t)); state->jit = jit; state->code = code_cache_new(); jit_x86_gen_exit_stub(state); jit_x86_gen_call_stub(state); jit_x86_gen_alloc_stub(state); jit_x86_gen_tlab_stub(state); jit_x86_gen_fexp_stub(state); DEBUG_ONLY(jit_x86_gen_debug_stub(state)); if (!__builtin_cpu_supports("sse4.1")) jit_x86_gen_round_stub(state); return state; } static void jit_x86_cleanup(void *context) { jit_x86_state_t *state = context; code_cache_free(state->code); free(state); } static const jit_plugin_t jit_x86 = { .init = jit_x86_init, .cgen = jit_x86_cgen, .cleanup = jit_x86_cleanup }; void jit_register_native_plugin(jit_t *j) { const int threshold = opt_get_int(OPT_JIT_THRESHOLD); if (threshold > 0) jit_add_tier(j, threshold, &jit_x86); else if (threshold < 0) warnf("invalid NVC_JIT_THRESOLD setting %d", threshold); } nvc-r1.17.1/src/jit/jit.h000066400000000000000000000071561504111170000150640ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _JIT_H #define _JIT_H #include "prim.h" #include "diag.h" #include "util.h" typedef int32_t jit_handle_t; #define JIT_HANDLE_INVALID 0xffffffff typedef union { int64_t integer; void *pointer; double real; } jit_scalar_t; STATIC_ASSERT(sizeof(jit_scalar_t) == 8); typedef struct { void *(*init)(jit_t *); void (*cgen)(jit_t *, jit_handle_t, void *); void (*cleanup)(void *); } jit_plugin_t; typedef struct { loc_t loc; object_t *object; ident_t symbol; } jit_frame_t; typedef struct { size_t count; jit_frame_t frames[0]; } jit_stack_trace_t; typedef void (*jit_irq_fn_t)(jit_t *, void *); jit_t *jit_new(unit_registry_t *ur, mir_context_t *mc); void jit_free(jit_t *j); jit_handle_t jit_compile(jit_t *j, ident_t name); jit_handle_t jit_lazy_compile(jit_t *j, ident_t name); jit_handle_t jit_assemble(jit_t *j, ident_t name, const char *text); void *jit_link(jit_t *j, jit_handle_t handle); void *jit_get_frame_var(jit_t *j, jit_handle_t handle, ident_t name); void jit_set_silent(jit_t *j, bool silent); mspace_t *jit_get_mspace(jit_t *j); void jit_load_dll(jit_t *j, ident_t name); void jit_load_pack(jit_t *j, FILE *f); bool jit_exit_status(jit_t *j, int *status); void jit_reset_exit_status(jit_t *j); void jit_add_tier(jit_t *j, int threshold, const jit_plugin_t *plugin); ident_t jit_get_name(jit_t *j, jit_handle_t handle); object_t *jit_get_object(jit_t *j, jit_handle_t handle); void jit_register_native_plugin(jit_t *j); void jit_interrupt(jit_t *j, jit_irq_fn_t fn, void *ctx); void jit_check_interrupt(jit_t *j); void jit_reset(jit_t *j); int32_t *jit_get_cover_mem(jit_t *j, int mintags); int32_t *jit_sync_cover_mem(jit_t *j, int mintags); bool jit_is_shutdown(jit_t *j); void *jit_mspace_alloc(size_t size) RETURNS_NONNULL; jit_stack_trace_t *jit_stack_trace(void); jit_t *jit_for_thread(void); typedef void *(*thunk_result_fn_t)(jit_scalar_t *, void *); bool jit_try_call(jit_t *j, jit_handle_t handle, jit_scalar_t *result, ...); jit_scalar_t jit_call(jit_t *j, jit_handle_t handle, ...); void *jit_call_thunk(jit_t *j, vcode_unit_t unit, void *context, thunk_result_fn_t fn, void *arg); bool jit_fastcall(jit_t *j, jit_handle_t handle, jit_scalar_t *result, jit_scalar_t p1, jit_scalar_t p2, tlab_t *tlab); bool jit_vfastcall(jit_t *j, jit_handle_t handle, const jit_scalar_t *inargs, unsigned nargs, jit_scalar_t *results, unsigned nresults, tlab_t *tlab); tlab_t jit_null_tlab(jit_t *j); jit_pack_t *jit_pack_new(void); void jit_pack_free(jit_pack_t *jp); void jit_write_pack(jit_t *j, const ident_t *units, size_t count, FILE *f); jit_pack_t *jit_read_pack(FILE *f); __attribute__((format(printf, 3, 4))) void jit_msg(const loc_t *where, diag_level_t level, const char *fmt, ...); __attribute__((noreturn)) void jit_abort(void); __attribute__((noreturn)) void jit_abort_with_status(int code); #endif // _JIT_H nvc-r1.17.1/src/lexer.l000066400000000000000000001261241504111170000146300ustar00rootroot00000000000000/* -*- mode: c; c-basic-offset: 3 -*- */ /* * Copyright (C) 2011-2025 Nick Gasson * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ %option noyywrap %option nounput %option noinput %{ #include "util.h" #include "common.h" #include "diag.h" #include "ident.h" #include "option.h" #include "scan.h" #include "tree.h" #include #include #include #define YY_INPUT(buf, result, max_size) { \ result = get_next_char(buf, max_size); \ if (result <= 0) \ result = YY_NULL; \ } #define YY_USER_ACTION begin_token(yytext, yyleng); #define TOKEN(t) return (last_token = (t)) #define TOKEN_LRM(t, lrm) do { \ if (standard() < lrm && isalnum_iso88591(yytext[0])) { \ static bool warned = false; \ const token_t token = parse_id(yytext); \ if (token == tID && !warned) { \ warn_lrm(lrm, "%s is a reserved word in VHDL-%s", \ istr(yylval.ident), standard_text(lrm)); \ warned = true; \ } \ return token; \ } \ else \ return (last_token = (t)); \ } while (0) #define MIN_STD(lrm, what) do { \ static bool warned = false; \ if (!warned && standard() < lrm) { \ warn_lrm(lrm, "%s are a VHDL-%s feature", what, \ standard_text(lrm)); \ warned = true; \ } \ } while (0) #define TOKEN_00(t) TOKEN_LRM(t, STD_00) #define TOKEN_08(t) TOKEN_LRM(t, STD_08) #define TOKEN_19(t) TOKEN_LRM(t, STD_19) static int parse_id(char *str); static int parse_ex_id(char *str); static int parse_bit_string(const char *str); static int parse_string(const char *str); static int parse_decimal_literal(const char *str); static int parse_verilog_real(const char *str); static int parse_based_literal(const char *str); static int resolve_ir1045(void); static void warn_lrm(vhdl_standard_t std, const char *fmt, ...); static void warn_utf8(const char *str); static bool begin_psl_comment(void); static int escape_verilog_string(const char *str); static int report_unterminated_string(const char *str); static int report_bad_identifier(char *str); static int last_token = -1; static int comment_caller = 0; static bool in_psl_comment = false; static bool preserve_case = false; extern loc_t yylloc; extern yylval_t yylval; %} LOWER [a-z\xdf-\xf6\xf8-\xff] UPPER [A-Z\xc0-\xd6\xd8-\xde] VHDL_ID ({LOWER}|{UPPER})(_?({LOWER}|{UPPER}|[0-9]))* BAD_ID ({LOWER}|{UPPER}|_)({LOWER}|{UPPER}|[0-9_])* EXID \\([^\\\n]|\\\\)*\\ VLOG_ID [a-zA-Z_]([a-zA-Z0-9_$])* /* TODO: Add "escaped_character" handling to SDF ID */ /* TODO: According to spec, identifier could even start with number*/ SDF_ID ([a-zA-Z$_])([a-zA-Z$_0-9])* SYSTASK \$[a-zA-Z_$]([a-zA-Z0-9_$])* STRING (\"([^\"\n]|\"\")*\")|(\%([^\"\n\%]|\%\%)*\%) BADSTRING (\"([^\"\n]|\"\")*)|(\%([^\"\n\%]|\%\%)*) VLOG_STRING "\""[^\n\"]*"\"" BITSTRING [0-9]*[usUS]?(?i:[boxd]\"[^\"\n]*\")|(?i:[boxd]\%[^\n\%]*\%) CHAR '.' INTEGER [0-9][0-9_]* EXPONENT [Ee][+-]?{INTEGER} DECIMAL {INTEGER}(\.{INTEGER})?{EXPONENT}? HEX [0-9a-fA-FzZxX][0-9a-fA-FzZxX_]* BASED_HASH {INTEGER}[#]{HEX}(\.{HEX})?[#]{EXPONENT}? BASED_COLON {INTEGER}[:]{HEX}(\.{HEX})?[:]{EXPONENT}? BASED {BASED_HASH}|{BASED_COLON} SPACE [ \t\r]+ PRAGMA --[ \t]* SYNTH_OFF {PRAGMA}(?i:synthesis)[ \t]+(?i:translate_off).* SYNTH_ON {PRAGMA}(?i:synthesis)[ \t]+(?i:translate_on).* COVERAGE_OFF {PRAGMA}(?i:coverage)[ \t]+(?i:off).* COVERAGE_ON {PRAGMA}(?i:coverage)[ \t]+(?i:on).* TRANSLATE_OFF {PRAGMA}(?i:pragma)[ \t]+(?i:translate_off).* TRANSLATE_ON {PRAGMA}(?i:pragma)[ \t]+(?i:translate_on).* PSL_COMMENT {PRAGMA}(?i:psl) PSL_CONT ^{SPACE}*({PSL_COMMENT}|"--") UTF8_MB [\x80-\xff][\x80-\xbf]{1,3} VLOG_NUMBER {INTEGER}?\'[bhd]{HEX} VLOG_REAL {INTEGER}\.{INTEGER} UDP_LEVEL [01xX?bB] UDP_EDGE [rRfFpPnN*] SCALAR_ZERO ('b0|'B0|1'b0|1'B0) SCALAR_ONE ('b1|'B1|1'b1|1'B1) PAREN_STAR "("{SPACE}*"*"{SPACE}*")" %x COMMENT C_COMMENT PSL VLOG UDP SDF SDF_EXPR ENTITY ?i:entity IS ?i:is END ?i:end GENERIC ?i:generic PORT ?i:port CONSTANT ?i:constant CONFIGURATION ?i:configuration COMPONENT ?i:component ARCHITECTURE ?i:architecture OF ?i:of BEGIN ?i:begin AND ?i:and OR ?i:or XOR ?i:xor XNOR ?i:xnor NOR ?i:nor NAND ?i:nand ABS ?i:abs NOT ?i:not ALL ?i:all IN ?i:in OUT ?i:out BUFFER ?i:buffer BUS ?i:bus REGISTER ?i:register UNAFFECTED ?i:unaffected SIGNAL ?i:signal PROCESS ?i:process WAIT ?i:wait REPORT ?i:report INOUT ?i:inout LINKAGE ?i:linkage VARIABLE ?i:variable FOR ?i:for TYPE ?i:type RANGE ?i:range TO ?i:to DOWNTO ?i:downto SUBTYPE ?i:subtype UNITS ?i:units PACKAGE ?i:package LIBRARY ?i:library USE ?i:use NULL ?i:null FUNCTION ?i:function IMPURE ?i:impure PURE ?i:pure RETURN ?i:return ARRAY ?i:array OTHERS ?i:others ASSERT ?i:assert SEVERITY ?i:severity ON ?i:on MAP ?i:map IF ?i:if THEN ?i:then ELSE ?i:else ELSIF ?i:elsif BODY ?i:body WHILE ?i:while LOOP ?i:loop AFTER ?i:after ALIAS ?i:alias MOD ?i:mod ATTRIBUTE ?i:attribute PROCEDURE ?i:procedure EXIT ?i:exit REM ?i:rem WHEN ?i:when CASE ?i:case TRANSPORT ?i:transport INERTIAL ?i:inertial REJECT ?i:reject BLOCK ?i:block WITH ?i:with SELECT ?i:select GENERATE ?i:generate ACCESS ?i:access POSTPONED ?i:postponed FILE ?i:file OPEN ?i:open UNTIL ?i:until RECORD ?i:record NEW ?i:new SHARED ?i:shared NEXT ?i:next SLL ?i:sll SRL ?i:srl SLA ?i:sla SRA ?i:sra ROL ?i:rol ROR ?i:ror GROUP ?i:group LABEL ?i:label LITERAL ?i:literal GUARDED ?i:guarded REVRANGE ?i:reverse_range PROTECTED ?i:protected CONTEXT ?i:context ERROR ?i:error WARNING ?i:warning DISCONNECT ?i:disconnect FORCE ?i:force RELEASE ?i:release PARAMETER ?i:parameter ALWAYS ?i:always DEFAULT ?i:default CLOCK ?i:clock NEVER ?i:never EVENTUALLY ?i:eventually NEXT_A ?i:next_a NEXT_E ?i:next_e NEXT_EVENT ?i:next_event ASSUME ?i:assume ASSUME_G ?i:assume_guarantee RESTRICT ?i:restrict RESTRICT_G ?i:restrict_guarantee STRONG ?i:strong FAIRNESS ?i:fairness COVER ?i:cover PROPERTY ?i:property SEQUENCE ?i:sequence CONST ?i:const MUTABLE ?i:mutable HDLTYPE ?i:hdltype BOOLEAN ?i:boolean BIT ?i:bit BITVECTOR ?i:bitvector NUMERIC ?i:numeric STRING_K ?i:string WITHIN ?i:within VIEW ?i:view PRIVATE ?i:private PREV ?i:prev STABLE ?i:stable ROSE ?i:rose FELL ?i:fell ENDED ?i:ended NONDET ?i:nondet NONDET_V ?i:nondet_vector UNION ?i:union INF ?i:inf ENDPOINT ?i:endpoint INTERCONNECT ?i:interconnect DELAYFILE ?i:delayfile SDFVERSION ?i:sdfversion DESIGN ?i:design DATE ?i:date VENDOR ?i:vendor PROGRAM ?i:program VERSION ?i:version DIVIDER ?i:divider VOLTAGE ?i:voltage TEMPERATURE ?i:temperature TIMESCALE ?i:timescale CELL ?i:cell CELLTYPE ?i:celltype INSTANCE ?i:instance ABSOLUTE ?i:absolute PATHPULSE ?i:pathpulse PATHPULSEP ?i:pathpulsepercent INCREMENT ?i:increment IOPATH ?i:iopath DELAY ?i:delay SETUP ?i:setup HOLD ?i:hold SETUPHOLD ?i:setuphold RECOVERY ?i:recovery REMOVAL ?i:removal RECREM ?i:recrem WIDTH ?i:width PERIOD ?i:period SKEW ?i:skew BIDIRSKEW ?i:bidirectskew NOCHANGE ?i:nochange NETDELAY ?i:netdelay DEVICE ?i:device COND ?i:cond CONDELSE ?i:condelse PATHCONSTRAINT ?i:PATHCONSTRAINT PERIODCONSTRAINT ?i:PERIODCONSTRAINT SUM ?i:SUM DIFF ?i:DIFF SKEWCONSTRAINT ?i:SKEWCONSTRAINT ARRIVAL ?i:ARRIVAL DEPARTURE ?i:DEPARTURE SLACK ?i:SLACK WAVEFORM ?i:WAVEFORM NAME ?i:NAME EXCEPTION ?i:EXCEPTION TIMINGCHECK ?i:TIMINGCHECK TIMINGENV ?i:TIMINGENV RETAIN ?i:RETAIN SCOND ?i:SCOND CCOND ?i:CCOND ABORT ?i:abort ASYNC_ABORT ?i:async_abort SYNC_ABORT ?i:sync_abort BEFORE ?i:before %% {SYNTH_OFF} { TOKEN(tSYNTHOFF); } {SYNTH_ON} { TOKEN(tSYNTHON); } {COVERAGE_OFF} { TOKEN(tCOVERAGEOFF); } {COVERAGE_ON} { TOKEN(tCOVERAGEON); } {TRANSLATE_OFF} { TOKEN(tTRANSLATEOFF); } {TRANSLATE_ON} { TOKEN(tTRANSLATEON); } "--" { comment_caller = YY_START; BEGIN(COMMENT); } "//" { comment_caller = YY_START; BEGIN(COMMENT); } {PSL_COMMENT}[^ \t\r\n] { comment_caller = YY_START; BEGIN(COMMENT); } {PSL_COMMENT} { if (begin_psl_comment()) { in_psl_comment = true; BEGIN(PSL); TOKEN(tSTARTPSL); } else { comment_caller = YY_START; BEGIN(COMMENT); } } \n { BEGIN(comment_caller); } .* { } "/*" { MIN_STD(STD_08, "delimited comments"); comment_caller = YY_START; BEGIN(C_COMMENT); } "/*" { comment_caller = YY_START; BEGIN(C_COMMENT); } "*/" { BEGIN(comment_caller); } \n { /* Must match a single character */ } . { } ; { TOKEN(tSEMI); } {PSL_CONT} { /* Multi-line PSL comment */ if (!in_psl_comment) { comment_caller = YY_START; BEGIN(COMMENT); } } {ENTITY} { TOKEN(tENTITY); } {IS} { TOKEN(tIS); } {END} { TOKEN(tEND); } {GENERIC} { TOKEN(tGENERIC); } {PORT} { TOKEN(tPORT); } {COMPONENT} { TOKEN(tCOMPONENT); } {CONFIGURATION} { TOKEN(tCONFIGURATION); } {ARCHITECTURE} { TOKEN(tARCHITECTURE); } {OF} { TOKEN(tOF); } {BEGIN} { TOKEN(tBEGIN); } {IN} { TOKEN(tIN); } {OUT} { TOKEN(tOUT); } {BUFFER} { TOKEN(tBUFFER); } {BUS} { TOKEN(tBUS); } {REGISTER} { TOKEN(tREGISTER); } {UNAFFECTED} { TOKEN(tUNAFFECTED); } {PROCESS} { TOKEN(tPROCESS); } {WAIT} { TOKEN(tWAIT); } {REPORT} { TOKEN(tREPORT); } {INOUT} { TOKEN(tINOUT); } {LINKAGE} { TOKEN(tLINKAGE); } {FOR} { TOKEN(tFOR); } {TYPE} { TOKEN(tTYPE); } {SUBTYPE} { TOKEN(tSUBTYPE); } {UNITS} { TOKEN(tUNITS); } {PACKAGE} { TOKEN(tPACKAGE); } {LIBRARY} { TOKEN(tLIBRARY); } {USE} { TOKEN(tUSE); } {FUNCTION} { TOKEN(tFUNCTION); } {IMPURE} { TOKEN(tIMPURE); } {PURE} { TOKEN(tPURE); } {RETURN} { TOKEN(tRETURN); } {ARRAY} { TOKEN(tARRAY); } {OTHERS} { TOKEN(tOTHERS); } {ASSERT} { TOKEN(tASSERT); } {SEVERITY} { TOKEN(tSEVERITY); } {ON} { TOKEN(tON); } {MAP} { TOKEN(tMAP); } {IF} { TOKEN(tIF); } {THEN} { TOKEN(tTHEN); } {ELSE} { TOKEN(tELSE); } {ELSIF} { TOKEN(tELSIF); } {BODY} { TOKEN(tBODY); } {WHILE} { TOKEN(tWHILE); } {LOOP} { TOKEN(tLOOP); } {AFTER} { TOKEN(tAFTER); } {ALIAS} { TOKEN(tALIAS); } {ATTRIBUTE} { TOKEN(tATTRIBUTE); } {PROCEDURE} { TOKEN(tPROCEDURE); } {POSTPONED} { TOKEN(tPOSTPONED); } {EXIT} { TOKEN(tEXIT); } {WHEN} { TOKEN(tWHEN); } {CASE} { TOKEN(tCASE); } {TRANSPORT} { TOKEN(tTRANSPORT); } {REJECT} { TOKEN(tREJECT); } {INERTIAL} { TOKEN(tINERTIAL); } {BLOCK} { TOKEN(tBLOCK); } {WITH} { TOKEN(tWITH); } {SELECT} { TOKEN(tSELECT); } {GENERATE} { TOKEN(tGENERATE); } {ACCESS} { TOKEN(tACCESS); } {FILE} { TOKEN(tFILE); } {OPEN} { TOKEN(tOPEN); } {RECORD} { TOKEN(tRECORD); } {NEW} { TOKEN(tNEW); } {SHARED} { TOKEN(tSHARED); } {NEXT} { TOKEN(tNEXT); } {LITERAL} { TOKEN(tLITERAL); } {GROUP} { TOKEN(tGROUP); } {LABEL} { TOKEN(tLABEL); } {GUARDED} { TOKEN(tGUARDED); } {DISCONNECT} { TOKEN(tDISCONNECT); } {REVRANGE} { TOKEN(tREVRANGE); } {PROTECTED} { TOKEN_00(tPROTECTED); } {CONTEXT} { TOKEN_08(tCONTEXT); } {FORCE} { TOKEN_08(tFORCE); } {RELEASE} { TOKEN_08(tRELEASE); } {PARAMETER} { TOKEN_08(tPARAMETER); } {DEFAULT} { TOKEN_08(tDEFAULT); } {COVER} { TOKEN_08(tCOVER); } {VIEW} { TOKEN_19(tVIEW); } {PRIVATE} { TOKEN_19(tPRIVATE); } `{IF} { TOKEN(tCONDIF); } `{ELSE} { TOKEN(tCONDELSE); } `{ELSIF} { TOKEN(tCONDELSIF); } `{END} { TOKEN(tCONDEND); } `{ERROR} { TOKEN(tCONDERROR); } `{WARNING} { TOKEN(tCONDWARN); } {AND} { TOKEN(tAND); } {OR} { TOKEN(tOR); } {XOR} { TOKEN(tXOR); } {XNOR} { TOKEN(tXNOR); } {NAND} { TOKEN(tNAND); } {NOR} { TOKEN(tNOR); } {ABS} { TOKEN(tABS); } {NOT} { TOKEN(tNOT); } {ALL} { TOKEN(tALL); } {SLL} { TOKEN(tSLL); } {SRL} { TOKEN(tSRL); } {SLA} { TOKEN(tSLA); } {SRA} { TOKEN(tSRA); } {ROL} { TOKEN(tROL); } {ROR} { TOKEN(tROR); } {REM} { TOKEN(tREM); } {MOD} { TOKEN(tMOD); } {NULL} { TOKEN(tNULL); } {RANGE} { TOKEN(tRANGE); } {TO} { TOKEN(tTO); } {DOWNTO} { TOKEN(tDOWNTO); } {UNTIL} { TOKEN(tUNTIL); } {CONSTANT} { TOKEN(tCONSTANT); } {SIGNAL} { TOKEN(tSIGNAL); } {VARIABLE} { TOKEN(tVARIABLE); } {UDP_LEVEL} { yylval.i64 = yytext[0]; return tUDPLEVEL; } {UDP_EDGE} { yylval.i64 = yytext[0]; return tUDPEDGE; } <*>"(" { TOKEN(tLPAREN); } <*>")" { TOKEN(tRPAREN); } <*>"[" { TOKEN(tLSQUARE); } <*>"]" { TOKEN(tRSQUARE); } <*>"{" { TOKEN(tLBRACE); } <*>"}" { TOKEN(tRBRACE); } <*>"," { TOKEN(tCOMMA); } <*>";" { TOKEN(tSEMI); } <*>":" { TOKEN(tCOLON); } <*>"<" { TOKEN(tLT); } <*>">" { TOKEN(tGT); } <*>"+" { TOKEN(tPLUS); } <*>"-" { TOKEN(tMINUS); } <*>"*" { TOKEN(tTIMES); } <*>"@" { TOKEN(tAT); } <*>"?" { TOKEN(tQUESTION); } <*>"{" { TOKEN(tLBRACE); } <*>"}" { TOKEN(tRBRACE); } <*>"/" { TOKEN(tOVER); } <*>"." { TOKEN(tDOT); } <*>"&" { TOKEN(tAMP); } <*>"|" { TOKEN(tBAR); } <*>"[" { TOKEN(tLSQUARE); } <*>"]" { TOKEN(tRSQUARE); } <*>"=" { TOKEN(tEQ); } <*>"#" { TOKEN(tHASH); } <*>"~" { TOKEN(tTILDE); } <*>"^" { TOKEN(tCARET); } <*>"'" { TOKEN(tTICK); } "!" { TOKEN(tBAR); } "!" { TOKEN(tBANG); } "**" { TOKEN(tPOWER); } ":=" { TOKEN(tWALRUS); } "<>" { TOKEN(tBOX); } "?<" { TOKEN_08(tMLT); } "?<=" { TOKEN_08(tMLE); } "?>" { TOKEN_08(tMGT); } "?>=" { TOKEN_08(tMGE); } "??" { TOKEN_08(tCCONV); } "/=" { TOKEN(tNEQ); } "?/=" { TOKEN_08(tMNEQ); } "?=" { TOKEN_08(tMEQ); } "<<" { TOKEN(tLTLT); } ">>" { TOKEN(tGTGT); } "[[" { TOKEN(t2LSQUARE); } "]]" { TOKEN(t2RSQUARE); } "<=" { TOKEN(tLE); } ">=" { TOKEN(tGE); } "=>" { TOKEN(tASSOC); } {ASSERT} { TOKEN(tASSERT); } {ASSUME} { TOKEN(tASSUME); } {ASSUME_G} { TOKEN(tASSUMEG); } {RESTRICT} { TOKEN(tRESTRICT); } {RESTRICT_G} { TOKEN(tRESTRICTG); } {STRONG} { TOKEN(tSTRONG); } {FAIRNESS} { TOKEN(tFAIRNESS); } {COVER} { TOKEN(tCOVER); } {PROPERTY} { TOKEN(tPROPERTY); } {SEQUENCE} { TOKEN(tSEQUENCE); } {CONST} { TOKEN(tCONST); } {MUTABLE} { TOKEN(tMUTABLE); } {HDLTYPE} { TOKEN(tHDLTYPE); } {BOOLEAN} { TOKEN(tBOOLEAN); } {BIT} { TOKEN(tBIT); } {BITVECTOR} { TOKEN(tBITVECTOR); } {NUMERIC} { TOKEN(tNUMERIC); } {STRING_K} { TOKEN(tSTRINGK); } {ALWAYS} { TOKEN(tALWAYS); } {DEFAULT} { TOKEN(tDEFAULT); } {CLOCK} { TOKEN(tCLOCK); } {IS} { TOKEN(tIS); } {IN} { TOKEN(tIN); } {FOR} { TOKEN(tFOR); } "->" { TOKEN(tIFIMPL); } "<->" { TOKEN(tIFFIMPL); } {NEXT} { TOKEN(tPSLNEXT); } {NEXT}! { TOKEN(tNEXT1); } {NEVER} { TOKEN(tNEVER); } {EVENTUALLY}! { TOKEN(tEVENTUALLY); } {NEXT_A} { TOKEN(tNEXTA); } {NEXT_A}! { TOKEN(tNEXTA1); } {NEXT_E} { TOKEN(tNEXTE); } {NEXT_E}! { TOKEN(tNEXTE1); } {NEXT_EVENT} { TOKEN(tNEXTEVENT); } {NEXT_EVENT}! { TOKEN(tNEXTEVENT1); } "[*" { TOKEN(tTIMESRPT); } "[+]" { TOKEN(tPLUSRPT); } "[=" { TOKEN(tEQRPT); } "[->" { TOKEN(tGOTORPT); } "&&" { TOKEN(tDBLAMP); } {WITHIN} { TOKEN(tWITHIN); } {PREV} { TOKEN(tPREV); } {STABLE} { TOKEN(tSTABLE); } {ROSE} { TOKEN(tROSE); } {FELL} { TOKEN(tFELL); } {ENDED} { TOKEN(tENDED); } {NONDET} { TOKEN(tNONDET); } {NONDET_V} { TOKEN(tNONDETV); } {UNION} { TOKEN(tUNION); } {UNTIL}! { TOKEN(tUNTIL1); } {UNTIL}_ { TOKEN(tUNTIL_); } {UNTIL}_! { TOKEN(tUNTIL1_); } {ABORT} { TOKEN(tABORT); } {ASYNC_ABORT} { TOKEN(tASYNC_ABORT); } {SYNC_ABORT} { TOKEN(tSYNC_ABORT); } {BEFORE} { TOKEN(tBEFORE); } {BEFORE}! { TOKEN(tBEFORE1); } {BEFORE}_ { TOKEN(tBEFORE_); } {BEFORE}!_ { TOKEN(tBEFORE1_); } "|->" { TOKEN(tSUFFIXOVR); } "|=>" { TOKEN(tSUFFIXNON); } {INF} { TOKEN(tINF); } {ENDPOINT} { TOKEN(tENDPOINT); } "module" { return tMODULE; } "endmodule" { return tENDMODULE; } "input" { return tINPUT; } "output" { return tOUTPUT; } "inout" { return tINOUT; } "reg" { return tREG; } "always" { return tALWAYS; } "always_ff" { return tALWAYSFF; } "always_comb" { return tALWAYSCOMB; } "always_latch" { return tALWAYSLATCH; } "posedge" { return tPOSEDGE; } "negedge" { return tNEGEDGE; } "initial" { return tINITIAL; } "begin" { return tBEGIN; } "end" { return tEND; } "wire" { return tWIRE; } "tri" { return tTRI; } "tri0" { return tTRI0; } "tri1" { return tTRI1; } "wand" { return tWAND; } "triand" { return tTRIAND; } "wor" { return tWOR; } "trior" { return tTRIOR; } "trireg" { return tTRIREG; } "uwire" { return tUWIRE; } "none" { return tNONE; } "assign" { return tASSIGN; } "if" { return tIF; } "else" { return tELSE; } "fork" { return tFORK; } "join" { return tJOIN; } "automatic" { return tAUTOMATIC; } "`timescale" { return tTIMESCALE; } "`default_nettype" { return tDEFNETTYPE; } "`celldefine" { } "`endcelldefine" { } "`begin_keywords" { return tBEGINKEYWORDS; } "`end_keywords" { return tENDKEYWORDS; } "`__nvc_push" { return tNVCPUSH; } "`__nvc_pop" { return tNVCPOP; } "`resetall" { return tRESETALL; } "highz0" { return tHIGHZ0; } "highz1" { return tHIGHZ1; } "supply0" { return tSUPPLY0; } "supply1" { return tSUPPLY1; } "strong0" { return tSTRONG0; } "strong1" { return tSTRONG1; } "pull0" { return tPULL0; } "pull1" { return tPULL1; } "weak0" { return tWEAK0; } "weak1" { return tWEAK1; } "small" { return tSMALL; } "medium" { return tMEDIUM; } "large" { return tLARGE; } "vectored" { return tVECTORED; } "scalared" { return tSCALARED; } "interconnect" { return tINTERCONNECT; } "pulldown" { return tPULLDOWN; } "pullup" { return tPULLUP; } "forever" { return tFOREVER; } "==" { return tLOGEQ; } "!=" { return tLOGNEQ; } "===" { return tCASEEQ; } "!==" { return tCASENEQ; } "||" { return tLOGOR; } "&&" { return tDBLAMP; } "&&&" { return tTRPLAMP; } "<<" { return tSHIFTLL; } ">>" { return tSHIFTRL; } "<<<" { return tSHIFTLA; } ">>>" { return tSHIFTRA; } "(*" { return tATTRBEGIN; } "*)" { return tATTREND; } "%" { return tPERCENT; } "++" { return tPLUSPLUS; } "--" { return tMINUSMINUS; } "+:" { return tINDEXPOS; } "-:" { return tINDEXNEG; } "**" { return tPOWER; } "^" { return tCARET; } ("~^"|"^~") { return tTILDECARET; } "->" { return tIFIMPL; } "var" { return tVAR; } "specify" { return tSPECIFY; } "endspecify" { return tENDSPECIFY; } "primitive" { return tPRIMITIVE; } "endprimitive" { return tENDPRIMITIVE; } "table" { return tTABLE; } "endtable" { return tENDTABLE; } "and" { return tAND; } "nand" { return tNAND; } "or" { return tOR; } "nor" { return tNOR; } "xor" { return tXOR; } "xnor" { return tXNOR; } "not" { return tNOT; } "buf" { return tBUF; } "struct" { return tSTRUCT; } "packed" { return tPACKED; } "void" { return tVOID; } "byte" { return tBYTE; } "shortint" { return tSHORTINT; } "longint" { return tLONGINT; } "int" { return tSVINT; } "integer" { return tINTEGER; } "real" { return tSVREAL; } "shortreal" { return tSHORTREAL; } "realtime" { return tREALTIME; } "time" { return tTIME; } "typedef" { return tTYPEDEF; } "bit" { return tBIT; } "logic" { return tLOGIC; } "enum" { return tENUM; } "union" { return tUNION; } "tagged" { return tTAGGED; } "while" { return tWHILE; } "repeat" { return tREPEAT; } "do" { return tDO; } "task" { return tTASK; } "endtask" { return tENDTASK; } "function" { return tFUNCTION; } "endfunction" { return tENDFUNCTION; } "generate" { return tGENERATE; } "endgenerate" { return tENDGENERATE; } "wait" { return tWAIT; } "parameter" { return tPARAMETER; } "for" { return tFOR; } "localparam" { return tLOCALPARAM; } "case" { return tCASE; } "casex" { return tCASEX; } "casez" { return tCASEZ; } "endcase" { return tENDCASE; } "default" { return tDEFAULT; } "ifnone" { return tIFNONE; } "edge" { return tEDGE; } "specparam" { return tSPECPARAM; } "*>" { return tTIMESGT; } "$setup" { return tDLRSETUP; } "$hold" { return tDLRHOLD; } "$recovery" { return tDLRRECOVERY; } "$removal" { return tDLRREMOVAL; } "$setuphold" { return tDLRSETUPHOLD; } "$recrem" { return tDLRRECREM; } "$width" { return tDLRWIDTH; } "event" { return tEVENT; } "genvar" { return tGENVAR; } {SYSTASK} { yylval.str = xstrdup(yytext); return tSYSTASK; } {VLOG_ID} { yylval.str = xstrdup(yytext); return tID; } {INTEGER} { yylval.str = xstrdup(yytext); return tUNSIGNED; } {VLOG_STRING} { return escape_verilog_string(yytext); } {VLOG_NUMBER} { yylval.str = xstrdup(yytext); return tNUMBER; } {VLOG_REAL} { return parse_verilog_real(yytext); }; {PAREN_STAR} { return tPARENSTAR; } {DECIMAL} { return parse_decimal_literal(yytext); } {BASED} { return parse_based_literal(yytext); } {BITSTRING} { return parse_bit_string(yytext); } {STRING} { return parse_string(yytext); } {BADSTRING} { return report_unterminated_string(yytext); } {CHAR} { if (resolve_ir1045()) { yylval.ident = ident_new(yytext); TOKEN(tID); } REJECT; } % /* These PSL tokens must be scanned in VHDL mode for look-ahead */ "->" { TOKEN(tIFIMPL); } "<->" { TOKEN(tIFFIMPL); } "[*" { TOKEN(tTIMESRPT); } "[+]" { TOKEN(tPLUSRPT); } "[=" { TOKEN(tEQRPT); } "[->" { TOKEN(tGOTORPT); } {UNTIL}! { TOKEN(tUNTIL1); } {UNTIL}_ { TOKEN(tUNTIL_); } {UNTIL}!_ { TOKEN(tUNTIL1_); } % /* These VHDL tokens must be scanned in PSL mode for look-ahead */ {SEVERITY} { TOKEN(tSEVERITY); } {REPORT} { TOKEN(tREPORT); } % /* SDF rules separated from rest for better maintainability */ % /* SDF hierarchical_identifier may conflict with SDF keywords -> Must be scanned in separate mode! Tokens that may be lookahead after an identifier must be scanned too. */ "!" { TOKEN(tBANG); } "<<" { TOKEN(tLTLT); } ">>" { TOKEN(tGTGT); } "<=" { TOKEN(tLE); } ">=" { TOKEN(tGE); } "&&" { TOKEN(tDBLAMP); } "~&" { TOKEN(tTILDEAMP); } "~|" { TOKEN(tTILDEBAR); } "^~" { TOKEN(tTILDECARET); } "~^" { TOKEN(tTILDECARET); } "%" { TOKEN(tPERCENT); } "||" { TOKEN(tLOGOR); } "^" { TOKEN(tCARET); } "==" { TOKEN(tLOGEQ); } "!=" { TOKEN(tLOGNEQ); } "===" { TOKEN(tCASEEQ); } "!==" { TOKEN(tCASENEQ); } "//" { comment_caller = YY_START; BEGIN(COMMENT); } "/*" { comment_caller = YY_START; BEGIN(C_COMMENT); } {SCALAR_ZERO} { TOKEN(tSCALARZERO); } {SCALAR_ONE} { TOKEN(tSCALARONE); } % /* TODO: Crosscheck SDF definition of decimal */ {DECIMAL} { return parse_decimal_literal(yytext); } % /* VLOG_STRING is defined almost equally as SDF qstring */ {VLOG_STRING} { return parse_string(yytext); } {DELAYFILE} { TOKEN(tDELAYFILE); } {SDFVERSION} { TOKEN(tSDFVERSION); } {DESIGN} { TOKEN(tDESIGN); } {DATE} { TOKEN(tDATE); } {VENDOR} { TOKEN(tVENDOR); } {PROGRAM} { TOKEN(tPROGRAM); } {VERSION} { TOKEN(tVERSION); } {DIVIDER} { TOKEN(tDIVIDER); } {VOLTAGE} { TOKEN(tVOLTAGE); } {PROCESS} { TOKEN(tPROCESS); } {TEMPERATURE} { TOKEN(tTEMPERATURE); } {TIMESCALE} { TOKEN(tTIMESCALE); } {CELL} { TOKEN(tCELL); } {CELLTYPE} { TOKEN(tCELLTYPE); } {INSTANCE} { TOKEN(tINSTANCE); } {DELAY} { TOKEN(tDELAY); } {ABSOLUTE} { TOKEN(tABSOLUTE); } {PATHPULSE} { TOKEN(tPATHPULSE); } {PATHPULSEP} { TOKEN(tPATHPULSEP); } {INCREMENT} { TOKEN(tINCREMENT); } {IOPATH} { TOKEN(tIOPATH); } "posedge" { TOKEN(tPOSEDGE); } "negedge" { TOKEN(tNEGEDGE); } {SETUP} { TOKEN(tSETUP); } {HOLD} { TOKEN(tHOLD); } {SETUPHOLD} { TOKEN(tSETUPHOLD); } {RECOVERY} { TOKEN(tRECOVERY); } {REMOVAL} { TOKEN(tREMOVAL); } {RECREM} { TOKEN(tRECREM); } {WIDTH} { TOKEN(tWIDTH); } {PERIOD} { TOKEN(tPERIOD); } {SKEW} { TOKEN(tSKEW); } {BIDIRSKEW} { TOKEN(tBIDIRSKEW); } {NOCHANGE} { TOKEN(tNOCHANGE); } {PORT} { TOKEN(tPORT); } {INTERCONNECT} { TOKEN(tINTERCONNECT); } {NETDELAY} { TOKEN(tNETDELAY); } {DEVICE} { TOKEN(tDEVICE); } {COND} { TOKEN(tSDFCOND); } {CONDELSE} { TOKEN(tSDFCONDELSE); } {PATHCONSTRAINT} { TOKEN(tPATHCONSTR); } {PERIODCONSTRAINT} { TOKEN(tPERIODCONSTR); } {SUM} { TOKEN(tSUM); } {DIFF} { TOKEN(tDIFF); } {SKEWCONSTRAINT} { TOKEN(tSKEWCONSTR); } {ARRIVAL} { TOKEN(tARRIVAL); } {DEPARTURE} { TOKEN(tDEPARTURE); } {SLACK} { TOKEN(tSLACK); } {WAVEFORM} { TOKEN(tWAVEFORM); } {NAME} { TOKEN(tNAME); } {EXCEPTION} { TOKEN(tEXCEPTION); } {LABEL} { TOKEN(tLABEL); } {TIMINGCHECK} { TOKEN(tTIMINGCHECK); } {TIMINGENV} { TOKEN(tTIMINGENV); } {RETAIN} { TOKEN(tRETAIN); } {SCOND} { TOKEN(tSCOND); } {CCOND} { TOKEN(tCCOND); } {SDF_ID} { yylval.str = xstrdup(yytext); TOKEN(tID); } {UTF8_MB} { warn_utf8(yytext); REJECT; } {VHDL_ID} { return parse_id(yytext); } {EXID} { return parse_ex_id(yytext); } {BAD_ID} { return report_bad_identifier(yytext); } <*>{SPACE} { } <*>"\n" { /* Must match a single character */ } <*><> { return 0; } <*>. { TOKEN(tERROR); } %% static int resolve_ir1045(void) { // See here for discussion: // http://www.eda-stds.org/isac/IRs-VHDL-93/IR1045.txt // The set of tokens that may precede a character literal is // disjoint from that which may precede a single tick token. switch (last_token) { case tRSQUARE: case tRPAREN: case tALL: case tID: // Cannot be a character literal return 0; default: return 1; } } static bool begin_psl_comment(void) { static bool printed = false; if (opt_get_int(OPT_PSL_COMMENTS)) return true; else if (!printed) { // TODO: enable this once PSL support is complete // note_at(&yylloc, "pass $bold$--psl$$ to enable parsing of PSL " // "directives in comments"); printed = true; return false; } else return false; } static int parse_id(char *str) { if (!preserve_case) { for (char *p = str; *p; p++) *p = toupper_iso88591(*p); } yylval.ident = ident_new(str); TOKEN(tID); } static int parse_ex_id(char *str) { // Replace double '\\' character by single '\\' char *p = str + 1; for (char *s = p; *s; ) { if (*s == '\\' && *(s + 1) == '\\') s++; *p++ = *s++; } *p = '\0'; yylval.ident = ident_new(str); TOKEN(tID); } static void strip_underscores(char *s) { bool error = false; char *p; for (p = s; *s; s++) { if (*s != '_') *p++ = *s; else if ((s[1] == '\0' || s[1] == '_') && !error) { error_at(&yylloc, "a literal may not end with an underscore or " "contain multiple consecutive underscores"); error = true; } } *p = '\0'; } static int parse_decimal_literal(const char *str) { // Transform a string into a literal as specified in LRM 13.4.1 // decimal_literal ::= integer [.integer] [exponent] int tok = tERROR; char *tmp LOCAL = xstrdup(str); strip_underscores(tmp); char *dot = strpbrk(tmp, "."); if (dot == NULL) { char *sign = strpbrk(tmp, "-"); char *val = strtok(tmp, "eE"); char *exp = strtok(NULL, "eE"); errno = 0; yylval.i64 = strtoll(val, NULL, 10); bool overflow = (errno == ERANGE); long long int e = (exp ? atoll(exp) : 0); if (yylval.i64 == 0) tok = tINT; else if (e >= 0) { // Minus sign forbidden for an integer literal for (; e > 0; e--) { if (__builtin_mul_overflow(yylval.i64, INT64_C(10), &yylval.i64)) { overflow = true; break; } } tok = (sign == NULL) ? tINT : tERROR; } if (overflow) error_at(&yylloc, "value %s is outside implementation defined range " "of universal_integer", str); } else { yylval.real = strtod(tmp, NULL); tok = tREAL; } TOKEN(tok); } static int parse_based_literal(const char *str) { // Transform a string into a literal as specified in LRM 13.4.2 // based_literal ::= base [#:] based_integer [.based_integer] [#:] // [exponent] int tok = tERROR; char *tmp LOCAL = xstrdup(str); strip_underscores(tmp); char *dot = strpbrk(tmp, "."); char *sign = strpbrk(tmp, "-"); char *base = strtok(tmp, "#:"); char *val = strtok(NULL, "#:"); char *exp = strtok(NULL, "eE"); // Base must be at least 2 and at most 16 if ((2 <= atoi(base)) && (atoi(base) <= 16)) { if (dot == NULL) { char *eptr; yylval.i64 = strtoll(val, &eptr, atoi(base)); long long int e = (exp ? atoll(exp) : 0); if (e >= 0) { // Minus sign forbidden for an integer literal for (; e > 0; e--) yylval.i64 *= atoi(base); tok = ((*eptr == '\0') && (sign == NULL)) ? tINT : tERROR; } } else { char *eptr_integer, *eptr_rational; char *integer = strtok(val, "."); char *rational = strtok(NULL, "."); yylval.real = (double)strtoll(integer, &eptr_integer, atoi(base)); double tmp = (double)strtoll(rational, &eptr_rational, atoi(base)); tmp *= pow((double)atoi(base), (double)((long)(0 - strlen(rational)))); yylval.real += tmp; long long int e = (exp ? atoll(exp) : 0); if (e != 0) yylval.real *= pow((double) atoi(base), (double) e); if (*eptr_integer == '\0' && *eptr_rational == '\0') tok = tREAL; else tok = tERROR; } } TOKEN(tok); } static int parse_string(const char *str) { // Replaces all double '\"' by single '\"' or all double '%' by // single '%'. In the case when '\%' is used as string brackets, the // enclosed senquence of characters should not contain quotation // marks! char *s = (yylval.str = xstrdup(str)); // Replacing double '\"' character by single '\"' or double '%' // character by single '%' // Begins after first character s++; char *p = s; while (*p) { if ((*p == *(yylval.str)) && (*(p+1) == *(yylval.str))) p++; *s++ = *p++; } *s = *p; TOKEN(tSTRING); } static int parse_bit_string(const char *str) { // Copy input, remove all '_' characters and replace all '\%' // characters by '\"'. char *copy = (yylval.str = xstrdup(str)); bool error = false; for (char *src = copy, *dst = src; *src != '\0'; src++) { if (*src == '%') *dst++ = '\"'; else if (*src != '_') *dst++ = *src; else if ((src[-1] == '\"' || src[1] == '\"') && !error) { error_at(&yylloc, "a bit string literal may not start or end with " "an underscore"); error = true; } else if (src[-1] == '_' && !error) { error_at(&yylloc, "a bit string literal may not contain multiple " "consecutive underscores"); error = true; } } TOKEN(tBITSTRING); } static int parse_verilog_real(const char *str) { // unsigned_number [ . unsigned_number ] exp [ sign ] unsigned_number yylval.real = strtod(str, NULL); return tREAL; } static int report_unterminated_string(const char *str) { diag_t *d = diag_new(DIAG_ERROR, &yylloc); diag_printf(d, "unterminated string literal"); diag_hint(d, NULL, "a string literal must fit on one line since it " "is a lexical element, longer strings can be formed using " "concatenation"); diag_lrm(d, STD_08, "15.7"); diag_emit(d); return parse_string(str); } static int report_bad_identifier(char *str) { diag_t *d = diag_new(DIAG_ERROR, &yylloc); diag_printf(d, "a VHDL basic identifier must not start or end with an " "underscore, or contain multiple consecutive underscores"); diag_lrm(d, STD_08, "15.4.2"); diag_emit(d); return parse_id(str); } static int escape_verilog_string(const char *str) { char *s = (yylval.str = xstrdup(str)); for (char *p = s; *p; p++) { if (*p == '\\') { switch (*++p) { case 'n': *s++ = '\n'; break; case 'r': *s++ = '\r'; break; case 't': *s++ = '\t'; break; case 'b': *s++ = '\b'; break; default: warn_at(&yylloc, "unrecognised escaped character '%c'", *p); *s++ = *p; } } else *s++ = *p; } *s = '\0'; return tSTRING; } static void warn_lrm(vhdl_standard_t std, const char *fmt, ...) { va_list ap; va_start(ap, fmt); diag_t *d = diag_new(DIAG_WARN, &yylloc); diag_vprintf(d, fmt, ap); diag_hint(d, NULL, "pass $bold$--std=%s$$ to enable this feature", standard_text(std)); diag_emit(d); va_end(ap); } static void warn_utf8(const char *text) { static bool warned = false; if (!warned) { diag_t *d = diag_new(DIAG_WARN, &yylloc); diag_printf(d, "possible multi-byte UTF-8 character found in input"); diag_hint(d, NULL, "the native encoding of VHDL is ISO-8859-1"); diag_emit(d); warned = true; } } void reset_scanner(void) { last_token = -1; comment_caller = 0; in_psl_comment = false; preserve_case = opt_get_int(OPT_PRESERVE_CASE); YY_FLUSH_BUFFER; BEGIN(INITIAL); } void scan_as_psl(void) { BEGIN(PSL); } void scan_as_vhdl(void) { BEGIN(INITIAL); in_psl_comment = false; } void scan_as_verilog(void) { BEGIN(VLOG); } void scan_as_udp(void) { BEGIN(UDP); } void scan_as_sdf(void) { BEGIN(SDF); } void scan_as_sdf_expr(void) { BEGIN(SDF_EXPR); } nvc-r1.17.1/src/lib.c000066400000000000000000000726011504111170000142460ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "fbuf.h" #include "hash.h" #include "ident.h" #include "lib.h" #include "object.h" #include "option.h" #include "tree.h" #include "vlog/vlog-node.h" #include "vlog/vlog-util.h" #include #include #include #include #include #include #include #include #include #include #include #include #include typedef struct _search_path search_path_t; typedef struct _lib_index lib_index_t; typedef struct _lib_list lib_list_t; typedef struct _lib_unit lib_unit_t; #define INDEX_FILE_MAGIC 0x55225511 struct _lib_unit { object_t *object; ident_t name; uint64_t mtime; unit_meta_t meta; lib_unit_t *next; tree_kind_t kind; bool dirty; bool error; }; struct _lib_index { ident_t name; tree_kind_t kind; lib_index_t *next; }; struct _lib { char *path; ident_t name; ghash_t *lookup; lib_unit_t *units; lib_index_t *index; uint64_t index_mtime; off_t index_size; int lock_fd; bool readonly; }; struct _lib_list { lib_t item; lib_list_t *next; vhdl_standard_t standard; }; struct _search_path { search_path_t *next; const char *path; }; static lib_t work = NULL; static lib_list_t *loaded = NULL; static search_path_t *search_paths = NULL; static text_buf_t *lib_file_path(lib_t lib, const char *name); static const char *standard_suffix(vhdl_standard_t std) { static const char *ext[] = { "87", "93", "00", "02", "08", "19" }; assert(std < ARRAY_LEN(ext)); return ext[std]; } static ident_t upcase_name(const char *name) { char *name_copy LOCAL = xstrdup(name); char *name_up = name_copy; for (char *p = name_up; *p != '\0'; p++) *p = toupper_iso88591(*p); char *last_dot = strrchr(name_up, '.'); if (last_dot != NULL) *last_dot = '\0'; return ident_new(name_up); } static void lib_add_to_index(lib_t lib, ident_t name, tree_kind_t kind) { // Keep the index in sorted order to make library builds reproducible lib_index_t **it; for (it = &(lib->index); *it != NULL && ident_compare((*it)->name, name) < 0; it = &((*it)->next)) ; if (*it != NULL && (*it)->name == name) { // Already in the index (*it)->kind = kind; } else { lib_index_t *new = xmalloc(sizeof(lib_index_t)); new->name = name; new->kind = kind; new->next = *it; *it = new; } } static void lib_read_index(lib_t lib) { fbuf_t *f = lib_fbuf_open(lib, "_index", FBUF_IN, FBUF_CS_NONE); if (f != NULL) { file_info_t info; if (!get_handle_info(fbuf_file_handle(f), &info)) fatal_errno("%s", fbuf_file_name(f)); const uint32_t magic = read_u32(f); if (magic != INDEX_FILE_MAGIC) { warnf("ignoring library index %s from an old version of " PACKAGE, fbuf_file_name(f)); return; } lib->index_mtime = info.mtime; lib->index_size = info.size; ident_rd_ctx_t ictx = ident_read_begin(f); lib_index_t **insert = &(lib->index); const int entries = read_u32(f); for (int i = 0; i < entries; i++) { ident_t name = ident_read(ictx); tree_kind_t kind = read_u16(f); assert(kind <= T_LAST_TREE_KIND); while (*insert && ident_compare((*insert)->name, name) < 0) insert = &((*insert)->next); if (*insert && (*insert)->name == name) { (*insert)->kind = kind; insert = &((*insert)->next); } else { lib_index_t *new = xmalloc(sizeof(lib_index_t)); new->name = name; new->kind = kind; new->next = *insert; *insert = new; insert = &(new->next); } } ident_read_end(ictx); fbuf_close(f, NULL); } } static uint32_t lib_name_hash(const void *key) { return ident_casehash((ident_t)key); } static bool lib_name_cmp(const void *a, const void *b) { ident_t name_a = (ident_t)a, name_b = (ident_t)b; assert(name_a != name_b); // Checked in ghash already if (ident_casecmp(name_a, name_b)) { // Unit names with extended identifiers that differ only in case // should not compare equal const char *astr = istr(name_a); const char *bstr = istr(name_b); bool inext = false; for (; *astr && *bstr; astr++, bstr++) { if (*astr == '\\' && *bstr == '\\') inext = !inext; else if (inext && *astr != *bstr) return false; else if (!inext && toupper_iso88591(*astr) != toupper_iso88591(*bstr)) return false; } return true; } else return false; } static lib_t lib_init(const char *name, const char *rpath, int lock_fd) { lib_t l = xcalloc(sizeof(struct _lib)); l->name = upcase_name(name); l->index = NULL; l->lock_fd = lock_fd; l->readonly = false; l->lookup = ghash_new(128, lib_name_hash, lib_name_cmp); char abspath[PATH_MAX]; if (rpath == NULL) l->path = NULL; else if (realpath(rpath, abspath) == NULL) l->path = xstrdup(rpath); else l->path = xstrdup(abspath); lib_list_t *el = xcalloc(sizeof(lib_list_t)); el->item = l; el->next = loaded; el->standard = standard(); loaded = el; if (opt_get_verbose(OPT_LIB_VERBOSE, name)) debugf("library %s at %s", istr(l->name), l->path); if (l->lock_fd == -1 && rpath != NULL) { LOCAL_TEXT_BUF lock_path = lib_file_path(l, "_NVC_LIB"); // Try to open the lock file read-write as this is required for // exlusive locking on some NFS implementations if ((l->lock_fd = open(tb_get(lock_path), O_RDWR)) < 0 && (errno == EACCES || errno == EPERM || errno == EROFS)) { // Try again in read-only mode l->lock_fd = open(tb_get(lock_path), O_RDONLY); l->readonly = true; } if (l->lock_fd < 0) fatal_errno("open: %s", tb_get(lock_path)); file_read_lock(l->lock_fd); } lib_read_index(l); if (l->lock_fd != -1) file_unlock(l->lock_fd); return l; } static lib_index_t *lib_find_in_index(lib_t lib, ident_t name) { lib_index_t *it; for (it = lib->index; (it != NULL) && (it->name != name); it = it->next) ; return it; } static void lib_obsolete_cb(ident_t name, void *ctx) { lib_unit_t *lu = ctx; diag_t *d = diag_new(DIAG_ERROR, &lu->object->loc); tree_t t1 = tree_from_object(lu->object); if (t1 != NULL) diag_printf(d, "%s ", class_str(class_of(t1))); else diag_printf(d, "design unit "); diag_printf(d, "%s depends on an obsolete version of ", istr(lu->name)); if (lu->name == name) { diag_printf(d, "a design unit with the same name"); diag_hint(d, NULL, "this is a caused by a circular dependency on the " "design unit being analysed"); } else diag_printf(d, "%s", istr(name)); diag_emit(d); } static void lib_mark_obsolete(lib_t lib, lib_unit_t *lu, object_t *new) { if (lu->object == new) return; else if (lu->dirty) { diag_t *d = diag_new(DIAG_WARN, &new->loc); diag_printf(d, "design unit %s replaces a previously analysed unit " "with the same name", istr(lu->name)); diag_hint(d, &new->loc, "latest definition is here"); diag_hint(d, &(lu->object->loc), "previous definition is now obsolete"); diag_emit(d); } arena_set_obsolete(object_arena(lu->object), true); } static lib_unit_t *lib_put_aux(lib_t lib, object_t *object, bool dirty, bool error, timestamp_t mtime, const unit_meta_t *meta) { assert(lib != NULL); tree_kind_t kind = T_LAST_TREE_KIND; ident_t name; tree_t tree; vlog_node_t vlog; if ((tree = tree_from_object(object))) { name = tree_ident(tree); kind = tree_kind(tree); } else if ((vlog = vlog_from_object(object))) name = vlog_ident(vlog); else fatal_trace("unexpected object class in lib_put_aux"); assert(ident_until(name, '.') == lib->name); bool fresh = false; lib_unit_t *where = ghash_get(lib->lookup, name); if (where == NULL) { where = xcalloc(sizeof(lib_unit_t)); fresh = true; } else lib_mark_obsolete(lib, where, object); where->object = object; where->name = name; where->dirty = dirty; where->error = error; where->mtime = mtime; where->kind = kind; if (meta != NULL) where->meta = *meta; if (fresh) { lib_unit_t **it; for (it = &(lib->units); *it; it = &(*it)->next) { assert((*it)->object != object); assert((*it)->name != name); } *it = where; } lib_add_to_index(lib, name, where->kind); ghash_put(lib->lookup, name, where); return where; } static lib_t lib_open_at(const char *name, const char *path) { if (access(path, F_OK) < 0) return NULL; char *marker LOCAL = xasprintf("%s" DIR_SEP "_NVC_LIB", path); if (access(marker, F_OK) < 0) return NULL; return lib_init(name, path, -1); } static lib_t lib_find_at(const char *name, const char *path) { DIR *d = opendir(path); if (d == NULL) return NULL; char *best LOCAL = NULL; const char *std_suffix = standard_suffix(standard()); const size_t namelen = strlen(name); struct dirent *e; while ((e = readdir(d))) { if (!isalpha(e->d_name[0])) continue; const char *dot = strchr(e->d_name, '.'); if (dot != NULL) { if (namelen != dot - e->d_name) continue; else if (strncasecmp(name, e->d_name, namelen) != 0) continue; else if (strcmp(dot + 1, std_suffix) != 0) continue; } else { if (strcasecmp(name, e->d_name) != 0) continue; else if (best != NULL) continue; } free(best); best = xstrdup(e->d_name); } closedir(d); if (best == NULL) return NULL; LOCAL_TEXT_BUF dir = tb_new(); tb_cat(dir, path); tb_cat(dir, DIR_SEP); tb_cat(dir, best); char *marker LOCAL = xasprintf("%s" DIR_SEP "_NVC_LIB", tb_get(dir)); if (access(marker, F_OK) < 0) return NULL; return lib_init(name, tb_get(dir), -1); } static text_buf_t *lib_file_path(lib_t lib, const char *name) { text_buf_t *tb = tb_new(); tb_printf(tb, "%s" DIR_SEP "%s", lib->path, name); return tb; } static lib_t lib_loaded(ident_t name_i) { if (name_i == well_known(W_WORK) && work != NULL) return work; for (lib_list_t *it = loaded; it != NULL; it = it->next) { if (it->standard != standard()) continue; else if (ident_casecmp(lib_name(it->item), name_i)) return it->item; } return NULL; } lib_t lib_new(const char *spec) { char *copy LOCAL = xstrdup(spec); #ifdef __MINGW32__ char *split = strchr(copy, ';'); if (split == NULL) { split = strchr(copy, ':'); // Ignore a leading drive letter in the path if (split == copy + 1 && (copy[2] == '/' || copy[2] == '\\')) split = NULL; } #else char *split = strchr(copy, ':'); #endif const char *path, *name, *search = NULL; if (split == NULL) { // No colon in the argument means search in the given directory char *slash = strrchr(copy, *DIR_SEP) ?: strrchr(copy, '/'); if (slash == NULL) { name = path = copy; search = "."; } else { *slash = '\0'; name = slash + 1; path = spec; search = copy; } } else { // The string after the colon specifies the exact library path *split = '\0'; name = copy; path = split + 1; } if (*name == '\0') fatal("library name cannot be empty"); const char *last_dot = strrchr(name, '.'); if (last_dot != NULL) { const char *ext = standard_suffix(standard()); if (strcmp(last_dot + 1, ext) != 0) fatal("library directory suffix must be '%s' for this standard", ext); } for (const char *p = name; *p && p != last_dot; p++) { if (!isalnum_iso88591(*p) && (*p != '_')) fatal("invalid character '%c' in library name", *p); } ident_t name_i = upcase_name(name); lib_t lib = lib_loaded(name_i); if (lib != NULL) return lib; else if (search != NULL && (lib = lib_find_at(name, search)) != NULL) return lib; else if (search == NULL && (lib = lib_open_at(name, path)) != NULL) return lib; char *lockf LOCAL = xasprintf("%s" DIR_SEP "%s", path, "_NVC_LIB"); bool existing = false; file_info_t dir_info; if (get_file_info(path, &dir_info)) { if (dir_info.type == FILE_DIR) { file_info_t lockf_info; existing = !get_file_info(lockf, &lockf_info); } else fatal("path %s already exists and is not a directory", path); } make_dir(path); int fd = open(lockf, O_CREAT | O_EXCL | O_RDWR, 0777); if (fd < 0) { // If errno is EEXIST we raced with another process to create the // lock file. Calling into lib_init with fd as -1 will cause it // to be opened again without O_CREAT. if (errno != EEXIST) fatal_errno("lib_new: %s", lockf); } else { file_write_lock(fd); if (existing) { // We cannot do this check above as we may be racing with another // process trying to create the library which has already made the // directory but not yet created the lock file warnf("directory %s already exists and is not an NVC library", path); } const char *marker = PACKAGE_STRING "\n"; if (write(fd, marker, strlen(marker)) < 0) fatal_errno("write: %s", path); } return lib_init(name, path, fd); } lib_t lib_tmp(const char *name) { // For unit tests, avoids creating files return lib_init(name, NULL, -1); } static void push_path(const char *path) { for (search_path_t *it = search_paths; it != NULL; it = it->next) { if (strcmp(it->path, path) == 0) return; } search_path_t *s = xmalloc(sizeof(search_path_t)); s->next = search_paths; s->path = strdup(path); search_paths = s; } static void lib_default_search_paths(void) { #ifdef ENABLE_DEFAULT_PATHS if (search_paths == NULL) { LOCAL_TEXT_BUF tb = tb_new(); get_lib_dir(tb); push_path(tb_get(tb)); const char *home_env = getenv("HOME"); if (home_env) { char *LOCAL path = xasprintf("%s/.%s/lib", home_env, PACKAGE); push_path(path); } char *LOCAL env_copy = NULL; const char *libpath_env = getenv("NVC_LIBPATH"); if (libpath_env) { env_copy = strdup(libpath_env); char *path_tok = strtok(env_copy, ":"); do { push_path(path_tok); } while ((path_tok = strtok(NULL, ":"))); } } #endif } void lib_add_search_path(const char *path) { lib_default_search_paths(); push_path(path); } void lib_add_map(const char *name, const char *path) { lib_t lib = lib_open_at(name, path); if (lib == NULL) warnf("library %s not found at %s", name, path); } void lib_print_search_paths(text_buf_t *tb) { lib_default_search_paths(); for (search_path_t *it = search_paths; it != NULL; it = it->next) tb_printf(tb, "\n %s", it->path); } void lib_search_paths_to_diag(diag_t *d) { lib_default_search_paths(); LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "library search path contains: "); for (search_path_t *it = search_paths; it != NULL; it = it->next) tb_printf(tb, "%s%s", it != search_paths ? ", " : "", it->path); diag_hint(d, NULL, "%s", tb_get(tb)); diag_hint(d, NULL, "add additional directories to the search path with " "the $bold$-L$$ option"); } lib_t lib_find(ident_t name_i) { lib_t lib = lib_loaded(name_i); if (lib != NULL) return lib; lib_default_search_paths(); const char *name_str = istr(name_i); for (search_path_t *it = search_paths; it != NULL; it = it->next) { if ((lib = lib_find_at(name_str, it->path))) break; } return lib; } lib_t lib_require(ident_t name) { lib_t lib = lib_find(name); if (lib == NULL) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); diag_printf(d, "required library %s not found", istr(name)); lib_search_paths_to_diag(d); diag_emit(d); fatal_exit(EXIT_FAILURE); } return lib; } FILE *lib_fopen(lib_t lib, const char *name, const char *mode) { assert(lib != NULL); LOCAL_TEXT_BUF path = lib_file_path(lib, name); return fopen(tb_get(path), mode); } fbuf_t *lib_fbuf_open(lib_t lib, const char *name, fbuf_mode_t mode, fbuf_cs_t csum) { assert(lib != NULL); if (lib->path == NULL) return NULL; // Temporary library for unit test else { LOCAL_TEXT_BUF path = lib_file_path(lib, name); return fbuf_open(tb_get(path), mode, csum); } } void lib_free(lib_t lib) { assert(lib != NULL); assert(lib != work); if (lib->lock_fd != -1) close(lib->lock_fd); for (lib_list_t **it = &loaded; *it; it = &((*it)->next)) { if ((*it)->item == lib) { lib_list_t *tmp = *it; *it = (*it)->next; free(tmp); break; } } while (lib->index) { lib_index_t *tmp = lib->index->next; free(lib->index); lib->index = tmp; } for (lib_unit_t *lu = lib->units, *tmp; lu; lu = tmp) { tmp = lu->next; free(lu); } ghash_free(lib->lookup); free(lib->path); free(lib); } void lib_destroy(lib_t lib) { // This is convenience function for testing: remove all // files associated with a library assert(lib != NULL); close(lib->lock_fd); lib->lock_fd = -1; DIR *d = opendir(lib->path); if (d == NULL) { perror("opendir"); return; } char buf[PATH_MAX]; struct dirent *e; while ((e = readdir(d))) { if (e->d_name[0] != '.') { checked_sprintf(buf, sizeof(buf), "%s" DIR_SEP "%s", lib->path, e->d_name); if (unlink(buf) < 0) fatal_errno("unlink"); } } closedir(d); if (rmdir(lib->path) < 0) fatal_errno("rmdir"); } lib_t lib_work(void) { assert(work != NULL); return work; } void lib_set_work(lib_t lib) { work = lib; } const char *lib_path(lib_t lib) { assert(lib != NULL); return lib->path; } void lib_put(lib_t lib, tree_t unit) { object_t *obj = tree_to_object(unit); lib_put_aux(lib, obj, true, false, get_real_time(), NULL); } void lib_put_vlog(lib_t lib, vlog_node_t module) { assert(is_top_level(module)); object_t *obj = vlog_to_object(module); lib_put_aux(lib, obj, true, false, get_real_time(), NULL); } void lib_put_meta(lib_t lib, tree_t unit, const unit_meta_t *meta) { object_t *obj = tree_to_object(unit); lib_put_aux(lib, obj, true, false, get_real_time(), meta); } void lib_put_error(lib_t lib, tree_t unit) { object_t *obj = tree_to_object(unit); lib_put_aux(lib, obj, true, true, get_real_time(), NULL); } static void lib_encode_file_name(ident_t id, text_buf_t *tb) { // Encode extended identifiers in file names using the hexadecimal // value of the ISO-8859-1 code points to avoid illegal characters // and case sensitivity issues on Windows and macOS bool esc = false; for (const char *p = istr(id); *p; p++) { if (*p == '\\') { esc = !esc; tb_append(tb, '+'); } else if (esc) tb_printf(tb, "%02x", *p); else if ((*p == '.' && strcmp(p, ".elab") == 0) || (*p == '-' && strcmp(p, "-body") == 0)) { // TODO: remove these special cases tb_cat(tb, p); break; } else tb_append(tb, toupper_iso88591(*p)); } } static void lib_read_meta(fbuf_t *f, unit_meta_t *meta) { const size_t len = fbuf_get_uint(f); meta->cover_file = xmalloc(len + 1); read_raw(meta->cover_file, len + 1, f); } static lib_unit_t *lib_read_unit(lib_t lib, ident_t id) { LOCAL_TEXT_BUF tb = tb_new(); lib_encode_file_name(id, tb); fbuf_t *f = lib_fbuf_open(lib, tb_get(tb), FBUF_IN, FBUF_CS_ADLER32); if (f == NULL) return NULL; file_info_t info; if (!get_handle_info(fbuf_file_handle(f), &info)) fatal_errno("%s", tb_get(tb)); ident_rd_ctx_t ident_ctx = ident_read_begin(f); loc_rd_ctx_t *loc_ctx = loc_read_begin(f); object_t *obj = NULL; unit_meta_t meta = {}; char tag; while ((tag = read_u8(f))) { switch (tag) { case 'T': obj = object_read(f, lib_load_handler, ident_ctx, loc_ctx); break; case 'M': lib_read_meta(f, &meta); break; case 'V': // Ignore it (remove after 1.12 release) break; default: fatal_trace("unhandled tag %c in %s", tag, tb_get(tb)); } } loc_read_end(loc_ctx); ident_read_end(ident_ctx); uint32_t checksum; fbuf_close(f, &checksum); if (obj == NULL) fatal_trace("%s did not contain a HDL design unit", tb_get(tb)); arena_set_checksum(object_arena(obj), checksum); return lib_put_aux(lib, obj, false, false, info.mtime, &meta); } static lib_unit_t *lib_get_aux(lib_t lib, ident_t ident) { assert(lib != NULL); // Handle aliased library names and names without the library ident_t uname = ident, lname = ident_walk_selected(&uname); if (uname == NULL) ident = ident_prefix(lib->name, lname, '.'); else if (lname != lib->name) ident = ident_prefix(lib->name, uname, '.'); lib_unit_t *lu = ghash_get(lib->lookup, ident); if (lu != NULL) return lu; if (lib->path == NULL) // Temporary library return NULL; assert(lib->lock_fd != -1); // Should not be called in unit tests file_read_lock(lib->lock_fd); // Otherwise search in the filesystem if not in the cache lu = lib_read_unit(lib, ident); file_unlock(lib->lock_fd); if (lu == NULL && lib_find_in_index(lib, ident) != NULL) fatal("library %s corrupt: unit %s present in index but missing " "on disk", istr(lib->name), istr(ident)); if (lu != NULL && !opt_get_int(OPT_IGNORE_TIME)) { bool stale = false; file_info_t info; const char *file = loc_file_str(&(lu->object->loc)); if (get_file_info(file, &info)) stale = (lu->mtime < info.mtime); if (stale) { diag_t *d = diag_new(DIAG_WARN, NULL); diag_printf(d, "design unit %s is older than its source file " "%s and should be reanalysed", istr(ident), file); diag_hint(d, NULL, "you can use the $bold$--ignore-time$$ option " "to skip this check"); diag_emit(d); } } return lu; } static void lib_ensure_writable(lib_t lib) { if (lib->readonly) fatal("cannot write to read-only library %s", istr(lib->name)); } object_t *lib_get_generic(lib_t lib, ident_t ident, const unit_meta_t **meta) { lib_unit_t *lu = lib_get_aux(lib, ident); if (lu == NULL) return NULL; else if (lu->error) fatal_at(&lu->object->loc, "design unit %s was analysed with errors", istr(lu->name)); if (meta != NULL) *meta = &lu->meta; return lu->object; } tree_t lib_get(lib_t lib, ident_t ident) { object_t *obj = lib_get_generic(lib, ident, NULL); if (obj == NULL) return NULL; tree_t tree = tree_from_object(obj); if (tree == NULL) fatal_at(&obj->loc, "%s is not a VHDL design unit", istr(ident)); return tree; } tree_t lib_get_allow_error(lib_t lib, ident_t ident, bool *error) { lib_unit_t *lu = lib_get_aux(lib, ident); if (lu != NULL) { *error = lu->error; tree_t tree = tree_from_object(lu->object); if (tree == NULL) fatal_at(&lu->object->loc, "%s is not a VHDL design unit", istr(lu->name)); return tree; } else { *error = false; return NULL; } } object_t *lib_load_handler(ident_t qual) { ident_t lname = ident_until(qual, '.'); if (lname == NULL) return NULL; lib_t lib = lib_find(lname); if (lib == NULL) return NULL; return lib_get_generic(lib, qual, NULL); } tree_t lib_get_qualified(ident_t qual) { object_t *obj = lib_load_handler(qual); if (obj == NULL) return NULL; tree_t tree = tree_from_object(obj); if (tree == NULL) fatal_at(&obj->loc, "%s is not a VHDL design unit", istr(qual)); return tree; } timestamp_t lib_get_mtime(lib_t lib, ident_t ident) { lib_unit_t *lu = ghash_get(lib->lookup, ident); if (lu != NULL) return lu->mtime; LOCAL_TEXT_BUF path = lib_file_path(lib, istr(ident)); file_info_t info; if (get_file_info(tb_get(path), &info)) return info.mtime; return 0; } bool lib_had_errors(lib_t lib, ident_t ident) { lib_unit_t *lu = lib_get_aux(lib, ident); if (lu != NULL) return lu->error; return false; } ident_t lib_name(lib_t lib) { assert(lib != NULL); return lib->name; } static void lib_save_unit(lib_t lib, lib_unit_t *unit) { LOCAL_TEXT_BUF tb = tb_new(); lib_encode_file_name(unit->name, tb); fbuf_t *f = lib_fbuf_open(lib, tb_get(tb), FBUF_OUT, FBUF_CS_ADLER32); if (f == NULL) fatal("failed to create %s in library %s", tb_get(tb), istr(lib->name)); write_u8('T', f); ident_wr_ctx_t ident_ctx = ident_write_begin(f); loc_wr_ctx_t *loc_ctx = loc_write_begin(f); object_arena_t *arena = object_arena(unit->object); object_write(unit->object, f, ident_ctx, loc_ctx); if (unit->meta.cover_file != NULL) { write_u8('M', f); const size_t len = strlen(unit->meta.cover_file); fbuf_put_uint(f, len); write_raw(unit->meta.cover_file, len + 1, f); } write_u8('\0', f); loc_write_end(loc_ctx); ident_write_end(ident_ctx); uint32_t checksum; fbuf_close(f, &checksum); arena_set_checksum(arena, checksum); assert(unit->dirty); unit->dirty = false; } void lib_save(lib_t lib) { assert(lib != NULL); assert(lib->lock_fd != -1); // Should not be called in unit tests lib_ensure_writable(lib); file_write_lock(lib->lock_fd); freeze_global_arena(); for (lib_unit_t *lu = lib->units; lu; lu = lu->next) { if (lu->dirty) { if (lu->error) fatal_trace("attempting to save unit %s with errors", istr(lu->name)); else { arena_walk_obsolete_deps(object_arena(lu->object), lib_obsolete_cb, lu); lib_save_unit(lib, lu); } } } LOCAL_TEXT_BUF index_path = lib_file_path(lib, "_index"); file_info_t info; if (get_file_info(tb_get(index_path), &info)) { if (info.mtime != lib->index_mtime || info.size != lib->index_size) { // Library was updated concurrently: re-read the index while we // have the lock lib_read_index(lib); } } int index_sz = lib_index_size(lib); fbuf_t *f = lib_fbuf_open(lib, "_index", FBUF_OUT, FBUF_CS_NONE); if (f == NULL) fatal_errno("failed to create library %s index", istr(lib->name)); write_u32(INDEX_FILE_MAGIC, f); ident_wr_ctx_t ictx = ident_write_begin(f); write_u32(index_sz, f); for (lib_index_t *it = lib->index; it != NULL; it = it->next) { ident_write(it->name, ictx); write_u16(it->kind, f); } ident_write_end(ictx); fbuf_close(f, NULL); if (!get_file_info(tb_get(index_path), &info)) fatal_errno("%s", tb_get(index_path)); lib->index_mtime = info.mtime; lib->index_size = info.size; file_unlock(lib->lock_fd); } void lib_walk_index(lib_t lib, lib_index_fn_t fn, void *context) { assert(lib != NULL); lib_index_t *it; for (it = lib->index; it != NULL; it = it->next) (*fn)(lib, it->name, it->kind, context); } void lib_for_all(lib_walk_fn_t fn, void *ctx) { for (lib_list_t *it = loaded; it != NULL; it = it->next) { if (!(*fn)(it->item, ctx)) break; } } unsigned lib_index_size(lib_t lib) { assert(lib != NULL); unsigned n = 0; for (lib_index_t *it = lib->index; it != NULL; it = it->next) n++; return n; } void lib_realpath(lib_t lib, const char *name, char *buf, size_t buflen) { assert(lib != NULL); if (lib->path == NULL) checked_sprintf(buf, buflen, "." DIR_SEP "%s", name); else if (name) checked_sprintf(buf, buflen, "%s" DIR_SEP "%s", lib->path, name); else checked_sprintf(buf, buflen, "%s", lib->path); } void lib_delete(lib_t lib, const char *name) { assert(lib != NULL); LOCAL_TEXT_BUF path = lib_file_path(lib, name); if (remove(tb_get(path)) != 0 && errno != ENOENT) fatal_errno("remove: %s", name); } nvc-r1.17.1/src/lib.h000066400000000000000000000050151504111170000142460ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _LIB_H #define _LIB_H #include #include #include #include "fbuf.h" #include "prim.h" typedef struct { char *cover_file; } unit_meta_t; lib_t lib_find(ident_t name); lib_t lib_require(ident_t name) RETURNS_NONNULL; lib_t lib_new(const char *spec); lib_t lib_tmp(const char *name); void lib_free(lib_t lib); FILE *lib_fopen(lib_t lib, const char *name, const char *mode); fbuf_t *lib_fbuf_open(lib_t lib, const char *name, fbuf_mode_t mode, fbuf_cs_t csum); const char *lib_path(lib_t lib); void lib_realpath(lib_t lib, const char *name, char *buf, size_t buflen); void lib_destroy(lib_t lib); ident_t lib_name(lib_t lib); void lib_save(lib_t lib); void lib_add_search_path(const char *path); void lib_add_map(const char *name, const char *path); void lib_delete(lib_t lib, const char *name); void lib_print_search_paths(text_buf_t *tb); void lib_search_paths_to_diag(diag_t *d); typedef bool (*lib_walk_fn_t)(lib_t, void *); void lib_for_all(lib_walk_fn_t fn, void *ctx); lib_t lib_work(void); void lib_set_work(lib_t lib); void lib_put(lib_t lib, tree_t unit); void lib_put_error(lib_t lib, tree_t unit); void lib_put_vlog(lib_t lib, vlog_node_t module); void lib_put_meta(lib_t lib, tree_t unit, const unit_meta_t *meta); object_t *lib_get_generic(lib_t lib, ident_t ident, const unit_meta_t **meta); tree_t lib_get(lib_t lib, ident_t ident); tree_t lib_get_allow_error(lib_t lib, ident_t ident, bool *error); tree_t lib_get_qualified(ident_t qual); timestamp_t lib_get_mtime(lib_t lib, ident_t ident); object_t *lib_load_handler(ident_t qual); bool lib_had_errors(lib_t lib, ident_t ident); unsigned lib_index_size(lib_t lib); typedef void (*lib_index_fn_t)(lib_t lib, ident_t ident, int kind, void *ctx); void lib_walk_index(lib_t lib, lib_index_fn_t fn, void *context); #endif // _LIB_H nvc-r1.17.1/src/lower.c000066400000000000000000015004561504111170000146350ustar00rootroot00000000000000// // Copyright (C) 2014-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "cov/cov-api.h" #include "diag.h" #include "driver.h" #include "hash.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "object.h" #include "option.h" #include "phase.h" #include "psl/psl-phase.h" #include "rt/assert.h" #include "rt/rt.h" #include "type.h" #include "vcode.h" #include "vhdl/vhdl-lower.h" #include #include #include #include #include #include #include typedef enum { EXPR_LVALUE, EXPR_RVALUE, } expr_ctx_t; typedef struct _loop_stack loop_stack_t; typedef struct _lazy_cscope lazy_cscope_t; struct _loop_stack { loop_stack_t *up; ident_t name; vcode_block_t test_bb; vcode_block_t exit_bb; }; typedef struct _lazy_cscope { lazy_cscope_t *parent; lower_unit_t *owner; cover_scope_t *cscope; tree_t tree; } lazy_cscope_t; typedef enum { LOWER_NORMAL, LOWER_THUNK } lower_mode_t; #define INSTANCE_BIT 0x80000000 #define PARAM_VAR_BIT 0x40000000 typedef A(vcode_var_t) var_list_t; typedef struct _lower_unit { unit_registry_t *registry; hash_t *objects; lower_unit_t *parent; ident_t name; tree_t container; var_list_t free_temps; vcode_unit_t vunit; cover_data_t *cover; cover_scope_t *cscope; bool finished; lower_mode_t mode; unsigned deferred; lazy_cscope_t *lazy_cscope; } lower_unit_t; typedef enum { PART_ALL, PART_ELEM, PART_FIELD, PART_PUSH_FIELD, PART_PUSH_ELEM, PART_POP, PART_SLICE } part_kind_t; typedef struct { part_kind_t kind; vcode_reg_t reg; vcode_reg_t off; tree_t target; } target_part_t; typedef void (*lower_field_fn_t)(lower_unit_t *, tree_t, vcode_reg_t, vcode_reg_t, vcode_reg_t, void *); typedef void (*convert_emit_fn)(vcode_reg_t, vcode_reg_t, vcode_reg_t); typedef vcode_reg_t (*resolved_fn_t)(vcode_reg_t, vcode_reg_t); typedef struct { resolved_fn_t fn; const char *suffix; vcode_var_t var; } last_time_params_t; static vcode_reg_t lower_expr(lower_unit_t *lu, tree_t expr, expr_ctx_t ctx); static void lower_stmt(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops); static void lower_func_body(lower_unit_t *lu, object_t *obj); static void lower_proc_body(lower_unit_t *lu, object_t *obj); static vcode_reg_t lower_record_aggregate(lower_unit_t *lu, tree_t expr, bool nest, bool is_const, vcode_reg_t hint); static vcode_reg_t lower_aggregate(lower_unit_t *lu, tree_t expr, vcode_reg_t hint); static void lower_decls(lower_unit_t *lu, tree_t scope); static void lower_check_array_sizes(lower_unit_t *lu, type_t ltype, type_t rtype, vcode_reg_t lval, vcode_reg_t rval, vcode_reg_t locus); static vcode_type_t lower_alias_type(tree_t alias); static void lower_predef(lower_unit_t *lu, object_t *obj); static ident_t lower_predef_func_name(type_t type, const char *op); static void lower_generics(lower_unit_t *lu, tree_t block, tree_t primary); static vcode_reg_t lower_default_value(lower_unit_t *lu, type_t type, vcode_reg_t hint_reg); static vcode_reg_t lower_array_total_len(lower_unit_t *lu, type_t type, vcode_reg_t reg); static vcode_var_t lower_temp_var(lower_unit_t *lu, const char *prefix, vcode_type_t vtype, vcode_type_t vbounds); static void lower_release_temp(lower_unit_t *lu, vcode_var_t tmp); static vcode_reg_t lower_resolved(lower_unit_t *lu, type_t type, vcode_reg_t reg); static void lower_copy_record(lower_unit_t *lu, type_t type, vcode_reg_t dst_ptr, vcode_reg_t src_ptr, vcode_reg_t locus); static bool lower_is_signal_ref(tree_t expr); static vcode_reg_t lower_rewrap(vcode_reg_t data, vcode_reg_t bounds); static void lower_predef_field_eq_cb(lower_unit_t *lu, tree_t field, vcode_reg_t r0, vcode_reg_t r1, vcode_reg_t locus, void *context); static void lower_check_indexes(lower_unit_t *lu, type_t from, type_t to, vcode_reg_t array, tree_t where); static vcode_reg_t lower_conversion(lower_unit_t *lu, vcode_reg_t value_reg, tree_t where, type_t from, type_t to); static vcode_reg_t lower_get_type_bounds(lower_unit_t *lu, type_t type); static vcode_reg_t lower_attr_prefix(lower_unit_t *lu, tree_t prefix); static void lower_subprogram_ports(lower_unit_t *lu, tree_t body, bool params_as_vars); static vcode_type_t lower_func_result_type(type_t result); static vcode_reg_t lower_context_for_call(lower_unit_t *lu, ident_t unit_name); static void lower_driver_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t unused, vcode_reg_t locus, void *__ctx); static void lower_dependencies(lower_unit_t *lu, tree_t unit); typedef vcode_reg_t (*lower_signal_flag_fn_t)(vcode_reg_t, vcode_reg_t); typedef vcode_reg_t (*arith_fn_t)(vcode_reg_t, vcode_reg_t); #define MAX_INLINE_CONST 32 #define PUSH_DEBUG_INFO(t) \ __attribute__((cleanup(emit_debug_info), unused)) \ const loc_t _old_loc = *vcode_last_loc(); \ emit_debug_info(tree_loc((t))); \ #define PUSH_COVER_SCOPE(lu, t) \ __attribute__((cleanup(_lower_pop_cover_scope))) \ lazy_cscope_t __lcs = { \ .parent = (lu)->lazy_cscope, \ .owner = (lu), \ .tree = (t) \ }; \ (lu)->lazy_cscope = &__lcs; __attribute__((always_inline)) static inline void _lower_pop_cover_scope(lazy_cscope_t *lcs) { assert(lcs->owner->lazy_cscope == lcs); lcs->owner->lazy_cscope = lcs->parent; } static bool lower_is_const(tree_t t) { switch (tree_kind(t)) { case T_AGGREGATE: { type_t type = tree_type(t); if (type_is_record(type) && !type_const_bounds(type)) return false; const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); switch (tree_subkind(a)) { case A_NAMED: if (!lower_is_const(tree_name(a))) return false; break; case A_RANGE: case A_SLICE: { tree_t r = tree_range(a, 0); if (tree_subkind(r) == RANGE_EXPR) return false; else if (!lower_is_const(tree_left(r))) return false; else if (!lower_is_const(tree_right(r))) return false; } break; } if (!lower_is_const(tree_value(a))) return false; } return true; } case T_REF: { tree_t decl = tree_ref(t); const tree_kind_t decl_kind = tree_kind(decl); if (decl_kind == T_CONST_DECL && type_is_scalar(tree_type(t))) return tree_has_value(decl) && lower_is_const(tree_value(decl)); else return decl_kind == T_ENUM_LIT || decl_kind == T_FIELD_DECL; } case T_LITERAL: case T_STRING: return true; case T_RANGE: if (tree_subkind(t) == RANGE_EXPR) return lower_is_const(tree_value(t)); else return lower_is_const(tree_left(t)) && lower_is_const(tree_right(t)); default: return false; } } static bool needs_bounds_var(type_t type) { // A constrained array subtype with non-constant bounds should have // its bounds evaluated once and stored in a variable if (type_is_unconstrained(type)) return false; else return !type_const_bounds(type); } static int dims_for_type(type_t type) { int ndims = dimension_of(type); for (type_t e = type_elem(type); type_is_array(e) && !type_const_bounds(e); e = type_elem(e)) ndims += dimension_of(e); return ndims; } static bool have_uarray_ptr(vcode_reg_t reg) { vcode_type_t vtype = vcode_reg_type(reg); if (vtype_kind(vtype) != VCODE_TYPE_POINTER) return false; return vtype_kind(vtype_pointed(vtype)) == VCODE_TYPE_UARRAY; } static bool lower_trivially_copyable(type_t type) { if (type_is_record(type)) return type_const_bounds(type); else if (type_is_array(type)) return lower_trivially_copyable(type_elem_recur(type)); else return true; } static vcode_reg_t lower_range_expr(lower_unit_t *lu, tree_t r, int *dim) { assert(tree_subkind(r) == RANGE_EXPR); tree_t value = tree_value(r); assert(tree_kind(value) == T_ATTR_REF); if (tree_params(value) > 0) *dim = assume_int(tree_value(tree_param(value, 0))); if (tree_subkind(value) == ATTR_REVERSE_RANGE) *dim *= -1; tree_t prefix = tree_name(value); type_t type = tree_type(prefix); assert(!type_const_bounds(type)); vcode_reg_t prefix_reg = lower_attr_prefix(lu, prefix); if (prefix_reg == VCODE_INVALID_REG) return lower_get_type_bounds(lu, type); assert(vcode_reg_kind(prefix_reg) == VCODE_TYPE_UARRAY); return prefix_reg; } static vcode_reg_t lower_range_left(lower_unit_t *lu, tree_t r) { assert(tree_kind(r) == T_RANGE); type_t type = tree_type(r); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t left_reg; if (tree_subkind(r) == RANGE_EXPR) { int dim = 1; vcode_reg_t array_reg = lower_range_expr(lu, r, &dim); if (dim < 0) left_reg = emit_uarray_right(array_reg, -dim - 1); else left_reg = emit_uarray_left(array_reg, dim - 1); } else left_reg = lower_rvalue(lu, tree_left(r)); return emit_cast(vtype, vbounds, left_reg); } static vcode_reg_t lower_range_right(lower_unit_t *lu, tree_t r) { assert(tree_kind(r) == T_RANGE); type_t type = tree_type(r); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t right_reg; if (tree_subkind(r) == RANGE_EXPR) { int dim = 1; vcode_reg_t array_reg = lower_range_expr(lu, r, &dim); if (dim < 0) right_reg = emit_uarray_left(array_reg, -dim - 1); else right_reg = emit_uarray_right(array_reg, dim - 1); type_t type = tree_type(r); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); return emit_cast(vtype, vbounds, right_reg); } else right_reg = lower_rvalue(lu, tree_right(r)); return emit_cast(vtype, vbounds, right_reg); } static vcode_reg_t lower_range_dir(lower_unit_t *lu, tree_t r) { const range_kind_t rkind = tree_subkind(r); switch (rkind) { case RANGE_TO: case RANGE_DOWNTO: return emit_const(vtype_bool(), rkind); case RANGE_EXPR: { int dim = 1; vcode_reg_t array_reg = lower_range_expr(lu, r, &dim); if (dim < 0) return emit_not(emit_uarray_dir(array_reg, -dim - 1)); else return emit_uarray_dir(array_reg, dim - 1); } case RANGE_ERROR: break; } return VCODE_INVALID_REG; } static vcode_reg_t lower_array_data(vcode_reg_t reg) { vcode_type_t type = vcode_reg_type(reg); switch (vtype_kind(type)) { case VCODE_TYPE_UARRAY: return emit_unwrap(reg); case VCODE_TYPE_POINTER: if (vtype_kind(vtype_pointed(type)) == VCODE_TYPE_UARRAY) return emit_unwrap(emit_load_indirect(reg)); else return reg; case VCODE_TYPE_SIGNAL: return reg; default: vcode_dump(); fatal_trace("invalid type in lower_array_data r%d", reg); } } static bool have_array_metadata(type_t type, vcode_reg_t reg) { if (reg == VCODE_INVALID_REG) return false; else if (type_const_bounds(type)) return false; else if (type_is_unconstrained(type)) { assert(reg != VCODE_INVALID_REG); assert(vcode_reg_kind(reg) == VCODE_TYPE_UARRAY); return true; } else return vcode_reg_kind(reg) == VCODE_TYPE_UARRAY; } static vcode_reg_t lower_array_left(lower_unit_t *lu, type_t type, int dim, vcode_reg_t reg) { if (have_array_metadata(type, reg)) { type_t index_type = index_type_of(type, dim); return emit_cast(lower_type(index_type), lower_bounds(index_type), emit_uarray_left(reg, dim)); } else return lower_range_left(lu, range_of(type, dim)); } static vcode_reg_t lower_array_right(lower_unit_t *lu, type_t type, int dim, vcode_reg_t reg) { if (have_array_metadata(type, reg)) { type_t index_type = index_type_of(type, dim); return emit_cast(lower_type(index_type), lower_bounds(index_type), emit_uarray_right(reg, dim)); } else return lower_range_right(lu, range_of(type, dim)); } static vcode_reg_t lower_array_dir(lower_unit_t *lu, type_t type, int dim, vcode_reg_t reg) { if (have_array_metadata(type, reg)) return emit_uarray_dir(reg, dim); else return lower_range_dir(lu, range_of(type, dim)); } static vcode_reg_t lower_array_len(lower_unit_t *lu, type_t type, int dim, vcode_reg_t reg) { assert(type_is_array(type)); if (type_const_bounds(type)) { tree_t r = range_of(type, dim); int64_t low, high; if (!folded_bounds(r, &low, &high)) fatal_trace("type %s bounds not constant", type_pp(type)); return emit_const(vtype_offset(), MAX(high - low + 1, 0)); } else if (reg != VCODE_INVALID_REG // TODO: fix lower_default_value to not pass garbage && vcode_reg_kind(reg) == VCODE_TYPE_UARRAY) return emit_uarray_len(reg, dim); else { vcode_reg_t bounds_reg = lower_get_type_bounds(lu, type); return emit_uarray_len(bounds_reg, dim); } } static vcode_reg_t lower_array_stride(lower_unit_t *lu, type_t type, vcode_reg_t reg) { vcode_type_t voffset = vtype_offset(); vcode_reg_t stride = emit_const(voffset, 1); type_t elem = type_elem(type); if (!type_is_array(elem)) return stride; int udims = 0, dim = 0; if (have_array_metadata(type, reg)) { udims = dims_for_type(type); dim = dimension_of(type); // Skip to element dimensions assert(vtype_dims(vcode_reg_type(reg)) == udims); } do { const int edims = dimension_of(elem); for (int i = 0; i < edims; i++, dim++) { vcode_reg_t len_reg; if (dim < udims) len_reg = emit_uarray_len(reg, dim); else { tree_t r = range_of(elem, i); int64_t low, high; if (!folded_bounds(r, &low, &high)) { // TODO: this should be a fatal error but lower_type_bounds // does not work for records emit_comment("Workaround for missing record type bounds"); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); vcode_reg_t dir_reg = lower_range_dir(lu, r); len_reg = emit_range_length(left_reg, right_reg, dir_reg); } else len_reg = emit_const(voffset, MAX(high - low + 1, 0)); } stride = emit_mul(stride, len_reg); } } while (type_is_array((elem = type_elem(elem)))); emit_comment("Array of array stride is r%d", stride); return stride; } static vcode_reg_t lower_array_total_len(lower_unit_t *lu, type_t type, vcode_reg_t reg) { const int ndims = dimension_of(type); vcode_reg_t total = VCODE_INVALID_REG; for (int i = 0; i < ndims; i++) { vcode_reg_t this = lower_array_len(lu, type, i, reg); if (total == VCODE_INVALID_REG) total = this; else total = emit_mul(this, total); } type_t elem = type_elem(type); if (type_is_array(elem)) return emit_mul(total, lower_array_stride(lu, type, reg)); else return total; } static vcode_reg_t lower_type_width(lower_unit_t *lu, type_t type, vcode_reg_t reg) { if (type_is_array(type)) return lower_array_total_len(lu, type, reg); else { assert(type_is_scalar(type)); return emit_const(vtype_offset(), 1); } } static size_t lower_array_const_size(type_t type) { const int ndims = dimension_of(type); size_t size = 1; for (int i = 0; i < ndims; i++) { tree_t r = range_of(type, i); int64_t low, high; range_bounds(r, &low, &high); if (__builtin_mul_overflow(size, MAX(high - low + 1, 0), &size)) return SIZE_MAX; } type_t elem = type_elem(type); return type_is_array(elem) ? size * lower_array_const_size(elem) : size; } static vcode_type_t lower_array_type(type_t type) { type_t elem = type_elem_recur(type); vcode_type_t elem_type = lower_type(elem); vcode_type_t elem_bounds = lower_bounds(elem); if (type_const_bounds(type)) return vtype_carray(lower_array_const_size(type), elem_type, elem_bounds); else return vtype_uarray(dims_for_type(type), elem_type, elem_bounds); } vcode_type_t lower_type(type_t type) { switch (type_kind(type)) { case T_SUBTYPE: if (type_is_array(type)) return lower_array_type(type); else return lower_type(type_base(type)); case T_ARRAY: return lower_array_type(type); case T_PHYSICAL: case T_INTEGER: { tree_t r = type_dim(type, 0); int64_t low, high; const bool folded = folded_bounds(r, &low, &high); if (folded) return vtype_int(low, high); else return vtype_int(INT64_MIN, INT64_MAX); } case T_ENUM: return vtype_int(0, type_enum_literals(type) - 1); case T_RECORD: { ident_t name = type_ident(type); vcode_type_t record = vtype_find_named_record(name); if (record == VCODE_INVALID_TYPE) { vtype_named_record(name, NULL, 0); // Forward-declare the name const int nfields = type_fields(type); vcode_type_t fields[nfields]; for (int i = 0; i < nfields; i++) fields[i] = lower_type(tree_type(type_field(type, i))); record = vtype_named_record(name, fields, nfields); } return record; } case T_PROTECTED: return vtype_context(type_ident(type)); case T_FILE: return vtype_file(lower_type(type_designated(type))); case T_ACCESS: { type_t access = type_designated(type); if (type_is_array(access) && type_const_bounds(access)) return vtype_access(lower_type(type_elem_recur(access))); else return vtype_access(lower_type(access)); } case T_REAL: { tree_t r = type_dim(type, 0); double low, high; const bool folded = folded_bounds_real(r, &low, &high); if (folded) return vtype_real(low, high); else return vtype_real(-DBL_MAX, DBL_MAX); } case T_INCOMPLETE: return vtype_opaque(); default: fatal_trace("cannot lower type kind %s", type_kind_str(type_kind(type))); } } vcode_type_t lower_bounds(type_t type) { if (type_kind(type) == T_SUBTYPE) { if (type_is_integer(type) || type_is_enum(type)) { tree_t r = range_of(type, 0); int64_t low, high; if (folded_bounds(r, &low, &high)) return vtype_int(low, high); } else if (type_is_real(type)) { tree_t r = range_of(type, 0); double low, high; if (folded_bounds_real(r, &low, &high)) return vtype_real(low, high); } } if (type_is_array(type)) return lower_bounds(type_elem(type)); return lower_type(type); } static vcode_type_t lower_signal_type(type_t type) { if (type_is_array(type)) { if (type_is_homogeneous(type)) { vcode_type_t base = vtype_signal(lower_type(type_elem_recur(type))); if (type_const_bounds(type)) return base; else return vtype_uarray(dims_for_type(type), base, base); } else { vcode_type_t base = lower_signal_type(type_elem_recur(type)); if (type_const_bounds(type)) return vtype_carray(lower_array_const_size(type), base, base); else return vtype_uarray(dims_for_type(type), base, base); } } else if (type_is_record(type)) { type_t base = type_base_recur(type); ident_t name = ident_prefix(type_ident(base), ident_new("$"), '\0'); vcode_type_t record = vtype_find_named_record(name); if (record == VCODE_INVALID_TYPE) { vtype_named_record(name, NULL, 0); // Forward-declare the name const int nfields = type_fields(base); vcode_type_t fields[nfields]; for (int i = 0; i < nfields; i++) fields[i] = lower_signal_type(tree_type(type_field(base, i))); record = vtype_named_record(name, fields, nfields); } return record; } else return vtype_signal(lower_type(type)); } static vcode_reg_t lower_debug_locus(tree_t t) { return emit_debug_locus(tree_to_object(t)); } static vcode_reg_t lower_wrap_with_new_bounds(lower_unit_t *lu, type_t from_type, type_t to_type, vcode_reg_t array, vcode_reg_t data) { assert(type_is_array(from_type)); assert(type_is_array(to_type)); const int ncons = dims_for_type(to_type); vcode_dim_t dims[ncons]; int dptr = 0; int udims = 0; if (have_array_metadata(from_type, array)) { udims = dims_for_type(from_type); assert(vtype_dims(vcode_reg_type(array)) == udims); } for (; dptr < ncons; from_type = type_elem(from_type), to_type = type_elem(to_type)) { const int ndims = dimension_of(from_type); for (int i = 0; i < ndims; i++, dptr++) { if (dptr < udims) { dims[dptr].left = emit_uarray_left(array, dptr); dims[dptr].right = emit_uarray_right(array, dptr); dims[dptr].dir = emit_uarray_dir(array, dptr); } else { type_t src_type = type_is_unconstrained(to_type) ? from_type : to_type; tree_t r = range_of(src_type, i); dims[dptr].left = lower_range_left(lu, r); dims[dptr].right = lower_range_right(lu, r); dims[dptr].dir = lower_range_dir(lu, r); } } } assert(dptr == ncons); return emit_wrap(lower_array_data(data), dims, ncons); } static vcode_reg_t lower_wrap(lower_unit_t *lu, type_t type, vcode_reg_t data) { return lower_wrap_with_new_bounds(lu, type, type, data, data); } static vcode_reg_t lower_wrap_element(lower_unit_t *lu, type_t type, vcode_reg_t array, vcode_reg_t data) { assert(type_is_array(type)); assert(!type_const_bounds(type_elem(type))); assert(array != VCODE_INVALID_REG); const int ndims = dimension_of(type); const int ncons = vtype_dims(vcode_reg_type(array)) - ndims; assert(ncons > 0); vcode_dim_t dims[ncons]; for (int i = 0; i < ncons; i++) { dims[i].left = emit_uarray_left(array, ndims + i); dims[i].right = emit_uarray_right(array, ndims + i); dims[i].dir = emit_uarray_dir(array, ndims + i); } return emit_wrap(lower_array_data(data), dims, ncons); } static vcode_reg_t lower_rewrap(vcode_reg_t data, vcode_reg_t bounds) { const int ndims = vtype_dims(vcode_reg_type(bounds)); vcode_dim_t dims[ndims]; for (int i = 0; i < ndims; i++) { dims[i].left = emit_uarray_left(bounds, i); dims[i].right = emit_uarray_right(bounds, i); dims[i].dir = emit_uarray_dir(bounds, i); } return emit_wrap(data, dims, ndims); } static void lower_for_each_field_2(lower_unit_t *lu, type_t type1, type_t type2, vcode_reg_t rec1_ptr, vcode_reg_t rec2_ptr, vcode_reg_t locus, lower_field_fn_t fn, void *context) { assert(type2 == NULL || type_eq(type1, type2)); if (type_is_array(type1)) { assert(!type_is_homogeneous(type1)); // Otherwise why call this if (have_uarray_ptr(rec1_ptr)) rec1_ptr = emit_load_indirect(rec1_ptr); if (rec2_ptr != VCODE_INVALID_REG && have_uarray_ptr(rec2_ptr)) rec2_ptr = emit_load_indirect(rec2_ptr); if (locus != VCODE_INVALID_REG && rec2_ptr != VCODE_INVALID_REG) lower_check_array_sizes(lu, type1, type2, rec1_ptr, rec2_ptr, locus); vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_reg_t count1_reg = lower_array_total_len(lu, type1, rec1_ptr); vcode_reg_t data1_reg = lower_array_data(rec1_ptr); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_block_t null_reg = emit_cmp(VCODE_CMP_EQ, count1_reg, emit_const(voffset, 0)); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t ptr1_reg = emit_array_ref(data1_reg, i_reg); vcode_reg_t ptr2_reg = VCODE_INVALID_REG; if (rec2_ptr != VCODE_INVALID_REG) { vcode_reg_t data2_reg = lower_array_data(rec2_ptr); ptr2_reg = emit_array_ref(data2_reg, i_reg); } type_t elem1 = type_elem_recur(type1); type_t elem2 = type2 == NULL ? NULL : type_elem_recur(type2); lower_for_each_field_2(lu, elem1, elem2, ptr1_reg, ptr2_reg, locus, fn, context); vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1)); emit_store(next_reg, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count1_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); lower_release_temp(lu, i_var); } else { assert(vcode_reg_kind(rec1_ptr) == VCODE_TYPE_POINTER); const int nfields = type_fields(type1); for (int i = 0; i < nfields; i++) { tree_t f = type_field(type1, i); vcode_reg_t f1_reg = emit_record_ref(rec1_ptr, i); vcode_reg_t f2_reg = VCODE_INVALID_REG; if (rec2_ptr != VCODE_INVALID_REG) f2_reg = emit_record_ref(rec2_ptr, i); (*fn)(lu, f, f1_reg, f2_reg, locus, context); } } } static void lower_for_each_field(lower_unit_t *lu, type_t type, vcode_reg_t rec1_ptr, vcode_reg_t locus, lower_field_fn_t fn, void *context) { lower_for_each_field_2(lu, type, type, rec1_ptr, VCODE_INVALID_REG, locus, fn, context); } static void lower_get_scalar_type_bounds(lower_unit_t *lu, type_t type, vcode_reg_t *left_reg, vcode_reg_t *right_reg, vcode_reg_t *dir_reg) { assert(type_is_scalar(type)); tree_t r = range_of(type, 0); const range_kind_t rkind = tree_subkind(r); if (rkind != RANGE_EXPR) { tree_t left = tree_left(r), right = tree_right(r); int64_t ileft, iright; double rleft, rright; if (folded_int(left, &ileft) && folded_int(right, &iright)) { vcode_type_t vtype = lower_type(type); *left_reg = emit_const(vtype, ileft); *right_reg = emit_const(vtype, iright); *dir_reg = emit_const(vtype_bool(), rkind); return; } else if (folded_real(left, &rleft) && folded_real(right, &rright)) { vcode_type_t vtype = lower_type(type); *left_reg = emit_const_real(vtype, rleft); *right_reg = emit_const_real(vtype, rright); *dir_reg = emit_const(vtype_bool(), rkind); return; } } if (type_has_ident(type) && needs_bounds_var(type)) { vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t wrap_reg; int hops = 0; vcode_var_t var = lower_search_vcode_obj(type, lu, &hops); if (var == VCODE_INVALID_VAR) { // Type or subtype declared in package ident_t id = type_ident(type); vcode_reg_t context = emit_link_package(ident_runtil(id, '.')); vcode_type_t vuarray = vtype_uarray(1, vtype, vbounds); vcode_reg_t ptr_reg = emit_link_var(context, id, vuarray); wrap_reg = emit_load_indirect(ptr_reg); } else if (hops == 0) wrap_reg = emit_load(var); else { vcode_reg_t ptr_reg = emit_var_upref(hops, var); wrap_reg = emit_load_indirect(ptr_reg); } *left_reg = emit_cast(vtype, vbounds, emit_uarray_left(wrap_reg, 0)); *right_reg = emit_cast(vtype, vbounds, emit_uarray_right(wrap_reg, 0)); *dir_reg = emit_uarray_dir(wrap_reg, 0); } else { *left_reg = lower_range_left(lu, r); *right_reg = lower_range_right(lu, r); *dir_reg = lower_range_dir(lu, r); } } static vcode_reg_t lower_scalar_type_left(lower_unit_t *lu, type_t type) { assert(type_is_scalar(type)); tree_t r = range_of(type, 0); const range_kind_t rkind = tree_subkind(r); if (rkind != RANGE_EXPR) { tree_t left = tree_left(r); // Handle common case of constant bounds without generating the // right bound or direction double rleft; int64_t ileft; if (folded_int(left, &ileft)) return emit_const(lower_type(type), ileft); else if (folded_real(left, &rleft)) return emit_const_real(lower_type(type), rleft); } vcode_reg_t left_reg, right_reg, dir_reg; lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg); return left_reg; } static void lower_check_scalar_bounds(lower_unit_t *lu, vcode_reg_t value, type_t type, tree_t where, tree_t hint) { tree_t r = range_of(type, 0); int64_t low, high; if (folded_bounds(r, &low, &high) && low <= high) { vcode_type_t vbounds = vcode_reg_bounds(value); if (vtype_low(vbounds) >= low && vtype_high(vbounds) <= high) return; // Avoid generating debug locus } vcode_reg_t left_reg, right_reg, dir_reg; lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg); vcode_reg_t locus = lower_debug_locus(where); vcode_reg_t hint_locus = locus; if (hint != NULL && hint != where) hint_locus = lower_debug_locus(hint); emit_range_check(value, left_reg, right_reg, dir_reg, locus, hint_locus); } static bool lower_have_signal(vcode_reg_t reg) { return vtype_is_signal(vcode_reg_type(reg)); } static vcode_reg_t lower_coerce_arrays(lower_unit_t *lu, type_t from, type_t to, vcode_reg_t reg) { vcode_type_t reg_vtype = vcode_reg_type(reg); const bool have_uarray = vtype_kind(reg_vtype) == VCODE_TYPE_UARRAY; const bool need_uarray = !type_const_bounds(to); if (have_uarray && need_uarray && vtype_dims(reg_vtype) == dims_for_type(to)) return reg; else if (need_uarray) { // Need to wrap array with metadata return lower_wrap_with_new_bounds(lu, from, to, reg, reg); } else if (have_uarray && !need_uarray) { // Need to unwrap array to get raw pointer return emit_unwrap(reg); } else return reg; } static void lower_resolved_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t field_ptr, vcode_reg_t dst_ptr, vcode_reg_t locus, void *ctx) { type_t ftype = tree_type(field); if (!type_is_homogeneous(ftype)) { if (have_uarray_ptr(dst_ptr)) { // Need to allocate memory for the array assert(have_uarray_ptr(field_ptr)); vcode_reg_t field_reg = emit_load_indirect(field_ptr); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, field_reg); type_t elem = type_elem_recur(ftype); vcode_type_t vtype = lower_type(elem); vcode_type_t vbounds = lower_bounds(elem); vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, count_reg); vcode_reg_t wrap_reg = lower_wrap_with_new_bounds(lu, ftype, ftype, field_reg, mem_reg); emit_store_indirect(wrap_reg, dst_ptr); } lower_for_each_field_2(lu, ftype, ftype, field_ptr, dst_ptr, locus, lower_resolved_field_cb, ctx); } else { resolved_fn_t fn = ctx; vcode_reg_t sig_reg = emit_load_indirect(field_ptr); if (type_is_array(ftype)) { vcode_reg_t count_reg = lower_array_total_len(lu, ftype, sig_reg); vcode_reg_t r_reg = (*fn)(lower_array_data(sig_reg), count_reg); if (type_const_bounds(ftype)) emit_copy(dst_ptr, r_reg, count_reg); else { vcode_reg_t wrap_reg = lower_rewrap(r_reg, sig_reg); emit_store_indirect(wrap_reg, dst_ptr); } } else { vcode_reg_t r_reg = (*fn)(sig_reg, VCODE_INVALID_REG); emit_store_indirect(emit_load_indirect(r_reg), dst_ptr); } } } static vcode_reg_t lower_signal_record_aggregate(lower_unit_t *lu, tree_t expr) { type_t type = tree_type(expr); const int nfields = type_fields(type); const int nassocs = tree_assocs(expr); vcode_reg_t *vals LOCAL = xcalloc_array(nfields, sizeof(vcode_reg_t)); for (int i = 0; i < nfields; i++) vals[i] = VCODE_INVALID_REG; type_t *value_types LOCAL = xcalloc_array(nfields, sizeof(type)); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); tree_t value = tree_value(a); int pos = 0; switch (tree_subkind(a)) { case A_POS: pos = tree_pos(a); break; case A_NAMED: pos = tree_pos(tree_ref(tree_name(a))); break; case A_OTHERS: case A_RANGE: fatal_trace("unexpected association in record signal aggregate"); } vals[pos] = lower_lvalue(lu, value); value_types[pos] = tree_type(value); } for (int i = 0; i < nfields; i++) assert(vals[i] != VCODE_INVALID_REG); vcode_type_t vtype = lower_signal_type(type); vcode_var_t tmp_var = lower_temp_var(lu, "signalagg", vtype, vtype); vcode_reg_t mem_reg = emit_index(tmp_var, VCODE_INVALID_REG); for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i); vcode_reg_t val_reg = vals[i]; assert(lower_have_signal(val_reg)); if (type_is_record(ftype)) emit_copy(ptr_reg, val_reg, VCODE_INVALID_REG); else emit_store_indirect(val_reg, ptr_reg); } return mem_reg; } static vcode_reg_t lower_signal_array_aggregate(lower_unit_t *lu, tree_t expr) { const int nassocs = tree_assocs(expr); if (nassocs != 1) fatal_at(tree_loc(expr), "sorry, this form of parameter is not " "yet supported"); tree_t a0 = tree_assoc(expr, 0); vcode_reg_t a0_reg = lower_lvalue(lu, tree_value(a0)); type_t type = tree_type(expr); if (type_is_unconstrained(type)) { assert(tree_subkind(a0) == A_NAMED); vcode_reg_t left_reg = lower_rvalue(lu, tree_name(a0)); vcode_reg_t dir_reg = emit_const(vtype_bool(), RANGE_TO); vcode_dim_t dims[1] = { { left_reg, left_reg, dir_reg } }; return emit_wrap(a0_reg, dims, 1); } else if (!type_const_bounds(type)) return lower_wrap(lu, type, a0_reg); else return a0_reg; } static vcode_reg_t lower_subprogram_arg(lower_unit_t *lu, tree_t fcall, unsigned nth) { if (nth >= tree_params(fcall)) return VCODE_INVALID_REG; tree_t param = tree_param(fcall, nth); assert(tree_subkind(param) == P_POS); assert(tree_pos(param) == nth); tree_t value = tree_value(param); tree_t decl = tree_ref(fcall); tree_t port = tree_port(decl, nth); type_t value_type = tree_type(value); type_t port_type = tree_type(port); const class_t class = tree_class(port); const port_mode_t mode = tree_subkind(port); vcode_reg_t reg; if (class == C_SIGNAL && tree_kind(value) == T_AGGREGATE) { if (type_is_record(value_type)) reg = lower_signal_record_aggregate(lu, value); else reg = lower_signal_array_aggregate(lu, value); } else if (class == C_SIGNAL || class == C_FILE || mode != PORT_IN) reg = lower_lvalue(lu, value); else if (tree_kind(value) == T_OPEN) { tree_t def = tree_value(port); if (is_body(decl) || is_literal(def) || tree_kind(def) == T_STRING) { reg = lower_rvalue(lu, def); value_type = tree_type(def); } else { // Need to evaluate default expression in the context where it // was defined ident_t func = ident_sprintf("%s$default_%s", istr(tree_ident2(decl)), istr(tree_ident(port))); vcode_type_t vtype = lower_func_result_type(port_type); vcode_type_t vbounds = lower_bounds(port_type); vcode_reg_t context_reg; switch (tree_kind(fcall)) { case T_PROT_FCALL: case T_PROT_PCALL: if (tree_has_name(fcall)) { // XXX: evaluates prefix twice context_reg = lower_rvalue(lu, tree_name(fcall)); break; } // Fall-through default: context_reg = lower_context_for_call(lu, func); break; } vcode_reg_t args[] = { context_reg }; reg = emit_fcall(func, vtype, vbounds, args, 1); } } else reg = lower_rvalue(lu, value); if (type_is_array(value_type)) { if (!type_is_unconstrained(port_type)) { vcode_reg_t locus = lower_debug_locus(port); lower_check_array_sizes(lu, port_type, value_type, VCODE_INVALID_REG, reg, locus); } return lower_coerce_arrays(lu, value_type, port_type, reg); } else if (class == C_SIGNAL || class == C_FILE) return reg; else if (mode == PORT_OUT || !type_is_scalar(port_type)) return reg; else if (mode == PORT_INOUT) { vcode_reg_t scalar_reg = emit_load_indirect(reg); lower_check_scalar_bounds(lu, scalar_reg, port_type, value, port); return reg; } else { lower_check_scalar_bounds(lu, reg, port_type, value, port); return reg; } } static void lower_signal_flag_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t field_ptr, vcode_reg_t unused, vcode_reg_t locus, void *__ctx) { type_t ftype = tree_type(field); if (!type_is_homogeneous(ftype)) lower_for_each_field_2(lu, ftype, ftype, field_ptr, VCODE_INVALID_REG, locus, lower_signal_flag_field_cb, __ctx); else { struct { lower_signal_flag_fn_t fn; vcode_var_t result; } *args = __ctx; vcode_reg_t flag; if (type_is_array(ftype)) { vcode_reg_t nets_reg = emit_load_indirect(field_ptr); vcode_reg_t len_reg = lower_array_total_len(lu, ftype, nets_reg); flag = (*args->fn)(nets_reg, len_reg); } else { vcode_reg_t nets_reg = emit_load_indirect(field_ptr); flag = (*args->fn)(nets_reg, emit_const(vtype_offset(), 1)); } vcode_reg_t cur_reg = emit_load(args->result); vcode_reg_t new_reg = emit_or(cur_reg, flag); emit_store(new_reg, args->result); } } static vcode_reg_t lower_signal_flag(lower_unit_t *lu, tree_t ref, lower_signal_flag_fn_t fn) { vcode_reg_t nets = lower_lvalue(lu, ref); if (nets == VCODE_INVALID_REG) return emit_const(vtype_bool(), 0); type_t type = tree_type(ref); if (!type_is_homogeneous(type)) { vcode_type_t vbool = vtype_bool(); vcode_var_t tmp_var = lower_temp_var(lu, "flag", vbool, vbool); emit_store(emit_const(vbool, 0), tmp_var); struct { lower_signal_flag_fn_t fn; vcode_var_t result; } args = { fn, tmp_var }; lower_for_each_field(lu, type, nets, VCODE_INVALID_REG, lower_signal_flag_field_cb, &args); vcode_reg_t result_reg = emit_load(tmp_var); lower_release_temp(lu, tmp_var); return result_reg; } else if (type_is_array(type)) { vcode_reg_t data_reg = lower_array_data(nets); vcode_reg_t len_reg = lower_array_total_len(lu, type, nets); return (*fn)(data_reg, len_reg); } else return (*fn)(nets, emit_const(vtype_offset(), 1)); } static vcode_reg_t lower_last_value(lower_unit_t *lu, tree_t ref) { vcode_reg_t nets = lower_lvalue(lu, ref); type_t type = tree_type(ref); if (type_is_homogeneous(type)) { vcode_reg_t data_reg = emit_last_value(lower_array_data(nets), VCODE_INVALID_REG); if (vcode_reg_kind(nets) == VCODE_TYPE_UARRAY) return lower_rewrap(data_reg, nets); else return data_reg; } else { // Use a helper function to convert a record signal into a record // containing the resolved values ident_t base_id = type_ident(type_base_recur(type)); ident_t helper_func = ident_prefix(base_id, ident_new("last_value"), '$'); vcode_reg_t arg_reg = nets; if (type_is_array(type) && vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY) arg_reg = lower_wrap(lu, type, nets); vcode_type_t vrtype = lower_func_result_type(type); vcode_reg_t context_reg = lower_context_for_call(lu, helper_func); vcode_reg_t args[] = { context_reg, arg_reg }; return emit_fcall(helper_func, vrtype, vrtype, args, 2); } } static type_t lower_arg_type(tree_t fcall, int nth) { if (nth >= tree_params(fcall)) return NULL; else return tree_type(tree_value(tree_param(fcall, nth))); } static vcode_reg_t lower_wrap_string(const char *str) { const size_t len = strlen(str); vcode_reg_t chars[len + 1]; vcode_type_t ctype = vtype_char(); for (int j = 0; j < len; j++) chars[j] = emit_const(ctype, str[j]); vcode_type_t str_type = vtype_carray(len, ctype, ctype); vcode_reg_t data = emit_const_array(str_type, chars, len); vcode_dim_t dim0 = { .left = emit_const(vtype_offset(), 1), .right = emit_const(vtype_offset(), len), .dir = emit_const(vtype_bool(), RANGE_TO) }; return emit_wrap(emit_address_of(data), &dim0, 1); } static void get_hierarchical_name(text_buf_t *tb, lower_unit_t *lu, attr_kind_t which) { switch (tree_kind(lu->container)) { case T_BLOCK: case T_PACK_BODY: case T_PACKAGE: case T_PACK_INST: tb_append(tb, ':'); break; case T_PROC_BODY: case T_FUNC_BODY: case T_PROC_INST: case T_FUNC_INST: get_hierarchical_name(tb, lu->parent, which); tb_istr(tb, tree_ident(lu->container)); if (standard() >= STD_02) type_signature(tree_type(lu->container), tb); tb_append(tb, ':'); tb_downcase(tb); break; case T_PROCESS: get_hierarchical_name(tb, lu->parent, which); if (!(tree_flags(lu->container) & TREE_F_SYNTHETIC_NAME)) tb_istr(tb, tree_ident(lu->container)); tb_append(tb, ':'); tb_downcase(tb); break; case T_PROT_BODY: // LCS-2016-032 requires dynamic name if (standard() < STD_19) { get_hierarchical_name(tb, lu->parent, which); tb_istr(tb, tree_ident(lu->container)); tb_downcase(tb); } tb_append(tb, ':'); break; default: fatal_at(tree_loc(lu->container), "cannot get hierarchical name"); } } static vcode_reg_t lower_name_attr(lower_unit_t *lu, tree_t decl, attr_kind_t which) { LOCAL_TEXT_BUF tb = tb_new(); lower_unit_t *scope = lu; int extra_hops = 0; switch (tree_kind(decl)) { case T_PACK_BODY: decl = tree_primary(decl); // Fall-through case T_PACKAGE: case T_PACK_INST: tb_append(tb, ':'); tb_istr(tb, tree_ident(decl)); tb_append(tb, ':'); tb_replace(tb, '.', ':'); tb_downcase(tb); return lower_wrap_string(tb_get(tb)); case T_INSTANCE: tb_append(tb, ':'); tb_istr(tb, tree_ident(decl)); tb_downcase(tb); break; case T_BLOCK: case T_ENTITY: case T_ARCH: case T_PROT_DECL: case T_PROT_BODY: case T_FOR_GENERATE: case T_IF_GENERATE: case T_CASE_GENERATE: tb_append(tb, ':'); break; case T_PROCESS: tb_append(tb, ':'); tb_istr(tb, tree_ident(decl)); tb_append(tb, ':'); tb_downcase(tb); break; case T_PROC_DECL: case T_FUNC_DECL: case T_PROC_BODY: case T_FUNC_BODY: case T_PROC_INST: case T_FUNC_INST: { vcode_unit_t parent = unit_registry_get_parent(lu->registry, tree_ident2(decl)); if (parent != NULL) { for (; scope != NULL; scope = scope->parent, extra_hops++) { if (scope->vunit == parent) { get_hierarchical_name(tb, scope, which); tb_istr(tb, tree_ident(decl)); if (standard() >= STD_02) type_signature(tree_type(decl), tb); tb_append(tb, ':'); tb_downcase(tb); break; } } } else scope = NULL; } break; case T_VAR_DECL: case T_SIGNAL_DECL: case T_ALIAS: case T_PORT_DECL: case T_CONST_DECL: case T_GENERIC_DECL: case T_PARAM_DECL: { int obj = lower_search_vcode_obj(decl, lu, &extra_hops); if (obj != -1) { for (int i = 0; i < extra_hops; i++, scope = scope->parent); get_hierarchical_name(tb, scope, which); tb_istr(tb, tree_ident(decl)); tb_downcase(tb); } else scope = NULL; } break; default: fatal_trace("cannot handle decl kind %s in lower_name_attr", tree_kind_str(tree_kind(decl))); } if (scope == NULL) { tree_t container = tree_container(decl); if (is_package((container))) { tb_append(tb, ':'); tb_istr(tb, tree_ident(primary_unit_of(container))); tb_append(tb, ':'); tb_replace(tb, '.', ':'); tb_istr(tb, tree_ident(decl)); if (is_container(decl) || is_subprogram(decl)) tb_append(tb, ':'); tb_downcase(tb); return lower_wrap_string(tb_get(tb)); } fatal_at(tree_loc(decl), "cannot get hierachical name"); } ident_t var_name = well_known(which == ATTR_PATH_NAME ? W_PATH_NAME : W_INSTANCE_NAME); int hops = 0; vcode_var_t var = lower_search_vcode_obj(var_name, scope, &hops); assert(var != VCODE_INVALID_VAR); vcode_reg_t array_reg; if (hops + extra_hops == 0) array_reg = emit_load(var); else { vcode_reg_t ptr_reg = emit_var_upref(hops + extra_hops, var); array_reg = emit_load_indirect(ptr_reg); } if (tb_len(tb) == 0) return array_reg; vcode_type_t ctype = vtype_char(); vcode_type_t voffset = vtype_offset(); const size_t suffix_len = tb_len(tb); vcode_reg_t chars[suffix_len]; for (int j = 0; j < suffix_len; j++) chars[j] = emit_const(ctype, tb_get(tb)[j]); vcode_type_t str_type = vtype_carray(suffix_len, ctype, ctype); vcode_reg_t suffix_reg = emit_const_array(str_type, chars, suffix_len); vcode_reg_t prefix_len_reg = emit_uarray_len(array_reg, 0); vcode_reg_t suffix_len_reg = emit_const(voffset, suffix_len); vcode_reg_t total_len_reg = emit_add(prefix_len_reg, suffix_len_reg); vcode_reg_t mem_reg = emit_alloc(ctype, ctype, total_len_reg); vcode_reg_t suffix_ptr_reg = emit_array_ref(mem_reg, prefix_len_reg); emit_copy(mem_reg, emit_unwrap(array_reg), prefix_len_reg); emit_copy(suffix_ptr_reg, emit_address_of(suffix_reg), suffix_len_reg); vcode_dim_t dim0 = { .left = emit_const(voffset, 1), .right = total_len_reg, .dir = emit_const(vtype_bool(), RANGE_TO) }; return emit_wrap(mem_reg, &dim0, 1); } static vcode_reg_t lower_arith(tree_t fcall, subprogram_kind_t kind, vcode_reg_t r0, vcode_reg_t r1) { type_t type = tree_type(fcall); switch (kind) { case S_ADD: if (type_is_integer(type)) return emit_trap_add(r0, r1, lower_debug_locus(fcall)); else return emit_add(r0, r1); case S_MUL: if (type_is_integer(type)) return emit_trap_mul(r0, r1, lower_debug_locus(fcall)); else return emit_mul(r0, r1); case S_SUB: if (type_is_integer(type)) return emit_trap_sub(r0, r1, lower_debug_locus(fcall)); else return emit_sub(r0, r1); case S_MOD: return emit_mod(r0, r1); case S_REM: return emit_rem(r0, r1); case S_DIV: return emit_div(r0, r1); case S_EXP: if (type_is_integer(type)) return emit_trap_exp(r0, r1, lower_debug_locus(fcall)); else return emit_exp(r0, r1); default: fatal_trace("invalid subprogram kind %d in lower_arith", kind); } } static void lower_branch_coverage(lower_unit_t *lu, tree_t b, vcode_block_t true_bb, vcode_block_t false_bb) { assert(cover_enabled(lu->cover, COVER_MASK_BRANCH)); object_t *obj = tree_to_object(b); cover_scope_t *cs = lower_get_cover_scope(lu); cover_item_t *item = cover_add_items_for(lu->cover, cs, obj, COV_ITEM_BRANCH); if (item == NULL) return; vcode_block_t blocks[2] = { true_bb, false_bb }; for (int i = 0; i < item->consecutive; i++) { assert(blocks[i] != VCODE_INVALID_BLOCK); vcode_select_block(blocks[i]); emit_cover_branch(item[i].tag); } } static void lower_stmt_coverage(lower_unit_t *lu, tree_t stmt) { if (!cover_enabled(lu->cover, COVER_MASK_STMT)) return; cover_scope_t *cs = lower_get_cover_scope(lu); cover_item_t *item = cover_add_items_for(lu->cover, cs, tree_to_object(stmt), COV_ITEM_STMT); if (item != NULL) emit_cover_stmt(item->tag); } static void lower_toggle_coverage_cb(lower_unit_t *lu, tree_t field, vcode_reg_t field_ptr, vcode_reg_t unused, vcode_reg_t locus, void *ctx) { type_t ftype = tree_type(field); PUSH_COVER_SCOPE(lu, field); if (!type_is_homogeneous(ftype)) lower_for_each_field(lu, ftype, field_ptr, locus, lower_toggle_coverage_cb, NULL); else { cover_scope_t *cscope = lower_get_cover_scope(lu); cover_item_t *first = cover_add_items_for(lu->cover, cscope, tree_to_object(field), COV_ITEM_TOGGLE); if (first != NULL) { vcode_reg_t nets_reg = emit_load_indirect(field_ptr); emit_cover_toggle(nets_reg, first->tag); } } } static void lower_toggle_coverage(lower_unit_t *lu, tree_t decl) { assert(cover_enabled(lu->cover, COVER_MASK_TOGGLE)); int hops = 0; vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops); assert(var != VCODE_INVALID_VAR); assert(hops == 0); type_t type = tree_type(decl); if (!type_is_homogeneous(type)) { vcode_reg_t rec_ptr = emit_index(var, VCODE_INVALID_REG); lower_for_each_field(lu, type, rec_ptr, VCODE_INVALID_REG, lower_toggle_coverage_cb, NULL); } else { cover_scope_t *cscope = lower_get_cover_scope(lu); cover_item_t *first = cover_add_items_for(lu->cover, cscope, tree_to_object(decl), COV_ITEM_TOGGLE); if (first != NULL) { vcode_reg_t nets_reg = emit_load(var); emit_cover_toggle(nets_reg, first->tag); } } } static void lower_state_coverage(lower_unit_t *lu, tree_t decl) { assert(cover_enabled(lu->cover, COVER_MASK_STATE)); cover_scope_t *cscope = lower_get_cover_scope(lu); int hops = 0; vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops); assert(var != VCODE_INVALID_VAR); cover_item_t *item = cover_add_items_for(lu->cover, cscope, tree_to_object(decl), COV_ITEM_STATE); if (item) { vcode_reg_t nets_reg = emit_load(var); // If a type is sub-type, then lower bound may be non-zero. // Then value of lower bound will correspond to first coverage // tag. Need to remember the lower bound, so that run-time can // subtract lower bound to get correct index of coverage data. vcode_reg_t low_reg = emit_const(vtype_int(INT64_MIN, INT64_MAX), item->metadata); emit_cover_state(nets_reg, low_reg, item->tag); } } static vcode_reg_t lower_logical(lower_unit_t *lu, tree_t fcall, vcode_reg_t result, vcode_reg_t lhs, vcode_reg_t rhs, subprogram_kind_t builtin, unsigned unrc_msk) { if (!cover_enabled(lu->cover, COVER_MASK_EXPRESSION)) return result; cover_scope_t *cscope = lower_get_cover_scope(lu); cover_item_t *first = cover_add_items_for(lu->cover, cscope, tree_to_object(fcall), COV_ITEM_EXPRESSION); if (first == NULL) return result; cover_item_t *current = first; vcode_reg_t lhs_n = VCODE_INVALID_REG; vcode_reg_t rhs_n = VCODE_INVALID_REG; if (first->flags & COVER_FLAGS_LHS_RHS_BINS) { lhs_n = emit_not(lhs); rhs_n = emit_not(rhs); } struct { unsigned flag; vcode_reg_t lhs; vcode_reg_t rhs; } bins[] = { { COV_FLAG_00, lhs_n, rhs_n }, { COV_FLAG_01, lhs_n, rhs }, { COV_FLAG_10, lhs, rhs_n }, { COV_FLAG_11, lhs, rhs }, }; for (int i = 0; i < first->consecutive; i++) { vcode_block_t next_bb = emit_block(); vcode_block_t match_bb = emit_block(); if (unrc_msk & current->flags) current->flags |= COV_FLAG_UNREACHABLE; // Unary expressions if ((current->flags & COV_FLAG_TRUE) || (current->flags & COV_FLAG_FALSE)) { vcode_reg_t test = (current->flags & COV_FLAG_TRUE) ? result : emit_not(result); emit_cond(test, match_bb, next_bb); vcode_select_block(match_bb); emit_cover_expr(current->tag); emit_jump(next_bb); vcode_select_block(next_bb); } // Binary expressions else { for (int j = 0; j < ARRAY_LEN(bins); j++) { if (current->flags & bins[j].flag) { vcode_reg_t test = emit_and(bins[j].lhs, bins[j].rhs); emit_cond(test, match_bb, next_bb); vcode_select_block(match_bb); emit_cover_expr(current->tag); emit_jump(next_bb); vcode_select_block(next_bb); break; } } } current++; } return result; } static void lower_logic_expr_coverage(lower_unit_t *lu, tree_t fcall, vcode_reg_t *args) { cover_scope_t *cscope = lower_get_cover_scope(lu); cover_item_t *first = cover_add_items_for(lu->cover, cscope, tree_to_object(fcall), COV_ITEM_EXPRESSION); if (first == NULL) return; vcode_reg_t lhs = args[1]; vcode_reg_t rhs = args[2]; // Corresponds to how std_ulogic enum is translated vcode_type_t vc_logic = vcode_reg_type(lhs); vcode_reg_t log_0 = emit_const(vc_logic, 2); vcode_reg_t log_1 = emit_const(vc_logic, 3); struct { unsigned flag; vcode_reg_t lhs_exp; vcode_reg_t rhs_exp; } bins[] = { { COV_FLAG_00, log_0, log_0 }, { COV_FLAG_01, log_0, log_1 }, { COV_FLAG_10, log_1, log_0 }, { COV_FLAG_11, log_1, log_1 }, }; cover_item_t *current = first; for (int i = 0; i < first->consecutive; i++) { vcode_block_t next_bb = emit_block(); vcode_block_t match_bb = emit_block(); // Build logic to check combinations of LHS and RHS for (int j = 0; j < ARRAY_LEN(bins); j++) { if (current->flags & bins[j].flag) { vcode_reg_t cmp_lhs = emit_cmp(VCODE_CMP_EQ, lhs, bins[j].lhs_exp); vcode_reg_t cmp_rhs = emit_cmp(VCODE_CMP_EQ, rhs, bins[j].rhs_exp); vcode_reg_t test = emit_and(cmp_lhs, cmp_rhs); emit_cond(test, match_bb, next_bb); vcode_select_block(match_bb); emit_cover_expr(current->tag); emit_jump(next_bb); vcode_select_block(next_bb); } } current++; } } static bool lower_side_effect_free(tree_t expr) { // True if expression is side-effect free with no function calls switch (tree_kind(expr)) { case T_REF: case T_LITERAL: case T_STRING: return true; case T_FCALL: { const subprogram_kind_t kind = tree_subkind(tree_ref(expr)); if (kind == S_DIV || kind == S_DIV_PR || kind == S_DIV_RI || kind == S_REM || kind == S_MOD) return false; else if (kind == S_USER || !is_open_coded_builtin(kind)) return false; const int nparams = tree_params(expr); for (int i = 0; i < nparams; i++) { if (!lower_side_effect_free(tree_value(tree_param(expr, i)))) return false; } return true; } break; case T_RECORD_REF: case T_QUALIFIED: case T_TYPE_CONV: return lower_side_effect_free(tree_value(expr)); case T_ATTR_REF: { const attr_kind_t kind = tree_subkind(expr); if (kind == ATTR_EVENT || kind == ATTR_ACTIVE) return lower_side_effect_free(tree_name(expr)); else return false; } default: return false; } } static vcode_var_t lower_temp_var(lower_unit_t *lu, const char *prefix, vcode_type_t vtype, vcode_type_t vbounds) { vcode_var_t tmp = VCODE_INVALID_VAR; unsigned pos = 0; for (; pos < lu->free_temps.count; pos++) { tmp = lu->free_temps.items[pos]; if (vtype_eq(vcode_var_type(tmp), vtype) && vtype_eq(vcode_var_bounds(tmp), vbounds)) break; } if (pos == lu->free_temps.count) return emit_var(vtype, vbounds, ident_uniq("%s", prefix), VAR_TEMP); emit_comment("Reusing temp var %s", istr(vcode_var_name(tmp))); for (; pos < lu->free_temps.count - 1; pos++) lu->free_temps.items[pos] = lu->free_temps.items[pos + 1]; APOP(lu->free_temps); return tmp; } static void lower_release_temp(lower_unit_t *lu, vcode_var_t tmp) { assert(vcode_var_flags(tmp) & VAR_TEMP); APUSH(lu->free_temps, tmp); } static vcode_reg_t lower_short_circuit(lower_unit_t *lu, tree_t fcall, subprogram_kind_t builtin) { vcode_reg_t r0 = lower_subprogram_arg(lu, fcall, 0); int64_t value; if (vcode_reg_const(r0, &value)) { vcode_reg_t result = VCODE_INVALID_REG; switch (builtin) { case S_SCALAR_AND: result = value ? lower_subprogram_arg(lu, fcall, 1) : r0; break; case S_SCALAR_OR: result = value ? r0 : lower_subprogram_arg(lu, fcall, 1); break; case S_SCALAR_NOR: result = emit_not(value ? r0 : lower_subprogram_arg(lu, fcall, 1)); break; case S_SCALAR_NAND: result = emit_not(value ? lower_subprogram_arg(lu, fcall, 1) : r0); break; default: fatal_trace("unhandled subprogram kind %d in lower_short_circuit", builtin); } return result; } if (lower_side_effect_free(tree_value(tree_param(fcall, 1)))) { vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1); switch (builtin) { case S_SCALAR_AND: return lower_logical(lu, fcall, emit_and(r0, r1), r0, r1, builtin, 0); case S_SCALAR_OR: return lower_logical(lu, fcall, emit_or(r0, r1), r0, r1, builtin, 0); case S_SCALAR_NOR: return lower_logical(lu, fcall, emit_nor(r0, r1), r0, r1, builtin, 0); case S_SCALAR_NAND: return lower_logical(lu, fcall, emit_nand(r0, r1), r0, r1, builtin, 0); default: fatal_trace("unhandled subprogram kind %d in lower_short_circuit", builtin); } } vcode_block_t arg1_bb = emit_block(); vcode_block_t after_bb = emit_block(); vcode_type_t vbool = vtype_bool(); vcode_var_t tmp_var = lower_temp_var(lu, "shortcircuit", vbool, vbool); if (builtin == S_SCALAR_NOR || builtin == S_SCALAR_NAND) emit_store(emit_not(r0), tmp_var); else emit_store(r0, tmp_var); if (builtin == S_SCALAR_AND || builtin == S_SCALAR_NAND) emit_cond(r0, arg1_bb, after_bb); else emit_cond(r0, after_bb, arg1_bb); vcode_select_block(arg1_bb); vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1); switch (builtin) { case S_SCALAR_AND: emit_store(emit_and(r0, r1), tmp_var); break; case S_SCALAR_OR: emit_store(emit_or(r0, r1), tmp_var); break; case S_SCALAR_NOR: emit_store(emit_nor(r0, r1), tmp_var); break; case S_SCALAR_NAND: emit_store(emit_nand(r0, r1), tmp_var); break; default: fatal_trace("unhandled subprogram kind %d in lower_short_circuit", builtin); } // Automaticaly flag non-executed bins as un-reachable if configured unsigned unrc_msk = 0; if (cover_enabled(lu->cover, COVER_MASK_EXCLUDE_UNREACHABLE)) { if (builtin == S_SCALAR_AND || builtin == S_SCALAR_NAND) unrc_msk = COV_FLAG_00 | COV_FLAG_01; else unrc_msk = COV_FLAG_11 | COV_FLAG_10; } // Only emit expression coverage when also arg1 is evaluated. lower_logical(lu, fcall, emit_load(tmp_var), r0, r1, builtin, unrc_msk); emit_jump(after_bb); vcode_select_block(after_bb); vcode_reg_t result = emit_load(tmp_var); lower_release_temp(lu, tmp_var); return result; } static vcode_reg_t lower_comparison(lower_unit_t *lu, tree_t fcall, subprogram_kind_t builtin, vcode_reg_t r0, vcode_reg_t r1) { vcode_cmp_t cmp; switch (builtin) { case S_SCALAR_EQ: cmp = VCODE_CMP_EQ; break; case S_SCALAR_NEQ: cmp = VCODE_CMP_NEQ; break; case S_SCALAR_LT: cmp = VCODE_CMP_LT; break; case S_SCALAR_GT: cmp = VCODE_CMP_GT; break; case S_SCALAR_LE: cmp = VCODE_CMP_LEQ; break; case S_SCALAR_GE: cmp = VCODE_CMP_GEQ; break; default: fatal_trace("unhandled built-in comparison %d", builtin); } vcode_reg_t result = emit_cmp(cmp, r0, r1); return lower_logical(lu, fcall, result, r0, r1, builtin, 0); } static vcode_reg_t lower_builtin(lower_unit_t *lu, tree_t fcall, subprogram_kind_t builtin, vcode_reg_t *out_r0, vcode_reg_t *out_r1) { if (builtin == S_SCALAR_AND || builtin == S_SCALAR_OR || builtin == S_SCALAR_NOR || builtin == S_SCALAR_NAND) return lower_short_circuit(lu, fcall, builtin); vcode_reg_t r0 = lower_subprogram_arg(lu, fcall, 0); vcode_reg_t r1 = lower_subprogram_arg(lu, fcall, 1); if (out_r0 != NULL) *out_r0 = r0; if (out_r1 != NULL) *out_r1 = r1; type_t r0_type = lower_arg_type(fcall, 0); type_t r1_type = lower_arg_type(fcall, 1); switch (builtin) { case S_SCALAR_EQ: case S_SCALAR_NEQ: case S_SCALAR_LT: case S_SCALAR_GT: case S_SCALAR_LE: case S_SCALAR_GE: return lower_comparison(lu, fcall, builtin, r0, r1); case S_MOD: case S_REM: case S_DIV: if (type_is_integer(r1_type)) { vcode_reg_t locus = lower_debug_locus(fcall); emit_zero_check(r1, locus); } // Fall-through case S_MUL: case S_ADD: case S_SUB: return lower_arith(fcall, builtin, r0, r1); case S_EXP: { if (type_is_integer(r0_type)) { vcode_reg_t locus = lower_debug_locus(fcall); emit_exponent_check(r1, locus); } if (!type_eq(r0_type, r1_type)) r1 = emit_cast(lower_type(r0_type), lower_bounds(r0_type), r1); return lower_arith(fcall, S_EXP, r0, r1); } case S_NEGATE: { if (type_is_integer(r0_type)) { vcode_reg_t locus = lower_debug_locus(fcall); return emit_trap_neg(r0, locus); } else return emit_neg(r0); } case S_ABS: return emit_abs(r0); case S_IDENTITY: return r0; case S_SCALAR_NOT: return lower_logical(lu, fcall, emit_not(r0), r0, 0, builtin, 0); case S_SCALAR_XOR: return lower_logical(lu, fcall, emit_xor(r0, r1), r0, r1, builtin, 0); case S_SCALAR_XNOR: return lower_logical(lu, fcall, emit_xnor(r0, r1), r0, r1, builtin, 0); case S_FILE_OPEN1: { vcode_reg_t name = lower_array_data(r1); vcode_reg_t length = lower_array_len(lu, r1_type, 0, r1); vcode_reg_t kind = lower_subprogram_arg(lu, fcall, 2); emit_file_open(r0, name, length, kind, VCODE_INVALID_REG); return VCODE_INVALID_REG; } case S_FILE_OPEN2: { type_t arg_type = lower_arg_type(fcall, 2); vcode_reg_t r2 = lower_subprogram_arg(lu, fcall, 2); vcode_reg_t name = lower_array_data(r2); vcode_reg_t length = lower_array_len(lu, arg_type, 0, r2); vcode_reg_t kind = lower_subprogram_arg(lu, fcall, 3); emit_file_open(r1, name, length, kind, r0); return VCODE_INVALID_REG; } case S_FILE_WRITE: { vcode_reg_t length = VCODE_INVALID_REG; vcode_reg_t data = r1; if (type_is_array(r1_type)) { length = lower_array_total_len(lu, r1_type, r1); data = lower_array_data(r1); } emit_file_write(r0, data, length); return VCODE_INVALID_REG; } case S_FILE_READ: { vcode_reg_t inlen = VCODE_INVALID_REG; if (type_is_array(r1_type)) inlen = lower_array_total_len(lu, r1_type, r1); vcode_reg_t outlen = VCODE_INVALID_REG; if (tree_params(fcall) == 3) outlen = lower_subprogram_arg(lu, fcall, 2); vcode_reg_t data_reg = lower_array_data(r1); emit_file_read(r0, data_reg, inlen, outlen); return VCODE_INVALID_REG; } case S_DEALLOCATE: emit_deallocate(r0); return VCODE_INVALID_REG; case S_MUL_RP: case S_MUL_RI: { vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX); vcode_type_t rtype = lower_type(tree_type(fcall)); return emit_cast(rtype, rtype, emit_mul(r0, emit_cast(vreal, vreal, r1))); } case S_MUL_PR: case S_MUL_IR: { vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX); vcode_type_t rtype = lower_type(tree_type(fcall)); return emit_cast(rtype, rtype, emit_mul(emit_cast(vreal, vreal, r0), r1)); } case S_MUL_IP: { vcode_type_t rtype = lower_type(tree_type(fcall)); vcode_reg_t cast_reg = emit_cast(rtype, rtype, r0); return emit_mul(cast_reg, r1); } case S_MUL_PI: { vcode_type_t rtype = lower_type(tree_type(fcall)); vcode_reg_t cast_reg = emit_cast(rtype, rtype, r1); return emit_mul(r0, cast_reg); } case S_DIV_PR: { vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX); vcode_type_t rtype = lower_type(tree_type(fcall)); return emit_cast(rtype, rtype, emit_div(emit_cast(vreal, vreal, r0), r1)); } case S_DIV_RI: { vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX); vcode_type_t rtype = lower_type(tree_type(fcall)); vcode_reg_t locus = lower_debug_locus(fcall); emit_zero_check(r1, locus); return emit_cast(rtype, rtype, emit_div(r0, emit_cast(vreal, vreal, r1))); } case S_DIV_PP: { vcode_reg_t locus = lower_debug_locus(fcall); emit_zero_check(r1, locus); vcode_reg_t div_reg = emit_div(r0, r1); vcode_type_t rtype = lower_type(tree_type(fcall)); return emit_cast(rtype, rtype, div_reg); } case S_DIV_PI: { vcode_reg_t locus = lower_debug_locus(fcall); emit_zero_check(r1, locus); vcode_type_t rtype = lower_type(tree_type(fcall)); vcode_reg_t cast_reg = emit_cast(rtype, rtype, r1); return emit_div(r0, cast_reg); } default: fatal_at(tree_loc(fcall), "cannot lower builtin %d", builtin); } } static vcode_type_t lower_func_result_type(type_t result) { if (type_is_array(result) && type_const_bounds(result)) return vtype_pointer(lower_type(type_elem_recur(result))); else if (type_is_record(result)) return vtype_pointer(lower_type(result)); else return lower_type(result); } static vcode_type_t lower_param_type(type_t type, class_t class, port_mode_t mode) { switch (class) { case C_SIGNAL: if (type_is_homogeneous(type)) return lower_signal_type(type); else if (type_is_array(type)) { if (type_const_bounds(type)) return vtype_pointer(lower_signal_type(type_elem_recur(type))); else return lower_signal_type(type); } else return vtype_pointer(lower_signal_type(type)); case C_VARIABLE: case C_DEFAULT: case C_CONSTANT: { if (type_is_array(type)) { if (type_const_bounds(type)) return vtype_pointer(lower_type(type_elem_recur(type))); else return lower_type(type); } else if (type_is_record(type)) return vtype_pointer(lower_type(type)); else if (mode == PORT_OUT || mode == PORT_INOUT) return vtype_pointer(lower_type(type)); else return lower_type(type); } break; case C_FILE: return vtype_pointer(lower_type(type)); default: fatal_trace("unhandled class %s in lower_param_type", class_str(class)); } } static vcode_reg_t lower_context_for_call(lower_unit_t *lu, ident_t unit_name) { vcode_unit_t context = unit_registry_get_parent(lu->registry, unit_name); if (context != NULL) { vcode_unit_t ancestor = lu->vunit; int hops = 0; for (; ancestor && ancestor != context; hops++, ancestor = vcode_unit_context(ancestor)) ; if (ancestor != NULL) return emit_context_upref(hops); } ident_t context_name = get_call_context(unit_name); if (context_name == lu->name) return emit_context_upref(0); int hops; vcode_reg_t reg = lower_search_vcode_obj(context_name, lu, &hops); if (reg != VCODE_INVALID_REG && hops == 0) return reg; else if (reg != VCODE_INVALID_REG) return emit_link_package(context_name); tree_t unit = lib_get_qualified(context_name); // Handle corner case with nested packages bool nested = false; for (ident_t it = context_name; unit == NULL; unit = lib_get_qualified(it)) { it = get_call_context(it); nested = true; } if (!is_package(unit)) // Subprogram in architecture with no context return emit_null(vtype_context(context_name)); else if (nested) { vcode_reg_t parent_reg = lower_context_for_call(lu, context_name); vcode_type_t vcontext = vtype_context(context_name); vcode_reg_t var_reg = emit_link_var(parent_reg, context_name, vcontext); return emit_load_indirect(var_reg); } else if (vcode_unit_kind(lu->vunit) == VCODE_UNIT_THUNK) { if (is_well_known(context_name) < NUM_WELL_KNOWN) return emit_package_init(context_name, VCODE_INVALID_REG); else { vcode_type_t vcontext = vtype_context(context_name); return emit_undefined(vcontext, vcontext); } } else { // XXX: this should be impossible but can be triggered since // record subtypes do not currently have bounds variables return emit_link_package(context_name); } } static vcode_reg_t lower_fcall(lower_unit_t *lu, tree_t fcall, vcode_reg_t bounds_reg) { tree_t decl = tree_ref(fcall); const subprogram_kind_t kind = tree_subkind(decl); if (is_open_coded_builtin(kind)) return lower_builtin(lu, fcall, kind, NULL, NULL); const int nparams = tree_params(fcall); SCOPED_A(vcode_reg_t) args = AINIT; ident_t name = tree_ident2(decl); if (tree_kind(fcall) == T_PROT_FCALL && tree_has_name(fcall)) APUSH(args, lower_rvalue(lu, tree_name(fcall))); else APUSH(args, lower_context_for_call(lu, name)); for (int i = 0; i < nparams; i++) { vcode_reg_t arg_reg = lower_subprogram_arg(lu, fcall, i); APUSH(args, arg_reg); } if (bounds_reg != VCODE_INVALID_REG) APUSH(args, bounds_reg); type_t result = tree_type(fcall); vcode_type_t rtype = lower_func_result_type(result); vcode_type_t rbounds = lower_bounds(result); if (cover_enabled(lu->cover, COVER_MASK_EXPRESSION)) lower_logic_expr_coverage(lu, fcall, args.items); return emit_fcall(name, rtype, rbounds, args.items, args.count); } static vcode_reg_t lower_known_subtype(lower_unit_t *lu, tree_t value, type_t type, vcode_reg_t bounds_reg) { const tree_kind_t kind = tree_kind(value); switch (tree_kind(value)) { case T_FCALL: { tree_t decl = tree_ref(value); if (!(tree_flags(decl) & TREE_F_KNOWS_SUBTYPE)) return lower_rvalue(lu, value); } break; default: return lower_rvalue(lu, value); } if (type_is_array(type)) { if (bounds_reg == VCODE_INVALID_REG || vcode_reg_kind(bounds_reg) != VCODE_TYPE_UARRAY) bounds_reg = lower_get_type_bounds(lu, type); } else if (type_is_record(type)) { if (bounds_reg == VCODE_INVALID_REG) { // This is inefficient but should only occur in declarations bounds_reg = lower_default_value(lu, type, VCODE_INVALID_REG); } else if (vtype_is_signal(vcode_reg_type(bounds_reg))) bounds_reg = lower_resolved(lu, type, bounds_reg); } switch (kind) { case T_FCALL: return lower_fcall(lu, value, bounds_reg); default: should_not_reach_here(); } } static vcode_reg_t *lower_string_literal_chars(tree_t lit, int *nchars) { type_t ltype = tree_type(lit); vcode_type_t vtype = lower_type(type_elem(ltype)); *nchars = tree_chars(lit); vcode_reg_t *tmp = xmalloc_array(*nchars, sizeof(vcode_reg_t)); for (int i = 0; i < *nchars; i++) tmp[i] = emit_const(vtype, assume_int(tree_char(lit, i))); return tmp; } static vcode_reg_t lower_string_literal(tree_t lit, bool nest) { int nchars; vcode_reg_t *tmp LOCAL = lower_string_literal_chars(lit, &nchars); type_t type = tree_type(lit); vcode_type_t elem = lower_type(type_elem(type)); vcode_type_t array_type = vtype_carray(nchars, elem, elem); vcode_reg_t array_reg = emit_const_array(array_type, tmp, nchars); if (type_is_array(type) && !type_const_bounds(type)) { vcode_dim_t dim0 = { .left = emit_const(vtype_offset(), 1), .right = emit_const(vtype_offset(), nchars), .dir = emit_const(vtype_bool(), RANGE_TO) }; return emit_wrap(emit_address_of(array_reg), &dim0, 1); } else if (nest) return array_reg; else return emit_address_of(array_reg); } static vcode_reg_t lower_literal(tree_t lit) { switch (tree_subkind(lit)) { case L_PHYSICAL: assert(!tree_has_ref(lit)); // Fall-through case L_INT: return emit_const(lower_type(tree_type(lit)), tree_ival(lit)); case L_NULL: return emit_null(lower_type(tree_type(lit))); case L_REAL: return emit_const_real(lower_type(tree_type(lit)), tree_dval(lit)); default: fatal_at(tree_loc(lit), "cannot lower literal kind %d", tree_subkind(lit)); } } int lower_search_vcode_obj(void *key, lower_unit_t *scope, int *hops) { *hops = 0; for (; scope != NULL; scope = scope->parent) { const void *ptr = hash_get(scope->objects, key); const int obj = (uintptr_t)ptr - 1; if (obj != VCODE_INVALID_REG) return obj; (*hops)++; } *hops = 0; return VCODE_INVALID_REG; } void lower_put_vcode_obj(void *key, int obj, lower_unit_t *scope) { hash_put(scope->objects, key, (void *)(uintptr_t)(obj + 1)); } static vcode_var_t lower_get_var(lower_unit_t *lu, tree_t decl, int *hops) { return lower_search_vcode_obj(decl, lu, hops); } static vcode_reg_t lower_get_type_bounds(lower_unit_t *lu, type_t type) { assert(!type_is_unconstrained(type)); if (type_is_record(type)) return VCODE_INVALID_REG; // TODO else if (type_is_scalar(type)) { vcode_reg_t left_reg, right_reg, dir_reg; lower_get_scalar_type_bounds(lu, type, &left_reg, &right_reg, &dir_reg); vcode_dim_t dims[1] = { { left_reg, right_reg, dir_reg } }; vcode_reg_t null_reg = emit_null(vtype_pointer(lower_type(type))); return emit_wrap(null_reg, dims, 1); } else if (type_const_bounds(type)) { vcode_type_t velem = lower_type(type_elem_recur(type)); vcode_reg_t null_reg = emit_null(vtype_pointer(velem)); return lower_wrap(lu, type, null_reg); } else if (type_has_ident(type)) { int hops = 0; vcode_var_t var = lower_search_vcode_obj(type, lu, &hops); if (var == VCODE_INVALID_VAR) { // Type or subtype declared in package ident_t id = type_ident(type); vcode_reg_t context = emit_link_package(ident_runtil(id, '.')); vcode_reg_t ptr_reg = emit_link_var(context, id, lower_type(type)); return emit_load_indirect(ptr_reg); } else if (hops == 0) return emit_load(var); else { vcode_reg_t ptr_reg = emit_var_upref(hops, var); return emit_load_indirect(ptr_reg); } } else { vcode_type_t vtype = lower_type(type); assert(vtype_kind(vtype) == VCODE_TYPE_UARRAY); const int ndims = vtype_dims(vtype); int dptr = 0; vcode_dim_t dims[ndims]; const int tdims = dimension_of(type); for (int i = 0; i < tdims; i++, dptr++) { tree_t r = range_of(type, i); dims[dptr].left = lower_range_left(lu, r); dims[dptr].right = lower_range_right(lu, r); dims[dptr].dir = lower_range_dir(lu, r); } if (dptr < ndims) { type_t elem = type_elem(type); vcode_reg_t bounds_reg = lower_get_type_bounds(lu, elem); assert(dptr + vtype_dims(vcode_reg_type(bounds_reg)) == ndims); for (int i = 0; dptr < ndims; i++, dptr++) { dims[dptr].left = emit_uarray_left(bounds_reg, i); dims[dptr].right = emit_uarray_right(bounds_reg, i); dims[dptr].dir = emit_uarray_dir(bounds_reg, i); } } vcode_reg_t null_reg = emit_null(vtype_pointer(vtype_elem(vtype))); return emit_wrap(null_reg, dims, ndims); } } static vcode_type_t lower_var_type(tree_t decl) { if (tree_kind(decl) == T_ALIAS) return lower_alias_type(decl); else { type_t type = tree_type(decl); if (class_of(decl) == C_SIGNAL) return lower_signal_type(type); else if (type_is_array(type) && type_const_bounds(type)) return lower_type(type_elem_recur(type)); else return lower_type(type); } } static vcode_reg_t lower_link_var(lower_unit_t *lu, tree_t decl) { tree_t container = tree_container(decl); assert(!is_uninstantiated_package(container)); vcode_reg_t context; int hops; ident_t container_name = tree_ident(container); vcode_reg_t reg = lower_search_vcode_obj(container_name, lu, &hops); if (reg != VCODE_INVALID_REG) context = emit_link_package(container_name); else if (lu->mode == LOWER_THUNK) { if (tree_kind(decl) == T_CONST_DECL && tree_has_value(decl)) { tree_t value = tree_value(decl); if (lower_is_const(value)) { type_t to_type = tree_type(decl); type_t from_type = tree_type(value); emit_comment("Expanding constant %s", istr(tree_ident(decl))); vcode_reg_t value_reg = lower_rvalue(lu, value); if (type_is_array(from_type)) return lower_coerce_arrays(lu, from_type, to_type, value_reg); else return value_reg; } } if (is_well_known(container_name) < NUM_WELL_KNOWN) context = emit_package_init(container_name, VCODE_INVALID_REG); else { vcode_type_t vcontext = vtype_context(container_name); context = emit_undefined(vcontext, vcontext); } } else if (is_package(container)) { // XXX: this should be impossible but can be triggered since // record subtypes do not currently have bounds variables context = emit_link_package(container_name); } else { vcode_dump(); fatal_trace("invalid container kind %s for %s", tree_kind_str(tree_kind(container)), istr(tree_ident(decl))); } return emit_link_var(context, tree_ident(decl), lower_var_type(decl)); } static vcode_reg_t lower_var_ref(lower_unit_t *lu, tree_t decl, expr_ctx_t ctx) { type_t type = tree_type(decl); vcode_reg_t ptr_reg = VCODE_INVALID_REG; int hops = 0; vcode_var_t var = lower_get_var(lu, decl, &hops); if (var == VCODE_INVALID_VAR) ptr_reg = lower_link_var(lu, decl); // External variable else if (var & INSTANCE_BIT) { // This variable is declared in an instantiated package vcode_var_t pkg_var = var & ~INSTANCE_BIT; vcode_reg_t pkg_reg; if (hops == 0) pkg_reg = emit_load(pkg_var); else pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var)); vcode_type_t vtype = lower_var_type(decl); ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype); } else if (hops > 0) ptr_reg = emit_var_upref(hops, var); if (ptr_reg != VCODE_INVALID_REG) { if (ctx == EXPR_LVALUE) return ptr_reg; else if (type_is_scalar(type)) return emit_load_indirect(ptr_reg); else if (have_uarray_ptr(ptr_reg)) return emit_load_indirect(ptr_reg); else return ptr_reg; } else if (type_is_array(type) && type_const_bounds(type)) return emit_index(var, VCODE_INVALID_REG); else if (type_is_record(type) || type_is_protected(type)) return emit_index(var, VCODE_INVALID_REG); else if ((type_is_scalar(type) || type_is_file(type) || type_is_access(type)) && ctx == EXPR_LVALUE) return emit_index(var, VCODE_INVALID_REG); else return emit_load(var); } static vcode_reg_t lower_signal_ref(lower_unit_t *lu, tree_t decl) { int hops = 0; vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops); vcode_reg_t ptr_reg; if (var == VCODE_INVALID_VAR) { // Link to external package signal ptr_reg = lower_link_var(lu, decl); } else if (var & INSTANCE_BIT) { // This signal is declared in an instantiated package vcode_var_t pkg_var = var & ~INSTANCE_BIT; vcode_reg_t pkg_reg; if (hops == 0) pkg_reg = emit_load(pkg_var); else pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var)); vcode_type_t vtype = lower_signal_type(tree_type(decl)); ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype); } else if (hops == 0 && vtype_is_scalar(vcode_var_type(var))) return emit_load(var); else if (hops == 0) ptr_reg = emit_index(var, VCODE_INVALID_REG); else ptr_reg = emit_var_upref(hops, var); if (!vtype_is_scalar(vtype_pointed(vcode_reg_type(ptr_reg)))) return ptr_reg; return emit_load_indirect(ptr_reg); } static vcode_reg_t lower_port_ref(lower_unit_t *lu, tree_t decl) { int hops = 0; vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops); if (var == VCODE_INVALID_VAR) { vcode_dump(); fatal_trace("missing variable for port %s", istr(tree_ident(decl))); } if (hops == 0 && vtype_is_scalar(vcode_var_type(var))) return emit_load(var); vcode_reg_t ptr_reg; if (hops == 0) ptr_reg = emit_index(var, VCODE_INVALID_REG); else ptr_reg = emit_var_upref(hops, var); if (!vtype_is_scalar(vtype_pointed(vcode_reg_type(ptr_reg)))) return ptr_reg; return emit_load_indirect(ptr_reg); } static vcode_reg_t lower_param_ref(lower_unit_t *lu, tree_t decl) { int hops = 0; int obj = lower_search_vcode_obj(decl, lu, &hops); const bool is_proc_var = (obj != -1 && !!(obj & PARAM_VAR_BIT)); const bool is_invalid = obj == VCODE_INVALID_REG; obj &= ~PARAM_VAR_BIT; if (hops > 0) { // Reference to parameter in parent subprogram return emit_load_indirect(emit_var_upref(hops, obj)); } else if (is_proc_var) return emit_load(obj); else { vcode_reg_t reg = obj; const bool undefined_in_thunk = lu->mode == LOWER_THUNK && (is_invalid || tree_class(decl) == C_SIGNAL || type_is_protected(tree_type(decl))); if (undefined_in_thunk) { type_t type = tree_type(decl); emit_comment("Cannot resolve reference to %s", istr(tree_ident(decl))); if (tree_class(decl) == C_SIGNAL) return emit_undefined(lower_signal_type(type), lower_bounds(type)); else { vcode_type_t vtype = lower_type(tree_type(decl)); if (vtype_kind(vtype) == VCODE_TYPE_RECORD) return emit_undefined(vtype_pointer(vtype), lower_bounds(type)); else return emit_undefined(vtype, lower_bounds(type)); } } else if (is_invalid) { vcode_dump(); fatal_trace("missing register for parameter %s", istr(tree_ident(decl))); } return reg; } } static vcode_reg_t lower_generic_ref(lower_unit_t *lu, tree_t decl, expr_ctx_t ctx) { type_t type = tree_type(decl); int hops = 0; vcode_var_t var = lower_search_vcode_obj(decl, lu, &hops); vcode_reg_t ptr_reg = VCODE_INVALID_REG; if (var == VCODE_INVALID_VAR) { tree_t unit; if (tree_kind((unit = tree_container(decl))) == T_PACK_INST) { vcode_reg_t context = emit_link_package(tree_ident(unit)); ptr_reg = emit_link_var(context, tree_ident(decl), lower_type(type)); } else if (lu->mode == LOWER_THUNK) { type_t type = tree_type(decl); emit_comment("Cannot resolve generic %s", istr(tree_ident(decl))); return emit_undefined(lower_type(type), lower_bounds(type)); } else { vcode_dump(); fatal_trace("missing variable for generic %s in %s", istr(tree_ident(decl)), istr(tree_ident(unit))); } } else if (var & INSTANCE_BIT) { // This generic is declared in an instantiated package vcode_var_t pkg_var = var & ~INSTANCE_BIT; vcode_reg_t pkg_reg; if (hops == 0) pkg_reg = emit_load(pkg_var); else pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var)); vcode_type_t vtype = lower_var_type(decl); ptr_reg = emit_link_var(pkg_reg, tree_ident(decl), vtype); } else if (hops > 0) ptr_reg = emit_var_upref(hops, var); if (ptr_reg != VCODE_INVALID_REG) { if (type_is_scalar(type)) return emit_load_indirect(ptr_reg); else if (type_is_array(type) && !type_const_bounds(type)) return emit_load_indirect(ptr_reg); else return ptr_reg; } else if (type_is_array(type) && type_const_bounds(type)) return emit_index(var, VCODE_INVALID_REG); else if (type_is_record(type) || type_is_protected(type)) return emit_index(var, VCODE_INVALID_REG); else return emit_load(var); } static vcode_reg_t lower_alias_ref(lower_unit_t *lu, tree_t alias, expr_ctx_t ctx) { tree_t value = tree_value(alias); type_t type = tree_type(tree_has_type(alias) ? alias : value); if (tree_kind(value) == T_EXTERNAL_NAME) { // Elaborating the alias declaration already warmed the cache int hops = 0; vcode_var_t var = lower_search_vcode_obj(value, lu, &hops); assert(var != VCODE_INVALID_VAR); vcode_reg_t ptr_reg; if (hops == 0) ptr_reg = emit_index(var, VCODE_INVALID_REG); else ptr_reg = emit_var_upref(hops, var); vcode_reg_t result_reg = emit_load_indirect(ptr_reg); if (type_is_record(type)) return result_reg; else return emit_load_indirect(result_reg); } else if (!type_is_array(type)) return lower_expr(lu, value, ctx); int hops = 0; vcode_var_t var = lower_get_var(lu, alias, &hops); if (var == VCODE_INVALID_VAR) { if (lu->mode == LOWER_THUNK) return emit_undefined(lower_type(type), lower_bounds(type)); else { // External alias variable return lower_link_var(lu, alias); } } else if (var & INSTANCE_BIT) { // This alias is declared in an instantiated package vcode_var_t pkg_var = var & ~INSTANCE_BIT; vcode_reg_t pkg_reg; if (hops == 0) pkg_reg = emit_load(pkg_var); else pkg_reg = emit_load_indirect(emit_var_upref(hops, pkg_var)); vcode_type_t vtype = lower_alias_type(alias); return emit_link_var(pkg_reg, tree_ident(alias), vtype); } if (hops == 0) return emit_load(var); else return emit_load_indirect(emit_var_upref(hops, var)); } static bool lower_is_trivial_constant(tree_t decl) { if (!type_is_scalar(tree_type(decl))) return false; else if (!tree_has_value(decl)) return false; else return tree_kind(tree_value(decl)) == T_LITERAL; } static vcode_reg_t lower_ref(lower_unit_t *lu, tree_t ref, expr_ctx_t ctx) { tree_t decl = tree_ref(ref); tree_kind_t kind = tree_kind(decl); switch (kind) { case T_ENUM_LIT: if (ctx == EXPR_LVALUE) return VCODE_INVALID_REG; else return emit_const(lower_type(tree_type(decl)), tree_pos(decl)); case T_VAR_DECL: case T_FILE_DECL: return lower_var_ref(lu, decl, ctx); case T_PORT_DECL: return lower_port_ref(lu, decl); case T_PARAM_DECL: return lower_param_ref(lu, decl); case T_GENERIC_DECL: return lower_generic_ref(lu, decl, ctx); case T_SIGNAL_DECL: case T_IMPLICIT_SIGNAL: return lower_signal_ref(lu, decl); case T_TYPE_DECL: return VCODE_INVALID_REG; case T_CONST_DECL: if (ctx == EXPR_LVALUE) return VCODE_INVALID_REG; else if (lower_is_trivial_constant(decl)) return lower_expr(lu, tree_value(decl), ctx); else return lower_var_ref(lu, decl, ctx); case T_UNIT_DECL: return lower_expr(lu, tree_value(decl), ctx); case T_ALIAS: return lower_alias_ref(lu, decl, ctx); case T_FUNC_BODY: // Used to implement the "function knows result size" feature assert(standard() >= STD_19); assert(tree_flags(decl) & TREE_F_KNOWS_SUBTYPE); return lower_param_ref(lu, decl); default: vcode_dump(); fatal_trace("cannot lower reference to %s", tree_kind_str(kind)); } } static vcode_reg_t lower_external_name(lower_unit_t *lu, tree_t ref) { type_t type = tree_type(ref), base = type_base_recur(type); vcode_type_t vtype, vbounds = lower_bounds(type); if (tree_class(ref) == C_SIGNAL) vtype = lower_signal_type(base); else vtype = lower_type(base); ident_t scope; for (vcode_unit_t vu = lu->vunit;; vu = vcode_unit_context(vu)) { scope = vcode_unit_name(vu); const vunit_kind_t kind = vcode_unit_kind(vu); if (kind == VCODE_UNIT_PACKAGE || kind == VCODE_UNIT_INSTANCE) break; } int hops = 0; vcode_var_t var = lower_search_vcode_obj(ref, lu, &hops); assert(var != VCODE_INVALID_VAR); vcode_reg_t ptr_reg; if (hops == 0) ptr_reg = emit_index(var, VCODE_INVALID_REG); else ptr_reg = emit_var_upref(hops, var); vcode_reg_t cache_reg = emit_load_indirect(ptr_reg); vcode_reg_t null_reg = emit_null(vcode_reg_type(cache_reg)); vcode_reg_t test_reg = emit_cmp(VCODE_CMP_EQ, cache_reg, null_reg); vcode_block_t bind_bb = emit_block(); vcode_block_t cached_bb = emit_block(); emit_cond(test_reg, bind_bb, cached_bb); vcode_select_block(bind_bb); vcode_reg_t locus = lower_debug_locus(ref); vcode_reg_t ext_reg = emit_bind_external(locus, scope, vtype, vbounds); // The external name subtype indication does not have to exactly // match the subtype of the referenced object if (type_is_array(type) && !type_is_unconstrained(type)) { vcode_reg_t array_reg = emit_load_indirect(ext_reg); lower_check_array_sizes(lu, type, base, VCODE_INVALID_REG, array_reg, locus); } emit_store_indirect(ext_reg, ptr_reg); emit_jump(cached_bb); vcode_select_block(cached_bb); vcode_reg_t result_reg = emit_load_indirect(ptr_reg); if (type_is_record(type)) return result_reg; else return emit_load_indirect(result_reg); } static void lower_external_name_cache(tree_t t, void *ctx) { ident_t suffix = tree_ident(tree_part(t, tree_parts(t) - 1)); ident_t name = ident_prefix(suffix, ident_uniq("ename"), '.'); type_t type = tree_type(t), base = type_base_recur(type); vcode_type_t vtype, vbounds = lower_bounds(type); if (tree_class(t) == C_SIGNAL) vtype = vtype_pointer(lower_signal_type(base)); else vtype = vtype_pointer(lower_type(base)); vcode_var_t var = emit_var(vtype, vbounds, name, 0); lower_put_vcode_obj(t, var, ctx); emit_store(emit_null(vtype), var); } static vcode_reg_t lower_resolved(lower_unit_t *lu, type_t type, vcode_reg_t reg) { if (!lower_have_signal(reg)) return reg; else if (have_uarray_ptr(reg)) reg = emit_load_indirect(reg); if (type_is_homogeneous(type)) { vcode_reg_t data_reg, count_reg = VCODE_INVALID_REG; if (vcode_reg_kind(reg) == VCODE_TYPE_POINTER) data_reg = emit_resolved(emit_load_indirect(reg), count_reg); else data_reg = emit_resolved(lower_array_data(reg), count_reg); if (vcode_reg_kind(reg) == VCODE_TYPE_UARRAY) return lower_rewrap(data_reg, reg); else return data_reg; } else { // Use a helper function to convert a record signal into a record // containing the resolved values ident_t base_id = type_ident(type_base_recur(type)); ident_t helper_func = ident_prefix(base_id, ident_new("resolved"), '$'); vcode_reg_t arg_reg = reg; if (type_is_array(type)) { if (have_uarray_ptr(arg_reg)) arg_reg = emit_load_indirect(arg_reg); else if (vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY) arg_reg = lower_wrap(lu, type, reg); } vcode_type_t vrtype = lower_func_result_type(type); vcode_reg_t args[] = { lower_context_for_call(lu, helper_func), arg_reg }; return emit_fcall(helper_func, vrtype, vrtype, args, 2); } } static vcode_reg_t lower_array_off(lower_unit_t *lu, vcode_reg_t off, vcode_reg_t array, type_t type, unsigned dim) { // Convert VHDL offset 'off' to a zero-based array offset assert(vtype_kind(vcode_reg_type(off)) == VCODE_TYPE_INT); vcode_reg_t zeroed = VCODE_INVALID_REG; if (have_array_metadata(type, array)) { vcode_reg_t left_reg = lower_array_left(lu, type, dim, array); vcode_reg_t downto = emit_sub(left_reg, off); vcode_reg_t upto = emit_sub(off, left_reg); zeroed = emit_select(emit_uarray_dir(array, dim), downto, upto); } else { tree_t r = range_of(type, dim); vcode_reg_t left = lower_range_left(lu, r); switch (tree_subkind(r)) { case RANGE_TO: zeroed = emit_sub(off, left); break; case RANGE_DOWNTO: zeroed = emit_sub(left, off); break; case RANGE_EXPR: { vcode_reg_t dir = lower_range_dir(lu, r); vcode_reg_t to = emit_sub(off, left); vcode_reg_t downto = emit_sub(left, off); zeroed = emit_select(dir, downto, to); } break; } } return emit_cast(vtype_offset(), VCODE_INVALID_TYPE, zeroed); } static vcode_reg_t lower_array_ref(lower_unit_t *lu, tree_t ref, expr_ctx_t ctx) { tree_t value = tree_value(ref); vcode_reg_t array = lower_expr(lu, value, ctx); if (array == VCODE_INVALID_REG) return array; if (have_uarray_ptr(array)) array = emit_load_indirect(array); DEBUG_ONLY({ const vtype_kind_t vtkind = vtype_kind(vcode_reg_type(array)); assert(vtkind == VCODE_TYPE_POINTER || vtkind == VCODE_TYPE_UARRAY || vtkind == VCODE_TYPE_SIGNAL); }); type_t value_type = tree_type(value); const bool elide_bounds = tree_flags(ref) & TREE_F_ELIDE_BOUNDS; vcode_reg_t offset_reg = emit_const(vtype_offset(), 0); const int nparams = tree_params(ref); for (int i = 0; i < nparams; i++) { tree_t p = tree_param(ref, i); assert(tree_subkind(p) == P_POS); tree_t index = tree_value(p); vcode_reg_t index_reg = lower_rvalue(lu, index); if (!elide_bounds) { vcode_reg_t left_reg = lower_array_left(lu, value_type, i, array); vcode_reg_t right_reg = lower_array_right(lu, value_type, i, array); vcode_reg_t dir_reg = lower_array_dir(lu, value_type, i, array); vcode_reg_t locus = lower_debug_locus(index); emit_index_check(index_reg, left_reg, right_reg, dir_reg, locus, locus); } if (i > 0) { vcode_reg_t stride = lower_array_len(lu, value_type, i, array); offset_reg = emit_mul(offset_reg, stride); } vcode_reg_t zerored_reg = lower_array_off(lu, index_reg, array, value_type, i); offset_reg = emit_add(offset_reg, zerored_reg); } vcode_reg_t stride_reg = lower_array_stride(lu, value_type, array); offset_reg = emit_mul(offset_reg, stride_reg); vcode_reg_t data_reg = lower_array_data(array); vcode_reg_t ptr_reg = emit_array_ref(data_reg, offset_reg); type_t elem_type = type_elem(value_type); if (type_is_array(elem_type) && !type_const_bounds(elem_type)) return lower_wrap_element(lu, value_type, array, ptr_reg); else return ptr_reg; } static vcode_reg_t lower_array_slice(lower_unit_t *lu, tree_t slice, expr_ctx_t ctx) { tree_t value = tree_value(slice); tree_t r = tree_range(slice, 0); type_t type = tree_type(value); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); vcode_reg_t kind_reg = lower_range_dir(lu, r); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, kind_reg); vcode_reg_t array_reg = lower_expr(lu, value, ctx); int64_t null_const; const bool known_not_null = vcode_reg_const(null_reg, &null_const) && null_const == 0; vcode_block_t after_bounds_bb = VCODE_INVALID_BLOCK; if (!known_not_null) { vcode_block_t not_null_bb = emit_block(); after_bounds_bb = emit_block(); emit_cond(null_reg, after_bounds_bb, not_null_bb); vcode_select_block(not_null_bb); } vcode_reg_t aleft_reg = lower_array_left(lu, type, 0, array_reg); vcode_reg_t aright_reg = lower_array_right(lu, type, 0, array_reg); vcode_reg_t adir_reg = lower_array_dir(lu, type, 0, array_reg); vcode_reg_t locus = lower_debug_locus(r); emit_index_check(left_reg, aleft_reg, aright_reg, adir_reg, locus, locus); emit_index_check(right_reg, aleft_reg, aright_reg, adir_reg, locus, locus); emit_dir_check(kind_reg, adir_reg, locus); if (!known_not_null) { emit_jump(after_bounds_bb); vcode_select_block(after_bounds_bb); } if (array_reg == VCODE_INVALID_REG) return VCODE_INVALID_REG; vcode_reg_t stride_reg = lower_array_stride(lu, type, array_reg); vcode_reg_t data_reg = lower_array_data(array_reg); vcode_reg_t off_reg = lower_array_off(lu, left_reg, array_reg, type, 0); vcode_reg_t ptr_reg = emit_array_ref(data_reg, emit_mul(off_reg, stride_reg)); if (type_const_bounds(type)) return ptr_reg; vcode_dim_t dim0 = { .left = left_reg, .right = right_reg, .dir = kind_reg }; const int ndims = dims_for_type(type); if (ndims > 1) { assert(vcode_reg_kind(array_reg) == VCODE_TYPE_UARRAY); vcode_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(vcode_dim_t)); dims[0] = dim0; for (int i = 1; i < ndims; i++) { dims[i].left = emit_uarray_left(array_reg, i); dims[i].right = emit_uarray_right(array_reg, i); dims[i].dir = emit_uarray_dir(array_reg, i); } return emit_wrap(ptr_reg, dims, ndims); } else return emit_wrap(ptr_reg, &dim0, 1); } static inline void lower_copy_vals(vcode_reg_t *restrict dst, const vcode_reg_t *restrict src, int n) { assert(n >= 0); memcpy(dst, src, n * sizeof(vcode_reg_t)); } static vcode_reg_t *lower_const_array_aggregate(lower_unit_t *lu, tree_t t, type_t type, int dim, int *n_elems) { if ((*n_elems = lower_array_const_size(type)) == 0) return NULL; vcode_reg_t *vals = xmalloc_array(*n_elems, sizeof(vcode_reg_t)); for (int i = 0; i < *n_elems; i++) vals[i] = VCODE_INVALID_REG; tree_t r = range_of(type, dim); const int64_t left = assume_int(tree_left(r)); const bool is_downto = (tree_subkind(r) == RANGE_DOWNTO); int pos = 0; const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); tree_t value = tree_value(a); type_t value_type = tree_type(value); const tree_kind_t value_kind = tree_kind(value); vcode_reg_t tmp = VCODE_INVALID_REG; vcode_reg_t *sub = &tmp; int nsub = 1; if (value_kind == T_AGGREGATE) { if (type_is_array(value_type)) sub = lower_const_array_aggregate(lu, value, value_type, 0, &nsub); else if (type_is_record(value_type)) *sub = lower_record_aggregate(lu, value, true, lower_is_const(value), VCODE_INVALID_REG); else should_not_reach_here(); } else if (value_kind == T_STRING) sub = lower_string_literal_chars(value, &nsub); else *sub = lower_rvalue(lu, value); switch (tree_subkind(a)) { case A_POS: case A_CONCAT: lower_copy_vals(vals + pos, sub, nsub); pos += nsub; break; case A_NAMED: { const int64_t name = assume_int(tree_name(a)); const int64_t off = is_downto ? left - name : name - left; lower_copy_vals(vals + (off * nsub), sub, nsub); } break; case A_OTHERS: assert((*n_elems % nsub) == 0); for (int j = 0; j < (*n_elems / nsub); j++) { if (vals[j * nsub] == VCODE_INVALID_REG) lower_copy_vals(vals + (j * nsub), sub, nsub); } break; case A_RANGE: { tree_t r = tree_range(a, 0); int64_t r_low, r_high; range_bounds(r, &r_low, &r_high); for (int j = r_low; j <= r_high; j++) { const int64_t off = is_downto ? left - j : j - left; lower_copy_vals(vals + (off * nsub), sub, nsub); } } break; case A_SLICE: { assert(standard() >= STD_08); tree_t r = tree_range(a, 0); const int64_t r_left = assume_int(tree_left(r)); const int64_t off = is_downto ? left - r_left : r_left - left; lower_copy_vals(vals + off, sub, nsub); } break; } if (sub != &tmp) free(sub); } #ifdef DEBUG for (int i = 0; i < *n_elems; i++) { if (vals[i] == VCODE_INVALID_REG) { vcode_dump(); fatal_trace("missing constant array element %d", i); } } #endif return vals; } static vcode_reg_t lower_record_sub_aggregate(lower_unit_t *lu, tree_t value, tree_t field, bool is_const) { type_t ftype = tree_type(field); if (is_const && type_is_array(ftype)) { if (tree_kind(value) == T_STRING) return lower_string_literal(value, true); else if (lu->mode == LOWER_THUNK && !type_const_bounds(ftype)) return emit_undefined(lower_type(ftype), lower_bounds(ftype)); else { int nvals; vcode_reg_t *values LOCAL = lower_const_array_aggregate(lu, value, ftype, 0, &nvals); return emit_const_array(lower_type(ftype), values, nvals); } } else if (is_const && type_is_record(ftype)) return lower_record_aggregate(lu, value, true, true, VCODE_INVALID_REG); else if (type_is_scalar(ftype) || type_is_access(ftype)) return lower_rvalue(lu, value); else if (type_is_array(ftype)) { vcode_reg_t value_reg = lower_rvalue(lu, value); if (!type_is_unconstrained(ftype)) { vcode_reg_t locus = lower_debug_locus(field); lower_check_array_sizes(lu, ftype, tree_type(value), VCODE_INVALID_REG, value_reg, locus); } return lower_coerce_arrays(lu, tree_type(value), ftype, value_reg); } else return lower_rvalue(lu, value); } static vcode_reg_t lower_record_aggregate(lower_unit_t *lu, tree_t expr, bool nest, bool is_const, vcode_reg_t hint) { type_t type = tree_type(expr); const int nfields = type_fields(type); const int nassocs = tree_assocs(expr); vcode_reg_t *vals LOCAL = xcalloc_array(nfields, sizeof(vcode_reg_t)); for (int i = 0; i < nfields; i++) vals[i] = VCODE_INVALID_REG; tree_t *map LOCAL = xcalloc_array(nfields, sizeof(tree_t)); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); tree_t value = tree_value(a); switch (tree_subkind(a)) { case A_POS: { const int pos = tree_pos(a); tree_t field = type_field(type, pos); vals[pos] = lower_record_sub_aggregate(lu, value, field, is_const); map[pos] = value; } break; case A_NAMED: { const int pos = tree_pos(tree_ref(tree_name(a))); tree_t field = type_field(type, pos); vals[pos] = lower_record_sub_aggregate(lu, value, field, is_const); map[pos] = value; } break; case A_OTHERS: for (int j = 0; j < nfields; j++) { if (vals[j] == VCODE_INVALID_REG) { tree_t field = type_field(type, j); vals[j] = lower_record_sub_aggregate(lu, value, field, is_const); map[j] = value; } } break; default: fatal_trace("unexpected range association in record aggregate"); } } for (int i = 0; i < nfields; i++) assert(vals[i] != VCODE_INVALID_REG); if (is_const) { vcode_reg_t reg = emit_const_record(lower_type(type), vals, nfields); return nest ? reg : emit_address_of(reg); } else { vcode_type_t vtype = lower_type(type); vcode_reg_t mem_reg = hint; if (mem_reg == VCODE_INVALID_REG) { vcode_var_t tmp_var = lower_temp_var(lu, "record", vtype, vtype); mem_reg = emit_index(tmp_var, VCODE_INVALID_REG); } for (int i = 0; i < nfields; i++) { tree_t f = type_field(type, i), cons; type_t ftype = tree_type(f); vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i); if (type_is_array(ftype)) { if (have_uarray_ptr(ptr_reg)) { type_t value_type = tree_type(map[i]); vcode_reg_t wrap_reg = lower_wrap_with_new_bounds(lu, value_type, ftype, vals[i], vals[i]); if ((cons = type_constraint_for_field(type, f))) { // Element constraint may be OPEN for constants type_t ctype = tree_type(cons); if (!type_is_unconstrained(ctype)) { vcode_reg_t locus = lower_debug_locus(map[i]); lower_check_array_sizes(lu, ctype, value_type, VCODE_INVALID_REG, wrap_reg, locus); } } emit_store_indirect(wrap_reg, ptr_reg); } else { vcode_reg_t src_reg = lower_array_data(vals[i]); vcode_reg_t length_reg = lower_array_total_len(lu, ftype, vals[i]); emit_copy(ptr_reg, src_reg, length_reg); } } else if (type_is_record(ftype)) emit_copy(ptr_reg, vals[i], VCODE_INVALID_REG); else emit_store_indirect(vals[i], ptr_reg); } return mem_reg; } } static bool lower_can_use_const_rep(tree_t expr, int *length, tree_t *elem) { switch (tree_kind(expr)) { case T_AGGREGATE: { type_t type = tree_type(expr); assert(type_const_bounds(type)); tree_t a0 = tree_assoc(expr, 0); if (tree_subkind(a0) != A_OTHERS) return false; tree_t others = tree_value(a0); type_t elem_type = tree_type(others); if (type_is_array(elem_type)) { if (!lower_can_use_const_rep(others, length, elem)) return false; } else if (type_is_scalar(elem_type)) *elem = others; else return false; *length = lower_array_const_size(type); return true; } case T_STRING: { const int nchars = tree_chars(expr); if (nchars == 0) return false; tree_t c0 = tree_char(expr, 0); tree_t d0 = tree_ref(c0); for (int i = 1; i < nchars; i++) { if (tree_ref(tree_char(expr, i)) != d0) return false; } *elem = c0; *length = nchars; return true; } default: return false; } } static vcode_reg_t lower_aggregate_bounds(lower_unit_t *lu, tree_t expr, vcode_reg_t *value_regs) { // Calculate the direction and bounds of an unconstrained array // aggregate using the rules in LRM 93 7.3.2.2 type_t type = tree_type(expr); assert(type_is_unconstrained(type)); type_t index_type = index_type_of(type, 0); vcode_reg_t left_reg = VCODE_INVALID_REG, right_reg = VCODE_INVALID_REG, dir_reg = VCODE_INVALID_REG; range_kind_t dir; int64_t ileft, iright; if (calculate_aggregate_bounds(expr, &dir, &ileft, &iright)) { vcode_type_t vindex = lower_type(index_type); left_reg = emit_const(vindex, ileft); right_reg = emit_const(vindex, iright); dir_reg = emit_const(vtype_bool(), dir); } else { vcode_type_t voffset = vtype_offset(); vcode_reg_t length_reg = VCODE_INVALID_REG; const int nassocs = tree_assocs(expr); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); const assoc_kind_t akind = tree_subkind(a); switch (akind) { case A_NAMED: assert(nassocs == 1); // Must have a single association left_reg = right_reg = lower_rvalue(lu, tree_name(a)); dir_reg = lower_range_dir(lu, range_of(index_type, 0)); break; case A_OTHERS: assert(tree_ranges(a) > 0); // With relaxed rules // Fall-through case A_RANGE: case A_SLICE: { tree_t r = tree_range(a, 0); left_reg = lower_range_left(lu, r); right_reg = lower_range_right(lu, r); dir_reg = lower_range_dir(lu, r); } break; case A_POS: case A_CONCAT: { vcode_reg_t count_reg; if (akind == A_CONCAT) { type_t value_type = tree_type(tree_value(a)); count_reg = lower_array_len(lu, value_type, 0, value_regs[i]); } else count_reg = emit_const(voffset, 1); if (length_reg == VCODE_INVALID_REG) length_reg = count_reg; else length_reg = emit_add(length_reg, count_reg); } break; } } if (length_reg != VCODE_INVALID_REG) { vcode_type_t vindex = lower_type(index_type); vcode_reg_t delta_reg = emit_sub(length_reg, emit_const(voffset, 1)); vcode_reg_t cast_reg = emit_cast(vindex, vindex, delta_reg); vcode_reg_t index_right_reg; lower_get_scalar_type_bounds(lu, index_type, &left_reg, &index_right_reg, &dir_reg); right_reg = emit_add(left_reg, cast_reg); } } vcode_reg_t null_reg = emit_null(vtype_pointer(vtype_offset())); const int ndims = dims_for_type(type); if (ndims > 1) { vcode_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(vcode_dim_t)); dims[0].left = left_reg; dims[0].right = right_reg; dims[0].dir = dir_reg; tree_t a0 = tree_value(tree_assoc(expr, 0)); vcode_reg_t a0_reg = value_regs[0]; assert(a0_reg != VCODE_INVALID_REG); if (vcode_reg_kind(a0_reg) == VCODE_TYPE_UARRAY) { for (int i = 1; i < ndims; i++) { dims[i].left = emit_uarray_left(a0_reg, i - 1); dims[i].right = emit_uarray_right(a0_reg, i - 1); dims[i].dir = emit_uarray_dir(a0_reg, i - 1); } } else { type_t a0_type = tree_type(a0); for (int i = 1; i < ndims; i++) { dims[i].left = lower_array_left(lu, a0_type, i - 1, a0_reg); dims[i].right = lower_array_right(lu, a0_type, i - 1, a0_reg); dims[i].dir = lower_array_dir(lu, a0_type, i - 1, a0_reg); } } return emit_wrap(null_reg, dims, ndims); } else { vcode_dim_t dims[] = { { left_reg, right_reg, dir_reg } }; return emit_wrap(null_reg, dims, 1); } } static vcode_reg_t lower_array_aggregate(lower_unit_t *lu, tree_t expr, vcode_reg_t hint) { emit_debug_info(tree_loc(expr)); type_t type = tree_type(expr); type_t elem_type = type_elem(type); type_t scalar_elem_type = type_elem_recur(type); if (type_const_bounds(type) && lower_is_const(expr)) { int rep_size = -1; tree_t rep_elem = NULL; if (lower_can_use_const_rep(expr, &rep_size, &rep_elem) && rep_size > 1) { vcode_reg_t elem_reg = lower_rvalue(lu, rep_elem); if (hint != VCODE_INVALID_REG) { emit_memset(hint, elem_reg, emit_const(vtype_offset(), rep_size)); return hint; } else { vcode_type_t vtype = lower_type(type); vcode_reg_t array = emit_const_rep(vtype, elem_reg, rep_size); return emit_address_of(array); } } else { int nvals; vcode_reg_t *values LOCAL = lower_const_array_aggregate(lu, expr, type, 0, &nvals); vcode_reg_t array = emit_const_array(lower_type(type), values, nvals); return emit_address_of(array); } } bool all_literals = true; tree_t def_value = NULL; int last_pos = -1; const int nassocs = tree_assocs(expr); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); switch (tree_subkind(a)) { case A_POS: all_literals &= (tree_kind(tree_value(a)) == T_LITERAL); last_pos = i; break; case A_CONCAT: last_pos = i; all_literals = false; break; case A_OTHERS: def_value = tree_value(a); // Fall-through default: all_literals = false; break; } } emit_comment("Begin array aggregrate line %d", tree_loc(expr)->first_line); assert(hint == VCODE_INVALID_REG || !have_uarray_ptr(hint)); const int ndims = dimension_of(type); const bool multidim = ndims > 1; const bool array_of_array = type_is_array(elem_type); const bool is_unconstrained = type_is_unconstrained(type); vcode_reg_t *value_regs LOCAL = xmalloc_array(nassocs, sizeof(vcode_reg_t)); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); tree_t value = tree_value(a); const assoc_kind_t akind = tree_subkind(a); if (akind == A_CONCAT || akind == A_SLICE) value_regs[i] = lower_rvalue(lu, value); // Always need length else if (is_unconstrained && i == 0 && (array_of_array || multidim)) value_regs[i] = lower_rvalue(lu, value); else if (tree_kind(value) == T_AGGREGATE) value_regs[i] = VCODE_INVALID_REG; // Prefer to generate in-place else value_regs[i] = lower_rvalue(lu, value); } vcode_reg_t bounds_reg = VCODE_INVALID_REG; if (is_unconstrained) bounds_reg = lower_aggregate_bounds(lu, expr, value_regs); else if (hint != VCODE_INVALID_REG && vcode_reg_kind(hint) == VCODE_TYPE_UARRAY) bounds_reg = hint; else if (needs_bounds_var(type)) bounds_reg = lower_get_type_bounds(lu, type); vcode_reg_t dir_reg = lower_array_dir(lu, type, 0, bounds_reg); vcode_reg_t left_reg = lower_array_left(lu, type, 0, bounds_reg); vcode_reg_t right_reg = lower_array_right(lu, type, 0, bounds_reg); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg); vcode_type_t velem = lower_type(scalar_elem_type); vcode_type_t vbounds = lower_bounds(scalar_elem_type); vcode_type_t voffset = vtype_offset(); if (all_literals) { // The array has non-constant bounds but the elements are all // constants so just create a constant array and wrap it vcode_type_t velem = lower_type(elem_type); vcode_type_t vbounds = lower_bounds(elem_type); vcode_type_t vtype = vtype_carray(nassocs, velem, vbounds); vcode_reg_t array_reg = emit_const_array(vtype, value_regs, nassocs); vcode_reg_t mem_reg = emit_address_of(array_reg); vcode_reg_t nassocs_reg = emit_const(voffset, nassocs); vcode_reg_t length_reg = emit_range_length(left_reg, right_reg, dir_reg); vcode_reg_t locus = lower_debug_locus(expr); emit_length_check(length_reg, nassocs_reg, locus, VCODE_INVALID_REG); vcode_dim_t dims[1] = { { left_reg, right_reg, dir_reg } }; return emit_wrap(mem_reg, dims, 1); } int64_t null_const; bool known_not_null = false; if (vcode_reg_const(null_reg, &null_const)) { if (null_const) { vcode_type_t vtype = vtype_carray(0, velem, vbounds); vcode_reg_t mem_reg = emit_address_of(emit_const_array(vtype, NULL, 0)); if (bounds_reg != VCODE_INVALID_REG) return lower_rewrap(mem_reg, bounds_reg); else return mem_reg; } else known_not_null = true; } vcode_reg_t stride; if (array_of_array) stride = lower_array_stride(lu, type, bounds_reg); else stride = emit_const(voffset, 1); if (multidim) { for (int i = 1; i < ndims; i++) stride = emit_mul(stride, lower_array_len(lu, type, i, bounds_reg)); emit_comment("Multidimensional array stride is r%d", stride); } vcode_reg_t dim0_len = lower_array_len(lu, type, 0, bounds_reg); vcode_reg_t len_reg = emit_mul(dim0_len, stride); if (is_unconstrained) hint = VCODE_INVALID_REG; else if (hint != VCODE_INVALID_REG && def_value == NULL) { // It is not safe to use the hint location if the aggregate has // non-static bounds and those bounds were not derived from the // context in the case of an OTHERS association int64_t rlow, rhigh; if (!folded_bounds(range_of(type, 0), &rlow, &rhigh)) hint = VCODE_INVALID_REG; } vcode_reg_t mem_reg; if (hint != VCODE_INVALID_REG) mem_reg = lower_array_data(hint); else mem_reg = emit_alloc(velem, vbounds, len_reg); vcode_reg_t wrap_reg; if (type_const_bounds(type)) wrap_reg = mem_reg; else if (bounds_reg != VCODE_INVALID_REG) wrap_reg = lower_rewrap(mem_reg, bounds_reg); else if (multidim) { vcode_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(vcode_dim_t)); for (int i = 0; i < ndims; i++) { dims[i].left = lower_array_left(lu, type, i, bounds_reg); dims[i].right = lower_array_right(lu, type, i, bounds_reg); dims[i].dir = lower_array_dir(lu, type, i, bounds_reg); } wrap_reg = emit_wrap(mem_reg, dims, ndims); } else if (array_of_array) wrap_reg = lower_wrap(lu, type, mem_reg); else { vcode_dim_t dim0 = { .left = left_reg, .right = right_reg, .dir = dir_reg }; wrap_reg = emit_wrap(mem_reg, &dim0, 1); } vcode_block_t skip_bb = VCODE_INVALID_BLOCK; if (!known_not_null) { vcode_block_t not_null_bb = emit_block(); skip_bb = emit_block(); emit_cond(null_reg, skip_bb, not_null_bb); vcode_select_block(not_null_bb); } if (def_value != NULL) { // Initialise the array with the default value if (type_is_scalar(elem_type) && !multidim) { vcode_reg_t def_reg = lower_rvalue(lu, def_value); lower_check_scalar_bounds(lu, def_reg, elem_type, def_value, NULL); emit_memset(mem_reg, def_reg, len_reg); } else { vcode_block_t loop_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); // TODO: this is a hack to work around the lack of a block // ordering pass in vcode vcode_reg_t def_reg = VCODE_INVALID_REG; if (type_is_scalar(elem_type) && !multidim) def_reg = lower_rvalue(lu, def_value); emit_cond(null_reg, exit_bb, loop_bb); vcode_select_block(loop_bb); vcode_reg_t inc_reg = stride; if (inc_reg == VCODE_INVALID_REG) inc_reg = emit_const(voffset, 1); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t next_reg = emit_add(i_reg, inc_reg); emit_store(next_reg, i_var); vcode_reg_t ptr_reg = emit_array_ref(mem_reg, i_reg); if (def_reg == VCODE_INVALID_REG) { if (tree_kind(def_value) == T_AGGREGATE) { vcode_reg_t elem_reg = ptr_reg; if (array_of_array && !multidim && !type_const_bounds(elem_type)) { assert(bounds_reg != VCODE_INVALID_REG); elem_reg = lower_wrap_element(lu, type, bounds_reg, ptr_reg); } def_reg = lower_aggregate(lu, def_value, elem_reg); } else def_reg = lower_rvalue(lu, def_value); } if (array_of_array || multidim) { assert(stride != VCODE_INVALID_REG); vcode_reg_t src_reg = lower_array_data(def_reg); emit_copy(ptr_reg, src_reg, stride); } else if (type_is_record(elem_type)) emit_copy(ptr_reg, def_reg, VCODE_INVALID_REG); else emit_store_indirect(def_reg, ptr_reg); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg); emit_cond(done_reg, exit_bb, loop_bb); vcode_select_block(exit_bb); lower_release_temp(lu, i_var); } } vcode_reg_t next_pos = emit_const(voffset, 0); type_t index_type = index_type_of(type, 0); tree_t index_r = range_of(index_type, 0); vcode_type_t vindex = lower_type(index_type); vcode_reg_t low_reg = emit_select(dir_reg, right_reg, left_reg); vcode_reg_t length0_reg = VCODE_INVALID_REG; for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(expr, i); tree_t value = tree_value(a); type_t value_type = tree_type(value); const assoc_kind_t akind = tree_subkind(a); bool need_length_check = array_of_array && is_unconstrained && ndims == 1; vcode_reg_t count_reg = VCODE_INVALID_REG; if (akind == A_CONCAT || akind == A_SLICE) count_reg = lower_array_len(lu, value_type, 0, value_regs[i]); vcode_reg_t loop_bb = VCODE_INVALID_BLOCK; vcode_reg_t exit_bb = VCODE_INVALID_BLOCK; vcode_var_t tmp_var = VCODE_INVALID_VAR; vcode_reg_t off_reg = VCODE_INVALID_REG; switch (akind) { case A_POS: { off_reg = next_pos; next_pos = emit_add(off_reg, emit_const(voffset, 1)); if (i == 0 || i == last_pos) { vcode_reg_t locus = lower_debug_locus(a); vcode_reg_t hint = lower_debug_locus(index_r); vcode_reg_t off_cast_reg = emit_cast(vindex, vindex, off_reg); vcode_reg_t index_reg = emit_add(low_reg, off_cast_reg); emit_index_check(index_reg, left_reg, right_reg, dir_reg, locus, hint); } } break; case A_CONCAT: { off_reg = next_pos; next_pos = emit_add(off_reg, count_reg); if (i == 0 || i == last_pos) { vcode_reg_t locus = lower_debug_locus(a); vcode_reg_t hint = lower_debug_locus(index_r); vcode_reg_t off_cast_reg = emit_cast(vindex, vindex, off_reg); vcode_reg_t index_reg = emit_add(low_reg, off_cast_reg); if (i == 0) emit_index_check(index_reg, left_reg, right_reg, dir_reg, locus, hint); else if (i == last_pos) { vcode_reg_t one_reg = emit_const(vindex, 1); vcode_reg_t next_index_reg = emit_sub(emit_cast(vindex, vindex, count_reg), one_reg); vcode_reg_t high_index_reg = emit_add(index_reg, next_index_reg); emit_index_check(high_index_reg, left_reg, right_reg, dir_reg, locus, hint); } } need_length_check = false; } break; case A_NAMED: { tree_t name = tree_name(a); vcode_reg_t name_reg = lower_rvalue(lu, name); vcode_reg_t locus = lower_debug_locus(name); emit_index_check(name_reg, left_reg, right_reg, dir_reg, locus, locus); off_reg = lower_array_off(lu, name_reg, wrap_reg, type, 0); } break; case A_RANGE: { loop_bb = emit_block(); exit_bb = emit_block(); tree_t r = tree_range(a, 0); type_t rtype = tree_type(r); vcode_reg_t r_left_reg = lower_range_left(lu, r); vcode_reg_t r_right_reg = lower_range_right(lu, r); vcode_reg_t r_dir_reg = lower_range_dir(lu, r); vcode_reg_t locus = lower_debug_locus(r); emit_index_check(r_left_reg, left_reg, right_reg, dir_reg, locus, locus); emit_index_check(r_right_reg, left_reg, right_reg, dir_reg, locus, locus); vcode_type_t vtype = lower_type(rtype); vcode_type_t vbounds = lower_bounds(rtype); tmp_var = lower_temp_var(lu, "i", vtype, vbounds); emit_store(r_left_reg, tmp_var); vcode_reg_t null_reg = emit_range_null(r_left_reg, r_right_reg, r_dir_reg); emit_cond(null_reg, exit_bb, loop_bb); vcode_select_block(loop_bb); emit_debug_info(tree_loc(a)); vcode_reg_t i_reg = emit_load(tmp_var); off_reg = lower_array_off(lu, i_reg, wrap_reg, type, 0); } break; case A_SLICE: { tree_t r = tree_range(a, 0); vcode_reg_t r_left_reg = lower_range_left(lu, r); vcode_reg_t r_right_reg = lower_range_right(lu, r); vcode_reg_t r_dir_reg = lower_range_dir(lu, r); vcode_reg_t locus = lower_debug_locus(a); emit_index_check(r_left_reg, left_reg, right_reg, dir_reg, locus, locus); emit_index_check(r_right_reg, left_reg, right_reg, dir_reg, locus, locus); vcode_reg_t expect_reg = emit_range_length(r_left_reg, r_right_reg, r_dir_reg); emit_length_check(expect_reg, count_reg, locus, VCODE_INVALID_REG); vcode_reg_t dir_cmp_reg = emit_cmp(VCODE_CMP_EQ, dir_reg, r_dir_reg); vcode_reg_t base_reg = emit_select(dir_cmp_reg, r_left_reg, r_right_reg); off_reg = lower_array_off(lu, base_reg, wrap_reg, type, 0); need_length_check = false; } break; case A_OTHERS: // Handled above continue; } if (stride != VCODE_INVALID_REG) off_reg = emit_mul(off_reg, stride); vcode_reg_t ptr_reg = emit_array_ref(mem_reg, off_reg); if (value_regs[i] == VCODE_INVALID_REG) { // Prefer generating aggregates in-place assert(tree_kind(value) == T_AGGREGATE); value_regs[i] = lower_aggregate(lu, value, ptr_reg); } if (need_length_check) { vcode_reg_t length_reg = count_reg; if (length_reg == VCODE_INVALID_REG) length_reg = lower_array_len(lu, value_type, 0, value_regs[i]); if (i == 0) length0_reg = length_reg; else { vcode_reg_t locus = lower_debug_locus(a); emit_length_check(length0_reg, length_reg, locus, emit_const(voffset, 0)); } } if (count_reg != VCODE_INVALID_REG) { vcode_reg_t total_reg = count_reg; if (stride != VCODE_INVALID_REG) total_reg = emit_mul(count_reg, stride); vcode_reg_t src_reg = lower_array_data(value_regs[i]); emit_copy(ptr_reg, src_reg, total_reg); } else if (array_of_array || multidim) { assert(stride != VCODE_INVALID_REG); vcode_reg_t src_reg = lower_array_data(value_regs[i]); emit_copy(ptr_reg, src_reg, stride); } else if (type_is_record(elem_type)) emit_copy(ptr_reg, value_regs[i], VCODE_INVALID_REG); else if (type_is_scalar(elem_type)) { lower_check_scalar_bounds(lu, value_regs[i], elem_type, value, NULL); emit_store_indirect(value_regs[i], ptr_reg); } else emit_store_indirect(value_regs[i], ptr_reg); if (loop_bb != VCODE_INVALID_BLOCK) { assert(tree_subkind(a) == A_RANGE); tree_t r = tree_range(a, 0); vcode_type_t vtype = lower_type(tree_type(r)); vcode_reg_t r_dir_reg = lower_range_dir(lu, r); vcode_reg_t step_down = emit_const(vtype, -1); vcode_reg_t step_up = emit_const(vtype, 1); vcode_reg_t step_reg = emit_select(r_dir_reg, step_down, step_up); vcode_reg_t i_reg = emit_load(tmp_var); vcode_reg_t next_reg = emit_add(i_reg, step_reg); emit_store(next_reg, tmp_var); vcode_reg_t r_right_reg = lower_range_right(lu, r); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_reg, r_right_reg); emit_cond(done_reg, exit_bb, loop_bb); vcode_select_block(exit_bb); } if (tmp_var != VCODE_INVALID_VAR) lower_release_temp(lu, tmp_var); } if (skip_bb != VCODE_INVALID_BLOCK) { emit_jump(skip_bb); vcode_select_block(skip_bb); } return wrap_reg; } static vcode_reg_t lower_aggregate(lower_unit_t *lu, tree_t expr, vcode_reg_t hint) { type_t type = tree_type(expr); if (type_is_record(type)) return lower_record_aggregate(lu, expr, false, lower_is_const(expr), hint); else if (type_is_array(type)) return lower_array_aggregate(lu, expr, hint); else fatal_trace("invalid type %s in lower_aggregate", type_pp(type)); } static vcode_reg_t lower_record_ref(lower_unit_t *lu, tree_t expr, expr_ctx_t ctx) { tree_t value = tree_value(expr); type_t type = tree_type(value); vcode_reg_t record = lower_expr(lu, value, ctx); const int index = tree_pos(tree_ref(expr)); type_t ftype = tree_type(type_field(type, index)); vcode_reg_t f_reg = emit_record_ref(record, index); if (lower_have_signal(f_reg) && type_is_homogeneous(ftype)) return emit_load_indirect(f_reg); else if (type_is_array(ftype) && !type_const_bounds(ftype)) { // The field type may be unconstrained but this particular // instance has a record element constraint vcode_reg_t array = emit_load_indirect(f_reg); if (type_const_bounds(tree_type(expr))) return lower_array_data(array); else return array; } else return f_reg; } static vcode_reg_t lower_prot_ref(lower_unit_t *lu, tree_t expr) { assert(standard() >= STD_19); vcode_reg_t prefix = lower_rvalue(lu, tree_value(expr)); vcode_type_t vtype = lower_type(tree_type(expr)); return emit_link_var(prefix, tree_ident(expr), vtype); } static vcode_reg_t lower_protected_init(lower_unit_t *lu, type_t type, tree_t decl) { vcode_reg_t names[2] = { VCODE_INVALID_REG, VCODE_INVALID_REG }; if (standard() >= STD_19) { // Pass path name and instance names as arguments for LCS-2016-032 LOCAL_TEXT_BUF tb = tb_new(); static const attr_kind_t which[2] = { ATTR_PATH_NAME, ATTR_INSTANCE_NAME }; for (int i = 0; i < 2; i++) { tb_rewind(tb); get_hierarchical_name(tb, lu, which[i]); if (decl != NULL) tb_istr(tb, tree_ident(decl)); tb_append(tb, ':'); tb_downcase(tb); names[i] = lower_name_attr(lu, decl ?: lu->container, which[i]); } } vcode_type_t vtype = lower_type(type); vcode_reg_t context_reg = lower_context_for_call(lu, type_ident(type)); return emit_protected_init(vtype, context_reg, names[0], names[1]); } static void lower_new_record(lower_unit_t *lu, type_t type, vcode_reg_t dst_ptr, vcode_reg_t src_ptr) { if (src_ptr == dst_ptr) return; else if (type_const_bounds(type)) emit_copy(dst_ptr, src_ptr, VCODE_INVALID_REG); else { ident_t base_id = type_ident(type_base_recur(type)); ident_t helper_func = ident_prefix(base_id, ident_new("new"), '$'); vcode_reg_t args[] = { lower_context_for_call(lu, helper_func), dst_ptr, src_ptr, }; emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, args, ARRAY_LEN(args)); } } static vcode_reg_t lower_new(lower_unit_t *lu, tree_t expr) { tree_t qual = tree_value(expr); assert(tree_kind(qual) == T_QUALIFIED); type_t type = tree_type(qual); if (type_is_array(type)) { type_t value_type = type, result_type = type_designated(tree_type(expr)); type_t elem = type_elem_recur(type); const bool wrap_result = !type_const_bounds(result_type); const bool wrap_value = !type_const_bounds(type); type_t alloc_type = wrap_result ? result_type : elem; vcode_reg_t init_reg = VCODE_INVALID_REG, bounds_reg = VCODE_INVALID_REG; tree_t value = NULL; if (tree_has_value(qual)) { value = tree_value(qual); value_type = tree_type(value); const bool in_place_aggregate = tree_kind(value) == T_AGGREGATE && type_const_bounds(value_type); if (!in_place_aggregate) init_reg = bounds_reg = lower_rvalue(lu, qual); } else if (wrap_value) bounds_reg = lower_get_type_bounds(lu, type); vcode_reg_t length_reg = lower_array_total_len(lu, value_type, bounds_reg); vcode_reg_t mem_reg = emit_new(lower_type(alloc_type), length_reg); vcode_reg_t all_reg = emit_all(mem_reg); vcode_reg_t data_reg = lower_array_data(all_reg); vcode_reg_t array_reg = all_reg; if (wrap_value) array_reg = lower_wrap_with_new_bounds(lu, value_type, type, bounds_reg, data_reg); if (value == NULL) init_reg = lower_default_value(lu, type, array_reg); else if (init_reg == VCODE_INVALID_REG) init_reg = lower_aggregate(lu, value, data_reg); if (init_reg != array_reg) { vcode_reg_t src_reg = lower_array_data(init_reg); emit_copy(data_reg, src_reg, length_reg); } if (wrap_result) { // Need to initialise the array bounds vcode_reg_t meta_reg = lower_wrap_with_new_bounds(lu, value_type, result_type, bounds_reg, data_reg); emit_store_indirect(meta_reg, all_reg); } return mem_reg; } else if (type_is_record(type)) { vcode_reg_t result_reg = emit_new(lower_type(type), VCODE_INVALID_REG); vcode_reg_t all_reg = emit_all(result_reg); vcode_reg_t init_reg; if (tree_has_value(qual)) { tree_t value = tree_value(qual); if (tree_kind(value) == T_AGGREGATE && type_const_bounds(type)) init_reg = lower_aggregate(lu, value, all_reg); else init_reg = lower_rvalue(lu, qual); } else init_reg = lower_default_value(lu, type, all_reg); lower_new_record(lu, type, all_reg, init_reg); return result_reg; } else if (type_is_protected(type)) { vcode_reg_t obj_reg = lower_protected_init(lu, type, NULL); vcode_reg_t result_reg = emit_new(lower_type(type), VCODE_INVALID_REG); vcode_reg_t all_reg = emit_all(result_reg); emit_store_indirect(obj_reg, all_reg); return result_reg; } else { vcode_reg_t result_reg = emit_new(lower_type(type), VCODE_INVALID_REG); vcode_reg_t all_reg = emit_all(result_reg); vcode_reg_t init_reg; if (tree_has_value(qual)) init_reg = lower_rvalue(lu, qual); else init_reg = lower_default_value(lu, type, VCODE_INVALID_REG); emit_store_indirect(init_reg, all_reg); return result_reg; } } static vcode_reg_t lower_incomplete_access(vcode_reg_t in_reg, type_t type) { assert(vcode_reg_kind(in_reg) == VCODE_TYPE_ACCESS); vcode_type_t pointed = vtype_pointed(vcode_reg_type(in_reg)); const bool have_opaque = vtype_kind(pointed) == VCODE_TYPE_OPAQUE; const bool have_incomplete = type_is_incomplete(type); if (have_incomplete ^ have_opaque) { vcode_type_t ptr_type = vtype_access(lower_type(type)); return emit_cast(ptr_type, ptr_type, in_reg); } return in_reg; } static vcode_reg_t lower_all(lower_unit_t *lu, tree_t all, expr_ctx_t ctx) { type_t type = tree_type(all); vcode_reg_t access_reg = lower_rvalue(lu, tree_value(all)); emit_null_check(access_reg, lower_debug_locus(all)); access_reg = lower_incomplete_access(access_reg, tree_type(all)); vcode_reg_t all_reg = emit_all(access_reg); if (type_is_array(type) && !type_const_bounds(type)) return emit_load_indirect(all_reg); else return all_reg; } static void lower_convert_record(lower_unit_t *lu, vcode_reg_t value_reg, tree_t where, type_t from, type_t to, vcode_reg_t ptr_reg) { const int to_nf = type_fields(to); const int from_nf = type_fields(from); for (int i = 0; i < to_nf; i++) { tree_t to_f = type_field(to, i); type_t to_type = tree_type(to_f), from_type = NULL; ident_t name = tree_ident(to_f); vcode_reg_t from_reg = VCODE_INVALID_REG; for (int j = 0; j < from_nf; j++) { tree_t f = type_field(from, j); if (tree_ident(f) == name) { from_reg = emit_record_ref(value_reg, j); from_type = tree_type(f); break; } } assert(from_reg != VCODE_INVALID_REG); if (have_uarray_ptr(from_reg)) from_reg = emit_load_indirect(from_reg); vcode_reg_t to_reg = emit_record_ref(ptr_reg, i); if (type_is_array(to_type)) { vcode_reg_t conv_reg = lower_conversion(lu, from_reg, where, from_type, to_type); // Shallow copy is ok here as the result of this conversion is // effectively constant if (have_uarray_ptr(to_reg)) { assert(vcode_reg_kind(conv_reg) == VCODE_TYPE_UARRAY); emit_store_indirect(conv_reg, to_reg); } else { vcode_reg_t data_reg = lower_array_data(conv_reg); vcode_reg_t count_reg = lower_array_total_len(lu, to_type, conv_reg); emit_copy(to_reg, data_reg, count_reg); } } else if (type_is_record(to_type)) lower_convert_record(lu, from_reg, where, from_type, to_type, to_reg); else { vcode_reg_t elem_reg = emit_load_indirect(from_reg); vcode_reg_t conv_reg = lower_conversion(lu, elem_reg, where, from_type, to_type); emit_store_indirect(conv_reg, to_reg); } } } static vcode_reg_t lower_conversion(lower_unit_t *lu, vcode_reg_t value_reg, tree_t where, type_t from, type_t to) { type_kind_t from_k = type_kind(type_base_recur(from)); type_kind_t to_k = type_kind(type_base_recur(to)); if (from_k == T_REAL && to_k == T_INTEGER) { vcode_type_t vtype = lower_type(to); vcode_type_t vbounds = vtype_int(INT64_MIN, INT64_MAX); vcode_reg_t cast = emit_cast(vtype, vbounds, value_reg); lower_check_scalar_bounds(lu, cast, to, where, NULL); return cast; } else if (from_k == T_INTEGER && to_k == T_REAL) { vcode_type_t vtype = lower_type(to); vcode_type_t vbounds = vtype_real((double)INT64_MIN, (double)INT64_MAX); return emit_cast(vtype, vbounds, value_reg); } else if (from_k == T_ARRAY && to_k == T_ARRAY) { type_t from_e = type_elem_recur(from); type_t to_e = type_elem_recur(to); vcode_reg_t result_reg = value_reg; if (standard() >= STD_08 && !type_eq(from_e, to_e)) { // VHDL-2008 allows closely related element types which might // need conversion and/or bounds checks vcode_type_t velem = lower_type(to_e); vcode_type_t vbounds = lower_bounds(from_e); vcode_type_t voffset = vtype_offset(); vcode_reg_t count_reg = lower_array_total_len(lu, from, value_reg); vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg); vcode_reg_t zero_reg = emit_const(voffset, 0); vcode_reg_t data_reg = lower_array_data(value_reg); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(zero_reg, i_var); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t src_reg = emit_array_ref(data_reg, i_reg); vcode_reg_t elem_reg = emit_load_indirect(src_reg); vcode_reg_t conv_reg = lower_conversion(lu, elem_reg, where, from_e, to_e); vcode_reg_t dest_reg = emit_array_ref(mem_reg, i_reg); emit_store_indirect(conv_reg, dest_reg); vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1)); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg); emit_store(next_reg, i_var); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); lower_release_temp(lu, i_var); result_reg = mem_reg; } if (!type_const_bounds(to)) // Need to wrap in metadata result_reg = lower_wrap(lu, from, result_reg); if (type_is_unconstrained(to)) lower_check_indexes(lu, from, to, result_reg, where); else { vcode_reg_t locus = lower_debug_locus(where); lower_check_array_sizes(lu, to, from, value_reg, result_reg, locus); } return result_reg; } else if ((from_k == T_INTEGER && to_k == T_INTEGER) || (from_k == T_REAL && to_k == T_REAL)) { // Possibly change width lower_check_scalar_bounds(lu, value_reg, to, where, NULL); return emit_cast(lower_type(to), lower_bounds(to), value_reg); } else if (from_k == T_RECORD && to_k == T_RECORD) { vcode_type_t vtype_to = lower_type(to); vcode_var_t tmp_var = lower_temp_var(lu, "conv", vtype_to, vtype_to); vcode_reg_t ptr_reg = emit_index(tmp_var, VCODE_INVALID_REG); lower_convert_record(lu, value_reg, where, from, to, ptr_reg); return ptr_reg; } else { // No conversion to perform return value_reg; } } static vcode_reg_t lower_type_conv(lower_unit_t *lu, tree_t expr) { tree_t value = tree_value(expr); type_t from = tree_type(value); type_t to = tree_type(expr); vcode_reg_t value_reg = lower_rvalue(lu, value); return lower_conversion(lu, value_reg, expr, from, to); } static vcode_reg_t lower_driving_value(lower_unit_t *lu, tree_t name) { vcode_reg_t name_reg = lower_lvalue(lu, name); type_t name_type = tree_type(name); if (type_is_homogeneous(name_type)) { if (type_is_array(name_type)) { vcode_reg_t len_reg = lower_array_total_len(lu, name_type, name_reg); vcode_reg_t nets_reg = lower_array_data(name_reg); vcode_reg_t ptr_reg = emit_driving_value(nets_reg, len_reg); if (vcode_reg_kind(name_reg) == VCODE_TYPE_UARRAY) return lower_rewrap(ptr_reg, name_reg); else return ptr_reg; } else { vcode_reg_t ptr_reg = emit_driving_value(name_reg, VCODE_INVALID_REG); return emit_load_indirect(ptr_reg); } } else { type_t base = type_base_recur(name_type); ident_t base_id = type_ident(base); ident_t helper_func = ident_prefix(base_id, ident_new("driving"), '$'); vcode_reg_t arg_reg; if (type_is_array(base)) arg_reg = lower_coerce_arrays(lu, name_type, base, name_reg); else arg_reg = name_reg; vcode_type_t vrtype = lower_func_result_type(base); vcode_reg_t context_reg = lower_context_for_call(lu, helper_func); vcode_reg_t args[] = { context_reg, arg_reg }; return emit_fcall(helper_func, vrtype, vrtype, args, 2); } } static const int lower_get_attr_dimension(tree_t expr) { if (tree_params(expr) > 0) return assume_int(tree_value(tree_param(expr, 0))) - 1; else return 0; } static vcode_reg_t lower_attr_prefix(lower_unit_t *lu, tree_t prefix) { switch (class_of(prefix)) { case C_SIGNAL: { vcode_reg_t reg = lower_lvalue(lu, prefix); if (have_uarray_ptr(reg)) return emit_load_indirect(reg); else return reg; } case C_TYPE: case C_SUBTYPE: return VCODE_INVALID_REG; default: return lower_rvalue(lu, prefix); } } static vcode_reg_t lower_reflect_attr(lower_unit_t *lu, tree_t expr) { tree_t name = tree_name(expr); type_t type = tree_type(expr); ident_t init_func = type_ident(type); vcode_reg_t context_reg = lower_context_for_call(lu, init_func); type_t value_mirror = reflection_type(REFLECT_VALUE_MIRROR); const bool is_value_mirror = type_eq(type, value_mirror); vcode_reg_t value_reg = VCODE_INVALID_REG, bounds_reg = VCODE_INVALID_REG; if (is_value_mirror) value_reg = lower_attr_prefix(lu, name); type_t value_type = tree_type(name); if (type_is_array(value_type)) bounds_reg = lower_wrap(lu, value_type, value_reg); vcode_reg_t locus = lower_debug_locus(name); if (is_value_mirror) return emit_reflect_value(value_reg, context_reg, locus, bounds_reg); else return emit_reflect_subtype(context_reg, locus, bounds_reg); } static vcode_reg_t lower_attr_param(lower_unit_t *lu, tree_t value, type_t port_type, class_t class) { type_t value_type = tree_type(value); vcode_reg_t reg; if (class == C_SIGNAL || class == C_FILE) reg = lower_lvalue(lu, value); else reg = lower_rvalue(lu, value); if (reg == VCODE_INVALID_REG) return reg; if (type_is_array(value_type)) return lower_coerce_arrays(lu, value_type, port_type ?: value_type, reg); else if (class == C_SIGNAL || class == C_FILE) return reg; else return reg; } static vcode_reg_t lower_attr_ref(lower_unit_t *lu, tree_t expr) { tree_t name = tree_name(expr); const attr_kind_t predef = tree_subkind(expr); switch (predef) { case ATTR_LEFT: case ATTR_RIGHT: { const int dim = lower_get_attr_dimension(expr); type_t type = tree_type(name); if (type_is_unconstrained(type)) { vcode_reg_t array_reg = lower_attr_prefix(lu, name); if (predef == ATTR_LEFT) return lower_array_left(lu, type, dim, array_reg); else return lower_array_right(lu, type, dim, array_reg); } else { tree_t r = range_of(type, dim); if (predef == ATTR_LEFT) return lower_range_left(lu, r); else return lower_range_right(lu, r); } } case ATTR_LOW: case ATTR_HIGH: { const int dim = lower_get_attr_dimension(expr); vcode_reg_t left_reg = VCODE_INVALID_REG; vcode_reg_t right_reg = VCODE_INVALID_REG; vcode_reg_t dir_reg = VCODE_INVALID_REG; type_t type = tree_type(name); if (type_is_unconstrained(type)) { vcode_reg_t array_reg = lower_attr_prefix(lu, name); left_reg = lower_array_left(lu, type, dim, array_reg); right_reg = lower_array_right(lu, type, dim, array_reg); dir_reg = lower_array_dir(lu, type, dim, array_reg); } else { tree_t r = range_of(type, dim); const range_kind_t rkind = tree_subkind(r); if (rkind == RANGE_TO) { return predef == ATTR_LOW ? lower_range_left(lu, r) : lower_range_right(lu, r); } else if (rkind == RANGE_DOWNTO) { return predef == ATTR_LOW ? lower_range_right(lu, r) : lower_range_left(lu, r); } left_reg = lower_range_left(lu, r); right_reg = lower_range_right(lu, r); dir_reg = lower_range_dir(lu, r); } if (predef == ATTR_LOW) return emit_select(dir_reg, right_reg, left_reg); else return emit_select(dir_reg, left_reg, right_reg); } case ATTR_LENGTH: { const int dim = lower_get_attr_dimension(expr); vcode_reg_t name_reg = lower_attr_prefix(lu, name); vcode_reg_t len_reg = lower_array_len(lu, tree_type(name), dim, name_reg); return emit_cast(lower_type(tree_type(expr)), VCODE_INVALID_TYPE, len_reg); } case ATTR_ELEMENT: { vcode_reg_t array_reg = lower_attr_prefix(lu, name); type_t type = tree_type(name); type_t elem = type_elem_recur(type); vcode_reg_t null_reg = emit_null(vtype_pointer(lower_type(elem))); return lower_wrap_element(lu, type, array_reg, null_reg); } case ATTR_ASCENDING: { type_t type = tree_type(name); const int dim = lower_get_attr_dimension(expr); if (type_const_bounds(type)) return emit_const(vtype_bool(), direction_of(type, dim) == RANGE_TO); else { vcode_reg_t name_reg = lower_attr_prefix(lu, name); return emit_not(lower_array_dir(lu, type, dim, name_reg)); } } case ATTR_LAST_EVENT: case ATTR_LAST_ACTIVE: { vcode_reg_t name_reg = lower_attr_prefix(lu, name); type_t name_type = tree_type(name); if (type_is_homogeneous(name_type)) { vcode_reg_t len_reg = VCODE_INVALID_REG; if (type_is_array(name_type)) { len_reg = lower_array_total_len(lu, name_type, name_reg); name_reg = lower_array_data(name_reg); } if (predef == ATTR_LAST_EVENT) return emit_last_event(name_reg, len_reg); else return emit_last_active(name_reg, len_reg); } else { ident_t base_id = type_ident(type_base_recur(name_type)); const char *suffix = predef == ATTR_LAST_EVENT ? "last_event" : "last_active"; ident_t helper_func = ident_sprintf("%s$%s", istr(base_id), suffix); vcode_reg_t arg_reg = name_reg; if (type_is_array(name_type) && vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY) arg_reg = lower_wrap(lu, name_type, name_reg); vcode_type_t vtime = vtype_time(); vcode_reg_t context_reg = lower_context_for_call(lu, helper_func); vcode_reg_t args[] = { context_reg, arg_reg }; return emit_fcall(helper_func, vtime, vtime, args, 2); } } case ATTR_DRIVING_VALUE: return lower_driving_value(lu, name); case ATTR_EVENT: return lower_signal_flag(lu, name, emit_event_flag); case ATTR_ACTIVE: return lower_signal_flag(lu, name, emit_active_flag); case ATTR_DRIVING: return lower_signal_flag(lu, name, emit_driving_flag); case ATTR_LAST_VALUE: return lower_last_value(lu, name); case ATTR_INSTANCE_NAME: case ATTR_PATH_NAME: if (lu->mode == LOWER_THUNK) { vcode_type_t vchar = vtype_char(); vcode_type_t vstring = vtype_uarray(1, vchar, vchar); return emit_undefined(vstring, vchar); } else return lower_name_attr(lu, tree_ref(name), predef); case ATTR_SIMPLE_NAME: { LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, tree_ident(tree_ref(name))); tb_downcase(tb); return lower_wrap_string(tb_get(tb)); } case ATTR_IMAGE: { tree_t value = tree_value(tree_param(expr, 0)); type_t type = tree_type(value); type_t base = type_base_recur(type); ident_t func = ident_prefix(type_ident(base), ident_new("image"), '$'); vcode_type_t ctype = vtype_char(); vcode_type_t strtype = vtype_uarray(1, ctype, ctype); vcode_reg_t arg_reg = lower_attr_param(lu, value, base, C_CONSTANT); vcode_reg_t args[] = { lower_context_for_call(lu, func), arg_reg, }; return emit_fcall(func, strtype, strtype, args, 2); } case ATTR_VALUE: { type_t name_type = tree_type(name); tree_t value = tree_value(tree_param(expr, 0)); type_t value_type = tree_type(value); vcode_reg_t value_reg = lower_rvalue(lu, value); if (lower_have_signal(value_reg)) value_reg = emit_resolved(value_reg, VCODE_INVALID_REG); if (vcode_reg_kind(value_reg) != VCODE_TYPE_UARRAY) value_reg = lower_wrap(lu, value_type, value_reg); type_t base = type_base_recur(name_type); ident_t func = ident_prefix(type_ident(base), ident_new("value"), '$'); vcode_reg_t args[] = { lower_context_for_call(lu, func), value_reg }; vcode_reg_t reg = emit_fcall(func, lower_type(base), lower_bounds(base), args, 2); if (type_is_scalar(name_type)) lower_check_scalar_bounds(lu, reg, name_type, expr, NULL); else if (type_is_array(name_type) && type_const_bounds(name_type)) { vcode_reg_t locus = lower_debug_locus(expr); lower_check_array_sizes(lu, name_type, base, VCODE_INVALID_REG, reg, locus); } return reg; } case ATTR_SUCC: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), 1)); } case ATTR_PRED: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); return emit_sub(arg_reg, emit_const(vcode_reg_type(arg_reg), 1)); } case ATTR_LEFTOF: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); type_t type = tree_type(expr); const int dir = (type_is_enum(type) || direction_of(type, 0) == RANGE_TO) ? -1 : 1; return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), dir)); } case ATTR_RIGHTOF: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); type_t type = tree_type(expr); const int dir = (type_is_enum(type) || direction_of(type, 0) == RANGE_TO) ? 1 : -1; return emit_add(arg_reg, emit_const(vcode_reg_type(arg_reg), dir)); } case ATTR_POS: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); type_t type = tree_type(expr); return emit_cast(lower_type(type), lower_bounds(type), arg_reg); } case ATTR_VAL: { tree_t value = tree_value(tree_param(expr, 0)); vcode_reg_t arg_reg = lower_attr_param(lu, value, NULL, C_CONSTANT); type_t type = tree_type(expr); lower_check_scalar_bounds(lu, arg_reg, type, expr, NULL); return emit_cast(lower_type(type), lower_bounds(type), arg_reg); } case ATTR_REFLECT: return lower_reflect_attr(lu, expr); default: fatal_at(tree_loc(expr), "cannot lower attribute %s (%d)", istr(tree_ident(expr)), predef); } } static vcode_reg_t lower_qualified(lower_unit_t *lu, tree_t expr) { tree_t value = tree_value(expr); type_t from_type = tree_type(value); type_t to_type = tree_type(expr); vcode_reg_t value_reg = lower_rvalue(lu, value); if (type_is_array(to_type)) return lower_coerce_arrays(lu, from_type, to_type, value_reg); else return value_reg; } static vcode_reg_t lower_cond_value(lower_unit_t *lu, tree_t expr) { vcode_block_t exit_bb = VCODE_INVALID_BLOCK; // TODO: vcode really needs phi nodes... type_t type = tree_type(expr); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t temp_var = lower_temp_var(lu, "cond", vtype, vbounds); const int nconds = tree_conds(expr); for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(expr, i); assert(tree_kind(c) == T_COND_EXPR); vcode_block_t next_bb = VCODE_INVALID_BLOCK; if (tree_has_value(c)) { vcode_reg_t test = lower_rvalue(lu, tree_value(c)); vcode_block_t btrue = emit_block(); if (i == nconds - 1) { if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); next_bb = exit_bb; } else next_bb = emit_block(); emit_cond(test, btrue, next_bb); vcode_select_block(btrue); } vcode_reg_t result_reg = lower_rvalue(lu, tree_result(c)); if (type_is_array(type) && type_const_bounds(type)) { vcode_reg_t count_reg = lower_array_total_len(lu, type, VCODE_INVALID_REG); vcode_reg_t dest_reg = emit_index(temp_var, VCODE_INVALID_REG); vcode_reg_t src_reg = lower_array_data(result_reg); emit_copy(dest_reg, src_reg, count_reg); } else if (type_is_record(type)) { vcode_reg_t dest_reg = emit_index(temp_var, VCODE_INVALID_REG); emit_copy(dest_reg, result_reg, VCODE_INVALID_REG); } else emit_store(result_reg, temp_var); if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); emit_jump(exit_bb); if (next_bb == VCODE_INVALID_BLOCK) break; else vcode_select_block(next_bb); } if (exit_bb != VCODE_INVALID_BLOCK) vcode_select_block(exit_bb); if (type_is_scalar(type)) return emit_load(temp_var); else return emit_index(temp_var, VCODE_INVALID_REG); } static vcode_reg_t lower_expr(lower_unit_t *lu, tree_t expr, expr_ctx_t ctx) { PUSH_DEBUG_INFO(expr); switch (tree_kind(expr)) { case T_FCALL: case T_PROT_FCALL: return lower_fcall(lu, expr, VCODE_INVALID_REG); case T_PSL_FCALL: return psl_lower_fcall(lu, tree_psl(expr)); case T_PSL_UNION: return psl_lower_union(lu, tree_psl(expr)); case T_LITERAL: return lower_literal(expr); case T_STRING: return lower_string_literal(expr, false); case T_REF: return lower_ref(lu, expr, ctx); case T_EXTERNAL_NAME: return lower_external_name(lu, expr); case T_AGGREGATE: return lower_aggregate(lu, expr, VCODE_INVALID_VAR); case T_ARRAY_REF: return lower_array_ref(lu, expr, ctx); case T_ARRAY_SLICE: return lower_array_slice(lu, expr, ctx); case T_RECORD_REF: return lower_record_ref(lu, expr, ctx); case T_PROT_REF: return lower_prot_ref(lu, expr); case T_NEW: return lower_new(lu, expr); case T_ALL: return lower_all(lu, expr, ctx); case T_TYPE_CONV: return lower_type_conv(lu, expr); case T_ATTR_REF: return lower_attr_ref(lu, expr); case T_QUALIFIED: return lower_qualified(lu, expr); case T_OPEN: return VCODE_INVALID_REG; case T_COND_VALUE: return lower_cond_value(lu, expr); default: fatal_at(tree_loc(expr), "cannot lower expression kind %s", tree_kind_str(tree_kind(expr))); } } static vcode_reg_t lower_nested_default_value(lower_unit_t *lu, type_t type) { if (type_is_scalar(type)) return lower_scalar_type_left(lu, type); else if (type_is_array(type)) { assert(type_const_bounds(type)); type_t elem = type_elem_recur(type); vcode_reg_t elem_reg = lower_nested_default_value(lu, elem); const size_t size = lower_array_const_size(type); if (vtype_is_scalar(vcode_reg_type(elem_reg))) return emit_const_rep(lower_type(type), elem_reg, size); else { vcode_reg_t *values LOCAL = xmalloc_array(size, sizeof(vcode_reg_t)); for (int i = 0; i < size; i++) values[i] = elem_reg; return emit_const_array(lower_type(type), values, size); } } else if (type_is_record(type)) { assert(type_const_bounds(type)); const int nfields = type_fields(type); vcode_type_t vtype = lower_type(type); vcode_reg_t *values LOCAL = xmalloc_array(nfields, sizeof(vcode_reg_t)); for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); values[i] = lower_nested_default_value(lu, ftype); } return emit_const_record(vtype, values, nfields); } else if (type_is_access(type)) return emit_null(lower_type(type)); fatal_trace("cannot handle type %s in lower_nested_default_value", type_pp(type)); } static vcode_reg_t lower_default_value(lower_unit_t *lu, type_t type, vcode_reg_t hint_reg) { if (type_is_scalar(type)) return lower_scalar_type_left(lu, type); else if (type_is_array(type)) { assert(!type_is_unconstrained(type)); type_t elem_type = type_elem_recur(type); if (type_const_bounds(type)) { const size_t size = lower_array_const_size(type); if (hint_reg != VCODE_INVALID_REG && type_is_scalar(elem_type)) { vcode_reg_t elem_reg = lower_scalar_type_left(lu, elem_type); vcode_reg_t count_reg = emit_const(vtype_offset(), size); vcode_reg_t data_reg = lower_array_data(hint_reg); emit_memset(data_reg, elem_reg, count_reg); return hint_reg; } else if (size < MAX_INLINE_CONST) return emit_address_of(lower_nested_default_value(lu, type)); } vcode_reg_t count_reg = lower_array_total_len(lu, type, hint_reg); vcode_reg_t def_reg = lower_default_value(lu, elem_type, VCODE_INVALID_REG); if (hint_reg == VCODE_INVALID_REG) { vcode_type_t velem = lower_type(elem_type); vcode_type_t vbounds = lower_bounds(elem_type); hint_reg = emit_alloc(velem, vbounds, count_reg); } vcode_reg_t data_reg = lower_array_data(hint_reg); if (type_is_scalar(elem_type)) emit_memset(data_reg, def_reg, count_reg); else { // Loop to initialise the array vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_block_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, emit_const(voffset, 0)); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t ptr_reg = emit_array_ref(data_reg, i_reg); if (type_is_scalar(elem_type)) emit_store_indirect(def_reg, ptr_reg); else if (type_is_record(elem_type)) lower_new_record(lu, elem_type, ptr_reg, def_reg); else emit_store_indirect(def_reg, ptr_reg); vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1)); emit_store(next_reg, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); lower_release_temp(lu, i_var); } return hint_reg; } else if (type_is_record(type)) { if (type_const_bounds(type)) return emit_address_of(lower_nested_default_value(lu, type)); type_t base = type_base_recur(type); const int nfields = type_fields(base); vcode_type_t vtype = lower_type(type); vcode_reg_t mem_reg = hint_reg; if (hint_reg == VCODE_INVALID_REG) { vcode_var_t tmp_var = lower_temp_var(lu, "def", vtype, vtype); mem_reg = emit_index(tmp_var, VCODE_INVALID_REG); } for (int i = 0; i < nfields; i++) { tree_t f = type_field(base, i); vcode_reg_t ptr_reg = emit_record_ref(mem_reg, i); type_t ftype = tree_type(f); if (base != type && type_is_unconstrained(ftype)) { tree_t ec = type_constraint_for_field(type, f); assert(ec != NULL); ftype = tree_type(ec); } if (type_is_scalar(ftype)) { vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg); emit_store_indirect(def_reg, ptr_reg); } else if (type_is_array(ftype)) { if (have_uarray_ptr(ptr_reg)) { // Need to allocate memory for the array type_t elem_type = type_elem_recur(ftype); vcode_type_t vtype = lower_type(elem_type); vcode_type_t vbounds = lower_bounds(elem_type); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, VCODE_INVALID_REG); vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, count_reg); vcode_reg_t def_reg = lower_default_value(lu, ftype, mem_reg); assert(def_reg == mem_reg); vcode_reg_t wrap_reg = lower_wrap_with_new_bounds(lu, ftype, tree_type(f), def_reg, mem_reg); emit_store_indirect(wrap_reg, ptr_reg); } else { vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, VCODE_INVALID_REG); emit_copy(ptr_reg, def_reg, count_reg); } } else if (type_is_record(ftype)) { vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg); emit_copy(ptr_reg, def_reg, VCODE_INVALID_REG); } else { vcode_reg_t def_reg = lower_default_value(lu, ftype, ptr_reg); emit_store_indirect(def_reg, ptr_reg); } } return mem_reg; } else if (type_is_access(type)) return emit_null(lower_type(type)); else fatal_trace("cannot handle type %s in lower_default_value", type_pp(type)); } static void lower_report(lower_unit_t *lu, tree_t stmt) { lower_stmt_coverage(lu, stmt); vcode_reg_t severity_reg = VCODE_INVALID_REG; if (tree_has_severity(stmt)) severity_reg = lower_rvalue(lu, tree_severity(stmt)); else { vcode_type_t vseverity = vtype_int(0, 3); severity_reg = emit_const(vseverity, SEVERITY_NOTE); } vcode_reg_t message = VCODE_INVALID_REG, length = VCODE_INVALID_REG; if (tree_has_message(stmt)) { tree_t m = tree_message(stmt); vcode_reg_t message_wrapped = lower_rvalue(lu, m); message = lower_array_data(message_wrapped); length = lower_array_len(lu, tree_type(m), 0, message_wrapped); } vcode_reg_t locus = lower_debug_locus(stmt); emit_report(message, length, severity_reg, locus); } static bool lower_can_hint_assert(tree_t expr) { if (tree_kind(expr) != T_FCALL) return false; switch (tree_subkind(tree_ref(expr))) { case S_SCALAR_EQ: case S_SCALAR_NEQ: case S_SCALAR_LT: case S_SCALAR_LE: case S_SCALAR_GT: case S_SCALAR_GE: return true; default: return false; } } static void lower_assert(lower_unit_t *lu, tree_t stmt) { lower_stmt_coverage(lu, stmt); tree_t value = tree_value(stmt); vcode_reg_t value_reg, hint_left_reg = VCODE_INVALID_REG, hint_right_reg = VCODE_INVALID_REG; if (!tree_has_message(stmt) && lower_can_hint_assert(value)) value_reg = lower_builtin(lu, value, tree_subkind(tree_ref(value)), &hint_left_reg, &hint_right_reg); else value_reg = lower_rvalue(lu, value); int64_t value_const; if (vcode_reg_const(value_reg, &value_const) && value_const) return; vcode_block_t fail_bb = VCODE_INVALID_BLOCK; vcode_block_t exit_bb = VCODE_INVALID_BLOCK; tree_t message = tree_has_message(stmt) ? tree_message(stmt) : NULL; tree_t severity = tree_has_severity(stmt) ? tree_severity(stmt) : NULL; // If evaluating the message or severity expressions can have side // effects then branch to a new block const bool has_side_effects = (message != NULL && !lower_side_effect_free(message)) || (severity != NULL && !lower_side_effect_free(severity)); if (has_side_effects) { fail_bb = emit_block(); exit_bb = emit_block(); emit_cond(value_reg, exit_bb, fail_bb); vcode_select_block(fail_bb); } vcode_reg_t message_reg = VCODE_INVALID_REG, length_reg = VCODE_INVALID_REG; if (message != NULL) { vcode_reg_t message_wrapped = lower_rvalue(lu, message); message_reg = lower_array_data(message_wrapped); length_reg = lower_array_len(lu, tree_type(message), 0, message_wrapped); } vcode_reg_t severity_reg = VCODE_INVALID_REG; if (severity != NULL) severity_reg = lower_rvalue(lu, severity); else { vcode_type_t vseverity = vtype_int(0, 3); severity_reg = emit_const(vseverity, SEVERITY_ERROR); } vcode_reg_t locus = lower_debug_locus(value); emit_assert(value_reg, message_reg, length_reg, severity_reg, locus, hint_left_reg, hint_right_reg); if (exit_bb != VCODE_INVALID_BLOCK) { emit_jump(exit_bb); vcode_select_block(exit_bb); } } static void lower_sched_event_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t unused, vcode_reg_t locus, void *ctx) { type_t type = tree_type(field); if (!type_is_homogeneous(type)) lower_for_each_field(lu, type, ptr, locus, lower_sched_event_field_cb, ctx); else { vcode_reg_t nets_reg = emit_load_indirect(ptr); vcode_reg_t data_reg = lower_array_data(nets_reg); vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); const bool clear = (uintptr_t)ctx; if (clear) emit_clear_event(data_reg, count_reg); else emit_sched_event(data_reg, count_reg); } } static void lower_sched_event(lower_unit_t *lu, tree_t on) { type_t type = tree_type(on); vcode_reg_t nets_reg = lower_lvalue(lu, on); assert(nets_reg != VCODE_INVALID_REG); if (!type_is_homogeneous(type)) lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG, lower_sched_event_field_cb, NULL); else { vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_sched_event(data_reg, count_reg); } } static void lower_clear_event(lower_unit_t *lu, tree_t on) { type_t type = tree_type(on); vcode_reg_t nets_reg = lower_lvalue(lu, on); assert(nets_reg != VCODE_INVALID_REG); if (!type_is_homogeneous(type)) lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG, lower_sched_event_field_cb, (void *)1); else { vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_clear_event(data_reg, count_reg); } } static vcode_reg_t lower_call_now(void) { ident_t func = ident_new("STD.STANDARD.NOW()25STD.STANDARD.DELAY_LENGTH"); vcode_type_t rtype = vtype_time(); vcode_reg_t context_reg = emit_link_package(well_known(W_STD_STANDARD)); vcode_reg_t args[1] = { context_reg }; return emit_fcall(func, rtype, rtype, args, ARRAY_LEN(args)); } static void lower_wait(lower_unit_t *lu, tree_t wait) { const bool is_static = !!(tree_flags(wait) & TREE_F_STATIC_WAIT); assert(!is_static || (!tree_has_delay(wait) && !tree_has_value(wait))); const int ntriggers = tree_triggers(wait); if (!is_static) { lower_stmt_coverage(lu, wait); // The _sched_event for static waits is emitted in the reset block for (int i = 0; i < ntriggers; i++) lower_sched_event(lu, tree_trigger(wait, i)); } const bool has_delay = tree_has_delay(wait); const bool has_value = tree_has_value(wait); vcode_reg_t delay = VCODE_INVALID_REG; if (has_delay) delay = lower_rvalue(lu, tree_delay(wait)); vcode_var_t remain = VCODE_INVALID_VAR; if (has_value && has_delay) { ident_t remain_i = ident_new("wait_remain"); remain = vcode_find_var(remain_i); if (remain == VCODE_INVALID_VAR) { vcode_type_t time = vtype_time(); remain = emit_var(time, time, remain_i, 0); } vcode_reg_t now_reg = lower_call_now(); vcode_reg_t abs_reg = emit_add(now_reg, delay); emit_store(abs_reg, remain); } vcode_block_t resume = emit_block(); emit_wait(resume, delay); vcode_select_block(resume); if (!is_static) { for (int i = 0; i < ntriggers; i++) lower_clear_event(lu, tree_trigger(wait, i)); } if (has_value) { // Generate code to loop until condition is met vcode_reg_t until_reg = lower_rvalue(lu, tree_value(wait)); vcode_reg_t timeout_reg = VCODE_INVALID_REG; vcode_reg_t done_reg = until_reg; if (has_delay) { vcode_reg_t remain_reg = emit_load(remain); vcode_reg_t now_reg = lower_call_now(); timeout_reg = emit_sub(remain_reg, now_reg); vcode_reg_t expired_reg = emit_cmp(VCODE_CMP_EQ, timeout_reg, emit_const(vtype_time(), 0)); done_reg = emit_or(expired_reg, until_reg); } vcode_block_t done_bb = emit_block(); vcode_block_t again_bb = emit_block(); emit_cond(done_reg, done_bb, again_bb); vcode_select_block(again_bb); for (int i = 0; i < ntriggers; i++) lower_sched_event(lu, tree_trigger(wait, i)); emit_wait(resume, timeout_reg); vcode_select_block(done_bb); } } static void lower_check_array_sizes(lower_unit_t *lu, type_t ltype, type_t rtype, vcode_reg_t lval, vcode_reg_t rval, vcode_reg_t locus) { const int ndims = dimension_of(ltype); for (int i = 0; i < ndims; i++) { vcode_reg_t llen_reg = lower_array_len(lu, ltype, i, lval); vcode_reg_t rlen_reg = lower_array_len(lu, rtype, i, rval); vcode_reg_t dim_reg = VCODE_INVALID_REG; if (ndims > 1) dim_reg = emit_const(vtype_offset(), i + 1); emit_length_check(llen_reg, rlen_reg, locus, dim_reg); } } static void lower_find_matching_refs(tree_t ref, void *context) { tree_t *decl = (tree_t *)context; if (tree_ref(ref) == *decl) *decl = NULL; } static bool lower_can_hint_aggregate(tree_t target, tree_t value) { if (tree_kind(value) != T_AGGREGATE) return false; type_t type = tree_type(target); if (!type_const_bounds(type)) return false; tree_t ref = name_to_ref(target); if (ref == NULL) return false; tree_t decl = tree_ref(ref); tree_visit_only(value, lower_find_matching_refs, &decl, T_REF); return decl != NULL; } static int lower_count_target_parts(tree_t target, int depth) { if (tree_kind(target) == T_AGGREGATE) { int count = 0; const int nassocs = tree_assocs(target); for (int i = 0; i < nassocs; i++) { tree_t value = tree_value(tree_assoc(target, i)); count += lower_count_target_parts(value, depth + 1); } return count + (depth > 0 ? 2 : 1); } else return depth == 0 ? 2 : 1; } static void lower_fill_target_parts(lower_unit_t *lu, tree_t target, part_kind_t kind, target_part_t **ptr) { type_t target_type = tree_type(target); if (tree_kind(target) == T_AGGREGATE) { const bool is_record = type_is_record(target_type); const int ndims = dimension_of(target_type); if (kind != PART_ALL) { (*ptr)->reg = VCODE_INVALID_REG; (*ptr)->off = VCODE_INVALID_REG; (*ptr)->target = NULL; (*ptr)->kind = kind == PART_FIELD ? PART_PUSH_FIELD : PART_PUSH_ELEM; ++(*ptr); } vcode_reg_t sum_reg = emit_const(vtype_offset(), 0); const int nassocs = tree_assocs(target); for (int i = 0; i < nassocs; i++) { tree_t value = tree_value(tree_assoc(target, i)); part_kind_t newkind; if (is_record) newkind = PART_FIELD; else if (ndims == 1 && type_eq(tree_type(value), target_type)) newkind = PART_SLICE; else newkind = PART_ELEM; lower_fill_target_parts(lu, value, newkind, ptr); vcode_reg_t len_reg; if (newkind == PART_SLICE) len_reg = (*ptr - 1)->off; else len_reg = emit_const(vtype_offset(), 1); sum_reg = emit_add(sum_reg, len_reg); } (*ptr)->reg = VCODE_INVALID_REG; (*ptr)->off = sum_reg; (*ptr)->target = NULL; (*ptr)->kind = PART_POP; ++(*ptr); } else { (*ptr)->reg = lower_lvalue(lu, target); (*ptr)->target = target; (*ptr)->kind = kind; if (type_is_array(target_type)) (*ptr)->off = lower_array_total_len(lu, target_type, (*ptr)->reg); else (*ptr)->off = emit_const(vtype_offset(), 1); ++(*ptr); if (kind == PART_ALL) { (*ptr)->reg = VCODE_INVALID_REG; (*ptr)->off = (*ptr - 1)->off; (*ptr)->target = NULL; (*ptr)->kind = PART_POP; ++(*ptr); } } } static void lower_copy_record(lower_unit_t *lu, type_t type, vcode_reg_t dst_ptr, vcode_reg_t src_ptr, vcode_reg_t locus) { if (dst_ptr == src_ptr) return; else if (lower_trivially_copyable(type)) emit_copy(dst_ptr, src_ptr, VCODE_INVALID_REG); else { ident_t base_id = type_ident(type_base_recur(type)); ident_t helper_func = ident_prefix(base_id, ident_new("copy"), '$'); vcode_reg_t args[] = { lower_context_for_call(lu, helper_func), dst_ptr, src_ptr, locus }; emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, args, ARRAY_LEN(args)); } } static void lower_copy_array(lower_unit_t *lu, type_t dst_type, type_t src_type, vcode_reg_t dst_array, vcode_reg_t src_array, vcode_reg_t locus) { if (dst_array == src_array) return; else if (lower_trivially_copyable(dst_type)) { lower_check_array_sizes(lu, dst_type, src_type, dst_array, src_array, locus); vcode_reg_t count_reg = lower_array_total_len(lu, dst_type, dst_array); vcode_reg_t src_data = lower_array_data(src_array); vcode_reg_t dst_data = lower_array_data(dst_array); emit_copy(dst_data, src_data, count_reg); } else { ident_t base_id = type_ident(type_base_recur(dst_type)); ident_t helper_func = ident_prefix(base_id, ident_new("copy"), '$'); assert(vcode_reg_kind(dst_array) == VCODE_TYPE_UARRAY); assert(vcode_reg_kind(src_array) == VCODE_TYPE_UARRAY); vcode_reg_t args[] = { lower_context_for_call(lu, helper_func), dst_array, src_array, locus }; emit_fcall(helper_func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, args, ARRAY_LEN(args)); } } static void lower_var_assign_target(lower_unit_t *lu, target_part_t **ptr, tree_t where, vcode_reg_t rhs, type_t rhs_type) { int fieldno = 0; for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) { vcode_reg_t src_reg = rhs; type_t src_type = rhs_type; if (p->kind == PART_FIELD || p->kind == PART_PUSH_FIELD) { assert(vcode_reg_kind(rhs) == VCODE_TYPE_POINTER); src_reg = emit_record_ref(rhs, fieldno); src_type = tree_type(type_field(src_type, fieldno)); fieldno++; } if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) { lower_var_assign_target(lu, ptr, where, src_reg, src_type); continue; } else if (p->reg == VCODE_INVALID_REG) continue; if (p->kind == PART_ELEM) src_type = type_elem(src_type); type_t type = tree_type(p->target); if (p->kind != PART_SLICE && type_is_array(type)) { vcode_reg_t locus = lower_debug_locus(p->target); lower_check_array_sizes(lu, type, src_type, p->reg, src_reg, locus); } if (p->kind == PART_ELEM || p->kind == PART_SLICE) src_reg = lower_array_data(src_reg); vcode_reg_t scalar_reg = src_reg; if ((p->kind == PART_ELEM || p->kind == PART_FIELD) && !type_is_composite(type)) scalar_reg = emit_load_indirect(src_reg); if (type_is_scalar(type)) { lower_check_scalar_bounds(lu, scalar_reg, type, where, p->target); emit_store_indirect(scalar_reg, p->reg); } else if (type_is_array(type)) { vcode_reg_t data_reg = lower_array_data(src_reg); vcode_reg_t count_reg = lower_array_total_len(lu, type, p->reg); vcode_reg_t dest_reg = lower_array_data(p->reg); emit_copy(dest_reg, data_reg, count_reg); } else if (type_is_record(type)) { vcode_reg_t locus = lower_debug_locus(where); lower_copy_record(lu, type, p->reg, src_reg, locus); } else emit_store_indirect(scalar_reg, p->reg); if (p->kind == PART_ELEM || p->kind == PART_SLICE) { assert(vcode_reg_kind(src_reg) == VCODE_TYPE_POINTER); rhs = emit_array_ref(src_reg, p->off); } } } static void lower_var_assign(lower_unit_t *lu, tree_t stmt) { tree_t value = tree_value(stmt); tree_t target = tree_target(stmt); type_t type = tree_type(target); lower_stmt_coverage(lu, stmt); const bool is_var_decl = tree_kind(target) == T_REF && tree_kind(tree_ref(target)) == T_VAR_DECL; const bool is_scalar = type_is_scalar(type); const bool is_access = type_is_access(type); if (is_scalar || is_access) { vcode_reg_t value_reg = lower_rvalue(lu, value); vcode_var_t var = VCODE_INVALID_VAR; int hops = 0; if (is_scalar) lower_check_scalar_bounds(lu, value_reg, type, value, target); else value_reg = lower_incomplete_access(value_reg, type_designated(type)); if (is_var_decl && (var = lower_get_var(lu, tree_ref(target), &hops)) != VCODE_INVALID_VAR && hops == 0) emit_store(value_reg, var); else { vcode_reg_t ptr_reg = lower_lvalue(lu, target); emit_store_indirect(value_reg, ptr_reg); } } else if (tree_kind(target) == T_AGGREGATE) { const int nparts = lower_count_target_parts(target, 0); target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t)); target_part_t *ptr = parts; lower_fill_target_parts(lu, target, PART_ALL, &ptr); assert(ptr == parts + nparts); vcode_reg_t rhs = lower_rvalue(lu, value); if (type_is_array(type)) { vcode_reg_t rhs_len = lower_array_len(lu, tree_type(value), 0, rhs); vcode_reg_t locus = lower_debug_locus(target); assert(parts[nparts - 1].kind == PART_POP); emit_length_check(parts[nparts - 1].off, rhs_len, locus, VCODE_INVALID_REG); } ptr = parts; lower_var_assign_target(lu, &ptr, value, rhs, tree_type(value)); assert(ptr == parts + nparts); } else if (type_is_array(type)) { vcode_reg_t target_reg = lower_lvalue(lu, target); vcode_reg_t value_reg; if (lower_can_hint_aggregate(target, value)) value_reg = lower_aggregate(lu, value, lower_array_data(target_reg)); else value_reg = lower_known_subtype(lu, value, type, target_reg); vcode_reg_t locus = lower_debug_locus(target); type_t value_type = tree_type(value); lower_copy_array(lu, type, value_type, target_reg, value_reg, locus); } else { vcode_reg_t target_reg = lower_lvalue(lu, target); vcode_reg_t value_reg; if (lower_can_hint_aggregate(target, value)) value_reg = lower_aggregate(lu, value, target_reg); else value_reg = lower_known_subtype(lu, value, type, target_reg); vcode_reg_t locus = lower_debug_locus(stmt); lower_copy_record(lu, type, target_reg, value_reg, locus); } } static void lower_signal_target_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t dst_ptr, vcode_reg_t src_ptr, vcode_reg_t locus, void *__ctx) { type_t type = tree_type(field); vcode_reg_t *args = __ctx; if (!type_is_homogeneous(type)) lower_for_each_field_2(lu, type, type, dst_ptr, src_ptr, locus, lower_signal_target_field_cb, __ctx); else if (type_is_array(type)) { vcode_reg_t src_array = VCODE_INVALID_REG; vcode_reg_t dst_array = VCODE_INVALID_REG; vcode_reg_t nets_reg; if (have_uarray_ptr(dst_ptr)) { dst_array = emit_load_indirect(dst_ptr); nets_reg = lower_array_data(dst_array); } else nets_reg = emit_load_indirect(dst_ptr); vcode_reg_t array_reg; if (have_uarray_ptr(src_ptr)) { src_array = emit_load_indirect(src_ptr); array_reg = lower_resolved(lu, type, src_array); } else array_reg = lower_resolved(lu, type, src_ptr); lower_check_array_sizes(lu, type, type, dst_array, src_array, locus); vcode_reg_t count_reg = lower_array_total_len(lu, type, array_reg); vcode_reg_t data_reg = lower_array_data(array_reg); emit_sched_waveform(nets_reg, count_reg, data_reg, args[0], args[1]); } else { vcode_reg_t nets_reg = emit_load_indirect(dst_ptr); vcode_reg_t data_reg = lower_resolved(lu, type, src_ptr); emit_sched_waveform(nets_reg, emit_const(vtype_offset(), 1), data_reg, args[0], args[1]); } } static void lower_signal_assign_target(lower_unit_t *lu, target_part_t **ptr, tree_t where, vcode_reg_t rhs, type_t rhs_type, vcode_reg_t reject, vcode_reg_t after) { int fieldno = 0; for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) { vcode_reg_t src_reg = rhs; type_t src_type = rhs_type; if (p->kind == PART_FIELD || p->kind == PART_PUSH_FIELD) { assert(vcode_reg_kind(rhs) == VCODE_TYPE_POINTER); src_reg = emit_record_ref(rhs, fieldno); src_type = tree_type(type_field(src_type, fieldno)); fieldno++; } if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) { lower_signal_assign_target(lu, ptr, where, src_reg, src_type, reject, after); continue; } else if (p->reg == VCODE_INVALID_REG) continue; if (p->kind == PART_ELEM) src_type = type_elem(src_type); type_t type = tree_type(p->target); if (p->kind != PART_SLICE && type_is_array(type)) { vcode_reg_t locus = lower_debug_locus(p->target); lower_check_array_sizes(lu, type, src_type, p->reg, src_reg, locus); } if (p->kind == PART_ELEM || p->kind == PART_SLICE) src_reg = lower_array_data(src_reg); if (type_is_scalar(type)) lower_check_scalar_bounds(lu, src_reg, type, where, p->target); if (!type_is_homogeneous(type)) { vcode_reg_t args[2] = { reject, after }; vcode_reg_t locus = lower_debug_locus(where); lower_for_each_field_2(lu, type, src_type, p->reg, src_reg, locus, lower_signal_target_field_cb, &args); } else if (type_is_array(type)) { vcode_reg_t resolved_reg = lower_resolved(lu, type, src_reg); vcode_reg_t data_reg = lower_array_data(resolved_reg); vcode_reg_t count_reg = lower_array_total_len(lu, type, p->reg); vcode_reg_t nets_raw = lower_array_data(p->reg); emit_sched_waveform(nets_raw, count_reg, data_reg, reject, after); } else { vcode_reg_t data_reg = lower_resolved(lu, type, src_reg); emit_sched_waveform(p->reg, emit_const(vtype_offset(), 1), data_reg, reject, after); } if (p->kind == PART_ELEM || p->kind == PART_SLICE) { assert(vcode_reg_kind(src_reg) == VCODE_TYPE_POINTER); rhs = emit_array_ref(src_reg, p->off); } } } static void lower_disconnect_target(lower_unit_t *lu, target_part_t **ptr, vcode_reg_t reject, vcode_reg_t after) { for (const target_part_t *p = (*ptr)++; p->kind != PART_POP; p = (*ptr)++) { if (p->kind == PART_PUSH_FIELD || p->kind == PART_PUSH_ELEM) { lower_disconnect_target(lu, ptr, reject, after); continue; } else if (p->reg == VCODE_INVALID_REG) continue; vcode_reg_t nets_reg = lower_array_data(p->reg); type_t type = tree_type(p->target); if (type_is_record(type)) { // XXX: this seems wrong const int width = type_width(type); emit_disconnect(nets_reg, emit_const(vtype_offset(), width), reject, after); } else { vcode_reg_t count_reg = lower_type_width(lu, type, p->reg); emit_disconnect(nets_reg, count_reg, reject, after); } } } static void lower_signal_assign(lower_unit_t *lu, tree_t stmt) { lower_stmt_coverage(lu, stmt); tree_t target = tree_target(stmt); const int nparts = lower_count_target_parts(target, 0); target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t)); target_part_t *ptr = parts; lower_fill_target_parts(lu, target, PART_ALL, &ptr); assert(ptr == parts + nparts); const int nwaveforms = tree_waveforms(stmt); for (int i = 0; i < nwaveforms; i++) { tree_t w = tree_waveform(stmt, i); tree_t delay = NULL; vcode_reg_t delay_reg; if (tree_has_delay(w)) { delay = tree_delay(w); delay_reg = lower_rvalue(lu, delay); } else delay_reg = emit_const(vtype_time(), 0); vcode_reg_t reject_reg; if (i == 0 && tree_has_reject(stmt)) { tree_t reject = tree_reject(stmt); if (reject == delay) { // If delay is the same as reject ensure the expression is // only evaluated once reject_reg = delay_reg; } else reject_reg = lower_rvalue(lu, reject); } else { // All but the first waveform have zero reject time reject_reg = emit_const(vtype_time(), 0); } vcode_var_t tmp_var = VCODE_INVALID_VAR; target_part_t *ptr = parts; if (tree_has_value(w)) { tree_t wvalue = tree_value(w); type_t wtype = tree_type(wvalue); vcode_reg_t rhs = VCODE_INVALID_REG; if (ptr->kind == PART_ALL) { if (lower_can_hint_aggregate(ptr->target, wvalue)) { type_t ptype = tree_type(ptr->target); vcode_type_t vtype = lower_type(ptype); vcode_type_t vbounds = lower_bounds(ptype); tmp_var = lower_temp_var(lu, "tmp", vtype, vbounds); vcode_reg_t hint_reg = emit_index(tmp_var, VCODE_INVALID_REG); rhs = lower_aggregate(lu, wvalue, hint_reg); } else if (type_is_record(wtype) && lower_is_signal_ref(wvalue)) { // If the RHS is another record signal we can avoid creating // a temporary resolved copy of the whole record by // resolving each field individually in the field callback. rhs = lower_lvalue(lu, wvalue); } else if (standard() >= STD_19) { type_t ptype = tree_type(ptr->target); rhs = lower_known_subtype(lu, wvalue, ptype, ptr->reg); } } if (rhs == VCODE_INVALID_REG) rhs = lower_rvalue(lu, wvalue); if (ptr->kind != PART_ALL && type_is_array(wtype)) { vcode_reg_t rhs_len = lower_array_len(lu, wtype, 0, rhs); vcode_reg_t locus = lower_debug_locus(target); assert(parts[nparts - 1].kind == PART_POP); emit_length_check(parts[nparts - 1].off, rhs_len, locus, VCODE_INVALID_REG); } lower_signal_assign_target(lu, &ptr, wvalue, rhs, wtype, reject_reg, delay_reg); } else lower_disconnect_target(lu, &ptr, reject_reg, delay_reg); assert(ptr == parts + nparts); if (tmp_var != VCODE_INVALID_VAR) lower_release_temp(lu, tmp_var); } } static void lower_force_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t value, vcode_reg_t locus, void *__ctx) { type_t type = tree_type(field); if (type_is_homogeneous(type)) { vcode_reg_t nets_reg = emit_load_indirect(ptr); vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); emit_force(lower_array_data(nets_reg), count_reg, value); } else lower_for_each_field_2(lu, type, type, ptr, value, locus, lower_force_field_cb, NULL); } static void lower_force(lower_unit_t *lu, tree_t stmt) { tree_t target = tree_target(stmt); type_t type = tree_type(target); vcode_reg_t nets = lower_lvalue(lu, target); tree_t value = tree_value(stmt); type_t value_type = tree_type(value); vcode_reg_t value_reg = lower_rvalue(lu, value); if (type_is_array(type)) { vcode_reg_t locus = lower_debug_locus(target); lower_check_array_sizes(lu, type, value_type, nets, value_reg, locus); vcode_reg_t count_reg = lower_array_total_len(lu, type, nets); vcode_reg_t data_reg = lower_array_data(value_reg); emit_force(lower_array_data(nets), count_reg, data_reg); } else if (type_is_record(type)) { vcode_reg_t locus = lower_debug_locus(value); lower_for_each_field_2(lu, type, value_type, nets, value_reg, locus, lower_force_field_cb, NULL); } else emit_force(nets, emit_const(vtype_offset(), 1), value_reg); } static void lower_release(lower_unit_t *lu, tree_t stmt) { tree_t target = tree_target(stmt); type_t type = tree_type(target); vcode_reg_t nets = lower_lvalue(lu, target); if (type_is_array(type)) { vcode_reg_t count_reg = lower_array_total_len(lu, type, nets); emit_release(lower_array_data(nets), count_reg); } else if (type_is_record(type)) { should_not_reach_here(); } else emit_release(nets, emit_const(vtype_offset(), 1)); } static void lower_sequence(lower_unit_t *lu, tree_t block, loop_stack_t *loops) { const int nstmts = tree_stmts(block); for (int i = 0; i < nstmts; i++) lower_stmt(lu, tree_stmt(block, i), loops); } static void lower_if(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); vcode_block_t exit_bb = VCODE_INVALID_BLOCK; const bool want_coverage = cover_enabled(lu->cover, COVER_MASK_BRANCH); const int nconds = tree_conds(stmt); for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(stmt, i); vcode_block_t next_bb = VCODE_INVALID_BLOCK; PUSH_COVER_SCOPE(lu, c); if (tree_has_value(c)) { vcode_reg_t test = lower_rvalue(lu, tree_value(c)); vcode_block_t btrue = emit_block(); if (i == nconds - 1 && !want_coverage) { if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); next_bb = exit_bb; } else next_bb = emit_block(); emit_cond(test, btrue, next_bb); if (want_coverage) lower_branch_coverage(lu, c, btrue, next_bb); vcode_select_block(btrue); } lower_sequence(lu, c, loops); if (!vcode_block_finished()) { if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); emit_jump(exit_bb); } if (next_bb == VCODE_INVALID_BLOCK) break; vcode_select_block(next_bb); if (i == nconds - 1 && want_coverage) { if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); emit_jump(exit_bb); } } if (exit_bb != VCODE_INVALID_BLOCK) vcode_select_block(exit_bb); } static void lower_leave_subprogram(lower_unit_t *lu) { // Release resources for protected and file variables const int ndecls = tree_decls(lu->container); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(lu->container, i); switch (tree_kind(d)) { case T_VAR_DECL: if (type_is_protected(tree_type(d))) { int hops = 0; vcode_var_t var = lower_get_var(lu, d, &hops); assert(var != VCODE_INVALID_VAR); vcode_reg_t obj_reg; if (hops == 0) obj_reg = emit_load(var); else obj_reg = emit_load_indirect(emit_var_upref(hops, var)); emit_protected_free(obj_reg); } break; case T_FILE_DECL: { type_t base = type_base_recur(tree_type(d)); LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, ident_runtil(type_ident(base), '.')); tb_cat(tb, ".FILE_CLOSE("); mangle_one_type(tb, base); tb_cat(tb, ")"); tb_cat(tb, "$predef"); ident_t func = ident_new(tb_get(tb)); vcode_reg_t ptr_reg = lower_var_ref(lu, d, EXPR_LVALUE); vcode_reg_t context_reg = lower_context_for_call(lu, func); vcode_reg_t args[] = { context_reg, ptr_reg }; emit_fcall(func, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, args, ARRAY_LEN(args)); } break; default: break; } } } static void lower_return(lower_unit_t *lu, tree_t stmt) { lower_stmt_coverage(lu, stmt); vcode_reg_t value_reg = VCODE_INVALID_REG; if (tree_has_value(stmt)) { tree_t value = tree_value(stmt); type_t type = tree_type(value); value_reg = lower_rvalue(lu, value); if (type_is_scalar(type)) lower_check_scalar_bounds(lu, value_reg, type, value, NULL); else if (type_is_access(type)) value_reg = lower_incomplete_access(value_reg, type_designated(type)); else if (type_is_array(type)) value_reg = lower_coerce_arrays(lu, type, tree_type(stmt), value_reg); } if (is_subprogram(lu->container)) lower_leave_subprogram(lu); emit_return(value_reg); } static void lower_pcall(lower_unit_t *lu, tree_t pcall) { lower_stmt_coverage(lu, pcall); tree_t decl = tree_ref(pcall); const subprogram_kind_t kind = tree_subkind(decl); if (is_open_coded_builtin(kind)) { lower_builtin(lu, pcall, kind, NULL, NULL); return; } bool use_fcall; switch (vcode_unit_kind(lu->vunit)) { case VCODE_UNIT_FUNCTION: case VCODE_UNIT_THUNK: use_fcall = true; break; case VCODE_UNIT_PROCESS: { tree_t wait = tree_stmt(lu->container, tree_stmts(lu->container) - 1); if (tree_kind(wait) == T_WAIT && (tree_flags(wait) & TREE_F_STATIC_WAIT)) { // This process has a sensitivity list and therefore cannot // wait inside a procedure use_fcall = true; break; } } // Fall-through default: use_fcall = !!(tree_flags(decl) & TREE_F_NEVER_WAITS); break; } const int nparams = tree_params(pcall); SCOPED_A(vcode_reg_t) args = AINIT; ident_t name = tree_ident2(decl); if (tree_kind(pcall) == T_PROT_PCALL && tree_has_name(pcall)) APUSH(args, lower_rvalue(lu, tree_name(pcall))); else APUSH(args, lower_context_for_call(lu, name)); const int arg0 = args.count; for (int i = 0; i < nparams; i++) { vcode_reg_t arg_reg = lower_subprogram_arg(lu, pcall, i); if (!use_fcall) vcode_heap_allocate(arg_reg); APUSH(args, arg_reg); } if (use_fcall) emit_fcall(name, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, args.items, args.count); else { vcode_block_t resume_bb = emit_block(); emit_pcall(name, args.items, args.count, resume_bb); vcode_select_block(resume_bb); emit_resume(name); } // Copy any out parameters passed as aggregates const int nports = tree_ports(decl); for (int i = 0; i < nports; i++) { tree_t p = tree_port(decl, i); if (tree_class(p) != C_VARIABLE || tree_subkind(p) == PORT_IN) continue; tree_t value = tree_value(tree_param(pcall, i)); if (tree_kind(value) != T_AGGREGATE) continue; const int nparts = lower_count_target_parts(value, 0); target_part_t *parts LOCAL = xmalloc_array(nparts, sizeof(target_part_t)); target_part_t *ptr = parts; lower_fill_target_parts(lu, value, PART_ALL, &ptr); assert(ptr == parts + nparts); vcode_reg_t arg_reg = args.items[arg0 + i]; ptr = parts; lower_var_assign_target(lu, &ptr, value, arg_reg, tree_type(value)); assert(ptr == parts + nparts); } } static void lower_wait_free_cb(tree_t t, void *ctx) { int *count = ctx; const tree_kind_t kind = tree_kind(t); if (kind == T_PCALL || kind == T_PROT_PCALL || kind == T_WAIT) (*count)++; } static bool lower_is_wait_free(lower_unit_t *lu, tree_t stmt) { switch (vcode_unit_kind(lu->vunit)) { case VCODE_UNIT_PROCEDURE: case VCODE_UNIT_PROCESS: { int count = 0; tree_visit(stmt, lower_wait_free_cb, &count); return count == 0; } default: return true; // Can never wait } } static void lower_for(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); tree_t r = tree_range(stmt, 0); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); vcode_reg_t dir_reg = lower_range_dir(lu, r); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg); vcode_block_t exit_bb = VCODE_INVALID_BLOCK; int64_t null_const; if (vcode_reg_const(null_reg, &null_const) && null_const) return; // Loop range is always null else { vcode_block_t init_bb = emit_block(); exit_bb = emit_block(); emit_cond(null_reg, exit_bb, init_bb); vcode_select_block(init_bb); } tree_t idecl = tree_decl(stmt, 0); vcode_type_t vtype = lower_type(tree_type(idecl)); vcode_type_t bounds = vtype; vcode_reg_t step_down = emit_const(vtype, -1); vcode_reg_t step_up = emit_const(vtype, 1); vcode_reg_t step_reg = emit_select(dir_reg, step_down, step_up); // If the body of the loop may wait we need to store the bounds in a // variable as the range is evaluated only on entry to the loop const bool is_wait_free = lower_is_wait_free(lu, stmt); vcode_var_t right_var = VCODE_INVALID_VAR, step_var = VCODE_INVALID_VAR; if (!is_wait_free) { right_var = lower_temp_var(lu, "right", vtype, vtype); emit_store(right_reg, right_var); step_var = lower_temp_var(lu, "step", vtype, vtype); emit_store(step_reg, step_var); } int64_t lconst, rconst, dconst; const bool l_is_const = vcode_reg_const(left_reg, &lconst); const bool r_is_const = vcode_reg_const(right_reg, &rconst); if (l_is_const && r_is_const) bounds = vtype_int(MIN(lconst, rconst), MAX(lconst, rconst)); else if ((l_is_const || r_is_const) && vcode_reg_const(dir_reg, &dconst)) { if (dconst == RANGE_TO) bounds = vtype_int(l_is_const ? lconst : vtype_low(vtype), r_is_const ? rconst : vtype_high(vtype)); else bounds = vtype_int(r_is_const ? rconst : vtype_low(vtype), l_is_const ? lconst : vtype_high(vtype)); } ident_t ident = ident_prefix(tree_ident(idecl), tree_ident(stmt), '.'); vcode_var_t ivar = emit_var(vtype, bounds, ident, 0); emit_store(left_reg, ivar); vcode_block_t body_bb = emit_block(); emit_jump(body_bb); vcode_select_block(body_bb); vcode_reg_t ireg = VCODE_INVALID_VAR; if (is_wait_free) { ireg = emit_load(ivar); lower_put_vcode_obj(idecl, ireg, lu); } else lower_put_vcode_obj(idecl, ivar | PARAM_VAR_BIT, lu); if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); loop_stack_t this = { .up = loops, .name = tree_ident(stmt), .test_bb = VCODE_INVALID_BLOCK, .exit_bb = exit_bb }; lower_sequence(lu, stmt, &this); if (this.test_bb != VCODE_INVALID_BLOCK) { // Loop body contained a "next" statement if (!vcode_block_finished()) emit_jump(this.test_bb); vcode_select_block(this.test_bb); } vcode_reg_t rightn_reg = right_reg; if (right_var != VCODE_INVALID_VAR) rightn_reg = emit_load(right_var); vcode_reg_t stepn_reg = step_reg; if (step_var != VCODE_INVALID_VAR) stepn_reg = emit_load(step_var); if (ireg == VCODE_INVALID_REG) ireg = emit_load(ivar); if (!vcode_block_finished()) { vcode_reg_t next_reg = emit_add(ireg, stepn_reg); emit_store(next_reg, ivar); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, ireg, rightn_reg); emit_cond(done_reg, exit_bb, body_bb); } vcode_select_block(exit_bb); if (!is_wait_free) { lower_release_temp(lu, right_var); lower_release_temp(lu, step_var); } } static void lower_while(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); vcode_block_t test_bb = emit_block(); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_jump(test_bb); vcode_select_block(test_bb); vcode_reg_t test = lower_rvalue(lu, tree_value(stmt)); emit_cond(test, body_bb, exit_bb); if (cover_enabled(lu->cover, COVER_MASK_BRANCH)) lower_branch_coverage(lu, stmt, body_bb, exit_bb); vcode_select_block(body_bb); loop_stack_t this = { .up = loops, .name = tree_ident(stmt), .test_bb = test_bb, .exit_bb = exit_bb }; lower_sequence(lu, stmt, &this); if (!vcode_block_finished()) emit_jump(test_bb); vcode_select_block(exit_bb); } static void lower_loop(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_jump(body_bb); vcode_select_block(body_bb); loop_stack_t this = { .up = loops, .name = tree_ident(stmt), .test_bb = body_bb, .exit_bb = exit_bb }; lower_sequence(lu, stmt, &this); if (!vcode_block_finished()) emit_jump(body_bb); vcode_select_block(exit_bb); } static void lower_loop_control(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); vcode_block_t false_bb = emit_block(); if (tree_has_value(stmt)) { vcode_block_t true_bb = emit_block(); vcode_reg_t result = lower_rvalue(lu, tree_value(stmt)); emit_cond(result, true_bb, false_bb); if (cover_enabled(lu->cover, COVER_MASK_BRANCH)) lower_branch_coverage(lu, stmt, true_bb, false_bb); vcode_select_block(true_bb); } ident_t label = tree_ident2(stmt); loop_stack_t *it; for (it = loops; it != NULL && it->name != label; it = it->up) ; assert(it != NULL); if (tree_kind(stmt) == T_EXIT) emit_jump(it->exit_bb); else { if (it->test_bb == VCODE_INVALID_BLOCK) it->test_bb = emit_block(); emit_jump(it->test_bb); } vcode_select_block(false_bb); } static void lower_case_scalar(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { const int nstmts = tree_stmts(stmt); const bool want_coverage = cover_enabled(lu->cover, COVER_MASK_BRANCH); vcode_block_t def_bb = VCODE_INVALID_BLOCK; vcode_block_t exit_bb = emit_block(); vcode_reg_t value_reg = lower_rvalue(lu, tree_value(stmt)); int nchoices = 0; for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(stmt, i); const int nassocs = tree_assocs(alt); nchoices += nassocs; for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); // Pre-filter range choices in case the number of elements is large if (tree_subkind(a) == A_RANGE) { tree_t r = tree_range(a, 0); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); const range_kind_t dir = tree_subkind(r); vcode_reg_t low_reg = dir == RANGE_TO ? left_reg : right_reg; vcode_reg_t high_reg = dir == RANGE_TO ? right_reg : left_reg; vcode_reg_t lcmp_reg = emit_cmp(VCODE_CMP_GEQ, value_reg, low_reg); vcode_reg_t hcmp_reg = emit_cmp(VCODE_CMP_LEQ, value_reg, high_reg); vcode_reg_t hit_reg = emit_and(lcmp_reg, hcmp_reg); vcode_block_t skip_bb = emit_block(); vcode_block_t hit_bb = emit_block(); emit_cond(hit_reg, hit_bb, skip_bb); if (want_coverage) { PUSH_COVER_SCOPE(lu, a); lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK); } vcode_select_block(hit_bb); lower_sequence(lu, alt, loops); if (!vcode_block_finished()) emit_jump(exit_bb); vcode_select_block(skip_bb); } } } vcode_block_t start_bb = vcode_active_block(); vcode_reg_t *cases LOCAL = xcalloc_array(nchoices, sizeof(vcode_reg_t)); vcode_block_t *blocks LOCAL = xcalloc_array(nchoices, sizeof(vcode_block_t)); int cptr = 0; for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(stmt, i); vcode_block_t hit_bb = VCODE_INVALID_BLOCK; const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); const assoc_kind_t kind = tree_subkind(a); if (kind == A_RANGE) continue; // Handled separately above PUSH_COVER_SCOPE(lu, a); if (hit_bb == VCODE_INVALID_BLOCK) hit_bb = emit_block(); // Must track each branch cover item separately vcode_block_t cover_bb = hit_bb; if (want_coverage && nassocs > 1) cover_bb = emit_block(); if (kind == A_OTHERS) { assert(def_bb == VCODE_INVALID_BLOCK); if (want_coverage) { def_bb = cover_bb; lower_branch_coverage(lu, a, cover_bb, VCODE_INVALID_BLOCK); } else def_bb = hit_bb; } else { vcode_select_block(start_bb); cases[cptr] = lower_rvalue(lu, tree_name(a)); if (want_coverage) { blocks[cptr] = cover_bb; lower_branch_coverage(lu, a, cover_bb, VCODE_INVALID_BLOCK); } else blocks[cptr] = hit_bb; cptr++; } if (cover_bb != hit_bb) { vcode_select_block(cover_bb); emit_jump(hit_bb); } } if (hit_bb == VCODE_INVALID_BLOCK) continue; vcode_select_block(hit_bb); lower_sequence(lu, alt, loops); if (!vcode_block_finished()) emit_jump(exit_bb); } assert(cptr <= nchoices); if (def_bb == VCODE_INVALID_BLOCK) def_bb = exit_bb; vcode_select_block(start_bb); emit_case(value_reg, def_bb, cases, blocks, cptr); vcode_select_block(exit_bb); } static void lower_case_array(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX); vcode_type_t voffset = vtype_offset(); tree_t value = tree_value(stmt); type_t type = tree_type(value); vcode_reg_t val_reg = lower_rvalue(lu, tree_value(stmt)); vcode_reg_t data_ptr = lower_array_data(val_reg); vcode_block_t def_bb = VCODE_INVALID_BLOCK; vcode_block_t exit_bb = emit_block(); vcode_block_t hit_bb = VCODE_INVALID_BLOCK; vcode_block_t start_bb = vcode_active_block(); int64_t length = INT64_MAX; if (type_is_unconstrained(type) || !folded_length(range_of(type, 0), &length)) { vcode_reg_t length_reg = lower_array_len(lu, type, 0, val_reg); // Need a runtime check of expression length against choice length vcode_reg_t c0_length_reg; tree_t a0 = tree_assoc(tree_stmt(stmt, 0), 0); if (tree_subkind(a0) == A_NAMED) { tree_t c0 = tree_name(a0); vcode_reg_t c0_reg = lower_rvalue(lu, c0); c0_length_reg = lower_array_len(lu, tree_type(c0), 0, c0_reg); } else c0_length_reg = length_reg; // Only others choice if (!vcode_reg_const(length_reg, &length)) { if (!vcode_reg_const(c0_length_reg, &length)) { error_at(tree_loc(stmt), "cannot determine length of " "case expression"); return; } } vcode_reg_t locus = lower_debug_locus(stmt); emit_length_check(c0_length_reg, length_reg, locus, VCODE_INVALID_REG); } type_t base = type_base_recur(type_elem(type)); assert(type_kind(base) == T_ENUM); const int nbits = ilog2(type_enum_literals(base)); const bool exact_map = length * nbits <= 64; // Limit the number of cases branches we generate so it can be // efficiently implemented with a jump table static const int max_cases = 256; if (!exact_map) { // Hash function may have collisions so need to emit calls to // comparison function if (vcode_reg_kind(val_reg) != VCODE_TYPE_UARRAY) val_reg = lower_wrap(lu, type, val_reg); } vcode_type_t enc_type = VCODE_INVALID_TYPE; vcode_reg_t enc_reg = VCODE_INVALID_REG; if (exact_map && length <= 4) { // Unroll the encoding calculation enc_type = voffset; enc_reg = emit_const(enc_type, 0); for (int64_t i = 0; i < length; i++) { vcode_reg_t i_reg = emit_const(voffset, i); vcode_reg_t ptr_reg = emit_array_ref(data_ptr, i_reg); vcode_reg_t byte_reg = emit_load_indirect(ptr_reg); enc_reg = emit_mul(enc_reg, emit_const(enc_type, 1 << nbits)); enc_reg = emit_add(enc_reg, emit_cast(enc_type, enc_type, byte_reg)); } } else { enc_type = vint64; vcode_var_t enc_var = lower_temp_var(lu, "enc", enc_type, enc_type); emit_store(emit_const(enc_type, 0), enc_var); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = start_bb = emit_block(); emit_jump(body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t ptr_reg = emit_array_ref(data_ptr, i_reg); vcode_reg_t byte_reg = emit_load_indirect(ptr_reg); vcode_reg_t tmp_reg = emit_load(enc_var); if (exact_map) tmp_reg = emit_mul(tmp_reg, emit_const(enc_type, 1 << nbits)); else tmp_reg = emit_mul(tmp_reg, emit_const(enc_type, 0x27d4eb2d)); tmp_reg = emit_add(tmp_reg, emit_cast(enc_type, enc_type, byte_reg)); emit_store(tmp_reg, enc_var); vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1)); emit_store(i_next, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next, emit_const(voffset, length)); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); enc_reg = emit_load(enc_var); if (!exact_map) enc_reg = emit_rem(enc_reg, emit_const(enc_type, max_cases)); lower_release_temp(lu, i_var); lower_release_temp(lu, enc_var); } int nchoices = 0; const int nstmts = tree_stmts(stmt); for (int i = 0; i < nstmts; i++) nchoices += tree_assocs(tree_stmt(stmt, i)); vcode_reg_t *cases LOCAL = xcalloc_array(nchoices, sizeof(vcode_reg_t)); vcode_block_t *blocks LOCAL = xcalloc_array(nchoices, sizeof(vcode_block_t)); int64_t *encoding LOCAL = xcalloc_array(nchoices, sizeof(int64_t)); ident_t cmp_func = NULL; vcode_type_t vbool = vtype_bool(); vcode_block_t fallthrough_bb = VCODE_INVALID_BLOCK; if (!exact_map) { fallthrough_bb = emit_block(); cmp_func = lower_predef_func_name(tree_type(value), "="); } int cptr = 0; for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(stmt, i); const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); const assoc_kind_t kind = tree_subkind(a); assert(kind != A_RANGE); hit_bb = emit_block(); PUSH_COVER_SCOPE(lu, a); if (kind == A_OTHERS) { assert(def_bb == VCODE_INVALID_BLOCK); def_bb = hit_bb; if (cover_enabled(lu->cover, COVER_MASK_BRANCH)) lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK); } else { tree_t name = tree_name(a); const int exact_bits = exact_map ? nbits : 0; int64_t enc = encode_case_choice(name, length, exact_bits); if (!exact_map) enc %= max_cases; vcode_block_t entry_bb = hit_bb; bool have_dup = false; if (!exact_map) { // There may be collisions in the hash function vcode_block_t chain_bb = fallthrough_bb; for (int k = 0; k < cptr; k++) { if (encoding[k] == enc) { chain_bb = blocks[k]; blocks[k] = hit_bb; have_dup = true; break; } } vcode_select_block(hit_bb); hit_bb = emit_block(); vcode_reg_t name_reg = lower_rvalue(lu, name); if (vcode_reg_kind(name_reg) != VCODE_TYPE_UARRAY) name_reg = lower_wrap(lu, tree_type(name), name_reg); vcode_reg_t context_reg = lower_context_for_call(lu, cmp_func); vcode_reg_t args[] = { context_reg, name_reg, val_reg }; vcode_reg_t eq_reg = emit_fcall(cmp_func, vbool, vbool, args, 3); emit_cond(eq_reg, hit_bb, chain_bb); } if (!have_dup) { vcode_select_block(start_bb); cases[cptr] = emit_const(enc_type, enc); blocks[cptr] = entry_bb; encoding[cptr] = enc; // TODO: How to handle have_dup == true ? if (cover_enabled(lu->cover, COVER_MASK_BRANCH)) lower_branch_coverage(lu, a, hit_bb, VCODE_INVALID_BLOCK); cptr++; } } vcode_select_block(hit_bb); lower_sequence(lu, alt, loops); if (!vcode_block_finished()) emit_jump(exit_bb); } } assert(cptr <= nchoices); if (def_bb == VCODE_INVALID_BLOCK) def_bb = exit_bb; if (fallthrough_bb != VCODE_INVALID_BLOCK) { vcode_select_block(fallthrough_bb); emit_jump(def_bb); } vcode_select_block(start_bb); emit_case(enc_reg, def_bb, cases, blocks, cptr); vcode_select_block(exit_bb); } static void lower_case(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_stmt_coverage(lu, stmt); if (type_is_scalar(tree_type(tree_value(stmt)))) lower_case_scalar(lu, stmt, loops); else lower_case_array(lu, stmt, loops); } static void lower_match_case(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { vcode_block_t exit_bb = VCODE_INVALID_BLOCK; tree_t value = tree_value(stmt); type_t type = tree_type(value); const bool is_array = type_is_array(type); type_t scalar = is_array ? type_elem(type) : type; if (type_eq(scalar, std_type(NULL, STD_BIT))) { // The "?=" operator on BIT is the same as "=" so just use a // normal case statement lower_case(lu, stmt, loops); return; } vcode_reg_t value_reg = lower_rvalue(lu, value); if (is_array && vcode_reg_kind(value_reg) != VCODE_TYPE_UARRAY) value_reg = lower_wrap(lu, type, value_reg); ident_t func = ident_new(is_array ? "IEEE.STD_LOGIC_1164.\"?=\"(YY)U$predef" : "IEEE.STD_LOGIC_1164.\"?=\"(UU)U$predef"); vcode_reg_t context_reg = lower_context_for_call(lu, func); vcode_type_t vscalar = lower_type(scalar); vcode_reg_t true_reg = emit_const(vscalar, 3); // STD_LOGIC'POS('1') const int nstmts = tree_stmts(stmt); for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(stmt, i); vcode_block_t hit_bb = emit_block(); vcode_block_t skip_bb = VCODE_INVALID_BLOCK; const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { vcode_block_t loop_bb = VCODE_INVALID_BLOCK; vcode_reg_t test_reg = VCODE_INVALID_REG; vcode_var_t tmp_var = VCODE_INVALID_VAR; tree_t a = tree_assoc(alt, j); switch (tree_subkind(a)) { case A_NAMED: { tree_t name = tree_name(a); test_reg = lower_rvalue(lu, name); if (is_array && vcode_reg_kind(test_reg) != VCODE_TYPE_UARRAY) test_reg = lower_wrap(lu, tree_type(name), test_reg); skip_bb = emit_block(); } break; case A_RANGE: { tree_t r = tree_range(a, 0); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); vcode_reg_t dir_reg = lower_range_dir(lu, r); if (tmp_var == VCODE_INVALID_VAR) tmp_var = lower_temp_var(lu, "i", vscalar, vscalar); emit_store(left_reg, tmp_var); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg); vcode_block_t body_bb = emit_block(); loop_bb = emit_block(); skip_bb = emit_block(); emit_cond(null_reg, skip_bb, body_bb); vcode_select_block(body_bb); test_reg = emit_load(tmp_var); vcode_select_block(loop_bb); vcode_reg_t step_down = emit_const(vscalar, -1); vcode_reg_t step_up = emit_const(vscalar, 1); vcode_reg_t step_reg = emit_select(dir_reg, step_down, step_up); vcode_reg_t next_reg = emit_add(test_reg, step_reg); emit_store(next_reg, tmp_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, test_reg, right_reg); emit_cond(done_reg, skip_bb, body_bb); vcode_select_block(body_bb); } break; case A_OTHERS: emit_jump(hit_bb); continue; } vcode_reg_t args[] = { context_reg, value_reg, test_reg, }; vcode_reg_t result_reg = emit_fcall(func, vscalar, vscalar, args, ARRAY_LEN(args)); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, result_reg, true_reg); if (loop_bb != VCODE_INVALID_BLOCK) emit_cond(cmp_reg, hit_bb, loop_bb); else emit_cond(cmp_reg, hit_bb, skip_bb); vcode_select_block(skip_bb); if (tmp_var != VCODE_INVALID_VAR) lower_release_temp(lu, tmp_var); } vcode_select_block(hit_bb); lower_sequence(lu, alt, loops); if (!vcode_block_finished()) { if (exit_bb == VCODE_INVALID_BLOCK) exit_bb = emit_block(); emit_jump(exit_bb); } if (skip_bb != VCODE_INVALID_BLOCK) vcode_select_block(skip_bb); } if (exit_bb != VCODE_INVALID_BLOCK) { if (!vcode_block_finished()) emit_jump(exit_bb); vcode_select_block(exit_bb); } } static void lower_sequential_block(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { lower_decls(lu, stmt); lower_sequence(lu, stmt, loops); } static void lower_stmt(lower_unit_t *lu, tree_t stmt, loop_stack_t *loops) { if (vcode_block_finished()) return; // Unreachable PUSH_DEBUG_INFO(stmt); PUSH_COVER_SCOPE(lu, stmt); switch (tree_kind(stmt)) { case T_ASSERT: lower_assert(lu, stmt); break; case T_REPORT: lower_report(lu, stmt); break; case T_WAIT: lower_wait(lu, stmt); break; case T_VAR_ASSIGN: lower_var_assign(lu, stmt); break; case T_SIGNAL_ASSIGN: lower_signal_assign(lu, stmt); break; case T_FORCE: lower_force(lu, stmt); break; case T_RELEASE: lower_release(lu, stmt); break; case T_IF: lower_if(lu, stmt, loops); break; case T_RETURN: lower_return(lu, stmt); break; case T_PCALL: case T_PROT_PCALL: lower_pcall(lu, stmt); break; case T_WHILE: lower_while(lu, stmt, loops); break; case T_LOOP: lower_loop(lu, stmt, loops); break; case T_FOR: lower_for(lu, stmt, loops); break; case T_SEQUENCE: lower_sequential_block(lu, stmt, loops); break; case T_EXIT: case T_NEXT: lower_loop_control(lu, stmt, loops); break; case T_CASE: lower_case(lu, stmt, loops); break; case T_MATCH_CASE: lower_match_case(lu, stmt, loops); break; case T_DUMMY_DRIVER: break; default: fatal_at(tree_loc(stmt), "cannot lower statement kind %s", tree_kind_str(tree_kind(stmt))); } } static void lower_check_indexes(lower_unit_t *lu, type_t from, type_t to, vcode_reg_t array, tree_t where) { const int ndims = dimension_of(to); for (int i = 0; i < ndims; i++) { type_t index = index_type_of(to, i); vcode_reg_t ileft_reg, iright_reg, idir_reg; lower_get_scalar_type_bounds(lu, index, &ileft_reg, &iright_reg, &idir_reg); vcode_reg_t aleft_reg = lower_array_left(lu, from, i, array); vcode_reg_t aright_reg = lower_array_right(lu, from, i, array); vcode_reg_t adir_reg = lower_array_dir(lu, from, i, array); vcode_reg_t null_reg = emit_range_null(aleft_reg, aright_reg, adir_reg); vcode_block_t after_bb = VCODE_INVALID_BLOCK; int64_t null_const; if (vcode_reg_const(null_reg, &null_const)) { if (null_const == 1) continue; // Array range is statically known to be null } else { vcode_block_t check_bb = emit_block(); after_bb = emit_block(); emit_cond(null_reg, after_bb, check_bb); vcode_select_block(check_bb); } vcode_reg_t hint_reg; if (type_is_unconstrained(to)) hint_reg = lower_debug_locus(range_of(index, 0)); else hint_reg = lower_debug_locus(range_of(to, i)); vcode_reg_t locus = where ? lower_debug_locus(where) : hint_reg; emit_index_check(aleft_reg, ileft_reg, iright_reg, idir_reg, locus, hint_reg); emit_index_check(aright_reg, ileft_reg, iright_reg, idir_reg, locus, hint_reg); if (after_bb != VCODE_INVALID_BLOCK) { emit_jump(after_bb); vcode_select_block(after_bb); } } } static vcode_reg_t lower_var_constraints(lower_unit_t *lu, type_t var_type, type_t init_type, vcode_reg_t init_reg, vcode_reg_t mem_reg) { assert(type_is_array(var_type)); assert(type_is_array(init_type)); const int ncons = dims_for_type(var_type); vcode_dim_t dims[ncons]; int dptr = 0; int udims = 0; if (have_array_metadata(init_type, init_reg)) udims = vtype_dims(vcode_reg_type(init_reg)); for (; dptr < ncons; init_type = type_elem(init_type), var_type = type_elem(var_type)) { tree_t c = NULL; for (type_t iter = var_type; type_kind(iter) == T_SUBTYPE; iter = type_base(iter)) { if (type_has_constraint(iter)) { tree_t c0 = type_constraint(iter); if (tree_subkind(c0) == C_INDEX) { c = c0; break; } } } const int ndims = dimension_of(var_type); for (int i = 0; i < ndims; i++, dptr++) { if (c != NULL) { tree_t r = tree_range(c, i); dims[dptr].left = lower_range_left(lu, r); dims[dptr].right = lower_range_right(lu, r); dims[dptr].dir = lower_range_dir(lu, r); } else if (dptr < udims) { dims[dptr].left = emit_uarray_left(init_reg, dptr); dims[dptr].right = emit_uarray_right(init_reg, dptr); dims[dptr].dir = emit_uarray_dir(init_reg, dptr); } else { tree_t r = range_of(init_type, i); dims[dptr].left = lower_range_left(lu, r); dims[dptr].right = lower_range_right(lu, r); dims[dptr].dir = lower_range_dir(lu, r); } } } assert(dptr == ncons); return emit_wrap(mem_reg, dims, ncons); } static void lower_var_decl(lower_unit_t *lu, tree_t decl) { type_t type = tree_type(decl); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); const bool is_const = tree_kind(decl) == T_CONST_DECL; bool skip_copy = false; if (is_const && !tree_has_value(decl)) { // Deferred constant in package return; } else if (is_const && type_is_array(type) && !type_const_bounds(type) // TODO: remove this restriction && lower_is_const(tree_value(decl))) { skip_copy = true; // Will be allocated in constant data } vcode_var_flags_t flags = 0; if (is_const) flags |= VAR_CONST; vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), flags); lower_put_vcode_obj(decl, var, lu); if (type_is_protected(type)) { vcode_reg_t obj_reg = lower_protected_init(lu, type, decl); emit_store(obj_reg, var); return; } emit_debug_info(tree_loc(decl)); vcode_reg_t bounds_reg = VCODE_INVALID_REG; vcode_reg_t dest_reg = VCODE_INVALID_REG; vcode_reg_t count_reg = VCODE_INVALID_REG; vcode_reg_t mem_reg = VCODE_INVALID_REG; if (type_is_record(type)) dest_reg = emit_index(var, VCODE_INVALID_REG); else if (type_is_array(type)) { if (needs_bounds_var(type)) { bounds_reg = lower_get_type_bounds(lu, type); count_reg = lower_array_total_len(lu, type, bounds_reg); vcode_type_t velem = lower_type(type_elem_recur(type)); mem_reg = emit_alloc(velem, vbounds, count_reg); dest_reg = lower_rewrap(mem_reg, bounds_reg); emit_store(dest_reg, var); } else if (!type_is_unconstrained(type)) { count_reg = lower_array_total_len(lu, type, bounds_reg); dest_reg = mem_reg = emit_index(var, VCODE_INVALID_REG); } } type_t value_type = NULL; vcode_reg_t value_reg; if (tree_has_value(decl)) { tree_t value = tree_value(decl); value_type = tree_type(value); if (tree_kind(value) == T_AGGREGATE) value_reg = lower_aggregate(lu, value, dest_reg); else value_reg = lower_known_subtype(lu, value, type, bounds_reg); } else { value_type = type; value_reg = lower_default_value(lu, type, dest_reg); } if (type_is_array(type)) { vcode_reg_t data_reg = lower_array_data(value_reg); if (is_const && skip_copy) { vcode_reg_t wrap_reg = lower_coerce_arrays(lu, value_type, type, value_reg); emit_store(wrap_reg, var); } else if (type_is_unconstrained(type)) { count_reg = lower_array_total_len(lu, value_type, value_reg); type_t scalar_elem = type_elem_recur(type); dest_reg = emit_alloc(lower_type(scalar_elem), lower_bounds(scalar_elem), count_reg); emit_copy(dest_reg, data_reg, count_reg); vcode_reg_t wrap_reg = lower_var_constraints(lu, type, value_type, value_reg, dest_reg); vcode_reg_t locus = lower_debug_locus(decl); lower_check_array_sizes(lu, type, value_type, wrap_reg, value_reg, locus); emit_store(wrap_reg, var); } else { vcode_reg_t locus = lower_debug_locus(decl); lower_check_indexes(lu, value_type, type, value_reg, NULL); lower_check_array_sizes(lu, type, value_type, dest_reg, value_reg, locus); emit_copy(mem_reg, data_reg, count_reg); } } else if (type_is_record(type)) lower_new_record(lu, type, dest_reg, value_reg); else if (type_is_scalar(type)) { lower_check_scalar_bounds(lu, value_reg, type, decl, decl); emit_store(value_reg, var); } else if (type_is_access(type)) { type_t designated = type_designated(type); vcode_reg_t src_reg = lower_incomplete_access(value_reg, designated); emit_store(src_reg, var); } else emit_store(value_reg, var); } static void lower_resolution_wrapper(lower_unit_t *lu, object_t *obj) { type_t type = type_from_object(obj); assert(type_has_resolution(type)); tree_t rname = type_resolution(type); type_t elem = type; while (tree_kind(rname) == T_ELEM_RESOLUTION) { assert(type_is_array(type)); assert(tree_assocs(rname) == 1); rname = tree_value(tree_assoc(rname, 0)); elem = type_elem(elem); } tree_t rdecl = tree_ref(rname); ident_t rfunc = tree_ident2(rdecl); type_t uarray_param = type_param(tree_type(rdecl), 0); assert(type_kind(uarray_param) == T_ARRAY); tree_t r = range_of(type_index(uarray_param, 0), 0); vcode_type_t velem = lower_type(type_elem_recur(elem)); vcode_reg_t vbounds = lower_bounds(elem); vcode_type_t rtype = lower_func_result_type(type); vcode_type_t atype = vtype_pointer(velem); vcode_type_t vuint32 = vtype_int(0, UINT32_MAX); vcode_type_t voffset = vtype_offset(); vcode_set_result(rtype); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t data_reg = emit_param(atype, vbounds, ident_new("p")); vcode_reg_t count_reg = emit_param(vuint32, vuint32, ident_new("count")); vcode_reg_t left_reg = emit_const(voffset, assume_int(tree_left(r))); vcode_reg_t one_reg = emit_const(voffset, 1); vcode_reg_t cast_reg = emit_cast(voffset, voffset, count_reg); vcode_reg_t right_reg = emit_sub(emit_add(left_reg, cast_reg), one_reg); vcode_dim_t dims[] = { { .left = left_reg, .right = right_reg, .dir = emit_const(vtype_bool(), RANGE_TO) } }; vcode_reg_t wrap_reg = emit_wrap(data_reg, dims, 1); vcode_reg_t context_reg = lower_context_for_call(lu, rfunc); vcode_reg_t args[] = { context_reg, wrap_reg }; vcode_reg_t call_reg = emit_fcall(rfunc, rtype, vbounds, args, 2); emit_return(call_reg); } static void lower_resolution_var(lower_unit_t *lu, tree_t decl, type_t type) { tree_t rname = type_resolution(type); type_t elem = type; while (tree_kind(rname) == T_ELEM_RESOLUTION) { assert(type_is_array(type)); assert(tree_assocs(rname) == 1); rname = tree_value(tree_assoc(rname, 0)); elem = type_elem(elem); } vcode_reg_t nlits_reg; if (type_is_enum(elem)) { // This resolution function can potentially be memoised if (type_kind(elem) == T_SUBTYPE) { int64_t low, high; range_bounds(range_of(elem, 0), &low, &high); nlits_reg = emit_const(vtype_offset(), high - low + 1); } else nlits_reg = emit_const(vtype_offset(), type_enum_literals(elem)); } else nlits_reg = emit_const(vtype_offset(), 0); ident_t prefix; if (is_anonymous_subtype(type)) prefix = tree_ident(decl); else prefix = type_ident(type); ident_t name = ident_prefix(prefix, well_known(W_RESOLUTION), '$'); unit_registry_defer(lu->registry, name, lu, emit_function, lower_resolution_wrapper, NULL, type_to_object(type)); vcode_type_t rtype = lower_func_result_type(type); vcode_reg_t context_reg = emit_context_upref(0); vcode_reg_t closure_reg = emit_closure(name, context_reg, rtype); vcode_reg_t wrapper_reg = emit_resolution_wrapper(rtype, closure_reg, nlits_reg); vcode_type_t vresolution = vcode_reg_type(wrapper_reg); vcode_var_t var = emit_var(vresolution, vresolution, name, VAR_CONST); emit_store(wrapper_reg, var); lower_put_vcode_obj(type, var, lu); } static vcode_reg_t lower_resolution_func(lower_unit_t *lu, type_t type, bool *is_array) { type_t rtype = NULL; for (type_t t = type; type_kind(t) == T_SUBTYPE; t = type_base(t)) { if (type_has_resolution(t)) { rtype = t; break; } } if (rtype == NULL && type_is_array(type)) return lower_resolution_func(lu, type_elem(type), is_array); else if (rtype == NULL) return VCODE_INVALID_REG; tree_t rname = type_resolution(rtype); type_t elem = rtype; while (tree_kind(rname) == T_ELEM_RESOLUTION) { assert(type_is_array(type)); assert(tree_assocs(rname) == 1); rname = tree_value(tree_assoc(rname, 0)); elem = type_elem(elem); } *is_array = type_is_array(elem); int hops; vcode_var_t var = lower_search_vcode_obj(rtype, lu, &hops); if (var == VCODE_INVALID_VAR) { vcode_type_t vtype = lower_func_result_type(elem); ident_t var_name = ident_prefix(type_ident(rtype), well_known(W_RESOLUTION), '$'); vcode_reg_t context_reg = lower_context_for_call(lu, var_name); return emit_link_var(context_reg, var_name, vtype_resolution(vtype)); } else if (hops == 0) return emit_index(var, VCODE_INVALID_REG); else return emit_var_upref(hops, var); } static void lower_sub_signals(lower_unit_t *lu, type_t type, type_t var_type, type_t init_type, tree_t where, tree_t view, vcode_var_t sig_var, vcode_reg_t sig_ptr, vcode_reg_t init_reg, vcode_reg_t resolution, vcode_reg_t null_reg, sig_flags_t flags, vcode_reg_t bounds_reg) { bool has_scope = false; if (resolution == VCODE_INVALID_REG) resolution = lower_resolution_func(lu, type, &has_scope); if (type_is_scalar(type)) { vcode_type_t voffset = vtype_offset(); vcode_reg_t size_reg = emit_const(voffset, type_byte_width(type)); vcode_reg_t len_reg = emit_const(voffset, 1); vcode_type_t vtype = lower_type(type); vcode_reg_t locus = lower_debug_locus(where); if (init_reg == VCODE_INVALID_REG) init_reg = lower_scalar_type_left(lu, type); lower_check_scalar_bounds(lu, init_reg, type, where, where); assert(!has_scope); well_known_t wk = is_well_known(type_ident(type_base_recur(type))); if (wk == W_IEEE_ULOGIC || wk == W_IEEE_LOGIC) flags |= SIG_F_STD_LOGIC; vcode_reg_t flags_reg = emit_const(voffset, flags); vcode_reg_t sig = emit_init_signal(vtype, len_reg, size_reg, init_reg, flags_reg, locus, null_reg); if (resolution != VCODE_INVALID_REG) emit_resolve_signal(sig, resolution); if (sig_var != VCODE_INVALID_VAR) emit_store(sig, sig_var); else emit_store_indirect(sig, sig_ptr); } else if (type_is_homogeneous(type)) { assert(type_is_array(type)); vcode_type_t voffset = vtype_offset(); vcode_reg_t size_reg = emit_const(voffset, type_byte_width(type)); vcode_reg_t len_reg = lower_array_total_len(lu, type, bounds_reg); vcode_type_t vtype = lower_type(type_elem_recur(type)); vcode_reg_t locus = lower_debug_locus(where); if (init_reg == VCODE_INVALID_REG) init_reg = lower_scalar_type_left(lu, type_elem_recur(type)); else { lower_check_array_sizes(lu, type, init_type, bounds_reg, init_reg, locus); init_reg = lower_array_data(init_reg); } if (has_scope) emit_array_scope(locus, lower_type(type)); well_known_t wk = is_well_known(type_ident(type_base_recur(type))); if (wk == W_IEEE_ULOGIC_VECTOR || wk == W_IEEE_LOGIC_VECTOR) flags |= SIG_F_STD_LOGIC; vcode_reg_t flags_reg = emit_const(voffset, flags); vcode_reg_t sig = emit_init_signal(vtype, len_reg, size_reg, init_reg, flags_reg, locus, null_reg); if (resolution != VCODE_INVALID_REG) emit_resolve_signal(sig, resolution); if (bounds_reg != VCODE_INVALID_REG) sig = lower_rewrap(sig, bounds_reg); else sig = lower_coerce_arrays(lu, type, var_type, sig); if (sig_var != VCODE_INVALID_VAR) emit_store(sig, sig_var); else emit_store_indirect(sig, sig_ptr); if (has_scope) emit_pop_scope(); } else if (type_is_array(type)) { // Array of non-homogeneous type (e.g. records). Need a loop to // initialise each sub-signal. type_t elem = type_elem_recur(type); if (null_reg == VCODE_INVALID_REG || have_uarray_ptr(null_reg)) null_reg = emit_null(vtype_pointer(lower_type(elem))); if (sig_ptr == VCODE_INVALID_REG) sig_ptr = emit_index(sig_var, VCODE_INVALID_REG); vcode_reg_t locus = lower_debug_locus(where); if (init_reg != VCODE_INVALID_REG) lower_check_array_sizes(lu, type, init_type, bounds_reg, init_reg, locus); vcode_reg_t len_reg = lower_array_total_len(lu, type, bounds_reg); if (have_uarray_ptr(sig_ptr)) { // Need to allocate separate memory for the array vcode_type_t vtype = lower_signal_type(elem); vcode_type_t vbounds = lower_bounds(elem); vcode_reg_t mem_reg = emit_alloc(vtype, vbounds, len_reg); vcode_reg_t wrap_reg; if (bounds_reg != VCODE_INVALID_REG) wrap_reg = lower_rewrap(mem_reg, bounds_reg); else wrap_reg = lower_wrap(lu, type, mem_reg); emit_store_indirect(wrap_reg, sig_ptr); sig_ptr = mem_reg; } vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); emit_array_scope(locus, lower_type(type)); vcode_block_t cmp_bb = emit_block(); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_jump(cmp_bb); vcode_select_block(cmp_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t eq_reg = emit_cmp(VCODE_CMP_EQ, i_reg, len_reg); emit_cond(eq_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t ptr_reg = emit_array_ref(sig_ptr, i_reg); vcode_reg_t null_off_reg = emit_array_ref(null_reg, i_reg); vcode_reg_t data_reg = VCODE_INVALID_REG; if (init_reg != VCODE_INVALID_REG) data_reg = emit_array_ref(lower_array_data(init_reg), i_reg); vcode_reg_t ebounds_reg = VCODE_INVALID_REG; if (bounds_reg != VCODE_INVALID_REG && type_is_unconstrained(elem)) ebounds_reg = emit_unwrap(bounds_reg); lower_sub_signals(lu, elem, elem, elem, where, view, VCODE_INVALID_VAR, ptr_reg, data_reg, resolution, null_off_reg, flags, ebounds_reg); emit_store(emit_add(i_reg, emit_const(voffset, 1)), i_var); emit_jump(cmp_bb); vcode_select_block(exit_bb); emit_pop_scope(); lower_release_temp(lu, i_var); } else if (type_is_record(type)) { vcode_type_t vtype = lower_type(type); emit_record_scope(lower_debug_locus(where), vtype); if (null_reg == VCODE_INVALID_REG) null_reg = emit_null(vtype_pointer(vtype)); if (sig_ptr == VCODE_INVALID_REG) sig_ptr = emit_index(sig_var, VCODE_INVALID_REG); type_t base = type_base_recur(type); const int nfields = type_fields(base); for (int i = 0; i < nfields; i++) { tree_t f = type_field(base, i); type_t ft = tree_type(f), et = ft; if (base != type && type_is_unconstrained(ft)) { tree_t ec = type_constraint_for_field(type, f); if (ec != NULL) et = tree_type(ec); } sig_flags_t newflags = flags; tree_t fview = NULL; if (view != NULL) { bool converse = false; tree_t e = find_element_mode_indication(view, f, &converse); assert(e != NULL); switch (tree_subkind(e)) { case PORT_INOUT: newflags |= NET_F_EFFECTIVE | NET_F_INOUT; break; case PORT_ARRAY_VIEW: case PORT_RECORD_VIEW: fview = tree_value(e); break; } } vcode_type_t fvtype = vtype_field(vtype, i); vcode_reg_t null_field_reg; if (vtype_kind(fvtype) == VCODE_TYPE_UARRAY) null_field_reg = emit_null(vtype_pointer(fvtype)); else null_field_reg = emit_record_ref(null_reg, i); vcode_reg_t field_reg = VCODE_INVALID_REG; if (init_reg != VCODE_INVALID_REG) { field_reg = emit_record_ref(init_reg, i); if (have_uarray_ptr(field_reg)) field_reg = emit_load_indirect(field_reg); else if (type_is_scalar(ft)) field_reg = emit_load_indirect(field_reg); } vcode_reg_t fbounds_reg = VCODE_INVALID_REG; if (bounds_reg != VCODE_INVALID_REG && type_is_unconstrained(ft)) { fbounds_reg = emit_record_ref(bounds_reg, i); if (have_uarray_ptr(fbounds_reg)) fbounds_reg = emit_load_indirect(fbounds_reg); } vcode_reg_t ptr_reg = emit_record_ref(sig_ptr, i); lower_sub_signals(lu, et, ft, ft, f, fview, VCODE_INVALID_VAR, ptr_reg, field_reg, resolution, null_field_reg, newflags, fbounds_reg); } emit_pop_scope(); } else fatal_trace("unhandled type %s in lower_sub_signals", type_pp(type)); } static void lower_signal_decl(lower_unit_t *lu, tree_t decl) { type_t type = tree_type(decl); vcode_type_t vtype = lower_signal_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), VAR_SIGNAL); lower_put_vcode_obj(decl, var, lu); type_t value_type = type; vcode_reg_t init_reg = VCODE_INVALID_REG; if (tree_has_value(decl)) { tree_t value = tree_value(decl); value_type = tree_type(value); init_reg = lower_known_subtype(lu, value, type, VCODE_INVALID_REG); } vcode_reg_t bounds_reg = VCODE_INVALID_REG; if (standard() >= STD_19 && type_is_unconstrained(type)) { type = value_type; bounds_reg = init_reg; } else if (needs_bounds_var(type)) bounds_reg = lower_get_type_bounds(lu, type); if (is_anonymous_subtype(type) && type_has_resolution(type)) lower_resolution_var(lu, decl, type); sig_flags_t flags = 0; if (tree_flags(decl) & TREE_F_REGISTER) flags |= SIG_F_REGISTER; lower_sub_signals(lu, type, type, value_type, decl, NULL, var, VCODE_INVALID_REG, init_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, flags, bounds_reg); PUSH_COVER_SCOPE(lu, decl); if (cover_enabled(lu->cover, COVER_MASK_TOGGLE)) lower_toggle_coverage(lu, decl); if (cover_enabled(lu->cover, COVER_MASK_STATE)) lower_state_coverage(lu, decl); } static void lower_build_wait_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t value, vcode_reg_t locus, void *ctx) { type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t nets_reg = emit_load_indirect(ptr); vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_sched_event(data_reg, count_reg); } else lower_for_each_field_2(lu, ftype, ftype, ptr, value, locus, lower_build_wait_field_cb, ctx); } static void lower_build_wait_cb(tree_t expr, void *ctx) { lower_unit_t *lu = ctx; type_t type = tree_type(expr); vcode_reg_t nets_reg = lower_lvalue(lu, expr); if (type_is_homogeneous(type)) { vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_sched_event(data_reg, count_reg); } else lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG, lower_build_wait_field_cb, NULL); } static void lower_implicit_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t value, vcode_reg_t locus, void *ctx) { vcode_reg_t sig_reg = (intptr_t)ctx; type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t nets_reg = emit_load_indirect(ptr); vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_map_implicit(data_reg, sig_reg, count_reg); } else lower_for_each_field(lu, ftype, ptr, locus, lower_implicit_field_cb, ctx); } static void lower_implicit_delayed(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); assert(tree_kind(decl) == T_IMPLICIT_SIGNAL); tree_t wave = tree_value(decl); assert(tree_kind(wave) == T_WAVEFORM); type_t type = tree_type(decl); tree_t expr = tree_value(wave); vcode_reg_t nets_reg = lower_signal_ref(lu, decl); if (type_is_homogeneous(type)) { vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_drive_signal(data_reg, count_reg); } else lower_for_each_field(lu, type, nets_reg, VCODE_INVALID_REG, lower_driver_field_cb, NULL); build_wait(expr, lower_build_wait_cb, lu); emit_return(VCODE_INVALID_REG); vcode_block_t main_bb = emit_block(); vcode_select_block(main_bb); vcode_type_t vtime = vtype_time(); vcode_reg_t delay_reg; if (tree_has_delay(wave)) delay_reg = lower_rvalue(lu, tree_delay(wave)); else delay_reg = emit_const(vtime, 0); vcode_reg_t reject_reg = emit_const(vtime, 0); vcode_reg_t value_reg = lower_rvalue(lu, expr); target_part_t parts[] = { { .kind = PART_ALL, .reg = lower_signal_ref(lu, decl), .off = VCODE_INVALID_REG, .target = decl }, { .kind = PART_POP, .reg = VCODE_INVALID_REG, .off = VCODE_INVALID_REG, } }; target_part_t *ptr = parts; lower_signal_assign_target(lu, &ptr, decl, value_reg, type, reject_reg, delay_reg); emit_return(VCODE_INVALID_REG); } static void lower_implicit_transaction(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); assert(tree_kind(decl) == T_IMPLICIT_SIGNAL); vcode_type_t vtype = lower_type(tree_type(decl)); vcode_set_result(vtype); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t preg = emit_param(vtype, vtype, ident_new("p")); emit_return(emit_not(preg)); } static void lower_implicit_stable(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); assert(tree_kind(decl) == T_IMPLICIT_SIGNAL); vcode_type_t vtype = lower_type(tree_type(decl)); vcode_set_result(vtype); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); tree_t w = tree_value(decl); assert(tree_kind(w) == T_WAVEFORM); tree_t prefix = tree_value(w); lower_signal_flag_fn_t fn = tree_subkind(decl) == IMPLICIT_STABLE ? emit_event_flag : emit_active_flag; vcode_reg_t flag_reg = lower_signal_flag(lu, prefix, fn); emit_return(emit_not(flag_reg)); } static void lower_implicit_guard(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); assert(tree_kind(decl) == T_IMPLICIT_SIGNAL); vcode_type_t vtype = lower_type(tree_type(decl)); vcode_set_result(vtype); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); tree_t expr = tree_value(decl); build_wait(expr, lower_build_wait_cb, lu); emit_return(lower_rvalue(lu, expr)); } static void lower_implicit_decl(lower_unit_t *parent, tree_t decl) { ident_t name = tree_ident(decl); type_t type = tree_type(decl); const implicit_kind_t kind = tree_subkind(decl); vcode_type_t signal_type = lower_signal_type(type); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t var = emit_var(signal_type, vbounds, name, VAR_SIGNAL); lower_put_vcode_obj(decl, var, parent); switch (kind) { case IMPLICIT_GUARD: { ident_t qual = ident_prefix(parent->name, name, '.'); ident_t func = ident_prefix(qual, ident_new("guard"), '$'); unit_registry_defer(parent->registry, func, parent, emit_function, lower_implicit_guard, NULL, tree_to_object(decl)); vcode_reg_t one_reg = emit_const(vtype_offset(), 1); vcode_reg_t locus = lower_debug_locus(decl); vcode_reg_t context_reg = lower_context_for_call(parent, func); vcode_reg_t closure = emit_closure(func, context_reg, vtype); vcode_reg_t delay_reg = emit_const(vtype_time(), TIME_HIGH); vcode_reg_t kind_reg = emit_const(vtype_offset(), IMPLICIT_GUARD); vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus, kind_reg, closure, delay_reg); emit_store(sig, var); } break; case IMPLICIT_DELAYED: { vcode_reg_t init_reg = lower_default_value(parent, type, VCODE_INVALID_REG); lower_sub_signals(parent, type, type, type, decl, NULL, var, VCODE_INVALID_REG, init_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, 0, VCODE_INVALID_REG); object_t *obj = tree_to_object(decl); ident_t name = ident_prefix(parent->name, tree_ident(decl), '.'); unit_registry_defer(parent->registry, name, parent, emit_process, lower_implicit_delayed, NULL, obj); emit_process_init(name, lower_debug_locus(decl)); } break; case IMPLICIT_TRANSACTION: { object_t *obj = tree_to_object(decl); ident_t qual = ident_prefix(parent->name, name, '.'); unit_registry_defer(parent->registry, qual, parent, emit_function, lower_implicit_transaction, NULL, obj); vcode_reg_t locus = lower_debug_locus(decl); vcode_type_t voffset = vtype_offset(); vcode_reg_t one_reg = emit_const(voffset, 1); vcode_reg_t delay_reg = emit_const(vtype_time(), TIME_HIGH); vcode_reg_t kind_reg = emit_const(voffset, IMPLICIT_TRANSACTION); vcode_reg_t context_reg = lower_context_for_call(parent, qual); vcode_reg_t closure = emit_closure(qual, context_reg, vtype); vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus, kind_reg, closure, delay_reg); emit_store(sig, var); tree_t prefix = tree_value(decl); type_t type = tree_type(prefix); vcode_reg_t prefix_reg = lower_attr_prefix(parent, prefix); if (type_is_homogeneous(type)) { vcode_reg_t count_reg = lower_type_width(parent, type, prefix_reg); vcode_reg_t nets_reg = lower_array_data(prefix_reg); emit_map_implicit(nets_reg, sig, count_reg); } else lower_for_each_field(parent, type, prefix_reg, locus, lower_implicit_field_cb, (void *)(intptr_t)sig); } break; case IMPLICIT_STABLE: case IMPLICIT_QUIET: { ident_t qual = ident_prefix(parent->name, name, '.'); object_t *obj = tree_to_object(decl); unit_registry_defer(parent->registry, qual, parent, emit_function, lower_implicit_stable, NULL, obj); tree_t w = tree_value(decl); assert(tree_kind(w) == T_WAVEFORM); vcode_reg_t delay_reg; if (tree_has_delay(w)) delay_reg = lower_rvalue(parent, tree_delay(w)); else delay_reg = emit_const(vtype_time(), 0); vcode_reg_t one_reg = emit_const(vtype_offset(), 1); vcode_reg_t locus = lower_debug_locus(decl); vcode_reg_t context_reg = lower_context_for_call(parent, qual); vcode_reg_t closure = emit_closure(qual, context_reg, vtype); vcode_reg_t kind_reg = emit_const(vtype_offset(), kind); vcode_reg_t sig = emit_implicit_signal(vtype, one_reg, one_reg, locus, kind_reg, closure, delay_reg); emit_store(sig, var); tree_t prefix = tree_value(w); vcode_reg_t prefix_reg = lower_attr_prefix(parent, prefix); type_t prefix_type = tree_type(prefix); if (type_is_homogeneous(prefix_type)) { vcode_reg_t count_reg = lower_type_width(parent, prefix_type, prefix_reg); vcode_reg_t nets_reg = lower_array_data(prefix_reg); emit_map_implicit(nets_reg, sig, count_reg); } else lower_for_each_field(parent, prefix_type, prefix_reg, locus, lower_implicit_field_cb, (void *)(intptr_t)sig); } break; } } static void lower_file_decl(lower_unit_t *lu, tree_t decl) { type_t type = tree_type(decl); vcode_type_t vtype = lower_type(type); vcode_var_t var = emit_var(vtype, vtype, tree_ident(decl), 0); lower_put_vcode_obj(decl, var, lu); emit_store(emit_null(vtype), var); if (tree_has_value(decl)) { // Generate initial call to file_open tree_t value = tree_value(decl); vcode_reg_t name_array = lower_rvalue(lu, tree_value(decl)); vcode_reg_t name_data = lower_array_data(name_array); vcode_reg_t name_len = lower_array_len(lu, tree_type(value), 0, name_array); vcode_reg_t file_ptr = emit_index(var, VCODE_INVALID_REG); vcode_reg_t mode = lower_rvalue(lu, tree_file_mode(decl)); emit_file_open(file_ptr, name_data, name_len, mode, VCODE_INVALID_REG); } } static vcode_type_t lower_alias_type(tree_t alias) { tree_t value = tree_value(alias); const class_t class = class_of(value); type_t type = tree_has_type(alias) ? tree_type(alias) : tree_type(value); if (type_is_array(type)) { vcode_type_t velem; switch (class) { case C_SIGNAL: velem = lower_signal_type(type_elem_recur(type)); break; case C_VARIABLE: case C_CONSTANT: velem = lower_type(type_elem_recur(type)); break; default: return VCODE_INVALID_TYPE; } vcode_type_t vbounds = lower_bounds(type); return vtype_uarray(dims_for_type(type), velem, vbounds); } else return VCODE_INVALID_TYPE; } static void lower_alias_decl(lower_unit_t *lu, tree_t decl) { tree_t value = tree_value(decl); if (tree_kind(value) == T_EXTERNAL_NAME) { // Avoid null check on every access to the external name lower_external_name(lu, value); return; } vcode_type_t vtype = lower_alias_type(decl); if (vtype == VCODE_INVALID_TYPE) return; type_t value_type = tree_type(value); type_t type = tree_has_type(decl) ? tree_type(decl) : value_type; vcode_reg_t value_reg; vcode_var_flags_t flags = 0; if (class_of(value) == C_SIGNAL) { flags |= VAR_SIGNAL; value_reg = lower_lvalue(lu, value); } else value_reg = lower_rvalue(lu, value); vcode_type_t vbounds = lower_bounds(type); vcode_var_t var = emit_var(vtype, vbounds, tree_ident(decl), flags); lower_put_vcode_obj(decl, var, lu); if (type_is_array(type)) { vcode_reg_t data_reg = lower_array_data(value_reg); vcode_reg_t wrap_reg = lower_var_constraints(lu, type, value_type, value_reg, data_reg); vcode_reg_t locus = lower_debug_locus(decl); lower_check_array_sizes(lu, type, value_type, wrap_reg, value_reg, locus); emit_store(wrap_reg, var); } else emit_store(value_reg, var); } static void lower_character_array_image_helper(lower_unit_t *lu, type_t type, vcode_reg_t preg, bool quote) { type_t elem = type_base_recur(type_elem(type)); vcode_type_t ctype = vtype_char(); vcode_type_t voffset = vtype_offset(); const int nlits = type_enum_literals(elem); vcode_reg_t *map LOCAL = xmalloc_array(nlits, sizeof(vcode_reg_t)); for (int i = 0; i < nlits; i++) { const ident_t id = tree_ident(type_enum_literal(elem, i)); assert(ident_char(id, 0) == '\''); map[i] = emit_const(ctype, ident_char(id, 1)); } vcode_type_t map_vtype = vtype_carray(nlits, ctype, ctype); vcode_reg_t map_reg = emit_const_array(map_vtype, map, nlits); vcode_reg_t zero_reg = emit_const(voffset, 0); vcode_reg_t one_reg = emit_const(voffset, 1); vcode_reg_t two_reg = emit_const(voffset, 2); vcode_reg_t length_reg = lower_array_len(lu, type, 0, preg); vcode_reg_t data_reg = lower_array_data(preg); vcode_reg_t total_reg = quote ? emit_add(length_reg, two_reg) : length_reg; vcode_reg_t mem_reg = emit_alloc(ctype, ctype, total_reg); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(zero_reg, i_var); if (quote) { vcode_reg_t lquote_reg = emit_array_ref(mem_reg, zero_reg); emit_store_indirect(emit_const(ctype, '"'), lquote_reg); } vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, length_reg, zero_reg); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t sptr_reg = emit_array_ref(data_reg, i_reg); vcode_reg_t src_reg = emit_load_indirect(sptr_reg); vcode_reg_t off_reg = emit_cast(voffset, voffset, src_reg); vcode_reg_t lptr_reg = emit_array_ref(emit_address_of(map_reg), off_reg); vcode_reg_t doff_reg = quote ? emit_add(i_reg, one_reg) : i_reg; vcode_reg_t dptr_reg = emit_array_ref(mem_reg, doff_reg); emit_store_indirect(emit_load_indirect(lptr_reg), dptr_reg); vcode_reg_t next_reg = emit_add(i_reg, one_reg); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, next_reg, length_reg); emit_store(next_reg, i_var); emit_cond(cmp_reg, exit_bb, body_bb); vcode_select_block(exit_bb); if (quote) { vcode_reg_t right_reg = emit_add(length_reg, one_reg); vcode_reg_t rquote_reg = emit_array_ref(mem_reg, right_reg); emit_store_indirect(emit_const(ctype, '"'), rquote_reg); } vcode_dim_t dims[] = { { .left = emit_const(voffset, 1), .right = total_reg, .dir = emit_const(vtype_bool(), RANGE_TO) } }; emit_return(emit_wrap(mem_reg, dims, 1)); } static void lower_enum_value_helper(lower_unit_t *lu, type_t type, tree_t decl, vcode_reg_t preg) { const int nlits = type_enum_literals(type); assert(nlits >= 1); vcode_reg_t arg_len_reg = emit_uarray_len(preg, 0); vcode_reg_t arg_data_reg = emit_unwrap(preg); vcode_type_t voffset = vtype_offset(); vcode_type_t vchar = vtype_char(); vcode_type_t vstring = vtype_uarray(1, vchar, vchar); ident_t canon_fn = ident_new("NVC.TEXT_UTIL.CANON_VALUE(S)S"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); vcode_reg_t canon_args[] = { text_util_reg, preg }; vcode_reg_t canon_reg = emit_fcall(canon_fn, vstring, vchar, canon_args, ARRAY_LEN(canon_args)); vcode_reg_t canon_len_reg = emit_uarray_len(canon_reg, 0); size_t stride = 0; vcode_reg_t *len_regs LOCAL = xmalloc_array(nlits, sizeof(vcode_reg_t)); for (int i = 0; i < nlits; i++) { size_t len = ident_len(tree_ident(type_enum_literal(type, i))); len_regs[i] = emit_const(voffset, len); stride = MAX(stride, len); } vcode_type_t len_array_type = vtype_carray(nlits, voffset, voffset); vcode_reg_t len_array_reg = emit_const_array(len_array_type, len_regs, nlits); vcode_reg_t len_array_ptr = emit_address_of(len_array_reg); const size_t nchars = nlits * stride; vcode_reg_t *char_regs LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t)); for (int i = 0; i < nlits; i++) { const char *str = istr(tree_ident(type_enum_literal(type, i))); size_t pos = 0; for (const char *p = str; *p; p++, pos++) char_regs[(i * stride) + pos] = emit_const(vchar, *p); for (; pos < stride; pos++) char_regs[(i * stride) + pos] = emit_const(vchar, 0); } vcode_type_t char_array_type = vtype_carray(nchars, vchar, vchar); vcode_reg_t char_array_reg = emit_const_array(char_array_type, char_regs, nchars); vcode_reg_t char_array_ptr = emit_address_of(char_array_reg); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_block_t head_bb = emit_block(); vcode_block_t fail_bb = emit_block(); emit_jump(head_bb); const loc_t *loc = vcode_last_loc(); vcode_select_block(head_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_block_t memcmp_bb = emit_block(); vcode_block_t skip_bb = emit_block(); vcode_block_t match_bb = emit_block(); vcode_reg_t len_ptr = emit_array_ref(len_array_ptr, i_reg); vcode_reg_t len_reg = emit_load_indirect(len_ptr); vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, len_reg, canon_len_reg); emit_cond(len_eq, memcmp_bb, skip_bb); vcode_select_block(memcmp_bb); vcode_reg_t char_off = emit_mul(i_reg, emit_const(voffset, stride)); vcode_reg_t char_ptr = emit_array_ref(char_array_ptr, char_off); vcode_dim_t dims[] = { { .left = emit_const(vtype_offset(), 1), .right = len_reg, .dir = emit_const(vtype_bool(), RANGE_TO) } }; vcode_reg_t str_reg = emit_wrap(char_ptr, dims, 1); type_t std_string = std_type(NULL, STD_STRING); ident_t func = lower_predef_func_name(std_string, "="); vcode_type_t vbool = vtype_bool(); vcode_reg_t context_reg = lower_context_for_call(lu, func); vcode_reg_t str_cmp_args[] = { context_reg, str_reg, canon_reg }; vcode_reg_t eq_reg = emit_fcall(func, vbool, vbool, str_cmp_args, 3); emit_cond(eq_reg, match_bb, skip_bb); vcode_select_block(skip_bb); vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1)); emit_store(i_next, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next, emit_const(voffset, nlits)); emit_cond(done_reg, fail_bb, head_bb); vcode_select_block(fail_bb); emit_debug_info(loc); vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1); vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE); vcode_reg_t const_str_reg = lower_wrap_string("\" is not a valid enumeration value"); vcode_reg_t const_str_len = emit_uarray_len(const_str_reg, 0); vcode_reg_t extra_len = emit_add(const_str_len, emit_const(voffset, 1)); vcode_reg_t msg_len = emit_add(arg_len_reg, extra_len); vcode_reg_t mem_reg = emit_alloc(vchar, vchar, msg_len); emit_store_indirect(emit_const(vchar, '\"'), mem_reg); vcode_reg_t ptr1_reg = emit_array_ref(mem_reg, emit_const(voffset, 1)); emit_copy(ptr1_reg, arg_data_reg, arg_len_reg); vcode_reg_t ptr2_reg = emit_array_ref(ptr1_reg, arg_len_reg); emit_copy(ptr2_reg, emit_unwrap(const_str_reg), const_str_len); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t locus = lower_debug_locus(type_enum_literal(type, 0)); emit_report(mem_reg, msg_len, failure_reg, locus); emit_return(emit_const(vtype, 0)); vcode_select_block(match_bb); lower_check_scalar_bounds(lu, i_reg, type, decl, NULL); emit_return(emit_cast(vtype, vbounds, i_reg)); } static void lower_physical_value_helper(lower_unit_t *lu, type_t type, tree_t decl, vcode_reg_t preg) { vcode_reg_t arg_len_reg = emit_uarray_len(preg, 0); vcode_reg_t arg_data_reg = emit_unwrap(preg); vcode_type_t voffset = vtype_offset(); vcode_type_t vchar = vtype_char(); vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX); vcode_type_t vstring = vtype_uarray(1, vchar, vchar); vcode_type_t vstdint = (standard() < STD_19) ? vtype_int(INT32_MIN, INT32_MAX) : vtype_int(INT64_MIN, INT64_MAX); vcode_var_t used_var = lower_temp_var(lu, "used", vstdint, vstdint); vcode_reg_t used_ptr = emit_index(used_var, VCODE_INVALID_REG); vcode_var_t int_var = lower_temp_var(lu, "int", vint64, vint64); vcode_reg_t int_ptr = emit_index(int_var, VCODE_INVALID_REG); ident_t conv_fn = ident_new("NVC.TEXT_UTIL.STRING_TO_INT(S21NVC.TEXT_UTIL.T_INT64N)"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); vcode_reg_t conv_args[] = { text_util_reg, preg, int_ptr, used_ptr, }; emit_fcall(conv_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, conv_args, ARRAY_LEN(conv_args)); vcode_reg_t int_reg = emit_load(int_var); vcode_reg_t used_reg = emit_cast(voffset, voffset, emit_load(used_var)); vcode_reg_t tail_ptr = emit_array_ref(arg_data_reg, used_reg); vcode_reg_t tail_len = emit_sub(arg_len_reg, used_reg); vcode_reg_t one_reg = emit_const(vtype_offset(), 1); vcode_reg_t to_reg = emit_const(vtype_bool(), RANGE_TO); vcode_dim_t tail_dims[1] = { { .left = one_reg, .right = tail_len, .dir = to_reg }, }; vcode_reg_t tail_reg = emit_wrap(tail_ptr, tail_dims, 1); ident_t canon_fn = ident_new("NVC.TEXT_UTIL.CANON_VALUE(S)S"); vcode_reg_t canon_args[] = { text_util_reg, tail_reg, }; vcode_reg_t canon_reg = emit_fcall(canon_fn, vstring, vchar, canon_args, ARRAY_LEN(canon_args)); vcode_reg_t canon_len_reg = emit_uarray_len(canon_reg, 0); const int nunits = type_units(type); assert(nunits >= 1); size_t stride = 0; vcode_reg_t *len_regs LOCAL = xmalloc_array(nunits, sizeof(vcode_reg_t)); vcode_reg_t *mul_regs LOCAL = xmalloc_array(nunits, sizeof(vcode_reg_t)); for (int i = 0; i < nunits; i++) { tree_t unit = type_unit(type, i); size_t len = ident_len(tree_ident(unit)); len_regs[i] = emit_const(voffset, len); stride = MAX(stride, len); vcode_reg_t value_reg = lower_rvalue(lu, tree_value(unit)); mul_regs[i] = emit_cast(vint64, vint64, value_reg); } vcode_type_t len_array_type = vtype_carray(nunits, voffset, voffset); vcode_reg_t len_array_reg = emit_const_array(len_array_type, len_regs, nunits); vcode_reg_t len_array_ptr = emit_address_of(len_array_reg); vcode_type_t mul_array_type = vtype_carray(nunits, vint64, vint64); vcode_reg_t mul_array_reg = emit_const_array(mul_array_type, mul_regs, nunits); vcode_reg_t mul_array_ptr = emit_address_of(mul_array_reg); const size_t nchars = nunits * stride; vcode_reg_t *char_regs LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t)); for (int i = 0; i < nunits; i++) { const char *str = istr(tree_ident(type_unit(type, i))); size_t pos = 0; for (const char *p = str; *p; p++, pos++) char_regs[(i * stride) + pos] = emit_const(vchar, *p); for (; pos < stride; pos++) char_regs[(i * stride) + pos] = emit_const(vchar, 0); } vcode_type_t char_array_type = vtype_carray(nchars, vchar, vchar); vcode_reg_t char_array_reg = emit_const_array(char_array_type, char_regs, nchars); vcode_reg_t char_array_ptr = emit_address_of(char_array_reg); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_block_t head_bb = emit_block(); vcode_block_t fail_bb = emit_block(); emit_jump(head_bb); const loc_t *loc = vcode_last_loc(); vcode_select_block(head_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_block_t memcmp_bb = emit_block(); vcode_block_t skip_bb = emit_block(); vcode_block_t match_bb = emit_block(); vcode_reg_t len_ptr = emit_array_ref(len_array_ptr, i_reg); vcode_reg_t len_reg = emit_load_indirect(len_ptr); vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, len_reg, canon_len_reg); emit_cond(len_eq, memcmp_bb, skip_bb); vcode_select_block(memcmp_bb); vcode_reg_t char_off = emit_mul(i_reg, emit_const(voffset, stride)); vcode_reg_t char_ptr = emit_array_ref(char_array_ptr, char_off); vcode_dim_t dims[] = { { .left = one_reg, .right = len_reg, .dir = to_reg, } }; vcode_reg_t str_reg = emit_wrap(char_ptr, dims, 1); type_t std_string = std_type(NULL, STD_STRING); ident_t func = lower_predef_func_name(std_string, "="); vcode_reg_t std_reg = emit_link_package(well_known(W_STD_STANDARD)); vcode_type_t vbool = vtype_bool(); vcode_reg_t str_cmp_args[] = { std_reg, str_reg, canon_reg }; vcode_reg_t eq_reg = emit_fcall(func, vbool, vbool, str_cmp_args, 3); emit_cond(eq_reg, match_bb, skip_bb); vcode_select_block(skip_bb); vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1)); emit_store(i_next, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next, emit_const(voffset, nunits)); emit_cond(done_reg, fail_bb, head_bb); vcode_select_block(fail_bb); emit_debug_info(loc); vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1); vcode_reg_t failure_reg = emit_const(vseverity, SEVERITY_FAILURE); vcode_reg_t const_str_reg = lower_wrap_string("\" is not a valid unit name"); vcode_reg_t const_str_len = emit_uarray_len(const_str_reg, 0); vcode_reg_t extra_len = emit_add(const_str_len, emit_const(voffset, 1)); vcode_reg_t msg_len = emit_add(tail_len, extra_len); vcode_reg_t mem_reg = emit_alloc(vchar, vchar, msg_len); emit_store_indirect(emit_const(vchar, '\"'), mem_reg); vcode_reg_t ptr1_reg = emit_array_ref(mem_reg, emit_const(voffset, 1)); emit_copy(ptr1_reg, tail_ptr, tail_len); vcode_reg_t ptr2_reg = emit_array_ref(ptr1_reg, tail_len); emit_copy(ptr2_reg, emit_unwrap(const_str_reg), const_str_len); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t locus = lower_debug_locus(type_unit(type, 0)); emit_report(mem_reg, msg_len, failure_reg, locus); emit_return(emit_const(vtype, 0)); vcode_select_block(match_bb); vcode_reg_t mul_ptr = emit_array_ref(mul_array_ptr, i_reg); vcode_reg_t mul_reg = emit_load_indirect(mul_ptr); vcode_reg_t result_reg = emit_mul(int_reg, mul_reg); lower_check_scalar_bounds(lu, result_reg, type, decl, NULL); emit_return(emit_cast(vtype, vbounds, result_reg)); } static void lower_numeric_value_helper(lower_unit_t *lu, type_t type, tree_t decl, vcode_reg_t preg) { vcode_reg_t result_reg; if (type_is_real(type)) { ident_t conv_fn = ident_new("NVC.TEXT_UTIL.STRING_TO_REAL(S)R"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); vcode_reg_t conv_args[] = { text_util_reg, preg }; vcode_type_t vreal = vtype_real(-DBL_MAX, DBL_MAX); result_reg = emit_fcall(conv_fn, vreal, vreal, conv_args, ARRAY_LEN(conv_args)); } else { ident_t conv_fn = ident_new("NVC.TEXT_UTIL.STRING_TO_INT(S)21NVC.TEXT_UTIL.T_INT64"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); vcode_reg_t conv_args[] = { text_util_reg, preg }; vcode_type_t vint64 = vtype_int(INT64_MIN, INT64_MAX); result_reg = emit_fcall(conv_fn, vint64, vint64, conv_args, ARRAY_LEN(conv_args)); } vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); lower_check_scalar_bounds(lu, result_reg, type, decl, NULL); emit_return(emit_cast(vtype, vbounds, result_reg)); } static void lower_record_value_helper(lower_unit_t *lu, type_t type, tree_t decl, vcode_reg_t preg) { vcode_type_t voffset = vtype_offset(); vcode_type_t ctype = vtype_char(); vcode_type_t strtype = vtype_uarray(1, ctype, ctype); vcode_type_t vtype = lower_type(type); vcode_type_t vnat = vtype_int(0, INT64_MAX); vcode_reg_t locus = lower_debug_locus(decl); vcode_var_t result_var = emit_var(vtype, vtype, ident_new("result"), VAR_HEAP); ident_t find_open_fn = ident_new("NVC.TEXT_UTIL.FIND_OPEN(S)N"); ident_t find_close_fn = ident_new("NVC.TEXT_UTIL.FIND_CLOSE(SN)"); ident_t next_delim_fn = ident_new("NVC.TEXT_UTIL.NEXT_DELIMITER(SN)S"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); vcode_reg_t open_args[] = { text_util_reg, preg }; vcode_reg_t open_reg = emit_fcall(find_open_fn, vnat, vnat, open_args, 2); vcode_reg_t off_reg = emit_cast(voffset, voffset, open_reg); vcode_reg_t ptr_reg = emit_index(result_var, VCODE_INVALID_REG); const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { vcode_reg_t nd_args[] = { text_util_reg, preg, off_reg }; vcode_reg_t nd_reg = emit_fcall(next_delim_fn, strtype, ctype, nd_args, 3); type_t ftype = type_base_recur(tree_type(type_field(type, i))); ident_t func = ident_prefix(type_ident(ftype), ident_new("value"), '$'); vcode_reg_t args[] = { lower_context_for_call(lu, func), nd_reg, }; vcode_type_t fvtype = lower_func_result_type(ftype); vcode_type_t fvbounds = lower_bounds(ftype); vcode_reg_t value_reg = emit_fcall(func, fvtype, fvbounds, args, 2); vcode_reg_t vlen_reg = emit_uarray_len(nd_reg, 0); off_reg = emit_add(off_reg, vlen_reg); off_reg = emit_add(off_reg, emit_const(voffset, 1)); // Skip comma vcode_reg_t fptr_reg = emit_record_ref(ptr_reg, i); if (type_is_array(ftype)) { vcode_reg_t data_reg = lower_array_data(value_reg); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, value_reg); emit_copy(fptr_reg, data_reg, count_reg); } else if (type_is_record(ftype)) lower_copy_record(lu, ftype, fptr_reg, value_reg, locus); else emit_store_indirect(value_reg, fptr_reg); } vcode_reg_t close_args[] = { text_util_reg, preg, off_reg }; emit_fcall(find_close_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, close_args, ARRAY_LEN(close_args)); emit_return(ptr_reg); } static void lower_array_value_helper(lower_unit_t *lu, type_t type, tree_t decl, vcode_reg_t preg) { vcode_type_t voffset = vtype_offset(); vcode_type_t ctype = vtype_char(); vcode_type_t strtype = vtype_uarray(1, ctype, ctype); vcode_type_t vnat = vtype_int(0, INT64_MAX); vcode_reg_t locus = lower_debug_locus(decl); vcode_reg_t zero_reg = emit_const(voffset, 0); vcode_reg_t one_reg = emit_const(voffset, 1); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(zero_reg, i_var); ident_t next_delim_fn = ident_new("NVC.TEXT_UTIL.NEXT_DELIMITER(SN)S"); ident_t count_delim_fn = ident_new("NVC.TEXT_UTIL.COUNT_DELIMITERS(S)N"); ident_t trim_ws_fn = ident_new("NVC.TEXT_UTIL.TRIM_WS(SNN)"); ident_t find_open_fn = ident_new("NVC.TEXT_UTIL.FIND_OPEN(S)N"); ident_t find_close_fn = ident_new("NVC.TEXT_UTIL.FIND_CLOSE(SN)"); ident_t bad_char_fn = ident_new("NVC.TEXT_UTIL.REPORT_BAD_CHAR(SC)"); vcode_reg_t text_util_reg = emit_link_package(well_known(W_TEXT_UTIL)); type_t elem = type_base_recur(type_elem_recur(type)); vcode_type_t velem = lower_type(elem); vcode_type_t vbounds = lower_bounds(elem); if (type_is_character_array(type)) { vcode_block_t body_bb = emit_block(); vcode_block_t bad_bb = emit_block(); vcode_block_t good_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_block_t paren_bb = emit_block(); vcode_var_t first_var = emit_var(vnat, vnat, ident_new("first"), 0); vcode_var_t last_var = emit_var(vnat, vnat, ident_new("last"), 0); vcode_reg_t first_ptr = emit_index(first_var, VCODE_INVALID_REG); vcode_reg_t last_ptr = emit_index(last_var, VCODE_INVALID_REG); vcode_reg_t trim_args[] = { text_util_reg, preg, first_ptr, last_ptr }; emit_fcall(trim_ws_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, trim_args, ARRAY_LEN(trim_args)); vcode_reg_t first_reg = emit_cast(voffset, voffset, emit_load(first_var)); vcode_reg_t last_reg = emit_cast(voffset, voffset, emit_load(last_var)); vcode_reg_t count_reg = emit_add(emit_sub(last_reg, first_reg), one_reg); vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg); vcode_var_t pos_var = lower_temp_var(lu, "pos", voffset, voffset); emit_store(emit_cast(voffset, voffset, first_reg), pos_var); const int nlits = type_enum_literals(elem); vcode_reg_t entry_vtype = vtype_int(0, nlits); vcode_reg_t map[256], def_reg = emit_const(entry_vtype, nlits); for (int i = 0; i < 256; i++) map[i] = def_reg; for (int i = 0; i < nlits; i++) { const ident_t id = tree_ident(type_enum_literal(elem, i)); if (ident_char(id, 0) == '\'') map[(uint8_t)ident_char(id, 1)] = emit_const(entry_vtype, i); } vcode_type_t map_vtype = vtype_carray(256, entry_vtype, entry_vtype); vcode_reg_t map_array_reg = emit_const_array(map_vtype, map, 256); vcode_reg_t map_reg = emit_address_of(map_array_reg); vcode_reg_t data_reg = lower_array_data(preg); vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t pos_reg = emit_load(pos_var); vcode_reg_t sptr_reg = emit_array_ref(data_reg, pos_reg); vcode_reg_t dptr_reg = emit_array_ref(mem_reg, i_reg); vcode_reg_t char_reg = emit_load_indirect(sptr_reg); vcode_reg_t cast_reg = emit_cast(voffset, ctype, char_reg); vcode_reg_t mptr_reg = emit_array_ref(map_reg, cast_reg); vcode_reg_t entry_reg = emit_load_indirect(mptr_reg); vcode_reg_t bad_reg = emit_cmp(VCODE_CMP_EQ, entry_reg, def_reg); emit_cond(bad_reg, bad_bb, good_bb); vcode_select_block(good_bb); vcode_reg_t good_reg = emit_cast(velem, velem, entry_reg); emit_store_indirect(good_reg, dptr_reg); vcode_reg_t next_pos_reg = emit_add(pos_reg, one_reg); emit_store(next_pos_reg, pos_var); vcode_reg_t next_i_reg = emit_add(i_reg, one_reg); emit_store(next_i_reg, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_i_reg, count_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(bad_bb); vcode_reg_t bad_char_args[] = { text_util_reg, preg, char_reg }; emit_fcall(bad_char_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, bad_char_args, ARRAY_LEN(bad_char_args)); emit_unreachable(locus); vcode_select_block(exit_bb); vcode_dim_t dims[] = { { .left = emit_const(vtype_offset(), 1), .right = count_reg, .dir = emit_const(vtype_bool(), RANGE_TO) } }; vcode_reg_t wrap_reg = emit_wrap(mem_reg, dims, 1); emit_return(wrap_reg); vcode_select_block(paren_bb); lower_release_temp(lu, pos_var); } vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_reg_t count_args[] = { text_util_reg, preg }; vcode_reg_t count_result_reg = emit_fcall(count_delim_fn, vnat, vnat, count_args, 2); vcode_reg_t count_reg = emit_cast(voffset, voffset, count_result_reg); vcode_reg_t mem_reg = emit_alloc(velem, vbounds, count_reg); vcode_reg_t open_args[] = { text_util_reg, preg }; vcode_reg_t open_reg = emit_fcall(find_open_fn, vnat, vnat, open_args, 2); vcode_var_t pos_var = lower_temp_var(lu, "pos", voffset, voffset); emit_store(emit_cast(voffset, voffset, open_reg), pos_var); vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t pos_reg = emit_load(pos_var); vcode_reg_t nd_args[] = { text_util_reg, preg, pos_reg }; vcode_reg_t nd_reg = emit_fcall(next_delim_fn, strtype, ctype, nd_args, 3); ident_t func = ident_prefix(type_ident(elem), ident_new("value"), '$'); vcode_reg_t args[] = { lower_context_for_call(lu, func), nd_reg, }; vcode_reg_t value_reg = emit_fcall(func, lower_func_result_type(elem), vbounds, args, 2); vcode_reg_t ptr_reg = emit_array_ref(mem_reg, i_reg); if (type_is_record(elem)) lower_copy_record(lu, elem, ptr_reg, value_reg, locus); else emit_store_indirect(value_reg, ptr_reg); vcode_reg_t next_i_reg = emit_add(i_reg, one_reg); emit_store(next_i_reg, i_var); vcode_reg_t vlen_reg = emit_add(emit_uarray_len(nd_reg, 0), one_reg); vcode_reg_t next_pos_reg = emit_add(pos_reg, vlen_reg); emit_store(next_pos_reg, pos_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_i_reg, count_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); vcode_reg_t close_args[] = { text_util_reg, preg, emit_load(pos_var) }; emit_fcall(find_close_fn, VCODE_INVALID_TYPE, VCODE_INVALID_TYPE, close_args, ARRAY_LEN(close_args)); vcode_dim_t dims[] = { { .left = emit_const(vtype_offset(), 1), .right = count_reg, .dir = emit_const(vtype_bool(), RANGE_TO) } }; vcode_reg_t wrap_reg = emit_wrap(mem_reg, dims, 1); emit_return(wrap_reg); } static void lower_value_helper(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); type_t type = type_base_recur(tree_type(decl)); assert(type_is_representable(type)); vcode_set_result(lower_func_result_type(type)); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_type_t ctype = vtype_char(); vcode_type_t strtype = vtype_uarray(1, ctype, ctype); vcode_reg_t preg = emit_param(strtype, strtype, ident_new("VAL")); switch (type_kind(type)) { case T_ENUM: lower_enum_value_helper(lu, type, decl, preg); break; case T_INTEGER: case T_REAL: lower_numeric_value_helper(lu, type, decl, preg); break; case T_PHYSICAL: lower_physical_value_helper(lu, type, decl, preg); break; case T_RECORD: lower_record_value_helper(lu, type, decl, preg); break; case T_ARRAY: lower_array_value_helper(lu, type, decl, preg); break; default: fatal_trace("cannot lower value helper for type %s", type_pp(type)); } } static void lower_resolved_record_fn(lower_unit_t *lu, object_t *obj, resolved_fn_t fn) { tree_t decl = tree_from_object(obj); type_t type = tree_type(decl); assert(!type_is_homogeneous(type) && can_be_signal(type)); vcode_set_result(lower_func_result_type(type)); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_type_t vatype = lower_param_type(type, C_SIGNAL, PORT_IN); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t p_reg = emit_param(vatype, vbounds, ident_new("p")); vcode_var_t var = emit_var(vtype, vbounds, ident_new("result"), 0); vcode_reg_t data_reg, result_reg; if (vtype_kind(vtype) == VCODE_TYPE_UARRAY) { type_t elem = type_elem_recur(type); vcode_reg_t count_reg = lower_array_total_len(lu, type, p_reg); data_reg = emit_alloc(lower_type(elem), lower_bounds(elem), count_reg); result_reg = lower_rewrap(data_reg, p_reg); emit_store(result_reg, var); } else data_reg = result_reg = emit_index(var, VCODE_INVALID_VAR); lower_for_each_field_2(lu, type, type, p_reg, data_reg, VCODE_INVALID_REG, lower_resolved_field_cb, fn); emit_return(result_reg); } static void lower_resolved_helper(lower_unit_t *lu, object_t *obj) { lower_resolved_record_fn(lu, obj, emit_resolved); } static void lower_last_value_helper(lower_unit_t *lu, object_t *obj) { lower_resolved_record_fn(lu, obj, emit_last_value); } static void lower_driving_value_helper(lower_unit_t *lu, object_t *obj) { lower_resolved_record_fn(lu, obj, emit_driving_value); } static void lower_last_time_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t field_ptr, vcode_reg_t dst_ptr, vcode_reg_t locus, void *ctx) { last_time_params_t *params = ctx; vcode_reg_t last_reg = VCODE_INVALID_REG; type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t field_reg = emit_load_indirect(field_ptr); if (type_is_array(ftype)) { vcode_reg_t data_reg = lower_array_data(field_reg); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, field_reg); last_reg = (*params->fn)(data_reg, count_reg); } else last_reg = (*params->fn)(field_reg, VCODE_INVALID_REG); } else { ident_t base_id = type_ident(type_base_recur(ftype)); ident_t helper_func = ident_sprintf("%s$%s", istr(base_id), params->suffix); vcode_reg_t arg_reg = field_ptr; if (type_is_array(ftype) && vcode_reg_kind(arg_reg) != VCODE_TYPE_UARRAY) arg_reg = lower_wrap(lu, ftype, field_ptr); vcode_type_t vtime = vtype_time(); vcode_reg_t context_reg = lower_context_for_call(lu, helper_func); vcode_reg_t args[] = { context_reg, arg_reg }; last_reg = emit_fcall(helper_func, vtime, vtime, args, 2); } vcode_reg_t cur_reg = emit_load(params->var); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_LT, last_reg, cur_reg); vcode_reg_t new_reg = emit_select(cmp_reg, last_reg, cur_reg); emit_store(new_reg, params->var); } static void lower_last_time_fn(lower_unit_t *lu, object_t *obj, resolved_fn_t fn, const char *suffix) { tree_t decl = tree_from_object(obj); type_t type = tree_type(decl); assert(!type_is_homogeneous(type) && can_be_signal(type)); vcode_type_t vtime = vtype_time(); vcode_type_t vatype = lower_param_type(type, C_SIGNAL, PORT_IN); vcode_type_t vbounds = lower_bounds(type); vcode_set_result(vtime); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t p_reg = emit_param(vatype, vbounds, ident_new("p")); vcode_var_t var = emit_var(vtime, vtime, ident_new("result"), 0); emit_store(emit_const(vtime, TIME_HIGH), var); last_time_params_t params = { fn, suffix, var }; lower_for_each_field(lu, type, p_reg, VCODE_INVALID_REG, lower_last_time_field_cb, ¶ms); emit_return(emit_load(var)); } static void lower_last_event_helper(lower_unit_t *lu, object_t *obj) { lower_last_time_fn(lu, obj, emit_last_event, "last_event"); } static void lower_last_active_helper(lower_unit_t *lu, object_t *obj) { lower_last_time_fn(lu, obj, emit_last_active, "last_active"); } static void lower_copy_helper(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); type_t type = tree_type(decl); assert(!lower_trivially_copyable(type)); vcode_type_t vbounds = lower_bounds(type); vcode_type_t vdtype = lower_param_type(type, C_VARIABLE, PORT_OUT); vcode_type_t vstype = lower_param_type(type, C_VARIABLE, PORT_IN); vcode_type_t vlocus = vtype_debug_locus(); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t pdst_reg = emit_param(vdtype, vbounds, ident_new("dest")); vcode_reg_t psrc_reg = emit_param(vstype, vbounds, ident_new("src")); vcode_reg_t plocus = emit_param(vlocus, vlocus, ident_new("locus")); if (type_is_record(type)) { const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); vcode_reg_t dst_ptr = emit_record_ref(pdst_reg, i); vcode_reg_t src_ptr = emit_record_ref(psrc_reg, i); if (type_is_scalar(ftype) || type_is_access(ftype)) { vcode_reg_t src_reg = emit_load_indirect(src_ptr); emit_store_indirect(src_reg, dst_ptr); } else if (type_is_array(ftype)) { vcode_reg_t src_reg = src_ptr; if (have_uarray_ptr(src_reg)) src_reg = emit_load_indirect(src_ptr); vcode_reg_t dst_reg = dst_ptr; if (have_uarray_ptr(dst_reg)) dst_reg = emit_load_indirect(dst_ptr); lower_copy_array(lu, ftype, ftype, dst_reg, src_reg, plocus); } else if (type_is_record(ftype)) lower_copy_record(lu, ftype, dst_ptr, src_ptr, plocus); else fatal_trace("unhandled field type %s in lower_copy_helper", type_pp(ftype)); } } else { assert(type_is_array(type)); type_t elem = type_elem_recur(type); lower_check_array_sizes(lu, type, type, pdst_reg, psrc_reg, plocus); vcode_reg_t count_reg = lower_array_total_len(lu, type, psrc_reg); vcode_reg_t src_data = lower_array_data(psrc_reg); vcode_reg_t dst_data = lower_array_data(pdst_reg); assert(!lower_trivially_copyable(elem)); vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); vcode_reg_t zero_reg = emit_const(voffset, 0); emit_store(zero_reg, i_var); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); vcode_reg_t null_reg = emit_cmp(VCODE_CMP_EQ, count_reg, zero_reg); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t dptr_reg = emit_array_ref(dst_data, i_reg); vcode_reg_t sptr_reg = emit_array_ref(src_data, i_reg); lower_copy_record(lu, elem, dptr_reg, sptr_reg, plocus); vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1)); emit_store(next_reg, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, next_reg, count_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); lower_release_temp(lu, i_var); } emit_return(VCODE_INVALID_REG); } static void lower_new_helper(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); type_t type = tree_type(decl); assert(type_is_record(type) && !type_const_bounds(type)); vcode_type_t vbounds = lower_bounds(type); vcode_type_t vdtype = lower_param_type(type, C_VARIABLE, PORT_OUT); vcode_type_t vstype = lower_param_type(type, C_VARIABLE, PORT_IN); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t pdst_reg = emit_param(vdtype, vbounds, ident_new("dest")); vcode_reg_t psrc_reg = emit_param(vstype, vbounds, ident_new("src")); const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(type, i)); vcode_reg_t dst_ptr = emit_record_ref(pdst_reg, i); vcode_reg_t src_ptr = emit_record_ref(psrc_reg, i); if (type_is_scalar(ftype) || type_is_access(ftype)) { vcode_reg_t src_reg = emit_load_indirect(src_ptr); emit_store_indirect(src_reg, dst_ptr); } else if (type_is_array(ftype)) { vcode_reg_t src_reg = src_ptr; if (have_uarray_ptr(src_reg)) src_reg = emit_load_indirect(src_ptr); vcode_reg_t count_reg = lower_array_total_len(lu, ftype, src_reg); vcode_reg_t dst_reg = dst_ptr; if (have_uarray_ptr(dst_reg)) { type_t scalar_elem = type_elem_recur(ftype); vcode_type_t vtype = lower_type(scalar_elem); vcode_reg_t mem_reg = emit_new(vtype, count_reg); vcode_reg_t all_reg = emit_all(mem_reg); vcode_reg_t wrap_reg = lower_rewrap(all_reg, src_reg); emit_store_indirect(wrap_reg, dst_ptr); dst_reg = wrap_reg; } vcode_reg_t src_data = lower_array_data(src_reg); vcode_reg_t dst_data = lower_array_data(dst_reg); emit_copy(dst_data, src_data, count_reg); } else if (type_is_record(ftype)) lower_new_record(lu, ftype, dst_ptr, src_ptr); else fatal_trace("unhandled type %s in lower_new_helper", type_pp(ftype)); } emit_return(VCODE_INVALID_REG); } static void lower_instantiated_package(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); assert(tree_kind(decl) == T_PACK_INST); lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, decl, NULL); tree_t pack = tree_ref(decl); assert(is_uninstantiated_package(pack)); lower_dependencies(lu, body_of(pack) ?: pack); lower_generics(lu, decl, NULL); lower_decls(lu, decl); emit_return(VCODE_INVALID_REG); } static void lower_type_bounds_var(lower_unit_t *lu, type_t type) { if (type_is_array(type)) { vcode_type_t vtype = lower_type(type); assert(vtype_kind(vtype) == VCODE_TYPE_UARRAY); type_t elem = type_elem_recur(type); vcode_type_t velem = lower_type(elem); vcode_type_t vbounds = lower_bounds(elem); vcode_var_t var = emit_var(vtype, vbounds, type_ident(type), VAR_CONST); vcode_reg_t null_reg = emit_null(vtype_pointer(velem)); vcode_reg_t wrap_reg = lower_wrap(lu, type, null_reg); emit_store(wrap_reg, var); lower_put_vcode_obj(type, var, lu); } else if (type_is_scalar(type)) { vcode_type_t velem = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_type_t vtype = vtype_uarray(1, velem, vbounds); vcode_var_t var = emit_var(vtype, vbounds, type_ident(type), VAR_CONST); tree_t r = range_of(type, 0); vcode_reg_t left_reg = lower_range_left(lu, r); vcode_reg_t right_reg = lower_range_right(lu, r); vcode_reg_t dir_reg = lower_range_dir(lu, r); vcode_dim_t dims[1] = { { left_reg, right_reg, dir_reg }, }; vcode_reg_t null_reg = emit_null(vtype_pointer(velem)); vcode_reg_t wrap_reg = emit_wrap(null_reg, dims, 1); emit_store(wrap_reg, var); lower_put_vcode_obj(type, var, lu); } else if (type_is_record(type)) { vcode_type_t vtype = lower_type(type); assert(vtype_kind(vtype) == VCODE_TYPE_RECORD); vcode_var_t var = emit_var(vtype, vtype, type_ident(type), VAR_CONST); vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG); vcode_reg_t value_reg = lower_default_value(lu, type, ptr_reg); lower_copy_record(lu, type, ptr_reg, value_reg, VCODE_INVALID_REG); lower_put_vcode_obj(type, var, lu); } else fatal_trace("unexpected type %s in lower_type_bounds", type_pp(type)); } static void lower_foreign_stub(lower_unit_t *lu, object_t *obj) { tree_t spec = tree_from_object(obj); assert(tree_kind(spec) == T_ATTR_SPEC); tree_t value = tree_value(spec); type_t str_type = tree_type(value); tree_t sub = tree_ref(spec); assert(is_subprogram(sub)); type_t type = tree_type(sub); if (type_has_result(type)) vcode_set_result(lower_func_result_type(type_result(type))); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); lower_subprogram_ports(lu, sub, false); vcode_reg_t spec_reg = lower_rvalue(lu, value); vcode_reg_t data_reg = lower_array_data(spec_reg); vcode_reg_t length_reg = lower_array_len(lu, str_type, 0, spec_reg); vcode_reg_t locus = lower_debug_locus(spec); emit_bind_foreign(data_reg, length_reg, locus); emit_unreachable(VCODE_INVALID_REG); } static void lower_decl(lower_unit_t *lu, tree_t decl) { PUSH_DEBUG_INFO(decl); switch (tree_kind(decl)) { case T_CONST_DECL: case T_VAR_DECL: lower_var_decl(lu, decl); break; case T_SIGNAL_DECL: lower_signal_decl(lu, decl); break; case T_IMPLICIT_SIGNAL: lower_implicit_decl(lu, decl); break; case T_FILE_DECL: lower_file_decl(lu, decl); break; case T_ALIAS: lower_alias_decl(lu, decl); break; case T_TYPE_DECL: { type_t type = tree_type(decl); ident_t id = type_ident(type); object_t *obj = tree_to_object(decl); if (needs_bounds_var(type)) lower_type_bounds_var(lu, type); if (type_is_representable(type)) { ident_t image = ident_prefix(id, ident_new("image"), '$'); unit_registry_defer2(lu->registry, image, lu, MIR_UNIT_FUNCTION, vhdl_lower_image_helper, obj); ident_t value = ident_prefix(id, ident_new("value"), '$'); unit_registry_defer(lu->registry, value, lu, emit_function, lower_value_helper, NULL, obj); } if (!type_is_homogeneous(type) && can_be_signal(type)) { ident_t resolved = ident_prefix(id, ident_new("resolved"), '$'); unit_registry_defer(lu->registry, resolved, lu, emit_function, lower_resolved_helper, NULL, obj); ident_t last_value = ident_prefix(id, ident_new("last_value"), '$'); unit_registry_defer(lu->registry, last_value, lu, emit_function, lower_last_value_helper, NULL, obj); ident_t last_event = ident_sprintf("%s$last_event", istr(id)); unit_registry_defer(lu->registry, last_event, lu, emit_function, lower_last_event_helper, NULL, obj); ident_t last_active = ident_sprintf("%s$last_active", istr(id)); unit_registry_defer(lu->registry, last_active, lu, emit_function, lower_last_active_helper, NULL, obj); ident_t driving = ident_prefix(id, ident_new("driving"), '$'); unit_registry_defer(lu->registry, driving, lu, emit_function, lower_driving_value_helper, NULL, obj); } if (!lower_trivially_copyable(type)) { ident_t copy = ident_prefix(id, ident_new("copy"), '$'); unit_registry_defer(lu->registry, copy, lu, emit_function, lower_copy_helper, NULL, obj); } if (type_is_record(type) && !type_const_bounds(type)) { ident_t new = ident_prefix(id, ident_new("new"), '$'); unit_registry_defer(lu->registry, new, lu, emit_function, lower_new_helper, NULL, obj); } } break; case T_SUBTYPE_DECL: { type_t type = tree_type(decl); if (needs_bounds_var(type)) lower_type_bounds_var(lu, type); if (type_has_resolution(type)) lower_resolution_var(lu, decl, type); } break; case T_FUNC_DECL: case T_PROC_DECL: case T_ATTR_DECL: case T_COMPONENT: case T_USE: case T_SPEC: case T_GROUP: case T_GROUP_TEMPLATE: case T_VIEW_DECL: case T_PROT_DECL: case T_HIER: case T_ATTR_SPEC: break; case T_PACKAGE: case T_PACK_BODY: case T_PACK_INST: if (unit_needs_cgen(decl)) { ident_t name = ident_prefix(lu->name, tree_ident(decl), '.'); object_t *obj = tree_to_object(decl); unit_registry_defer(lu->registry, name, lu, emit_package, lower_instantiated_package, lu->cover, obj); vcode_type_t vcontext = vtype_context(name); vcode_var_t var = emit_var(vcontext, vcontext, name, 0); lower_put_vcode_obj(decl, var, lu); vcode_reg_t pkg_reg = emit_package_init(name, emit_context_upref(0)); emit_store(pkg_reg, var); lower_put_vcode_obj(name, pkg_reg, lu); const int ngenerics = tree_generics(tree_ref(decl)); for (int i = 0; i < ngenerics; i++) lower_put_vcode_obj(tree_generic(decl, i), var | INSTANCE_BIT, lu); const int ndecls = tree_decls(tree_ref(decl)); for (int i = 0; i < ndecls; i++) lower_put_vcode_obj(tree_decl(decl, i), var | INSTANCE_BIT, lu); } break; case T_PSL_DECL: psl_lower_decl(lu->registry, lu, tree_psl(decl), tree_ident(decl)); break; default: fatal_trace("cannot lower decl kind %s", tree_kind_str(tree_kind(decl))); } } void lower_finished(lower_unit_t *lu) { assert(!lu->finished); vcode_select_unit(lu->vunit); vcode_opt(); if (opt_get_verbose(OPT_LOWER_VERBOSE, istr(lu->name))) vcode_dump(); lu->finished = true; if (lu->name != NULL) unit_registry_import(lu->registry, lu->vunit); } static void lower_protected_body(lower_unit_t *lu, object_t *obj) { tree_t body = tree_from_object(obj); assert(tree_kind(body) == T_PROT_BODY); lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, body, NULL); if (standard() >= STD_19) { // LCS-2016-032 requires dynamic 'PATH_NAME and 'INSTANCE_NAME for // protected type ident_t path_i = well_known(W_PATH_NAME); ident_t inst_i = well_known(W_INSTANCE_NAME); vcode_type_t vchar = vtype_char(); vcode_type_t vstring = vtype_uarray(1, vchar, vchar); vcode_reg_t path_reg = emit_param(vstring, vchar, path_i); vcode_reg_t inst_reg = emit_param(vstring, vchar, inst_i); const tree_global_flags_t gflags = tree_global_flags(body); if (gflags & TREE_GF_INSTANCE_NAME) { vcode_var_t path_var = emit_var(vstring, vchar, path_i, VAR_CONST); lower_put_vcode_obj(path_i, path_var, lu); emit_store(path_reg, path_var); } if (gflags & TREE_GF_PATH_NAME) { vcode_var_t inst_var = emit_var(vstring, vchar, inst_i, VAR_CONST); lower_put_vcode_obj(inst_i, inst_var, lu); emit_store(inst_reg, inst_var); } } lower_decls(lu, tree_primary(body)); lower_decls(lu, body); emit_return(VCODE_INVALID_REG); } static void lower_subprogram_default(lower_unit_t *lu, object_t *obj) { tree_t port = tree_from_object(obj); assert(tree_kind(port) == T_PARAM_DECL); tree_t value = tree_value(port); type_t value_type = tree_type(value); type_t port_type = tree_type(port); vcode_set_result(lower_func_result_type(port_type)); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_reg_t result_reg = lower_rvalue(lu, value); if (type_is_array(value_type)) emit_return(lower_coerce_arrays(lu, value_type, port_type, result_reg)); else emit_return(result_reg); } static void lower_decls(lower_unit_t *lu, tree_t scope) { const int ndecls = tree_decls(scope); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(scope, i); if (tree_kind(d) != T_ATTR_SPEC) continue; else if (ident_casecmp(tree_ident(d), well_known(W_FOREIGN))) unit_registry_defer(lu->registry, tree_ident2(tree_ref(d)), lu, emit_function, lower_foreign_stub, NULL, tree_to_object(d)); } for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(scope, i); switch (tree_kind(d)) { case T_FUNC_INST: if (!is_body(tree_ref(d))) break; // Deferred instantiation in package body // Fall-through case T_FUNC_BODY: { ident_t mangled = tree_ident2(d); if (!unit_registry_query(lu->registry, mangled)) unit_registry_defer(lu->registry, mangled, lu, emit_function, lower_func_body, lu->cover, tree_to_object(d)); } break; case T_PROC_INST: if (!is_body(tree_ref(d))) break; // Deferred instantiation in package body // Fall-through case T_PROC_BODY: { const bool never_waits = !!(tree_flags(d) & TREE_F_NEVER_WAITS) || (tree_flags(d) & TREE_F_PROTECTED); emit_fn_t emitfn = never_waits ? emit_function : emit_procedure; ident_t mangled = tree_ident2(d); if (!unit_registry_query(lu->registry, mangled)) unit_registry_defer(lu->registry, tree_ident2(d), lu, emitfn, lower_proc_body, lu->cover, tree_to_object(d)); } break; case T_PROT_BODY: unit_registry_defer(lu->registry, type_ident(tree_type(d)), lu, emit_protected, lower_protected_body, lu->cover, tree_to_object(d)); break; case T_FUNC_DECL: case T_PROC_DECL: { const subprogram_kind_t kind = tree_subkind(d); if (kind == S_USER) { const int nports = tree_ports(d); for (int i = 0; i < nports; i++) { tree_t p = tree_port(d, i); if (!tree_has_value(p)) continue; tree_t value = tree_value(p); if (is_literal(value) || tree_kind(value) == T_STRING) continue; ident_t def_func = ident_sprintf("%s$default_%s", istr(tree_ident2(d)), istr(tree_ident(p))); unit_registry_defer(lu->registry, def_func, lu, emit_function, lower_subprogram_default, lu->cover, tree_to_object(p)); } continue; } else if (is_open_coded_builtin(kind)) continue; switch (kind) { case S_SLL: case S_SRL: case S_SLA: case S_SRA: case S_ROL: case S_ROR: case S_MATCH_EQ: case S_MATCH_NEQ: case S_MATCH_LT: case S_MATCH_LE: case S_MATCH_GT: case S_MATCH_GE: case S_ARRAY_NOT: case S_ARRAY_AND: case S_ARRAY_OR: case S_ARRAY_XOR: case S_ARRAY_XNOR: case S_ARRAY_NAND: case S_ARRAY_NOR: case S_RISING_EDGE: case S_FALLING_EDGE: unit_registry_defer2(lu->registry, tree_ident2(d), NULL, MIR_UNIT_FUNCTION, vhdl_lower_predef, tree_to_object(d)); break; default: unit_registry_defer(lu->registry, tree_ident2(d), lu, emit_function, lower_predef, lu->cover, tree_to_object(d)); } } break; default: lower_decl(lu, d); break; } } } static bool lower_has_subprograms(tree_t scope) { const int ndecls = tree_decls(scope); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(scope, i); const tree_kind_t kind = tree_kind(d); if (kind == T_FUNC_BODY || kind == T_PROC_BODY) return true; else if (kind == T_FUNC_INST || kind == T_PROC_INST) return true; else if (kind == T_TYPE_DECL) { // Predefined operators for certain types may reference the // parameters: e.g. an array with non-static length type_t type = tree_type(d); if (type_is_record(type) || type_is_array(type)) return true; } } return false; } static void lower_subprogram_ports(lower_unit_t *lu, tree_t body, bool params_as_vars) { const int nports = tree_ports(body); for (int i = 0; i < nports; i++) { tree_t p = tree_port(body, i); type_t type = tree_type(p); const class_t class = tree_class(p); const port_mode_t mode = tree_subkind(p); vcode_type_t vtype = lower_param_type(type, class, mode); vcode_type_t vbounds = lower_bounds(type); vcode_reg_t preg = emit_param(vtype, vbounds, tree_ident(p)); if (params_as_vars) { vcode_var_t var = emit_var(vtype, vbounds, tree_ident(p), 0); emit_store(preg, var); lower_put_vcode_obj(p, var | PARAM_VAR_BIT, lu); } else lower_put_vcode_obj(p, preg, lu); } } static ident_t lower_predef_func_name(type_t type, const char *op) { type_t base = type_base_recur(type); LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "%s.\"%s\"(", istr(ident_runtil(type_ident(base), '.')), op); mangle_one_type(tb, base); mangle_one_type(tb, base); tb_cat(tb, ")"); mangle_one_type(tb, std_type(NULL, STD_BOOLEAN)); tb_cat(tb, "$predef"); return ident_new(tb_get(tb)); } static void lower_array_cmp_inner(lower_unit_t *lu, vcode_reg_t lhs_data, vcode_reg_t rhs_data, vcode_reg_t lhs_array, vcode_reg_t rhs_array, type_t left_type, type_t right_type, vcode_cmp_t pred, vcode_block_t fail_bb) { // Behaviour of relational operators on arrays is described in // LRM 93 section 7.2.2 assert(pred == VCODE_CMP_EQ || pred == VCODE_CMP_LT || pred == VCODE_CMP_LEQ); const int ndims = dimension_of(left_type); assert(dimension_of(right_type) == ndims); vcode_reg_t left_len = lower_array_len(lu, left_type, 0, lhs_array); for (int i = 1; i < ndims; i++) { vcode_reg_t dim_len = lower_array_len(lu, left_type, i, lhs_array); left_len = emit_mul(dim_len, left_len); } vcode_reg_t right_len = lower_array_len(lu, right_type, 0, rhs_array); for (int i = 1; i < ndims; i++) { vcode_reg_t dim_len = lower_array_len(lu, right_type, i, rhs_array); right_len = emit_mul(dim_len, right_len); } vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_block_t test_bb = emit_block(); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); type_t elem_type = type_elem(left_type); vcode_reg_t stride = VCODE_INVALID_REG; if (type_is_array(elem_type)) stride = lower_array_stride(lu, left_type, lhs_array); vcode_reg_t len_eq = emit_cmp(VCODE_CMP_EQ, left_len, right_len); if (pred == VCODE_CMP_EQ) emit_cond(len_eq, test_bb, fail_bb); else emit_jump(test_bb); // Loop test vcode_select_block(test_bb); vcode_reg_t i_loaded = emit_load(i_var); if (pred == VCODE_CMP_EQ) { vcode_reg_t done = emit_cmp(VCODE_CMP_EQ, i_loaded, left_len); emit_cond(done, exit_bb, body_bb); } else { vcode_block_t check_r_len_bb = emit_block(); vcode_reg_t len_ge_l = emit_cmp(VCODE_CMP_GEQ, i_loaded, left_len); emit_cond(len_ge_l, exit_bb, check_r_len_bb); vcode_select_block(check_r_len_bb); vcode_reg_t len_ge_r = emit_cmp(VCODE_CMP_GEQ, i_loaded, right_len); emit_cond(len_ge_r, fail_bb, body_bb); } // Loop body vcode_select_block(body_bb); vcode_reg_t ptr_inc = i_loaded; if (stride != VCODE_INVALID_REG) ptr_inc = emit_mul(ptr_inc, stride); vcode_reg_t inc = emit_add(i_loaded, emit_const(voffset, 1)); emit_store(inc, i_var); vcode_reg_t i_eq_len = emit_cmp(VCODE_CMP_EQ, inc, left_len); vcode_reg_t l_ptr = emit_array_ref(lhs_data, ptr_inc); vcode_reg_t r_ptr = emit_array_ref(rhs_data, ptr_inc); if (type_is_array(elem_type)) { vcode_reg_t lhs_sub_array = VCODE_INVALID_REG; vcode_reg_t rhs_sub_array = VCODE_INVALID_REG; if (type_is_unconstrained(elem_type)) { lhs_sub_array = lower_wrap_element(lu, left_type, lhs_array, l_ptr); rhs_sub_array = lower_wrap_element(lu, right_type, rhs_array, r_ptr); } lower_array_cmp_inner(lu, l_ptr, r_ptr, lhs_sub_array, rhs_sub_array, type_elem(left_type), type_elem(right_type), pred, fail_bb); emit_jump(test_bb); } else if (type_is_record(elem_type)) { lower_for_each_field_2(lu, elem_type, elem_type, l_ptr, r_ptr, VCODE_INVALID_REG, lower_predef_field_eq_cb, (void *)(uintptr_t)fail_bb); emit_jump(test_bb); } else { vcode_reg_t l_val = emit_load_indirect(l_ptr); vcode_reg_t r_val = emit_load_indirect(r_ptr); if (pred == VCODE_CMP_EQ) { vcode_reg_t eq = emit_cmp(pred, l_val, r_val); emit_cond(eq, test_bb, fail_bb); } else { vcode_reg_t cmp = emit_cmp(pred, l_val, r_val); vcode_reg_t eq = emit_cmp(VCODE_CMP_EQ, l_val, r_val); vcode_reg_t done = emit_or(emit_not(eq), emit_and(len_eq, i_eq_len)); vcode_block_t cmp_result_bb = emit_block(); emit_cond(done, cmp_result_bb, test_bb); vcode_select_block(cmp_result_bb); emit_cond(cmp, exit_bb, fail_bb); } } // Epilogue vcode_select_block(exit_bb); } static void lower_predef_array_cmp(lower_unit_t *lu, tree_t decl, vcode_cmp_t pred) { type_t r0_type = tree_type(tree_port(decl, 0)); type_t r1_type = tree_type(tree_port(decl, 1)); vcode_reg_t r0 = 1, r1 = 2; vcode_reg_t r0_data = lower_array_data(r0); vcode_reg_t r1_data = lower_array_data(r1); vcode_block_t fail_bb = emit_block(); lower_array_cmp_inner(lu, r0_data, r1_data, r0, r1, r0_type, r1_type, pred, fail_bb); emit_return(emit_const(vtype_bool(), 1)); vcode_select_block(fail_bb); emit_return(emit_const(vtype_bool(), 0)); } static void lower_predef_field_eq_cb(lower_unit_t *lu, tree_t field, vcode_reg_t r0, vcode_reg_t r1, vcode_reg_t locus, void *context) { vcode_block_t fail_bb = (uintptr_t)context; type_t ftype = tree_type(field); if (type_is_array(ftype)) { vcode_reg_t r0_data = r0, r0_array = VCODE_INVALID_REG; if (have_uarray_ptr(r0)) { r0_array = emit_load_indirect(r0); r0_data = lower_array_data(r0_array); } vcode_reg_t r1_data = r1, r1_array = VCODE_INVALID_REG; if (have_uarray_ptr(r1)) { r1_array = emit_load_indirect(r1); r1_data = lower_array_data(r1_array); } lower_array_cmp_inner(lu, r0_data, r1_data, r0_array, r1_array, ftype, ftype, VCODE_CMP_EQ, fail_bb); } else if (type_is_record(ftype)) lower_for_each_field_2(lu, ftype, ftype, r0, r1, locus, lower_predef_field_eq_cb, (void *)(uintptr_t)fail_bb); else { vcode_reg_t r0_load = emit_load_indirect(r0); vcode_reg_t r1_load = emit_load_indirect(r1); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, r0_load, r1_load); vcode_block_t next_bb = emit_block(); emit_cond(cmp_reg, next_bb, fail_bb); vcode_select_block(next_bb); } } static void lower_predef_record_eq(lower_unit_t *lu, tree_t decl) { vcode_reg_t r0 = 1, r1 = 2; type_t type = tree_type(tree_port(decl, 0)); vcode_block_t fail_bb = emit_block(); lower_for_each_field_2(lu, type, type, r0, r1, VCODE_INVALID_REG, lower_predef_field_eq_cb, (void *)(uintptr_t)fail_bb); emit_return(emit_const(vtype_bool(), 1)); vcode_select_block(fail_bb); emit_return(emit_const(vtype_bool(), 0)); } static void lower_predef_to_string(lower_unit_t *lu, tree_t decl) { // LRM 08 section 5.7 on string representations type_t arg_type = tree_type(tree_port(decl, 0)); vcode_reg_t context_reg = 0, r0 = 1; if (type_is_array(arg_type)) { type_t elem = type_elem(arg_type); if (type_is_enum(elem) && all_character_literals(elem)) { lower_character_array_image_helper(lu, arg_type, r0, false); return; } } assert(type_is_representable(arg_type)); ident_t func = ident_prefix(type_ident(arg_type), ident_new("image"), '$'); vcode_type_t ctype = vtype_char(); vcode_type_t rtype = vtype_uarray(1, ctype, ctype); vcode_reg_t args[] = { context_reg, r0 }; vcode_reg_t str_reg = emit_fcall(func, rtype, ctype, args, 2); if (type_is_enum(arg_type)) { // If the result is a character literal return just the character // without the quotes vcode_reg_t quote_reg = emit_const(ctype, '\''); vcode_reg_t data_reg = lower_array_data(str_reg); vcode_reg_t char0_reg = emit_load_indirect(data_reg); vcode_reg_t is_quote = emit_cmp(VCODE_CMP_EQ, char0_reg, quote_reg); vcode_block_t char_bb = emit_block(); vcode_block_t other_bb = emit_block(); emit_cond(is_quote, char_bb, other_bb); vcode_select_block(char_bb); vcode_reg_t one_reg = emit_const(vtype_offset(), 1); vcode_reg_t char1_ptr = emit_array_ref(data_reg, one_reg); vcode_reg_t left_reg = emit_uarray_left(str_reg, 0); vcode_reg_t dir_reg = emit_uarray_dir(str_reg, 0); vcode_dim_t dims[] = { { .left = left_reg, .right = left_reg, .dir = dir_reg } }; emit_return(emit_wrap(char1_ptr, dims, 1)); vcode_select_block(other_bb); } emit_return(str_reg); } static void lower_predef_mixed_bit_vec_op(lower_unit_t *lu, tree_t decl, subprogram_kind_t kind) { // Mixed scalar/array bit vector operations vcode_reg_t r0 = 1, r1 = 2; type_t r0_type = tree_type(tree_port(decl, 0)); type_t r1_type = tree_type(tree_port(decl, 1)); vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(vtype_offset(), 0), i_var); const bool r0_is_array = type_is_array(r0_type); type_t array_type = r0_is_array ? r0_type : r1_type; vcode_reg_t array_reg = r0_is_array ? r0 : r1; vcode_reg_t len_reg = lower_array_len(lu, array_type, 0, array_reg); vcode_reg_t data_reg = lower_array_data(array_reg); vcode_reg_t left_reg = lower_array_left(lu, array_type, 0, array_reg); vcode_reg_t right_reg = lower_array_right(lu, array_type, 0, array_reg); vcode_reg_t dir_reg = lower_array_dir(lu, array_type, 0, array_reg); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg); vcode_reg_t mem_reg = emit_alloc(vtype_bool(), vtype_bool(), len_reg); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t l_reg = emit_load_indirect(emit_array_ref(data_reg, i_reg)); vcode_reg_t r_reg = r0_is_array ? r1 : r0; vcode_reg_t result_reg = VCODE_INVALID_REG; switch (kind) { case S_MIXED_AND: result_reg = emit_and(l_reg, r_reg); break; case S_MIXED_OR: result_reg = emit_or(l_reg, r_reg); break; case S_MIXED_NAND: result_reg = emit_nand(l_reg, r_reg); break; case S_MIXED_NOR: result_reg = emit_nor(l_reg, r_reg); break; case S_MIXED_XOR: result_reg = emit_xor(l_reg, r_reg); break; case S_MIXED_XNOR: result_reg = emit_xnor(l_reg, r_reg); break; default: break; } emit_store_indirect(result_reg, emit_array_ref(mem_reg, i_reg)); vcode_reg_t next_reg = emit_add(i_reg, emit_const(voffset, 1)); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg); emit_store(next_reg, i_var); emit_cond(cmp_reg, exit_bb, body_bb); vcode_select_block(exit_bb); vcode_dim_t dims[1] = { { .left = left_reg, .right = right_reg, .dir = dir_reg } }; emit_return(emit_wrap(mem_reg, dims, 1)); } static void lower_predef_reduction_op(lower_unit_t *lu, tree_t decl, subprogram_kind_t kind) { vcode_reg_t r0 = 1; type_t r0_type = tree_type(tree_port(decl, 0)); vcode_type_t vbool = vtype_bool(); vcode_type_t voffset = vtype_offset(); vcode_var_t result_var = lower_temp_var(lu, "result", vbool, vbool); vcode_reg_t init_reg = emit_const(vbool, kind == S_REDUCE_NAND || kind == S_REDUCE_AND); emit_store(init_reg, result_var); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(vtype_offset(), 0), i_var); vcode_reg_t len_reg = lower_array_len(lu, r0_type, 0, r0); vcode_reg_t data_reg = lower_array_data(r0); vcode_reg_t left_reg = lower_array_left(lu, r0_type, 0, r0); vcode_reg_t right_reg = lower_array_right(lu, r0_type, 0, r0); vcode_reg_t dir_reg = lower_array_dir(lu, r0_type, 0, r0); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, dir_reg); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t src_reg = emit_load_indirect(emit_array_ref(data_reg, i_reg)); vcode_reg_t cur_reg = emit_load(result_var); vcode_reg_t result_reg = VCODE_INVALID_REG; switch (kind) { case S_REDUCE_OR: case S_REDUCE_NOR: result_reg = emit_or(cur_reg, src_reg); break; case S_REDUCE_AND: case S_REDUCE_NAND: result_reg = emit_and(cur_reg, src_reg); break; case S_REDUCE_XOR: case S_REDUCE_XNOR: result_reg = emit_xor(cur_reg, src_reg); break; default: break; } emit_store(result_reg, result_var); vcode_reg_t next_reg = emit_add(i_reg, emit_const(vtype_offset(), 1)); vcode_reg_t cmp_reg = emit_cmp(VCODE_CMP_EQ, next_reg, len_reg); emit_store(next_reg, i_var); emit_cond(cmp_reg, exit_bb, body_bb); vcode_select_block(exit_bb); if (kind == S_REDUCE_NOR || kind == S_REDUCE_NAND || kind == S_REDUCE_XNOR) emit_return(emit_not(emit_load(result_var))); else emit_return(emit_load(result_var)); } static void lower_predef_min_max(lower_unit_t *lu, tree_t decl, vcode_cmp_t cmp) { type_t type = tree_type(tree_port(decl, 0)); if (type_is_array(type) && tree_ports(decl) == 1) { type_t elem = type_elem(type); assert(type_is_scalar(elem)); vcode_reg_t array_reg = 1; vcode_type_t voffset = vtype_offset(); vcode_var_t i_var = lower_temp_var(lu, "i", voffset, voffset); emit_store(emit_const(voffset, 0), i_var); vcode_type_t elem_vtype = lower_type(elem); vcode_var_t result_var = lower_temp_var(lu, "result", elem_vtype, elem_vtype); tree_t elem_r = range_of(elem, 0); vcode_reg_t def_reg = (cmp == VCODE_CMP_GT && tree_subkind(elem_r) == RANGE_TO) || (cmp == VCODE_CMP_LT && tree_subkind(elem_r) == RANGE_DOWNTO) ? lower_range_left(lu, elem_r) : lower_range_right(lu, elem_r); emit_store(def_reg, result_var); vcode_reg_t left_reg = lower_array_left(lu, type, 0, array_reg); vcode_reg_t right_reg = lower_array_right(lu, type, 0, array_reg); vcode_reg_t len_reg = lower_array_len(lu, type, 0, array_reg); vcode_reg_t kind_reg = lower_array_dir(lu, type, 0, array_reg); vcode_reg_t data_reg = lower_array_data(array_reg); vcode_reg_t null_reg = emit_range_null(left_reg, right_reg, kind_reg); vcode_block_t body_bb = emit_block(); vcode_block_t exit_bb = emit_block(); emit_cond(null_reg, exit_bb, body_bb); vcode_select_block(body_bb); vcode_reg_t i_reg = emit_load(i_var); vcode_reg_t elem_ptr = emit_array_ref(data_reg, i_reg); vcode_reg_t elem_reg = emit_load_indirect(elem_ptr); vcode_reg_t cur_reg = emit_load(result_var); vcode_reg_t cmp_reg = emit_cmp(cmp, elem_reg, cur_reg); vcode_reg_t next_reg = emit_select(cmp_reg, elem_reg, cur_reg); emit_store(next_reg, result_var); vcode_reg_t i_next = emit_add(i_reg, emit_const(voffset, 1)); emit_store(i_next, i_var); vcode_reg_t done_reg = emit_cmp(VCODE_CMP_EQ, i_next, len_reg); emit_cond(done_reg, exit_bb, body_bb); vcode_select_block(exit_bb); emit_return(emit_load(result_var)); } else { vcode_reg_t context_reg = 0, r0 = 1, r1 = 2; vcode_reg_t test_reg; if (type_is_scalar(type)) test_reg = emit_cmp(cmp, r0, r1); else { const char *op = cmp == VCODE_CMP_GT ? ">" : "<"; ident_t func = lower_predef_func_name(type, op); vcode_reg_t args[] = { context_reg, r0, r1 }; vcode_type_t vbool = vtype_bool(); test_reg = emit_fcall(func, vbool, vbool, args, 3); } emit_return(emit_select(test_reg, r0, r1)); } } static void lower_predef_negate(tree_t decl, const char *op) { type_t type = tree_type(tree_port(decl, 0)); vcode_type_t vbool = vtype_bool(); vcode_reg_t args[] = { 0, 1, 2 }; vcode_reg_t eq_reg = emit_fcall(lower_predef_func_name(type, op), vbool, vbool, args, 3); emit_return(emit_not(eq_reg)); } static void lower_foreign_predef(lower_unit_t *lu, tree_t decl, const char *fn) { static const char prefix[] = "INTERNAL "; const size_t fnlen = strlen(fn); const size_t nchars = fnlen + sizeof(prefix) - 1; vcode_reg_t *chars LOCAL = xmalloc_array(nchars, sizeof(vcode_reg_t)); vcode_type_t ctype = vtype_char(); vcode_type_t stype = vtype_carray(nchars, ctype, ctype); int pos = 0; for (int i = 0; i < sizeof(prefix) - 1; i++) chars[pos++] = emit_const(ctype, prefix[i]); for (int i = 0; i < fnlen; i++) chars[pos++] = emit_const(ctype, fn[i]); assert(pos == nchars); vcode_reg_t array_reg = emit_const_array(stype, chars, nchars); vcode_reg_t data_reg = emit_address_of(array_reg); vcode_reg_t length_reg = emit_const(vtype_offset(), nchars); emit_bind_foreign(data_reg, length_reg, VCODE_INVALID_REG); emit_unreachable(VCODE_INVALID_REG); } static void lower_predef_file_open3(lower_unit_t *lu, tree_t decl) { vcode_type_t rtype = vcode_unit_result(lu->vunit); vcode_var_t status_var = emit_var(rtype, rtype, ident_new("status"), 0); vcode_reg_t status_reg = emit_index(status_var, VCODE_INVALID_REG); vcode_reg_t data_reg = emit_unwrap(2); vcode_reg_t length_reg = emit_uarray_len(2, 0); emit_file_open(1, data_reg, length_reg, 3, status_reg); emit_return(emit_load(status_var)); } static void lower_predef(lower_unit_t *lu, object_t *obj) { tree_t decl = tree_from_object(obj); const subprogram_kind_t kind = tree_subkind(decl); assert(kind != S_USER); assert(!is_open_coded_builtin(kind)); type_t type = tree_type(decl); if (type_has_result(type)) vcode_set_result(lower_func_result_type(type_result(type))); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); lower_subprogram_ports(lu, decl, false); switch (tree_subkind(decl)) { case S_ARRAY_EQ: lower_predef_array_cmp(lu, decl, VCODE_CMP_EQ); break; case S_ARRAY_LE: lower_predef_array_cmp(lu, decl, VCODE_CMP_LEQ); break; case S_ARRAY_LT: lower_predef_array_cmp(lu, decl, VCODE_CMP_LT); break; case S_ARRAY_GE: lower_predef_negate(decl, "<"); break; case S_ARRAY_GT: lower_predef_negate(decl, "<="); break; case S_RECORD_EQ: lower_predef_record_eq(lu, decl); break; case S_ARRAY_NEQ: case S_RECORD_NEQ: lower_predef_negate(decl, "="); break; case S_TO_STRING: lower_predef_to_string(lu, decl); break; case S_TO_STRING_TIME: lower_foreign_predef(lu, decl, "_std_to_string_time"); break; case S_TO_STRING_REAL_DIGITS: lower_foreign_predef(lu, decl, "_std_to_string_real_digits"); break; case S_TO_STRING_REAL_FORMAT: lower_foreign_predef(lu, decl, "_std_to_string_real_format"); break; case S_TO_HSTRING_BITVEC: lower_foreign_predef(lu, decl, "_std_to_hstring_bit_vec"); break; case S_TO_OSTRING_BITVEC: lower_foreign_predef(lu, decl, "_std_to_ostring_bit_vec"); break; case S_MIXED_AND: case S_MIXED_OR: case S_MIXED_XOR: case S_MIXED_XNOR: case S_MIXED_NAND: case S_MIXED_NOR: lower_predef_mixed_bit_vec_op(lu, decl, kind); break; case S_REDUCE_OR: case S_REDUCE_AND: case S_REDUCE_NAND: case S_REDUCE_NOR: case S_REDUCE_XOR: case S_REDUCE_XNOR: lower_predef_reduction_op(lu, decl, kind); break; case S_MAXIMUM: lower_predef_min_max(lu, decl, VCODE_CMP_GT); break; case S_MINIMUM: lower_predef_min_max(lu, decl, VCODE_CMP_LT); break; case S_FILE_FLUSH: lower_foreign_predef(lu, decl, "__nvc_flush"); break; case S_FILE_OPEN3: lower_predef_file_open3(lu, decl); break; case S_FILE_CLOSE: lower_foreign_predef(lu, decl, "__nvc_file_close"); break; case S_ENDFILE: lower_foreign_predef(lu, decl, "__nvc_endfile"); break; case S_FILE_MODE: lower_foreign_predef(lu, decl, "__nvc_file_mode"); break; case S_FILE_CANSEEK: lower_foreign_predef(lu, decl, "__nvc_file_canseek"); break; case S_FILE_SIZE: lower_foreign_predef(lu, decl, "__nvc_file_size"); break; case S_FILE_REWIND: lower_foreign_predef(lu, decl, "__nvc_rewind"); break; case S_FILE_SEEK: lower_foreign_predef(lu, decl, "__nvc_seek"); break; case S_FILE_TRUNCATE: lower_foreign_predef(lu, decl, "__nvc_truncate"); break; case S_FILE_STATE: lower_foreign_predef(lu, decl, "__nvc_file_state"); break; case S_FILE_POSITION: lower_foreign_predef(lu, decl, "__nvc_file_position"); break; default: fatal_trace("cannot lower predefined function %s", type_pp(type)); } } static void lower_proc_body(lower_unit_t *lu, object_t *obj) { tree_t body = tree_from_object(obj); assert(!is_uninstantiated_subprogram(body)); lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, body, NULL); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); if (tree_kind(body) == T_PROC_INST) lower_generics(lu, body, NULL); const bool never_waits = vcode_unit_kind(lu->vunit) == VCODE_UNIT_FUNCTION; const bool has_subprograms = lower_has_subprograms(body); lower_subprogram_ports(lu, body, has_subprograms || !never_waits); lower_decls(lu, body); lower_sequence(lu, body, NULL); if (!vcode_block_finished()) { lower_leave_subprogram(lu); emit_return(VCODE_INVALID_REG); } } static void lower_func_body(lower_unit_t *lu, object_t *obj) { tree_t body = tree_from_object(obj); assert(!is_uninstantiated_subprogram(body)); type_t result = type_result(tree_type(body)); vcode_set_result(lower_func_result_type(result)); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, body, NULL); if (tree_kind(body) == T_FUNC_INST) lower_generics(lu, body, NULL); const bool has_subprograms = lower_has_subprograms(body); lower_subprogram_ports(lu, body, has_subprograms); if (tree_flags(body) & TREE_F_KNOWS_SUBTYPE) { // Extra hidden parameter for result bounds vcode_type_t vresult = lower_param_type(result, C_CONSTANT, PORT_IN); vcode_reg_t bounds_reg = emit_param(vresult, vresult, ident_new("result")); lower_put_vcode_obj(body, bounds_reg, lu); } lower_decls(lu, body); lower_sequence(lu, body, NULL); if (!vcode_block_finished()) emit_unreachable(lower_debug_locus(body)); } static void lower_driver_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t ptr, vcode_reg_t unused, vcode_reg_t locus, void *__ctx) { tree_t view = untag_pointer(__ctx, void), elem = NULL; bool converse = !!pointer_tag(__ctx); type_t type = tree_type(field); if (view != NULL) { elem = find_element_mode_indication(view, field, &converse); assert(elem != NULL); if (converse_mode(elem, converse) == PORT_IN) return; } if (type_is_homogeneous(type)) { vcode_reg_t nets_reg = emit_load_indirect(ptr); vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_drive_signal(data_reg, count_reg); } else if (elem != NULL && tree_subkind(elem) == PORT_RECORD_VIEW) { void *new_ctx = tag_pointer(tree_value(elem), converse); lower_for_each_field(lu, type, ptr, VCODE_INVALID_REG, lower_driver_field_cb, new_ctx); } else lower_for_each_field(lu, type, ptr, VCODE_INVALID_REG, lower_driver_field_cb, NULL); } static bool can_use_transfer_signal(tree_t proc, driver_set_t *ds) { driver_info_t *di = get_drivers(ds, proc); if (di == NULL || di->chain_proc != NULL) return false; else if (tree_stmts(proc) != 2) return false; tree_t s0 = tree_stmt(proc, 0); if (tree_kind(s0) != T_SIGNAL_ASSIGN) return false; else if (tree_target(s0) != di->prefix) return false; else if (!type_is_homogeneous(tree_type(di->prefix))) return false; else if (tree_waveforms(s0) != 1) return false; tree_t w0 = tree_waveform(s0, 0); if (tree_has_delay(w0)) { tree_t d = tree_delay(w0); if (tree_kind(d) != T_LITERAL) return false; } if (tree_has_reject(s0)) { tree_t r = tree_reject(s0); if (tree_kind(r) != T_LITERAL) return false; } tree_t value = tree_value(w0), ref = name_to_ref(value); if (ref == NULL || class_of(ref) != C_SIGNAL) return false; else if (value != longest_static_prefix(value)) return false; tree_t s1 = tree_stmt(proc, 1); if (tree_kind(s1) != T_WAIT) return false; else if (!(tree_flags(s1) & TREE_F_STATIC_WAIT)) return false; else if (tree_triggers(s1) != 1) return false; tree_t t0 = tree_trigger(s1, 0); if (!same_tree(t0, value)) return false; return true; } static vcode_reg_t lower_trigger(lower_unit_t *lu, tree_t fcall, tree_t proc) { tree_t decl = tree_ref(fcall); const subprogram_kind_t kind = tree_subkind(decl); if (kind == S_SCALAR_EQ) { tree_t p0 = tree_value(tree_param(fcall, 0)), p1; if (is_literal(p0)) // Commute arguments p1 = p0, p0 = tree_value(tree_param(fcall, 1)); else p1 = tree_value(tree_param(fcall, 1)); if (tree_kind(p0) != T_REF || class_of(p0) != C_SIGNAL) return VCODE_INVALID_REG; else if (!is_literal(p1)) return VCODE_INVALID_REG; vcode_reg_t left_reg = lower_lvalue(lu, p0); vcode_reg_t right_reg = lower_rvalue(lu, p1); return emit_cmp_trigger(left_reg, right_reg); } else if (kind == S_SCALAR_AND) { // Testing x'event is redundant if the process is only // sensitive to x tree_t w = tree_stmt(proc, 1); assert(tree_kind(w) == T_WAIT); if (tree_triggers(w) != 1) return VCODE_INVALID_REG; tree_t p0 = tree_value(tree_param(fcall, 0)); tree_t p1 = tree_value(tree_param(fcall, 1)); tree_t aref, other; if (tree_kind(p0) == T_ATTR_REF) aref = p0, other = p1; else if (tree_kind(p1) == T_ATTR_REF) aref = p1, other = p0; else return VCODE_INVALID_REG; if (tree_subkind(aref) != ATTR_EVENT) return VCODE_INVALID_REG; else if (tree_kind(other) != T_FCALL) return VCODE_INVALID_REG; if (!same_tree(tree_name(aref), tree_trigger(w, 0))) return VCODE_INVALID_REG; return lower_trigger(lu, other, proc); } else if (kind != S_USER && kind != S_FALLING_EDGE && kind != S_RISING_EDGE) return VCODE_INVALID_REG; else if (tree_flags(decl) & TREE_F_IMPURE) return VCODE_INVALID_REG; const int nparams = tree_params(fcall); if (nparams != tree_ports(decl)) return VCODE_INVALID_REG; for (int i = 0; i < nparams; i++) { tree_t p = tree_param(fcall, i); tree_t value = tree_value(p); if (is_literal(value)) continue; else if (tree_kind(value) == T_REF && class_of(value) == C_SIGNAL) { // Must be passing as a signal not the resolved value if (tree_subkind(p) != P_POS) return VCODE_INVALID_REG; else if (tree_class(tree_port(decl, tree_pos(p))) != C_SIGNAL) return VCODE_INVALID_REG; } else return VCODE_INVALID_REG; } ident_t name = tree_ident2(decl); vcode_reg_t *args LOCAL = xmalloc_array(nparams + 1, sizeof(vcode_reg_t)); args[0] = lower_context_for_call(lu, name); for (int i = 0; i < nparams; i++) args[i + 1] = lower_subprogram_arg(lu, fcall, i); return emit_function_trigger(name, args, nparams + 1); } static vcode_reg_t lower_process_trigger(lower_unit_t *lu, tree_t proc) { if (cover_enabled(lu->cover, COVER_MASK_BRANCH | COVER_MASK_EXPRESSION)) return VCODE_INVALID_REG; // Would have incorrect branch coverage else if (tree_stmts(proc) != 2) return VCODE_INVALID_REG; // Preconditions assert(tree_kind(tree_stmt(proc, 1)) == T_WAIT); assert(tree_flags(tree_stmt(proc, 1)) & TREE_F_STATIC_WAIT); tree_t s0 = tree_stmt(proc, 0); if (tree_kind(s0) != T_IF) return VCODE_INVALID_REG; const int nconds = tree_conds(s0); if (nconds > 2) return VCODE_INVALID_REG; vcode_reg_t branches[2] = { VCODE_INVALID_REG, VCODE_INVALID_REG }; for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(s0, i); if (!tree_has_value(c)) return VCODE_INVALID_REG; tree_t value = tree_value(c); if (tree_kind(value) != T_FCALL) return VCODE_INVALID_REG; branches[i] = lower_trigger(lu, value, proc); } if (nconds == 1) return branches[0]; else if (branches[0] == VCODE_INVALID_REG || branches[1] == VCODE_INVALID_REG) return VCODE_INVALID_REG; else return emit_or_trigger(branches[0], branches[1]); } void lower_process(lower_unit_t *parent, tree_t proc, driver_set_t *ds) { assert(tree_kind(proc) == T_PROCESS); ident_t label = tree_ident(proc); ident_t name = ident_prefix(parent->name, label, '.'); vcode_unit_t vu = emit_process(name, tree_to_object(proc), parent->vunit); // The code generator assumes the first state starts at block number // one. Allocate it here in case lowering the declarations generates // additional basic blocks. vcode_block_t start_bb = emit_block(); assert(start_bb == 1); lower_unit_t *lu = lower_unit_new(parent->registry, parent, vu, parent->cover, proc); unit_registry_put(parent->registry, lu); lu->cscope = cover_create_scope(lu->cover, parent->cscope, proc, NULL); if (tree_global_flags(proc) & TREE_GF_EXTERNAL_NAME) tree_visit_only(proc, lower_external_name_cache, lu, T_EXTERNAL_NAME); lower_decls(lu, proc); driver_info_t *di = get_drivers(ds, proc); for (; di; di = di->chain_proc) { assert(!di->tentative); type_t prefix_type = tree_type(di->prefix); vcode_reg_t nets_reg = lower_lvalue(lu, di->prefix); if (!type_is_homogeneous(prefix_type)) lower_for_each_field(lu, prefix_type, nets_reg, VCODE_INVALID_REG, lower_driver_field_cb, di->view); else { assert(di->view == NULL); vcode_reg_t count_reg = lower_type_width(lu, prefix_type, nets_reg); emit_drive_signal(lower_array_data(nets_reg), count_reg); } } const bool transfer = can_use_transfer_signal(proc, ds); vcode_reg_t trigger_reg = VCODE_INVALID_REG; if (transfer) { tree_t s0 = tree_stmt(proc, 0); assert(tree_kind(s0) == T_SIGNAL_ASSIGN); assert(tree_waveforms(s0) == 1); emit_debug_info(tree_loc(s0)); tree_t target = tree_target(s0); vcode_reg_t target_reg = lower_lvalue(lu, target); tree_t w0 = tree_waveform(s0, 0); vcode_reg_t source_reg = lower_lvalue(lu, tree_value(w0)); vcode_reg_t count_reg = lower_type_width(lu, tree_type(target), target_reg); vcode_reg_t delay_reg; if (tree_has_delay(w0)) delay_reg = lower_rvalue(lu, tree_delay(w0)); else delay_reg = emit_const(vtype_time(), 0); vcode_reg_t reject_reg = delay_reg; if (tree_has_reject(s0)) reject_reg = lower_rvalue(lu, tree_reject(s0)); vcode_reg_t target_nets = lower_array_data(target_reg); vcode_reg_t source_nets = lower_array_data(source_reg); emit_transfer_signal(target_nets, source_nets, count_reg, reject_reg, delay_reg); } else { // If the last statement in the process is a static wait then this // process is always sensitive to the same set of signals and we can // emit a single _sched_event call in the reset block tree_t wait = NULL; const int nstmts = tree_stmts(proc); if (nstmts > 0 && tree_kind((wait = tree_stmt(proc, nstmts - 1))) == T_WAIT && (tree_flags(wait) & TREE_F_STATIC_WAIT)) { const int ntriggers = tree_triggers(wait); for (int i = 0; i < ntriggers; i++) lower_sched_event(lu, tree_trigger(wait, i)); trigger_reg = lower_process_trigger(lu, proc); if (trigger_reg != VCODE_INVALID_REG) emit_add_trigger(trigger_reg); } } emit_return(VCODE_INVALID_REG); vcode_select_block(start_bb); if (transfer) emit_return(VCODE_INVALID_REG); else if (trigger_reg != VCODE_INVALID_REG) { tree_t s0 = tree_stmt(proc, 0); assert(tree_kind(s0) == T_IF); lower_stmt_coverage(lu, s0); const int nconds = tree_conds(s0); if (nconds == 1) { tree_t c = tree_cond(s0, 0); PUSH_COVER_SCOPE(lu, c); lower_sequence(lu, c, NULL); } else { assert(nconds == 2); tree_t c0 = tree_cond(s0, 0), c1 = tree_cond(s0, 1); vcode_reg_t test = lower_rvalue(lu, tree_value(c0)); vcode_block_t btrue = emit_block(); vcode_block_t bfalse = emit_block(); vcode_block_t bjoin = emit_block(); emit_cond(test, btrue, bfalse); { vcode_select_block(btrue); PUSH_COVER_SCOPE(lu, c0); lower_sequence(lu, c0, NULL); if (!vcode_block_finished()) emit_jump(bjoin); } { vcode_select_block(bfalse); PUSH_COVER_SCOPE(lu, c1); lower_sequence(lu, c1, NULL); if (!vcode_block_finished()) emit_jump(bjoin); } vcode_select_block(bjoin); } tree_t s1 = tree_stmt(proc, 1); assert(tree_kind(s1) == T_WAIT); lower_wait(lu, s1); } else lower_sequence(lu, proc, NULL); if (!vcode_block_finished()) emit_jump(start_bb); lower_finished(lu); unit_registry_finalise(parent->registry, lu); } static bool lower_is_signal_ref(tree_t expr) { switch (tree_kind(expr)) { case T_REF: return class_of(tree_ref(expr)) == C_SIGNAL; case T_ALIAS: case T_ARRAY_SLICE: case T_ARRAY_REF: case T_RECORD_REF: case T_QUALIFIED: case T_TYPE_CONV: return lower_is_signal_ref(tree_value(expr)); default: return false; } } static void lower_conv_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t target_ptr, vcode_reg_t result_ptr, vcode_reg_t locus, void *ctx) { type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t nets_reg = emit_load_indirect(target_ptr); vcode_reg_t count_reg, data_reg = result_ptr; if (type_is_array(ftype)) { count_reg = lower_array_total_len(lu, ftype, nets_reg); data_reg = lower_array_data(result_ptr); nets_reg = lower_array_data(nets_reg); } else { count_reg = emit_const(vtype_offset(), 1); nets_reg = emit_load_indirect(target_ptr); } vcode_reg_t cf_reg = (uintptr_t)ctx; emit_put_conversion(cf_reg, nets_reg, count_reg, data_reg); } else lower_for_each_field_2(lu, ftype, ftype, target_ptr, result_ptr, locus, lower_conv_field_cb, ctx); } static void lower_converter_body(lower_unit_t *lu, tree_t dst, tree_t src, tree_t conv, port_mode_t dir) { type_t dst_type = tree_type(dst); type_t src_type = tree_type(src); type_t conv_type = tree_type(conv); // Dummy return value to force function calling convention vcode_type_t voffset = vtype_offset(); vcode_set_result(voffset); vcode_type_t vcontext = vtype_context(lu->parent->name); emit_param(vcontext, vcontext, ident_new("context")); vcode_type_t vconv = vtype_conversion(); vcode_reg_t cf_reg = emit_param(vconv, vconv, ident_new("cf")); vcode_reg_t target_reg; if (tree_kind(dst) == T_PORT_DECL) target_reg = lower_port_ref(lu, dst); else target_reg = lower_lvalue(lu, dst); vcode_reg_t in_reg; if (dir == PORT_IN) in_reg = lower_rvalue(lu, src); else in_reg = lower_driving_value(lu, src); vcode_reg_t result_reg = in_reg; if (tree_kind(conv) == T_TYPE_CONV) result_reg = lower_conversion(lu, in_reg, conv, src_type, conv_type); else { tree_t fdecl = tree_ref(conv); type_t p0_type = tree_type(tree_port(fdecl, 0)); vcode_reg_t arg_reg = in_reg; if (type_is_array(p0_type)) arg_reg = lower_coerce_arrays(lu, src_type, p0_type, in_reg); vcode_type_t vrtype = lower_func_result_type(conv_type); vcode_type_t vrbounds = lower_bounds(conv_type); ident_t func = tree_ident2(fdecl); vcode_reg_t context_reg = lower_context_for_call(lu, func); vcode_reg_t args[] = { context_reg, arg_reg }; result_reg = emit_fcall(func, vrtype, vrbounds, args, 2); if (type_is_array(dst_type)) { vcode_reg_t locus = lower_debug_locus(conv); lower_check_array_sizes(lu, dst_type, conv_type, target_reg, result_reg, locus); } } if (type_is_homogeneous(dst_type)) { vcode_reg_t count_reg, data_reg = result_reg, nets_reg = target_reg; if (type_is_array(dst_type)) { count_reg = lower_array_total_len(lu, dst_type, target_reg); data_reg = lower_array_data(result_reg); nets_reg = lower_array_data(target_reg); } else count_reg = emit_const(voffset, 1); emit_put_conversion(cf_reg, nets_reg, count_reg, data_reg); } else { vcode_reg_t locus = lower_debug_locus(conv); lower_for_each_field_2(lu, dst_type, conv_type, target_reg, result_reg, locus, lower_conv_field_cb, (void *)(uintptr_t)cf_reg); } emit_return(emit_const(voffset, 0)); } static void lower_out_converter(lower_unit_t *lu, object_t *obj) { tree_t map = tree_from_object(obj); assert(tree_kind(map) == T_PARAM); tree_t value = tree_value(map), conv = tree_name(map); tree_t src = tree_value(conv), dst = value; const tree_kind_t value_kind = tree_kind(value); if (value_kind == T_CONV_FUNC || value_kind == T_TYPE_CONV) dst = tree_value(value); lower_converter_body(lu, dst, src, conv, PORT_OUT); } static void lower_in_converter(lower_unit_t *lu, object_t *obj) { tree_t map = tree_from_object(obj); assert(tree_kind(map) == T_PARAM); tree_t conv = tree_value(map); tree_t src = NULL; const tree_kind_t value_kind = tree_kind(conv); if (value_kind == T_CONV_FUNC || value_kind == T_TYPE_CONV) { tree_t p0 = tree_value(conv); assert(lower_is_signal_ref(p0)); src = p0; } tree_t dst; switch (tree_subkind(map)) { case P_POS: dst = tree_port(lu->parent->container, tree_pos(map)); break; case P_NAMED: { dst = tree_name(map); const tree_kind_t kind = tree_kind(dst); if (kind == T_CONV_FUNC || kind == T_TYPE_CONV) dst = tree_value(dst); } break; default: should_not_reach_here(); } // Dummy return value to force function calling convention vcode_type_t voffset = vtype_offset(); vcode_set_result(voffset); lower_converter_body(lu, dst, src, conv, PORT_IN); } static vcode_reg_t lower_converter(lower_unit_t *parent, tree_t map, port_mode_t dir) { tree_t conv = dir == PORT_IN ? tree_value(map) : tree_name(map); // Detect some trivial cases and avoid generating a conversion function switch (tree_kind(conv)) { case T_TYPE_CONV: { type_t conv_type = tree_type(conv); type_t src_type = tree_type(tree_value(conv)); if (type_is_array(conv_type) && type_is_array(src_type)) { if (type_eq(type_elem(conv_type), type_elem(src_type))) return VCODE_INVALID_REG; } else if (type_is_enum(conv_type) && type_is_enum(src_type)) return VCODE_INVALID_REG; } break; case T_CONV_FUNC: break; default: should_not_reach_here(); } ident_t name; switch (tree_subkind(map)) { case P_POS: { tree_t port = tree_port(parent->container, tree_pos(map)); name = ident_sprintf("%s.%s.convert_%s", istr(parent->name), istr(tree_ident(port)), dir == PORT_IN ? "in" : "out"); } break; case P_NAMED: { tree_t dst = tree_name(map); const tree_kind_t kind = tree_kind(dst); if (kind == T_CONV_FUNC || kind == T_TYPE_CONV) dst = tree_value(dst); if (tree_kind(dst) == T_REF) name = ident_sprintf("%s.%s.convert_%s", istr(parent->name), istr(tree_ident(dst)), dir == PORT_IN ? "in" : "out"); else name = ident_uniq("%s.%s.convert_%s.part", istr(parent->name), istr(tree_ident(tree_ref(name_to_ref(dst)))), dir == PORT_IN ? "in" : "out"); } break; default: should_not_reach_here(); } lower_fn_t lower_fn = dir == PORT_IN ? lower_in_converter : lower_out_converter; unit_registry_defer(parent->registry, name, parent, emit_function, lower_fn, NULL, tree_to_object(map)); vcode_reg_t context_reg = emit_context_upref(0); vcode_reg_t vdummy = vtype_opaque(); return emit_closure(name, context_reg, vdummy); } static void lower_map_signal_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t src_ptr, vcode_reg_t dst_ptr, vcode_reg_t locus, void *ctx) { type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t dst_reg = emit_load_indirect(dst_ptr); vcode_reg_t src_reg; if (lower_have_signal(src_ptr)) src_reg = emit_load_indirect(src_ptr); else if (have_uarray_ptr(src_ptr)) src_reg = emit_load_indirect(src_ptr); else src_reg = src_ptr; if (type_is_array(ftype)) lower_check_array_sizes(lu, ftype, ftype, src_reg, dst_reg, locus); vcode_reg_t count_reg = lower_type_width(lu, ftype, dst_reg); src_reg = lower_array_data(src_reg); dst_reg = lower_array_data(dst_reg); if (lower_have_signal(src_reg)) emit_map_signal(src_reg, dst_reg, count_reg); else emit_map_const(src_reg, dst_reg, count_reg); } else lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus, lower_map_signal_field_cb, ctx); } static void lower_map_view_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t src_ptr, vcode_reg_t dst_ptr, vcode_reg_t locus, void *__ctx) { tree_t view = untag_pointer(__ctx, void); bool converse = !!pointer_tag(__ctx); tree_t elem = find_element_mode_indication(view, field, &converse); assert(elem != NULL); type_t ftype = tree_type(field); if (type_is_homogeneous(ftype)) { vcode_reg_t src_reg = emit_load_indirect(src_ptr); vcode_reg_t dst_reg = emit_load_indirect(dst_ptr); if (type_is_array(ftype)) lower_check_array_sizes(lu, ftype, ftype, src_reg, dst_reg, locus); vcode_reg_t count_reg = lower_type_width(lu, ftype, src_reg); vcode_reg_t src_nets = lower_array_data(src_reg); vcode_reg_t dst_nets = lower_array_data(dst_reg); switch (converse_mode(elem, converse)) { case PORT_IN: emit_map_signal(dst_nets, src_nets, count_reg); break; case PORT_OUT: case PORT_INOUT: case PORT_BUFFER: emit_map_signal(src_nets, dst_nets, count_reg); break; default: fatal_trace("unhandled port mode in lower_map_view_field_cb"); } } else if (tree_subkind(elem) == PORT_RECORD_VIEW) { void *new_ctx = tag_pointer(tree_value(elem), converse); lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus, lower_map_view_field_cb, new_ctx); } else if (converse_mode(elem, converse) == PORT_IN) lower_for_each_field_2(lu, ftype, ftype, dst_ptr, src_ptr, locus, lower_map_signal_field_cb, NULL); else lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, locus, lower_map_signal_field_cb, NULL); } static void lower_map_signal(lower_unit_t *lu, vcode_reg_t src_reg, vcode_reg_t dst_reg, type_t src_type, type_t dst_type, tree_t where) { if (!type_is_homogeneous(src_type)) { vcode_reg_t locus = lower_debug_locus(where); lower_for_each_field_2(lu, src_type, dst_type, src_reg, dst_reg, locus, lower_map_signal_field_cb, NULL); } else if (type_is_array(src_type)) { vcode_reg_t locus = lower_debug_locus(where); lower_check_array_sizes(lu, dst_type, src_type, dst_reg, src_reg, locus); vcode_reg_t src_nets = lower_array_data(src_reg); vcode_reg_t dst_nets = lower_array_data(dst_reg); vcode_reg_t count_reg = lower_array_total_len(lu, dst_type, dst_reg); if (lower_have_signal(src_reg)) emit_map_signal(src_nets, dst_nets, count_reg); else emit_map_const(src_nets, dst_nets, count_reg); } else { vcode_reg_t count_reg = emit_const(vtype_offset(), 1); vcode_reg_t dst_nets = lower_array_data(dst_reg); if (lower_have_signal(src_reg)) emit_map_signal(src_reg, dst_nets, count_reg); else emit_map_const(src_reg, dst_nets, count_reg); } } static void lower_convert_signal_field_cb(lower_unit_t *lu, tree_t field, vcode_reg_t src_ptr, vcode_reg_t dst_ptr, vcode_reg_t conv_func, void *ctx) { type_t ftype = tree_type(field); void (*emit_fn)(vcode_reg_t, vcode_reg_t, vcode_reg_t) = ctx; if (type_is_homogeneous(ftype)) { vcode_reg_t nets_reg = emit_load_indirect(src_ptr); vcode_reg_t count_reg = lower_type_width(lu, ftype, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); (*emit_fn)(conv_func, data_reg, count_reg); } else lower_for_each_field_2(lu, ftype, ftype, src_ptr, dst_ptr, conv_func, lower_convert_signal_field_cb, ctx); } static void lower_convert_signal(lower_unit_t *lu, vcode_reg_t src_reg, type_t type, vcode_reg_t conv_func, convert_emit_fn emit_fn) { if (!type_is_homogeneous(type)) lower_for_each_field(lu, type, src_reg, conv_func, lower_convert_signal_field_cb, emit_fn); else if (type_is_array(type)) { vcode_reg_t count_reg = lower_array_total_len(lu, type, src_reg); vcode_reg_t nets_reg = lower_array_data(src_reg); (*emit_fn)(conv_func, nets_reg, count_reg); } else { vcode_reg_t count_reg = emit_const(vtype_offset(), 1); vcode_reg_t nets_reg = lower_array_data(src_reg); (*emit_fn)(conv_func, nets_reg, count_reg); } } static void lower_inertial_actual_process(lower_unit_t *lu, object_t *obj) { // Construct the equivalent process according the procedure in LRM 08 // section 6.5.6.3 tree_t inertial = tree_from_object(obj); assert(tree_kind(inertial) == T_INERTIAL); tree_t expr = tree_value(inertial); tree_t target = tree_target(inertial); type_t type = tree_type(target); // Block number one must be the non-reset entry point vcode_block_t main_bb = emit_block(); assert(main_bb == 1); int hops; vcode_var_t var = lower_search_vcode_obj(inertial, lu, &hops); assert(var != VCODE_INVALID_VAR); if (tree_global_flags(inertial) & TREE_GF_EXTERNAL_NAME) tree_visit_only(inertial, lower_external_name_cache, lu, T_EXTERNAL_NAME); if (type_is_homogeneous(type)) { vcode_reg_t nets_reg = emit_load_indirect(emit_var_upref(1, var)); vcode_reg_t count_reg = lower_type_width(lu, type, nets_reg); vcode_reg_t data_reg = lower_array_data(nets_reg); emit_drive_signal(data_reg, count_reg); } else { vcode_reg_t ptr_reg = emit_var_upref(1, var); lower_for_each_field(lu, type, ptr_reg, VCODE_INVALID_REG, lower_driver_field_cb, NULL); } build_wait(expr, lower_build_wait_cb, lu); emit_return(VCODE_INVALID_REG); vcode_select_block(main_bb); lu->cscope = cover_create_scope(lu->cover, lu->parent->cscope, inertial, NULL); vcode_reg_t zero_time_reg = emit_const(vtype_time(), 0); vcode_reg_t value_reg = lower_rvalue(lu, expr); vcode_reg_t nets_reg = emit_var_upref(1, var); if (!type_is_record(type)) nets_reg = emit_load_indirect(nets_reg); target_part_t parts[] = { { .kind = PART_ALL, .reg = nets_reg, .off = VCODE_INVALID_REG, .target = target }, { .kind = PART_POP, .reg = VCODE_INVALID_REG, .off = VCODE_INVALID_REG, } }; target_part_t *ptr = parts; lower_signal_assign_target(lu, &ptr, target, value_reg, tree_type(expr), zero_time_reg, zero_time_reg); emit_return(VCODE_INVALID_REG); } static void lower_inertial_actual(lower_unit_t *parent, tree_t dst, vcode_reg_t port_reg, tree_t actual) { assert(standard() >= STD_08); ident_t name; if (tree_kind(dst) == T_PORT_DECL) name = ident_sprintf("%s_actual", istr(tree_ident(dst))); else name = ident_uniq("%s_actual.part", istr(tree_ident(name_to_ref(dst)))); type_t type = tree_type(dst); vcode_type_t signal_type = lower_signal_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t var = emit_var(signal_type, vbounds, name, VAR_SIGNAL); lower_put_vcode_obj(actual, var, parent); if (type_is_record(type)) { vcode_reg_t locus = lower_debug_locus(dst); vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG); lower_copy_record(parent, type, ptr_reg, port_reg, locus); } else emit_store(port_reg, var); ident_t pname = ident_prefix(parent->name, name, '.'); unit_registry_defer(parent->registry, pname, parent, emit_process, lower_inertial_actual_process, parent->cover, tree_to_object(actual)); emit_process_init(pname, lower_debug_locus(actual)); } static tree_t lower_get_view(tree_t name, port_mode_t *mode, bool *converse) { switch (tree_kind(name)) { case T_REF: { tree_t port = tree_ref(name); assert(tree_kind(port) == T_PORT_DECL); *mode = tree_subkind(port); return tree_value(port); } case T_RECORD_REF: { tree_t view = lower_get_view(tree_value(name), mode, converse); if (view == NULL) return NULL; tree_t elem = find_element_mode_indication(view, tree_ref(name), converse); assert(elem != NULL); *mode = converse_mode(elem, *converse); if (*mode == PORT_ARRAY_VIEW || *mode == PORT_RECORD_VIEW) return tree_value(elem); else return NULL; } case T_ARRAY_REF: case T_ARRAY_SLICE: return lower_get_view(tree_value(name), mode, converse); default: should_not_reach_here(); } } static void lower_port_map(lower_unit_t *lu, tree_t block, tree_t map, vcode_reg_t value_reg) { vcode_reg_t port_reg = VCODE_INVALID_REG; tree_t view = NULL, name; vcode_reg_t out_conv = VCODE_INVALID_REG; vcode_reg_t in_conv = VCODE_INVALID_REG; tree_t value = tree_value(map); port_mode_t mode = PORT_IN; tree_t value_conv = NULL; const tree_kind_t value_kind = tree_kind(value); if (value_kind == T_CONV_FUNC || value_kind == T_TYPE_CONV) { assert(value_reg == VCODE_INVALID_REG); tree_t p0 = tree_value(value); if (lower_is_signal_ref(p0)) { value_conv = p0; value_reg = lower_lvalue(lu, p0); } else value_reg = lower_rvalue(lu, value); } switch (tree_subkind(map)) { case P_POS: { tree_t port = name = tree_port(block, tree_pos(map)); mode = tree_subkind(port); if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) view = tree_value(port); int hops; vcode_var_t var = lower_get_var(lu, port, &hops); assert(hops == 0); if (type_is_homogeneous(tree_type(port))) port_reg = emit_load(var); else port_reg = emit_index(var, VCODE_INVALID_REG); } break; case P_NAMED: { name = tree_name(map); const tree_kind_t kind = tree_kind(name); if (kind == T_CONV_FUNC || kind == T_TYPE_CONV) { out_conv = lower_converter(lu, map, PORT_OUT); name = tree_value(name); } tree_t port = tree_ref(name_to_ref(name)); mode = tree_subkind(port); if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { bool converse = false; view = lower_get_view(name, &mode, &converse); } port_reg = lower_lvalue(lu, name); } break; default: should_not_reach_here(); } if (value_conv != NULL) { // Value has conversion function in_conv = lower_converter(lu, map, PORT_IN); value = value_conv; } if (tree_kind(value) == T_INERTIAL) lower_inertial_actual(lu, name, port_reg, value); else if (value_reg == VCODE_INVALID_REG) return; else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { assert(lower_is_signal_ref(value)); vcode_reg_t locus = lower_debug_locus(view); lower_for_each_field_2(lu, tree_type(name), tree_type(value), port_reg, value_reg, locus, lower_map_view_field_cb, view); } else if (lower_is_signal_ref(value)) { type_t value_type = tree_type(value); type_t name_type = tree_type(name); vcode_reg_t src_reg = mode == PORT_IN ? value_reg : port_reg; vcode_reg_t dst_reg = mode == PORT_IN ? port_reg : value_reg; vcode_reg_t conv_func = mode == PORT_IN ? in_conv : out_conv; type_t src_type = mode == PORT_IN ? value_type : name_type; type_t dst_type = mode == PORT_IN ? name_type : value_type; if (conv_func != VCODE_INVALID_REG) { vcode_reg_t conv_reg = emit_port_conversion(conv_func, in_conv); lower_convert_signal(lu, dst_reg, dst_type, conv_reg, emit_convert_out); lower_convert_signal(lu, src_reg, src_type, conv_reg, emit_convert_in); } else lower_map_signal(lu, src_reg, dst_reg, src_type, dst_type, map); } else { type_t value_type = tree_type(value); type_t name_type = tree_type(name); lower_map_signal(lu, value_reg, port_reg, value_type, name_type, map); } } static void lower_direct_mapped_port(lower_unit_t *lu, driver_set_t *ds, tree_t block, tree_t map, hset_t *direct, hset_t **poison, vcode_reg_t src_reg) { tree_t port = NULL; int field = -1; switch (tree_subkind(map)) { case P_POS: port = tree_port(block, tree_pos(map)); break; case P_NAMED: { tree_t name = tree_name(map); tree_kind_t kind = tree_kind(name); if (kind == T_RECORD_REF) { field = tree_pos(tree_ref(name)); name = tree_value(name); kind = tree_kind(name); } if (kind != T_REF) return; port = tree_ref(name); } break; } assert(tree_kind(port) == T_PORT_DECL); tree_t value = tree_value(map); if (tree_class(port) == C_VARIABLE) { // Variable ports are always directly aliased to the actual // variable in the parent scope vcode_type_t vtype = lower_type(tree_type(port)); vcode_var_t var = emit_var(vtype, vtype, tree_ident(port), 0); lower_put_vcode_obj(port, var, lu); vcode_reg_t src_reg = lower_rvalue(lu, value); emit_store(src_reg, var); hset_insert(direct, map); hset_insert(direct, port); return; } else if (tree_subkind(port) != PORT_IN) return; // Not safe in general else if (!lower_is_signal_ref(value) || tree_kind(value) == T_TYPE_CONV) { if (field != -1) { // We can't use direct mapping for this record element so make // sure we don't direct map any other elements of this signal if (*poison == NULL) *poison = hset_new(32); hset_insert(*poison, port); } return; } else if (*poison != NULL && hset_contains(*poison, port)) return; type_t type = tree_type(value); type_t port_type = tree_type(port); if (type_is_unconstrained(port_type)) return; // Not supported for now int hops = 0; vcode_var_t var = lower_search_vcode_obj(port, lu, &hops); assert(var != VCODE_INVALID_VAR); assert(hops == 0); type_t field_type = port_type; if (field != -1) { tree_t f = type_field(port_type, field); tree_t cons = type_constraint_for_field(port_type, f); field_type = tree_type(cons ?: f); port_type = tree_type(f); } vcode_reg_t bounds_reg = VCODE_INVALID_REG; if (!type_const_bounds(field_type)) bounds_reg = lower_get_type_bounds(lu, field_type); if (type_is_array(type)) { vcode_reg_t locus = lower_debug_locus(map); lower_check_array_sizes(lu, field_type, type, bounds_reg, src_reg, locus); } if (field != -1) { vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG); vcode_reg_t field_reg = emit_record_ref(ptr_reg, field); if (type_is_record(type)) emit_copy(field_reg, src_reg, VCODE_INVALID_REG); else if (type_is_array(type)) { if (type_is_homogeneous(type)){ vcode_reg_t coerce_reg = lower_coerce_arrays(lu, type, port_type, src_reg); emit_store_indirect(coerce_reg, field_reg); } else { vcode_reg_t data_reg = lower_array_data(src_reg); vcode_reg_t count_reg = lower_array_total_len(lu, type, src_reg); emit_copy(field_reg, data_reg, count_reg); } } else emit_store_indirect(src_reg, field_reg); } else if (type_is_record(type)) { vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG); emit_copy(ptr_reg, src_reg, VCODE_INVALID_REG); } else if (type_is_array(type)) { vcode_reg_t data_reg = lower_array_data(src_reg); if (vcode_reg_kind(data_reg) == VCODE_TYPE_SIGNAL) emit_alias_signal(data_reg, lower_debug_locus(port)); if (bounds_reg != VCODE_INVALID_REG) { vcode_reg_t wrap_reg = lower_rewrap(data_reg, bounds_reg); emit_store(wrap_reg, var); } else if (!type_is_homogeneous(type)) { vcode_reg_t ptr_reg = emit_index(var, VCODE_INVALID_REG); vcode_reg_t count_reg = lower_array_total_len(lu, type, src_reg); emit_copy(ptr_reg, data_reg, count_reg); } else emit_store(data_reg, var); } else { emit_alias_signal(src_reg, lower_debug_locus(port)); emit_store(src_reg, var); } hset_insert(direct, map); hset_insert(direct, port); } static void lower_port_signal(lower_unit_t *lu, tree_t port, vcode_var_t var, vcode_reg_t bounds_reg) { type_t type = tree_type(port); type_t value_type = type; const port_mode_t mode = tree_subkind(port); tree_t view = NULL; vcode_reg_t init_reg = VCODE_INVALID_REG; if (mode == PORT_RECORD_VIEW || mode == PORT_ARRAY_VIEW) { // No explicit initial value view = tree_value(port); } else if (tree_has_value(port)) { tree_t value = tree_value(port); value_type = tree_type(value); init_reg = lower_rvalue(lu, value); } sig_flags_t flags = 0; if (tree_flags(port) & TREE_F_REGISTER) flags |= SIG_F_REGISTER; // Port signals will need separate driving/effective values if they // are inout or have conversion functions. if (mode == PORT_INOUT) flags |= NET_F_EFFECTIVE | NET_F_INOUT; lower_sub_signals(lu, type, type, value_type, port, view, var, VCODE_INVALID_REG, init_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, flags, bounds_reg); } static vcode_reg_t lower_constrain_port(lower_unit_t *lu, tree_t port, int pos, tree_t block, vcode_reg_t *map_regs) { vcode_reg_t left_reg = VCODE_INVALID_REG, right_reg = VCODE_INVALID_REG; type_t port_type = tree_type(port); vcode_reg_t rptr_reg = VCODE_INVALID_VAR; if (type_is_record(port_type)) { vcode_type_t vtype = lower_signal_type(port_type); ident_t name = ident_prefix(tree_ident(port), ident_new("cons"), '$'); vcode_var_t rec_var = emit_var(vtype, vtype, name, 0); rptr_reg = emit_index(rec_var, VCODE_INVALID_REG); } const int nparams = tree_params(block); for (int i = 0; i < nparams; i++) { tree_t map = tree_param(block, i), name = NULL; switch (tree_subkind(map)) { case P_POS: if (tree_pos(map) != pos) continue; break; case P_NAMED: { name = tree_name(map); tree_t ref; switch (tree_kind(name)) { case T_TYPE_CONV: case T_CONV_FUNC: ref = name_to_ref(tree_value(name)); break; default: ref = name_to_ref(name); break; } if (ref == NULL || tree_ref(ref) != port) continue; } break; } vcode_reg_t bounds_reg; if (map_regs[i] == VCODE_INVALID_REG) { // Has conversion function tree_t value = tree_value(map); assert(tree_kind(value) == T_CONV_FUNC); // TODO: lower_get_type_bounds does not support records type_t type = tree_type(value); if (type_is_record(type)) bounds_reg = lower_default_value(lu, type, VCODE_INVALID_REG); else bounds_reg = lower_get_type_bounds(lu, type); } else bounds_reg = map_regs[i]; if (name == NULL || tree_kind(name) == T_REF) { type_t value_type = tree_type(tree_value(map)); if (type_is_array(port_type)) return lower_coerce_arrays(lu, value_type, port_type, bounds_reg); else return bounds_reg; } switch (tree_kind(name)) { case T_ARRAY_REF: { // The name is of the form X(I) so use this to derive // the bounds of a single-element array tree_t value = tree_value(tree_param(name, 0)); if (left_reg == VCODE_INVALID_REG) left_reg = right_reg = lower_rvalue(lu, value); else { vcode_reg_t value_reg = lower_rvalue(lu, value); vcode_reg_t below_reg = emit_cmp(VCODE_CMP_LT, value_reg, left_reg); vcode_reg_t above_reg = emit_cmp(VCODE_CMP_GT, value_reg, right_reg); left_reg = emit_select(below_reg, value_reg, left_reg); right_reg = emit_select(above_reg, value_reg, right_reg); } } break; case T_RECORD_REF: { tree_t f = tree_ref(name); assert(tree_kind(f) == T_FIELD_DECL); type_t ftype = tree_type(f); if (!type_is_unconstrained(ftype)) continue; type_t value_type = tree_type(tree_value(map)); vcode_reg_t value_reg; if (type_is_array(ftype)) value_reg = lower_coerce_arrays(lu, value_type, ftype, bounds_reg); else value_reg = bounds_reg; vcode_reg_t field_reg = emit_record_ref(rptr_reg, tree_pos(f)); emit_store_indirect(value_reg, field_reg); } break; case T_CONV_FUNC: case T_TYPE_CONV: return lower_get_type_bounds(lu, tree_type(name)); default: // TODO: this should be an assert and a proper error generated // during sem/elab fatal_at(tree_loc(name), "invalid formal name for unconstrained " "port %s", istr(tree_ident(port))); } } if (rptr_reg != VCODE_INVALID_REG) return rptr_reg; else { assert(left_reg != VCODE_INVALID_REG); type_t elem = type_elem_recur(port_type); vcode_type_t velem = lower_type(elem); vcode_reg_t dir_reg = emit_const(vtype_bool(), RANGE_TO); vcode_reg_t null_reg = emit_null(vtype_pointer(velem)); vcode_dim_t dims[] = { { left_reg, right_reg, dir_reg }, }; return emit_wrap(null_reg, dims, 1); } } static vcode_reg_t lower_open_port_map(lower_unit_t *lu, tree_t block, tree_t p) { tree_t port; if (tree_subkind(p) == P_NAMED) { tree_t name = tree_name(p); if (tree_kind(name) == T_REF) port = tree_ref(name); else { // VHDL-2019 partially connected vectors in port map assert(standard() >= STD_19); return VCODE_INVALID_REG; } } else port = tree_port(block, tree_pos(p)); if (tree_subkind(port) == PORT_IN && tree_has_value(port)) { tree_t def = tree_value(port); vcode_reg_t def_reg = lower_rvalue(lu, def); type_t port_type = tree_type(port); if (type_is_array(port_type)) return lower_coerce_arrays(lu, tree_type(def), port_type, def_reg); return def_reg; } else return VCODE_INVALID_REG; } static void lower_ports(lower_unit_t *lu, driver_set_t *ds, tree_t block) { const int nports = tree_ports(block); const int nparams = tree_params(block); hset_t *direct = hset_new(nports * 2), *poison = NULL; vcode_reg_t *map_regs LOCAL = xmalloc_array(nparams, sizeof(vcode_reg_t)); vcode_var_t *port_vars LOCAL = xmalloc_array(nports, sizeof(vcode_var_t)); for (int i = 0; i < nparams; i++) { tree_t p = tree_param(block, i); tree_t value = tree_value(p); const tree_kind_t kind = tree_kind(value); if (kind == T_TYPE_CONV || kind == T_CONV_FUNC || kind == T_INERTIAL) map_regs[i] = VCODE_INVALID_REG; else if (lower_is_signal_ref(value)) map_regs[i] = lower_lvalue(lu, value); else if (tree_kind(value) == T_OPEN) map_regs[i] = lower_open_port_map(lu, block, p); else map_regs[i] = lower_rvalue(lu, value); } for (int i = 0; i < nports; i++) { tree_t port = tree_port(block, i); type_t type = tree_type(port); vcode_type_t vtype = lower_signal_type(type); port_vars[i] = emit_var(vtype, vtype, tree_ident(port), VAR_SIGNAL); lower_put_vcode_obj(port, port_vars[i], lu); } if (!opt_get_int(OPT_NO_COLLAPSE)) { // Filter out "direct mapped" inputs which can be aliased to // signals in the scope above for (int i = 0; i < nparams; i++) lower_direct_mapped_port(lu, ds, block, tree_param(block, i), direct, &poison, map_regs[i]); } for (int i = 0; i < nports; i++) { tree_t port = tree_port(block, i); type_t type = tree_type(port); vcode_reg_t bounds_reg = VCODE_INVALID_REG; if (type_is_unconstrained(type)) bounds_reg = lower_constrain_port(lu, port, i, block, map_regs); else if (!type_const_bounds(type)) bounds_reg = lower_get_type_bounds(lu, type); if (!hset_contains(direct, port)) lower_port_signal(lu, port, port_vars[i], bounds_reg); else if (poison != NULL && hset_contains(poison, port)) lower_port_signal(lu, port, port_vars[i], bounds_reg); } for (int i = 0; i < nparams; i++) { tree_t map = tree_param(block, i); if (!hset_contains(direct, map)) lower_port_map(lu, block, map, map_regs[i]); else if (poison != NULL && tree_subkind(map) == P_NAMED) { tree_t port = tree_ref(name_to_ref(tree_name(map))); if (hset_contains(poison, port)) lower_port_map(lu, block, map, map_regs[i]); } } if (cover_enabled(lu->cover, COVER_MASK_TOGGLE)) { for (int i = 0; i < nports; i++) { tree_t p = tree_port(block, i); PUSH_COVER_SCOPE(lu, p); lower_toggle_coverage(lu, p); } } hset_free(direct); if (poison != NULL) hset_free(poison); } static void lower_check_generic_constraint(lower_unit_t *lu, tree_t expect, tree_t generic, vcode_reg_t locus) { vcode_reg_t expect_reg = lower_rvalue(lu, expect); if (expect_reg == VCODE_INVALID_REG) return; // Was OPEN int hops; vcode_var_t actual_var = lower_get_var(lu, generic, &hops); assert(actual_var != VCODE_INVALID_VAR); assert(hops == 0); type_t type = tree_type(expect); vcode_reg_t test_reg; if (type_is_scalar(type)) { vcode_reg_t actual_reg = emit_load(actual_var); test_reg = emit_cmp(VCODE_CMP_EQ, expect_reg, actual_reg); } else { vcode_reg_t actual_reg; if (vtype_kind(vcode_var_type(actual_var)) == VCODE_TYPE_UARRAY) actual_reg = emit_load(actual_var); else actual_reg = emit_index(actual_var, VCODE_INVALID_REG); vcode_reg_t left_reg = actual_reg, right_reg = expect_reg; if (type_is_array(type)) { left_reg = lower_wrap(lu, type, actual_reg); right_reg = lower_wrap(lu, type, expect_reg); } ident_t func = lower_predef_func_name(type, "="); vcode_reg_t context_reg = lower_context_for_call(lu, func); vcode_reg_t args[] = { context_reg, left_reg, right_reg }; vcode_type_t vbool = vtype_bool(); test_reg = emit_fcall(func, vbool, vbool, args, 3); } vcode_type_t vseverity = vtype_int(0, SEVERITY_FAILURE - 1); vcode_reg_t error_reg = emit_const(vseverity, SEVERITY_ERROR); emit_assert(test_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, error_reg, locus, VCODE_INVALID_REG, VCODE_INVALID_REG); } static void lower_pack_inst_generics(lower_unit_t *lu, tree_t inst, tree_t map) { int hops = 0; vcode_reg_t var = lower_search_vcode_obj(inst, lu, &hops); vcode_reg_t context; if (var == VCODE_INVALID_VAR) context = emit_link_package(tree_ident(inst)); else context = emit_load_indirect(emit_var_upref(hops, var)); const int ngenerics = tree_generics(inst); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(inst, i); if (tree_class(g) != C_CONSTANT) continue; type_t type = tree_type(g); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); ident_t name = tree_ident(g); vcode_var_t var = emit_var(vtype, vbounds, name, VAR_CONST); vcode_reg_t ptr_reg = emit_link_var(context, name, vtype); if (type_is_scalar(type)) emit_store(emit_load_indirect(ptr_reg), var); else if (type_is_array(type)) { if (type_const_bounds(type)) { vcode_reg_t count_reg = lower_array_total_len(lu, type, ptr_reg); vcode_reg_t dest_reg = emit_index(var, VCODE_INVALID_REG); vcode_reg_t src_reg = lower_array_data(ptr_reg); emit_copy(dest_reg, src_reg, count_reg); } } else { vcode_reg_t dest_reg = emit_index(var, VCODE_INVALID_REG); emit_copy(dest_reg, ptr_reg, VCODE_INVALID_REG); } lower_put_vcode_obj(g, var, lu); tree_t g0 = tree_generic(tree_ref(inst), i); lower_put_vcode_obj(g0, var, lu); } switch (tree_subkind(map)) { case PACKAGE_MAP_MATCHING: { const int count = tree_genmaps(map); for (int i = 0; i < count; i++) { tree_t m = tree_genmap(map, i); assert(tree_subkind(m) == P_POS); tree_t g = tree_generic(inst, i); vcode_reg_t locus = lower_debug_locus(m); lower_check_generic_constraint(lu, tree_value(m), g, locus); } } break; case PACKAGE_MAP_DEFAULT: for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(inst, i); tree_t g0 = tree_generic(tree_ref(map), i); vcode_reg_t locus = lower_debug_locus(map); lower_check_generic_constraint(lu, tree_value(g0), g, locus); } break; case PACKAGE_MAP_BOX: break; } } static void lower_generics(lower_unit_t *lu, tree_t block, tree_t primary) { const int ngenerics = tree_generics(block); assert(ngenerics == tree_genmaps(block)); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(block, i); tree_t m = tree_genmap(block, i); assert(tree_subkind(m) == P_POS); const class_t class = tree_class(g); if (class == C_PACKAGE) { // Make generics in a package instance passed via a package // interface generic available tree_t map = tree_value(g); assert(tree_kind(map) == T_PACKAGE_MAP); tree_t inst = tree_ref(tree_value(m)); assert(tree_kind(inst) == T_PACK_INST); lower_pack_inst_generics(lu, inst, map); } if (class != C_CONSTANT) continue; // Skip type generics, etc. type_t type = tree_type(g); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t var = emit_var(vtype, vbounds, tree_ident(g), VAR_CONST); vcode_reg_t mem_reg = VCODE_INVALID_REG, count_reg = VCODE_INVALID_REG; const bool is_array = type_is_array(type); if (is_array && type_const_bounds(type)) { mem_reg = emit_index(var, VCODE_INVALID_REG); count_reg = lower_array_total_len(lu, type, VCODE_INVALID_REG); } else if (type_is_record(type)) mem_reg = emit_index(var, VCODE_INVALID_REG); tree_t value = tree_value(m); vcode_reg_t value_reg; switch (tree_kind(value)) { case T_AGGREGATE: value_reg = lower_aggregate(lu, value, mem_reg); break; case T_OPEN: assert(tree_has_value(g)); value = tree_value(g); // Fall-through default: value_reg = lower_rvalue(lu, value); break; } if (is_array && mem_reg != VCODE_INVALID_REG) { vcode_reg_t locus = lower_debug_locus(g); lower_check_array_sizes(lu, type, tree_type(value), VCODE_INVALID_REG, value_reg, locus); } else if (type_is_scalar(type)) lower_check_scalar_bounds(lu, value_reg, type, value, g); if (mem_reg != VCODE_INVALID_REG) emit_copy(mem_reg, lower_array_data(value_reg), count_reg); else if (is_array) { vcode_reg_t wrap_reg = lower_coerce_arrays(lu, tree_type(value), type, value_reg); emit_store(wrap_reg, var); } else emit_store(value_reg, var); lower_put_vcode_obj(g, var, lu); if (primary != NULL) { // The generic object in the instance may have been copied in // which case we also need to associate the variable with the // original generic in the primary unit tree_t g2 = tree_generic(primary, i); assert(ident_casecmp(tree_ident(g2), tree_ident(g))); if (g2 != g) lower_put_vcode_obj(g2, var, lu); } } } static void lower_deps_cb(ident_t unit_name, void *__ctx) { lower_unit_t *lu = __ctx; object_t *obj = lib_load_handler(unit_name); tree_t unit = tree_from_object(obj); if (unit == NULL) return; const tree_kind_t kind = tree_kind(unit); if (kind != T_ENTITY && unit_name == lu->name) return; // Package body depends on package if (kind == T_PACKAGE && standard() >= STD_08) { if (is_uninstantiated_package(unit)) return; // No code generated for uninstantiated packages } if (kind != T_PACKAGE && kind != T_PACK_INST) return; vcode_reg_t reg = emit_package_init(unit_name, VCODE_INVALID_REG); lower_put_vcode_obj(unit_name, reg, lu); } static void lower_dependencies(lower_unit_t *lu, tree_t unit) { tree_walk_deps(unit, lower_deps_cb, lu); switch (tree_kind(unit)) { case T_ARCH: case T_PACK_BODY: lower_dependencies(lu, tree_primary(unit)); break; case T_PACK_INST: { tree_t pack = tree_ref(unit); assert(is_uninstantiated_package(pack)); if (package_needs_body(pack)) { tree_t body = body_of(pack); assert(body != NULL); lower_dependencies(lu, body); } else lower_dependencies(lu, pack); } break; case T_BLOCK: { tree_t hier = tree_decl(unit, 0); assert(tree_kind(hier) == T_HIER); tree_t src = tree_ref(hier); if (is_design_unit(src)) lower_dependencies(lu, src); } break; default: break; } } static bool lower_push_package_scope(tree_t pack) { const int ndecls = tree_decls(pack); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(pack, i); if (tree_kind(d) == T_SIGNAL_DECL) { vcode_reg_t locus = lower_debug_locus(pack); emit_package_scope(locus); return true; } } return false; } static void lower_cache_instance_name(lower_unit_t *lu, attr_kind_t which) { ident_t name = well_known(which == ATTR_INSTANCE_NAME ? W_INSTANCE_NAME : W_PATH_NAME); vcode_type_t vchar = vtype_char(); vcode_type_t vstring = vtype_uarray(1, vchar, vchar); vcode_var_t var = emit_var(vstring, vchar, name, VAR_CONST); switch (tree_kind(lu->container)) { case T_BLOCK: { vcode_reg_t kind_reg = emit_const(vtype_offset(), which); vcode_reg_t str_reg = emit_instance_name(kind_reg); emit_store(str_reg, var); } break; case T_PACKAGE: case T_PACK_BODY: case T_PACK_INST: { LOCAL_TEXT_BUF tb = tb_new(); tb_append(tb, ':'); tb_istr(tb, tree_ident(primary_unit_of(lu->container))); tb_replace(tb, '.', ':'); tb_downcase(tb); vcode_reg_t str_reg = lower_wrap_string(tb_get(tb)); emit_store(str_reg, var); } break; default: should_not_reach_here(); } lower_put_vcode_obj(name, var, lu); } static void lower_pack_body(lower_unit_t *lu, object_t *obj) { tree_t body = tree_from_object(obj); tree_t pack = tree_primary(body); assert(!is_uninstantiated_package(pack)); tree_global_flags_t gflags = tree_global_flags(body); gflags |= tree_global_flags(pack); if (gflags & TREE_GF_INSTANCE_NAME) lower_cache_instance_name(lu, ATTR_INSTANCE_NAME); if (gflags & TREE_GF_PATH_NAME) lower_cache_instance_name(lu, ATTR_PATH_NAME); if (gflags & TREE_GF_EXTERNAL_NAME) { tree_visit_only(pack, lower_external_name_cache, lu, T_EXTERNAL_NAME); tree_visit_only(body, lower_external_name_cache, lu, T_EXTERNAL_NAME); } lower_dependencies(lu, body); const bool has_scope = lower_push_package_scope(pack) || lower_push_package_scope(body); lower_decls(lu, pack); lower_decls(lu, body); if (has_scope) emit_pop_scope(); emit_return(VCODE_INVALID_REG); } static void lower_package(lower_unit_t *lu, object_t *obj) { tree_t pack = tree_from_object(obj); assert(!is_uninstantiated_package(pack)); const tree_global_flags_t gflags = tree_global_flags(pack); if (gflags & TREE_GF_INSTANCE_NAME) lower_cache_instance_name(lu, ATTR_INSTANCE_NAME); if (gflags & TREE_GF_PATH_NAME) lower_cache_instance_name(lu, ATTR_PATH_NAME); if (gflags & TREE_GF_EXTERNAL_NAME) tree_visit_only(pack, lower_external_name_cache, lu, T_EXTERNAL_NAME); lower_dependencies(lu, pack); const bool has_scope = lower_push_package_scope(pack); lower_generics(lu, pack, NULL); lower_decls(lu, pack); if (has_scope) emit_pop_scope(); emit_return(VCODE_INVALID_REG); } vcode_reg_t lower_lvalue(lower_unit_t *lu, tree_t expr) { return lower_expr(lu, expr, EXPR_LVALUE); } vcode_reg_t lower_rvalue(lower_unit_t *lu, tree_t expr) { vcode_reg_t reg = lower_expr(lu, expr, EXPR_RVALUE); if (reg == VCODE_INVALID_REG) return reg; for (;;) { switch (vcode_reg_kind(reg)) { case VCODE_TYPE_SIGNAL: reg = lower_resolved(lu, tree_type(expr), reg); continue; case VCODE_TYPE_POINTER: { type_t type = tree_type(expr); if (lower_have_signal(reg)) { reg = lower_resolved(lu, tree_type(expr), reg); continue; } else if (!type_is_composite(type)) return emit_load_indirect(reg); else return reg; } case VCODE_TYPE_UARRAY: if (lower_have_signal(reg)) return lower_resolved(lu, tree_type(expr), reg); else return reg; default: return reg; } } } vcode_unit_t lower_case_generate_thunk(lower_unit_t *parent, tree_t t) { // TODO: this should really be in eval.c vcode_unit_t context = parent ? parent->vunit : NULL; vcode_unit_t thunk = emit_thunk(NULL, tree_to_object(t), context); lower_unit_t *lu = lower_unit_new(parent->registry, parent, thunk, NULL, NULL); vcode_type_t vbool = vtype_bool(); vcode_type_t vint = vtype_int(INT32_MIN, INT32_MAX); vcode_set_result(vint); if (parent != NULL) { vcode_type_t vcontext = vtype_context(parent->name); emit_param(vcontext, vcontext, ident_new("context")); } tree_t value = tree_value(t); type_t type = tree_type(value); ident_t cmp_func = NULL; if (!type_is_scalar(type)) cmp_func = lower_predef_func_name(tree_type(value), "="); vcode_reg_t value_reg = lower_rvalue(lu, value); if (cmp_func != NULL) value_reg = lower_wrap(lu, type, value_reg); const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(t, i); const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); switch (tree_subkind(a)) { case A_NAMED: { tree_t name = tree_name(a); vcode_reg_t name_reg = lower_rvalue(lu, name); vcode_block_t match_bb = emit_block(); vcode_block_t skip_bb = emit_block(); if (cmp_func != NULL) { if (vcode_reg_kind(name_reg) != VCODE_TYPE_UARRAY) name_reg = lower_wrap(lu, tree_type(name), name_reg); vcode_reg_t context_reg = lower_context_for_call(lu, cmp_func); vcode_reg_t args[] = { context_reg, name_reg, value_reg }; vcode_reg_t eq_reg = emit_fcall(cmp_func, vbool, vbool, args, 3); emit_cond(eq_reg, match_bb, skip_bb); } else { vcode_reg_t eq_reg = emit_cmp(VCODE_CMP_EQ, name_reg, value_reg); emit_cond(eq_reg, match_bb, skip_bb); } vcode_select_block(match_bb); emit_return(emit_const(vint, i)); vcode_select_block(skip_bb); } break; case A_OTHERS: emit_return(emit_const(vint, i)); break; default: fatal_at(tree_loc(a), "sorry, this form of choice is not " "yet supported"); } } } if (!vcode_block_finished()) emit_return(emit_const(vint, -1)); lower_finished(lu); lower_unit_free(lu); return thunk; } static void lower_thunk_body(lower_unit_t *lu, tree_t t) { type_t to_type = tree_type(t), from_type = to_type; vcode_type_t vtype = VCODE_INVALID_TYPE; switch (tree_kind(t)) { case T_FCALL: from_type = tree_type(tree_ref(t)); vtype = lower_func_result_type(type_result(from_type)); break; case T_ATTR_REF: vtype = lower_type(to_type); break; default: vtype = lower_func_result_type(to_type); break; } vcode_set_result(vtype); vcode_reg_t result_reg = lower_rvalue(lu, t); if (type_is_scalar(tree_type(t))) emit_return(emit_cast(vtype, vtype, result_reg)); else if (type_is_array(to_type)) emit_return(lower_coerce_arrays(lu, from_type, to_type, result_reg)); else emit_return(result_reg); } vcode_unit_t lower_global_thunk(unit_registry_t *registry, tree_t t) { tree_t container = tree_container(t); vcode_unit_t thunk = emit_thunk(NULL, tree_to_object(t), NULL); lower_unit_t *lu = lower_unit_new(registry, NULL, thunk, NULL, container); if (tree_kind(t) == T_FCALL && !(tree_flags(t) & TREE_F_LOCALLY_STATIC)) lower_dependencies(lu, container); lower_thunk_body(lu, t); lower_finished(lu); lower_unit_free(lu); if (vcode_unit_has_undefined(thunk)) { vcode_unit_unref(thunk); return NULL; } vcode_close(); return thunk; } vcode_unit_t lower_thunk_in_context(unit_registry_t *registry, tree_t t, lower_unit_t *parent) { tree_t container = primary_unit_of(tree_container(t)); assert(parent->registry == registry); vcode_unit_t context = parent->vunit; vcode_unit_t thunk = emit_thunk(NULL, tree_to_object(t), context); lower_unit_t *lu = lower_unit_new(registry, parent, thunk, NULL, container); vcode_type_t vcontext = vtype_context(parent->name); emit_param(vcontext, vcontext, ident_new("context")); lower_thunk_body(lu, t); lower_finished(lu); lower_unit_free(lu); if (vcode_unit_has_undefined(thunk)) { vcode_unit_unref(thunk); return NULL; } vcode_close(); return thunk; } lower_unit_t *lower_instance(unit_registry_t *ur, lower_unit_t *parent, driver_set_t *ds, cover_data_t *cover, tree_t block) { assert(tree_kind(block) == T_BLOCK); vcode_select_unit(parent ? parent->vunit : NULL); ident_t prefix = parent ? parent->name : lib_name(lib_work()); ident_t label = tree_ident(block); ident_t name = ident_prefix(prefix, label, '.'); vcode_unit_t vu = emit_instance(name, tree_to_object(block), parent ? parent->vunit : NULL); tree_t hier = tree_decl(block, 0); assert(tree_kind(hier) == T_HIER); tree_t unit = tree_ref(hier), primary = NULL; if (is_design_unit(unit)) primary = primary_unit_of(unit); // Do not create coverage scopes for the implicit block from a // component instantiation if (cover != NULL && tree_kind(unit) == T_COMPONENT) cover = NULL; lower_unit_t *lu = lower_unit_new(ur, parent, vu, cover, block); unit_registry_put(ur, lu); if (cover != NULL) { if (parent == NULL) lu->cscope = cover_create_instance(cover, NULL, block, unit); else if (parent != NULL && parent->cover == NULL) { // Collapse this coverage scope with the block for the // component above assert(tree_subkind(tree_decl(parent->container, 0)) == T_COMPONENT); lu->cscope = cover_create_instance(cover, parent->parent->cscope, parent->container, unit); } else if (is_concurrent_block(unit)) lu->cscope = cover_create_instance(cover, parent->cscope, block, unit); else lu->cscope = cover_create_scope(cover, parent->cscope, block, NULL); cover_ignore_from_pragmas(cover, lu->cscope, unit); } tree_global_flags_t gflags = tree_global_flags(unit); if (primary != NULL) gflags |= tree_global_flags(primary); if (gflags & TREE_GF_INSTANCE_NAME) lower_cache_instance_name(lu, ATTR_INSTANCE_NAME); if (gflags & TREE_GF_PATH_NAME) lower_cache_instance_name(lu, ATTR_PATH_NAME); if (gflags & TREE_GF_EXTERNAL_NAME) tree_visit_only(block, lower_external_name_cache, lu, T_EXTERNAL_NAME); lower_dependencies(lu, block); lower_generics(lu, block, primary); lower_ports(lu, ds, block); lower_decls(lu, block); emit_return(VCODE_INVALID_REG); lower_finished(lu); return lu; } lower_unit_t *lower_unit_new(unit_registry_t *ur, lower_unit_t *parent, vcode_unit_t vunit, cover_data_t *cover, tree_t container) { lower_unit_t *new = xcalloc(sizeof(lower_unit_t)); new->parent = parent; new->objects = hash_new(128); new->container = container; new->vunit = vunit; new->cover = cover; new->registry = ur; const vunit_kind_t kind = vcode_unit_kind(vunit); new->name = vcode_unit_name(vunit); new->mode = (kind == VCODE_UNIT_THUNK) ? LOWER_THUNK : LOWER_NORMAL; return new; } void lower_unit_free(lower_unit_t *lu) { assert(lu->finished); hash_free(lu->objects); ACLEAR(lu->free_temps); free(lu); } vcode_unit_t get_vcode(lower_unit_t *lu) { return lu->vunit; } static cover_scope_t *lower_emit_cover_scopes(lower_unit_t *lu, lazy_cscope_t *lcs) { if (lcs == NULL) return lu->cscope; else if (lcs->cscope != NULL) return lcs->cscope; else { cover_scope_t *parent = lower_emit_cover_scopes(lu, lcs->parent); return (lcs->cscope = cover_create_scope(lu->cover, parent, lcs->tree, NULL)); } } cover_scope_t *lower_get_cover_scope(lower_unit_t *lu) { if (lu->cover == NULL) return NULL; else return lower_emit_cover_scopes(lu, lu->lazy_cscope); } //////////////////////////////////////////////////////////////////////////////// typedef enum { UNIT_DEFERRED = 1, UNIT_GENERATED = 2, UNIT_FINALISED = 3, } unit_kind_t; typedef void (*dep_visit_fn_t)(vcode_unit_t, void *); typedef bool (*dep_filter_fn_t)(ident_t, void *); typedef struct _unit_registry { hash_t *map; hset_t *visited; mir_context_t *mir; } unit_registry_t; typedef struct { lower_unit_t *parent; emit_fn_t emit_fn; lower_fn_t fn; object_t *object; cover_data_t *cover; } deferred_unit_t; unit_registry_t *unit_registry_new(mir_context_t *mc) { unit_registry_t *ur = xcalloc(sizeof(unit_registry_t)); ur->map = hash_new(128); ur->mir = mc; return ur; } void unit_registry_free(unit_registry_t *ur) { vcode_close(); const void *key; void *value; for (hash_iter_t it = HASH_BEGIN; hash_iter(ur->map, &it, &key, &value); ) { switch (pointer_tag(value)) { case UNIT_FINALISED: { vcode_unit_t vu = untag_pointer(value, struct _vcode_unit); vcode_unit_unref(vu); } break; case UNIT_GENERATED: { lower_unit_t *lu = untag_pointer(value, lower_unit_t); assert(lu->finished); assert(lu->registry == ur); vcode_unit_unref(lu->vunit); lower_unit_free(lu); } break; case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(value, deferred_unit_t); free(du); } break; default: fatal_trace("invalid tagged pointer %p", value); } } hash_free(ur->map); free(ur); } void unit_registry_put(unit_registry_t *ur, lower_unit_t *lu) { assert(hash_get(ur->map, lu->name) == NULL); hash_put(ur->map, lu->name, tag_pointer(lu, UNIT_GENERATED)); } bool unit_registry_query(unit_registry_t *ur, ident_t ident) { return hash_get(ur->map, ident) != NULL; } void unit_registry_purge(unit_registry_t *ur, ident_t prefix) { if (hash_get(ur->map, prefix) == NULL) return; // Fail fast if root not registered const void *key; void *value; for (hash_iter_t it = HASH_BEGIN; hash_iter(ur->map, &it, &key, &value); ) { if (ident_starts_with((ident_t)key, prefix)) { switch (pointer_tag(value)) { case UNIT_FINALISED: // TODO: unref vcode unit? hash_delete(ur->map, key); break; case UNIT_GENERATED: case UNIT_DEFERRED: fatal_trace("cannot purge this unit kind"); default: fatal_trace("invalid tagged pointer %p", value); } } } } static void walk_dependency_cb(ident_t name, void *ctx) { unit_registry_t *ur = ctx; if (hset_contains(ur->visited, name)) return; hset_insert(ur->visited, name); void *ptr = hash_get(ur->map, name); if (ptr == NULL) return; vcode_unit_t vu = NULL; switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); if (arena_frozen(object_arena(du->object))) return; vu = unit_registry_get(ur, name); } break; case UNIT_FINALISED: vu = untag_pointer(ptr, struct _vcode_unit); break; case UNIT_GENERATED: { lower_unit_t *lu = untag_pointer(ptr, lower_unit_t); vu = lu->vunit; } break; default: fatal_trace("invalid tagged pointer %p", ptr); } if (arena_frozen(object_arena(vcode_unit_object(vu)))) return; vcode_walk_dependencies(vu, walk_dependency_cb, ur); for (vcode_unit_t it = vcode_unit_child(vu); it; it = vcode_unit_next(it)) { assert(vcode_unit_kind(it) != VCODE_UNIT_THUNK); walk_dependency_cb(vcode_unit_name(it), ctx); } } void unit_registry_flush(unit_registry_t *ur, ident_t name) { assert(ur->visited == NULL); ur->visited = hset_new(128); // Make sure all transitive dependencies of this unit which contain // references to non-frozen objects are generated walk_dependency_cb(name, ur); hset_free(ur->visited); ur->visited = NULL; } void unit_registry_finalise(unit_registry_t *ur, lower_unit_t *lu) { assert(pointer_tag(hash_get(ur->map, lu->name)) == UNIT_GENERATED); if (!lu->finished) lower_finished(lu); if (lu->deferred > 0) return; hash_put(ur->map, lu->name, tag_pointer(lu->vunit, UNIT_FINALISED)); lower_unit_free(lu); } vcode_unit_t unit_registry_get(unit_registry_t *ur, ident_t ident) { void *ptr = hash_get(ur->map, ident); if (ptr == NULL) { ident_t it = ident; ident_t lname = ident_walk_selected(&it); ident_t uname = ident_walk_selected(&it); lib_t lib = lib_require(lname); ident_t unit_name = ident_prefix(lname, uname, '.'); tree_t unit = lib_get(lib, unit_name); if (unit == NULL || !is_package(unit)) return NULL; if (tree_kind(unit) == T_PACKAGE && package_needs_body(unit)) { tree_t body = body_of(unit); if (body == NULL) return NULL; unit_registry_defer(ur, unit_name, NULL, emit_package, lower_pack_body, NULL, tree_to_object(body)); } else unit_registry_defer(ur, unit_name, NULL, emit_package, lower_package, NULL, tree_to_object(unit)); if (unit_name != ident) { // We actually wanted a unit inside this package so need to // force code generation (void)unit_registry_get(ur, unit_name); } if ((ptr = hash_get(ur->map, ident)) == NULL) return NULL; } switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); vcode_state_t state; vcode_state_save(&state); vcode_unit_t context = du->parent ? du->parent->vunit : NULL; vcode_unit_t vu = (*du->emit_fn)(ident, du->object, context); tree_t container = tree_from_object(du->object); lower_unit_t *lu = lower_unit_new(ur, du->parent, vu, du->cover, container); hash_put(ur->map, ident, tag_pointer(lu, UNIT_GENERATED)); (*du->fn)(lu, du->object); for (lower_unit_t *p = du->parent; p; p = p->parent) { assert(p->deferred > 0); p->deferred--; } unit_registry_finalise(ur, lu); vcode_state_restore(&state); free(du); return vu; } case UNIT_GENERATED: { lower_unit_t *lu = untag_pointer(ptr, lower_unit_t); return lu->vunit; } case UNIT_FINALISED: return untag_pointer(ptr, struct _vcode_unit); default: fatal_trace("invalid tagged pointer %p", ptr); } } vcode_unit_t unit_registry_get_parent(unit_registry_t *ur, ident_t name) { void *ptr = hash_get(ur->map, name); if (ptr == NULL) return NULL; switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); return du->parent->vunit; } break; case UNIT_FINALISED: { vcode_unit_t vu = untag_pointer(ptr, struct _vcode_unit); return vcode_unit_context(vu); } case UNIT_GENERATED: { lower_unit_t *lu = untag_pointer(ptr, lower_unit_t); return lu->parent->vunit; } break; default: fatal_trace("invalid tagged pointer %p", ptr); } } void unit_registry_defer(unit_registry_t *ur, ident_t ident, lower_unit_t *parent, emit_fn_t emit_fn, lower_fn_t fn, cover_data_t *cover, object_t *object) { void *ptr = hash_get(ur->map, ident); if (ptr == NULL) { deferred_unit_t *du = xcalloc(sizeof(deferred_unit_t)); du->emit_fn = emit_fn; du->fn = fn; du->parent = parent; du->cover = cover; du->object = object; for (lower_unit_t *p = du->parent; p; p = p->parent) p->deferred++; hash_put(ur->map, ident, tag_pointer(du, UNIT_DEFERRED)); } #ifdef DEBUG else if (pointer_tag(ptr) == UNIT_DEFERRED) { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); assert(du->emit_fn == emit_fn); assert(du->fn == fn); assert(du->cover == cover); assert(du->object == object); } #endif } void unit_registry_defer2(unit_registry_t *ur, ident_t name, lower_unit_t *parent, mir_unit_kind_t kind, mir_lower_fn_t fn, object_t *object) { mir_defer(ur->mir, name, parent ? parent->name : NULL, kind, fn, object); } void unit_registry_import(unit_registry_t *ur, vcode_unit_t vu) { mir_unit_t *mu = mir_import(ur->mir, vu); mir_put_unit(ur->mir, mu); } nvc-r1.17.1/src/lower.h000066400000000000000000000063211504111170000146310ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _LOWER_H #define _LOWER_H #include "prim.h" #include "mir/mir-unit.h" typedef int32_t vcode_reg_t; typedef int32_t vcode_type_t; typedef void (*lower_fn_t)(lower_unit_t *, object_t *); typedef vcode_unit_t (*emit_fn_t)(ident_t, object_t *, vcode_unit_t); unit_registry_t *unit_registry_new(mir_context_t *mc); void unit_registry_free(unit_registry_t *ur); vcode_unit_t unit_registry_get(unit_registry_t *ur, ident_t ident); void unit_registry_put(unit_registry_t *ur, lower_unit_t *lu); void unit_registry_defer(unit_registry_t *ur, ident_t ident, lower_unit_t *parent, emit_fn_t emit_fn, lower_fn_t fn, cover_data_t *cover, object_t *object); void unit_registry_defer2(unit_registry_t *ur, ident_t name, lower_unit_t *parent, mir_unit_kind_t kind, mir_lower_fn_t fn, object_t *object); void unit_registry_purge(unit_registry_t *ur, ident_t prefix); bool unit_registry_query(unit_registry_t *ur, ident_t ident); void unit_registry_finalise(unit_registry_t *ur, lower_unit_t *lu); void unit_registry_flush(unit_registry_t *ur, ident_t name); vcode_unit_t unit_registry_get_parent(unit_registry_t *ur, ident_t name); void unit_registry_import(unit_registry_t *ur, vcode_unit_t vu); lower_unit_t *lower_unit_new(unit_registry_t *ur, lower_unit_t *parent, vcode_unit_t vunit, cover_data_t *cover, tree_t container); void lower_unit_free(lower_unit_t *lu); void lower_finished(lower_unit_t *lu); vcode_unit_t get_vcode(lower_unit_t *lu); cover_scope_t *lower_get_cover_scope(lower_unit_t *lu); vcode_reg_t lower_lvalue(lower_unit_t *lu, tree_t expr); vcode_reg_t lower_rvalue(lower_unit_t *lu, tree_t expr); vcode_type_t lower_type(type_t type); vcode_type_t lower_bounds(type_t type); lower_unit_t *lower_instance(unit_registry_t *ur, lower_unit_t *parent, driver_set_t *ds, cover_data_t *cover, tree_t block); void lower_process(lower_unit_t *parent, tree_t proc, driver_set_t *ds); vcode_unit_t lower_global_thunk(unit_registry_t *registry, tree_t t); vcode_unit_t lower_thunk_in_context(unit_registry_t *registry, tree_t t, lower_unit_t *parent); vcode_unit_t lower_case_generate_thunk(lower_unit_t *parent, tree_t t); int lower_search_vcode_obj(void *key, lower_unit_t *scope, int *hops); void lower_put_vcode_obj(void *key, int obj, lower_unit_t *scope); #endif // _LOWER_H nvc-r1.17.1/src/make.c000066400000000000000000000240541504111170000144140ustar00rootroot00000000000000// // Copyright (C) 2013-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "lib.h" #include "option.h" #include "phase.h" #include #include #include #include #include #include #include #include #include typedef enum { MAKE_TREE, MAKE_LIB, MAKE_FINAL_SO } make_product_t; typedef struct ident_list ident_list_t; struct ident_list { ident_list_t *next; ident_t ident; }; typedef struct rule rule_t; typedef enum { RULE_ANALYSE, RULE_ELABORATE } rule_kind_t; struct rule { rule_t *next; rule_kind_t kind; ident_list_t *outputs; ident_list_t *inputs; ident_t source; }; static hash_t *rule_map = NULL; static void make_rule(tree_t t, rule_t **rules); static void ident_list_add(ident_list_t **list, ident_t i) { for (; *list && ident_compare(i, (*list)->ident) < 0; list = &((*list)->next)) ; if (*list && (*list)->ident == i) return; ident_list_t *c = xmalloc(sizeof(ident_list_t)); c->ident = i; c->next = *list; *list = c; } static void ident_list_free(ident_list_t *list) { ident_list_t *it = list; while (it != NULL) { ident_list_t *next = it->next; free(it); it = next; } } static lib_t make_get_lib(ident_t name) { return lib_require(ident_until(name, '.')); } static const char *make_product(tree_t t, make_product_t product) { static char buf[PATH_MAX]; ident_t name = tree_ident(t); lib_t lib = make_get_lib(name); const char *path = lib_path(lib); switch (product) { case MAKE_TREE: checked_sprintf(buf, PATH_MAX, "%s/%s", path, istr(name)); break; case MAKE_FINAL_SO: { ident_t final = ident_runtil(name, '.'); checked_sprintf(buf, PATH_MAX, "%s/_%s.elab.so", path, istr(final)); } break; case MAKE_LIB: checked_sprintf(buf, PATH_MAX, "%s", path); break; } return buf; } static void make_rule_add_input(rule_t *r, const char *input) { ident_list_add(&(r->inputs), ident_new(input)); } static void make_rule_add_output(rule_t *r, const char *output) { ident_list_add(&(r->outputs), ident_new(output)); } static rule_t *make_rule_for_source(rule_t **all, rule_kind_t kind, const char *source) { ident_t ident = ident_new(source); rule_t **ins; for (ins = all; *ins != NULL; ins = &((*ins)->next)) { int cmp = ident_compare((*ins)->source, ident); if (cmp == 0) return *ins; else if (cmp > 0) break; } rule_t *new = xmalloc(sizeof(rule_t)); new->inputs = NULL; new->outputs = NULL; new->kind = kind; new->next = *ins; new->source = ident; *ins = new; return new; } static void make_free_rules(rule_t *list) { while (list != NULL) { rule_t *tmp = list->next; ident_list_free(list->inputs); ident_list_free(list->outputs); free(list); list = tmp; } } static void make_instance_deps(tree_t t, void *context) { rule_t *r = context; if (tree_class(t) == C_ENTITY) { ident_t name = tree_ident2(t); tree_t unit = lib_get(make_get_lib(name), name); if ((unit == NULL) || (tree_kind(unit) != T_ENTITY)) warnf("cannot find entity %s", istr(name)); else make_rule_add_input(r, make_product(unit, MAKE_TREE)); } } static char *make_elab_name(tree_t t) { const char *suffix = strchr(istr(tree_ident(t)), '.'); assert(suffix != NULL); char *name = xstrdup(suffix + 1); for (char *p = name; *p != '\0'; p++) { if (*p == '.') *p = '\0'; else *p = tolower((int)*p); } return name; } static void make_add_inputs_cb(ident_t name, void *__ctx) { rule_t *r = __ctx; tree_t unit = lib_get_qualified(name); if (unit != NULL) make_rule_add_input(r, make_product(unit, MAKE_TREE)); } static void make_dep_rules_cb(ident_t name, void *__ctx) { rule_t **rules = __ctx; tree_t unit = lib_get_qualified(name); if (unit != NULL) make_rule(unit, rules); } static void make_rule(tree_t t, rule_t **rules) { if (hash_get(rule_map, t)) return; lib_t work = make_get_lib(tree_ident(t)); if (work != lib_work()) return; tree_kind_t kind = tree_kind(t); rule_t *r; if (kind == T_ELAB) { char *name = make_elab_name(t); r = make_rule_for_source(rules, RULE_ELABORATE, name); free(name); } else { const char *file = loc_file_str(tree_loc(t)); r = make_rule_for_source(rules, RULE_ANALYSE, file); make_rule_add_input(r, file); if (kind == T_PACK_BODY) make_rule_add_input(r, make_product(tree_primary(t), MAKE_TREE)); } hash_put(rule_map, t, r); switch (kind) { case T_ELAB: make_rule_add_output(r, make_product(t, MAKE_TREE)); make_rule_add_output(r, make_product(t, MAKE_FINAL_SO)); break; case T_PACKAGE: case T_PACK_BODY: case T_ENTITY: case T_ARCH: case T_CONFIGURATION: case T_PACK_INST: case T_CONTEXT: make_rule_add_output(r, make_product(t, MAKE_TREE)); break; default: fatal("cannot get products for %s", tree_kind_str(tree_kind(t))); } tree_walk_deps(t, make_add_inputs_cb, r); if (kind == T_ARCH) tree_visit_only(t, make_instance_deps, r, T_INSTANCE); else if (kind == T_CONTEXT) { // TODO: T_USE should store a reference to the library unit const int nctx = tree_contexts(t); for (int i = 0; i < nctx; i++) { tree_t d = tree_context(t, i); if (tree_kind(d) == T_USE) make_add_inputs_cb(tree_ident(d), r); } } tree_walk_deps(t, make_dep_rules_cb, rules); } static void make_header(tree_t *targets, int count, FILE *out) { fprintf(out, "# Generated by " PACKAGE_STRING "\n\n"); if (!opt_get_int(OPT_MAKE_DEPS_ONLY)) { fprintf(out, "all:"); for (int i = 0; i < count; i++) fprintf(out, " %s", make_product(targets[i], MAKE_TREE)); fprintf(out, "\n\n"); } } static void make_clean(tree_t dummy, FILE *out) { fprintf(out, "clean:\n"); fprintf(out, "\trm -r %s\n", make_product(dummy, MAKE_LIB)); } static void make_print_inputs(rule_t *r, FILE *out) { for (ident_list_t *it = r->inputs; it != NULL; it = it->next) { bool circular = false; for (ident_list_t *o = r->outputs; o != NULL; o = o->next) { if (it->ident == o->ident) circular = true; } if (!circular) fprintf(out, " %s", istr(it->ident)); } } static void make_print_rules(rule_t *rules, FILE *out) { const bool deps_only = opt_get_int(OPT_MAKE_DEPS_ONLY); if (deps_only) { for (rule_t *r = rules; r != NULL; r = r->next) { for (ident_list_t *it = r->outputs; it != NULL; it = it->next) { fprintf(out, "%s:", istr(it->ident)); make_print_inputs(r, out); fprintf(out, "\n\n"); } } } else { for (rule_t *r = rules; r != NULL; r = r->next) { for (ident_list_t *it = r->outputs; it != NULL; it = it->next) fprintf(out, "%s%s", istr(it->ident), (it->next == NULL) ? "" : " "); fprintf(out, ":"); make_print_inputs(r, out); fprintf(out, "\n\tnvc "); switch (r->kind) { case RULE_ANALYSE: fprintf(out, "-a %s\n\n", istr(r->source)); break; case RULE_ELABORATE: fprintf(out, "-e %s\n\n", istr(r->source)); break; } } } } static void make_run(tree_t *targets, int count, FILE *out) { int selected = -1; for (int i = 0; i < count; i++) { if (tree_kind(targets[i]) == T_ELAB) { if (selected != -1) { warnf("multiple elaborarted units found: %s is selected as " "run target", istr(ident_runtil(tree_ident(targets[selected]), '.'))); return; } else { char *name LOCAL = make_elab_name(targets[i]); fprintf(out, "\nrun: all\n"); fprintf(out, "\tnvc -r %s\n", name); fprintf(out, "\nwave: all\n"); fprintf(out, "\tnvc -r -w %s\n", name); fprintf(out, "\n.PHONY: all run wave clean\n"); selected = i; } } } } static void make_add_target(lib_t lib, ident_t name, int kind, void *context) { tree_t **outp = context; *(*outp)++ = lib_get(lib, name); } void make(tree_t *targets, int count, FILE *out) { rule_map = hash_new(256); if (count == 0) { lib_t work = lib_work(); count = lib_index_size(work); targets = xmalloc_array(count, sizeof(tree_t)); tree_t *outp = targets; lib_walk_index(work, make_add_target, &outp); } make_header(targets, count, out); rule_t *rules = NULL; for (int i = 0; i < count; i++) make_rule(targets[i], &rules); make_print_rules(rules, out); make_free_rules(rules); if (!opt_get_int(OPT_MAKE_DEPS_ONLY) && count > 0) { make_clean(targets[0], out); make_run(targets, count, out); } if (!opt_get_int(OPT_MAKE_DEPS_ONLY)) fprintf(out, "\n-include local.mk\n"); else { file_info_t info; if (get_file_info("local.mk", &info)) fprintf(out, "\ninclude local.mk\n"); } free(targets); hash_free(rule_map); rule_map = NULL; } nvc-r1.17.1/src/mask.c000066400000000000000000000205051504111170000144270ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "mask.h" #include #include #include void mask_init(bit_mask_t *m, size_t size) { m->size = size; if (size > 64) m->ptr = xcalloc_array((size + 63) / 64, sizeof(uint64_t)); else m->bits = 0; } void mask_free(bit_mask_t *m) { if (m->size > 64) free(m->ptr); m->bits = 0; m->size = 0; } static inline uint64_t mask_for_range(int low, int high) { if (high < low) return 0; assert(low >= 0 && low < 64); assert(high >= 0 && high < 64); assert(low <= high); uint64_t mask = ~UINT64_C(0); if (high < 63) mask &= (UINT64_C(1) << (high + 1)) - 1; if (low > 0) mask &= ~((UINT64_C(1) << low) - 1); assert(__builtin_popcountll(mask) == high - low + 1); return mask; } void mask_clear_range(bit_mask_t *m, size_t start, size_t count) { if (m->size <= 64) { m->bits &= ~mask_for_range(start, start + count - 1); return; } if (count > 0 && start % 64 != 0) { // Pre-loop: clear range of bits in first 64-bit word const size_t low = start % 64; const size_t high = MIN(low + count - 1, 63); const size_t nbits = high - low + 1; m->ptr[start / 64] &= ~mask_for_range(low, high); start += nbits; count -= nbits; } if (count > 0) { // Main loop: clear complete 64-bit words for (; count >= 64; count -= 64, start += 64) m->ptr[start / 64] = 0; } if (count > 0) { // Post-loop: clear range of bits in last 64-bit word assert(start % 64 == 0); const int high = MIN(count - 1, 63); m->ptr[start / 64] &= ~mask_for_range(0, high); assert(count == high + 1); } } void mask_set_range(bit_mask_t *m, size_t start, size_t count) { if (m->size <= 64) { m->bits |= mask_for_range(start, start + count - 1); return; } if (count > 0 && start % 64 != 0) { // Pre-loop: set range of bits in first 64-bit word const size_t low = start % 64; const size_t high = MIN(low + count - 1, 63); const size_t nbits = high - low + 1; m->ptr[start / 64] |= mask_for_range(low, high); start += nbits; count -= nbits; } if (count > 0) { // Main loop: set complete 64-bit words for (; count >= 64; count -= 64, start += 64) m->ptr[start / 64] = ~UINT64_C(0); } if (count > 0) { // Post-loop: set range of bits in last 64-bit word assert(start % 64 == 0); const int high = MIN(count - 1, 63); m->ptr[start / 64] |= mask_for_range(0, high); assert(count == high + 1); } } bool mask_test_range(bit_mask_t *m, size_t start, size_t count) { if (m->size <= 64) return !!(m->bits & mask_for_range(start, start + count - 1)); if (count > 0 && start % 64 != 0) { // Pre-loop: test range of bits in first 64-bit word const size_t low = start % 64; const size_t high = MIN(low + count - 1, 63); const size_t nbits = high - low + 1; if (m->ptr[start / 64] & mask_for_range(low, high)) return true; start += nbits; count -= nbits; } if (count > 0) { // Main loop: test complete 64-bit words for (; count >= 64; count -= 64, start += 64) { if (m->ptr[start / 64]) return true; } } if (count > 0) { // Post-loop: test range of bits in last 64-bit word assert(start % 64 == 0); const int high = MIN(count - 1, 63); if (m->ptr[start / 64] & mask_for_range(0, high)) return true; assert(count == high + 1); } return false; } size_t mask_popcount(bit_mask_t *m) { if (m->size > 64) { size_t sum = 0; for (ssize_t i = 0; i < (m->size + 63) / 64; i++) sum += __builtin_popcountll(m->ptr[i]); return sum; } else return __builtin_popcountll(m->bits); } void mask_setall(bit_mask_t *m) { mask_set_range(m, 0, m->size); } void mask_clearall(bit_mask_t *m) { mask_clear_range(m, 0, m->size); } bool mask_test_and_set(bit_mask_t *m, size_t bit) { if (mask_test(m, bit)) return true; mask_set(m, bit); return false; } ssize_t mask_scan_backwards(bit_mask_t *m, size_t bit) { if (m->size <= 64) { uint64_t word0 = m->bits & mask_for_range(0, bit); return word0 == 0 ? -1 : 63 - __builtin_clzll(word0); } uint64_t word0 = m->ptr[bit / 64]; word0 &= mask_for_range(0, bit % 64); if (word0 != 0) return (bit | 63) - __builtin_clzll(word0); ssize_t i = bit - (bit % 64 + 1); for (; i > 0 && m->ptr[i / 64] == 0; i -= 64); if (i > 0) return (i | 63) - __builtin_clzll(m->ptr[i / 64]); return -1; } size_t mask_count_clear(bit_mask_t *m, size_t bit) { assert(bit < m->size); if (m->size <= 64) { const int fs = __builtin_ffsll(m->bits & mask_for_range(bit, 63)); return fs > 0 ? fs - 1 - bit : m->size - bit; } size_t count = 0; const int modbits = bit % 64, maxbits = MIN(64, m->size - (bit & ~63)); if (modbits > 0) { uint64_t word0 = m->ptr[bit / 64]; word0 &= mask_for_range(modbits, maxbits - 1); const int fs = __builtin_ffsll(word0); if (fs > 0) return fs - 1 - modbits; count = maxbits - modbits; bit = bit + maxbits - modbits; } if (bit == m->size) return count; assert(bit % 64 == 0); for (; bit + 64 < m->size && m->ptr[bit / 64] == 0; bit += 64, count += 64); const int fs = __builtin_ffsll(m->ptr[bit / 64]); if (fs > 0) return count + fs - 1; return count + m->size - bit; } void mask_subtract(bit_mask_t *m, const bit_mask_t *m2) { assert(m->size == m2->size); if (m->size > 64) { for (ssize_t i = 0; i < (m->size + 63) / 64; i++) m->ptr[i] &= ~m2->ptr[i]; } else m->bits &= ~m2->bits; } void mask_union(bit_mask_t *m, const bit_mask_t *m2) { assert(m->size == m2->size); if (m->size > 64) { for (ssize_t i = 0; i < (m->size + 63) / 64; i++) m->ptr[i] |= m2->ptr[i]; } else m->bits |= m2->bits; } void mask_intersect(bit_mask_t *m, const bit_mask_t *m2) { assert(m->size == m2->size); if (m->size > 64) { for (ssize_t i = 0; i < (m->size + 63) / 64; i++) m->ptr[i] &= m2->ptr[i]; } else m->bits &= m2->bits; } void mask_copy(bit_mask_t *m, const bit_mask_t *m2) { assert(m->size == m2->size); if (m->size > 64) { for (ssize_t i = 0; i < (m->size + 63) / 64; i++) m->ptr[i] = m2->ptr[i]; } else m->bits = m2->bits; } bool mask_eq(const bit_mask_t *m1, const bit_mask_t *m2) { assert(m1->size == m2->size); if (m1->size > 64) { for (ssize_t i = 0; i < (m1->size + 63) / 64; i++) { if (m1->ptr[i] != m2->ptr[i]) return false; } return true; } else return m1->bits == m2->bits; } bool mask_iter(const bit_mask_t *m, size_t *bit) { if (*bit + 1 < 0 || *bit + 1 >= m->size) return false; else if (m->size > 64) { size_t word = (*bit + 1) / 64; if ((*bit + 1) % 64 > 0) { const uint64_t remain = m->ptr[word] & ~mask_for_range(0, *bit % 64); const int fs = __builtin_ffsll(remain); if (fs > 0) { *bit = word*64 + fs - 1; return true; } word++; } for (; word < (m->size + 63) / 64; word++) { const int fs = __builtin_ffsll(m->ptr[word]); if (fs > 0) { *bit = word*64 + fs - 1; return true; } } return false; } else { const uint64_t remain = m->bits & ~mask_for_range(0, *bit); const int fs = __builtin_ffsll(remain); *bit = fs - 1; return fs > 0; } } nvc-r1.17.1/src/mask.h000066400000000000000000000063521504111170000144400ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _MASK_H #define _MASK_H #include "prim.h" #include #include #include typedef struct _bit_mask { size_t size; union { uint64_t bits; uint64_t *ptr; }; } bit_mask_t; #define mask_test(m, bit) ({ \ const size_t _bit = (bit); \ assert(_bit < (m)->size); \ (m)->size > 64 \ ? !!((m)->ptr[_bit / 64] & (UINT64_C(1) << (_bit % 64))) \ : !!((m)->bits & (UINT64_C(1) << (_bit % 64))); \ }) #define mask_set(m, bit) do { \ const size_t _bit = (bit); \ assert(_bit < (m)->size); \ if ((m)->size > 64) \ (m)->ptr[_bit / 64] |= (UINT64_C(1) << (_bit % 64)); \ else \ (m)->bits |= UINT64_C(1) << (_bit % 64); \ } while (0) #define mask_clear(m, bit) do { \ const size_t _bit = (bit); \ assert(_bit < (m)->size); \ if ((m)->size > 64) \ (m)->ptr[_bit / 64] &= ~(UINT64_C(1) << (_bit % 64)); \ else \ (m)->bits &= ~(UINT64_C(1) << (_bit % 64)); \ } while (0) #define LOCAL_BIT_MASK __attribute__((cleanup(mask_free))) bit_mask_t void mask_init(bit_mask_t *m, size_t size); void mask_free(bit_mask_t *m); void mask_clear_range(bit_mask_t *m, size_t start, size_t count); void mask_set_range(bit_mask_t *m, size_t start, size_t count); bool mask_test_range(bit_mask_t *m, size_t start, size_t count); size_t mask_popcount(bit_mask_t *m); void mask_setall(bit_mask_t *m); void mask_clearall(bit_mask_t *m); bool mask_test_and_set(bit_mask_t *m, size_t bit); ssize_t mask_scan_backwards(bit_mask_t *m, size_t bit); size_t mask_count_clear(bit_mask_t *m, size_t bit); void mask_subtract(bit_mask_t *m, const bit_mask_t *m2); void mask_union(bit_mask_t *m, const bit_mask_t *m2); void mask_intersect(bit_mask_t *m, const bit_mask_t *m2); void mask_copy(bit_mask_t *m, const bit_mask_t *m2); bool mask_eq(const bit_mask_t *m1, const bit_mask_t *m2); bool mask_iter(const bit_mask_t *m, size_t *bit); #endif // _MASK_H nvc-r1.17.1/src/mir/000077500000000000000000000000001504111170000141155ustar00rootroot00000000000000nvc-r1.17.1/src/mir/Makemodule.am000066400000000000000000000003711504111170000165200ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/mir/mir-unit.h \ src/mir/mir-unit.c \ src/mir/mir-node.h \ src/mir/mir-node.c \ src/mir/mir-type.c \ src/mir/mir-dump.c \ src/mir/mir-optim.c \ src/mir/mir-vcode.c \ src/mir/mir-priv.h \ src/mir/mir-structs.h nvc-r1.17.1/src/mir/mir-dump.c000066400000000000000000001704271504111170000160260ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-priv.h" #include "mir/mir-structs.h" #include "mir/mir-unit.h" #include "thread.h" #include "tree.h" #include "vlog/vlog-node.h" #include #include #include #include #include // LCOV_EXCL_START ///////////////////////////////////////////////////////////// const char *mir_op_string(mir_op_t op) { static const char *map[] = { [MIR_OP_ADD] = "add", [MIR_OP_RETURN] = "return", [MIR_OP_CONST] = "const", [MIR_OP_COMMENT] = "comment", [MIR_OP_STORE] = "store", [MIR_OP_LOAD] = "load", [MIR_OP_CONST_REAL] = "const real", [MIR_OP_JUMP] = "jump", [MIR_OP_COND] = "cond", [MIR_OP_CMP] = "cmp", [MIR_OP_PHI] = "phi", [MIR_OP_AND] = "and", [MIR_OP_OR] = "or", [MIR_OP_XOR] = "xor", [MIR_OP_CONSUME] = "consume", [MIR_OP_SUB] = "sub", [MIR_OP_MUL] = "mul", [MIR_OP_DIV] = "div", [MIR_OP_MOD] = "mod", [MIR_OP_EXP] = "exp", [MIR_OP_FCALL] = "fcall", [MIR_OP_PCALL] = "pcall", [MIR_OP_RESUME] = "resume", [MIR_OP_WRAP] = "wrap", [MIR_OP_UNWRAP] = "unwrap", [MIR_OP_NOT] = "not", [MIR_OP_RESOLVED] = "resolved", [MIR_OP_LAST_VALUE] = "last value", [MIR_OP_LOCUS] = "debug locus", [MIR_OP_INIT_SIGNAL] = "init signal", [MIR_OP_IMPLICIT_SIGNAL] = "implicit signal", [MIR_OP_SELECT] = "select", [MIR_OP_REM] = "rem", [MIR_OP_WAIT] = "wait", [MIR_OP_LINK_PACKAGE] = "link package", [MIR_OP_PACKAGE_INIT] = "package init", [MIR_OP_PROTECTED_INIT] = "protected init", [MIR_OP_ASSERT] = "assert", [MIR_OP_CONTEXT_UPREF] = "context upref", [MIR_OP_UARRAY_LEN] = "uarray len", [MIR_OP_UARRAY_LEFT] = "uarray left", [MIR_OP_UARRAY_RIGHT] = "uarray right", [MIR_OP_UARRAY_DIR] = "uarray dir", [MIR_OP_TRAP_ADD] = "trap add", [MIR_OP_TRAP_SUB] = "trap sub", [MIR_OP_TRAP_MUL] = "trap mul", [MIR_OP_TRAP_EXP] = "trap exp", [MIR_OP_CONST_ARRAY] = "const array", [MIR_OP_CONST_REP] = "const rep", [MIR_OP_CONST_RECORD] = "const record", [MIR_OP_CONST_VEC] = "const vec", [MIR_OP_ARRAY_REF] = "array ref", [MIR_OP_RECORD_REF] = "record ref", [MIR_OP_ADDRESS_OF] = "address of", [MIR_OP_VAR_UPREF] = "var upref", [MIR_OP_SCHED_WAVEFORM] = "sched waveform", [MIR_OP_DRIVE_SIGNAL] = "drive signal", [MIR_OP_EVENT] = "event", [MIR_OP_ACTIVE] = "active", [MIR_OP_CAST] = "cast", [MIR_OP_NEG] = "neg", [MIR_OP_TRAP_NEG] = "trap neg", [MIR_OP_ABS] = "abs", [MIR_OP_COPY] = "copy", [MIR_OP_REPORT] = "report", [MIR_OP_RANGE_CHECK] = "range check", [MIR_OP_INDEX_CHECK] = "index check", [MIR_OP_SCHED_EVENT] = "sched event", [MIR_OP_CLEAR_EVENT] = "clear event", [MIR_OP_ALLOC] = "alloc", [MIR_OP_RANGE_LENGTH] = "range length", [MIR_OP_RANGE_NULL] = "range null", [MIR_OP_SET] = "set", [MIR_OP_NULL] = "null", [MIR_OP_ALL] = "all", [MIR_OP_NEW] = "new", [MIR_OP_NULL_CHECK] = "null check", [MIR_OP_LENGTH_CHECK] = "length check", [MIR_OP_ZERO_CHECK] = "zero check", [MIR_OP_EXPONENT_CHECK] = "exponent check", [MIR_OP_ALIAS_SIGNAL] = "alias signal", [MIR_OP_MAP_SIGNAL] = "map signal", [MIR_OP_MAP_CONST] = "map const", [MIR_OP_MAP_IMPLICIT] = "map implicit", [MIR_OP_CASE] = "case", [MIR_OP_BIND_FOREIGN] = "bind foreign", [MIR_OP_BIND_EXTERNAL] = "bind external", [MIR_OP_UNREACHABLE] = "unreachable", [MIR_OP_RESOLUTION_WRAPPER] = "resolution wrapper", [MIR_OP_CLOSURE] = "closure", [MIR_OP_RESOLVE_SIGNAL] = "resolve signal", [MIR_OP_TRANSFER_SIGNAL] = "transfer signal", [MIR_OP_FILE_OPEN] = "file open", [MIR_OP_FILE_READ] = "file read", [MIR_OP_FILE_WRITE] = "file write", [MIR_OP_PORT_CONVERSION] = "port conversion", [MIR_OP_CONVERT_IN] = "convert in", [MIR_OP_CONVERT_OUT] = "convert out", [MIR_OP_PUT_CONVERSION] = "put conversion", [MIR_OP_LINK_VAR] = "link var", [MIR_OP_DRIVING_VALUE] = "driving value", [MIR_OP_FORCE] = "force", [MIR_OP_RELEASE] = "release", [MIR_OP_DISCONNECT] = "disconnect", [MIR_OP_PROCESS_INIT] = "process init", [MIR_OP_COVER_STMT] = "cover stmt", [MIR_OP_COVER_BRANCH] = "cover branch", [MIR_OP_COVER_TOGGLE] = "cover toggle", [MIR_OP_COVER_EXPR] = "cover expr", [MIR_OP_COVER_STATE] = "cover state", [MIR_OP_RECORD_SCOPE] = "record scope", [MIR_OP_ARRAY_SCOPE] = "array scope", [MIR_OP_PACKAGE_SCOPE] = "package scope", [MIR_OP_POP_SCOPE] = "pop scope", [MIR_OP_ADD_TRIGGER] = "add trigger", [MIR_OP_FUNCTION_TRIGGER] = "function trigger", [MIR_OP_OR_TRIGGER] = "or trigger", [MIR_OP_CMP_TRIGGER] = "cmp trigger", [MIR_OP_INSTANCE_NAME] = "instance name", [MIR_OP_LAST_EVENT] = "last event", [MIR_OP_LAST_ACTIVE] = "last active", [MIR_OP_DRIVING] = "driving", [MIR_OP_ENTER_STATE] = "enter state", [MIR_OP_DEPOSIT_SIGNAL] = "deposit signal", [MIR_OP_SYSCALL] = "syscall", [MIR_OP_REFLECT_VALUE] = "reflect value", [MIR_OP_REFLECT_SUBTYPE] = "reflect subtype", [MIR_OP_DEBUG_OUT] = "debug out", [MIR_OP_PACK] = "pack", [MIR_OP_UNPACK] = "unpack", [MIR_OP_BINARY] = "vector binary", [MIR_OP_UNARY] = "vector unary", [MIR_OP_DIR_CHECK] = "dir check", }; return map[op]; } static void mir_dump_tab(int col, int to_col) { if (col >= to_col) printf(" "); else printf("%*.s", to_col - col, ""); } static void mir_dump_comment(int col) { mir_dump_tab(col, 40); color_printf("$cyan$// "); } static int mir_pretty_print_int(int64_t n) { if (n == INT64_MAX) return printf("2^63-1"); else if (n == INT64_MIN) return printf("-2^63"); else if (n == INT32_MAX) return printf("2^31-1"); else if (n == INT32_MIN) return printf("-2^31"); else return printf("%"PRIi64, n); } static int mir_dump_value(mir_unit_t *mu, mir_value_t value, const mir_annotate_t *cb, void *ctx) { int col = 0; switch (value.tag) { case MIR_TAG_NULL: col += color_printf("$red$null$$"); break; case MIR_TAG_PARAM: col += color_printf("$magenta$%s$$", istr(mir_param_data(mu, value)->name)); break; case MIR_TAG_VAR: col += color_printf("$magenta$%s$$", istr(mir_var_data(mu, value)->name)); break; case MIR_TAG_NODE: col += color_printf("$green$%%%u$$", value.id); break; case MIR_TAG_BLOCK: col += color_printf("$yellow$%u$$", value.id); break; case MIR_TAG_CONST: { int64_t intg = 0; mir_get_const(mu, value, &intg); col += color_printf("$green$#%"PRIi64"$$", intg); } break; case MIR_TAG_LINKAGE: col += color_printf("$magenta$%s$$", istr(mu->linkage.items[value.id])); break; case MIR_TAG_ENUM: col += color_printf("%u", value.id); break; default: col += color_printf("$red$invalid$$"); break; } if (cb->value != NULL) col += (*cb->value)(mu, value, ctx); return col; } static void mir_dump_one_type(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case _MIR_INVALID_TYPE: break; case MIR_TYPE_INT: if (td->u.intg.low != td->u.intg.high) { mir_pretty_print_int(td->u.intg.low); printf(".."); mir_pretty_print_int(td->u.intg.high); } else mir_pretty_print_int(td->u.intg.low); break; case MIR_TYPE_REAL: if (td->u.real.low == -DBL_MAX && td->u.real.high == DBL_MAX) printf("%%"); else if (td->u.real.low == td->u.real.high) printf("%f", td->u.real.low); else printf("%f..%f", td->u.real.low, td->u.real.high); break; case MIR_TYPE_OFFSET: printf("#"); break; case MIR_TYPE_LOCUS: printf("D<>"); break; case MIR_TYPE_POINTER: printf("@<"); mir_dump_one_type(mu, td->u.pointer); printf(">"); break; case MIR_TYPE_UARRAY: { printf("["); for (int i = 0; i < td->u.uarray.dims; i++) printf("%s*", i > 0 ? ", " : ""); printf("] : "); mir_dump_one_type(mu, td->u.uarray.elem); } break; case MIR_TYPE_SIGNAL: printf("$<"); mir_dump_one_type(mu, td->u.signal.base); printf(">"); break; case MIR_TYPE_ACCESS: printf("A<"); mir_dump_one_type(mu, td->u.access.to); printf(">"); break; case MIR_TYPE_CONTEXT: printf("P<%s>", istr(td->u.context)); break; case MIR_TYPE_CARRAY: printf("[%u] : ", td->u.carray.size); mir_dump_one_type(mu, td->u.carray.elem); break; case MIR_TYPE_RECORD: printf("%s{}", istr(td->u.record.name)); break; case MIR_TYPE_CLOSURE: printf("C<"); mir_dump_one_type(mu, td->u.closure.rtype); printf(">"); break; case MIR_TYPE_RESOLUTION: printf("R<"); mir_dump_one_type(mu, td->u.base); printf(">"); break; case MIR_TYPE_FILE: printf("F<"); mir_dump_one_type(mu, td->u.base); printf(">"); break; case MIR_TYPE_CONVERSION: printf("X<>"); break; case MIR_TYPE_TRIGGER: printf("T<>"); break; case MIR_TYPE_OPAQUE: printf("?"); break; case MIR_TYPE_VEC2: printf("Vec2%s<%u>", td->u.vec.issigned ? "S" : "", td->u.vec.size); break; case MIR_TYPE_VEC4: printf("Vec4%s<%u>", td->u.vec.issigned ? "S" : "", td->u.vec.size); break; } } static void mir_dump_type(mir_unit_t *mu, int col, mir_type_t type) { if (mir_is_null(type)) return; mir_dump_comment(col); mir_dump_one_type(mu, type); } static void mir_dump_stamp(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp) { if (mir_is_null(type) || mir_is_null(stamp) || mir_is_top(mu, type, stamp)) return; printf(" => "); for (;;) { const stamp_data_t *sd = mir_stamp_data(mu, stamp); switch (sd->kind) { case _MIR_INVALID_STAMP: return; case MIR_STAMP_INT: if (sd->u.intg.low != sd->u.intg.high) { mir_pretty_print_int(sd->u.intg.low); printf(".."); mir_pretty_print_int(sd->u.intg.high); } else mir_pretty_print_int(sd->u.intg.low); return; case MIR_STAMP_REAL: if (sd->u.real.low == -DBL_MAX && sd->u.real.high == DBL_MAX) printf("%%"); else if (sd->u.real.low == sd->u.real.high) printf("%f", sd->u.real.low); else printf("%f..%f", sd->u.real.low, sd->u.real.high); return; case MIR_STAMP_POINTER: { static const char *map[] = { "", "const", "stack", "local", "global", "" }; printf("%s", map[sd->u.pointer.memory]); if (mir_is_null(sd->u.pointer.elem)) return; printf(", "); stamp = sd->u.pointer.elem; } break; } } } static int mir_dump_const_array(mir_unit_t *mu, mir_value_t value, const mir_annotate_t *cb, void *ctx) { node_data_t *n = mir_node_data(mu, value); bool is_string = true; const type_data_t *td = mir_type_data(mu, mir_get_elem(mu, n->type)); if (td->class != MIR_TYPE_INT || td->u.intg.low < 0 || td->u.intg.high > 255) is_string = false; mir_stamp_t elem = mir_stamp_elem(mu, n->stamp); if (!mir_is_null(elem)) { const stamp_data_t *sd = mir_stamp_data(mu, elem); if (sd->kind != MIR_STAMP_INT || !isprint(sd->u.intg.low) || !isprint(sd->u.intg.high)) is_string = false; } int col = printf(" := const "); if (is_string) { col += color_printf("$green$\""); for (int i = 0; i < n->nargs; i++) { mir_value_t elt = mir_get_arg(mu, value, i); int64_t cval; if (mir_get_const(mu, elt, &cval)) col += printf("%c", (char)cval); else should_not_reach_here(); } col += color_printf("\"$$"); return col; } col += printf("["); for (int i = 0; i < n->nargs; i++) { mir_value_t elt = mir_get_arg(mu, value, i); if (i > 0) col += printf(","); col += mir_dump_value(mu, elt, cb, ctx); } col += printf("]"); return col; } static int mir_dump_arg(mir_unit_t *mu, mir_value_t node, int nth, const mir_annotate_t *cb, void *ctx) { mir_value_t arg = mir_get_arg(mu, node, nth); return mir_dump_value(mu, arg, cb, ctx); } static int mir_dump_strength(mir_unit_t *mu, mir_value_t value) { assert(value.tag == MIR_TAG_ENUM); static const char *names[] = { "highz", "small", "medium", "weak", "large", "pull", "strong", "supply" }; return color_printf("$green$(%s1,%s0)$$", names[STRENGTH1(value.id)], names[STRENGTH0(value.id)]); } static int mir_dump_vector_op(mir_unit_t *mu, mir_value_t value) { assert(value.tag == MIR_TAG_ENUM); switch (value.id) { case MIR_VEC_BIT_AND: return printf(" & "); case MIR_VEC_BIT_OR: return printf(" | "); case MIR_VEC_BIT_XOR: return printf(" ^ "); case MIR_VEC_LOG_AND: return printf(" && "); case MIR_VEC_LOG_OR: return printf(" || "); case MIR_VEC_BIT_NOT: return printf(" ~ "); case MIR_VEC_LOG_NOT: return printf(" ! "); case MIR_VEC_LT: return printf(" < "); case MIR_VEC_LEQ: return printf(" <= "); case MIR_VEC_GT: return printf(" > "); case MIR_VEC_GEQ: return printf(" >= "); case MIR_VEC_LOG_EQ: return printf(" == "); case MIR_VEC_LOG_NEQ: return printf(" != "); case MIR_VEC_CASE_EQ: return printf(" === "); case MIR_VEC_CASE_NEQ: return printf(" !== "); case MIR_VEC_ADD: return printf(" + "); case MIR_VEC_SUB: return printf(" - "); case MIR_VEC_MUL: return printf(" * "); case MIR_VEC_SLL: return printf(" << "); case MIR_VEC_SRL: return printf(" >> "); default: return printf(" <%d> ", value.id); } } static int mir_dump_locus(object_t *obj) { int col = color_printf("$magenta$"); tree_t t = tree_from_object(obj); if (t != NULL) col += printf("%s@", tree_kind_str(tree_kind(t))); vlog_node_t v = vlog_from_object(obj); if (v != NULL) col += printf("%s@", vlog_kind_str(vlog_kind(v))); col += color_printf("%p$$", obj); return col; } static int mir_dump_dim(mir_unit_t *mu, mir_value_t node, int nth, const mir_annotate_t *cb, void *ctx) { mir_value_t left = mir_get_arg(mu, node, nth + 0); mir_value_t right = mir_get_arg(mu, node, nth + 1); mir_value_t dir = mir_get_arg(mu, node, nth + 2); int col = mir_dump_value(mu, left, cb, ctx); int64_t cdir; if (mir_get_const(mu, dir, &cdir) && (cdir == RANGE_TO || cdir == RANGE_DOWNTO)) { col += printf(" %s ", cdir == RANGE_TO ? "to" : "downto"); col += mir_dump_value(mu, right, cb, ctx); } else { col += printf(" "); col += mir_dump_value(mu, right, cb, ctx); col += printf(" "); col += mir_dump_value(mu, dir, cb, ctx); } return col; } static void mir_visit_records(mir_unit_t *mu, mir_type_t type, ihash_t **seen) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_RECORD: { if (*seen == NULL) { printf("Types\n"); *seen = ihash_new(16); } else if (ihash_get(*seen, type.bits) != NULL) break; int col = 0; col += color_printf(" $magenta$%s$$", istr(td->u.record.name)); mir_dump_tab(col, 40); color_printf("$cyan${"); for (int i = 0; i < td->u.record.count; i++) { if (i > 0) printf(", "); mir_dump_one_type(mu, td->u.record.fields[i]); } color_printf("}$$\n"); ihash_put(*seen, type.bits, (void *)-1); } break; case MIR_TYPE_POINTER: mir_visit_records(mu, td->u.pointer, seen); break; case MIR_TYPE_ACCESS: mir_visit_records(mu, td->u.access.to, seen); break; default: break; } } static void mir_dump_records(mir_unit_t *mu) { ihash_t *seen = NULL; for (int i = 0; i < mu->params.count; i++) mir_visit_records(mu, mu->params.items[i].type, &seen); for (int i = 0; i < mu->vars.count; i++) mir_visit_records(mu, mu->vars.items[i].type, &seen); for (int i = 0; i < mu->num_nodes; i++) { if (!mir_is_null(mu->nodes[i].type)) mir_visit_records(mu, mu->nodes[i].type, &seen); } if (seen != NULL) ihash_free(seen); } void mir_annotate(mir_unit_t *mu, const mir_annotate_t *cb, void *ctx) { static nvc_lock_t lock = 0; SCOPED_LOCK(lock); printf("\n"); if (mu->name != NULL) color_printf("Name $cyan$%s$$\n", istr(mu->name)); color_printf("Kind $cyan$"); switch (mu->kind) { case MIR_UNIT_PROCESS: printf("process"); break; case MIR_UNIT_FUNCTION: printf("function"); break; case MIR_UNIT_INSTANCE: printf("instance"); break; case MIR_UNIT_PROCEDURE: printf("procedure"); break; case MIR_UNIT_PACKAGE: printf("package"); break; case MIR_UNIT_THUNK: printf("thunk"); break; case MIR_UNIT_PROPERTY: printf("property"); break; case MIR_UNIT_PROTECTED: printf("protected"); break; } color_printf("$$\n"); if (mu->parent != NULL) color_printf("Context $cyan$%s$$\n", istr(mu->parent->name)); mir_dump_records(mu); if (mu->vars.count > 0) { printf("Variables\n"); for (int i = 0; i < mu->vars.count; i++) { const var_data_t *vd = &(mu->vars.items[i]); int col = printf(" "); col += color_printf("$magenta$%s$$", istr(vd->name)); mir_dump_type(mu, col, vd->type); mir_dump_stamp(mu, vd->type, vd->stamp); if (vd->flags & MIR_VAR_SIGNAL) printf(", signal"); if (vd->flags & MIR_VAR_HEAP) printf(", heap"); if (vd->flags & MIR_VAR_CONST) printf(", constant"); if (vd->flags & MIR_VAR_TEMP) printf(", temp"); color_printf("$$\n"); } } if (!mir_is_null(mu->result)) { color_printf("Result $cyan$"); mir_dump_one_type(mu, mu->result); color_printf("$$\n"); } if (mu->params.count > 0) { printf("Parameters\n"); for (int i = 0; i < mu->params.count; i++) { const param_data_t *pd = &(mu->params.items[i]); int col = color_printf(" $magenta$%s$$", istr(pd->name)); mir_dump_type(mu, col, pd->type); mir_dump_stamp(mu, pd->type, pd->stamp); color_printf("$$\n"); } } if (mu->linkage.count > 0) { printf("Linkage\n"); for (int i = 0; i < mu->linkage.count; i++) color_printf(" $magenta$%s$$\n", istr(mu->linkage.items[i])); } if (mu->blocks.count > 0) printf("Begin\n"); for (int i = 0; i < mu->blocks.count; i++) { const block_data_t *b = &(mu->blocks.items[i]); for (int j = 0; j < b->num_nodes; j++) { int col = 0; if (j == 0) { col += color_printf(" $yellow$%2d:$$ ", i); if (cb->begin_block != NULL) { mir_block_t b = { .tag = MIR_TAG_BLOCK, .id = i }; col += (*cb->begin_block)(mu, b, col, ctx); } } else col += printf(" "); const node_data_t *n = &(mu->nodes[b->nodes[j]]); const mir_value_t result = { .tag = MIR_TAG_NODE, .id = b->nodes[j] }; switch (n->op) { case MIR_OP_ADD: case MIR_OP_SUB: case MIR_OP_MUL: case MIR_OP_DIV: case MIR_OP_AND: case MIR_OP_OR: case MIR_OP_XOR: case MIR_OP_MOD: case MIR_OP_REM: case MIR_OP_EXP: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); switch (n->op) { case MIR_OP_ADD: col += printf(" + "); break; case MIR_OP_SUB: col += printf(" - "); break; case MIR_OP_MUL: col += printf(" * "); break; case MIR_OP_DIV: col += printf(" / "); break; case MIR_OP_AND: col += printf(" && "); break; case MIR_OP_OR: col += printf(" || "); break; case MIR_OP_XOR: col += printf(" ^ "); break; case MIR_OP_MOD: col += printf(" %% "); break; case MIR_OP_REM: col += printf(" %% "); break; case MIR_OP_EXP: col += printf(" ** "); break; default: break; } col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_TRAP_ADD: case MIR_OP_TRAP_SUB: case MIR_OP_TRAP_MUL: case MIR_OP_TRAP_EXP: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); switch (n->op) { case MIR_OP_TRAP_ADD: col += printf(" + "); break; case MIR_OP_TRAP_SUB: col += printf(" - "); break; case MIR_OP_TRAP_MUL: col += printf(" * "); break; case MIR_OP_TRAP_EXP: col += printf(" ** "); break; default: break; } col += mir_dump_value(mu, n->args[1], cb, ctx); col += printf(" locus "); col += mir_dump_value(mu, n->args[2], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_NOT: case MIR_OP_ALLOC: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_RETURN: { printf("%s", mir_op_string(n->op)); if (n->nargs > 0) { printf(" "); mir_dump_value(mu, n->args[0], cb, ctx); } } break; case MIR_OP_CONST: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s %"PRIi64" ", mir_op_string(n->op), n->iconst); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONST_REAL: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := const %g ", n->dconst); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONST_VEC: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := const 0x%"PRIx64", 0x%"PRIx64 , n->bits[0], n->bits[1]); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_STORE: case MIR_OP_COPY: case MIR_OP_SET: { mir_dump_value(mu, n->args[0], cb, ctx); printf(" := %s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[1], cb, ctx); if (n->nargs > 2) { printf(" count "); mir_dump_value(mu, n->args[2], cb, ctx); } } break; case MIR_OP_NEW: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); if (n->nargs > 0) { col += printf(" count "); col += mir_dump_value(mu, n->args[0], cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_LOAD: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_JUMP: case MIR_OP_ADD_TRIGGER: case MIR_OP_DEBUG_OUT: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); } break; case MIR_OP_COND: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); printf(" then "); mir_dump_value(mu, n->args[1], cb, ctx); printf(" else "); mir_dump_value(mu, n->args[2], cb, ctx); } break; case MIR_OP_CASE: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" default "); mir_dump_arg(mu, result, 1, cb, ctx); for (int i = 2; i < n->nargs; i += 2) { printf(" ["); mir_dump_arg(mu, result, i, cb, ctx); printf(" "); mir_dump_arg(mu, result, i + 1, cb, ctx); printf("]"); } } break; case MIR_OP_WAIT: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); if (n->nargs > 1) { printf(" for "); mir_dump_value(mu, n->args[1], cb, ctx); } } break; case MIR_OP_SELECT: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf(" then "); col += mir_dump_value(mu, n->args[1], cb, ctx); col += printf(" else "); col += mir_dump_value(mu, n->args[2], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CMP: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[1], cb, ctx); switch (n->args[0].id) { case MIR_CMP_EQ: col += printf(" == "); break; case MIR_CMP_NEQ: col += printf(" != "); break; case MIR_CMP_LT: col += printf(" < "); break; case MIR_CMP_GT: col += printf(" > "); break; case MIR_CMP_LEQ: col += printf(" <= "); break; case MIR_CMP_GEQ: col += printf(" >= "); break; } col += mir_dump_value(mu, n->args[2], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_PHI: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s", mir_op_string(n->op)); for (int i = 0; i < n->nargs; i += 2) { col += printf(" ["); col += mir_dump_value(mu, n->args[i], cb, ctx); col += printf(" "); col += mir_dump_value(mu, n->args[i+1], cb, ctx); col += printf("]"); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONSUME: case MIR_OP_RESUME: case MIR_OP_INSTANCE_NAME: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); } break; case MIR_OP_FCALL: case MIR_OP_FUNCTION_TRIGGER: { if (!mir_is_null(n->type)) { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := "); } col += printf("%s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" "); for (int i = 1; i < n->nargs; i++) { if (i > 1) col += printf(", "); col += mir_dump_arg(mu, result, i, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_PCALL: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 1, cb, ctx); printf(" "); for (int i = 2; i < n->nargs; i++) { if (i > 2) col += printf(", "); col += mir_dump_arg(mu, result, i, cb, ctx); } printf(" resume "); mir_dump_arg(mu, result, 0, cb, ctx); } break; case MIR_OP_SYSCALL: { if (!mir_is_null(n->type)) { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := "); } col += printf("%s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); for (int i = 2; i < n->nargs; i++) { col += printf("%s ", i > 2 ? "," : ""); col += mir_dump_arg(mu, result, i, cb, ctx); } col += color_printf(" locus "); col += mir_dump_arg(mu, result, 1, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_WRAP: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" ["); for (int i = 1; i < n->nargs; i += 3) { if (i > 1) col += printf(", "); col += mir_dump_dim(mu, result, i, cb, ctx); } col += printf("]"); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_UNWRAP: case MIR_OP_RESOLVED: case MIR_OP_LAST_VALUE: case MIR_OP_CAST: case MIR_OP_NEG: case MIR_OP_ABS: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_UARRAY_LEN: case MIR_OP_UARRAY_DIR: case MIR_OP_UARRAY_LEFT: case MIR_OP_UARRAY_RIGHT: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" dim "); col += mir_dump_arg(mu, result, 1, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_LOCUS: { col += mir_dump_value(mu, result, cb, ctx); col += color_printf(" := %s ", mir_op_string(n->op)); col += mir_dump_locus(n->locus); mir_dump_type(mu, col, n->type); } break; case MIR_OP_INIT_SIGNAL: { col += mir_dump_value(mu, result, cb, ctx); col += color_printf(" := %s count ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" size "); col += mir_dump_arg(mu, result, 1, cb, ctx); col += printf(" value "); col += mir_dump_arg(mu, result, 2, cb, ctx); col += printf(" flags "); col += mir_dump_arg(mu, result, 3, cb, ctx); col += printf(" locus "); col += mir_dump_arg(mu, result, 4, cb, ctx); if (n->nargs > 5) { col += printf(" offset "); col += mir_dump_arg(mu, result, 5, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_IMPLICIT_SIGNAL: { col += mir_dump_value(mu, result, cb, ctx); col += color_printf(" := %s count ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" size "); col += mir_dump_arg(mu, result, 1, cb, ctx); col += printf(" locus "); col += mir_dump_arg(mu, result, 2, cb, ctx); col += printf(" kind "); col += mir_dump_arg(mu, result, 3, cb, ctx); col += printf(" closure "); col += mir_dump_arg(mu, result, 4, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_PACKAGE_INIT: { col += mir_dump_value(mu, result, cb, ctx); col += color_printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); if (n->nargs > 1) { col += printf(" context "); col += mir_dump_value(mu, n->args[1], cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_SCHED_WAVEFORM: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" values "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" reject "); mir_dump_arg(mu, result, 3, cb, ctx); printf(" after "); mir_dump_arg(mu, result, 4, cb, ctx); } break; case MIR_OP_DRIVE_SIGNAL: case MIR_OP_RELEASE: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); printf(" count "); mir_dump_value(mu, n->args[1], cb, ctx); } break; case MIR_OP_DISCONNECT: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" reject "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" after "); mir_dump_arg(mu, result, 3, cb, ctx); } break; case MIR_OP_EVENT: case MIR_OP_ACTIVE: case MIR_OP_DRIVING: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf(" count "); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_ASSERT: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, mir_get_arg(mu, result, 0), cb, ctx); mir_value_t msg = mir_get_arg(mu, result, 2); if (!mir_is_null(msg)) { printf(" report "); mir_dump_value(mu, msg, cb, ctx); printf(" length "); mir_dump_value(mu, mir_get_arg(mu, result, 3), cb, ctx); } printf(" severity "); mir_dump_value(mu, mir_get_arg(mu, result, 1), cb, ctx); printf(" locus "); mir_dump_value(mu, mir_get_arg(mu, result, 4), cb, ctx); if (n->nargs > 5) { printf(" hint "); mir_dump_value(mu, mir_get_arg(mu, result, 5), cb, ctx); printf(" "); mir_dump_value(mu, mir_get_arg(mu, result, 6), cb, ctx); } } break; case MIR_OP_REPORT: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, mir_get_arg(mu, result, 1), cb, ctx); printf(" length "); mir_dump_value(mu, mir_get_arg(mu, result, 2), cb, ctx); printf(" severity "); mir_dump_value(mu, mir_get_arg(mu, result, 0), cb, ctx); printf(" locus "); mir_dump_value(mu, mir_get_arg(mu, result, 3), cb, ctx); } break; case MIR_OP_CONTEXT_UPREF: case MIR_OP_ADDRESS_OF: case MIR_OP_LINK_PACKAGE: case MIR_OP_ALL: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_LINK_VAR: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[1], cb, ctx); ident_t name = mir_get_name(mu, n->args[2]); col += color_printf(" $magenta$%s$$", istr(name)); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_VAR_UPREF: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); ident_t link = mir_get_name(mu, n->args[1]); if (link == NULL) col += color_printf(", $red$invalid$$"); else { mir_shape_t *s = mir_get_shape(mu->context, link); ident_t name = s->slots[n->args[2].id].name; col += color_printf(", $magenta$%s$$", istr(name)); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_ARRAY_REF: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf(" offset "); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_RECORD_REF: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf(" field "); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONST_ARRAY: { col += mir_dump_value(mu, result, cb, ctx); col += mir_dump_const_array(mu, result, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONST_REP: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := const ["); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf("]*"); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONST_RECORD: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := const {"); for (int i = 0; i < n->nargs; i++) { mir_value_t elt = mir_get_arg(mu, result, i); if (i > 0) col += printf(","); col += mir_dump_value(mu, elt, cb, ctx); } col += printf("}"); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_INDEX_CHECK: case MIR_OP_RANGE_CHECK: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" left "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" right "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" dir "); mir_dump_arg(mu, result, 3, cb, ctx); printf(" locus "); mir_value_t locus = mir_get_arg(mu, result, 4); mir_dump_value(mu, locus, cb, ctx); mir_value_t hint = mir_get_arg(mu, result, 5); if (mir_equals(locus, hint)) { printf(" hint "); mir_dump_value(mu, hint, cb, ctx); } } break; case MIR_OP_DIR_CHECK: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" == "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" locus "); mir_dump_arg(mu, result, 2, cb, ctx); } break; case MIR_OP_LENGTH_CHECK: { printf("%s left ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" == right "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" locus "); mir_dump_arg(mu, result, 2, cb, ctx); if (n->nargs > 3) { printf(" dim "); mir_dump_arg(mu, result, 3, cb, ctx); } } break; case MIR_OP_NULL_CHECK: case MIR_OP_ZERO_CHECK: case MIR_OP_EXPONENT_CHECK: case MIR_OP_ALIAS_SIGNAL: case MIR_OP_TRAP_NEG: case MIR_OP_PROCESS_INIT: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" locus "); mir_dump_arg(mu, result, 1, cb, ctx); } break; case MIR_OP_SCHED_EVENT: case MIR_OP_CLEAR_EVENT: { printf("%s on ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" count " ); mir_dump_arg(mu, result, 1, cb, ctx); } break; case MIR_OP_RANGE_LENGTH: case MIR_OP_RANGE_NULL: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s left ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" right "); col += mir_dump_arg(mu, result, 1, cb, ctx); col += printf(" dir "); col += mir_dump_arg(mu, result, 2, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_NULL: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s", mir_op_string(n->op)); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_MAP_SIGNAL: case MIR_OP_MAP_CONST: case MIR_OP_MAP_IMPLICIT: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" to "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 2, cb, ctx); } break; case MIR_OP_CLOSURE: case MIR_OP_PROTECTED_INIT: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" context "); col += mir_dump_arg(mu, result, 1, cb, ctx); if (n->nargs >= 4) { col += printf(" path "); col += mir_dump_arg(mu, result, 2, cb, ctx); col += printf(" instance "); col += mir_dump_arg(mu, result, 3, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_RESOLVE_SIGNAL: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" resolution "); mir_dump_arg(mu, result, 1, cb, ctx); } break; case MIR_OP_RESOLUTION_WRAPPER: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" nlits "); col += mir_dump_arg(mu, result, 1, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_TRANSFER_SIGNAL: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" to "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" reject "); mir_dump_arg(mu, result, 3, cb, ctx); printf(" after "); mir_dump_arg(mu, result, 4, cb, ctx); } break; case MIR_OP_FILE_OPEN: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" name "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" length "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" kind "); mir_dump_arg(mu, result, 3, cb, ctx); if (n->nargs > 4) { printf(" status "); mir_dump_arg(mu, result, 4, cb, ctx); } } break; case MIR_OP_FILE_READ: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" ptr "); mir_dump_arg(mu, result, 1, cb, ctx); if (n->nargs > 2) { printf(" inlen "); mir_dump_arg(mu, result, 2, cb, ctx); if (n->nargs > 3) { printf(" outlen "); mir_dump_arg(mu, result, 3, cb, ctx); } } } break; case MIR_OP_FILE_WRITE: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" value "); mir_dump_arg(mu, result, 1, cb, ctx); if (n->nargs > 2) { printf(" length "); mir_dump_arg(mu, result, 2, cb, ctx); } } break; case MIR_OP_PORT_CONVERSION: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); if (n->nargs > 1) { col += printf(" effective "); col += mir_dump_arg(mu, result, 1, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_CONVERT_IN: case MIR_OP_CONVERT_OUT: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" signal "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 2, cb, ctx); } break; case MIR_OP_PUT_CONVERSION: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" signal "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 2, cb, ctx); printf(" values "); mir_dump_arg(mu, result, 3, cb, ctx); } break; case MIR_OP_FORCE: case MIR_OP_DEPOSIT_SIGNAL: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" count "); mir_dump_arg(mu, result, 1, cb, ctx); printf(" values "); mir_dump_arg(mu, result, 2, cb, ctx); } break; case MIR_OP_UNREACHABLE: case MIR_OP_POP_SCOPE: { printf("%s", mir_op_string(n->op)); if (n->nargs > 0) { printf(" "); mir_dump_arg(mu, result, 0, cb, ctx); } } break; case MIR_OP_BIND_FOREIGN: { printf("%s ", mir_op_string(n->op)); mir_dump_arg(mu, result, 0, cb, ctx); printf(" length "); mir_dump_arg(mu, result, 1, cb, ctx); if (n->nargs > 2) { printf(" locus "); mir_dump_arg(mu, result, 2, cb, ctx); } } break; case MIR_OP_DRIVING_VALUE: case MIR_OP_LAST_ACTIVE: case MIR_OP_LAST_EVENT: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); if (n->nargs > 1) { col += printf(" count "); col += mir_dump_value(mu, n->args[1], cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_BIND_EXTERNAL: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); col += printf(" scope "); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } case MIR_OP_COVER_STMT: case MIR_OP_COVER_BRANCH: case MIR_OP_COVER_EXPR: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); } break; case MIR_OP_COVER_TOGGLE: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[1], cb, ctx); printf(" signal "); mir_dump_value(mu, n->args[0], cb, ctx); } break; case MIR_OP_COVER_STATE: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[2], cb, ctx); printf(" signal "); mir_dump_value(mu, n->args[0], cb, ctx); printf(" low "); mir_dump_value(mu, n->args[1], cb, ctx); } break; case MIR_OP_PACKAGE_SCOPE: case MIR_OP_ARRAY_SCOPE: case MIR_OP_RECORD_SCOPE: { col += printf("%s locus ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); mir_dump_type(mu, col, n->type); } break; case MIR_OP_OR_TRIGGER: case MIR_OP_CMP_TRIGGER: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_value(mu, n->args[0], cb, ctx); if (n->op == MIR_OP_OR_TRIGGER) col += printf(" || "); else col += printf(" == "); col += mir_dump_value(mu, n->args[1], cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_ENTER_STATE: { printf("%s ", mir_op_string(n->op)); mir_dump_value(mu, n->args[0], cb, ctx); if (n->nargs > 1) { printf(" strong "); mir_dump_value(mu, n->args[1], cb, ctx); } } break; case MIR_OP_REFLECT_VALUE: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" context "); col += mir_dump_arg(mu, result, 1, cb, ctx); col += printf(" locus "); col += mir_dump_arg(mu, result, 2, cb, ctx); if (n->nargs > 3) { col += printf(" bounds "); col += mir_dump_arg(mu, result, 3, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_REFLECT_SUBTYPE: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s context ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" locus "); col += mir_dump_arg(mu, result, 1, cb, ctx); if (n->nargs > 2) { col += printf(" bounds "); col += mir_dump_arg(mu, result, 2, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_UNPACK: { if (!mir_is_null(n->type)) { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := "); } col += printf("%s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); col += printf(" strength "); col += mir_dump_strength(mu, mir_get_arg(mu, result, 1)); if (n->nargs > 2) { col += printf(" into "); col += mir_dump_arg(mu, result, 2, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_PACK: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := %s ", mir_op_string(n->op)); col += mir_dump_arg(mu, result, 0, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_BINARY: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := vector "); col += mir_dump_arg(mu, result, 1, cb, ctx); col += mir_dump_vector_op(mu, n->args[0]); col += mir_dump_arg(mu, result, 2, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; case MIR_OP_UNARY: { col += mir_dump_value(mu, result, cb, ctx); col += printf(" := vector"); col += mir_dump_vector_op(mu, n->args[0]); col += mir_dump_arg(mu, result, 1, cb, ctx); mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; #ifdef DEBUG case MIR_OP_COMMENT: { const char *str = tb_get(mu->comments) + n->args[0].id; color_printf("$cyan$// %s$$ ", str); } break; #endif case _MIR_DELETED_OP: col += color_printf("$red$deleted$$"); break; default: { col += color_printf("$red$0x%02x$$ ", n->op); for (int k = 0; k < n->nargs; k++) { if (k > 0) col += printf(", "); mir_value_t arg = mir_get_arg(mu, result, k); col += mir_dump_value(mu, arg, cb, ctx); } mir_dump_type(mu, col, n->type); mir_dump_stamp(mu, n->type, n->stamp); } break; } const bool mark = !mir_is_null(mu->cursor.block) && i == mu->cursor.block.id && (j == mu->cursor.pos || (mu->cursor.pos >= b->num_nodes && j == b->num_nodes - 1)); if (mark) color_printf("\t $red$<----$$"); color_printf("$$\n"); if (cb->end_node != NULL) { mir_block_t b = { .tag = MIR_TAG_BLOCK, .id = i }; (*cb->end_node)(mu, b, result, ctx); } } if (b->num_nodes == 0) color_printf(" $yellow$%2d:$$ $red$Empty basic block$$\n", i); } printf("\n"); fflush(stdout); } void mir_dump(mir_unit_t *mu) { const mir_annotate_t cb = {}; mir_annotate(mu, &cb, NULL); } // LCOV_EXCL_STOP ////////////////////////////////////////////////////////////// nvc-r1.17.1/src/mir/mir-node.c000066400000000000000000003201401504111170000157730ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "mir/mir-node.h" #include "mir/mir-structs.h" #include "mir/mir-priv.h" #include #include #include #include #include #define SMALL_CONST_BIAS (1 << (_MIR_ID_BITS - 1)) #define SMALL_CONST_MIN (-SMALL_CONST_BIAS) #define SMALL_CONST_MAX (SMALL_CONST_BIAS - 1) block_data_t *mir_block_data(mir_unit_t *mu, mir_block_t block) { assert(block.tag == MIR_TAG_BLOCK); return AREF(mu->blocks, block.id); } mir_block_t mir_add_block(mir_unit_t *mu) { mir_block_t b = { .tag = MIR_TAG_BLOCK, .id = mu->blocks.count }; block_data_t bd = { .gap_pos = -1, .last_loc = mu->cursor.loc, }; APUSH(mu->blocks, bd); return b; } void mir_set_cursor(mir_unit_t *mu, mir_block_t block, unsigned pos) { if (!mir_is_null(mu->cursor.block)) mir_block_data(mu, mu->cursor.block)->last_loc = mu->cursor.loc; mu->cursor.block = block; mu->cursor.pos = pos; if (mir_is_null(block)) mu->cursor.loc = LOC_INVALID; else mu->cursor.loc = mir_block_data(mu, block)->last_loc; } mir_block_t mir_get_cursor(mir_unit_t *mu, unsigned *pos) { if (pos != NULL) *pos = mu->cursor.pos; return mu->cursor.block; } void mir_set_loc(mir_unit_t *mu, const loc_t *loc) { mu->cursor.loc = *loc; } void mir_delete(mir_unit_t *mu) { block_data_t *bd = mir_block_data(mu, mu->cursor.block); assert(mu->cursor.pos < bd->num_nodes); mir_value_t node = { .tag = MIR_TAG_NODE, .id = bd->nodes[mu->cursor.pos] }; node_data_t *nd = mir_node_data(mu, node); nd->op = _MIR_DELETED_OP; nd->nargs = 0; if (bd->gap_pos == -1 || bd->gap_pos > mu->cursor.pos) bd->gap_pos = mu->cursor.pos; } void mir_compact(mir_unit_t *mu) { for (int i = 0; i < mu->blocks.count; i++) { block_data_t *bd = &(mu->blocks.items[i]); if (bd->gap_pos == -1) continue; int wptr = bd->gap_pos; for (int j = bd->gap_pos; j < bd->num_nodes; j++) { if (mu->nodes[bd->nodes[j]].op != _MIR_DELETED_OP) bd->nodes[wptr++] = bd->nodes[j]; } bd->num_nodes = wptr; } mir_set_cursor(mu, MIR_NULL_BLOCK, MIR_APPEND); } unsigned mir_count_blocks(mir_unit_t *mu) { return mu->blocks.count; } mir_block_t mir_get_block(mir_unit_t *mu, unsigned nth) { assert(nth < mu->blocks.count); return (mir_block_t) { .tag = MIR_TAG_BLOCK, .id = nth }; } unsigned mir_count_nodes(mir_unit_t *mu, mir_block_t block) { if (mir_is_null(block)) return mu->num_nodes; else return mir_block_data(mu, block)->num_nodes; } mir_value_t mir_get_node(mir_unit_t *mu, mir_block_t block, unsigned nth) { const block_data_t *bd = mir_block_data(mu, block); assert(nth < bd->num_nodes); return (mir_value_t) { .tag = MIR_TAG_NODE, .id = bd->nodes[nth] }; } unsigned mir_count_vars(mir_unit_t *mu) { return mu->vars.count; } mir_value_t mir_get_var(mir_unit_t *mu, unsigned nth) { assert(nth < mu->vars.count); return (mir_value_t) { .tag = MIR_TAG_VAR, .id = nth }; } mir_value_t mir_get_param(mir_unit_t *mu, unsigned nth) { assert(nth < mu->params.count); return (mir_value_t) { .tag = MIR_TAG_PARAM, .id = nth }; } unsigned mir_count_params(mir_unit_t *mu) { return mu->params.count; } mir_op_t mir_get_op(mir_unit_t *mu, mir_value_t node) { switch (node.tag) { case MIR_TAG_NODE: return mir_node_data(mu, node)->op; default: return _MIR_DELETED_OP; } } const loc_t *mir_get_loc(mir_unit_t *mu, mir_value_t node) { switch (node.tag) { case MIR_TAG_NODE: return &(mir_node_data(mu, node)->loc); case MIR_TAG_NULL: return &(mu->cursor.loc); default: should_not_reach_here(); } } unsigned mir_count_args(mir_unit_t *mu, mir_value_t node) { return mir_node_data(mu, node)->nargs; } const mir_value_t *mir_get_args(mir_unit_t *mu, const node_data_t *nd) { if (nd->nargs <= MIR_INLINE_ARGS) return nd->args; else { assert(nd->spilloff < mu->num_argspill); return mu->argspill + nd->spilloff; } } mir_value_t mir_get_arg(mir_unit_t *mu, mir_value_t node, unsigned nth) { const node_data_t *nd = mir_node_data(mu, node); if (nth >= nd->nargs) return MIR_NULL_VALUE; else return mir_get_args(mu, nd)[nth]; } mir_value_t mir_add_param(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, ident_t name) { mir_value_t p = { .tag = MIR_TAG_PARAM, .id = mu->params.count }; param_data_t pd = { .name = name, .type = type, .stamp = stamp, }; APUSH(mu->params, pd); return p; } mir_value_t mir_add_var(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, ident_t name, mir_var_flags_t flags) { mir_value_t v = { .tag = MIR_TAG_VAR, .id = mu->vars.count }; mir_mem_t mem = MIR_MEM_STACK; if (flags & MIR_VAR_HEAP) mem = MIR_MEM_LOCAL; var_data_t vd = { .name = name, .type = type, .pointer = mir_get_var_pointer(mu, type), .stamp = mir_pointer_stamp(mu, mem, stamp), .flags = flags, }; APUSH(mu->vars, vd); return v; } bool mir_is_terminator(mir_op_t op) { switch (op) { case MIR_OP_RETURN: case MIR_OP_JUMP: case MIR_OP_COND: case MIR_OP_WAIT: case MIR_OP_CASE: case MIR_OP_PCALL: case MIR_OP_UNREACHABLE: return true; default: return false; } } bool mir_block_finished(mir_unit_t *mu, mir_block_t block) { if (mir_is_null(block)) block = mu->cursor.block; const block_data_t *bd = mir_block_data(mu, block); if (bd->num_nodes == 0) return false; return mir_is_terminator(mu->nodes[bd->nodes[bd->num_nodes - 1]].op); } static inline node_id_t mir_node_id(mir_unit_t *mu, node_data_t *n) { assert(n >= mu->nodes && n < mu->nodes + mu->num_nodes); return n - mu->nodes; } static node_data_t *mir_alloc_node(mir_unit_t *mu) { assert(!mir_is_null(mu->cursor.block)); node_data_t *n; block_data_t *bd = mir_block_data(mu, mu->cursor.block); if (mu->cursor.pos >= bd->num_nodes) { // Append new node if (bd->num_nodes == bd->max_nodes) { bd->max_nodes = MAX(4, bd->num_nodes * 2); bd->nodes = xrealloc_array(bd->nodes, bd->max_nodes, sizeof(node_id_t)); } if (mu->num_nodes == mu->max_nodes) { mu->max_nodes = MAX(8, mu->num_nodes * 2); mu->nodes = xrealloc_array(mu->nodes, mu->max_nodes, sizeof(node_data_t)); } bd->nodes[bd->num_nodes++] = mu->num_nodes; n = &(mu->nodes[mu->num_nodes++]); } else { n = &(mu->nodes[bd->nodes[mu->cursor.pos]]); assert(n->op == _MIR_DELETED_OP); } return n; } static size_t mir_spill_args(mir_unit_t *mu, unsigned num) { if (mu->num_argspill + num > mu->max_argspill) { mu->max_argspill = MAX(16, MAX(mu->num_argspill + num, mu->max_argspill * 2)); mu->argspill = xrealloc_array(mu->argspill, mu->max_argspill, sizeof(mir_value_t)); } const size_t off = mu->num_argspill; mu->num_argspill += num; return off; } static node_data_t *mir_add_node(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, unsigned nargs) { node_data_t *n = mir_alloc_node(mu); n->loc = mu->cursor.loc; n->op = op; n->type = type; n->stamp = stamp; n->nargs = nargs; if (nargs > MIR_INLINE_ARGS) n->spilloff = mir_spill_args(mu, nargs); return n; } static mir_value_t mir_build_0(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp) { node_data_t *n = mir_add_node(mu, op, type, stamp, 0); return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_1(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg) { node_data_t *n = mir_add_node(mu, op, type, stamp, 1); n->args[0] = arg; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_2(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg1, mir_value_t arg2) { STATIC_ASSERT(MIR_INLINE_ARGS >= 2); node_data_t *n = mir_add_node(mu, op, type, stamp, 2); n->args[0] = arg1; n->args[1] = arg2; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_3(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg1, mir_value_t arg2, mir_value_t arg3) { STATIC_ASSERT(MIR_INLINE_ARGS >= 3); node_data_t *n = mir_add_node(mu, op, type, stamp, 3); n->args[0] = arg1; n->args[1] = arg2; n->args[2] = arg3; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_4(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg1, mir_value_t arg2, mir_value_t arg3, mir_value_t arg4) { STATIC_ASSERT(MIR_INLINE_ARGS >= 4); node_data_t *n = mir_add_node(mu, op, type, stamp, 4); n->args[0] = arg1; n->args[1] = arg2; n->args[2] = arg3; n->args[3] = arg4; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_5(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg1, mir_value_t arg2, mir_value_t arg3, mir_value_t arg4, mir_value_t arg5) { node_data_t *n = mir_add_node(mu, op, type, stamp, 5); n->nargs = 5; STATIC_ASSERT(MIR_INLINE_ARGS < 5); mu->argspill[n->spilloff + 0] = arg1; mu->argspill[n->spilloff + 1] = arg2; mu->argspill[n->spilloff + 2] = arg3; mu->argspill[n->spilloff + 3] = arg4; mu->argspill[n->spilloff + 4] = arg5; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_6(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_stamp_t stamp, mir_value_t arg1, mir_value_t arg2, mir_value_t arg3, mir_value_t arg4, mir_value_t arg5, mir_value_t arg6) { node_data_t *n = mir_add_node(mu, op, type, stamp, 6); STATIC_ASSERT(MIR_INLINE_ARGS < 6); mu->argspill[n->spilloff + 0] = arg1; mu->argspill[n->spilloff + 1] = arg2; mu->argspill[n->spilloff + 2] = arg3; mu->argspill[n->spilloff + 3] = arg4; mu->argspill[n->spilloff + 4] = arg5; mu->argspill[n->spilloff + 5] = arg6; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_add_linkage(mir_unit_t *mu, ident_t ident) { for (int i = 0; i < mu->linkage.count; i++) { if (mu->linkage.items[i] == ident) return (mir_value_t){ .tag = MIR_TAG_LINKAGE, .id = i }; } mir_value_t link = { .tag = MIR_TAG_LINKAGE, .id = mu->linkage.count }; APUSH(mu->linkage, ident); return link; } static mir_value_t mir_add_extvar(mir_unit_t *mu, ident_t ident) { for (int i = 0; i < mu->extvars.count; i++) { if (mu->extvars.items[i] == ident) return (mir_value_t){ .tag = MIR_TAG_EXTVAR, .id = i }; } mir_value_t var = { .tag = MIR_TAG_EXTVAR, .id = mu->extvars.count }; APUSH(mu->extvars, ident); return var; } void mir_set_arg(mir_unit_t *mu, node_data_t *n, unsigned nth, mir_value_t value) { assert(nth < n->nargs); if (n->nargs <= MIR_INLINE_ARGS) n->args[nth] = value; else { assert(n->spilloff < mu->num_argspill); mu->argspill[n->spilloff + nth] = value; } } node_data_t *mir_node_data(mir_unit_t *mu, mir_value_t value) { assert(value.tag == MIR_TAG_NODE); assert(value.id < mu->num_nodes); return &(mu->nodes[value.id]); } const param_data_t *mir_param_data(mir_unit_t *mu, mir_value_t value) { assert(value.tag == MIR_TAG_PARAM); return AREF(mu->params, value.id); } const var_data_t *mir_var_data(mir_unit_t *mu, mir_value_t value) { assert(value.tag == MIR_TAG_VAR); return AREF(mu->vars, value.id); } #ifdef DEBUG void mir_comment(mir_unit_t *mu, const char *fmt, ...) { va_list ap; va_start(ap, fmt); if (mu->comments == NULL) mu->comments = tb_new(); mir_value_t value = { .tag = MIR_TAG_COMMENT, .id = tb_len(mu->comments) }; tb_vprintf(mu->comments, fmt, ap); tb_append(mu->comments, '\0'); va_end(ap); mir_build_1(mu, MIR_OP_COMMENT, MIR_NULL_TYPE, MIR_NULL_STAMP, value); } #endif mir_saved_loc_t _mir_push_debug_info(mir_unit_t *mu, const loc_t *loc) { mir_saved_loc_t result = { mu, mu->cursor.loc }; mu->cursor.loc = *loc; return result; } bool mir_get_const(mir_unit_t *mu, mir_value_t value, int64_t *result) { switch (value.tag) { case MIR_TAG_CONST: *result = (int64_t)value.id - SMALL_CONST_BIAS; return true; case MIR_TAG_ENUM: *result = value.id; return true; case MIR_TAG_NODE: { const node_data_t *n = mir_node_data(mu, value); if (n->op == MIR_OP_CONST) { *result = n->iconst; return true; } else return false; } default: return false; } } bool mir_get_const_real(mir_unit_t *mu, mir_value_t value, double *result) { switch (value.tag) { case MIR_TAG_NODE: { const node_data_t *n = mir_node_data(mu, value); if (n->op == MIR_OP_CONST_REAL) { *result = n->dconst; return true; } else return false; } default: return false; } } mir_type_t mir_get_type(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_NODE: return mir_node_data(mu, value)->type; case MIR_TAG_PARAM: return mir_param_data(mu, value)->type; case MIR_TAG_VAR: return mir_var_data(mu, value)->pointer; default: return MIR_NULL_TYPE; } } mir_stamp_t mir_get_stamp(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_NODE: return mir_node_data(mu, value)->stamp; case MIR_TAG_PARAM: return mir_param_data(mu, value)->stamp; case MIR_TAG_VAR: return mir_var_data(mu, value)->stamp; case MIR_TAG_CONST: { const int64_t ival = (int64_t)value.id - SMALL_CONST_BIAS; return mir_int_stamp(mu, ival, ival); } default: return MIR_NULL_STAMP; } } mir_mem_t mir_get_mem(mir_unit_t *mu, mir_value_t value) { mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return MIR_MEM_NONE; switch (mir_type_data(mu, type)->class) { case MIR_TYPE_UARRAY: case MIR_TYPE_CARRAY: case MIR_TYPE_RECORD: case MIR_TYPE_POINTER: case MIR_TYPE_ACCESS: break; default: return MIR_MEM_NONE; } mir_stamp_t stamp = mir_get_stamp(mu, value); if (mir_is_null(stamp)) return MIR_MEM_TOP; const stamp_data_t *sd = mir_stamp_data(mu, stamp); assert(sd->kind == MIR_STAMP_POINTER); return sd->u.pointer.memory; } ident_t mir_get_name(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_PARAM: return mir_param_data(mu, value)->name; case MIR_TAG_VAR: return mir_var_data(mu, value)->name; case MIR_TAG_LINKAGE: return AGET(mu->linkage, value.id); case MIR_TAG_EXTVAR: return AGET(mu->extvars, value.id); case MIR_TAG_NULL: return mu->name; default: return NULL; } } void mir_set_result(mir_unit_t *mu, mir_type_t type) { assert(mu->kind == MIR_UNIT_FUNCTION || mu->kind == MIR_UNIT_THUNK); mu->result = type; } mir_type_t mir_get_result(mir_unit_t *mu) { return mu->result; } object_t *mir_get_locus(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_NODE: { node_data_t *n = mir_node_data(mu, value); assert(n->op == MIR_OP_LOCUS); return n->locus; } break; default: should_not_reach_here(); } } void mir_get_bits(mir_unit_t *mu, mir_value_t value, uint64_t *abits, uint64_t *bbits) { switch (value.tag) { case MIR_TAG_NODE: { node_data_t *n = mir_node_data(mu, value); assert(n->op == MIR_OP_CONST_VEC); *abits = n->bits[0]; *bbits = n->bits[1]; } break; default: should_not_reach_here(); } } mir_var_flags_t mir_get_var_flags(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_VAR: return mir_var_data(mu, value)->flags; default: return 0; } } mir_type_t mir_get_var_type(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_VAR: return mir_var_data(mu, value)->type; default: return MIR_NULL_TYPE; } } bool mir_is_integral(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return true; mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; switch (mir_type_data(mu, type)->class) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: return true; default: return false; } } bool mir_is_numeric(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return true; mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; switch (mir_type_data(mu, type)->class) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: case MIR_TYPE_REAL: case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: return true; default: return false; } } bool mir_is_scalar(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return true; mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; switch (mir_type_data(mu, type)->class) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: case MIR_TYPE_REAL: case MIR_TYPE_ACCESS: case MIR_TYPE_POINTER: case MIR_TYPE_UARRAY: case MIR_TYPE_SIGNAL: case MIR_TYPE_CONTEXT: case MIR_TYPE_RESOLUTION: case MIR_TYPE_FILE: case MIR_TYPE_TRIGGER: case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: return true; default: return false; } } bool mir_is_vector(mir_unit_t *mu, mir_value_t value) { mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; switch (mir_type_data(mu, type)->class) { case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: return true; default: return false; } } bool mir_is_bool(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return value.id == SMALL_CONST_BIAS || value.id == SMALL_CONST_BIAS + 1; else return mir_equals(mir_get_type(mu, value), mir_bool_type(mu)); } bool mir_is_time(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return true; return mir_equals(mir_get_type(mu, value), mir_time_type(mu)); } bool mir_is(mir_unit_t *mu, mir_value_t value, mir_class_t class) { mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; return mir_type_data(mu, type)->class == class; } bool mir_points_to(mir_unit_t *mu, mir_value_t value, mir_class_t class) { mir_type_t type = mir_get_type(mu, value); if (mir_is_null(type)) return false; const type_data_t *td = mir_type_data(mu, type); if (td->class != MIR_TYPE_POINTER) return false; return mir_type_data(mu, td->u.pointer)->class == class; } bool mir_is_signal(mir_unit_t *mu, mir_value_t value) { return mir_is(mu, value, MIR_TYPE_SIGNAL); } bool mir_is_offset(mir_unit_t *mu, mir_value_t value) { if (value.tag == MIR_TAG_CONST) return true; return mir_is(mu, value, MIR_TYPE_OFFSET); } bool mir_is_const(mir_unit_t *mu, mir_value_t value) { switch (value.tag) { case MIR_TAG_CONST: return true; case MIR_TAG_NODE: { node_data_t *n = mir_node_data(mu, value); switch (n->op) { case MIR_OP_CONST: case MIR_OP_CONST_REAL: case MIR_OP_CONST_ARRAY: case MIR_OP_CONST_REP: case MIR_OP_CONST_RECORD: case MIR_OP_NULL: return true; default: return false; } } default: return false; } } bool mir_may_alias(mir_unit_t *mu, mir_value_t a, mir_value_t b) { const mir_mem_t a_mem = mir_get_mem(mu, a); if (a_mem == MIR_MEM_NONE) return false; if (mir_equals(a, b)) return true; const mir_mem_t b_mem = mir_get_mem(mu, b); if (b_mem == MIR_MEM_NONE) return false; if (a_mem == MIR_MEM_CONST || b_mem == MIR_MEM_CONST) { // Aliasing is only relevant in the presence of mutability return false; } return a_mem == b_mem || a_mem == MIR_MEM_TOP || b_mem == MIR_MEM_TOP; } #ifdef DEBUG static bool mir_check_type(mir_unit_t *mu, mir_value_t value, mir_type_t type) { if (value.tag == MIR_TAG_CONST) { const mir_class_t class = mir_type_data(mu, type)->class; return class == MIR_TYPE_INT || class == MIR_TYPE_OFFSET; } else return mir_equals(mir_get_type(mu, value), type); } #endif mir_value_t mir_enum(unsigned value) { assert(value < MIR_ID_MAX); return (mir_value_t){ .tag = MIR_TAG_ENUM, .id = value }; } mir_value_t mir_const(mir_unit_t *mu, mir_type_t type, int64_t value) { mir_value_t result; if (value >= SMALL_CONST_MIN && value <= SMALL_CONST_MAX) { const unsigned biased = value + SMALL_CONST_BIAS; result = (mir_value_t){ .tag = MIR_TAG_CONST, .id = biased }; } else { mir_stamp_t stamp = mir_int_stamp(mu, value, value); node_data_t *n = mir_add_node(mu, MIR_OP_CONST, type, stamp, 0); n->iconst = value; result = (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } #ifdef DEBUG const mir_class_t class = mir_get_class(mu, type); MIR_ASSERT(class == MIR_TYPE_INT || class == MIR_TYPE_OFFSET, "constant must have integral type"); #endif return result; } mir_value_t mir_const_real(mir_unit_t *mu, mir_type_t type, double value) { mir_stamp_t stamp = mir_real_stamp(mu, value, value); node_data_t *n = mir_add_node(mu, MIR_OP_CONST_REAL, type, stamp, 0); n->dconst = value; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_const_vec(mir_unit_t *mu, mir_type_t type, uint64_t abits, uint64_t bbits) { uint64_t mask = ~UINT64_C(0), size = mir_get_size(mu, type); if (size < 64) mask >>= 64 - size; node_data_t *n = mir_add_node(mu, MIR_OP_CONST_VEC, type, MIR_NULL_STAMP, 0); n->bits[0] = abits & mask; n->bits[1] = bbits & mask; #ifdef DEBUG const type_data_t *td = mir_type_data(mu, type); MIR_ASSERT(td->class == MIR_TYPE_VEC2 || td->class == MIR_TYPE_VEC4, "constant vector must have vector type"); MIR_ASSERT(bbits == 0 || td->class == MIR_TYPE_VEC4, "b-bits cannot be set for two-value vector"); #endif return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_const_array(mir_unit_t *mu, mir_type_t type, const mir_value_t *values, size_t count) { node_data_t *n = mir_add_node(mu, MIR_OP_CONST_ARRAY, type, MIR_NULL_STAMP, count); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_CARRAY, "constant array must have constrained array type"); MIR_ASSERT(mir_get_size(mu, type) == count, "expected %d elements but " "have %zd", mir_get_size(mu, type), count); mir_type_t elem = mir_get_elem(mu, type); const bool integral = mir_get_class(mu, elem) == MIR_TYPE_INT; int64_t low = INT64_MAX, high = INT64_MIN; for (size_t i = 0; i < count; i++) { mir_set_arg(mu, n, i, values[i]); MIR_ASSERT(mir_check_type(mu, values[i], elem), "element %zd has wrong type", i); MIR_ASSERT(mir_is_const(mu, values[i]), "element %zd not const", i); int64_t cval; if (integral && mir_get_const(mu, values[i], &cval)) { low = MIN(low, cval); high = MAX(high, cval); } } mir_stamp_t stamp = MIR_NULL_STAMP; if (integral && low <= high) stamp = mir_int_stamp(mu, low, high); n->stamp = mir_pointer_stamp(mu, MIR_MEM_CONST, stamp); return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_const_string(mir_unit_t *mu, const char *str) { int count = 0, low = UINT8_MAX, high = 0; for (const char *p = str; *p; p++, count++) { low = MIN(low, (unsigned char)*p); high = MAX(high, (unsigned char)*p); } mir_type_t t_char = mir_char_type(mu); mir_type_t type = mir_carray_type(mu, count, t_char); mir_stamp_t stamp = mir_int_stamp(mu, low, high); node_data_t *n = mir_add_node(mu, MIR_OP_CONST_ARRAY, type, stamp, count); for (int i = 0; i < count; i++) mir_set_arg(mu, n, i, mir_const(mu, t_char, (unsigned char)str[i])); return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_build_const_rep(mir_unit_t *mu, mir_type_t type, mir_value_t value, unsigned rep) { mir_stamp_t stamp = mir_get_stamp(mu, value); mir_value_t result = mir_build_2(mu, MIR_OP_CONST_REP, type, stamp, value, mir_enum(rep)); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_CARRAY, "constant array must have constrained array class"); MIR_ASSERT(rep < MIR_ID_MAX, "repetitions out of range"); return result; } mir_value_t mir_const_record(mir_unit_t *mu, mir_type_t type, const mir_value_t *values, size_t count) { node_data_t *n = mir_add_node(mu, MIR_OP_CONST_RECORD, type, MIR_NULL_STAMP, count); DEBUG_ONLY(const type_data_t *td = mir_type_data(mu, type)); MIR_ASSERT(td->class == MIR_TYPE_RECORD, "const record must have record type"); MIR_ASSERT(td->u.record.count == count, "expected %u fields but have %zu", td->u.record.count, count); for (int i = 0; i < count; i++) { mir_set_arg(mu, n, i, values[i]); MIR_ASSERT(mir_same_type(mu, mir_get_type(mu, values[i]), td->u.record.fields[i]), "wrong type for element %d", i); MIR_ASSERT(mir_is_const(mu, values[i]), "element %d is not constant", i); } return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } static mir_value_t mir_build_arith(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus, mir_stamp_t stamp) { mir_value_t result; if (mir_is_null(locus)) result = mir_build_2(mu, op, type, stamp, left, right); else result = mir_build_3(mu, op, type, stamp, left, right, locus); #ifdef DEBUG switch (mir_get_class(mu, type)) { case MIR_TYPE_INT: case MIR_TYPE_REAL: case MIR_TYPE_OFFSET: { mir_type_t ltype = mir_get_type(mu, left); mir_type_t rtype = mir_get_type(mu, right); MIR_ASSERT(mir_is_null(ltype) || mir_is_null(rtype) || mir_equals(ltype, rtype), "arguments to %s are not the same type", mir_op_string(op)); } break; case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: { const type_data_t *td = mir_type_data(mu, type); const type_data_t *ltd = mir_type_data(mu, mir_get_type(mu, left)); const type_data_t *rtd = mir_type_data(mu, mir_get_type(mu, right)); MIR_ASSERT(td->class == ltd->class && td->class == rtd->class, "cannot mix vector types"); MIR_ASSERT(td->u.vec.issigned == ltd->u.vec.issigned && td->u.vec.issigned == rtd->u.vec.issigned, "cannot mix vector signedness"); MIR_ASSERT(td->u.vec.size >= ltd->u.vec.size && td->u.vec.size >= rtd->u.vec.size, "implicit narrowing conversions are not allowed"); } break; default: MIR_ASSERT(false, "arithmetic is not allowed on this type"); break; } MIR_ASSERT(mir_is_null(locus) || mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to %s is not a locus", mir_op_string(op)); #endif return result; } static mir_value_t mir_build_add_op(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { int64_t lval, rval, cval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && lval == 0) return right; else if (rconst && rval == 0) return left; else if (lconst && rconst && !__builtin_add_overflow(lval, rval, &cval)) return mir_const(mu, type, cval); double lreal, rreal; const bool lconst_real = mir_get_const_real(mu, left, &lreal); const bool rconst_real = mir_get_const_real(mu, right, &rreal); if (lconst_real && (lreal == 0.0 || lreal == -0.0)) return right; else if (rconst_real && (rreal == 0.0 || rreal == -0.0)) return left; else if (lconst_real && rconst_real) return mir_const_real(mu, type, lreal + rreal); mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_add(mu, lstamp, rstamp); return mir_build_arith(mu, op, type, left, right, locus, stamp); } mir_value_t mir_build_add(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { return mir_build_add_op(mu, MIR_OP_ADD, type, left, right, MIR_NULL_VALUE); } mir_value_t mir_build_trap_add(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { return mir_build_add_op(mu, MIR_OP_TRAP_ADD, type, left, right, locus); } static mir_value_t mir_build_sub_op(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { int64_t lval, rval, cval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && lval == 0) return right; else if (rconst && rval == 0) return left; else if (lconst && rconst && !__builtin_sub_overflow(lval, rval, &cval)) return mir_const(mu, type, cval); else if (mir_equals(left, right)) return mir_get_class(mu, type) == MIR_TYPE_REAL ? mir_const_real(mu, type, 0.0) : mir_const(mu, type, 0); double lreal, rreal; const bool lconst_real = mir_get_const_real(mu, left, &lreal); const bool rconst_real = mir_get_const_real(mu, right, &rreal); if (lconst_real && (lreal == 0.0 || lreal == -0.0)) return right; else if (rconst_real && (rreal == 0.0 || rreal == -0.0)) return left; else if (lconst_real && rconst_real) return mir_const_real(mu, type, lreal - rreal); mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_sub(mu, lstamp, rstamp); return mir_build_arith(mu, op, type, left, right, locus, stamp); } mir_value_t mir_build_sub(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { return mir_build_sub_op(mu, MIR_OP_SUB, type, left, right, MIR_NULL_VALUE); } mir_value_t mir_build_trap_sub(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { return mir_build_sub_op(mu, MIR_OP_TRAP_SUB, type, left, right, locus); } mir_value_t mir_build_neg(mir_unit_t *mu, mir_type_t type, mir_value_t value) { int64_t cval; if (mir_get_const(mu, value, &cval)) return mir_const(mu, type, -cval); mir_value_t result = mir_build_1(mu, MIR_OP_NEG, type, MIR_NULL_STAMP, value); MIR_ASSERT(mir_is_numeric(mu, value), "argument must be numeric"); return result; } mir_value_t mir_build_trap_neg(mir_unit_t *mu, mir_type_t type, mir_value_t value, mir_value_t locus) { int64_t cval; if (mir_get_const(mu, value, &cval) && cval >= 0) return mir_const(mu, type, -cval); // TODO: check if stamp bounds are non-negative mir_value_t result = mir_build_2(mu, MIR_OP_TRAP_NEG, type, MIR_NULL_STAMP, value, locus); MIR_ASSERT(mir_is_numeric(mu, value), "argument must be numeric"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument must be debug locus"); return result; } mir_value_t mir_build_abs(mir_unit_t *mu, mir_type_t type, mir_value_t value) { int64_t lconst; if (mir_get_const(mu, value, &lconst)) return mir_const(mu, type, llabs(lconst)); mir_value_t result = mir_build_1(mu, MIR_OP_ABS, type, MIR_NULL_STAMP, value); MIR_ASSERT(mir_is_numeric(mu, value), "argument must be numeric"); return result; } static mir_value_t mir_build_mul_op(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { int64_t lval, rval, cval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && lval == 0) return left; else if (rconst && rval == 0) return right; else if (lconst && rconst && !__builtin_mul_overflow(lval, rval, &cval)) return mir_const(mu, type, cval); double lreal, rreal; const bool lconst_real = mir_get_const_real(mu, left, &lreal); const bool rconst_real = mir_get_const_real(mu, right, &rreal); if (lconst_real && rconst_real) return mir_const_real(mu, type, lreal * rreal); mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_mul(mu, lstamp, rstamp); return mir_build_arith(mu, op, type, left, right, locus, stamp); } mir_value_t mir_build_mul(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { return mir_build_mul_op(mu, MIR_OP_MUL, type, left, right, MIR_NULL_VALUE); } mir_value_t mir_build_trap_mul(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { return mir_build_sub_op(mu, MIR_OP_TRAP_MUL, type, left, right, locus); } mir_value_t mir_build_div(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && rconst && rval != 0) return mir_const(mu, type, lval / rval); else if (rconst && rval == 1) return left; mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_div(mu, lstamp, rstamp); return mir_build_arith(mu, MIR_OP_DIV, type, left, right, MIR_NULL_VALUE, stamp); } mir_value_t mir_build_rem(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && rconst && lval > 0 && rval > 0) return mir_const(mu, type, lval % rval); mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_rem(mu, lstamp, rstamp); return mir_build_arith(mu, MIR_OP_REM, type, left, right, MIR_NULL_VALUE, stamp); } mir_value_t mir_build_mod(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); if (lconst && rconst && lval > 0 && rval > 0) return mir_const(mu, type, lval % rval); mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); if (!mir_is_null(lstamp) && !mir_is_null(rstamp)) { const stamp_data_t *lsd = mir_stamp_data(mu, lstamp); const stamp_data_t *rsd = mir_stamp_data(mu, rstamp); if (lsd->u.intg.low >= 0 && rsd->u.intg.low >= 0) { // If both arguments are non-negative then rem is equivalent // and cheaper to compute mir_stamp_t stamp = mir_stamp_rem(mu, lstamp, rstamp); return mir_build_arith(mu, MIR_OP_REM, type, left, right, MIR_NULL_VALUE, stamp); } } return mir_build_arith(mu, MIR_OP_MOD, type, left, right, MIR_NULL_VALUE, MIR_NULL_STAMP); } mir_value_t mir_build_exp(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right) { return mir_build_arith(mu, MIR_OP_EXP, type, left, right, MIR_NULL_VALUE, MIR_NULL_STAMP); } mir_value_t mir_build_trap_exp(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus) { int64_t rconst; if (mir_get_const(mu, right, &rconst)) { if (rconst == 0) return mir_const(mu, type, 1); else if (rconst == 1) return left; } mir_value_t result = mir_build_arith(mu, MIR_OP_TRAP_EXP, type, left, right, locus, MIR_NULL_STAMP); MIR_ASSERT(mir_is_integral(mu, result), "trapping exp may only be used with integer types"); return result; } static mir_value_t mir_build_logical(mir_unit_t *mu, mir_op_t op, mir_type_t type, mir_value_t left, mir_value_t right) { mir_value_t result = mir_build_2(mu, op, type, MIR_NULL_STAMP, left, right); MIR_ASSERT(mir_is_bool(mu, left), "left argument to %s is not bool", mir_op_string(op)); MIR_ASSERT(mir_is_bool(mu, right), "right argument to %s is not bool", mir_op_string(op)); return result; } mir_value_t mir_build_and(mir_unit_t *mu, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); mir_type_t t_bool = mir_bool_type(mu); if (lconst && rconst) return mir_const(mu, t_bool, lval && rval); else if (lconst) return lval ? right : mir_const(mu, t_bool, 0); else if (rconst) return rval ? left : mir_const(mu, t_bool, 0); return mir_build_logical(mu, MIR_OP_AND, t_bool, left, right); } mir_value_t mir_build_or(mir_unit_t *mu, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); mir_type_t t_bool = mir_bool_type(mu); if (lconst && rconst) return mir_const(mu, t_bool, lval || rval); else if (lconst) return lval ? mir_const(mu, t_bool, 1) : right; else if (rconst) return rval ? mir_const(mu, t_bool, 1) : left; return mir_build_logical(mu, MIR_OP_OR, t_bool, left, right); } mir_value_t mir_build_xor(mir_unit_t *mu, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); mir_type_t t_bool = mir_bool_type(mu); if (lconst && rconst) return mir_const(mu, t_bool, lval ^ rval); else if (mir_equals(left, right)) return mir_const(mu, t_bool, 0); return mir_build_logical(mu, MIR_OP_XOR, t_bool, left, right); } mir_value_t mir_build_not(mir_unit_t *mu, mir_value_t value) { mir_type_t t_bool = mir_bool_type(mu); int64_t cval; if (mir_get_const(mu, value, &cval)) return mir_const(mu, t_bool, !cval); if (mir_get_op(mu, value) == MIR_OP_NOT) return mir_get_arg(mu, value, 0); mir_value_t result = mir_build_1(mu, MIR_OP_NOT, t_bool, MIR_NULL_STAMP, value); MIR_ASSERT(mir_is_bool(mu, value), "argument to not is not bool"); return result; } mir_value_t mir_build_cmp(mir_unit_t *mu, mir_cmp_t cmp, mir_value_t left, mir_value_t right) { int64_t lval, rval; const bool lconst = mir_get_const(mu, left, &lval); const bool rconst = mir_get_const(mu, right, &rval); mir_type_t t_bool = mir_bool_type(mu); if (lconst && rconst) { switch (cmp) { case MIR_CMP_EQ: return mir_const(mu, t_bool, lval == rval); case MIR_CMP_NEQ: return mir_const(mu, t_bool, lval != rval); case MIR_CMP_LT: return mir_const(mu, t_bool, lval < rval); case MIR_CMP_GT: return mir_const(mu, t_bool, lval > rval); case MIR_CMP_GEQ: return mir_const(mu, t_bool, lval >= rval); case MIR_CMP_LEQ: return mir_const(mu, t_bool, lval <= rval); default: should_not_reach_here(); } } mir_stamp_t lstamp = mir_get_stamp(mu, left); mir_stamp_t rstamp = mir_get_stamp(mu, right); mir_stamp_t stamp = mir_stamp_cmp(mu, cmp, lstamp, rstamp); int64_t sconst; if (mir_stamp_const(mu, stamp, &sconst)) return mir_const(mu, t_bool, sconst); mir_value_t result = mir_build_3(mu, MIR_OP_CMP, t_bool, stamp, mir_enum(cmp), left, right); MIR_ASSERT(mir_same_type(mu, mir_get_type(mu, left), mir_get_type(mu, right)), "arguments to cmp are not the same type"); return result; } mir_value_t mir_build_pack(mir_unit_t *mu, mir_type_t type, mir_value_t arg) { mir_value_t result = mir_build_1(mu, MIR_OP_PACK, type, MIR_NULL_STAMP, arg); #ifdef DEBUG const mir_class_t class = mir_get_class(mu, type); MIR_ASSERT(class == MIR_TYPE_VEC2 || class == MIR_TYPE_VEC4, "pack type must be vector"); MIR_ASSERT(mir_is(mu, arg, MIR_TYPE_POINTER) || (mir_get_size(mu, type) == 1 && mir_is_integral(mu, arg)), "pack argument must be pointer if size != 1"); #endif return result; } mir_value_t mir_build_unpack(mir_unit_t *mu, mir_value_t vec, uint8_t strength, mir_value_t dest) { mir_value_t result = dest; if (mir_is_null(dest)) result = mir_build_2(mu, MIR_OP_UNPACK, mir_logic_type(mu), MIR_NULL_STAMP, vec, mir_enum(strength)); else mir_build_3(mu, MIR_OP_UNPACK, MIR_NULL_TYPE, MIR_NULL_STAMP, vec, mir_enum(strength), dest); MIR_ASSERT(mir_is_vector(mu, vec), "unpack argument must be vector"); MIR_ASSERT(mir_is_null(dest) || mir_points_to(mu, dest, MIR_TYPE_INT), "unpack dest must be pointer to logic or null"); MIR_ASSERT(mir_get_size(mu, mir_get_type(mu, vec)) == 1 || !mir_is_null(dest), "unpack dest must be non-null if wide vector"); MIR_ASSERT((strength & 3) == 0, "strength lower bits must be zero"); return result; } mir_value_t mir_build_binary(mir_unit_t *mu, mir_vec_op_t op, mir_type_t type, mir_value_t left, mir_value_t right) { mir_type_t otype; switch (op) { case MIR_VEC_CASE_EQ: case MIR_VEC_CASE_NEQ: case MIR_VEC_LOG_AND: case MIR_VEC_LOG_OR: // XXX: these should be vec2 case MIR_VEC_LT: case MIR_VEC_LEQ: case MIR_VEC_GT: case MIR_VEC_GEQ: case MIR_VEC_LOG_EQ: case MIR_VEC_LOG_NEQ: otype = mir_vec4_type(mu, 1, false); break; default: otype = type; } mir_value_t result = mir_build_3(mu, MIR_OP_BINARY, otype, MIR_NULL_STAMP, mir_enum(op), left, right); MIR_ASSERT(mir_is_vector(mu, result), "binary operation must be vector"); MIR_ASSERT(mir_check_type(mu, left, type), "left type does not match"); MIR_ASSERT(mir_check_type(mu, right, type), "right type does not match"); return result; } mir_value_t mir_build_unary(mir_unit_t *mu, mir_vec_op_t op, mir_type_t type, mir_value_t arg) { mir_type_t otype; switch (op) { case MIR_VEC_LOG_NOT: otype = mir_vec2_type(mu, 1, false); break; default: otype = type; } mir_value_t result = mir_build_2(mu, MIR_OP_UNARY, otype, MIR_NULL_STAMP, mir_enum(op), arg); MIR_ASSERT(mir_is_vector(mu, result), "unary operation must be vector"); MIR_ASSERT(mir_check_type(mu, arg, type), "arg type does not match"); return result; } void mir_build_store(mir_unit_t *mu, mir_value_t dest, mir_value_t src) { mir_type_t type = mir_get_type(mu, dest); mir_type_t pointed = mir_get_pointer(mu, type); mir_build_2(mu, MIR_OP_STORE, pointed, MIR_NULL_STAMP, dest, src); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_POINTER, "store destination is not a pointer or variable"); MIR_ASSERT(mir_same_type(mu, pointed, mir_get_type(mu, src)), "source and destination have different types"); } mir_value_t mir_build_load(mir_unit_t *mu, mir_value_t value) { mir_type_t type = mir_get_type(mu, value); mir_stamp_t stamp = mir_stamp_elem(mu, mir_get_stamp(mu, value)); mir_type_t pointed = mir_get_pointer(mu, type); mir_value_t result = mir_build_1(mu, MIR_OP_LOAD, pointed, stamp, value); MIR_ASSERT(!mir_is_null(type), "cannot load this value"); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_POINTER, "argument to load is not a pointer or variable"); MIR_ASSERT(mir_is_scalar(mu, result), "cannot load non-scalar type"); return result; } void mir_build_copy(mir_unit_t *mu, mir_value_t dest, mir_value_t src, mir_value_t count) { int64_t cval; if (!mir_is_null(count) && mir_get_const(mu, count, &cval) && cval == 0) return; else if (mir_equals(dest, src)) return; mir_type_t dtype = mir_get_type(mu, dest); mir_type_t elem = mir_get_pointer(mu, dtype); if (mir_is_null(count)) mir_build_2(mu, MIR_OP_COPY, elem, MIR_NULL_STAMP, dest, src); else mir_build_3(mu, MIR_OP_COPY, elem, MIR_NULL_STAMP, dest, src, count); MIR_ASSERT(mir_is(mu, dest, MIR_TYPE_POINTER), "destination type is not a pointer"); MIR_ASSERT(mir_is(mu, src, MIR_TYPE_POINTER), "source type is not a pointer"); MIR_ASSERT(mir_equals(mir_get_type(mu, src), dtype), "source and destination types do not match"); MIR_ASSERT(mir_is_null(count) || mir_is_offset(mu, count), "count is not offset type"); } void mir_build_set(mir_unit_t *mu, mir_value_t dest, mir_value_t value, mir_value_t count) { int64_t cval; if (mir_get_const(mu, count, &cval) && cval == 0) return; mir_type_t dtype = mir_get_type(mu, dest); mir_type_t elem = mir_get_pointer(mu, dtype); mir_build_3(mu, MIR_OP_SET, elem, MIR_NULL_STAMP, dest, value, count); MIR_ASSERT(mir_is(mu, dest, MIR_TYPE_POINTER), "destination type is not a pointer"); MIR_ASSERT(mir_is_scalar(mu, value), "memset value must have scalar type"); MIR_ASSERT(mir_is_offset(mu, count), "count is not offset type"); } mir_value_t mir_build_alloc(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, mir_value_t count) { mir_type_t ptr = mir_pointer_type(mu, type); mir_value_t result = mir_build_1(mu, MIR_OP_ALLOC, ptr, stamp, count); MIR_ASSERT(mir_get_class(mu, type) != MIR_TYPE_CARRAY, "alloc element type cannot be array"); MIR_ASSERT(mir_is_offset(mu, count), "count must be offset type"); return result; } mir_value_t mir_build_null(mir_unit_t *mu, mir_type_t type) { mir_value_t result = mir_build_0(mu, MIR_OP_NULL, type, MIR_NULL_STAMP); #ifdef DEBUG const mir_class_t class = mir_get_class(mu, type); MIR_ASSERT(class == MIR_TYPE_POINTER || class == MIR_TYPE_FILE || class == MIR_TYPE_ACCESS || class == MIR_TYPE_CONTEXT, "null type must be file, access, context, or pointer"); #endif return result; } mir_value_t mir_build_new(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, mir_value_t count) { mir_type_t access = mir_access_type(mu, type); mir_value_t result; if (mir_is_null(count)) result = mir_build_0(mu, MIR_OP_NEW, access, stamp); else result = mir_build_1(mu, MIR_OP_NEW, access, stamp, count); #ifdef DEBUG const mir_class_t class = mir_get_class(mu, type); MIR_ASSERT(class == MIR_TYPE_INT || class == MIR_TYPE_RECORD || class == MIR_TYPE_UARRAY || class == MIR_TYPE_ACCESS || class == MIR_TYPE_REAL || class == MIR_TYPE_CONTEXT, "new type must be int, real, record, access, or uarray"); MIR_ASSERT(mir_is_null(count) || mir_is_offset(mu, count), "new count must have offset type"); #endif return result; } mir_value_t mir_build_all(mir_unit_t *mu, mir_value_t access) { mir_type_t type = mir_get_type(mu, access); mir_stamp_t stamp = mir_get_stamp(mu, access); mir_type_t pointed = mir_get_pointer(mu, type); mir_value_t result = mir_build_1(mu, MIR_OP_ALL, pointed, stamp, access); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_ACCESS, "argument to all must be access type"); return result; } mir_value_t mir_build_address_of(mir_unit_t *mu, mir_value_t array) { mir_type_t type = mir_get_type(mu, array); mir_type_t pointer = mir_get_pointer(mu, type); mir_stamp_t stamp = mir_get_stamp(mu, array); if (mir_is_null(pointer)) pointer = mir_pointer_type(mu, type); mir_value_t result = mir_build_1(mu, MIR_OP_ADDRESS_OF, pointer, stamp, array); MIR_ASSERT(mir_is(mu, array, MIR_TYPE_CARRAY) || mir_is(mu, array, MIR_TYPE_RECORD), "argument to address of must be array or record"); return result; } mir_value_t mir_build_array_ref(mir_unit_t *mu, mir_value_t array, mir_value_t offset) { mir_type_t type = mir_get_type(mu, array); mir_stamp_t stamp = mir_get_stamp(mu, array); mir_value_t result = mir_build_2(mu, MIR_OP_ARRAY_REF, type, stamp, array, offset); MIR_ASSERT(mir_is(mu, array, MIR_TYPE_POINTER) || mir_is_signal(mu, array), "argument to array ref must be pointer or signal"); MIR_ASSERT(mir_is_offset(mu, offset), "offset argument to array ref must be offset"); return result; } mir_value_t mir_build_record_ref(mir_unit_t *mu, mir_value_t record, unsigned field) { mir_type_t pointer = mir_get_type(mu, record); const type_data_t *td = mir_type_data(mu, mir_get_elem(mu, pointer)); mir_type_t type = MIR_NULL_TYPE; if (td->class == MIR_TYPE_RECORD && field < td->u.record.count) type = td->u.record.fields[field + td->u.record.count]; mir_value_t result = mir_build_2(mu, MIR_OP_RECORD_REF, type, MIR_NULL_STAMP, record, mir_enum(field)); MIR_ASSERT(mir_get_class(mu, pointer) == MIR_TYPE_POINTER, "record ref argument must be pointer to record"); MIR_ASSERT(td->class == MIR_TYPE_RECORD, "record ref argument must be pointer to record"); MIR_ASSERT(field < td->u.record.count, "field index %d out of range", field); return result; } mir_value_t mir_build_wrap(mir_unit_t *mu, mir_value_t data, const mir_dim_t *dims, int ndims) { mir_type_t type = mir_get_type(mu, data); mir_stamp_t stamp = mir_get_stamp(mu, data); const type_data_t *td = mir_type_data(mu, type); mir_type_t elem = td->class == MIR_TYPE_POINTER ? td->u.pointer : type; mir_type_t uarray = mir_uarray_type(mu, ndims, elem); node_data_t *n = mir_add_node(mu, MIR_OP_WRAP, uarray, stamp, ndims * 3 + 1); mir_set_arg(mu, n, 0, data); for (int i = 0; i < ndims; i++) { mir_set_arg(mu, n, i*3 + 1, dims[i].left); mir_set_arg(mu, n, i*3 + 2, dims[i].right); mir_set_arg(mu, n, i*3 + 3, dims[i].dir); } MIR_ASSERT(td->class == MIR_TYPE_POINTER || td->class == MIR_TYPE_SIGNAL, "wrapped data is not pointer or signal"); for (int i = 0; i < ndims; i++) { MIR_ASSERT(mir_is_integral(mu, dims[i].left), "dimension %d left bound must be integral", i + 1); MIR_ASSERT(mir_is_integral(mu, dims[i].right), "dimension %d right bound must be integral", i + 1); MIR_ASSERT(mir_is_bool(mu, dims[i].dir), "dimension %d direction must be bool", i + 1); } return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_build_unwrap(mir_unit_t *mu, mir_value_t array) { if (mir_get_op(mu, array) == MIR_OP_WRAP) return mir_get_arg(mu, array, 0); mir_type_t type = mir_get_type(mu, array); mir_type_t pointer = mir_get_pointer(mu, type); mir_stamp_t stamp = mir_get_stamp(mu, array); mir_value_t result = mir_build_1(mu, MIR_OP_UNWRAP, pointer, stamp, array); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_UARRAY, "unwrap argument must be uarray"); return result; } mir_value_t mir_build_uarray_len(mir_unit_t *mu, mir_value_t array, int dim) { mir_type_t t_offset = mir_offset_type(mu); mir_value_t result = mir_build_2(mu, MIR_OP_UARRAY_LEN, t_offset, MIR_NULL_STAMP, array, mir_const(mu, t_offset, dim)); MIR_ASSERT(mir_is(mu, array, MIR_TYPE_UARRAY), "uarray len argument must be uarrray"); #ifdef DEBUG const type_data_t *td = mir_type_data(mu, mir_get_type(mu, array)); MIR_ASSERT(dim >= 0 && dim < td->u.uarray.dims, "invalid dimension %d", dim); #endif return result; } static mir_value_t mir_build_uarray_op(mir_unit_t *mu, mir_op_t op, mir_type_t type, int arg_index, mir_value_t array, int dim) { if (mir_get_op(mu, array) == MIR_OP_WRAP) return mir_get_arg(mu, array, 1 + (dim * 3) + arg_index); mir_value_t result = mir_build_2(mu, op, type, MIR_NULL_STAMP, array, mir_enum(dim)); MIR_ASSERT(mir_is(mu, array, MIR_TYPE_UARRAY), "cannot use %s with non-uarray type", mir_op_string(op)); #ifdef DEBUG const type_data_t *td = mir_type_data(mu, mir_get_type(mu, array)); MIR_ASSERT(dim >= 0 && dim < td->u.uarray.dims, "invalid dimension %d", dim); #endif return result; } mir_value_t mir_build_uarray_left(mir_unit_t *mu, mir_value_t array, int dim) { return mir_build_uarray_op(mu, MIR_OP_UARRAY_LEFT, mir_offset_type(mu), 0, array, dim); } mir_value_t mir_build_uarray_right(mir_unit_t *mu, mir_value_t array, int dim) { return mir_build_uarray_op(mu, MIR_OP_UARRAY_RIGHT, mir_offset_type(mu), 1, array, dim); } mir_value_t mir_build_uarray_dir(mir_unit_t *mu, mir_value_t array, int dim) { return mir_build_uarray_op(mu, MIR_OP_UARRAY_DIR, mir_bool_type(mu), 2, array, dim); } mir_value_t mir_build_range_length(mir_unit_t *mu, mir_value_t left, mir_value_t right, mir_value_t dir) { mir_value_t result = mir_build_3(mu, MIR_OP_RANGE_LENGTH, mir_offset_type(mu), MIR_NULL_STAMP, left, right, dir); MIR_ASSERT(mir_same_type(mu, mir_get_type(mu, left), mir_get_type(mu, right)), "left and right are not the same type"); MIR_ASSERT(mir_is_integral(mu, left), "left/right type is not integeral"); MIR_ASSERT(mir_is_bool(mu, dir), "dir type is not bool"); return result; } mir_value_t mir_build_range_null(mir_unit_t *mu, mir_value_t left, mir_value_t right, mir_value_t dir) { mir_value_t result = mir_build_3(mu, MIR_OP_RANGE_NULL, mir_bool_type(mu), MIR_NULL_STAMP, left, right, dir); MIR_ASSERT(mir_same_type(mu, mir_get_type(mu, left), mir_get_type(mu, right)), "left and right are not the same type"); MIR_ASSERT(mir_is_integral(mu, left), "left/right type is not integeral"); MIR_ASSERT(mir_is_bool(mu, dir), "dir type is not bool"); return result; } void mir_build_jump(mir_unit_t *mu, mir_block_t target) { mir_build_1(mu, MIR_OP_JUMP, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_cast_value(target)); MIR_ASSERT(!mir_is_null(target), "invalid jump target"); } void mir_build_cond(mir_unit_t *mu, mir_value_t test, mir_block_t btrue, mir_block_t bfalse) { int64_t tconst; if (mir_get_const(mu, test, &tconst)) { mir_build_jump(mu, !!tconst ? btrue : bfalse); return; } mir_build_3(mu, MIR_OP_COND, MIR_NULL_TYPE, MIR_NULL_STAMP, test, mir_cast_value(btrue), mir_cast_value(bfalse)); MIR_ASSERT(mir_is_bool(mu, test), "cond test is not a bool"); MIR_ASSERT(!mir_is_null(btrue) && !mir_is_null(bfalse), "invalid cond targets"); } mir_value_t mir_build_select(mir_unit_t *mu, mir_type_t type, mir_value_t test, mir_value_t vtrue, mir_value_t vfalse) { int64_t tconst; if (mir_get_const(mu, test, &tconst)) return tconst ? vtrue : vfalse; else if (mir_equals(vtrue, vfalse)) return vtrue; mir_stamp_t s_true = mir_get_stamp(mu, vtrue); mir_stamp_t s_false = mir_get_stamp(mu, vfalse); mir_stamp_t stamp = mir_stamp_union(mu, s_true, s_false); mir_value_t result = mir_build_3(mu, MIR_OP_SELECT, type, stamp, test, vtrue, vfalse); MIR_ASSERT(mir_is_bool(mu, test), "select test is not a bool"); MIR_ASSERT(mir_check_type(mu, vtrue, type), "true argument to select is not expected type"); MIR_ASSERT(mir_check_type(mu, vfalse, type), "false argument to select is not expected type"); return result; } mir_value_t mir_build_phi(mir_unit_t *mu, mir_type_t type, unsigned ninputs) { node_data_t *n = mir_add_node(mu, MIR_OP_PHI, type, MIR_NULL_STAMP, ninputs * 2); for (int i = 0; i < ninputs; i++) mir_set_arg(mu, n, i, MIR_NULL_VALUE); return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } void mir_set_input(mir_unit_t *mu, mir_value_t phi, unsigned nth, mir_block_t block, mir_value_t value) { node_data_t *n = mir_node_data(mu, phi); assert(n->op == MIR_OP_PHI); assert(nth * 2 < n->nargs); mir_set_arg(mu, n, nth * 2, mir_cast_value(block)); mir_set_arg(mu, n, nth * 2 + 1, value); n->stamp = mir_stamp_union(mu, n->stamp, mir_get_stamp(mu, value)); MIR_ASSERT(mir_equals(n->type, mir_get_type(mu, value)), "phi input %d has wrong type", nth); #ifdef DEBUG if (value.tag != MIR_TAG_CONST) { const block_data_t *bd = mir_block_data(mu, block); for (int i = 0; i < bd->num_nodes; i++) { if (bd->nodes[i] == value.id) return; } MIR_ASSERT(false, "phi input %d not in block %d", nth, block.id); } #endif } void mir_build_case(mir_unit_t *mu, mir_value_t value, mir_block_t def, const mir_value_t *cases, const mir_block_t *blocks, int ncases) { int64_t cval; if (mir_get_const(mu, value, &cval)) { for (int i = 0; i < ncases; i++) { int64_t cmp; if (mir_get_const(mu, cases[i], &cmp) && cmp == cval) { mir_build_jump(mu, blocks[i]); return; } } mir_build_jump(mu, def); return; } node_data_t *n = mir_add_node(mu, MIR_OP_CASE, MIR_NULL_TYPE, MIR_NULL_STAMP, (ncases + 1) * 2); mir_set_arg(mu, n, 0, value); mir_set_arg(mu, n, 1, mir_cast_value(def)); for (int i = 0; i < ncases; i++) { mir_set_arg(mu, n, (i + 1) * 2, cases[i]); mir_set_arg(mu, n, (i + 1) * 2 + 1, mir_cast_value(blocks[i])); } MIR_ASSERT(mir_is_integral(mu, value), "case choice must be integral"); #ifdef DEBUG mir_type_t type = mir_get_type(mu, value); for (int i = 0; i < ncases; i++) { MIR_ASSERT(mir_is_const(mu, cases[i]), "case choice is not constant"); MIR_ASSERT(mir_same_type(mu, mir_get_type(mu, cases[i]), type), "choice and value types do not match"); for (int j = 0; j < i; j++) MIR_ASSERT(!mir_equals(cases[i], cases[j]), "duplicate case choice"); } #endif } void mir_build_return(mir_unit_t *mu, mir_value_t value) { if (mir_is_null(value)) mir_add_node(mu, MIR_OP_RETURN, MIR_NULL_TYPE, MIR_NULL_STAMP, 0); else mir_build_1(mu, MIR_OP_RETURN, MIR_NULL_TYPE, MIR_NULL_STAMP, value); MIR_ASSERT(mir_is_null(mu->result) || mir_check_type(mu, value, mu->result), "wrong result type"); MIR_ASSERT(!mir_is_null(mu->result) || mu->kind == MIR_UNIT_PROPERTY || mir_is_null(value), "cannot return a result"); } void mir_build_wait(mir_unit_t *mu, mir_block_t target, mir_value_t time) { if (mir_is_null(time)) mir_build_1(mu, MIR_OP_WAIT, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_cast_value(target)); else mir_build_2(mu, MIR_OP_WAIT, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_cast_value(target), time); MIR_ASSERT(mir_is_null(time) || mir_is_time(mu, time), "time argument to wait is not a time"); MIR_ASSERT(mu->kind == MIR_UNIT_PROCEDURE || mu->kind == MIR_UNIT_PROCESS, "wait only allowed in process or procedure"); } void mir_build_consume(mir_unit_t *mu, mir_value_t value) { if (value.tag != MIR_TAG_NODE) return; // Only useful for keeping nodes alive mir_build_1(mu, MIR_OP_CONSUME, MIR_NULL_TYPE, MIR_NULL_STAMP, value); } mir_value_t mir_build_fcall(mir_unit_t *mu, ident_t name, mir_type_t type, mir_stamp_t stamp, const mir_value_t *args, unsigned nargs) { node_data_t *n = mir_add_node(mu, MIR_OP_FCALL, type, stamp, nargs + 1); mir_set_arg(mu, n, 0, mir_add_linkage(mu, name)); for (int i = 0; i < nargs; i++) mir_set_arg(mu, n, i + 1, args[i]); if (mir_is_null(type)) return MIR_NULL_VALUE; else return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } void mir_build_pcall(mir_unit_t *mu, ident_t name, mir_block_t resume, const mir_value_t *args, unsigned nargs) { node_data_t *n = mir_add_node(mu, MIR_OP_PCALL, MIR_NULL_TYPE, MIR_NULL_STAMP, nargs + 2); mir_set_arg(mu, n, 0, mir_cast_value(resume)); mir_set_arg(mu, n, 1, mir_add_linkage(mu, name)); for (int i = 0; i < nargs; i++) mir_set_arg(mu, n, i + 2, args[i]); MIR_ASSERT(nargs > 0 && mir_is(mu, args[0], MIR_TYPE_CONTEXT), "first argument to VHDL procedure must be context pointer"); } void mir_build_resume(mir_unit_t *mu, ident_t name) { mir_value_t link = mir_add_linkage(mu, name); mir_build_1(mu, MIR_OP_RESUME, MIR_NULL_TYPE, MIR_NULL_STAMP, link); MIR_ASSERT(mir_count_nodes(mu, mu->cursor.block) == 1, "resume must be first op in a block"); } mir_value_t mir_build_syscall(mir_unit_t *mu, ident_t func, mir_type_t type, mir_stamp_t stamp, mir_value_t locus, const mir_value_t *args, int nargs) { node_data_t *n = mir_add_node(mu, MIR_OP_SYSCALL, type, stamp, nargs + 2); mir_set_arg(mu, n, 0, mir_add_linkage(mu, func)); mir_set_arg(mu, n, 1, locus); for (int i = 0; i < nargs; i++) mir_set_arg(mu, n, i + 2, args[i]); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to syscall must be a debug locus"); for (int i = 0; i < nargs; i++) MIR_ASSERT(!mir_is_null(args[i]), "invalid argument to syscall"); if (mir_is_null(type)) return MIR_NULL_VALUE; else return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } void mir_build_unreachable(mir_unit_t *mu, mir_value_t locus) { if (mir_is_null(locus)) mir_build_0(mu, MIR_OP_UNREACHABLE, MIR_NULL_TYPE, MIR_NULL_STAMP); else mir_build_1(mu, MIR_OP_UNREACHABLE, MIR_NULL_TYPE, MIR_NULL_STAMP, locus); MIR_ASSERT(mir_is_null(locus) || mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to unreachable must be debug locus"); } static void mir_build_bounds_op(mir_unit_t *mu, mir_op_t op, mir_value_t value, mir_value_t left, mir_value_t right, mir_value_t dir, mir_value_t locus, mir_value_t hint) { // TODO: check if can elide bounds mir_build_6(mu, op, MIR_NULL_TYPE, MIR_NULL_STAMP, value, left, right, dir, locus, hint); } void mir_build_range_check(mir_unit_t *mu, mir_value_t value, mir_value_t left, mir_value_t right, mir_value_t dir, mir_value_t locus, mir_value_t hint) { mir_build_bounds_op(mu, MIR_OP_RANGE_CHECK, value, left, right, dir, locus, hint); } void mir_build_index_check(mir_unit_t *mu, mir_value_t value, mir_value_t left, mir_value_t right, mir_value_t dir, mir_value_t locus, mir_value_t hint) { mir_build_bounds_op(mu, MIR_OP_INDEX_CHECK, value, left, right, dir, locus, hint); } void mir_build_dir_check(mir_unit_t *mu, mir_value_t value, mir_value_t dir, mir_value_t locus) { if (mir_equals(value, dir)) { mir_comment(mu, "Elided direction check"); return; } mir_build_3(mu, MIR_OP_DIR_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, value, dir, locus); MIR_ASSERT(mir_check_type(mu, value, mir_bool_type(mu)), "null check argument must be a bool"); MIR_ASSERT(mir_check_type(mu, dir, mir_bool_type(mu)), "null check direction must be a bool"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to null check must be a debug locus"); } void mir_build_null_check(mir_unit_t *mu, mir_value_t ptr, mir_value_t locus) { mir_build_2(mu, MIR_OP_NULL_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, ptr, locus); MIR_ASSERT(mir_is(mu, ptr, MIR_TYPE_ACCESS), "null check argument must be an access"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to null check must be a debug locus"); } void mir_build_zero_check(mir_unit_t *mu, mir_value_t value, mir_value_t locus) { int64_t cval; if (mir_get_const(mu, value, &cval) && cval != 0) return; mir_build_2(mu, MIR_OP_ZERO_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, value, locus); MIR_ASSERT(mir_is_integral(mu, value), "argument to zero check must be integral"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to zero check must be a debug locus"); } void mir_build_length_check(mir_unit_t *mu, mir_value_t llen, mir_value_t rlen, mir_value_t locus, mir_value_t dim) { if (mir_equals(llen, rlen)) return; if (mir_is_null(dim)) mir_build_3(mu, MIR_OP_LENGTH_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, llen, rlen, locus); else mir_build_4(mu, MIR_OP_LENGTH_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, llen, rlen, locus, dim); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to length check must be a debug locus"); } void mir_build_exponent_check(mir_unit_t *mu, mir_value_t exp, mir_value_t locus) { int64_t cval; if (mir_get_const(mu, exp, &cval) && cval >= 0) return; mir_build_2(mu, MIR_OP_EXPONENT_CHECK, MIR_NULL_TYPE, MIR_NULL_STAMP, exp, locus); MIR_ASSERT(mir_is_integral(mu, exp), "exp argument to exponent check must be a integer"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to exponent check must be a debug locus"); } void mir_build_file_open(mir_unit_t *mu, mir_value_t file, mir_value_t name, mir_value_t length, mir_value_t kind, mir_value_t status) { if (mir_is_null(status)) mir_build_4(mu, MIR_OP_FILE_OPEN, MIR_NULL_TYPE, MIR_NULL_STAMP, file, name, length, kind); else mir_build_5(mu, MIR_OP_FILE_OPEN, MIR_NULL_TYPE, MIR_NULL_STAMP, file, name, length, kind, status); MIR_ASSERT(mir_is(mu, file, MIR_TYPE_POINTER), "file open first argument must be pointer to file"); } void mir_build_file_read(mir_unit_t *mu, mir_value_t file, mir_value_t ptr, mir_value_t inlen, mir_value_t outlen) { if (mir_is_null(inlen)) mir_build_2(mu, MIR_OP_FILE_READ, MIR_NULL_TYPE, MIR_NULL_STAMP, file, ptr); else if (mir_is_null(outlen)) mir_build_3(mu, MIR_OP_FILE_READ, MIR_NULL_TYPE, MIR_NULL_STAMP, file, ptr, inlen); else mir_build_4(mu, MIR_OP_FILE_READ, MIR_NULL_TYPE, MIR_NULL_STAMP, file, ptr, inlen, outlen); MIR_ASSERT(mir_points_to(mu, file, MIR_TYPE_FILE), "file read first argument must have file pointer type"); MIR_ASSERT(mir_is(mu, file, MIR_TYPE_POINTER), "file read pointer argument must have pointer type"); MIR_ASSERT(mir_is_null(inlen) || mir_is_integral(mu, inlen), "file read inlen argument must be integral"); MIR_ASSERT(mir_is_null(outlen) || mir_is(mu, outlen, MIR_TYPE_POINTER), "file read outlen argument must have pointer type"); } void mir_build_file_write(mir_unit_t *mu, mir_value_t file, mir_value_t value, mir_value_t length) { if (mir_is_null(length)) mir_build_2(mu, MIR_OP_FILE_WRITE, MIR_NULL_TYPE, MIR_NULL_STAMP, file, value); else mir_build_3(mu, MIR_OP_FILE_WRITE, MIR_NULL_TYPE, MIR_NULL_STAMP, file, value, length); MIR_ASSERT(mir_points_to(mu, file, MIR_TYPE_FILE), "file write first argument must have file pointer type"); } mir_value_t mir_build_port_conversion(mir_unit_t *mu, mir_value_t driving, mir_value_t effective) { mir_type_t type = mir_conversion_type(mu); mir_value_t result; if (mir_is_null(effective) || mir_equals(effective, driving)) result = mir_build_1(mu, MIR_OP_PORT_CONVERSION, type, MIR_NULL_STAMP, driving); else result = mir_build_2(mu, MIR_OP_PORT_CONVERSION, type, MIR_NULL_STAMP, driving, effective); MIR_ASSERT(mir_is(mu, driving, MIR_TYPE_CLOSURE), "port conversion argument must be a closure"); MIR_ASSERT(mir_is_null(effective) || mir_is(mu, effective, MIR_TYPE_CLOSURE), "port conversion argument must be a closure"); return result; } void mir_build_convert_in(mir_unit_t *mu, mir_value_t conv, mir_value_t nets, mir_value_t count) { mir_build_3(mu, MIR_OP_CONVERT_IN, MIR_NULL_TYPE, MIR_NULL_STAMP, conv, nets, count); MIR_ASSERT(mir_is(mu, conv, MIR_TYPE_CONVERSION), "conv argument to convert must be a port conversion"); MIR_ASSERT(mir_is_signal(mu, nets), "nets argument to convert must be a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument to convert must be offset"); } void mir_build_convert_out(mir_unit_t *mu, mir_value_t conv, mir_value_t nets, mir_value_t count) { mir_build_3(mu, MIR_OP_CONVERT_OUT, MIR_NULL_TYPE, MIR_NULL_STAMP, conv, nets, count); MIR_ASSERT(mir_is(mu, conv, MIR_TYPE_CONVERSION), "conv argument to convert must be a port conversion"); MIR_ASSERT(mir_is_signal(mu, nets), "nets argument to convert must be a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument to convert must be offset"); } void mir_build_put_conversion(mir_unit_t *mu, mir_value_t cf, mir_value_t target, mir_value_t count, mir_value_t values) { mir_build_4(mu, MIR_OP_PUT_CONVERSION, MIR_NULL_TYPE, MIR_NULL_STAMP, cf, target, count, values); MIR_ASSERT(mir_is_signal(mu, target), "put conversion target is not signal"); MIR_ASSERT(mir_is_offset(mu, count), "put conversion net count is not offset type"); MIR_ASSERT(!mir_is_signal(mu, values), "signal cannot be values argument for put conversion"); MIR_ASSERT(mir_is(mu, cf, MIR_TYPE_CONVERSION), "cf argument to put conversion must be conversion function"); } mir_value_t mir_build_init_signal(mir_unit_t *mu, mir_type_t type, mir_value_t count, mir_value_t size, mir_value_t value, mir_value_t flags, mir_value_t locus, mir_value_t offset) { mir_type_t stype = mir_signal_type(mu, type); mir_value_t result; if (mir_is_null(offset)) result = mir_build_5(mu, MIR_OP_INIT_SIGNAL, stype, MIR_NULL_STAMP, count, size, value, flags, locus); else result = mir_build_6(mu, MIR_OP_INIT_SIGNAL, stype, MIR_NULL_STAMP, count, size, value, flags, locus, offset); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_INT || mir_get_class(mu, type) == MIR_TYPE_REAL, "signal must have integer or real type"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); MIR_ASSERT(mir_is_offset(mu, size), "size argument must be offset"); MIR_ASSERT(mir_is_offset(mu, flags), "flags argument must be offset"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to init signal is not debug locus"); MIR_ASSERT(mir_is_null(offset) || mir_is(mu, offset, MIR_TYPE_POINTER), "offset argument must be pointer or null"); return result; } mir_value_t mir_build_implicit_signal(mir_unit_t *mu, mir_type_t type, mir_value_t count, mir_value_t size, mir_value_t locus, mir_value_t kind, mir_value_t closure, mir_value_t delay) { mir_type_t stype = mir_signal_type(mu, type); mir_value_t result = mir_build_6(mu, MIR_OP_IMPLICIT_SIGNAL, stype, MIR_NULL_STAMP, count, size, locus, kind, closure, delay); MIR_ASSERT(mir_is_offset(mu, count), "count argument to implicit signal is not offset"); MIR_ASSERT(mir_is_offset(mu, kind), // XXX: should be enum "kind argument to implicit signal is not offset"); MIR_ASSERT(mir_is(mu, closure, MIR_TYPE_CLOSURE), "closure argument to implicit signal is not a closure"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to implicit signal must be a debug locus"); MIR_ASSERT(mir_is_integral(mu, delay), "delay argument to implicit signal must be time"); return result; } void mir_build_drive_signal(mir_unit_t *mu, mir_value_t target, mir_value_t count) { mir_build_2(mu, MIR_OP_DRIVE_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count); MIR_ASSERT(mir_is_signal(mu, target), "target must be signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); } void mir_build_sched_waveform(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values, mir_value_t reject, mir_value_t after) { int64_t nconst; if (mir_get_const(mu, count, &nconst) && nconst == 0) { mir_comment(mu, "Skip empty waveform"); return; } mir_build_5(mu, MIR_OP_SCHED_WAVEFORM, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count, values, reject, after); MIR_ASSERT(mir_is_signal(mu, target), "target is not a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count is not offset type"); MIR_ASSERT(!mir_is_signal(mu, values), "values cannot be signal"); } void mir_build_deposit_signal(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values) { mir_build_3(mu, MIR_OP_DEPOSIT_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count, values); MIR_ASSERT(mir_is_signal(mu, target), "deposit signal target is not signal"); MIR_ASSERT(mir_is_offset(mu, count), "deposit signal count is not offset type"); MIR_ASSERT(!mir_is_signal(mu, values), "signal cannot be values argument for deposit signal"); } mir_value_t mir_build_resolved(mir_unit_t *mu, mir_value_t signal) { mir_type_t type = mir_get_type(mu, signal); mir_type_t pointer = mir_get_pointer(mu, type); mir_stamp_t stamp = mir_get_stamp(mu, signal); mir_value_t result = mir_build_1(mu, MIR_OP_RESOLVED, pointer, stamp, signal); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_SIGNAL, "argument to resolved must be signal"); return result; } mir_value_t mir_build_last_value(mir_unit_t *mu, mir_value_t signal) { mir_type_t type = mir_get_type(mu, signal); mir_type_t pointer = mir_get_pointer(mu, type); mir_stamp_t stamp = mir_get_stamp(mu, signal); mir_value_t result = mir_build_1(mu, MIR_OP_LAST_VALUE, pointer, stamp, signal); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_SIGNAL, "argument to resolved must be signal"); return result; } mir_value_t mir_build_driving_value(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { mir_type_t type = mir_get_pointer(mu, mir_get_type(mu, signal)); mir_stamp_t stamp = mir_get_stamp(mu, signal); mir_value_t result; if (mir_is_null(count)) result = mir_build_1(mu, MIR_OP_DRIVING_VALUE, type, stamp, signal); else result = mir_build_2(mu, MIR_OP_DRIVING_VALUE, type, stamp, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "argument must have signal type"); MIR_ASSERT(mir_is_null(count) || mir_is_offset(mu, count), "count argument must have offset type"); return result; } void mir_build_force(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values) { mir_build_3(mu, MIR_OP_FORCE, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count, values); MIR_ASSERT(mir_is_signal(mu, target), "force target is not signal"); MIR_ASSERT(mir_is_offset(mu, count), "force count is not offset type"); } void mir_build_release(mir_unit_t *mu, mir_value_t target, mir_value_t count) { mir_build_2(mu, MIR_OP_RELEASE, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count); MIR_ASSERT(mir_is_signal(mu, target), "release target is not signal"); MIR_ASSERT(mir_is_offset(mu, count), "release net count is not offset type"); } void mir_build_disconnect(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t reject, mir_value_t after) { mir_build_4(mu, MIR_OP_DISCONNECT, MIR_NULL_TYPE, MIR_NULL_STAMP, target, count, reject, after); MIR_ASSERT(mir_is_signal(mu, target), "disconnect target is not signal"); MIR_ASSERT(mir_is_offset(mu, count), "disconnect count is not offset type"); } mir_value_t mir_build_last_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { mir_type_t type = mir_time_type(mu); mir_value_t result; if (mir_is_null(count)) result = mir_build_1(mu, MIR_OP_LAST_EVENT, type, MIR_NULL_STAMP, signal); else result = mir_build_2(mu, MIR_OP_LAST_EVENT, type, MIR_NULL_STAMP, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "signal argument to last event must have signal type"); MIR_ASSERT(mir_is_null(count) || mir_is_offset(mu, count), "length argument to last event must have offset type"); return result; } mir_value_t mir_build_last_active(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { mir_type_t type = mir_time_type(mu); mir_value_t result; if (mir_is_null(count)) result = mir_build_1(mu, MIR_OP_LAST_ACTIVE, type, MIR_NULL_STAMP, signal); else result = mir_build_2(mu, MIR_OP_LAST_ACTIVE, type, MIR_NULL_STAMP, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "signal argument to last event must have signal type"); MIR_ASSERT(mir_is_null(count) || mir_is_offset(mu, count), "length argument to last event must have offset type"); return result; } static mir_value_t mir_build_signal_flag(mir_unit_t *mu, mir_op_t op, mir_value_t signal, mir_value_t count) { mir_type_t t_bool = mir_bool_type(mu); mir_value_t result = mir_build_2(mu, op, t_bool, MIR_NULL_STAMP, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "signal argument must be signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); return result; } mir_value_t mir_build_event_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { return mir_build_signal_flag(mu, MIR_OP_EVENT, signal, count); } mir_value_t mir_build_active_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { return mir_build_signal_flag(mu, MIR_OP_ACTIVE, signal, count); } mir_value_t mir_build_driving_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { return mir_build_signal_flag(mu, MIR_OP_DRIVING, signal, count); } void mir_build_resolve_signal(mir_unit_t *mu, mir_value_t signal, mir_value_t resolution) { mir_build_2(mu, MIR_OP_RESOLVE_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, resolution); MIR_ASSERT(mir_is_signal(mu, signal), "signal argument has wrong type"); MIR_ASSERT(mir_points_to(mu, resolution, MIR_TYPE_RESOLUTION), "resolution wrapper argument has wrong type"); } void mir_build_transfer_signal(mir_unit_t *mu, mir_value_t target, mir_value_t source, mir_value_t count, mir_value_t reject, mir_value_t after) { mir_build_5(mu, MIR_OP_TRANSFER_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, target, source, count, reject, after); MIR_ASSERT(mir_is_signal(mu, target), "target is not a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); MIR_ASSERT(mir_is_signal(mu, source), "source is not a signal"); } void mir_build_cover_stmt(mir_unit_t *mu, uint32_t tag) { mir_build_1(mu, MIR_OP_COVER_STMT, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_enum(tag)); } void mir_build_cover_branch(mir_unit_t *mu, uint32_t tag) { mir_build_1(mu, MIR_OP_COVER_BRANCH, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_enum(tag)); } void mir_build_cover_expr(mir_unit_t *mu, uint32_t tag) { mir_build_1(mu, MIR_OP_COVER_EXPR, MIR_NULL_TYPE, MIR_NULL_STAMP, mir_enum(tag)); } void mir_build_cover_toggle(mir_unit_t *mu, mir_value_t signal, uint32_t tag) { mir_build_2(mu, MIR_OP_COVER_TOGGLE, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, mir_enum(tag)); MIR_ASSERT(mir_is_signal(mu, signal), "argument to cover toggle must be signal"); } void mir_build_cover_state(mir_unit_t *mu, mir_value_t signal, mir_value_t low, uint32_t tag) { mir_build_3(mu, MIR_OP_COVER_STATE, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, low, mir_enum(tag)); MIR_ASSERT(mir_is_signal(mu, signal), "argument to cover state must be signal"); } mir_value_t mir_build_package_init(mir_unit_t *mu, ident_t name, mir_value_t context) { mir_value_t link = mir_add_linkage(mu, name); mir_type_t type = mir_context_type(mu, name); mir_value_t result; if (mir_is_null(context)) result = mir_build_1(mu, MIR_OP_PACKAGE_INIT, type, MIR_NULL_STAMP, link); else result = mir_build_2(mu, MIR_OP_PACKAGE_INIT, type, MIR_NULL_STAMP, link, context); MIR_ASSERT(mir_is_null(context) || mir_is(mu, context, MIR_TYPE_CONTEXT), "invalid package init context argument"); MIR_ASSERT(mu->kind == MIR_UNIT_INSTANCE || mu->kind == MIR_UNIT_PACKAGE || mu->kind == MIR_UNIT_THUNK, "cannot use package init here"); MIR_ASSERT(name != mu->name, "cyclic package init"); return result; } void mir_build_process_init(mir_unit_t *mu, ident_t name, mir_value_t locus) { mir_value_t link = mir_add_linkage(mu, name); mir_build_2(mu, MIR_OP_PROCESS_INIT, MIR_NULL_TYPE, MIR_NULL_STAMP, link, locus); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to process init must be a debug locus"); } mir_value_t mir_build_protected_init(mir_unit_t *mu, mir_type_t type, mir_value_t context, mir_value_t path_name, mir_value_t inst_name) { mir_value_t link = mir_add_linkage(mu, mir_type_data(mu, type)->u.context); mir_value_t result; if (mir_is_null(path_name) && mir_is_null(inst_name)) result = mir_build_2(mu, MIR_OP_PROTECTED_INIT, type, MIR_NULL_STAMP, link, context); else { result = mir_build_4(mu, MIR_OP_PROTECTED_INIT, type, MIR_NULL_STAMP, link, context, path_name, inst_name); MIR_ASSERT(mir_is(mu, path_name, MIR_TYPE_UARRAY), "path name argument must be array"); MIR_ASSERT(mir_is(mu, inst_name, MIR_TYPE_UARRAY), "inst name argument must be array"); } MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_CONTEXT, "protected init type must be context"); MIR_ASSERT(mir_is(mu, context, MIR_TYPE_CONTEXT), "invalid protected init context argument"); return result; } void mir_build_record_scope(mir_unit_t *mu, mir_value_t locus, mir_type_t type) { mir_build_1(mu, MIR_OP_RECORD_SCOPE, type, MIR_NULL_STAMP, locus); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to record scope must be a debug locus"); MIR_ASSERT(mir_get_class(mu, type) == MIR_TYPE_RECORD, "record scope type must be record"); } void mir_build_array_scope(mir_unit_t *mu, mir_value_t locus, mir_type_t type) { mir_build_1(mu, MIR_OP_ARRAY_SCOPE, type, MIR_NULL_STAMP, locus); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to array scope must be a debug locus"); } void mir_build_package_scope(mir_unit_t *mu, mir_value_t locus) { mir_build_1(mu, MIR_OP_PACKAGE_SCOPE, MIR_NULL_TYPE, MIR_NULL_STAMP, locus); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to package scope must be a debug locus"); } void mir_build_pop_scope(mir_unit_t *mu) { mir_build_0(mu, MIR_OP_POP_SCOPE, MIR_NULL_TYPE, MIR_NULL_STAMP); } void mir_build_alias_signal(mir_unit_t *mu, mir_value_t signal, mir_value_t locus) { mir_build_2(mu, MIR_OP_ALIAS_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, locus); MIR_ASSERT(mir_is_signal(mu, signal), "argument must have signal type"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument must have debug locus type"); } void mir_build_map_signal(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count) { mir_build_3(mu, MIR_OP_MAP_SIGNAL, MIR_NULL_TYPE, MIR_NULL_STAMP, src, dst, count); MIR_ASSERT(mir_is_signal(mu, src), "src argument to map signal is not a signal"); MIR_ASSERT(mir_is_signal(mu, dst), "dst argument to map signal is not a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument to map signal is not offset type"); } void mir_build_map_const(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count) { mir_build_3(mu, MIR_OP_MAP_CONST, MIR_NULL_TYPE, MIR_NULL_STAMP, src, dst, count); MIR_ASSERT(mir_is_signal(mu, dst), "dst argument to map const is not a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument to map const is not offset type"); } void mir_build_map_implicit(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count) { mir_build_3(mu, MIR_OP_MAP_IMPLICIT, MIR_NULL_TYPE, MIR_NULL_STAMP, src, dst, count); MIR_ASSERT(mir_is_signal(mu, src), "src argument to map implicit is not a signal"); MIR_ASSERT(mir_is_signal(mu, dst), "dst argument to map implicit is not a signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument type to map implicit is not offset"); } mir_value_t mir_build_cmp_trigger(mir_unit_t *mu, mir_value_t left, mir_value_t right) { mir_type_t type = mir_trigger_type(mu); mir_value_t result = mir_build_2(mu, MIR_OP_CMP_TRIGGER, type, MIR_NULL_STAMP, left, right); MIR_ASSERT(mir_is_signal(mu, left), "cmp trigger left argument must be signal"); MIR_ASSERT(mir_is_integral(mu, right), "cmp trigger right argument must be integer"); return result; } mir_value_t mir_build_function_trigger(mir_unit_t *mu, ident_t name, const mir_value_t *args, unsigned nargs) { mir_type_t type = mir_trigger_type(mu); node_data_t *n = mir_add_node(mu, MIR_OP_FUNCTION_TRIGGER, type, MIR_NULL_STAMP, nargs + 1); mir_set_arg(mu, n, 0, mir_add_linkage(mu, name)); for (int i = 0; i < nargs; i++) mir_set_arg(mu, n, i + 1, args[i]); return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_build_or_trigger(mir_unit_t *mu, mir_value_t left, mir_value_t right) { mir_type_t type = mir_trigger_type(mu); mir_value_t result = mir_build_2(mu, MIR_OP_OR_TRIGGER, type, MIR_NULL_STAMP, left, right); MIR_ASSERT(mir_is(mu, left, MIR_TYPE_TRIGGER), "or trigger left argument must be trigger"); MIR_ASSERT(mir_is(mu, right, MIR_TYPE_TRIGGER), "or trigger right argument must be trigger"); return result; } void mir_build_add_trigger(mir_unit_t *mu, mir_value_t trigger) { mir_build_1(mu, MIR_OP_ADD_TRIGGER, MIR_NULL_TYPE, MIR_NULL_STAMP, trigger); MIR_ASSERT(mir_is(mu, trigger, MIR_TYPE_TRIGGER), "add trigger argument must be trigger"); } mir_value_t mir_build_link_package(mir_unit_t *mu, ident_t name) { mir_value_t link = mir_add_linkage(mu, name); mir_type_t type = mir_context_type(mu, name); mir_value_t result = mir_build_1(mu, MIR_OP_LINK_PACKAGE, type, MIR_NULL_STAMP, link); MIR_ASSERT(name != mu->name, "cannot link the current unit"); return result; } mir_value_t mir_build_link_var(mir_unit_t *mu, ident_t unit, mir_value_t context, ident_t name, mir_type_t type) { mir_type_t pointer = mir_get_var_pointer(mu, type); mir_value_t link = mir_add_linkage(mu, unit); mir_value_t var = mir_add_extvar(mu, name); mir_value_t result = mir_build_3(mu, MIR_OP_LINK_VAR, pointer, MIR_NULL_STAMP, link, context, var); MIR_ASSERT(mir_is(mu, context, MIR_TYPE_CONTEXT), "first argument to link var must be context"); return result; } void mir_build_bind_foreign(mir_unit_t *mu, mir_value_t spec, mir_value_t length, mir_value_t locus) { if (mir_is_null(locus)) mir_build_2(mu, MIR_OP_BIND_FOREIGN, MIR_NULL_TYPE, MIR_NULL_STAMP, spec, length); else mir_build_3(mu, MIR_OP_BIND_FOREIGN, MIR_NULL_TYPE, MIR_NULL_STAMP, spec, length, locus); MIR_ASSERT(mir_is(mu, spec, MIR_TYPE_POINTER), "spec argument to bind foreign must be a pointer"); MIR_ASSERT(mir_is_offset(mu, length), "legnth argument to bind foreign must be offset"); MIR_ASSERT(mir_is_null(locus) || mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to bind foreign value must be a debug locus"); } mir_value_t mir_build_bind_external(mir_unit_t *mu, mir_value_t locus, ident_t scope, mir_type_t type, mir_stamp_t stamp) { mir_type_t pointer = mir_get_var_pointer(mu, type); mir_value_t link = mir_add_linkage(mu, scope); mir_value_t result = mir_build_2(mu, MIR_OP_BIND_EXTERNAL, pointer, stamp, locus, link); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "bind external argument must be locus"); return result; } mir_value_t mir_build_context_upref(mir_unit_t *mu, int hops) { mir_type_t type = MIR_NULL_TYPE; if (hops == 0) type = mir_self_type(mu); else { mir_shape_t *s = mu->parent; for (int i = 1; s != NULL && i < hops; i++, s = s->parent); if (s != NULL) type = s->type; } mir_value_t result = mir_build_1(mu, MIR_OP_CONTEXT_UPREF, type, MIR_NULL_STAMP, mir_enum(hops)); MIR_ASSERT(hops >= 0, "invalid hop count"); MIR_ASSERT(!mir_is_null(type), "hop count is greater than depth"); return result; } mir_value_t mir_build_var_upref(mir_unit_t *mu, int hops, int nth) { mir_type_t type = MIR_NULL_TYPE; mir_value_t link = MIR_NULL_VALUE; mir_shape_t *s = mu->parent; for (int i = 1; s != NULL && i < hops; i++, s = s->parent); if (s != NULL && nth >= 0 && nth < s->num_slots) { type = s->slots[nth].pointer; link = mir_add_linkage(mu, s->name); } mir_value_t result = mir_build_3(mu, MIR_OP_VAR_UPREF, type, MIR_NULL_STAMP, mir_enum(hops), link, mir_enum(nth)); MIR_ASSERT(hops > 0, "invalid hop count"); MIR_ASSERT(!mir_is_null(type), "invalid variable reference"); return result; } void mir_build_sched_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { mir_build_2(mu, MIR_OP_SCHED_EVENT, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "argument must be signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); } void mir_build_clear_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count) { mir_build_2(mu, MIR_OP_CLEAR_EVENT, MIR_NULL_TYPE, MIR_NULL_STAMP, signal, count); MIR_ASSERT(mir_is_signal(mu, signal), "argument must be signal"); MIR_ASSERT(mir_is_offset(mu, count), "count argument must be offset"); } mir_value_t mir_build_reflect_value(mir_unit_t *mu, mir_value_t value, mir_value_t context, mir_value_t locus, mir_value_t bounds) { mir_type_t type = mir_access_type(mu, mir_opaque_type(mu)); mir_value_t result; if (mir_is_null(bounds)) result = mir_build_3(mu, MIR_OP_REFLECT_VALUE, type, MIR_NULL_STAMP, value, context, locus); else result = mir_build_4(mu, MIR_OP_REFLECT_VALUE, type, MIR_NULL_STAMP, value, context, locus, bounds); MIR_ASSERT(mir_is(mu, context, MIR_TYPE_CONTEXT), "invalid reflect value context argument"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to reflect value must be a debug locus"); return result; } mir_value_t mir_build_reflect_subtype(mir_unit_t *mu, mir_value_t context, mir_value_t locus, mir_value_t bounds) { mir_type_t type = mir_access_type(mu, mir_opaque_type(mu)); mir_value_t result; if (mir_is_null(bounds)) result = mir_build_2(mu, MIR_OP_REFLECT_SUBTYPE, type, MIR_NULL_STAMP, context, locus); else result = mir_build_3(mu, MIR_OP_REFLECT_SUBTYPE, type, MIR_NULL_STAMP, context, locus, bounds); MIR_ASSERT(mir_is(mu, context, MIR_TYPE_CONTEXT), "invalid reflect subtype context argument"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to reflect subtype must be a debug locus"); return result; } void mir_build_assert(mir_unit_t *mu, mir_value_t value, mir_value_t message, mir_value_t length, mir_value_t severity, mir_value_t locus, mir_value_t hint_left, mir_value_t hint_right) { int64_t value_const; if (mir_get_const(mu, value, &value_const) && value_const != 0) { mir_comment(mu, "Always true assertion"); return; } if (mir_is_null(hint_left)) mir_build_5(mu, MIR_OP_ASSERT, MIR_NULL_TYPE, MIR_NULL_STAMP, value, severity, message, length, locus); else { node_data_t *n = mir_add_node(mu, MIR_OP_ASSERT, MIR_NULL_TYPE, MIR_NULL_STAMP, 7); mir_set_arg(mu, n, 0, value); mir_set_arg(mu, n, 1, severity); mir_set_arg(mu, n, 2, message); mir_set_arg(mu, n, 3, length); mir_set_arg(mu, n, 4, locus); mir_set_arg(mu, n, 5, hint_left); mir_set_arg(mu, n, 6, hint_right); MIR_ASSERT(mir_is_scalar(mu, hint_left), "left hint must be scalar"); MIR_ASSERT(mir_is_scalar(mu, hint_right), "right hint must be scalar"); } MIR_ASSERT(mir_is_bool(mu, value), "value parameter to assert is not bool"); MIR_ASSERT(mir_is_null(message) || mir_is(mu, message, MIR_TYPE_POINTER), "message parameter to assert is not a pointer"); MIR_ASSERT(mir_is_bool(mu, value), "value parameter to assert is not bool"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to report must be a debug locus"); } void mir_build_report(mir_unit_t *mu, mir_value_t message, mir_value_t length, mir_value_t severity, mir_value_t locus) { mir_build_4(mu, MIR_OP_REPORT, MIR_NULL_TYPE, MIR_NULL_STAMP, severity, message, length, locus); MIR_ASSERT(mir_is(mu, message, MIR_TYPE_POINTER), "message parameter to report is not a pointer"); MIR_ASSERT(mir_is_offset(mu, length), "length argument must be offset type"); MIR_ASSERT(mir_is(mu, locus, MIR_TYPE_LOCUS), "locus argument to report must be a debug locus"); } mir_value_t mir_build_instance_name(mir_unit_t *mu, mir_value_t kind) { mir_type_t type = mir_string_type(mu); mir_value_t result = mir_build_1(mu, MIR_OP_INSTANCE_NAME, type, MIR_NULL_STAMP, kind); MIR_ASSERT(mir_is_offset(mu, kind), "kind argument to instance name must be offset"); return result; } void mir_build_enter_state(mir_unit_t *mu, mir_value_t state, mir_value_t strong) { if (mir_is_null(strong)) mir_build_1(mu, MIR_OP_ENTER_STATE, MIR_NULL_TYPE, MIR_NULL_STAMP, state); else mir_build_2(mu, MIR_OP_ENTER_STATE, MIR_NULL_TYPE, MIR_NULL_STAMP, state, strong); MIR_ASSERT(mir_is_integral(mu, state), "state must have integer type"); MIR_ASSERT(mir_is_null(strong) || mir_check_type(mu, strong, mir_bool_type(mu)), "strong argument not is not boolean"); } mir_value_t mir_build_closure(mir_unit_t *mu, ident_t func, mir_value_t context, mir_type_t atype, mir_type_t rtype) { mir_type_t ctype = mir_closure_type(mu, atype, rtype); mir_value_t link = mir_add_linkage(mu, func); mir_value_t result = mir_build_2(mu, MIR_OP_CLOSURE, ctype, MIR_NULL_STAMP, link, context); MIR_ASSERT(mir_is(mu, context, MIR_TYPE_CONTEXT), "invalid closure context argument"); return result; } mir_value_t mir_build_resolution_wrapper(mir_unit_t *mu, mir_type_t type, mir_value_t closure, mir_value_t nlits) { mir_type_t rtype = mir_resolution_type(mu, type); mir_value_t result = mir_build_2(mu, MIR_OP_RESOLUTION_WRAPPER, rtype, MIR_NULL_STAMP, closure, nlits); MIR_ASSERT(mir_is(mu, closure, MIR_TYPE_CLOSURE), "first argument to resolution wrapper must be closure"); return result; } mir_value_t mir_build_locus(mir_unit_t *mu, object_t *obj) { node_data_t *n = mir_add_node(mu, MIR_OP_LOCUS, mir_locus_type(mu), MIR_NULL_STAMP, 0); n->locus = obj; return (mir_value_t){ .tag = MIR_TAG_NODE, .id = mir_node_id(mu, n) }; } mir_value_t mir_build_cast(mir_unit_t *mu, mir_type_t type, mir_value_t value) { mir_type_t from = mir_get_type(mu, value); if (mir_equals(from, type)) return value; const mir_class_t class = mir_get_class(mu, type); const bool integral = (class == MIR_TYPE_OFFSET || class == MIR_TYPE_INT); int64_t cval; if (integral && mir_get_const(mu, value, &cval)) return mir_const(mu, type, cval); if (class == MIR_TYPE_VEC2 || class == MIR_TYPE_VEC4) { node_data_t *n = mir_node_data(mu, value); if (n->op == MIR_OP_CONST_VEC) { const uint64_t bbits = (class == MIR_TYPE_VEC2 ? 0 : n->bits[1]); return mir_const_vec(mu, type, n->bits[0], bbits); } } else if (integral && mir_is_vector(mu, value)) { node_data_t *n = mir_node_data(mu, value); if (n->op == MIR_OP_CONST_VEC) { MIR_ASSERT(n->bits[1] == 0, "X value in integral cast"); return mir_const(mu, type, n->bits[0]); } } mir_stamp_t stamp = mir_stamp_cast(mu, type, mir_get_stamp(mu, value)); mir_value_t result = mir_build_1(mu, MIR_OP_CAST, type, stamp, value); #ifdef DEBUG static const mir_class_t allowed[][2] = { { MIR_TYPE_INT, MIR_TYPE_OFFSET }, { MIR_TYPE_OFFSET, MIR_TYPE_INT }, { MIR_TYPE_INT, MIR_TYPE_INT }, { MIR_TYPE_INT, MIR_TYPE_REAL }, { MIR_TYPE_REAL, MIR_TYPE_INT }, { MIR_TYPE_REAL, MIR_TYPE_REAL }, { MIR_TYPE_ACCESS, MIR_TYPE_ACCESS }, { MIR_TYPE_VEC4, MIR_TYPE_VEC2 }, { MIR_TYPE_VEC2, MIR_TYPE_VEC4 }, { MIR_TYPE_VEC2, MIR_TYPE_VEC2 }, { MIR_TYPE_VEC4, MIR_TYPE_VEC4 }, { MIR_TYPE_VEC2, MIR_TYPE_INT }, { MIR_TYPE_VEC2, MIR_TYPE_OFFSET }, }; if (value.tag == MIR_TAG_CONST) return result; const mir_class_t from_k = mir_get_class(mu, from); for (size_t i = 0; i < ARRAY_LEN(allowed); i++) { if (from_k == allowed[i][0] && class == allowed[i][1]) return result; } MIR_ASSERT(false, "invalid type conversion in cast"); #else return result; #endif } void mir_build_debug_out(mir_unit_t *mu, mir_value_t value) { mir_build_1(mu, MIR_OP_DEBUG_OUT, MIR_NULL_TYPE, MIR_NULL_STAMP, value); MIR_ASSERT(mir_is_integral(mu, value), "argument must be integral"); } nvc-r1.17.1/src/mir/mir-node.h000066400000000000000000000700551504111170000160070ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _MIR_NODE_H #define _MIR_NODE_H #include "prim.h" #include "diag.h" #include "util.h" #include #define MIR_TAG_NULL 0 #define MIR_TAG_BLOCK 1 #define MIR_TAG_PARAM 2 #define MIR_TAG_NODE 3 #define MIR_TAG_COMMENT 4 #define MIR_TAG_TYPE 5 #define MIR_TAG_CONST 6 #define MIR_TAG_STAMP 7 #define MIR_TAG_VAR 8 #define MIR_TAG_ENUM 9 #define MIR_TAG_LINKAGE 10 #define MIR_TAG_EXTVAR 11 #define _MIR_TAG_BITS 4 #define _MIR_ID_BITS 28 STATIC_ASSERT(_MIR_TAG_BITS + _MIR_ID_BITS == 32); #define MIR_ID_MAX ((1 << _MIR_ID_BITS) - 1) typedef union _mir_block { struct { unsigned tag : _MIR_TAG_BITS; unsigned id : _MIR_ID_BITS; }; uint32_t bits; } mir_block_t; STATIC_ASSERT(sizeof(mir_block_t) == 4); #define MIR_NULL_BLOCK ((mir_block_t){ .tag = MIR_TAG_NULL }) typedef union _mir_value { struct { unsigned tag : _MIR_TAG_BITS; unsigned id : _MIR_ID_BITS; }; uint32_t bits; } mir_value_t; STATIC_ASSERT(sizeof(mir_value_t) == 4); #define MIR_NULL_VALUE ((mir_value_t){ .tag = MIR_TAG_NULL }) typedef union { struct { unsigned tag : _MIR_TAG_BITS; unsigned id : _MIR_ID_BITS; }; uint32_t bits; } mir_type_t; STATIC_ASSERT(sizeof(mir_type_t) == 4); #define MIR_NULL_TYPE ((mir_type_t){ .tag = MIR_TAG_NULL }) typedef union { struct { unsigned tag : _MIR_TAG_BITS; unsigned id : _MIR_ID_BITS; }; uint32_t bits; } mir_stamp_t; STATIC_ASSERT(sizeof(mir_stamp_t) == 4); #define MIR_NULL_STAMP ((mir_stamp_t){ .tag = MIR_TAG_NULL }) #define mir_is_null(o) ((o).tag == MIR_TAG_NULL) #define mir_equals(a, b) ((a).bits == (b).bits) #define mir_cast_value(p) ((mir_value_t){ .bits = (p).bits }) #define mir_cast_block(p) ({ \ assert((p).tag == MIR_TAG_BLOCK); \ (mir_block_t){ .bits = (p).bits }; \ }) #define mir_cast_type(p) ({ \ assert((p).tag == MIR_TAG_TYPE); \ (mir_type_t){ .bits = (p).bits }; \ }) typedef enum { MIR_CMP_EQ, MIR_CMP_NEQ, MIR_CMP_LT, MIR_CMP_GT, MIR_CMP_LEQ, MIR_CMP_GEQ, } mir_cmp_t; typedef enum { _MIR_DELETED_OP, MIR_OP_ADD, MIR_OP_RETURN, MIR_OP_COMMENT, MIR_OP_CONST, MIR_OP_STORE, MIR_OP_LOAD, MIR_OP_CONST_REAL, MIR_OP_JUMP, MIR_OP_COND, MIR_OP_CMP, MIR_OP_PHI, MIR_OP_AND, MIR_OP_SUB, MIR_OP_MUL, MIR_OP_DIV, MIR_OP_REM, MIR_OP_MOD, MIR_OP_EXP, MIR_OP_OR, MIR_OP_XOR, MIR_OP_CONSUME, MIR_OP_FCALL, MIR_OP_PCALL, MIR_OP_RESUME, MIR_OP_WRAP, MIR_OP_UNWRAP, MIR_OP_NOT, MIR_OP_RESOLVED, MIR_OP_LAST_VALUE, MIR_OP_LOCUS, MIR_OP_INIT_SIGNAL, MIR_OP_IMPLICIT_SIGNAL, MIR_OP_SELECT, MIR_OP_WAIT, MIR_OP_LINK_PACKAGE, MIR_OP_PACKAGE_INIT, MIR_OP_PROTECTED_INIT, MIR_OP_ASSERT, MIR_OP_CONTEXT_UPREF, MIR_OP_UARRAY_LEN, MIR_OP_UARRAY_LEFT, MIR_OP_UARRAY_RIGHT, MIR_OP_UARRAY_DIR, MIR_OP_TRAP_ADD, MIR_OP_TRAP_SUB, MIR_OP_TRAP_MUL, MIR_OP_TRAP_EXP, MIR_OP_CONST_ARRAY, MIR_OP_CONST_REP, MIR_OP_CONST_RECORD, MIR_OP_CONST_VEC, MIR_OP_ADDRESS_OF, MIR_OP_ARRAY_REF, MIR_OP_VAR_UPREF, MIR_OP_DRIVE_SIGNAL, MIR_OP_SCHED_WAVEFORM, MIR_OP_EVENT, MIR_OP_ACTIVE, MIR_OP_CAST, MIR_OP_NEG, MIR_OP_TRAP_NEG, MIR_OP_ABS, MIR_OP_COPY, MIR_OP_REPORT, MIR_OP_RANGE_CHECK, MIR_OP_INDEX_CHECK, MIR_OP_SCHED_EVENT, MIR_OP_CLEAR_EVENT, MIR_OP_ALLOC, MIR_OP_RANGE_LENGTH, MIR_OP_RANGE_NULL, MIR_OP_SET, MIR_OP_NULL, MIR_OP_NEW, MIR_OP_ALL, MIR_OP_NULL_CHECK, MIR_OP_LENGTH_CHECK, MIR_OP_ZERO_CHECK, MIR_OP_EXPONENT_CHECK, MIR_OP_ALIAS_SIGNAL, MIR_OP_MAP_SIGNAL, MIR_OP_MAP_CONST, MIR_OP_MAP_IMPLICIT, MIR_OP_CASE, MIR_OP_BIND_FOREIGN, MIR_OP_BIND_EXTERNAL, MIR_OP_UNREACHABLE, MIR_OP_RECORD_REF, MIR_OP_CLOSURE, MIR_OP_RESOLUTION_WRAPPER, MIR_OP_RESOLVE_SIGNAL, MIR_OP_TRANSFER_SIGNAL, MIR_OP_FILE_OPEN, MIR_OP_FILE_READ, MIR_OP_FILE_WRITE, MIR_OP_PORT_CONVERSION, MIR_OP_CONVERT_IN, MIR_OP_CONVERT_OUT, MIR_OP_PUT_CONVERSION, MIR_OP_LINK_VAR, MIR_OP_DRIVING_VALUE, MIR_OP_FORCE, MIR_OP_RELEASE, MIR_OP_DISCONNECT, MIR_OP_PROCESS_INIT, MIR_OP_COVER_STMT, MIR_OP_COVER_BRANCH, MIR_OP_COVER_TOGGLE, MIR_OP_COVER_EXPR, MIR_OP_COVER_STATE, MIR_OP_RECORD_SCOPE, MIR_OP_ARRAY_SCOPE, MIR_OP_PACKAGE_SCOPE, MIR_OP_POP_SCOPE, MIR_OP_FUNCTION_TRIGGER, MIR_OP_OR_TRIGGER, MIR_OP_CMP_TRIGGER, MIR_OP_ADD_TRIGGER, MIR_OP_INSTANCE_NAME, MIR_OP_LAST_EVENT, MIR_OP_LAST_ACTIVE, MIR_OP_DRIVING, MIR_OP_ENTER_STATE, MIR_OP_DEPOSIT_SIGNAL, MIR_OP_SYSCALL, MIR_OP_REFLECT_VALUE, MIR_OP_REFLECT_SUBTYPE, MIR_OP_DEBUG_OUT, MIR_OP_PACK, MIR_OP_UNPACK, MIR_OP_BINARY, MIR_OP_UNARY, MIR_OP_DIR_CHECK, } mir_op_t; typedef enum { _MIR_INVALID_TYPE, MIR_TYPE_INT, MIR_TYPE_OFFSET, MIR_TYPE_POINTER, MIR_TYPE_REAL, MIR_TYPE_CARRAY, MIR_TYPE_UARRAY, MIR_TYPE_SIGNAL, MIR_TYPE_LOCUS, MIR_TYPE_CONTEXT, MIR_TYPE_CLOSURE, MIR_TYPE_RESOLUTION, MIR_TYPE_RECORD, MIR_TYPE_ACCESS, MIR_TYPE_FILE, MIR_TYPE_TRIGGER, MIR_TYPE_CONVERSION, MIR_TYPE_OPAQUE, MIR_TYPE_VEC2, MIR_TYPE_VEC4, } mir_class_t; typedef struct { mir_value_t left; mir_value_t right; mir_value_t dir; } mir_dim_t; typedef enum { MIR_VAR_TEMP = (1 << 1), MIR_VAR_HEAP = (1 << 2), MIR_VAR_CONST = (1 << 3), MIR_VAR_SIGNAL = (1 << 4) } mir_var_flags_t; typedef enum { MIR_REPR_U1, MIR_REPR_I8, MIR_REPR_U8, MIR_REPR_I16, MIR_REPR_U16, MIR_REPR_I32, MIR_REPR_U32, MIR_REPR_I64, MIR_REPR_U64, } mir_repr_t; typedef enum { MIR_MEM_NONE, MIR_MEM_CONST, MIR_MEM_STACK, MIR_MEM_LOCAL, MIR_MEM_GLOBAL, MIR_MEM_TOP, } mir_mem_t; typedef enum { MIR_VEC_BIT_AND, MIR_VEC_BIT_OR, MIR_VEC_BIT_XOR, MIR_VEC_BIT_NOT, MIR_VEC_LOG_AND, MIR_VEC_LOG_OR, MIR_VEC_LOG_NOT, MIR_VEC_LT, MIR_VEC_LEQ, MIR_VEC_GT, MIR_VEC_GEQ, MIR_VEC_LOG_EQ, MIR_VEC_LOG_NEQ, MIR_VEC_CASE_EQ, MIR_VEC_CASE_NEQ, MIR_VEC_ADD, MIR_VEC_SUB, MIR_VEC_MUL, MIR_VEC_SLL, MIR_VEC_SRL, } mir_vec_op_t; #define MIR_APPEND UINT_MAX mir_type_t mir_int_type(mir_unit_t *mu, int64_t low, int64_t high); mir_type_t mir_real_type(mir_unit_t *mu, double low, double high); mir_type_t mir_offset_type(mir_unit_t *mu); mir_type_t mir_locus_type(mir_unit_t *mu); mir_type_t mir_conversion_type(mir_unit_t *mu); mir_type_t mir_trigger_type(mir_unit_t *mu); mir_type_t mir_self_type(mir_unit_t *mu); mir_type_t mir_bool_type(mir_unit_t *mu); mir_type_t mir_time_type(mir_unit_t *mu); mir_type_t mir_logic_type(mir_unit_t *mu); mir_type_t mir_double_type(mir_unit_t *mu); mir_type_t mir_char_type(mir_unit_t *mu); mir_type_t mir_string_type(mir_unit_t *mu); mir_type_t mir_pointer_type(mir_unit_t *mu, mir_type_t to); mir_type_t mir_access_type(mir_unit_t *mu, mir_type_t to); mir_type_t mir_carray_type(mir_unit_t *mu, int size, mir_type_t elem); mir_type_t mir_uarray_type(mir_unit_t *mu, int ndim, mir_type_t elem); mir_type_t mir_signal_type(mir_unit_t *mu, mir_type_t base); mir_type_t mir_context_type(mir_unit_t *mu, ident_t name); mir_type_t mir_opaque_type(mir_unit_t *mu); mir_type_t mir_record_type(mir_unit_t *mu, ident_t name, const mir_type_t *fields, unsigned count); mir_type_t mir_closure_type(mir_unit_t *mu, mir_type_t atype, mir_type_t rtype); mir_type_t mir_resolution_type(mir_unit_t *mu, mir_type_t base); mir_type_t mir_file_type(mir_unit_t *mu, mir_type_t base); mir_type_t mir_vec2_type(mir_unit_t *mu, int size, bool issigned); mir_type_t mir_vec4_type(mir_unit_t *mu, int size, bool issigned); mir_type_t mir_get_base(mir_unit_t *mu, mir_type_t type); mir_type_t mir_get_elem(mir_unit_t *mu, mir_type_t type); mir_type_t mir_get_pointer(mir_unit_t *mu, mir_type_t type); unsigned mir_get_dims(mir_unit_t *mu, mir_type_t type); unsigned mir_get_size(mir_unit_t *mu, mir_type_t type); mir_class_t mir_get_class(mir_unit_t *mu, mir_type_t type); mir_repr_t mir_get_repr(mir_unit_t *mu, mir_type_t type); const mir_type_t *mir_get_fields(mir_unit_t *mu, mir_type_t type, size_t *count); mir_stamp_t mir_int_stamp(mir_unit_t *mu, int64_t low, int64_t high); mir_stamp_t mir_real_stamp(mir_unit_t *mu, double low, double high); mir_stamp_t mir_pointer_stamp(mir_unit_t *mu, mir_mem_t mem, mir_stamp_t elem); mir_block_t mir_add_block(mir_unit_t *mu); void mir_set_cursor(mir_unit_t *mu, mir_block_t block, unsigned pos); mir_block_t mir_get_cursor(mir_unit_t *mu, unsigned *pos); void mir_set_loc(mir_unit_t *mu, const loc_t *loc); void mir_delete(mir_unit_t *mu); void mir_compact(mir_unit_t *mu); unsigned mir_count_blocks(mir_unit_t *mu); mir_block_t mir_get_block(mir_unit_t *mu, unsigned nth); unsigned mir_count_nodes(mir_unit_t *mu, mir_block_t block); mir_value_t mir_get_node(mir_unit_t *mu, mir_block_t block, unsigned nth); unsigned mir_count_vars(mir_unit_t *mu); unsigned mir_count_params(mir_unit_t *mu); mir_op_t mir_get_op(mir_unit_t *mu, mir_value_t node); unsigned mir_count_args(mir_unit_t *mu, mir_value_t node); mir_value_t mir_get_arg(mir_unit_t *mu, mir_value_t node, unsigned nth); const loc_t *mir_get_loc(mir_unit_t *mu, mir_value_t node); mir_value_t mir_get_var(mir_unit_t *mu, unsigned nth); mir_value_t mir_get_param(mir_unit_t *mu, unsigned nth); mir_value_t mir_add_param(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, ident_t name); mir_value_t mir_add_var(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, ident_t name, mir_var_flags_t flags); bool mir_get_const(mir_unit_t *mu, mir_value_t value, int64_t *result); bool mir_get_const_real(mir_unit_t *mu, mir_value_t value, double *result); mir_type_t mir_get_type(mir_unit_t *mu, mir_value_t value); mir_stamp_t mir_get_stamp(mir_unit_t *mu, mir_value_t value); mir_mem_t mir_get_mem(mir_unit_t *mu, mir_value_t value); ident_t mir_get_name(mir_unit_t *mu, mir_value_t value); object_t *mir_get_locus(mir_unit_t *mu, mir_value_t value); void mir_get_bits(mir_unit_t *mu, mir_value_t value, uint64_t *abits, uint64_t *bbits); mir_var_flags_t mir_get_var_flags(mir_unit_t *mu, mir_value_t value); mir_type_t mir_get_var_type(mir_unit_t *mu, mir_value_t value); void mir_set_input(mir_unit_t *mu, mir_value_t phi, unsigned nth, mir_block_t block, mir_value_t value); bool mir_block_finished(mir_unit_t *mu, mir_block_t block); void mir_set_result(mir_unit_t *mu, mir_type_t type); mir_type_t mir_get_result(mir_unit_t *mu); bool mir_is_integral(mir_unit_t *mu, mir_value_t value); bool mir_is_numeric(mir_unit_t *mu, mir_value_t value); bool mir_is_scalar(mir_unit_t *mu, mir_value_t value); bool mir_is_vector(mir_unit_t *mu, mir_value_t value); bool mir_is_bool(mir_unit_t *mu, mir_value_t value); bool mir_is_time(mir_unit_t *mu, mir_value_t value); bool mir_is_signal(mir_unit_t *mu, mir_value_t value); bool mir_is_offset(mir_unit_t *mu, mir_value_t value); bool mir_is(mir_unit_t *mu, mir_value_t value, mir_class_t class); bool mir_points_to(mir_unit_t *mu, mir_value_t value, mir_class_t class); bool mir_may_alias(mir_unit_t *mu, mir_value_t a, mir_value_t b); const char *mir_op_string(mir_op_t op); #ifdef DEBUG __attribute__((format(printf, 2, 3))) void mir_comment(mir_unit_t *mu, const char *fmt, ...); #else #define mir_comment(mu, fmt, ...) #endif typedef struct { mir_unit_t *mu; loc_t loc; } mir_saved_loc_t; mir_saved_loc_t _mir_push_debug_info(mir_unit_t *mu, const loc_t *loc); __attribute__((always_inline)) static inline void _mir_pop_debug_info(const mir_saved_loc_t *sl) { mir_set_loc(sl->mu, &sl->loc); } // Constants mir_value_t mir_enum(unsigned value); mir_value_t mir_const(mir_unit_t *mu, mir_type_t type, int64_t value); mir_value_t mir_const_real(mir_unit_t *mu, mir_type_t type, double value); mir_value_t mir_const_vec(mir_unit_t *mu, mir_type_t type, uint64_t abits, uint64_t bbits); mir_value_t mir_const_array(mir_unit_t *mu, mir_type_t type, const mir_value_t *values, size_t count); mir_value_t mir_const_string(mir_unit_t *mu, const char *str); mir_value_t mir_build_const_rep(mir_unit_t *mu, mir_type_t type, mir_value_t value, unsigned rep); mir_value_t mir_const_record(mir_unit_t *mu, mir_type_t type, const mir_value_t *values, size_t count); // Arithmetic mir_value_t mir_build_add(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_sub(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_mul(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_div(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_rem(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_mod(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_exp(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_neg(mir_unit_t *mu, mir_type_t type, mir_value_t value); mir_value_t mir_build_abs(mir_unit_t *mu, mir_type_t type, mir_value_t value); // Trapping arithmetic mir_value_t mir_build_trap_add(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus); mir_value_t mir_build_trap_sub(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus); mir_value_t mir_build_trap_mul(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus); mir_value_t mir_build_trap_exp(mir_unit_t *mu, mir_type_t type, mir_value_t left, mir_value_t right, mir_value_t locus); mir_value_t mir_build_trap_neg(mir_unit_t *mu, mir_type_t type, mir_value_t value, mir_value_t locus); // Logical mir_value_t mir_build_and(mir_unit_t *mu, mir_value_t left, mir_value_t right); mir_value_t mir_build_or(mir_unit_t *mu, mir_value_t left, mir_value_t right); mir_value_t mir_build_xor(mir_unit_t *mu, mir_value_t left, mir_value_t right); mir_value_t mir_build_not(mir_unit_t *mu, mir_value_t value); mir_value_t mir_build_cmp(mir_unit_t *mu, mir_cmp_t cmp, mir_value_t left, mir_value_t right); // Vectors mir_value_t mir_build_pack(mir_unit_t *mu, mir_type_t type, mir_value_t arg); mir_value_t mir_build_unpack(mir_unit_t *mu, mir_value_t vec, uint8_t strength, mir_value_t dest); mir_value_t mir_build_binary(mir_unit_t *mu, mir_vec_op_t op, mir_type_t type, mir_value_t left, mir_value_t right); mir_value_t mir_build_unary(mir_unit_t *mu, mir_vec_op_t op, mir_type_t type, mir_value_t arg); // Memory void mir_build_store(mir_unit_t *mu, mir_value_t dest, mir_value_t src); mir_value_t mir_build_load(mir_unit_t *mu, mir_value_t value); void mir_build_copy(mir_unit_t *mu, mir_value_t dest, mir_value_t src, mir_value_t count); void mir_build_set(mir_unit_t *mu, mir_value_t dest, mir_value_t value, mir_value_t count); mir_value_t mir_build_alloc(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, mir_value_t count); mir_value_t mir_build_null(mir_unit_t *mu, mir_type_t type); mir_value_t mir_build_new(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp, mir_value_t count); mir_value_t mir_build_all(mir_unit_t *mu, mir_value_t access); mir_value_t mir_build_address_of(mir_unit_t *mu, mir_value_t array); mir_value_t mir_build_array_ref(mir_unit_t *mu, mir_value_t array, mir_value_t offset); mir_value_t mir_build_record_ref(mir_unit_t *mu, mir_value_t record, unsigned field); // Arrays mir_value_t mir_build_wrap(mir_unit_t *mu, mir_value_t data, const mir_dim_t *dims, int ndims); mir_value_t mir_build_unwrap(mir_unit_t *mu, mir_value_t array); mir_value_t mir_build_uarray_len(mir_unit_t *mu, mir_value_t array, int dim); mir_value_t mir_build_uarray_left(mir_unit_t *mu, mir_value_t array, int dim); mir_value_t mir_build_uarray_right(mir_unit_t *mu, mir_value_t array, int dim); mir_value_t mir_build_uarray_dir(mir_unit_t *mu, mir_value_t array, int dim); mir_value_t mir_build_range_length(mir_unit_t *mu, mir_value_t left, mir_value_t right, mir_value_t dir); mir_value_t mir_build_range_null(mir_unit_t *mu, mir_value_t left, mir_value_t right, mir_value_t dir); // Control flow void mir_build_jump(mir_unit_t *mu, mir_block_t target); void mir_build_cond(mir_unit_t *mu, mir_value_t test, mir_block_t btrue, mir_block_t bfalse); mir_value_t mir_build_select(mir_unit_t *mu, mir_type_t type, mir_value_t test, mir_value_t vtrue, mir_value_t vfalse); mir_value_t mir_build_phi(mir_unit_t *mu, mir_type_t type, unsigned ninputs); void mir_build_case(mir_unit_t *mu, mir_value_t value, mir_block_t def, const mir_value_t *cases, const mir_block_t *blocks, int ncases); void mir_build_return(mir_unit_t *mu, mir_value_t value); void mir_build_wait(mir_unit_t *mu, mir_block_t target, mir_value_t time); void mir_build_consume(mir_unit_t *mu, mir_value_t value); mir_value_t mir_build_fcall(mir_unit_t *mu, ident_t name, mir_type_t type, mir_stamp_t stamp, const mir_value_t *args, unsigned nargs); void mir_build_pcall(mir_unit_t *mu, ident_t name, mir_block_t resume, const mir_value_t *args, unsigned nargs); void mir_build_resume(mir_unit_t *mu, ident_t name); mir_value_t mir_build_syscall(mir_unit_t *mu, ident_t func, mir_type_t type, mir_stamp_t stamp, mir_value_t locus, const mir_value_t *args, int nargs); void mir_build_unreachable(mir_unit_t *mu, mir_value_t locus); // Checks void mir_build_range_check(mir_unit_t *mu, mir_value_t value, mir_value_t left, mir_value_t right, mir_value_t dir, mir_value_t locus, mir_value_t hint); void mir_build_index_check(mir_unit_t *mu, mir_value_t value, mir_value_t left, mir_value_t right, mir_value_t dir, mir_value_t locus, mir_value_t hint); void mir_build_dir_check(mir_unit_t *mu, mir_value_t value, mir_value_t dir, mir_value_t locus); void mir_build_null_check(mir_unit_t *mu, mir_value_t ptr, mir_value_t locus); void mir_build_zero_check(mir_unit_t *mu, mir_value_t value, mir_value_t locus); void mir_build_length_check(mir_unit_t *mu, mir_value_t llen, mir_value_t rlen, mir_value_t locus, mir_value_t dim); void mir_build_exponent_check(mir_unit_t *mu, mir_value_t exp, mir_value_t locus); // Files void mir_build_file_open(mir_unit_t *mu, mir_value_t file, mir_value_t name, mir_value_t length, mir_value_t kind, mir_value_t status); void mir_build_file_read(mir_unit_t *mu, mir_value_t file, mir_value_t ptr, mir_value_t inlen, mir_value_t outlen); void mir_build_file_write(mir_unit_t *mu, mir_value_t file, mir_value_t value, mir_value_t length); // Port conversion mir_value_t mir_build_port_conversion(mir_unit_t *mu, mir_value_t driving, mir_value_t effective); void mir_build_convert_in(mir_unit_t *mu, mir_value_t conv, mir_value_t nets, mir_value_t count); void mir_build_convert_out(mir_unit_t *mu, mir_value_t conv, mir_value_t nets, mir_value_t count); void mir_build_put_conversion(mir_unit_t *mu, mir_value_t cf, mir_value_t target, mir_value_t count, mir_value_t values); // Signals mir_value_t mir_build_init_signal(mir_unit_t *mu, mir_type_t type, mir_value_t count, mir_value_t size, mir_value_t value, mir_value_t flags, mir_value_t locus, mir_value_t offset); mir_value_t mir_build_implicit_signal(mir_unit_t *mu, mir_type_t type, mir_value_t count, mir_value_t size, mir_value_t locus, mir_value_t kind, mir_value_t closure, mir_value_t delay); void mir_build_drive_signal(mir_unit_t *mu, mir_value_t target, mir_value_t count); void mir_build_sched_waveform(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values, mir_value_t reject, mir_value_t after); void mir_build_deposit_signal(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values); mir_value_t mir_build_resolved(mir_unit_t *mu, mir_value_t signal); mir_value_t mir_build_last_value(mir_unit_t *mu, mir_value_t signal); mir_value_t mir_build_driving_value(mir_unit_t *mu, mir_value_t signal, mir_value_t count); void mir_build_force(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t values); void mir_build_release(mir_unit_t *mu, mir_value_t target, mir_value_t count); void mir_build_disconnect(mir_unit_t *mu, mir_value_t target, mir_value_t count, mir_value_t reject, mir_value_t after); mir_value_t mir_build_last_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count); mir_value_t mir_build_last_active(mir_unit_t *mu, mir_value_t signal, mir_value_t count); mir_value_t mir_build_event_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count); mir_value_t mir_build_active_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count); mir_value_t mir_build_driving_flag(mir_unit_t *mu, mir_value_t signal, mir_value_t count); void mir_build_resolve_signal(mir_unit_t *mu, mir_value_t signal, mir_value_t resolution); void mir_build_transfer_signal(mir_unit_t *mu, mir_value_t target, mir_value_t source, mir_value_t count, mir_value_t reject, mir_value_t after); // Coverage void mir_build_cover_stmt(mir_unit_t *mu, uint32_t tag); void mir_build_cover_branch(mir_unit_t *mu, uint32_t tag); void mir_build_cover_expr(mir_unit_t *mu, uint32_t tag); void mir_build_cover_toggle(mir_unit_t *mu, mir_value_t signal, uint32_t tag); void mir_build_cover_state(mir_unit_t *mu, mir_value_t signal, mir_value_t low, uint32_t tag); // Initialisation mir_value_t mir_build_package_init(mir_unit_t *mu, ident_t name, mir_value_t context); void mir_build_process_init(mir_unit_t *mu, ident_t name, mir_value_t locus); mir_value_t mir_build_protected_init(mir_unit_t *mu, mir_type_t type, mir_value_t context, mir_value_t path_name, mir_value_t inst_name); void mir_build_record_scope(mir_unit_t *mu, mir_value_t locus, mir_type_t type); void mir_build_array_scope(mir_unit_t *mu, mir_value_t locus, mir_type_t type); void mir_build_package_scope(mir_unit_t *mu, mir_value_t locus); void mir_build_pop_scope(mir_unit_t *mu); void mir_build_alias_signal(mir_unit_t *mu, mir_value_t signal, mir_value_t locus); void mir_build_map_signal(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count); void mir_build_map_const(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count); void mir_build_map_implicit(mir_unit_t *mu, mir_value_t src, mir_value_t dst, mir_value_t count); // Triggers mir_value_t mir_build_cmp_trigger(mir_unit_t *mu, mir_value_t left, mir_value_t right); mir_value_t mir_build_function_trigger(mir_unit_t *mu, ident_t name, const mir_value_t *args, unsigned nargs); mir_value_t mir_build_or_trigger(mir_unit_t *mu, mir_value_t left, mir_value_t right); void mir_build_add_trigger(mir_unit_t *mu, mir_value_t trigger); // Linking mir_value_t mir_build_link_package(mir_unit_t *mu, ident_t name); mir_value_t mir_build_link_var(mir_unit_t *mu, ident_t unit, mir_value_t context, ident_t name, mir_type_t type); void mir_build_bind_foreign(mir_unit_t *mu, mir_value_t spec, mir_value_t length, mir_value_t locus); mir_value_t mir_build_bind_external(mir_unit_t *mu, mir_value_t locus, ident_t scope, mir_type_t type, mir_stamp_t stamp); mir_value_t mir_build_context_upref(mir_unit_t *mu, int hops); mir_value_t mir_build_var_upref(mir_unit_t *mu, int hops, int nth); // Events void mir_build_sched_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count); void mir_build_clear_event(mir_unit_t *mu, mir_value_t signal, mir_value_t count); // Reflection mir_value_t mir_build_reflect_value(mir_unit_t *mu, mir_value_t value, mir_value_t context, mir_value_t locus, mir_value_t bounds); mir_value_t mir_build_reflect_subtype(mir_unit_t *mu, mir_value_t context, mir_value_t locus, mir_value_t bounds); // Assertions void mir_build_assert(mir_unit_t *mu, mir_value_t value, mir_value_t message, mir_value_t length, mir_value_t severity, mir_value_t locus, mir_value_t hint_left, mir_value_t hint_right); void mir_build_report(mir_unit_t *mu, mir_value_t message, mir_value_t length, mir_value_t severity, mir_value_t locus); // Miscellaneous mir_value_t mir_build_instance_name(mir_unit_t *mu, mir_value_t kind); void mir_build_enter_state(mir_unit_t *mu, mir_value_t state, mir_value_t strong); mir_value_t mir_build_closure(mir_unit_t *mu, ident_t func, mir_value_t context, mir_type_t atype, mir_type_t rtype); mir_value_t mir_build_resolution_wrapper(mir_unit_t *mu, mir_type_t type, mir_value_t closure, mir_value_t nlits); mir_value_t mir_build_locus(mir_unit_t *mu, object_t *obj); mir_value_t mir_build_cast(mir_unit_t *mu, mir_type_t type, mir_value_t value); void mir_build_debug_out(mir_unit_t *mu, mir_value_t value); #endif // _MIR_NODE_H nvc-r1.17.1/src/mir/mir-optim.c000066400000000000000000000606351504111170000162100ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "ident.h" #include "mask.h" #include "mir/mir-node.h" #include "mir/mir-priv.h" #include "mir/mir-structs.h" #include "option.h" #include #include #include #define CFG_EMBED_EDGES 4 typedef struct { unsigned count; unsigned max; union { mir_block_t edges[CFG_EMBED_EDGES]; mir_block_t *external; } u; } cfg_edge_list_t; typedef struct { mir_block_t block; unsigned entry : 1; unsigned aborts : 1; unsigned returns : 1; cfg_edge_list_t in; cfg_edge_list_t out; bit_mask_t dom; #if 0 bit_mask_t livein; bit_mask_t varkill; bit_mask_t liveout; #endif } cfg_block_t; typedef uint32_t valnum_t; #define VN_INVALID UINT_MAX #define VN_CONST 0x80000000 typedef struct { mir_value_t value; uint32_t hash; mir_block_t block; valnum_t vn; } gvn_tab_t; typedef struct { valnum_t *nodevn; valnum_t *paramvn; valnum_t nextvn; valnum_t maxvn; mir_value_t *canon; bit_mask_t visited; size_t tabsz; gvn_tab_t hashtab[]; } gvn_state_t; typedef struct { bit_mask_t visited; uint8_t uses[]; } dce_state_t; typedef struct { cfg_block_t *cfg; gvn_state_t *gvn; dce_state_t *dce; } mir_optim_t; static void mir_dump_optim(mir_unit_t *mu, mir_optim_t *an); //////////////////////////////////////////////////////////////////////////////// // Control flow graph construction static void cfg_add_one_edge(cfg_edge_list_t *list, mir_block_t edge) { if (list->count < 4) list->u.edges[list->count++] = edge; else if (list->count == 4) { mir_block_t *ptr = xmalloc_array(16, sizeof(mir_block_t)); memcpy(ptr, list->u.edges, 4 * sizeof(mir_block_t)); list->max = 16; list->u.external = ptr; list->u.external[list->count++] = edge; } else if (list->count == list->max) { list->max *= 2; list->u.external = xrealloc_array(list->u.external, list->max, sizeof(mir_block_t)); list->u.external[list->count++] = edge; } else list->u.external[list->count++] = edge; } static void cfg_add_edge(cfg_block_t *cfg, mir_block_t from, mir_block_t to) { cfg_add_one_edge(&(cfg[from.id].out), to); cfg_add_one_edge(&(cfg[to.id].in), from); } static mir_block_t cfg_get_edge(const cfg_edge_list_t *list, int nth) { assert(nth < list->count); if (list->max <= 4) return list->u.edges[nth]; else return list->u.external[nth]; } static cfg_block_t *mir_get_cfg(mir_unit_t *mu) { cfg_block_t *cfg = xcalloc_array(mu->blocks.count, sizeof(cfg_block_t)); cfg[0].entry = true; if (mir_get_kind(mu) == MIR_UNIT_PROCESS && mu->blocks.count > 1) cfg[1].entry = true; for (int i = 0; i < mu->blocks.count; i++) { const block_data_t *bd = &(mu->blocks.items[i]); mir_block_t this = { .tag = MIR_TAG_BLOCK, .id = i }; DEBUG_ONLY(mir_set_cursor(mu, this, MIR_APPEND)); MIR_ASSERT(bd->num_nodes > 0, "empty basic block"); const node_data_t *last = &(mu->nodes[bd->nodes[bd->num_nodes - 1]]); MIR_ASSERT(mir_is_terminator(last->op), "last operation in block is not terminator"); switch (last->op) { case MIR_OP_WAIT: assert(last->args[0].tag == MIR_TAG_BLOCK); cfg[last->args[0].id].entry = true; // Fall-through case MIR_OP_RETURN: cfg[i].returns = true; break; default: assert(last->nargs <= MIR_INLINE_ARGS); for (int j = 0; j < last->nargs; j++) { if (last->args[j].tag == MIR_TAG_BLOCK) cfg_add_edge(cfg, this, mir_cast_block(last->args[j])); } } } return cfg; } static void mir_free_cfg(mir_unit_t *mu, cfg_block_t *cfg) { for (int i = 0; i < mu->blocks.count; i++) { cfg_block_t *cb = &(cfg[i]); if (cb->in.max > CFG_EMBED_EDGES) free(cb->in.u.external); if (cb->out.max > CFG_EMBED_EDGES) free(cb->out.u.external); mask_free(&cb->dom); } free(cfg); } //////////////////////////////////////////////////////////////////////////////// // Dominator tree construction static void mir_dominator_tree(mir_unit_t *mu, cfg_block_t *cfg) { // TODO: use more efficient algorithm for (int i = 0; i < mu->blocks.count; i++) { mask_init(&cfg[i].dom, mu->blocks.count); if (cfg[i].entry) mask_set(&cfg[i].dom, i); else mask_setall(&cfg[i].dom); } bit_mask_t tmp; mask_init(&tmp, mu->blocks.count); bool changes; do { changes = false; for (int i = 0; i < mu->blocks.count; i++) { if (cfg[i].entry) continue; mask_setall(&tmp); for (int j = 0; j < cfg[i].in.count; j++) { mir_block_t pred = cfg_get_edge(&cfg[i].in, j); mask_intersect(&tmp, &cfg[pred.id].dom); } mask_set(&tmp, i); if (!changes && !mask_eq(&tmp, &cfg[i].dom)) changes = true; mask_copy(&cfg[i].dom, &tmp); } } while (changes); } //////////////////////////////////////////////////////////////////////////////// // Liveness analysis #if 0 static void mir_do_liveness(mir_unit_t *mu, mir_optim_t *opt) { // Algorithm from "Engineering a Compiler" chapter 8.6 for (int i = 0; i < mu->num_blocks; i++) { cfg_block_t *cb = &(opt->cfg[i]); mask_init(&cb->livein, mu->num_nodes); mask_init(&cb->varkill, mu->num_nodes); mask_init(&cb->liveout, mu->num_nodes); const block_data_t *bd = mir_block_data(mu, cb->block); for (int j = 0; j < bd->num_nodes; j++) { mir_value_t node = { .tag = MIR_TAG_NODE, .id = bd->nodes[i] }; const node_data_t *n = mir_node_data(mu, node); if (n->op == MIR_OP_CONST || n->op == MIR_OP_CONST_REAL) continue; else if (mir_is_null(n->type)) continue; // Produces no value const mir_value_t *args = mir_get_args(mu, n); for (int k = 0; k < n->nargs; k++) { mir_value_t arg = args[k]; if (arg.tag == MIR_TAG_NODE && !mask_test(&cb->varkill, arg.id)) mask_set(&cb->livein, arg.id); } mask_set(&cb->varkill, node.id); } } bit_mask_t new, tmp; mask_init(&new, mu->num_nodes); mask_init(&tmp, mu->num_nodes); bool changed; do { changed = false; for (int i = mu->num_blocks - 1; i >= 0; i--) { cfg_block_t *cb = &(opt->cfg[i]); mask_clearall(&new); for (int j = 0; j < cb->out.count; j++) { cfg_block_t *succ = &(opt->cfg[cfg_get_edge(&cb->out, j).id]); mask_copy(&tmp, &succ->liveout); mask_subtract(&tmp, &succ->varkill); mask_union(&tmp, &succ->livein); mask_union(&new, &tmp); } if (!mask_eq(&new, &cb->liveout)) { mask_copy(&cb->liveout, &new); changed = true; } } } while (changed); // Replaced "upward exposed variables" set with live-in for (int i = 0; i < mu->num_blocks; i++) { cfg_block_t *cb = &(opt->cfg[i]); mask_copy(&tmp, &cb->liveout); mask_subtract(&tmp, &cb->varkill); mask_union(&cb->livein, &tmp); } mask_free(&new); mask_free(&tmp); } #endif //////////////////////////////////////////////////////////////////////////////// // Global value numbering static inline valnum_t gvn_new_value(mir_value_t canon, gvn_state_t *gvn) { assert(gvn->nextvn < gvn->maxvn); gvn->canon[gvn->nextvn] = canon; return gvn->nextvn++; } static inline bool gvn_tracked(mir_value_t value) { return value.tag == MIR_TAG_NODE || value.tag == MIR_TAG_PARAM; } static valnum_t gvn_get_value(mir_value_t value, gvn_state_t *gvn) { switch (value.tag) { case MIR_TAG_NODE: return gvn->nodevn[value.id]; case MIR_TAG_PARAM: return gvn->paramvn[value.id]; case MIR_TAG_CONST: return VN_CONST + value.id; default: should_not_reach_here(); } } static uint32_t gvn_hash_node(mir_unit_t *mu, const node_data_t *n, gvn_state_t *gvn) { uint32_t hash = knuth_hash(n->op) + knuth_hash(n->nargs); hash ^= mir_type_data(mu, n->type)->hash; if (n->op == MIR_OP_CONST) return hash ^ mix_bits_64(n->iconst); else if (n->op == MIR_OP_CONST_REAL) return hash ^ mix_bits_64(FLOAT_BITS(n->dconst)); else if (n->op == MIR_OP_CONST_VEC) return hash ^ mix_bits_64(n->bits[0]) ^ mix_bits_64(n->bits[1]); else if (n->op == MIR_OP_LOCUS) return hash ^ mix_bits_64(n->locus); else { const mir_value_t *args = mir_get_args(mu, n); for (int i = 0; i < n->nargs; i++) { hash <<= 1; // Argument order should affect hash if (gvn_tracked(args[i])) hash += knuth_hash(gvn_get_value(args[i], gvn)); else hash += knuth_hash(args[i].bits); } return mix_bits_32(hash); } } static bool gvn_compare(mir_unit_t *mu, const node_data_t *a, const node_data_t *b, gvn_state_t *gvn) { if (a->op != b->op || a->nargs != b->nargs || !mir_equals(a->type, b->type)) return false; else if (a->op == MIR_OP_CONST) return a->iconst == b->iconst; else if (a->op == MIR_OP_CONST_REAL) return a->dconst == b->dconst; else if (a->op == MIR_OP_CONST_VEC) return a->bits[0] == b->bits[0] && a->bits[1] == b->bits[1]; else if (a->op == MIR_OP_LOCUS) return a->locus == b->locus; const mir_value_t *a_args = mir_get_args(mu, a); const mir_value_t *b_args = mir_get_args(mu, b); for (int i = 0; i < a->nargs; i++) { if (a_args[i].tag != b_args[i].tag) return false; else if (gvn_tracked(a_args[i])) { const valnum_t avn = gvn_get_value(a_args[i], gvn); const valnum_t bvn = gvn_get_value(b_args[i], gvn); if (avn != bvn) return false; } else if (a_args[i].bits != b_args[i].bits) return false; } return true; } static void gvn_generic(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { const node_data_t *n = mir_node_data(mu, node); const cfg_block_t *cb = &(opt->cfg[block.id]); const uint32_t hash = gvn_hash_node(mu, n, opt->gvn); for (int idx = hash & (opt->gvn->tabsz - 1), limit = 0; limit < 10; idx = (idx + 1) & (opt->gvn->tabsz - 1), limit++) { gvn_tab_t *tab = &(opt->gvn->hashtab[idx]); if (mir_is_null(tab->value)) { tab->value = node; tab->hash = hash; tab->block = block; tab->vn = opt->gvn->nodevn[node.id] = gvn_new_value(node, opt->gvn); return; } else if (tab->hash == hash && mask_test(&cb->dom, tab->block.id)) { const node_data_t *o = mir_node_data(mu, tab->value); if (gvn_compare(mu, n, o, opt->gvn)) { opt->gvn->nodevn[node.id] = tab->vn; return; } } } opt->gvn->nodevn[node.id] = gvn_new_value(node, opt->gvn); } static void gvn_sub(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { node_data_t *n = mir_node_data(mu, node); assert(n->nargs == 2); // (X + Y) - Y ==> X mir_value_t left = n->args[0], right = n->args[1]; if (left.tag == MIR_TAG_NODE) { node_data_t *nl = mir_node_data(mu, left); if (nl->op == MIR_OP_ADD) { valnum_t left0_vn = gvn_get_value(nl->args[0], opt->gvn); valnum_t left1_vn = gvn_get_value(nl->args[1], opt->gvn); valnum_t right_vn = gvn_get_value(right, opt->gvn); if (left1_vn == right_vn) { opt->gvn->nodevn[node.id] = left0_vn; return; } } } gvn_generic(mu, node, block, opt); } static void gvn_commutative(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt, int first) { node_data_t *n = mir_node_data(mu, node); assert(n->nargs == first + 2); assert(n->nargs <= MIR_INLINE_ARGS); mir_value_t left = n->args[first], right = n->args[first + 1]; if (left.tag == MIR_TAG_CONST) { // Move constants to right hand side n->args[first] = right; n->args[first + 1] = left; } else if (gvn_tracked(left) && gvn_tracked(right)) { // Sort arguments by value number const valnum_t vn0 = gvn_get_value(left, opt->gvn); const valnum_t vn1 = gvn_get_value(right, opt->gvn); if (vn0 > vn1) { n->args[first] = right; n->args[first + 1] = left; } } gvn_generic(mu, node, block, opt); } static void gvn_cmp(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { node_data_t *n = mir_node_data(mu, node); assert(n->nargs == 3); assert(n->nargs <= MIR_INLINE_ARGS); assert(n->args[0].tag == MIR_TAG_ENUM); switch (n->args[0].id) { case MIR_CMP_EQ: case MIR_CMP_NEQ: gvn_commutative(mu, node, block, opt, 1); break; default: gvn_generic(mu, node, block, opt); break; } } static void gvn_logical(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { const node_data_t *n = mir_node_data(mu, node); assert(n->nargs == 2); assert(n->nargs <= MIR_INLINE_ARGS); if (gvn_tracked(n->args[0]) && gvn_tracked(n->args[1])) { const valnum_t vn0 = gvn_get_value(n->args[0], opt->gvn); const valnum_t vn1 = gvn_get_value(n->args[1], opt->gvn); if (vn0 == vn1) { switch (n->op) { case MIR_OP_AND: // X & X ==> X case MIR_OP_OR: // X | X ==> X opt->gvn->nodevn[node.id] = vn0; return; default: should_not_reach_here(); } } } gvn_commutative(mu, node, block, opt, 0); } static void gvn_phi(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { const node_data_t *n = mir_node_data(mu, node); assert(n->nargs >= 2); const mir_value_t *args = mir_get_args(mu, n); if (!gvn_tracked(args[1])) return; valnum_t vn = gvn_get_value(args[1], opt->gvn); for (int i = 3; i < n->nargs; i += 2) { if (gvn_get_value(args[i], opt->gvn) != vn) return; } opt->gvn->nodevn[node.id] = vn; } static void gvn_unpack(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { const node_data_t *n = mir_node_data(mu, node); if (mir_is_null(n->type)) return; // Unpack into memory gvn_generic(mu, node, block, opt); } static void gvn_load(mir_unit_t *mu, mir_value_t node, mir_block_t block, mir_optim_t *opt) { // TODO: check if stamp is const or pointer opt->gvn->nodevn[node.id] = gvn_new_value(node, opt->gvn); } static void gvn_visit_block(mir_unit_t *mu, mir_block_t block, mir_optim_t *opt) { if (mask_test(&opt->gvn->visited, block.id)) return; mask_set(&opt->gvn->visited, block.id); for (size_t id = -1; mask_iter(&opt->cfg[block.id].dom, &id);) { mir_block_t dom = { .tag = MIR_TAG_BLOCK, .id = id }; gvn_visit_block(mu, dom, opt); } const block_data_t *bd = mir_block_data(mu, block); for (int i = 0; i < bd->num_nodes; i++) { mir_value_t node = { .tag = MIR_TAG_NODE, .id = bd->nodes[i] }; switch (mir_get_op(mu, node)) { case MIR_OP_CMP: gvn_cmp(mu, node, block, opt); break; case MIR_OP_ADD: case MIR_OP_MUL: gvn_commutative(mu, node, block, opt, 0); break; case MIR_OP_SUB: gvn_sub(mu, node, block, opt); break; case MIR_OP_NOT: case MIR_OP_RESOLVED: case MIR_OP_SELECT: case MIR_OP_REM: case MIR_OP_LINK_PACKAGE: case MIR_OP_LINK_VAR: case MIR_OP_PACKAGE_INIT: case MIR_OP_LOCUS: case MIR_OP_UARRAY_LEN: case MIR_OP_RANGE_LENGTH: case MIR_OP_CAST: case MIR_OP_PACK: case MIR_OP_VAR_UPREF: case MIR_OP_CONST_VEC: case MIR_OP_BINARY: case MIR_OP_UNARY: case MIR_OP_CLOSURE: case MIR_OP_CONTEXT_UPREF: case MIR_OP_UNWRAP: gvn_generic(mu, node, block, opt); break; case MIR_OP_AND: case MIR_OP_OR: gvn_logical(mu, node, block, opt); break; case MIR_OP_PHI: gvn_phi(mu, node, block, opt); break; case MIR_OP_UNPACK: gvn_unpack(mu, node, block, opt); break; case MIR_OP_LOAD: gvn_load(mu, node, block, opt); break; case MIR_OP_INIT_SIGNAL: case MIR_OP_PORT_CONVERSION: opt->gvn->nodevn[node.id] = gvn_new_value(node, opt->gvn); break; default: break; } } } static void mir_do_gvn(mir_unit_t *mu, mir_optim_t *opt) { const size_t tabsz = next_power_of_2(mu->num_nodes * 2); valnum_t *vnmap = xmalloc_array(mu->num_nodes + mu->params.count, sizeof(gvn_tab_t)); opt->gvn = xcalloc_flex(sizeof(gvn_state_t), tabsz, sizeof(gvn_tab_t)); opt->gvn->tabsz = tabsz; opt->gvn->nodevn = vnmap; opt->gvn->paramvn = vnmap + mu->num_nodes; opt->gvn->maxvn = mu->num_nodes + mu->params.count; opt->gvn->canon = xcalloc_array(opt->gvn->maxvn, sizeof(mir_value_t)); for (int i = 0; i < mu->num_nodes; i++) opt->gvn->nodevn[i] = VN_INVALID; for (int i = 0; i < mu->params.count; i++) { mir_value_t param = { .tag = MIR_TAG_PARAM, .id = i }; opt->gvn->paramvn[i] = gvn_new_value(param, opt->gvn); } mask_init(&opt->gvn->visited, mu->blocks.count); for (int i = 0; i < mu->blocks.count; i++) { mir_block_t this = { .tag = MIR_TAG_BLOCK, .id = i }; gvn_visit_block(mu, this, opt); } for (int i = 0; i < mu->num_nodes; i++) { node_data_t *n = &(mu->nodes[i]); const mir_value_t *args = mir_get_args(mu, n); for (int j = 0; j < n->nargs; j++) { if (args[j].tag == MIR_TAG_NODE) { const valnum_t vn = opt->gvn->nodevn[args[j].id]; if (unlikely(vn == VN_INVALID)) { mir_dump_optim(mu, opt); fatal_trace("node %%%d has no value number", args[j].id); } else if (!mir_equals(opt->gvn->canon[vn], args[j])) mir_set_arg(mu, n, j, opt->gvn->canon[vn]); } } } if (opt_get_verbose(OPT_GVN_VERBOSE, istr(mu->name))) mir_dump_optim(mu, opt); mask_free(&opt->gvn->visited); free(vnmap); free(opt->gvn->canon); free(opt->gvn); opt->gvn = NULL; } //////////////////////////////////////////////////////////////////////////////// // Simple dead code elimination by counting uses static void dce_visit_block(mir_unit_t *mu, mir_block_t block, mir_optim_t *opt) { if (mask_test(&opt->dce->visited, block.id)) return; mask_set(&opt->dce->visited, block.id); const block_data_t *bd = mir_block_data(mu, block); for (int i = 0; i < bd->num_nodes; i++) { mir_value_t node = { .tag = MIR_TAG_NODE, .id = bd->nodes[i] }; node_data_t *n = mir_node_data(mu, node); const mir_value_t *args = mir_get_args(mu, n); for (int j = 0; j < n->nargs; j++) { mir_value_t arg = args[j]; if (arg.tag == MIR_TAG_NODE) opt->dce->uses[arg.id] = saturate_add(opt->dce->uses[arg.id], 1); } if (mir_is_null(n->type) || n->op == MIR_OP_STORE) opt->dce->uses[node.id] = 1; // Does not produce value } cfg_block_t *cb = &(opt->cfg[block.id]); for (int i = 0; i < cb->out.count; i++) dce_visit_block(mu, cfg_get_edge(&cb->out, i), opt); } static void mir_do_dce(mir_unit_t *mu, mir_optim_t *opt) { opt->dce = xcalloc_flex(sizeof(dce_state_t), mu->num_nodes, sizeof(uint8_t)); mask_init(&opt->dce->visited, mu->num_nodes); for (int i = 0; i < mu->blocks.count; i++) { if (opt->cfg[i].entry) { mir_block_t this = { .tag = MIR_TAG_BLOCK, .id = i }; dce_visit_block(mu, this, opt); } } if (opt_get_verbose(OPT_DCE_VERBOSE, istr(mu->name))) mir_dump_optim(mu, opt); for (int i = mu->blocks.count - 1; i >= 0; i--) { mir_block_t this = { .tag = MIR_TAG_BLOCK, .id = i }; const block_data_t *bd = mir_block_data(mu, this); for (int j = bd->num_nodes - 1; j >= 0; j--) { mir_value_t node = { .tag = MIR_TAG_NODE, .id = bd->nodes[j] }; if (opt->dce->uses[node.id] == 0) { const node_data_t *nd = mir_node_data(mu, node); const mir_value_t *args = mir_get_args(mu, nd); for (int k = 0; k < nd->nargs; k++) { if (args[k].tag == MIR_TAG_NODE) { const uint8_t uses = opt->dce->uses[args[k].id]; assert(uses > 0); if (uses < UINT8_MAX) opt->dce->uses[args[k].id] = uses - 1; } } DEBUG_ONLY(const mir_op_t op = nd->op); mir_set_cursor(mu, this, j); mir_delete(mu); DEBUG_ONLY(mir_comment(mu, "Dead %s definition of %%%u", mir_op_string(op), node.id)); } } } mir_compact(mu); mask_free(&opt->dce->visited); free(opt->dce); opt->dce = NULL; } //////////////////////////////////////////////////////////////////////////////// // Debugging // LCOV_EXCL_START ///////////////////////////////////////////////////////////// static int begin_block_cb(mir_unit_t *mu, mir_block_t block, int col, void *ctx) { const mir_optim_t *opt = ctx; if (opt->cfg == NULL) return 0; const cfg_block_t *cb = &(opt->cfg[block.id]); color_printf("$cyan$//"); if (cb->entry) printf(" entry"); if (cb->in.count > 0) { printf(" in:"); for (int i = 0; i < cb->in.count; i++) printf("%s%d", i > 0 ? "," : "", cfg_get_edge(&cb->in, i).id); } else if (!cb->entry) printf(" unreachable"); if (cb->out.count > 0) { printf(" out:"); for (int i = 0; i < cb->out.count; i++) printf("%s%d", i > 0 ? "," : "", cfg_get_edge(&cb->out, i).id); } if (cb->dom.size > 0) { printf(" dom:"); for (size_t bit = -1, nth = 0; mask_iter(&(cb->dom), &bit); nth++) printf("%s%zd", nth > 0 ? "," : "", bit); } if (cb->returns) printf(" returns"); if (cb->aborts) printf(" aborts"); color_printf("$$\n%*.s", col, ""); return 0; } static int value_cb(mir_unit_t *mu, mir_value_t value, void *ctx) { const mir_optim_t *opt = ctx; if (opt->gvn != NULL && gvn_tracked(value)) { int col = color_printf("$!black$("); if (value.tag == MIR_TAG_NODE) { const node_data_t *n = mir_node_data(mu, value); col += printf("%08x:", gvn_hash_node(mu, n, opt->gvn)); } if (opt->gvn->nodevn[value.id] == VN_INVALID) col += printf("-"); else col += printf("%u", gvn_get_value(value, opt->gvn)); col += color_printf(")$$"); return col; } else if (opt->dce != NULL && value.tag == MIR_TAG_NODE) return color_printf("$!black$(%u)$$", opt->dce->uses[value.id]); else return 0; } static void mir_dump_optim(mir_unit_t *mu, mir_optim_t *an) { const mir_annotate_t cb = { .begin_block = begin_block_cb, .value = value_cb, }; mir_annotate(mu, &cb, an); } // LCOV_EXCL_STOP ////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Public interface void mir_optimise(mir_unit_t *mu, mir_pass_t passes) { mir_optim_t opt = {}; const mir_pass_t need_cfg = MIR_PASS_GVN | MIR_PASS_DCE; if (passes & need_cfg) { opt.cfg = mir_get_cfg(mu); mir_dominator_tree(mu, opt.cfg); } if (passes & MIR_PASS_GVN) mir_do_gvn(mu, &opt); if (passes & MIR_PASS_DCE) mir_do_dce(mu, &opt); if (passes & need_cfg) mir_free_cfg(mu, opt.cfg); } nvc-r1.17.1/src/mir/mir-priv.h000066400000000000000000000060651504111170000160420ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _MIR_PRIV_H #define _MIR_PRIV_H #include "prim.h" #include "mir/mir-node.h" #include "mir/mir-structs.h" #ifdef DEBUG #define MIR_ASSERT(expr, ...) do \ if (unlikely(!(expr))) { \ mir_dump(mu); \ fatal_trace(__VA_ARGS__); \ } while (0) #else #define MIR_ASSERT(expr, ...) #endif typedef enum { UNIT_DEFERRED = 1, UNIT_GENERATED = 2, UNIT_FREED = 3, } unit_state_t; const type_data_t *mir_type_data(mir_unit_t *mu, mir_type_t type); const stamp_data_t *mir_stamp_data(mir_unit_t *mu, mir_stamp_t stamp); node_data_t *mir_node_data(mir_unit_t *mu, mir_value_t value); block_data_t *mir_block_data(mir_unit_t *mu, mir_block_t block); const param_data_t *mir_param_data(mir_unit_t *mu, mir_value_t param); const var_data_t *mir_var_data(mir_unit_t *mu, mir_value_t value); const mir_value_t *mir_get_args(mir_unit_t *mu, const node_data_t *nd); void mir_set_arg(mir_unit_t *mu, node_data_t *n, unsigned nth, mir_value_t value); bool mir_same_type(mir_unit_t *mu, mir_type_t a, mir_type_t b); bool mir_is_top(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp); mir_type_t mir_get_var_pointer(mir_unit_t *mu, mir_type_t type); mir_stamp_t mir_stamp_elem(mir_unit_t *mu, mir_stamp_t stamp); mir_stamp_t mir_stamp_add(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_sub(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_mul(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_div(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_rem(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_cmp(mir_unit_t *mu, mir_cmp_t cmp, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_union(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right); mir_stamp_t mir_stamp_cast(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp); bool mir_stamp_const(mir_unit_t *mu, mir_stamp_t stamp, int64_t *cval); bool mir_is_terminator(mir_op_t op); void mir_free_types(type_tab_t *tab); void *mir_global_malloc(mir_context_t *mc, size_t fixed, size_t nelems, size_t size); #endif // _MIR_PRIV_H nvc-r1.17.1/src/mir/mir-structs.h000066400000000000000000000140211504111170000165600ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _MIR_STRUCTS_H #define _MIR_STRUCTS_H #include "prim.h" #include "diag.h" #include "mir/mir-unit.h" #include "mir/mir-node.h" #include "thread.h" #define MIR_INLINE_ARGS 4 typedef struct { mir_op_t op; mir_type_t type; mir_stamp_t stamp; unsigned nargs; loc_t loc; union { mir_value_t args[MIR_INLINE_ARGS]; size_t spilloff; object_t *locus; int64_t iconst; double dconst; uint64_t bits[2]; }; } node_data_t; STATIC_ASSERT(sizeof(node_data_t) == 40); typedef uint32_t node_id_t; typedef struct { unsigned num_nodes; unsigned max_nodes; node_id_t *nodes; loc_t last_loc; int gap_pos; } block_data_t; typedef struct { ident_t name; mir_type_t type; mir_stamp_t stamp; } param_data_t; typedef struct { ident_t name; mir_type_t type; mir_stamp_t stamp; mir_type_t pointer; mir_var_flags_t flags; } var_data_t; typedef struct { int64_t low, high; } mir_intg_type_t; typedef struct { double low, high; } mir_real_type_t; typedef struct { unsigned size; mir_type_t elem; mir_type_t pointer; } mir_carray_type_t; typedef struct { unsigned dims; mir_type_t elem; mir_type_t pointer; } mir_uarray_type_t; typedef struct { mir_type_t base; mir_type_t pointer; } mir_signal_type_t; typedef struct { mir_type_t to; mir_type_t pointer; } mir_access_type_t; typedef struct { ident_t name; mir_type_t *fields; unsigned count; } mir_record_type_t; typedef struct { mir_type_t rtype; } mir_closure_type_t; typedef struct { unsigned size; bool issigned; } mir_vec_type_t; typedef struct { mir_class_t class : 16; mir_repr_t repr : 16; uint32_t hash; union { mir_intg_type_t intg; mir_real_type_t real; mir_type_t pointer; mir_carray_type_t carray; mir_uarray_type_t uarray; mir_signal_type_t signal; mir_access_type_t access; mir_record_type_t record; mir_closure_type_t closure; mir_type_t base; mir_vec_type_t vec; ident_t context; } u; } type_data_t; STATIC_ASSERT(sizeof(type_data_t) <= 32); typedef enum { _MIR_INVALID_STAMP, MIR_STAMP_INT, MIR_STAMP_REAL, MIR_STAMP_POINTER, } mir_stamp_kind_t; typedef struct { mir_stamp_t elem; mir_mem_t memory; } mir_ptr_stamp_t; typedef struct { mir_stamp_kind_t kind; uint32_t hash; union { mir_intg_type_t intg; mir_real_type_t real; mir_ptr_stamp_t pointer; } u; } stamp_data_t; typedef struct { mir_block_t block; unsigned pos; loc_t loc; } mir_cursor_t; typedef struct { mir_type_t offset_type; mir_type_t bool_type; mir_type_t time_type; mir_type_t logic_type; mir_type_t double_type; mir_type_t char_type; mir_type_t locus_type; mir_type_t conversion_type; mir_type_t trigger_type; mir_type_t self_type; mir_type_t string_type; } known_types_t; typedef struct { unsigned count; unsigned limit; block_data_t *items; } block_tab_t; typedef struct { unsigned count; unsigned limit; param_data_t *items; } param_tab_t; typedef struct { unsigned count; unsigned limit; var_data_t *items; } var_tab_t; typedef struct { unsigned count; unsigned limit; stamp_data_t *items; } stamp_tab_t; typedef struct { unsigned count; unsigned limit; ident_t *items; } link_tab_t; typedef struct _mir_unit { mir_context_t *context; ident_t name; object_t *object; mir_unit_kind_t kind; mir_shape_t *parent; mir_shape_t *shape; mem_pool_t *pool; hash_t *objmap; hash_t *privmap; mir_type_t result; known_types_t types; mir_cursor_t cursor; block_tab_t blocks; param_tab_t params; var_tab_t vars; stamp_tab_t stamps; link_tab_t linkage; link_tab_t extvars; unsigned num_nodes; unsigned max_nodes; node_data_t *nodes; mir_value_t *argspill; unsigned num_argspill; unsigned max_argspill; #ifdef DEBUG text_buf_t *comments; #endif } mir_unit_t; typedef enum { FREE_MARKER, BUSY_MARKER, INUSE_MARKER, MOVED_MARKER, } mir_marker_t; typedef union { struct { uint32_t marker : 2; uint32_t id : 30; }; uint32_t bits; } type_slot_t; STATIC_ASSERT(sizeof(type_slot_t) == 4); typedef struct { uint32_t max_types; uint32_t next_id; type_slot_t *hashtab; type_data_t types[0]; } type_tab_t; typedef struct _mir_context { type_tab_t *typetab; type_tab_t *resizing; chash_t *map; mem_pool_t *pool; nvc_lock_t pool_mtx; } mir_context_t; typedef struct { ident_t name; mir_type_t type; mir_type_t pointer; } shape_slot_t; typedef struct _mir_shape { ident_t name; mir_shape_t *parent; hash_t *objmap; mir_type_t type; mir_unit_kind_t kind; unsigned num_slots; shape_slot_t slots[]; } mir_shape_t; typedef struct { ident_t name; ident_t parent; mir_lower_fn_t fn; object_t *object; mir_unit_kind_t kind; } deferred_unit_t; #endif // _MIR_STRUCTS_H nvc-r1.17.1/src/mir/mir-type.c000066400000000000000000001025631504111170000160360ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-priv.h" #include "mir/mir-structs.h" #include "thread.h" #include #include #include #include #define REPROBE_LIMIT 10 static inline int64_t sadd64(int64_t a, int64_t b) { int64_t result; if (__builtin_add_overflow(a, b, &result)) return b < 0 ? INT64_MIN : INT64_MAX; return result; } static inline int64_t ssub64(int64_t a, int64_t b) { int64_t result; if (__builtin_sub_overflow(a, b, &result)) return b > 0 ? INT64_MIN : INT64_MAX; return result; } static inline int64_t smul64(int64_t a, int64_t b) { int64_t result; if (__builtin_mul_overflow(a, b, &result)) return (a > 0 && b > 0) || (a < 0 && b < 0) ? INT64_MAX : INT64_MIN; return result; } static uint32_t mir_hash_type(mir_unit_t *mu, const type_data_t *td) { uint32_t h = knuth_hash(td->class); switch (td->class) { case _MIR_INVALID_TYPE: case MIR_TYPE_OFFSET: case MIR_TYPE_LOCUS: case MIR_TYPE_CONVERSION: case MIR_TYPE_OPAQUE: case MIR_TYPE_TRIGGER: break; case MIR_TYPE_POINTER: h ^= mir_type_data(mu, td->u.pointer)->hash; break; case MIR_TYPE_SIGNAL: h ^= mir_type_data(mu, td->u.signal.base)->hash; break; case MIR_TYPE_INT: h ^= mix_bits_64(td->u.intg.low) >> 32; h ^= mix_bits_64(td->u.intg.high); break; case MIR_TYPE_REAL: h ^= mix_bits_64(FLOAT_BITS(td->u.real.low)) >> 32; h ^= mix_bits_64(FLOAT_BITS(td->u.real.high)); break; case MIR_TYPE_CARRAY: h += knuth_hash(td->u.carray.size); h ^= mir_type_data(mu, td->u.carray.elem)->hash; break; case MIR_TYPE_UARRAY: h += knuth_hash(td->u.uarray.dims); h ^= mir_type_data(mu, td->u.uarray.elem)->hash; break; case MIR_TYPE_CONTEXT: h ^= ident_hash(td->u.context); break; case MIR_TYPE_ACCESS: h ^= mir_type_data(mu, td->u.access.to)->hash; break; case MIR_TYPE_RECORD: h ^= ident_hash(td->u.record.name); for (int i = 0; i < td->u.record.count; i++) h ^= mir_type_data(mu, td->u.record.fields[i])->hash; break; case MIR_TYPE_CLOSURE: h ^= mir_type_data(mu, td->u.closure.rtype)->hash; break; case MIR_TYPE_RESOLUTION: case MIR_TYPE_FILE: h ^= mir_type_data(mu, td->u.base)->hash; break; case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: h ^= knuth_hash(td->u.vec.size) ^ td->u.vec.issigned; break; } return h; } static bool mir_compare_types(const type_data_t *a, const type_data_t *b) { if (a->class != b->class) return false; switch (a->class) { case _MIR_INVALID_TYPE: return false; case MIR_TYPE_OFFSET: case MIR_TYPE_LOCUS: case MIR_TYPE_OPAQUE: case MIR_TYPE_CONVERSION: case MIR_TYPE_TRIGGER: return true; case MIR_TYPE_POINTER: return a->u.pointer.bits == b->u.pointer.bits; case MIR_TYPE_SIGNAL: return a->u.signal.base.bits == b->u.signal.base.bits; case MIR_TYPE_INT: return a->u.intg.low == b->u.intg.low && a->u.intg.high == b->u.intg.high; case MIR_TYPE_REAL: return a->u.real.low == b->u.real.low && a->u.real.high == b->u.real.high; case MIR_TYPE_CARRAY: return a->u.carray.size == b->u.carray.size && a->u.carray.elem.bits == b->u.carray.elem.bits; case MIR_TYPE_UARRAY: return a->u.uarray.dims == b->u.uarray.dims && a->u.uarray.elem.bits == b->u.uarray.elem.bits; case MIR_TYPE_CONTEXT: return a->u.context == b->u.context; case MIR_TYPE_ACCESS: return a->u.access.to.bits == b->u.access.to.bits; case MIR_TYPE_RECORD: if (a->u.record.name != b->u.record.name) return false; else if (a->u.record.count != b->u.record.count) return false; else { for (int i = 0; i < a->u.record.count; i++) { if (a->u.record.fields[i].bits != b->u.record.fields[i].bits) return false; } return true; } case MIR_TYPE_CLOSURE: return a->u.closure.rtype.bits == b->u.closure.rtype.bits; case MIR_TYPE_RESOLUTION: case MIR_TYPE_FILE: return a->u.base.bits == b->u.base.bits; case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: return a->u.vec.size == b->u.vec.size && a->u.vec.size == b->u.vec.size; } should_not_reach_here(); } const type_data_t *mir_type_data(mir_unit_t *mu, mir_type_t type) { mir_context_t *mc = mu->context; type_tab_t *tab = load_acquire(&mc->typetab); assert(type.tag == MIR_TAG_TYPE); assert(type.id < tab->max_types); const type_data_t *td = &(tab->types[type.id]); assert(td->class != _MIR_INVALID_TYPE); return td; } static void mir_install_type(mir_unit_t *mu, type_data_t *dst, const type_data_t *src, uint32_t hash) { dst->class = src->class; dst->repr = src->repr; dst->hash = hash; switch (src->class) { case MIR_TYPE_CARRAY: { const mir_carray_type_t *src_a = &src->u.carray; mir_carray_type_t *dst_a = &dst->u.carray; dst_a->elem = src_a->elem; dst_a->size = src_a->size; dst_a->pointer = mir_pointer_type(mu, src_a->elem); } break; case MIR_TYPE_UARRAY: { const mir_uarray_type_t *src_a = &src->u.uarray; mir_uarray_type_t *dst_a = &dst->u.uarray; dst_a->dims = src_a->dims; dst_a->elem = src_a->elem; if (mir_get_class(mu, src_a->elem) == MIR_TYPE_SIGNAL) dst_a->pointer = src_a->elem; else dst_a->pointer = mir_pointer_type(mu, src_a->elem); } break; case MIR_TYPE_RECORD: { const mir_record_type_t *src_r = &src->u.record; mir_record_type_t *dst_r = &dst->u.record; dst_r->name = src_r->name; dst_r->count = src_r->count; dst_r->fields = mir_global_malloc(mu->context, 0, src_r->count * 2, sizeof(mir_type_t)); for (int i = 0; i < src_r->count; i++) { mir_type_t pointer = mir_get_var_pointer(mu, src_r->fields[i]); dst_r->fields[i] = src->u.record.fields[i]; dst_r->fields[i + src_r->count] = pointer; } } break; case MIR_TYPE_ACCESS: { const mir_access_type_t *src_a = &src->u.access; mir_access_type_t *dst_a = &dst->u.access; dst_a->to = src_a->to; dst_a->pointer = mir_pointer_type(mu, src_a->to); } break; case MIR_TYPE_SIGNAL: { const mir_signal_type_t *src_s = &src->u.signal; mir_signal_type_t *dst_s = &dst->u.signal; dst_s->base = src_s->base; dst_s->pointer = mir_pointer_type(mu, src_s->base); } break; default: dst->u = src->u; } } __attribute__((always_inline)) static inline type_slot_t mir_type_slot(const type_tab_t *tab, int pos) { return (type_slot_t) { .bits = load_acquire(&tab->hashtab[pos].bits) }; } static void mir_copy_table(type_tab_t *from, type_tab_t *to) { uint32_t max_id = 0; for (int i = 0; i < from->max_types; i++) { for (;;) { const type_slot_t slot = mir_type_slot(from, i); switch (slot.marker) { case BUSY_MARKER: spin_wait(); continue; case INUSE_MARKER: { const type_data_t *from_td = &(from->types[slot.id]); type_data_t *to_td = &(to->types[slot.id]); max_id = MAX((uint32_t)slot.id, max_id); for (int pos = from_td->hash & (to->max_types - 1);; pos = (pos + 1) & (to->max_types - 1)) { const type_slot_t exist = mir_type_slot(to, pos); if (exist.marker == FREE_MARKER) { *to_td = *from_td; store_release(&(to->hashtab[pos].bits), slot.bits); break; } else assert(exist.marker == INUSE_MARKER); } } break; case FREE_MARKER: break; default: should_not_reach_here(); } const type_slot_t moved = { .marker = MOVED_MARKER, .id = slot.id }; if (atomic_cas(&(from->hashtab[i].bits), slot.bits, moved.bits)) break; else assert(slot.marker == FREE_MARKER); // Raced to move free slot } } atomic_store(&to->next_id, max_id + 1); } static void mir_wait_for_resize(mir_context_t *mc) { for (;;) { type_tab_t *from = atomic_load(&mc->typetab); type_tab_t *to = atomic_load(&mc->resizing); if (from == to) break; thread_sleep(10); } } static void mir_grow_table(mir_context_t *mc, type_tab_t *cur) { type_tab_t *newtab = xcalloc_flex(sizeof(type_tab_t), cur->max_types * 2, sizeof(type_data_t)); newtab->max_types = cur->max_types * 2; newtab->hashtab = xcalloc_array(newtab->max_types, sizeof(uint32_t)); if (atomic_cas(&mc->resizing, cur, newtab)) { mir_copy_table(cur, newtab); assert(atomic_load(&mc->resizing) == newtab); if (!atomic_cas(&mc->typetab, cur, newtab)) should_not_reach_here(); async_free(cur->hashtab); async_free(cur); } else { free(newtab); mir_wait_for_resize(mc); } } static mir_type_t mir_try_build_type(mir_unit_t *mu, const type_data_t *td, uint32_t hash) { mir_context_t *mc = mu->context; type_tab_t *tab = load_acquire(&mc->typetab); assert(is_power_of_2(tab->max_types)); if (tab->next_id > tab->max_types / 2) { mir_grow_table(mc, tab); return MIR_NULL_TYPE; } for (int pos = hash & (tab->max_types - 1);; pos = (pos + 1) & (tab->max_types - 1)) { const type_slot_t slot = mir_type_slot(tab, pos); switch (slot.marker) { case BUSY_MARKER: spin_wait(); return MIR_NULL_TYPE; case FREE_MARKER: { // Copy the type data before CAS-ing the slot to busy since // mir_install_type may allocate new types and deadlock type_data_t copy; mir_install_type(mu, ©, td, hash); const type_slot_t busy = { .marker = BUSY_MARKER }; if (atomic_cas(&tab->hashtab[pos].bits, slot.bits, busy.bits)) { const uint32_t id = atomic_fetch_add(&tab->next_id, 1); const type_slot_t new = { .marker = INUSE_MARKER, .id = id }; if (unlikely(new.id != id)) fatal_trace("too many types"); tab->types[id] = copy; store_release(&tab->hashtab[pos].bits, new.bits); return (mir_type_t){ .tag = MIR_TAG_TYPE, .id = id }; } else { // Raced for this slot, leak copy for now spin_wait(); return MIR_NULL_TYPE; } } case INUSE_MARKER: if (hash != tab->types[slot.id].hash) break; else if (mir_compare_types(td, &(tab->types[slot.id]))) return (mir_type_t){ .tag = MIR_TAG_TYPE, .id = slot.id }; break; case MOVED_MARKER: mir_wait_for_resize(mc); return MIR_NULL_TYPE; } } } static mir_type_t mir_build_type(mir_unit_t *mu, const type_data_t *td) { const uint32_t hash = mir_hash_type(mu, td); mir_type_t type; do { type = mir_try_build_type(mu, td, hash); } while (mir_is_null(type)); return type; } mir_type_t mir_int_type(mir_unit_t *mu, int64_t low, int64_t high) { mir_repr_t repr; switch (bits_for_range(low, high)) { case 64: repr = low < 0 ? MIR_REPR_I64 : MIR_REPR_U64; break; case 32: repr = low < 0 ? MIR_REPR_I32 : MIR_REPR_U32; break; case 16: repr = low < 0 ? MIR_REPR_I16 : MIR_REPR_U16; break; case 8: repr = low < 0 ? MIR_REPR_I8 : MIR_REPR_U8; break; case 1: repr = MIR_REPR_U1; break; case 0: repr = MIR_REPR_I64; break; // Null range default: fatal_trace("cannot represent %"PRIi64"..%"PRIi64, low, high); } const type_data_t td = { .class = MIR_TYPE_INT, .repr = repr, .u = { .intg = { .low = low, .high = high } } }; return mir_build_type(mu, &td); } mir_type_t mir_real_type(mir_unit_t *mu, double low, double high) { const type_data_t td = { .class = MIR_TYPE_REAL, .u = { .real = { .low = low, .high = high } } }; return mir_build_type(mu, &td); } mir_type_t mir_offset_type(mir_unit_t *mu) { if (mir_is_null(mu->types.offset_type)) { const type_data_t td = { .class = MIR_TYPE_OFFSET, .repr = MIR_REPR_I64, .u = { .intg = { .low = INT64_MIN, .high = INT64_MAX } } }; mu->types.offset_type = mir_build_type(mu, &td); } return mu->types.offset_type; } mir_type_t mir_locus_type(mir_unit_t *mu) { if (mir_is_null(mu->types.locus_type)) { const type_data_t td = { .class = MIR_TYPE_LOCUS }; mu->types.locus_type = mir_build_type(mu, &td); } return mu->types.locus_type; } mir_type_t mir_conversion_type(mir_unit_t *mu) { if (mir_is_null(mu->types.conversion_type)) { const type_data_t td = { .class = MIR_TYPE_CONVERSION }; mu->types.conversion_type = mir_build_type(mu, &td); } return mu->types.conversion_type; } mir_type_t mir_trigger_type(mir_unit_t *mu) { if (mir_is_null(mu->types.trigger_type)) { const type_data_t td = { .class = MIR_TYPE_TRIGGER }; mu->types.trigger_type = mir_build_type(mu, &td); } return mu->types.trigger_type; } mir_type_t mir_self_type(mir_unit_t *mu) { if (mir_is_null(mu->types.self_type)) { const type_data_t td = { .class = MIR_TYPE_CONTEXT, .u.context = mu->name, }; mu->types.self_type = mir_build_type(mu, &td); } return mu->types.self_type; } mir_type_t mir_bool_type(mir_unit_t *mu) { if (mir_is_null(mu->types.bool_type)) mu->types.bool_type = mir_int_type(mu, 0, 1); return mu->types.bool_type; } mir_type_t mir_time_type(mir_unit_t *mu) { if (mir_is_null(mu->types.time_type)) mu->types.time_type = mir_int_type(mu, INT64_MIN, INT64_MAX); return mu->types.time_type; } mir_type_t mir_logic_type(mir_unit_t *mu) { if (mir_is_null(mu->types.logic_type)) mu->types.logic_type = mir_int_type(mu, 0, UINT8_MAX); return mu->types.logic_type; } mir_type_t mir_double_type(mir_unit_t *mu) { if (mir_is_null(mu->types.double_type)) mu->types.double_type = mir_real_type(mu, -DBL_MAX, DBL_MAX); return mu->types.double_type; } mir_type_t mir_char_type(mir_unit_t *mu) { if (mir_is_null(mu->types.char_type)) mu->types.char_type = mir_int_type(mu, 0, UINT8_MAX); return mu->types.char_type; } mir_type_t mir_string_type(mir_unit_t *mu) { if (mir_is_null(mu->types.string_type)) mu->types.string_type = mir_uarray_type(mu, 1, mir_char_type(mu)); return mu->types.string_type; } mir_type_t mir_pointer_type(mir_unit_t *mu, mir_type_t to) { MIR_ASSERT(mir_get_class(mu, to) != MIR_TYPE_CARRAY, "cannot get pointer to carray type"); const type_data_t td = { .class = MIR_TYPE_POINTER, .u = { .pointer = to } }; return mir_build_type(mu, &td); } mir_type_t mir_access_type(mir_unit_t *mu, mir_type_t to) { const type_data_t td = { .class = MIR_TYPE_ACCESS, .u = { .access = { .to = to } }, }; return mir_build_type(mu, &td); } mir_type_t mir_opaque_type(mir_unit_t *mu) { const type_data_t td = { .class = MIR_TYPE_OPAQUE, }; return mir_build_type(mu, &td); } mir_type_t mir_record_type(mir_unit_t *mu, ident_t name, const mir_type_t *fields, unsigned count) { const type_data_t td = { .class = MIR_TYPE_RECORD, .u = { .record = { .name = name, .fields = (mir_type_t *)fields, // Copied in mir_install_type .count = count } } }; return mir_build_type(mu, &td); } mir_type_t mir_closure_type(mir_unit_t *mu, mir_type_t atype, mir_type_t rtype) { const type_data_t td = { .class = MIR_TYPE_CLOSURE, .u = { .closure = { .rtype = rtype } }, }; return mir_build_type(mu, &td); } mir_type_t mir_resolution_type(mir_unit_t *mu, mir_type_t base) { const type_data_t td = { .class = MIR_TYPE_RESOLUTION, .u = { .base = base }, }; return mir_build_type(mu, &td); } mir_type_t mir_file_type(mir_unit_t *mu, mir_type_t base) { const type_data_t td = { .class = MIR_TYPE_FILE, .u = { .base = base }, }; return mir_build_type(mu, &td); } mir_type_t mir_carray_type(mir_unit_t *mu, int size, mir_type_t elem) { MIR_ASSERT(mir_get_class(mu, elem) != MIR_TYPE_CARRAY, "array types may not be nested"); const type_data_t td = { .class = MIR_TYPE_CARRAY, .u = { .carray = { .size = size, .elem = elem, } } }; return mir_build_type(mu, &td); } mir_type_t mir_uarray_type(mir_unit_t *mu, int ndim, mir_type_t elem) { MIR_ASSERT(mir_get_class(mu, elem) != MIR_TYPE_CARRAY, "array types may not be nested"); const type_data_t td = { .class = MIR_TYPE_UARRAY, .u = { .uarray = { .dims = ndim, .elem = elem, } } }; return mir_build_type(mu, &td); } mir_type_t mir_signal_type(mir_unit_t *mu, mir_type_t base) { const type_data_t td = { .class = MIR_TYPE_SIGNAL, .u = { .signal = { .base = base } } }; return mir_build_type(mu, &td); } mir_type_t mir_context_type(mir_unit_t *mu, ident_t name) { const type_data_t td = { .class = MIR_TYPE_CONTEXT, .u = { .context = name } }; return mir_build_type(mu, &td); } mir_type_t mir_vec2_type(mir_unit_t *mu, int size, bool issigned) { assert(size >= 0); const type_data_t td = { .class = MIR_TYPE_VEC2, .u = { .vec = { .size = size, .issigned = issigned } } }; return mir_build_type(mu, &td); } mir_type_t mir_vec4_type(mir_unit_t *mu, int size, bool issigned) { assert(size >= 0); const type_data_t td = { .class = MIR_TYPE_VEC4, .u = { .vec = { .size = size, .issigned = issigned } } }; return mir_build_type(mu, &td); } mir_type_t mir_get_base(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_SIGNAL: return td->u.signal.base; case MIR_TYPE_RESOLUTION: case MIR_TYPE_FILE: return td->u.base; default: return MIR_NULL_TYPE; } } mir_type_t mir_get_elem(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_UARRAY: return td->u.uarray.elem; case MIR_TYPE_CARRAY: return td->u.carray.elem; case MIR_TYPE_ACCESS: return td->u.access.to; case MIR_TYPE_POINTER: return td->u.pointer; default: return MIR_NULL_TYPE; } } mir_type_t mir_get_pointer(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_SIGNAL: return td->u.signal.pointer; case MIR_TYPE_POINTER: return td->u.pointer; case MIR_TYPE_UARRAY: return td->u.uarray.pointer; case MIR_TYPE_CARRAY: return td->u.carray.pointer; case MIR_TYPE_ACCESS: return td->u.access.pointer; default: return MIR_NULL_TYPE; } } mir_type_t mir_get_var_pointer(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_CARRAY: return td->u.carray.pointer; default: return mir_pointer_type(mu, type); } } unsigned mir_get_dims(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_UARRAY: return td->u.uarray.dims; default: should_not_reach_here(); } } unsigned mir_get_size(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_CARRAY: return td->u.carray.size; case MIR_TYPE_VEC2: case MIR_TYPE_VEC4: return td->u.vec.size; default: should_not_reach_here(); } } mir_class_t mir_get_class(mir_unit_t *mu, mir_type_t type) { return mir_type_data(mu, type)->class; } mir_repr_t mir_get_repr(mir_unit_t *mu, mir_type_t type) { const type_data_t *td = mir_type_data(mu, type); switch (td->class) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: return td->repr; default: should_not_reach_here(); } } const mir_type_t *mir_get_fields(mir_unit_t *mu, mir_type_t type, size_t *count) { const type_data_t *td = mir_type_data(mu, type); assert(td->class == MIR_TYPE_RECORD); if (count != NULL) *count = td->u.record.count; return td->u.record.fields; } static uint32_t mir_hash_stamp(mir_unit_t *mu, const stamp_data_t *sd) { uint32_t h = sd->kind; switch (sd->kind) { case _MIR_INVALID_STAMP: break; case MIR_STAMP_INT: h ^= mix_bits_64(sd->u.intg.low) >> 32; h ^= mix_bits_64(sd->u.intg.high); break; case MIR_STAMP_REAL: h ^= mix_bits_64(FLOAT_BITS(sd->u.real.low)) >> 32; h ^= mix_bits_64(FLOAT_BITS(sd->u.real.high)); break; case MIR_STAMP_POINTER: h += knuth_hash(sd->u.pointer.memory); if (!mir_is_null(sd->u.pointer.elem)) h ^= mir_stamp_data(mu, sd->u.pointer.elem)->hash; break; } return h; } static bool mir_compare_stamps(const stamp_data_t *a, const stamp_data_t *b) { if (a->kind != b->kind) return false; switch (a->kind) { case _MIR_INVALID_STAMP: return false; case MIR_STAMP_INT: return a->u.intg.low == b->u.intg.low && a->u.intg.high == b->u.intg.high; case MIR_STAMP_REAL: return a->u.real.low == b->u.real.low && a->u.real.high == b->u.real.high; case MIR_STAMP_POINTER: return a->u.pointer.memory == b->u.pointer.memory && a->u.pointer.elem.bits == b->u.pointer.elem.bits; } should_not_reach_here(); } static mir_stamp_t mir_build_stamp(mir_unit_t *mu, const stamp_data_t *sd) { const uint32_t hash = mir_hash_stamp(mu, sd); for (int i = 0; i < mu->stamps.count; i++) { const stamp_data_t *other = &(mu->stamps.items[i]); if (other->hash == hash && mir_compare_stamps(other, sd)) return (mir_stamp_t){ .tag = MIR_TAG_STAMP, .id = i }; } mir_stamp_t s = { .tag = MIR_TAG_STAMP, .id = mu->stamps.count }; stamp_data_t new = { .kind = sd->kind, .hash = hash, .u = sd->u, }; APUSH(mu->stamps, new); return s; } const stamp_data_t *mir_stamp_data(mir_unit_t *mu, mir_stamp_t stamp) { assert(stamp.tag == MIR_TAG_STAMP); return AREF(mu->stamps, stamp.id); } mir_stamp_t mir_int_stamp(mir_unit_t *mu, int64_t low, int64_t high) { assert(low <= high); const stamp_data_t sd = { .kind = MIR_STAMP_INT, .u = { .intg = { .low = low, .high = high } } }; return mir_build_stamp(mu, &sd); } mir_stamp_t mir_real_stamp(mir_unit_t *mu, double low, double high) { assert(low <= high); const stamp_data_t sd = { .kind = MIR_STAMP_REAL, .u = { .real = { .low = low, .high = high } } }; return mir_build_stamp(mu, &sd); } mir_stamp_t mir_pointer_stamp(mir_unit_t *mu, mir_mem_t mem, mir_stamp_t elem) { const stamp_data_t sd = { .kind = MIR_STAMP_POINTER, .u = { .pointer = { .memory = mem, .elem = elem } }, }; return mir_build_stamp(mu, &sd); } bool mir_is_top(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp) { const type_data_t *td = mir_type_data(mu, type); const stamp_data_t *sd = mir_stamp_data(mu, stamp); switch (td->class) { case MIR_TYPE_INT: case MIR_TYPE_OFFSET: return sd->u.intg.low <= td->u.intg.low && sd->u.intg.high >= td->u.intg.high; default: return false; } } mir_stamp_t mir_stamp_elem(mir_unit_t *mu, mir_stamp_t stamp) { if (mir_is_null(stamp)) return MIR_NULL_STAMP; const stamp_data_t *sd = mir_stamp_data(mu, stamp); switch (sd->kind) { case MIR_STAMP_POINTER: return sd->u.pointer.elem; default: return MIR_NULL_STAMP; } } mir_stamp_t mir_stamp_add(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: { const int64_t low = sadd64(lsd->u.intg.low, rsd->u.intg.low); const int64_t high = sadd64(lsd->u.intg.high, rsd->u.intg.high); return mir_int_stamp(mu, low, high); } case MIR_STAMP_REAL: { const double low = lsd->u.real.low + rsd->u.real.low; const double high = lsd->u.real.high + rsd->u.real.high; return mir_real_stamp(mu, low, high); } default: should_not_reach_here(); } } mir_stamp_t mir_stamp_sub(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: { const int64_t low = ssub64(lsd->u.intg.low, rsd->u.intg.high); const int64_t high = ssub64(lsd->u.intg.high, rsd->u.intg.low); return mir_int_stamp(mu, low, high); } case MIR_STAMP_REAL: { const double low = lsd->u.real.low - rsd->u.real.high; const double high = lsd->u.real.high - rsd->u.real.low; return mir_real_stamp(mu, low, high); } default: should_not_reach_here(); } } mir_stamp_t mir_stamp_mul(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: { const int64_t ll = smul64(lsd->u.intg.low, rsd->u.intg.low); const int64_t lh = smul64(lsd->u.intg.low, rsd->u.intg.high); const int64_t hl = smul64(lsd->u.intg.high, rsd->u.intg.low); const int64_t hh = smul64(lsd->u.intg.high, rsd->u.intg.high); int64_t min = MIN(MIN(ll, lh), MIN(hl, hh)); int64_t max = MAX(MAX(ll, lh), MAX(hl, hh)); return mir_int_stamp(mu, min, max); } case MIR_STAMP_REAL: { const double ll = lsd->u.real.low * rsd->u.real.low; const double lh = lsd->u.real.low * rsd->u.real.high; const double hl = lsd->u.real.high * rsd->u.real.low; const double hh = lsd->u.real.high * rsd->u.real.high; double min = MIN(MIN(ll, lh), MIN(hl, hh)); double max = MAX(MAX(ll, lh), MAX(hl, hh)); return mir_real_stamp(mu, min, max); } default: should_not_reach_here(); } } mir_stamp_t mir_stamp_div(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; return MIR_NULL_STAMP; // TODO } mir_stamp_t mir_stamp_rem(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: if (lsd->u.intg.low >= 0 && rsd->u.intg.high > 0) return mir_int_stamp(mu, 0, rsd->u.intg.high - 1); else return MIR_NULL_STAMP; default: should_not_reach_here(); } } mir_stamp_t mir_stamp_cmp(mir_unit_t *mu, mir_cmp_t cmp, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left) || mir_is_null(right)) return MIR_NULL_STAMP; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: { const int64_t a = lsd->u.intg.low; const int64_t b = lsd->u.intg.high; const int64_t c = rsd->u.intg.low; const int64_t d = rsd->u.intg.high; int trueval = 1; switch (cmp) { case MIR_CMP_EQ: trueval = 0; // Fall-through case MIR_CMP_NEQ: if (MAX(a, c) <= MIN(b, d)) return MIR_NULL_STAMP; // Ranges overlap else return mir_int_stamp(mu, trueval, trueval); case MIR_CMP_GEQ: trueval = 0; // Fall-through case MIR_CMP_LT: if (b < c) return mir_int_stamp(mu, trueval, trueval); else if (a >= d) return mir_int_stamp(mu, !trueval, !trueval); else return MIR_NULL_STAMP; case MIR_CMP_LEQ: trueval = 0; // Fall-through case MIR_CMP_GT: if (a > d) return mir_int_stamp(mu, trueval, trueval); else if (b <= c) return mir_int_stamp(mu, !trueval, !trueval); else return MIR_NULL_STAMP; default: should_not_reach_here(); } } case MIR_STAMP_REAL: return MIR_NULL_STAMP; default: should_not_reach_here(); } } mir_stamp_t mir_stamp_union(mir_unit_t *mu, mir_stamp_t left, mir_stamp_t right) { if (mir_is_null(left)) return right; else if (mir_is_null(right)) return left; const stamp_data_t *lsd = mir_stamp_data(mu, left); const stamp_data_t *rsd = mir_stamp_data(mu, right); assert(lsd->kind == rsd->kind); switch (lsd->kind) { case MIR_STAMP_INT: { const int64_t low = MIN(lsd->u.intg.low, rsd->u.intg.low); const int64_t high = MAX(lsd->u.intg.high, rsd->u.intg.high); return mir_int_stamp(mu, low, high); } case MIR_STAMP_REAL: { const double low = MIN(lsd->u.real.low, rsd->u.real.low); const double high = MAX(lsd->u.real.high, rsd->u.real.high); return mir_real_stamp(mu, low, high); } default: should_not_reach_here(); } } mir_stamp_t mir_stamp_cast(mir_unit_t *mu, mir_type_t type, mir_stamp_t stamp) { if (mir_is_null(stamp)) return stamp; const type_data_t *td = mir_type_data(mu, type); const stamp_data_t *sd = mir_stamp_data(mu, stamp); switch (td->class) { case MIR_TYPE_OFFSET: case MIR_TYPE_INT: if (sd->kind == MIR_STAMP_INT) return mir_int_stamp(mu, MAX(td->u.intg.low, sd->u.intg.low), MIN(td->u.intg.high, sd->u.intg.high)); else return MIR_NULL_STAMP; default: return MIR_NULL_STAMP; } } bool mir_stamp_const(mir_unit_t *mu, mir_stamp_t stamp, int64_t *cval) { if (mir_is_null(stamp)) return false; const stamp_data_t *sd = mir_stamp_data(mu, stamp); if (sd->kind != MIR_STAMP_INT || sd->u.intg.low != sd->u.intg.high) return false; *cval = sd->u.intg.low; return true; } bool mir_same_type(mir_unit_t *mu, mir_type_t a, mir_type_t b) { if (mir_is_null(a) && mir_is_null(b)) return true; else if (mir_is_null(a)) { const type_data_t *btd = mir_type_data(mu, b); return btd->class == MIR_TYPE_OFFSET || btd->class == MIR_TYPE_INT; } else if (mir_is_null(b)) { const type_data_t *atd = mir_type_data(mu, a); return atd->class == MIR_TYPE_OFFSET || atd->class == MIR_TYPE_INT; } else return mir_equals(a, b); } void mir_free_types(type_tab_t *tab) { #ifdef DEBUG for (int i = 0; i < tab->max_types; i++) { const type_slot_t islot = mir_type_slot(tab, i); assert(islot.marker == FREE_MARKER || islot.marker == INUSE_MARKER); if (islot.marker == INUSE_MARKER) { const type_data_t *itd = &(tab->types[islot.id]); for (int j = 0; j < i; j++) { const type_slot_t jslot = mir_type_slot(tab, j); if (jslot.marker == INUSE_MARKER) { const type_data_t *jtd = &(tab->types[jslot.id]); if (mir_compare_types(itd, jtd)) fatal_trace("duplicate types in table at %d (%d => %08x) " "and %d (%d => %08x)", i, islot.id, itd->hash, j, jslot.id, jtd->hash); } } } } #endif free(tab->hashtab); free(tab); } nvc-r1.17.1/src/mir/mir-unit.c000066400000000000000000000234001504111170000160240ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "lib.h" #include "mir/mir-node.h" #include "mir/mir-priv.h" #include "mir/mir-structs.h" #include "mir/mir-unit.h" #include "object.h" #include "option.h" #include "thread.h" #include #include #define TYPE_TAB_SIZE 256 mir_context_t *mir_context_new(void) { mir_context_t *mc = xcalloc(sizeof(mir_context_t)); mc->map = chash_new(32); mc->pool = pool_new(); type_tab_t *tab = xcalloc_flex(sizeof(type_tab_t), TYPE_TAB_SIZE, sizeof(type_data_t)); tab->max_types = TYPE_TAB_SIZE; tab->hashtab = xcalloc_array(TYPE_TAB_SIZE, sizeof(uint32_t)); store_release(&mc->resizing, tab); store_release(&mc->typetab, tab); return mc; } static void mir_unit_free_memory(mir_unit_t *mu) { #ifdef DEBUG if (mu->comments != NULL) tb_free(mu->comments); #endif for (int i = 0; i < mu->blocks.count; i++) free(mu->blocks.items[i].nodes); ACLEAR(mu->blocks); ACLEAR(mu->params); ACLEAR(mu->vars); ACLEAR(mu->stamps); ACLEAR(mu->linkage); ACLEAR(mu->extvars); pool_free(mu->pool); hash_free(mu->objmap); hash_free(mu->privmap); free(mu->nodes); free(mu->argspill); free(mu); } static void mir_free_unit_cb(const void *key, void *value) { switch (pointer_tag(value)) { case UNIT_GENERATED: mir_unit_free_memory(untag_pointer(value, mir_unit_t)); break; case UNIT_FREED: { mir_shape_t *s = untag_pointer(value, mir_shape_t); hash_free(s->objmap); } break; } } void mir_context_free(mir_context_t *mc) { chash_iter(mc->map, mir_free_unit_cb); mir_free_types(mc->typetab); pool_free(mc->pool); chash_free(mc->map); free(mc); } mir_unit_t *mir_unit_new(mir_context_t *mc, ident_t name, object_t *object, mir_unit_kind_t kind, mir_shape_t *parent) { mir_unit_t *mu = xcalloc(sizeof(mir_unit_t)); mu->context = mc; mu->name = name; mu->object = object; mu->kind = kind; mu->parent = parent; mu->result = MIR_NULL_TYPE; mir_block_t entry = mir_add_block(mu); mir_set_cursor(mu, entry, MIR_APPEND); if (object != NULL) mir_set_loc(mu, &(object->loc)); return mu; } mir_unit_kind_t mir_get_kind(mir_unit_t *mu) { return mu->kind; } object_t *mir_get_object(mir_unit_t *mu) { return mu->object; } ident_t mir_get_parent(mir_unit_t *mu) { if (mu->parent != NULL) return mu->parent->name; else return NULL; } mir_context_t *mir_get_context(mir_unit_t *mu) { return mu->context; } int mir_find_slot(mir_shape_t *shape, ident_t name) { for (int i = 0; i < shape->num_slots; i++) { if (shape->slots[i].name == name) return i; } return -1; } ident_t mir_get_shape_parent(mir_shape_t *shape) { return shape->parent ? shape->parent->name : NULL; } mir_value_t mir_search_object(mir_unit_t *mu, const void *obj, int *hops) { *hops = 0; if (mu->objmap != NULL) { void *ptr = hash_get(mu->objmap, obj); if (ptr != NULL) return (mir_value_t){ .bits = (uintptr_t)ptr }; } for (mir_shape_t *s = mu->parent; s != NULL; s = s->parent) { (*hops)++; if (s->objmap != NULL) { void *ptr = hash_get(s->objmap, obj); if (ptr != NULL) { mir_value_t value = { .bits = (uintptr_t)ptr }; assert(value.tag == MIR_TAG_VAR); return value; } } } return MIR_NULL_VALUE; } void mir_put_object(mir_unit_t *mu, const void *obj, mir_value_t value) { if (mu->objmap == NULL) mu->objmap = hash_new(16); hash_put(mu->objmap, obj, (void *)(uintptr_t)value.bits); } void *mir_get_priv(mir_unit_t *mu, const void *obj) { if (mu->privmap == NULL) return NULL; else return hash_get(mu->privmap, obj); } void mir_put_priv(mir_unit_t *mu, const void *obj, void *value) { if (mu->privmap == NULL) mu->privmap = hash_new(16); hash_put(mu->privmap, obj, value); } void *mir_malloc(mir_unit_t *mu, size_t size) { if (mu->pool == NULL) mu->pool = pool_new(); return pool_malloc(mu->pool, size); } void *mir_global_malloc(mir_context_t *mc, size_t fixed, size_t nelems, size_t size) { SCOPED_LOCK(mc->pool_mtx); return pool_malloc_flex(mc->pool, fixed, nelems, size); } static mir_shape_t *mir_build_shape(mir_unit_t *mu) { mir_shape_t *sh = mir_global_malloc(mu->context, sizeof(mir_shape_t), mu->vars.count, sizeof(shape_slot_t)); sh->name = mu->name; sh->kind = mu->kind; sh->type = mir_self_type(mu); sh->num_slots = mu->vars.count; sh->parent = mu->parent; sh->objmap = mu->objmap; mu->objmap = NULL; // Takes ownership for (int i = 0; i < mu->vars.count; i++) { const var_data_t *vd = &(mu->vars.items[i]); sh->slots[i].name = vd->name; sh->slots[i].type = vd->type; sh->slots[i].pointer = vd->pointer; } return sh; } void mir_unit_free(mir_unit_t *mu) { if (mu->name != NULL) { void *ptr = chash_get(mu->context->map, mu->name); switch (pointer_tag(ptr)) { case UNIT_GENERATED: { mir_shape_t *sh = mu->shape ?: mir_build_shape(mu); chash_put(mu->context->map, mu->name, tag_pointer(sh, UNIT_FREED)); } break; case UNIT_FREED: case UNIT_DEFERRED: should_not_reach_here(); default: break; } } mir_unit_free_memory(mu); } void mir_put_unit(mir_context_t *mc, mir_unit_t *mu) { assert(mu->context == mc); #ifdef DEBUG void *ptr = chash_get(mc->map, mu->name); if (ptr != NULL) fatal_trace("%s already registered", istr(mu->name)); #endif if (opt_get_verbose(OPT_LOWER_VERBOSE, istr(mu->name))) { mir_set_cursor(mu, MIR_NULL_BLOCK, MIR_APPEND); mir_dump(mu); } chash_put(mc->map, mu->name, tag_pointer(mu, UNIT_GENERATED)); } static mir_unit_t *mir_lazy_build(mir_context_t *mc, deferred_unit_t *du) { mir_shape_t *parent = NULL; if (du->parent != NULL && (parent = mir_get_shape(mc, du->parent)) == NULL) fatal_trace("cannot get parent %s of unit %s", istr(du->parent), istr(du->name)); mir_unit_t *mu = mir_unit_new(mc, du->name, du->object, du->kind, parent); (*du->fn)(mu, du->object); if (opt_get_verbose(OPT_LOWER_VERBOSE, istr(du->name))) { mir_set_cursor(mu, MIR_NULL_BLOCK, MIR_APPEND); mir_dump(mu); } chash_put(mc->map, du->name, tag_pointer(mu, UNIT_GENERATED)); return mu; } mir_unit_t *mir_get_unit(mir_context_t *mc, ident_t name) { void *ptr = chash_get(mc->map, name); if (ptr == NULL) return NULL; switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); return mir_lazy_build(mc, du); } case UNIT_GENERATED: return untag_pointer(ptr, mir_unit_t); case UNIT_FREED: fatal_trace("unit %s has already been freed", istr(name)); default: should_not_reach_here(); } } mir_shape_t *mir_get_shape(mir_context_t *mc, ident_t name) { void *ptr = chash_get(mc->map, name); if (ptr == NULL) return NULL; switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); mir_unit_t *mu = mir_lazy_build(mc, du); return (mu->shape = mir_build_shape(mu)); } case UNIT_GENERATED: { mir_unit_t *mu = untag_pointer(ptr, mir_unit_t); if (mu->shape != NULL) return mu->shape; return (mu->shape = mir_build_shape(mu)); } case UNIT_FREED: return untag_pointer(ptr, mir_shape_t); default: should_not_reach_here(); } } void mir_defer(mir_context_t *mc, ident_t name, ident_t parent, mir_unit_kind_t kind, mir_lower_fn_t fn, object_t *object) { #ifdef DEBUG void *ptr = chash_get(mc->map, name); if (ptr != NULL) { switch (pointer_tag(ptr)) { case UNIT_DEFERRED: { deferred_unit_t *du = untag_pointer(ptr, deferred_unit_t); assert(du->fn == fn); assert(du->kind == kind); assert(du->object == object); } return; case UNIT_GENERATED: { mir_unit_t *mu = untag_pointer(ptr, mir_unit_t); assert(mu->kind == kind); assert(mu->object == object); } return; case UNIT_FREED: { mir_shape_t *s = untag_pointer(ptr, mir_shape_t); assert(s->kind == kind); } return; default: should_not_reach_here(); } } #endif deferred_unit_t *du = mir_global_malloc(mc, sizeof(deferred_unit_t), 0, 0); du->name = name; du->fn = fn; du->parent = parent; du->kind = kind; du->object = object; chash_put(mc->map, name, tag_pointer(du, UNIT_DEFERRED)); } unsigned mir_count_linkage(mir_unit_t *mu) { return mu->linkage.count; } ident_t mir_get_linkage(mir_unit_t *mu, unsigned nth) { return AGET(mu->linkage, nth); } nvc-r1.17.1/src/mir/mir-unit.h000066400000000000000000000057531504111170000160440ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _MIR_UNIT_H #define _MIR_UNIT_H #include "prim.h" typedef union _mir_block mir_block_t; typedef union _mir_value mir_value_t; typedef enum { MIR_UNIT_FUNCTION, MIR_UNIT_PROCESS, MIR_UNIT_INSTANCE, MIR_UNIT_PROCEDURE, MIR_UNIT_PACKAGE, MIR_UNIT_PROTECTED, MIR_UNIT_THUNK, MIR_UNIT_PROPERTY, } mir_unit_kind_t; typedef struct { int (*begin_block)(mir_unit_t *, mir_block_t, int, void *); int (*value)(mir_unit_t *, mir_value_t, void *); void (*end_node)(mir_unit_t *, mir_block_t, mir_value_t, void *); } mir_annotate_t; typedef void (*mir_lower_fn_t)(mir_unit_t *, object_t *); mir_context_t *mir_context_new(void); void mir_context_free(mir_context_t *mc); void mir_put_unit(mir_context_t *mc, mir_unit_t *mu); mir_unit_t *mir_get_unit(mir_context_t *mc, ident_t name); mir_shape_t *mir_get_shape(mir_context_t *mc, ident_t name); void mir_defer(mir_context_t *mc, ident_t name, ident_t parent, mir_unit_kind_t kind, mir_lower_fn_t fn, object_t *object); unsigned mir_count_linkage(mir_unit_t *mu); ident_t mir_get_linkage(mir_unit_t *mu, unsigned nth); mir_unit_t *mir_import(mir_context_t *mc, vcode_unit_t vu); mir_unit_t *mir_unit_new(mir_context_t *mc, ident_t name, object_t *obj, mir_unit_kind_t kind, mir_shape_t *parent); void mir_dump(mir_unit_t *mu); void mir_annotate(mir_unit_t *mu, const mir_annotate_t *cb, void *ctx); void mir_unit_free(mir_unit_t *mu); mir_unit_kind_t mir_get_kind(mir_unit_t *mu); object_t *mir_get_object(mir_unit_t *mu); ident_t mir_get_parent(mir_unit_t *mu); ident_t mir_get_shape_parent(mir_shape_t *shape); mir_context_t *mir_get_context(mir_unit_t *mu); int mir_find_slot(mir_shape_t *shape, ident_t name); mir_value_t mir_search_object(mir_unit_t *mu, const void *obj, int *hops); void mir_put_object(mir_unit_t *mu, const void *obj, mir_value_t value); void *mir_get_priv(mir_unit_t *mu, const void *obj); void mir_put_priv(mir_unit_t *mu, const void *obj, void *value); void *mir_malloc(mir_unit_t *mu, size_t size); typedef enum { MIR_PASS_GVN = (1 << 0), MIR_PASS_DCE = (1 << 1), } mir_pass_t; #define MIR_PASS_O0 0 #define MIR_PASS_O1 (MIR_PASS_GVN | MIR_PASS_DCE) #define MIR_PASS_O2 (MIR_PASS_GVN | MIR_PASS_DCE) void mir_optimise(mir_unit_t *mu, mir_pass_t passes); #endif // _MIR_UNIT_H nvc-r1.17.1/src/mir/mir-vcode.c000066400000000000000000001660621504111170000161610ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "vcode.h" #include #include #include typedef struct { mir_block_t *blocks; mir_value_t *map; mir_value_t *vars; ihash_t *types; } mir_import_t; static mir_type_t import_type(mir_unit_t *mu, mir_import_t *imp, vcode_type_t vtype) { void *ptr = ihash_get(imp->types, vtype); if (ptr != NULL) return (mir_type_t){ .bits = (uintptr_t)ptr }; mir_type_t type; switch (vtype_kind(vtype)) { case VCODE_TYPE_INT: type = mir_int_type(mu, vtype_low(vtype), vtype_high(vtype)); break; case VCODE_TYPE_REAL: type = mir_real_type(mu, -DBL_MAX, DBL_MAX); break; case VCODE_TYPE_OFFSET: type = mir_offset_type(mu); break; case VCODE_TYPE_SIGNAL: type = mir_signal_type(mu, import_type(mu, imp, vtype_base(vtype))); break; case VCODE_TYPE_UARRAY: type = mir_uarray_type(mu, vtype_dims(vtype), import_type(mu, imp, vtype_elem(vtype))); break; case VCODE_TYPE_CARRAY: type = mir_carray_type(mu, vtype_size(vtype), import_type(mu, imp, vtype_elem(vtype))); break; case VCODE_TYPE_CONTEXT: type = mir_context_type(mu, vtype_name(vtype)); break; case VCODE_TYPE_ACCESS: type = mir_access_type(mu, import_type(mu, imp, vtype_pointed(vtype))); break; case VCODE_TYPE_OPAQUE: type = mir_opaque_type(mu); break; case VCODE_TYPE_CLOSURE: { mir_type_t atype = mir_opaque_type(mu); mir_type_t rtype = import_type(mu, imp, vtype_base(vtype)); type = mir_closure_type(mu, atype, rtype); } break; case VCODE_TYPE_RECORD: { const int nfields = vtype_fields(vtype); mir_type_t *fields LOCAL = xmalloc_array(nfields, sizeof(mir_type_t)); for (int i = 0; i < nfields; i++) fields[i] = import_type(mu, imp, vtype_field(vtype, i)); type = mir_record_type(mu, vtype_name(vtype), fields, nfields); } break; case VCODE_TYPE_POINTER: type = mir_pointer_type(mu, import_type(mu, imp, vtype_pointed(vtype))); break; case VCODE_TYPE_FILE: type = mir_file_type(mu, import_type(mu, imp, vtype_base(vtype))); break; case VCODE_TYPE_CONVERSION: type = mir_conversion_type(mu); break; case VCODE_TYPE_TRIGGER: type = mir_trigger_type(mu); break; case VCODE_TYPE_DEBUG_LOCUS: type = mir_locus_type(mu); break; case VCODE_TYPE_RESOLUTION: type = mir_resolution_type(mu, import_type(mu, imp, vtype_base(vtype))); break; default: vcode_dump(); fatal_trace("cannot import type kind %d", vtype_kind(vtype)); } ihash_put(imp->types, vtype, (void *)(uintptr_t)type.bits); return type; } static void import_package_init(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t context = MIR_NULL_VALUE; if (vcode_count_args(op) > 0) context = imp->map[vcode_get_arg(op, 0)]; ident_t name = vcode_get_func(op); imp->map[vcode_get_result(op)] = mir_build_package_init(mu, name, context); } static void import_link_package(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t context = mir_build_link_package(mu, vcode_get_ident(op)); imp->map[vcode_get_result(op)] = context; } static void import_link_var(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); vcode_type_t vtype = vtype_pointed(vcode_reg_type(result)); mir_value_t context = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vtype); ident_t unit_name = vtype_name(vcode_reg_type(vcode_get_arg(op, 0))); ident_t name = vcode_get_ident(op); imp->map[result] = mir_build_link_var(mu, unit_name, context, name, type); } static void import_return(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t result = MIR_NULL_VALUE; if (vcode_count_args(op) > 0) result = imp->map[vcode_get_arg(op, 0)]; mir_build_return(mu, result); } static void import_fcall(mir_unit_t *mu, mir_import_t *imp, int op) { const int nargs = vcode_count_args(op); mir_value_t *args LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) args[i] = imp->map[vcode_get_arg(op, i)]; ident_t func = vcode_get_func(op); vcode_reg_t result = vcode_get_result(op); if (result == VCODE_INVALID_REG) mir_build_fcall(mu, func, MIR_NULL_TYPE, MIR_NULL_STAMP, args, nargs); else { mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_fcall(mu, func, type, MIR_NULL_STAMP, args, nargs); } } static void import_pcall(mir_unit_t *mu, mir_import_t *imp, int op) { const int nargs = vcode_count_args(op); mir_value_t *args LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) args[i] = imp->map[vcode_get_arg(op, i)]; ident_t func = vcode_get_func(op); mir_block_t resume = imp->blocks[vcode_get_target(op, 0)]; mir_build_pcall(mu, func, resume, args, nargs); } static void import_resume(mir_unit_t *mu, mir_import_t *imp, int op) { mir_build_resume(mu, vcode_get_func(op)); } static void import_const(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_const(mu, type, vcode_get_value(op)); } static void import_const_real(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_const_real(mu, type, vcode_get_real(op)); } static void import_const_array(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); const int nargs = vcode_count_args(op); mir_value_t *elts LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) elts[i] = imp->map[vcode_get_arg(op, i)]; imp->map[result] = mir_const_array(mu, type, elts, nargs); } static void import_const_rep(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); mir_value_t value = imp->map[vcode_get_arg(op, 0)]; unsigned count = vcode_get_value(op); imp->map[result] = mir_build_const_rep(mu, type, value, count); } static void import_const_record(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); const int nargs = vcode_count_args(op); mir_value_t *elts LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) elts[i] = imp->map[vcode_get_arg(op, i)]; imp->map[result] = mir_const_record(mu, type, elts, nargs); } static void import_cmp(mir_unit_t *mu, mir_import_t *imp, int op) { const mir_cmp_t cmp = (mir_cmp_t)vcode_get_cmp(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_cmp(mu, cmp, left, right); } static void import_debug_locus(mir_unit_t *mu, mir_import_t *imp, int op) { object_t *obj = vcode_get_object(op); imp->map[vcode_get_result(op)] = mir_build_locus(mu, obj); } static void import_assert(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t severity = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 4)]; // TODO: returning VCODE_INVALID_REG sucks - why not have optional args? mir_value_t msg = MIR_NULL_VALUE, length = MIR_NULL_VALUE; if (vcode_get_arg(op, 2) != VCODE_INVALID_REG) { msg = imp->map[vcode_get_arg(op, 2)]; length = imp->map[vcode_get_arg(op, 3)]; } mir_value_t hint_left = MIR_NULL_VALUE, hint_right = MIR_NULL_VALUE; if (vcode_count_args(op) > 5) { hint_left = imp->map[vcode_get_arg(op, 5)]; hint_right = imp->map[vcode_get_arg(op, 6)]; } mir_build_assert(mu, value, msg, length, severity, locus, hint_left, hint_right); } static void import_report(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t severity = imp->map[vcode_get_arg(op, 0)]; mir_value_t message = imp->map[vcode_get_arg(op, 1)]; mir_value_t length = imp->map[vcode_get_arg(op, 2)]; mir_value_t locus = imp->map[vcode_get_arg(op, 3)]; mir_build_report(mu, message, length, severity, locus); } static void import_wait(mir_unit_t *mu, mir_import_t *imp, int op) { mir_block_t btarget = imp->blocks[vcode_get_target(op, 0)]; mir_value_t after = MIR_NULL_VALUE; vcode_reg_t after_reg = vcode_get_arg(op, 0); if (after_reg != VCODE_INVALID_REG) after = imp->map[after_reg]; mir_build_wait(mu, btarget, after); } static void import_jump(mir_unit_t *mu, mir_import_t *imp, int op) { mir_block_t btarget = imp->blocks[vcode_get_target(op, 0)]; mir_build_jump(mu, btarget); } static void import_cond(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t test = imp->map[vcode_get_arg(op, 0)]; mir_block_t btrue = imp->blocks[vcode_get_target(op, 0)]; mir_block_t bfalse = imp->blocks[vcode_get_target(op, 1)]; mir_build_cond(mu, test, btrue, bfalse); } static void import_case(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_block_t def = imp->blocks[vcode_get_target(op, 0)]; const int nargs = vcode_count_args(op); mir_value_t *cases LOCAL = xmalloc_array(nargs - 1, sizeof(mir_value_t)); mir_block_t *blocks LOCAL = xmalloc_array(nargs - 1, sizeof(mir_block_t)); for (int i = 1; i < nargs; i++) { cases[i - 1] = imp->map[vcode_get_arg(op, i)]; blocks[i - 1] = imp->blocks[vcode_get_target(op, i)]; } mir_build_case(mu, value, def, cases, blocks, nargs - 1); } static void import_init_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t count = imp->map[vcode_get_arg(op, 0)]; mir_value_t size = imp->map[vcode_get_arg(op, 1)]; mir_value_t value = imp->map[vcode_get_arg(op, 2)]; mir_value_t flags = imp->map[vcode_get_arg(op, 3)]; mir_value_t locus = imp->map[vcode_get_arg(op, 4)]; mir_value_t offset = MIR_NULL_VALUE; if (vcode_count_args(op) > 5) offset = imp->map[vcode_get_arg(op, 5)]; vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vtype_base(vcode_reg_type(result))); imp->map[result] = mir_build_init_signal(mu, type, count, size, value, flags, locus, offset); } static void import_implicit_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t count = imp->map[vcode_get_arg(op, 0)]; mir_value_t size = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_value_t kind = imp->map[vcode_get_arg(op, 3)]; mir_value_t closure = imp->map[vcode_get_arg(op, 4)]; mir_value_t delay = imp->map[vcode_get_arg(op, 5)]; vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vtype_base(vcode_reg_type(result))); imp->map[result] = mir_build_implicit_signal(mu, type, count, size, locus, kind, closure, delay); } static void import_drive_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_build_drive_signal(mu, target, count); } static void import_sched_waveform(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_value_t value = imp->map[vcode_get_arg(op, 2)]; mir_value_t reject = imp->map[vcode_get_arg(op, 3)]; mir_value_t after = imp->map[vcode_get_arg(op, 4)]; mir_build_sched_waveform(mu, target, count, value, reject, after); } static void import_resolved(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t nets = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_resolved(mu, nets); } static void import_address_of(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t nets = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_address_of(mu, nets); } static void import_store(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t var = imp->vars[vcode_get_address(op)]; mir_build_store(mu, var, imp->map[vcode_get_arg(op, 0)]); } static void import_store_indirect(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t var = imp->map[vcode_get_arg(op, 1)]; mir_build_store(mu, var, value); } static void import_load(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t var = imp->vars[vcode_get_address(op)]; imp->map[vcode_get_result(op)] = mir_build_load(mu, var); } static void import_load_indirect(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t var = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_load(mu, var); } static void import_context_upref(mir_unit_t *mu, mir_import_t *imp, int op) { const int hops = vcode_get_hops(op); imp->map[vcode_get_result(op)] = mir_build_context_upref(mu, hops); } static void import_var_upref(mir_unit_t *mu, mir_import_t *imp, int op) { const int hops = vcode_get_hops(op); vcode_var_t var = vcode_get_address(op); imp->map[vcode_get_result(op)] = mir_build_var_upref(mu, hops, var); } static void import_wrap(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t data = imp->map[vcode_get_arg(op, 0)]; const int nargs = vcode_count_args(op); assert((nargs - 1) % 3 == 0); const int ndims = (nargs - 1) / 3; mir_dim_t *dims LOCAL = xmalloc_array(ndims, sizeof(mir_dim_t)); for (int i = 0, pos = 1; i < ndims; i++, pos += 3) { dims[i].left = imp->map[vcode_get_arg(op, pos + 0)]; dims[i].right = imp->map[vcode_get_arg(op, pos + 1)]; dims[i].dir = imp->map[vcode_get_arg(op, pos + 2)]; } imp->map[vcode_get_result(op)] = mir_build_wrap(mu, data, dims, ndims); } static void import_unwrap(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_unwrap(mu, arg); } static void import_uarray_len(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; const int dim = vcode_get_dim(op); imp->map[vcode_get_result(op)] = mir_build_uarray_len(mu, arg, dim); } static void import_uarray_left(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; const int dim = vcode_get_dim(op); imp->map[vcode_get_result(op)] = mir_build_uarray_left(mu, arg, dim); } static void import_uarray_right(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; const int dim = vcode_get_dim(op); imp->map[vcode_get_result(op)] = mir_build_uarray_right(mu, arg, dim); } static void import_uarray_dir(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; const int dim = vcode_get_dim(op); imp->map[vcode_get_result(op)] = mir_build_uarray_dir(mu, arg, dim); } static void import_add(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_add(mu, type, left, right); } static void import_trap_add(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_trap_add(mu, type, left, right, locus); } static void import_sub(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_sub(mu, type, left, right); } static void import_trap_sub(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_trap_sub(mu, type, left, right, locus); } static void import_mul(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_mul(mu, type, left, right); } static void import_trap_mul(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_trap_mul(mu, type, left, right, locus); } static void import_div(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_div(mu, type, left, right); } static void import_mod(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_mod(mu, type, left, right); } static void import_rem(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_rem(mu, type, left, right); } static void import_exp(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_exp(mu, type, left, right); } static void import_trap_exp(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_trap_exp(mu, type, left, right, locus); } static void import_or(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_or(mu, left, right); } static void import_nor(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t or = mir_build_or(mu, left, right); imp->map[vcode_get_result(op)] = mir_build_not(mu, or); } static void import_xor(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_xor(mu, left, right); } static void import_xnor(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t xor = mir_build_xor(mu, left, right); imp->map[vcode_get_result(op)] = mir_build_not(mu, xor); } static void import_and(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_and(mu, left, right); } static void import_nand(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t and = mir_build_and(mu, left, right); imp->map[vcode_get_result(op)] = mir_build_not(mu, and); } static void import_event(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_event_flag(mu, signal, count); } static void import_active(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_active_flag(mu, signal, count); } static void import_driving(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_driving_flag(mu, signal, count); } static void import_not(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_not(mu, arg); } static void import_cast(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_get_type(op)); imp->map[vcode_get_result(op)] = mir_build_cast(mu, type, arg); } static void import_neg(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_neg(mu, type, arg); } static void import_trap_neg(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_trap_neg(mu, type, arg, locus); } static void import_abs(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_abs(mu, type, arg); } static void import_index(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t var = imp->vars[vcode_get_address(op)]; imp->map[vcode_get_result(op)] = var; } static void import_copy(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t dst = imp->map[vcode_get_arg(op, 0)]; mir_value_t src = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = MIR_NULL_VALUE; if (vcode_count_args(op) > 2) count = imp->map[vcode_get_arg(op, 2)]; mir_build_copy(mu, dst, src, count); } static void import_memset(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t dst = imp->map[vcode_get_arg(op, 0)]; mir_value_t value = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_set(mu, dst, value, count); } static void import_array_ref(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t array = imp->map[vcode_get_arg(op, 0)]; mir_value_t offset = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_array_ref(mu, array, offset); } static void import_record_ref(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t record = imp->map[vcode_get_arg(op, 0)]; const int field = vcode_get_field(op); imp->map[vcode_get_result(op)] = mir_build_record_ref(mu, record, field); } static void import_range_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t left = imp->map[vcode_get_arg(op, 1)]; mir_value_t right = imp->map[vcode_get_arg(op, 2)]; mir_value_t dir = imp->map[vcode_get_arg(op, 3)]; mir_value_t locus = imp->map[vcode_get_arg(op, 4)]; mir_value_t hint = imp->map[vcode_get_arg(op, 5)]; mir_build_range_check(mu, value, left, right, dir, locus, hint); } static void import_sched_event(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_build_sched_event(mu, signal, count); } static void import_clear_event(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_build_clear_event(mu, signal, count); } static void import_alloc(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t count = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_get_type(op)); vcode_reg_t result = vcode_get_result(op); imp->map[result] = mir_build_alloc(mu, type, MIR_NULL_STAMP, count); } static void import_range_length(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t dir = imp->map[vcode_get_arg(op, 2)]; vcode_reg_t result = vcode_get_result(op); imp->map[result] = mir_build_range_length(mu, left, right, dir); } static void import_range_null(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; mir_value_t dir = imp->map[vcode_get_arg(op, 2)]; vcode_reg_t result = vcode_get_result(op); imp->map[result] = mir_build_range_null(mu, left, right, dir); } static void import_null(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_null(mu, type); } static void import_new(mir_unit_t *mu, mir_import_t *imp, int op) { vcode_reg_t result = vcode_get_result(op); vcode_type_t vtype = vtype_pointed(vcode_reg_type(result)); mir_type_t type = import_type(mu, imp, vtype); mir_value_t count = MIR_NULL_VALUE; if (vcode_count_args(op) > 0) count = imp->map[vcode_get_arg(op, 0)]; imp->map[result] = mir_build_new(mu, type, MIR_NULL_STAMP, count); } static void import_all(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_all(mu, arg); } static void import_deallocate(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t arg = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = mir_get_type(mu, arg); mir_build_store(mu, arg, mir_build_null(mu, mir_get_pointer(mu, type))); } static void import_null_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t ptr = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_build_null_check(mu, ptr, locus); } static void import_zero_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_build_zero_check(mu, value, locus); } static void import_length_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t llen = imp->map[vcode_get_arg(op, 0)]; mir_value_t rlen = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_value_t dim = MIR_NULL_VALUE; if (vcode_count_args(op) > 3) dim = imp->map[vcode_get_arg(op, 3)]; mir_build_length_check(mu, llen, rlen, locus, dim); } static void import_index_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t left = imp->map[vcode_get_arg(op, 1)]; mir_value_t right = imp->map[vcode_get_arg(op, 2)]; mir_value_t dir = imp->map[vcode_get_arg(op, 3)]; mir_value_t locus = imp->map[vcode_get_arg(op, 4)]; mir_value_t hint = imp->map[vcode_get_arg(op, 5)]; mir_build_index_check(mu, value, left, right, dir, locus, hint); } static void import_dir_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t dir = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_build_dir_check(mu, value, dir, locus); } static void import_alias_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_build_alias_signal(mu, signal, locus); } static void import_map_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t src = imp->map[vcode_get_arg(op, 0)]; mir_value_t dst = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_map_signal(mu, src, dst, count); } static void import_map_const(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t src = imp->map[vcode_get_arg(op, 0)]; mir_value_t dst = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_map_const(mu, src, dst, count); } static void import_map_implicit(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t src = imp->map[vcode_get_arg(op, 0)]; mir_value_t dst = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_map_implicit(mu, src, dst, count); } static void import_bind_foreign(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t spec = imp->map[vcode_get_arg(op, 0)]; mir_value_t length = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = MIR_NULL_VALUE; if (vcode_count_args(op) > 2) locus = imp->map[vcode_get_arg(op, 2)]; mir_build_bind_foreign(mu, spec, length, locus); } static void import_bind_external(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; ident_t scope = vcode_get_ident(op); vcode_reg_t result = vcode_get_result(op); vcode_type_t vtype = vtype_pointed(vcode_reg_type(result)); mir_type_t type = import_type(mu, imp, vtype); imp->map[result] = mir_build_bind_external(mu, locus, scope, type, MIR_NULL_STAMP); } static void import_unreachable(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = MIR_NULL_VALUE; if (vcode_count_args(op) > 0) locus = imp->map[vcode_get_arg(op, 0)]; mir_build_unreachable(mu, locus); } static void import_select(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t test = imp->map[vcode_get_arg(op, 0)]; mir_value_t tval = imp->map[vcode_get_arg(op, 1)]; mir_value_t fval = imp->map[vcode_get_arg(op, 2)]; vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_select(mu, type, test, tval, fval); } static void import_closure(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t context = imp->map[vcode_get_arg(op, 0)]; ident_t func = vcode_get_func(op); mir_type_t atype = MIR_NULL_TYPE; vcode_reg_t result = vcode_get_result(op); mir_type_t rtype = import_type(mu, imp, vtype_base(vcode_reg_type(result))); imp->map[result] = mir_build_closure(mu, func, context, atype, rtype); } static void import_resolution_wrapper(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t closure = imp->map[vcode_get_arg(op, 0)]; mir_value_t nlits = imp->map[vcode_get_arg(op, 1)]; vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vtype_base(vcode_reg_type(result))); imp->map[result] = mir_build_resolution_wrapper(mu, type, closure, nlits); } static void import_resolve_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t resolution = imp->map[vcode_get_arg(op, 1)]; mir_build_resolve_signal(mu, signal, resolution); } static void import_transfer_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t source = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_value_t reject = imp->map[vcode_get_arg(op, 3)]; mir_value_t after = imp->map[vcode_get_arg(op, 4)]; mir_build_transfer_signal(mu, target, source, count, reject, after); } static void import_file_open(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t file = imp->map[vcode_get_arg(op, 0)]; mir_value_t name = imp->map[vcode_get_arg(op, 1)]; mir_value_t length = imp->map[vcode_get_arg(op, 2)]; mir_value_t kind = imp->map[vcode_get_arg(op, 3)]; mir_value_t status = MIR_NULL_VALUE; if (vcode_count_args(op) > 4) status = imp->map[vcode_get_arg(op, 4)]; mir_build_file_open(mu, file, name, length, kind, status); } static void import_file_read(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t file = imp->map[vcode_get_arg(op, 0)]; mir_value_t ptr = imp->map[vcode_get_arg(op, 1)]; mir_value_t inlen = MIR_NULL_VALUE, outlen = MIR_NULL_VALUE; if (vcode_count_args(op) > 2) { inlen = imp->map[vcode_get_arg(op, 2)]; if (vcode_count_args(op) > 3) outlen = imp->map[vcode_get_arg(op, 3)]; } mir_build_file_read(mu, file, ptr, inlen, outlen); } static void import_file_write(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t file = imp->map[vcode_get_arg(op, 0)]; mir_value_t value = imp->map[vcode_get_arg(op, 1)]; mir_value_t length = MIR_NULL_VALUE; if (vcode_count_args(op) > 2) length = imp->map[vcode_get_arg(op, 2)]; mir_build_file_write(mu, file, value, length); } static void import_port_conversion(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t driving = imp->map[vcode_get_arg(op, 0)]; mir_value_t effective = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) effective = imp->map[vcode_get_arg(op, 1)]; vcode_reg_t result = vcode_get_result(op); imp->map[result] = mir_build_port_conversion(mu, driving, effective); } static void import_convert_in(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t conv = imp->map[vcode_get_arg(op, 0)]; mir_value_t nets = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_convert_in(mu, conv, nets, count); } static void import_convert_out(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t conv = imp->map[vcode_get_arg(op, 0)]; mir_value_t nets = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_build_convert_out(mu, conv, nets, count); } static void import_driving_value(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_driving_value(mu, signal, count); } static void import_put_conversion(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t cf = imp->map[vcode_get_arg(op, 0)]; mir_value_t target = imp->map[vcode_get_arg(op, 1)]; mir_value_t count = imp->map[vcode_get_arg(op, 2)]; mir_value_t values = imp->map[vcode_get_arg(op, 3)]; mir_build_put_conversion(mu, cf, target, count, values); } static void import_force(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_value_t values = imp->map[vcode_get_arg(op, 2)]; mir_build_force(mu, target, count, values); } static void import_release(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_build_release(mu, target, count); } static void import_disconnect(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_value_t reject = imp->map[vcode_get_arg(op, 2)]; mir_value_t after = imp->map[vcode_get_arg(op, 3)]; mir_build_disconnect(mu, target, count, reject, after); } static void import_exponent_check(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t exp = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_build_exponent_check(mu, exp, locus); } static void import_process_init(mir_unit_t *mu, mir_import_t *imp, int op) { ident_t name = vcode_get_func(op); mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; mir_build_process_init(mu, name, locus); } static void import_cover_stmt(mir_unit_t *mu, mir_import_t *imp, int op) { mir_build_cover_stmt(mu, vcode_get_tag(op)); } static void import_cover_branch(mir_unit_t *mu, mir_import_t *imp, int op) { mir_build_cover_branch(mu, vcode_get_tag(op)); } static void import_cover_expr(mir_unit_t *mu, mir_import_t *imp, int op) { mir_build_cover_expr(mu, vcode_get_tag(op)); } static void import_cover_toggle(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_build_cover_toggle(mu, signal, vcode_get_tag(op)); } static void import_cover_state(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t low = imp->map[vcode_get_arg(op, 1)]; mir_build_cover_state(mu, signal, low, vcode_get_tag(op)); } static void import_array_scope(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_get_type(op)); mir_build_array_scope(mu, locus, type); } static void import_package_scope(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; mir_build_package_scope(mu, locus); } static void import_record_scope(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; mir_type_t type = import_type(mu, imp, vcode_get_type(op)); mir_build_record_scope(mu, locus, type); } static void import_pop_scope(mir_unit_t *mu, mir_import_t *imp, int op) { mir_build_pop_scope(mu); } static void import_cmp_trigger(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_cmp_trigger(mu, left, right); } static void import_function_trigger(mir_unit_t *mu, mir_import_t *imp, int op) { const int nargs = vcode_count_args(op); mir_value_t *args LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) args[i] = imp->map[vcode_get_arg(op, i)]; ident_t func = vcode_get_func(op); vcode_reg_t result = vcode_get_result(op); imp->map[result] = mir_build_function_trigger(mu, func, args, nargs); } static void import_or_trigger(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t left = imp->map[vcode_get_arg(op, 0)]; mir_value_t right = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_or_trigger(mu, left, right); } static void import_add_trigger(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t trigger = imp->map[vcode_get_arg(op, 0)]; mir_build_add_trigger(mu, trigger); } static void import_protected_init(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t context = imp->map[vcode_get_arg(op, 0)]; mir_value_t path_name = MIR_NULL_VALUE, inst_name = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) { path_name = imp->map[vcode_get_arg(op, 1)]; inst_name = imp->map[vcode_get_arg(op, 2)]; } vcode_reg_t result = vcode_get_result(op); mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_protected_init(mu, type, context, path_name, inst_name); } static void import_instance_name(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t kind = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_instance_name(mu, kind); } static void import_last_event(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_last_event(mu, signal, count); } static void import_last_active(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) count = imp->map[vcode_get_arg(op, 1)]; imp->map[vcode_get_result(op)] = mir_build_last_active(mu, signal, count); } static void import_last_value(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t signal = imp->map[vcode_get_arg(op, 0)]; imp->map[vcode_get_result(op)] = mir_build_last_value(mu, signal); } static void import_enter_state(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t state = imp->map[vcode_get_arg(op, 0)]; mir_value_t strong = MIR_NULL_VALUE; if (vcode_count_args(op) > 1) strong = imp->map[vcode_get_arg(op, 1)]; mir_build_enter_state(mu, state, strong); } static void import_deposit_signal(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t target = imp->map[vcode_get_arg(op, 0)]; mir_value_t count = imp->map[vcode_get_arg(op, 1)]; mir_value_t values = imp->map[vcode_get_arg(op, 2)]; mir_build_deposit_signal(mu, target, count, values); } static void import_syscall(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t locus = imp->map[vcode_get_arg(op, 0)]; ident_t func = vcode_get_func(op); mir_type_t type = MIR_NULL_TYPE; vcode_type_t vtype = vcode_get_type(op); if (vtype != VCODE_INVALID_TYPE) type = import_type(mu, imp, vtype); const int nargs = vcode_count_args(op) - 1; mir_value_t *args LOCAL = xmalloc_array(nargs, sizeof(mir_value_t)); for (int i = 0; i < nargs; i++) args[i] = imp->map[vcode_get_arg(op, i + 1)]; vcode_reg_t result = vcode_get_result(op); if (result == VCODE_INVALID_REG) mir_build_syscall(mu, func, type, MIR_NULL_STAMP, locus, args, nargs); else { mir_type_t type = import_type(mu, imp, vcode_reg_type(result)); imp->map[result] = mir_build_syscall(mu, func, type, MIR_NULL_STAMP, locus, args, nargs); } } static void import_reflect_value(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t value = imp->map[vcode_get_arg(op, 0)]; mir_value_t context = imp->map[vcode_get_arg(op, 1)]; mir_value_t locus = imp->map[vcode_get_arg(op, 2)]; mir_value_t bounds = MIR_NULL_VALUE; if (vcode_count_args(op) > 3) bounds = imp->map[vcode_get_arg(op, 3)]; imp->map[vcode_get_result(op)] = mir_build_reflect_value(mu, value, context, locus, bounds); } static void import_reflect_subtype(mir_unit_t *mu, mir_import_t *imp, int op) { mir_value_t context = imp->map[vcode_get_arg(op, 0)]; mir_value_t locus = imp->map[vcode_get_arg(op, 1)]; mir_value_t bounds = MIR_NULL_VALUE; if (vcode_count_args(op) > 2) bounds = imp->map[vcode_get_arg(op, 2)]; imp->map[vcode_get_result(op)] = mir_build_reflect_subtype(mu, context, locus, bounds); } static void import_block(mir_unit_t *mu, mir_import_t *imp) { const int nops = vcode_count_ops(); for (int i = 0; i < nops; i++) { mir_set_loc(mu, vcode_get_loc(i)); switch (vcode_get_op(i)) { case VCODE_OP_COMMENT: break; case VCODE_OP_PACKAGE_INIT: import_package_init(mu, imp, i); break; case VCODE_OP_LINK_PACKAGE: import_link_package(mu, imp, i); break; case VCODE_OP_LINK_VAR: import_link_var(mu, imp, i); break; case VCODE_OP_RETURN: import_return(mu, imp, i); break; case VCODE_OP_FCALL: import_fcall(mu, imp, i); break; case VCODE_OP_PCALL: import_pcall(mu, imp, i); break; case VCODE_OP_RESUME: import_resume(mu, imp, i); break; case VCODE_OP_CONST: import_const(mu, imp, i); break; case VCODE_OP_CONST_REAL: import_const_real(mu, imp, i); break; case VCODE_OP_CONST_ARRAY: import_const_array(mu, imp, i); break; case VCODE_OP_CONST_REP: import_const_rep(mu, imp, i); break; case VCODE_OP_CONST_RECORD: import_const_record(mu, imp, i); break; case VCODE_OP_CMP: import_cmp(mu, imp, i); break; case VCODE_OP_DEBUG_LOCUS: import_debug_locus(mu, imp, i); break; case VCODE_OP_ASSERT: import_assert(mu, imp, i); break; case VCODE_OP_REPORT: import_report(mu, imp, i); break; case VCODE_OP_WAIT: import_wait(mu, imp, i); break; case VCODE_OP_JUMP: import_jump(mu, imp, i); break; case VCODE_OP_COND: import_cond(mu, imp, i); break; case VCODE_OP_INIT_SIGNAL: import_init_signal(mu, imp, i); break; case VCODE_OP_IMPLICIT_SIGNAL: import_implicit_signal(mu, imp, i); break; case VCODE_OP_DRIVE_SIGNAL: import_drive_signal(mu, imp, i); break; case VCODE_OP_SCHED_WAVEFORM: import_sched_waveform(mu, imp, i); break; case VCODE_OP_RESOLVED: import_resolved(mu, imp, i); break; case VCODE_OP_ADDRESS_OF: import_address_of(mu, imp, i); break; case VCODE_OP_STORE: import_store(mu, imp, i); break; case VCODE_OP_STORE_INDIRECT: import_store_indirect(mu, imp, i); break; case VCODE_OP_LOAD: import_load(mu, imp, i); break; case VCODE_OP_LOAD_INDIRECT: import_load_indirect(mu, imp, i); break; case VCODE_OP_CONTEXT_UPREF: import_context_upref(mu, imp, i); break; case VCODE_OP_VAR_UPREF: import_var_upref(mu, imp, i); break; case VCODE_OP_WRAP: import_wrap(mu, imp, i); break; case VCODE_OP_UNWRAP: import_unwrap(mu, imp, i); break; case VCODE_OP_UARRAY_LEN: import_uarray_len(mu, imp, i); break; case VCODE_OP_UARRAY_LEFT: import_uarray_left(mu, imp, i); break; case VCODE_OP_UARRAY_RIGHT: import_uarray_right(mu, imp, i); break; case VCODE_OP_UARRAY_DIR: import_uarray_dir(mu, imp, i); break; case VCODE_OP_ADD: import_add(mu, imp, i); break; case VCODE_OP_TRAP_ADD: import_trap_add(mu, imp, i); break; case VCODE_OP_SUB: import_sub(mu, imp, i); break; case VCODE_OP_TRAP_SUB: import_trap_sub(mu, imp, i); break; case VCODE_OP_MUL: import_mul(mu, imp, i); break; case VCODE_OP_TRAP_MUL: import_trap_mul(mu, imp, i); break; case VCODE_OP_DIV: import_div(mu, imp, i); break; case VCODE_OP_MOD: import_mod(mu, imp, i); break; case VCODE_OP_REM: import_rem(mu, imp, i); break; case VCODE_OP_EXP: import_exp(mu, imp, i); break; case VCODE_OP_TRAP_EXP: import_trap_exp(mu, imp, i); break; case VCODE_OP_OR: import_or(mu, imp, i); break; case VCODE_OP_NOR: import_nor(mu, imp, i); break; case VCODE_OP_XOR: import_xor(mu, imp, i); break; case VCODE_OP_XNOR: import_xnor(mu, imp, i); break; case VCODE_OP_AND: import_and(mu, imp, i); break; case VCODE_OP_NAND: import_nand(mu, imp, i); break; case VCODE_OP_EVENT: import_event(mu, imp, i); break; case VCODE_OP_ACTIVE: import_active(mu, imp, i); break; case VCODE_OP_DRIVING: import_driving(mu, imp, i); break; case VCODE_OP_NOT: import_not(mu, imp, i); break; case VCODE_OP_CAST: import_cast(mu, imp, i); break; case VCODE_OP_NEG: import_neg(mu, imp, i); break; case VCODE_OP_TRAP_NEG: import_trap_neg(mu, imp, i); break; case VCODE_OP_ABS: import_abs(mu, imp, i); break; case VCODE_OP_INDEX: import_index(mu, imp, i); break; case VCODE_OP_COPY: import_copy(mu, imp, i); break; case VCODE_OP_MEMSET: import_memset(mu, imp, i); break; case VCODE_OP_ARRAY_REF: import_array_ref(mu, imp, i); break; case VCODE_OP_RECORD_REF: import_record_ref(mu, imp, i); break; case VCODE_OP_RANGE_CHECK: import_range_check(mu, imp, i); break; case VCODE_OP_SCHED_EVENT: import_sched_event(mu, imp, i); break; case VCODE_OP_CLEAR_EVENT: import_clear_event(mu, imp, i); break; case VCODE_OP_ALLOC: import_alloc(mu, imp, i); break; case VCODE_OP_RANGE_LENGTH: import_range_length(mu, imp, i); break; case VCODE_OP_RANGE_NULL: import_range_null(mu, imp, i); break; case VCODE_OP_NULL: import_null(mu, imp, i); break; case VCODE_OP_NEW: import_new(mu, imp, i); break; case VCODE_OP_ALL: import_all(mu, imp, i); break; case VCODE_OP_DEALLOCATE: import_deallocate(mu, imp, i); break; case VCODE_OP_ZERO_CHECK: import_zero_check(mu, imp, i); break; case VCODE_OP_NULL_CHECK: import_null_check(mu, imp, i); break; case VCODE_OP_LENGTH_CHECK: import_length_check(mu, imp, i); break; case VCODE_OP_INDEX_CHECK: import_index_check(mu, imp, i); break; case VCODE_OP_DIR_CHECK: import_dir_check(mu, imp, i); break; case VCODE_OP_ALIAS_SIGNAL: import_alias_signal(mu, imp, i); break; case VCODE_OP_MAP_SIGNAL: import_map_signal(mu, imp, i); break; case VCODE_OP_MAP_CONST: import_map_const(mu, imp, i); break; case VCODE_OP_MAP_IMPLICIT: import_map_implicit(mu, imp, i); break; case VCODE_OP_CASE: import_case(mu, imp, i); break; case VCODE_OP_BIND_FOREIGN: import_bind_foreign(mu, imp, i); break; case VCODE_OP_BIND_EXTERNAL: import_bind_external(mu, imp, i); break; case VCODE_OP_UNREACHABLE: import_unreachable(mu, imp, i); break; case VCODE_OP_SELECT: import_select(mu, imp, i); break; case VCODE_OP_CLOSURE: import_closure(mu, imp, i); break; case VCODE_OP_RESOLUTION_WRAPPER: import_resolution_wrapper(mu, imp, i); break; case VCODE_OP_RESOLVE_SIGNAL: import_resolve_signal(mu, imp, i); break; case VCODE_OP_TRANSFER_SIGNAL: import_transfer_signal(mu, imp, i); break; case VCODE_OP_FILE_OPEN: import_file_open(mu, imp, i); break; case VCODE_OP_FILE_READ: import_file_read(mu, imp, i); break; case VCODE_OP_FILE_WRITE: import_file_write(mu, imp, i); break; case VCODE_OP_PORT_CONVERSION: import_port_conversion(mu, imp, i); break; case VCODE_OP_CONVERT_IN: import_convert_in(mu, imp, i); break; case VCODE_OP_CONVERT_OUT: import_convert_out(mu, imp, i); break; case VCODE_OP_DRIVING_VALUE: import_driving_value(mu, imp, i); break; case VCODE_OP_PUT_CONVERSION: import_put_conversion(mu, imp, i); break; case VCODE_OP_FORCE: import_force(mu, imp, i); break; case VCODE_OP_RELEASE: import_release(mu, imp, i); break; case VCODE_OP_DISCONNECT: import_disconnect(mu, imp, i); break; case VCODE_OP_EXPONENT_CHECK: import_exponent_check(mu, imp, i); break; case VCODE_OP_PROCESS_INIT: import_process_init(mu, imp, i); break; case VCODE_OP_COVER_STMT: import_cover_stmt(mu, imp, i); break; case VCODE_OP_COVER_BRANCH: import_cover_branch(mu, imp, i); break; case VCODE_OP_COVER_EXPR: import_cover_expr(mu, imp, i); break; case VCODE_OP_COVER_TOGGLE: import_cover_toggle(mu, imp, i); break; case VCODE_OP_COVER_STATE: import_cover_state(mu, imp, i); break; case VCODE_OP_ARRAY_SCOPE: import_array_scope(mu, imp, i); break; case VCODE_OP_PACKAGE_SCOPE: import_package_scope(mu, imp, i); break; case VCODE_OP_RECORD_SCOPE: import_record_scope(mu, imp, i); break; case VCODE_OP_POP_SCOPE: import_pop_scope(mu, imp, i); break; case VCODE_OP_CMP_TRIGGER: import_cmp_trigger(mu, imp, i); break; case VCODE_OP_FUNCTION_TRIGGER: import_function_trigger(mu, imp, i); break; case VCODE_OP_OR_TRIGGER: import_or_trigger(mu, imp, i); break; case VCODE_OP_ADD_TRIGGER: import_add_trigger(mu, imp, i); break; case VCODE_OP_PROTECTED_INIT: import_protected_init(mu, imp, i); break; case VCODE_OP_PROTECTED_FREE: break; // No-op case VCODE_OP_INSTANCE_NAME: import_instance_name(mu, imp, i); break; case VCODE_OP_LAST_EVENT: import_last_event(mu, imp, i); break; case VCODE_OP_LAST_ACTIVE: import_last_active(mu, imp, i); break; case VCODE_OP_LAST_VALUE: import_last_value(mu, imp, i); break; case VCODE_OP_ENTER_STATE: import_enter_state(mu, imp, i); break; case VCODE_OP_DEPOSIT_SIGNAL: import_deposit_signal(mu, imp, i); break; case VCODE_OP_SYSCALL: import_syscall(mu, imp, i); break; case VCODE_OP_REFLECT_SUBTYPE: import_reflect_subtype(mu, imp, i); break; case VCODE_OP_REFLECT_VALUE: import_reflect_value(mu, imp, i); break; default: vcode_dump_with_mark(i, NULL, NULL); fatal_trace("cannot import vcode op %s", vcode_op_string(vcode_get_op(i))); } } } mir_unit_t *mir_import(mir_context_t *mc, vcode_unit_t vu) { static const mir_unit_kind_t kind_map[] = { [VCODE_UNIT_FUNCTION] = MIR_UNIT_FUNCTION, [VCODE_UNIT_INSTANCE] = MIR_UNIT_INSTANCE, [VCODE_UNIT_PROCEDURE] = MIR_UNIT_PROCEDURE, [VCODE_UNIT_PROCESS] = MIR_UNIT_PROCESS, [VCODE_UNIT_PACKAGE] = MIR_UNIT_PACKAGE, [VCODE_UNIT_THUNK] = MIR_UNIT_THUNK, [VCODE_UNIT_PROTECTED] = MIR_UNIT_PROTECTED, [VCODE_UNIT_PROPERTY] = MIR_UNIT_PROPERTY, }; const mir_unit_kind_t kind = kind_map[vcode_unit_kind(vu)]; mir_shape_t *parent = NULL; vcode_unit_t context = vcode_unit_context(vu); if (context != NULL) { ident_t name = vcode_unit_name(context); if ((parent = mir_get_shape(mc, name)) == NULL) { mir_unit_t *parent_mu = mir_import(mc, context); mir_put_unit(mc, parent_mu); parent = mir_get_shape(mc, name); assert(parent != NULL); } } ident_t name = vcode_unit_name(vu); object_t *obj = vcode_unit_object(vu); mir_unit_t *mu = mir_unit_new(mc, name, obj, kind, parent); vcode_select_unit(vu); const int nblocks = vcode_count_blocks(); const int nregs = vcode_count_regs(); const int nvars = vcode_count_vars(); mir_import_t imp = {}; imp.blocks = xcalloc_array(nblocks, sizeof(mir_block_t)); imp.map = xcalloc_array(nregs, sizeof(mir_value_t)); imp.vars = xcalloc_array(nvars, sizeof(mir_value_t)); imp.types = ihash_new(64); switch (kind) { case MIR_UNIT_FUNCTION: { vcode_type_t vresult = vcode_unit_result(vu); if (vresult != VCODE_INVALID_TYPE) mir_set_result(mu, import_type(mu, &imp, vresult)); } // Fall-through case MIR_UNIT_PROCEDURE: case MIR_UNIT_PROTECTED: case MIR_UNIT_PROPERTY: { const int nparams = vcode_count_params(); for (int i = 0; i < nparams; i++) { vcode_reg_t preg = vcode_param_reg(i); mir_type_t type = import_type(mu, &imp, vcode_param_type(i)); ident_t name = vcode_param_name(i); imp.map[preg] = mir_add_param(mu, type, MIR_NULL_STAMP, name); } } break; case MIR_UNIT_THUNK: mir_set_result(mu, import_type(mu, &imp, vcode_unit_result(vu))); break; default: break; } for (int i = 0; i < nvars; i++) { mir_type_t type = import_type(mu, &imp, vcode_var_type(i)); imp.vars[i] = mir_add_var(mu, type, MIR_NULL_STAMP, vcode_var_name(i), (mir_var_flags_t)vcode_var_flags(i)); } imp.blocks[0] = mir_get_cursor(mu, NULL); for (int i = 1; i < nblocks; i++) imp.blocks[i] = mir_add_block(mu); for (int i = 0; i < nblocks; i++) { vcode_select_block(i); mir_set_cursor(mu, imp.blocks[i], MIR_APPEND); import_block(mu, &imp); } ihash_free(imp.types); free(imp.blocks); free(imp.map); free(imp.vars); return mu; } nvc-r1.17.1/src/names.c000066400000000000000000004547331504111170000146150ustar00rootroot00000000000000// // Copyright (C) 2020-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "lib.h" #include "mask.h" #include "names.h" #include "option.h" #include "psl/psl-node.h" #include "thread.h" #include "type.h" #include #include #include #include typedef struct _scope scope_t; typedef struct _type_set type_set_t; typedef struct _spec spec_t; typedef struct _sym_chunk sym_chunk_t; typedef struct _lazy_sym lazy_sym_t; typedef A(tree_t) tree_list_t; typedef A(type_t) type_list_t; struct _spec { spec_t *next; spec_kind_t kind; ident_t ident; tree_t tree; unsigned matches; }; typedef enum { DIRECT, POTENTIAL, HIDDEN, OVERLOAD, ATTRIBUTE } visibility_t; typedef struct { tree_t tree; scope_t *origin; visibility_t visibility : 16; tree_kind_t kind : 16; name_mask_t mask; } decl_t; #define INLINE_DECLS 4 typedef struct { ident_t name; scope_t *owner; name_mask_t mask; uint32_t hash; unsigned ndecls; unsigned overflowsz; decl_t decls[INLINE_DECLS]; decl_t *overflow; } symbol_t; #define SYMBOLS_PER_CHUNK 32 typedef struct _sym_chunk { sym_chunk_t *chain; unsigned count; symbol_t symbols[SYMBOLS_PER_CHUNK]; } sym_chunk_t; #define INIT_TABSZ 16 typedef struct { type_t type; tree_t src; } tracked_type_t; typedef A(tracked_type_t) tracked_type_list_t; typedef bool (*type_pred_t)(type_t); typedef struct _type_set { tracked_type_list_t members; type_set_t *down; type_pred_t pred; unsigned watermark; tree_t target; } type_set_t; typedef enum { O_IDLE, O_POS, O_NAMED, } overload_state_t; typedef struct { ident_t name; tree_t tree; tree_list_t candidates; tree_list_t params; nametab_t *nametab; const symbol_t *symbol; type_set_t typeset; overload_state_t state; bool error; bool trace; bool trial; bool could_be_index; bool implicit_conversion; bool cancelled; type_t signature; tree_t prefix; unsigned initial; unsigned nactuals; } overload_t; typedef symbol_t *(*lazy_fn_t)(scope_t *, ident_t, void *); typedef void (*formal_fn_t)(diag_t *, ident_t, void *); typedef void (*make_visible_t)(scope_t *, ident_t, tree_t); typedef struct _lazy_sym { lazy_sym_t *next; lazy_fn_t fn; void *ctx; } lazy_sym_t; typedef struct { int proc; int loop; } label_cnts_t; typedef struct { defer_check_fn_t fn; tree_t tree; } defer_check_t; typedef A(defer_check_t) defer_checks_t; typedef struct _scope { scope_t *parent; sym_chunk_t symbols; sym_chunk_t *sym_tail; hash_t *gmap; spec_t *specs; overload_t *overload; formal_kind_t formal_kind; formal_fn_t formal_fn; void *formal_arg; ident_t prefix; tree_t container; bool suppress; lazy_sym_t *lazy; tree_list_t imported; label_cnts_t lbl_cnts; scope_t *chain; defer_checks_t deferred; unsigned tabsz; unsigned tabcount; symbol_t **symtab; symbol_t *inlinetab[]; } scope_t; typedef struct _nametab { scope_t *top_scope; type_set_t *top_type_set; hash_t *globalmap; scope_t *globals; tree_t std; tree_t psl; } nametab_t; static type_t _solve_types(nametab_t *tab, tree_t expr); static type_t try_solve_type(nametab_t *tab, tree_t expr); static bool is_forward_decl(tree_t decl, tree_t existing); static bool denotes_same_object(tree_t a, tree_t b); static void make_visible_slow(scope_t *s, ident_t name, tree_t decl); static const symbol_t *iterate_symbol_for(nametab_t *tab, ident_t name); static void free_scope(scope_t *s); static void begin_overload_resolution(overload_t *o); static tree_t finish_overload_resolution(overload_t *o); //////////////////////////////////////////////////////////////////////////////// // Type sets static void type_set_push(nametab_t *tab, type_set_t *ts) { assert(ts->down == NULL); assert(ts->members.count == 0); assert(ts->watermark == 0); ts->down = tab->top_type_set; tab->top_type_set = ts; } static void type_set_pop(nametab_t *tab, type_set_t *ts) { assert(tab->top_type_set == ts); tab->top_type_set = ts->down; ACLEAR(ts->members); } static void type_set_describe(nametab_t *tab, diag_t *d, const loc_t *loc, type_pred_t pred, const char *hint) { const type_set_t *ts = tab->top_type_set; if (ts == NULL) return; const int count = ts->members.count ?: ts->watermark; if (count == 0) return; LOCAL_TEXT_BUF tb = tb_new(); int poss = 0; for (unsigned n = 0; n < count; n++) { tracked_type_t tt = ts->members.items[n]; if (type_is_none(tt.type)) continue; else if (pred == NULL || (*pred)(tt.type)) { if (n > 0 && n + 1 == count) tb_cat(tb, " or "); else if (n > 0) tb_cat(tb, ", "); tb_cat(tb, type_pp(tt.type)); poss++; } else if (hint != NULL && *hint != '\0') diag_hint(d, NULL, "context contains type %s which is not %s", type_pp(tt.type), hint); else diag_hint(d, NULL, "context contains type %s", type_pp(tt.type)); if (tt.src != NULL && is_subprogram(tt.src)) diag_hint(d, tree_loc(tt.src), "context contains overload %s", type_pp(tree_type(tt.src))); } if (poss > 0) diag_hint(d, loc, "%s %s", poss > 1 ? "could be" : "expecting", tb_get(tb)); } static void type_set_add(nametab_t *tab, type_t t, tree_t src) { assert(tab->top_type_set != NULL); if (t == NULL) return; if (type_kind(t) == T_INCOMPLETE) t = resolve_type(tab, t); if (tab->top_scope->gmap != NULL) t = hash_get(tab->top_scope->gmap, t) ?: t; for (unsigned i = 0; i < tab->top_type_set->members.count; i++) { if (type_eq(tab->top_type_set->members.items[i].type, t)) return; } APUSH(tab->top_type_set->members, ((tracked_type_t){t, src})); } static void type_set_restrict(nametab_t *tab, type_pred_t pred) { if (tab->top_type_set == NULL) return; tab->top_type_set->watermark = tab->top_type_set->members.count; int j = 0; for (int i = 0; i < tab->top_type_set->members.count; i++) { tracked_type_t tt = tab->top_type_set->members.items[i]; if ((*pred)(tt.type)) tab->top_type_set->members.items[j++] = tt; } ATRIM(tab->top_type_set->members, j); } static bool type_set_uniq(nametab_t *tab, type_t *pt) { assert(tab->top_type_set != NULL); if (tab->top_type_set->members.count == 1) { *pt = tab->top_type_set->members.items[0].type; return true; } else { *pt = NULL; return false; } } static bool type_set_contains(nametab_t *tab, type_t type) { if (tab->top_type_set == NULL || tab->top_type_set->members.count == 0) return true; for (int i = 0; i < tab->top_type_set->members.count; i++) { type_t member = tab->top_type_set->members.items[i].type; if (type_eq(type, member)) return true; } return false; } static bool type_set_any(nametab_t *tab, type_pred_t pred) { if (tab->top_type_set == NULL) return false; for (int i = 0; i < tab->top_type_set->members.count; i++) { if ((*pred)(tab->top_type_set->members.items[i].type)) return true; } return false; } //////////////////////////////////////////////////////////////////////////////// // Scopes nametab_t *nametab_new(void) { nametab_t *tab = xcalloc(sizeof(nametab_t)); tab->globalmap = hash_new(128); return tab; } void nametab_finish(nametab_t *tab) { assert(tab->top_scope == NULL); assert(tab->top_type_set == NULL); for (scope_t *s = tab->globals, *tmp; s; s = tmp) { tmp = s->chain; free_scope(s); } hash_free(tab->globalmap); free(tab); } static scope_t *new_scope(void) { scope_t *s = xcalloc_flex(sizeof(scope_t), INIT_TABSZ, sizeof(symbol_t *)); s->sym_tail = &(s->symbols); s->tabsz = INIT_TABSZ; s->symtab = s->inlinetab; return s; } void push_scope(nametab_t *tab) { scope_t *s = new_scope(); s->parent = tab->top_scope; s->prefix = tab->top_scope ? tab->top_scope->prefix : NULL; s->suppress = tab->top_scope ? tab->top_scope->suppress : false; tab->top_scope = s; } static void free_overflow(sym_chunk_t *chunk) { for (int i = 0; i < chunk->count; i++) { if (chunk->symbols[i].overflow) free(chunk->symbols[i].overflow); } } static void free_scope(scope_t *s) { if (s->symtab != s->inlinetab) free(s->symtab); free_overflow(&(s->symbols)); for (sym_chunk_t *c = s->symbols.chain, *tmp; c; c = tmp) { free_overflow(c); tmp = c->chain; free(c); } for (lazy_sym_t *it = s->lazy, *tmp; it; it = tmp) { tmp = it->next; free(it); } hash_free(s->gmap); ACLEAR(s->imported); free(s); } void pop_scope(nametab_t *tab) { assert(tab->top_scope != NULL); scope_t *tmp = tab->top_scope->parent; for (int i = 0; i < tab->top_scope->deferred.count; i++) { const defer_check_t *dc = &(tab->top_scope->deferred.items[i]); (*dc->fn)(dc->tree, tab->top_scope->container, tab); } ACLEAR(tab->top_scope->deferred); for (spec_t *it = tab->top_scope->specs, *next; it != NULL; it = next) { if (it->kind == SPEC_EXACT && it->matches == 0 && !tab->top_scope->suppress) error_at(tree_loc(it->tree), "instance %s not found", istr(it->ident)); next = it->next; free(it); } free_scope(tab->top_scope); tab->top_scope = tmp; } void suppress_errors(nametab_t *tab) { tab->top_scope->suppress = true; } bool have_name_errors(nametab_t *tab) { return tab->top_scope->suppress; } void defer_check(nametab_t *tab, defer_check_fn_t fn, tree_t t) { defer_check_t dc = { fn, t }; APUSH(tab->top_scope->deferred, dc); } void map_generic_type(nametab_t *tab, type_t generic, type_t actual) { assert(type_kind(generic) == T_GENERIC); if (tab->top_scope->gmap == NULL) tab->top_scope->gmap = hash_new(128); // Try to prevent large numbers of cascading errors when the actual // type is not of the correct class: sem_check_generic_actual will // report a single error later static bool (*const pred[])(type_t) = { [GTYPE_PRIVATE] = type_is_valid, [GTYPE_INTEGER] = type_is_integer, [GTYPE_DISCRETE] = type_is_discrete, [GTYPE_SCALAR] = type_is_scalar, [GTYPE_ARRAY] = type_is_array, [GTYPE_ACCESS] = type_is_access, [GTYPE_FILE] = type_is_file, [GTYPE_FLOATING] = type_is_real, }; const gtype_class_t class = type_subkind(generic); if (pred[class] != NULL && !(*pred[class])(actual)) suppress_errors(tab); else if (class == GTYPE_ARRAY) { type_t gelem = type_elem(generic); if (type_kind(gelem) == T_GENERIC && !type_has_ident(gelem)) map_generic_type(tab, gelem, type_elem(actual)); const int ndims = type_indexes(generic); for (int i = 0; i < ndims; i++) { type_t index = type_index(generic, i); if (type_kind(index) == T_GENERIC && !type_has_ident(index)) map_generic_type(tab, index, index_type_of(actual, i)); } } hash_put(tab->top_scope->gmap, generic, actual); } void map_generic_subprogram(nametab_t *tab, tree_t decl, tree_t actual) { assert(is_subprogram(actual)); if (tab->top_scope->gmap == NULL) tab->top_scope->gmap = hash_new(128); hash_put(tab->top_scope->gmap, decl, actual); } void map_generic_package(nametab_t *tab, tree_t generic, tree_t actual) { assert(tree_kind(actual) == T_PACK_INST); if (tab->top_scope->gmap == NULL) tab->top_scope->gmap = hash_new(128); const int ndecls = tree_decls(generic); for (int i = 0; i < ndecls; i++) { tree_t gd = tree_decl(generic, i); tree_t ad = tree_decl(actual, i); assert(tree_kind(gd) == tree_kind(ad)); hash_put(tab->top_scope->gmap, gd, ad); if (is_type_decl(gd)) hash_put(tab->top_scope->gmap, tree_type(gd), tree_type(ad)); } const int ngenerics = tree_generics(generic); for (int i = 0; i < ngenerics; i++) { tree_t gg = tree_generic(generic, i); tree_t ag = tree_generic(actual, i); hash_put(tab->top_scope->gmap, gg, ag); if (tree_class(gg) == C_TYPE) hash_put(tab->top_scope->gmap, tree_type(gg), tree_type(ag)); } } void map_generic_const(nametab_t *tab, tree_t generic, tree_t actual) { if (tab->top_scope->container == NULL) return; else if (!is_literal(actual)) return; if (tab->top_scope->gmap == NULL) tab->top_scope->gmap = hash_new(128); hash_put(tab->top_scope->gmap, generic, actual); } hash_t *get_generic_map(nametab_t *tab) { return tab->top_scope->gmap; } static tree_t scope_find_enclosing(scope_t *s, scope_kind_t what) { for (; s != NULL; s = s->parent) { if (s->container == NULL) continue; if (what == S_LOOP && is_loop_stmt(s->container)) return s->container; else if (what == S_SUBPROGRAM && is_subprogram(s->container)) return s->container; else if (what == S_DESIGN_UNIT && is_design_unit(s->container)) return s->container; else if (what == S_PROCESS && tree_kind(s->container) == T_PROCESS) return s->container; else if (what == S_PROTECTED && tree_kind(s->container) == T_PROT_BODY) return s->container; else if (what == S_CONCURRENT_BLOCK && is_concurrent_block(s->container)) return s->container; else if (what == S_DECLARATIVE_REGION) return s->container; } return NULL; } void scope_set_prefix(nametab_t *tab, ident_t prefix) { tab->top_scope->prefix = ident_prefix(tab->top_scope->prefix, prefix, '.'); } ident_t scope_prefix(nametab_t *tab) { return tab->top_scope->prefix; } void scope_set_container(nametab_t *tab, tree_t container) { tab->top_scope->container = container; } void scope_set_subprogram(nametab_t *tab, tree_t subprog) { tab->top_scope->container = subprog; tab->top_scope->prefix = tree_ident2(subprog); } tree_t find_enclosing(nametab_t *tab, scope_kind_t what) { if (tab->top_scope) return scope_find_enclosing(tab->top_scope, what); else return NULL; } bool is_enclosing(nametab_t *tab, tree_t container) { assert(is_container(container)); for (scope_t *s = tab->top_scope; s; s = s->parent) { if (s->container == container) return true; } return false; } formal_kind_t scope_formal_kind(nametab_t *tab) { return tab->top_scope->formal_kind; } static uint32_t hash_name(ident_t name) { if (isalpha_iso88591(ident_char(name, 0))) return ident_casehash(name); else return ident_hash(name); } static bool compare_name(ident_t a, ident_t b) { if (a == b) return true; else if (isalpha_iso88591(ident_char(a, 0))) return ident_casecmp(a, b); else return false; } static symbol_t *lookup_symbol(scope_t *s, ident_t name) { const uint32_t hash = hash_name(name); for (int slot = hash & (s->tabsz - 1);; slot = (slot + 1) & (s->tabsz - 1)) { symbol_t *sym = s->symtab[slot]; if (sym == NULL) return NULL; else if (sym->hash == hash && compare_name(sym->name, name)) return sym; } } static const symbol_t *symbol_for(scope_t *s, ident_t name) { do { symbol_t *sym = lookup_symbol(s, name); if (sym != NULL) return sym; } while (s->formal_kind != F_RECORD && (s = s->parent)); return NULL; } static const symbol_t *lazy_symbol_for(scope_t *s, ident_t name) { do { symbol_t *sym = lookup_symbol(s, name); if (sym != NULL) return sym; else { for (lazy_sym_t *it = s->lazy; it; it = it->next) { if ((sym = (*it->fn)(s, name, it->ctx))) return sym; } } } while (s->formal_kind != F_RECORD && (s = s->parent)); return NULL; } static inline const decl_t *get_decl(const symbol_t *sym, unsigned nth) { assert(nth < sym->ndecls); return (nth < INLINE_DECLS) ? &(sym->decls[nth]) : &(sym->overflow[nth - INLINE_DECLS]); } static inline decl_t *get_decl_mutable(symbol_t *sym, unsigned nth) { assert(nth < sym->ndecls); return (nth < INLINE_DECLS) ? &(sym->decls[nth]) : &(sym->overflow[nth - INLINE_DECLS]); } static decl_t *add_decl(symbol_t *sym) { if (sym->ndecls < INLINE_DECLS) return &(sym->decls[sym->ndecls++]); else if (sym->ndecls - INLINE_DECLS == sym->overflowsz) { sym->overflowsz = MAX(sym->overflowsz * 2, 32); sym->overflow = xrealloc_array(sym->overflow, sym->overflowsz, sizeof(decl_t)); } else assert(sym->ndecls - INLINE_DECLS < sym->overflowsz); return &(sym->overflow[sym->ndecls++ - INLINE_DECLS]); } static void grow_symbol_table(scope_t *s, unsigned mincount) { if (mincount <= s->tabsz / 2) return; const unsigned old_size = s->tabsz; symbol_t **old_tab = s->symtab; s->tabsz = MAX(s->tabsz * 2, next_power_of_2(mincount * 2)); s->symtab = xcalloc_array(s->tabsz, sizeof(symbol_t *)); for (int i = 0; i < old_size; i++) { if (old_tab[i] == NULL) continue; for (int slot = old_tab[i]->hash & (s->tabsz - 1);; slot = (slot + 1) & (s->tabsz - 1)) { if (s->symtab[slot] == NULL) { s->symtab[slot] = old_tab[i]; break; } } } if (old_tab != s->inlinetab) free(old_tab); } static symbol_t *local_symbol_for(scope_t *s, ident_t name) { grow_symbol_table(s, s->tabcount + 1); const uint32_t hash = hash_name(name); int slot = hash & (s->tabsz - 1); for (;; slot = (slot + 1) & (s->tabsz - 1)) { symbol_t *sym = s->symtab[slot]; if (sym == NULL) break; else if (sym->hash == hash && compare_name(sym->name, name)) return sym; } sym_chunk_t *chunk = s->sym_tail; if (chunk->count == SYMBOLS_PER_CHUNK) { chunk = s->sym_tail->chain = xcalloc(sizeof(sym_chunk_t)); s->sym_tail = chunk; } symbol_t *sym = &(chunk->symbols[chunk->count++]); sym->name = name; sym->owner = s; sym->ndecls = 0; sym->hash = hash; if (s->parent != NULL && s->formal_kind == F_NONE) { const symbol_t *exist = symbol_for(s->parent, name); if (exist != NULL) { for (int i = 0; i < exist->ndecls; i++) *add_decl(sym) = *get_decl(exist, i); } } s->symtab[slot] = sym; s->tabcount++; return sym; } static inline name_mask_t subprogram_name_mask(tree_t sub, name_mask_t mask) { if (tree_flags(sub) & TREE_F_PREDEFINED) mask |= N_PREDEF; return mask | N_OVERLOAD; } static name_mask_t name_mask_for(tree_t t) { switch (tree_kind(t)) { case T_VAR_DECL: case T_SIGNAL_DECL: case T_PORT_DECL: case T_PARAM_DECL: case T_CONST_DECL: case T_FIELD_DECL: case T_IMPLICIT_SIGNAL: case T_EXTERNAL_NAME: return N_OBJECT; case T_FUNC_BODY: case T_FUNC_DECL: case T_FUNC_INST: return subprogram_name_mask(t, N_FUNC); case T_PROC_BODY: case T_PROC_DECL: case T_PROC_INST: return subprogram_name_mask(t, N_PROC); case T_TYPE_DECL: case T_SUBTYPE_DECL: case T_PROT_DECL: case T_PROT_BODY: return N_TYPE; case T_GENERIC_DECL: { switch (class_of(t)) { case C_TYPE: return N_TYPE; case C_FUNCTION: return subprogram_name_mask(t, N_FUNC); case C_PROCEDURE: return subprogram_name_mask(t, N_PROC); default: return N_OBJECT; } } case T_ALIAS: { tree_t value = tree_value(t); switch (tree_kind(value)) { case T_REF: if (tree_has_ref(value)) return name_mask_for(tree_ref(value)); else if (tree_has_type(t) && type_is_subprogram(tree_type(t))) return N_SUBPROGRAM; else return N_OVERLOAD; // Suppress cascading errors case T_PROT_REF: return N_SUBPROGRAM | N_OVERLOAD; default: return N_OBJECT; } } case T_PSL_DECL: return N_PSL; case T_ENUM_LIT: case T_UNIT_DECL: return N_OVERLOAD; default: return 0; } } static void add_type_literals(scope_t *s, type_t type, make_visible_t fn) { switch (type_kind(type)) { case T_ENUM: { const int nlits = type_enum_literals(type); for (int i = 0; i < nlits; i++) { tree_t literal = type_enum_literal(type, i); ident_t lit_name = tree_ident(literal); (*fn)(s, lit_name, literal); } } break; case T_PHYSICAL: { const int nunits = type_units(type); for (int i = 0; i < nunits; i++) { tree_t unit = type_unit(type, i); ident_t unit_name = tree_ident(unit); (*fn)(s, unit_name, unit); } } break; default: break; } } static void warn_hidden_decl(scope_t *s, decl_t *outer, tree_t inner) { // Warn when an inner declaration hides an outer declaration but try // to avoid false-positives and cases that may be intentional for (scope_t *it = s; it && it != outer->origin; it = it->parent) { if (it->container == NULL) return; // Ignore ports in component, etc. else if (is_subprogram(it->container)) return; // Do not warn when subprogram parameters hide ports else if (tree_kind(it->container) == T_BLOCK) return; // Block ports hiding entity ports seem common and benign } type_t outer_type = get_type_or_null(outer->tree); if (outer_type == NULL) return; type_t inner_type = get_type_or_null(inner); if (inner_type == NULL) return; // If the types are different then any misuse is likely to generate a // type error instead if (!type_eq(inner_type, outer_type)) return; diag_t *d = diag_new(DIAG_WARN, tree_loc(inner)); diag_printf(d, "declaration of %s hides an earlier declaration with the " "same type", istr(tree_ident(inner))); diag_hint(d, tree_loc(inner), "by the %s declaration here", class_str(class_of(inner))); diag_hint(d, tree_loc(outer->tree), "this declaration is hidden"); diag_emit(d); } static symbol_t *make_visible(scope_t *s, ident_t name, tree_t decl, visibility_t kind, scope_t *origin) { symbol_t *sym = local_symbol_for(s, name); const tree_kind_t tkind = tree_kind(decl); const name_mask_t mask = name_mask_for(decl); const bool overload = !!(mask & N_OVERLOAD); type_t type = get_type_or_null(decl); assert(origin == s || kind != DIRECT); if (tkind == T_ATTR_SPEC) kind = ATTRIBUTE; else if (tkind == T_ALIAS && (tree_flags(decl) & TREE_F_NONOBJECT_ALIAS)) { // A nonobject alias points directly to the aliased named entity // not to the alias declaration decl = tree_ref(tree_value(decl)); } for (int i = 0; i < sym->ndecls; i++) { decl_t *dd = get_decl_mutable(sym, i); if (dd->tree == decl) return sym; else if (dd->visibility == HIDDEN) continue; else if (dd->kind == T_LIBRARY) { if (tkind == T_LIBRARY && tree_ident(decl) == name) return sym; // Ignore redundant library declarations else dd->visibility = HIDDEN; } else if ((!overload || dd->visibility != OVERLOAD) && kind == DIRECT) { if (dd->origin == s && is_forward_decl(decl, dd->tree)) { // Replace forward declaration in same region with full // definition dd->visibility = HIDDEN; } else if (dd->origin == s && s->formal_kind == F_SUBPROGRAM) ; // Resolving subprogram formal names else if (dd->visibility == POTENTIAL) ; // Hide declaration visible from use clause else if (dd->kind == T_LIBRARY) dd->visibility = HIDDEN; // Library hidden by design unit else if (dd->origin == s) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(decl)); diag_printf(d, "%s already declared in this region", istr(name)); diag_hint(d, tree_loc(dd->tree), "previous declaration was here"); diag_hint(d, tree_loc(decl), "duplicate declaration"); diag_suppress(d, s->suppress); diag_emit(d); return sym; } else if (dd->visibility == DIRECT && (dd->mask & mask & N_OBJECT)) warn_hidden_decl(s, dd, decl); dd->visibility = HIDDEN; } else if (!overload && kind == POTENTIAL && dd->visibility == DIRECT) kind = HIDDEN; else if (dd->origin == origin && (dd->mask & mask & N_SUBPROGRAM) && (dd->mask & N_PREDEF) && type_eq(tree_type(dd->tree), type)) { // Allow pre-defined operators be to hidden by user-defined // subprograms in the same region dd->visibility = HIDDEN; } else if (is_forward_decl(decl, dd->tree)) dd->visibility = HIDDEN; else if (denotes_same_object(dd->tree, decl) && standard() >= STD_08) { // According LRM 08 section 12.3 two declarations are not // homographs if they denote different named entities return sym; } else if (overload && kind == DIRECT && type != NULL && tree_has_type(dd->tree) && type_eq(type, tree_type(dd->tree))) { if (dd->origin != s) { // LRM 93 section 10.3 on visibility specifies that if two // declarations are homographs then the one in the inner scope // hides the one in the outer scope dd->visibility = HIDDEN; } else if ((dd->kind == T_FUNC_BODY && tkind == T_FUNC_BODY) || (dd->kind == T_PROC_BODY && tkind == T_PROC_BODY)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(decl)); diag_printf(d, "duplicate subprogram body %s", type_pp(type)); diag_hint(d, tree_loc(decl), "duplicate definition here"); diag_hint(d, tree_loc(dd->tree), "previous definition was here"); diag_suppress(d, s->suppress || type_has_error(type)); diag_emit(d); return sym; } else if (dd->kind == T_ENUM_LIT && tkind == T_ENUM_LIT) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(decl)); diag_printf(d, "duplicate enumeration literal %s", istr(sym->name)); diag_hint(d, tree_loc(decl), "duplicate definition here"); diag_hint(d, tree_loc(dd->tree), "previous definition was here"); diag_suppress(d, s->suppress || type_has_error(type)); diag_emit(d); return sym; } else if (dd->origin == origin) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(decl)); if (type_strict_eq(tree_type(dd->tree), type)) diag_printf(d, "%s already declared in this region", type_pp(type)); else { diag_printf(d, "homograph of %s already declared in this region", type_pp(type)); diag_hint(d, NULL, "only the base type is considered when " "determining if two overloads have the same parameter " "type profile"); } diag_hint(d, tree_loc(dd->tree), "previous declaration was here"); diag_hint(d, tree_loc(decl), "duplicate declaration"); diag_suppress(d, s->suppress || type_has_error(type)); diag_emit(d); return sym; } } else if (kind == ATTRIBUTE && dd->visibility == ATTRIBUTE && tree_has_ref(dd->tree) && tree_has_ref(decl)) { tree_t of = tree_ref(decl); if (of == tree_ref(dd->tree)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(decl)); diag_printf(d, "duplicate specification for attribute %s of %s %s", istr(tree_ident(decl)), class_str(tree_class(decl)), istr(tree_ident(of))); diag_hint(d, tree_loc(dd->tree), "previous specification was here"); diag_hint(d, tree_loc(decl), "duplicate specification"); diag_suppress(d, s->suppress); diag_emit(d); } } } *add_decl(sym) = (decl_t) { .tree = decl, .visibility = overload ? OVERLOAD : kind, .origin = origin, .mask = mask, .kind = tkind, }; sym->mask |= mask; if (kind == DIRECT && (mask & N_TYPE) && is_type_decl(decl)) add_type_literals(s, tree_type(decl), make_visible_slow); return sym; } static void merge_symbol(scope_t *s, const symbol_t *src) { symbol_t *dst = local_symbol_for(s, src->name); dst->mask |= src->mask; const bool was_fresh = (dst->ndecls == 0); for (int i = 0; i < src->ndecls; i++) { const decl_t *dd = get_decl(src, i); assert(dd->origin == src->owner); if (dd->visibility == HIDDEN || dd->visibility == POTENTIAL) continue; if (was_fresh) { *add_decl(dst) = (decl_t) { .tree = dd->tree, .visibility = dd->visibility == DIRECT ? POTENTIAL : dd->visibility, .origin = dd->origin, .mask = dd->mask, .kind = dd->kind, }; } else make_visible(s, src->name, dd->tree, POTENTIAL, dd->origin); } } static void merge_scopes(scope_t *to, scope_t *from) { grow_symbol_table(to, from->tabcount); for (sym_chunk_t *chunk = &(from->symbols); chunk; chunk = chunk->chain) { for (int i = 0; i < chunk->count; i++) { symbol_t *sym = &(chunk->symbols[i]); assert(sym->owner->container == from->container); merge_symbol(to, sym); } } } static symbol_t *lazy_lib_cb(scope_t *s, ident_t name, void *context) { lib_t lib = context; bool error; tree_t unit = lib_get_allow_error(lib, name, &error); if (unit == NULL || error) return NULL; return make_visible(s, name, unit, DIRECT, s); } static void make_library_visible(scope_t *s, lib_t lib) { lazy_sym_t *l = xmalloc(sizeof(lazy_sym_t)); l->next = s->lazy; l->fn = lazy_lib_cb; l->ctx = lib; s->lazy = l; } static void make_visible_slow(scope_t *s, ident_t name, tree_t decl) { // Wrapper for make_visible in the common case of direct visibility // and the origin is the same as the target scope make_visible(s, name, decl, DIRECT, s); } static void make_visible_fast(scope_t *s, ident_t id, tree_t d) { // This should be functionally equivalent to calling make_visible but // with the knowledge there are no existing symbols in the scope and // it has been checked already const tree_kind_t kind = tree_kind(d); const name_mask_t mask = name_mask_for(d); visibility_t visibility = DIRECT; if (mask & N_OVERLOAD) visibility = OVERLOAD; else if (kind == T_ATTR_SPEC) visibility = ATTRIBUTE; symbol_t *sym = local_symbol_for(s, id); *add_decl(sym) = (decl_t) { .tree = d, .visibility = visibility, .origin = s, .mask = mask, .kind = kind, }; if ((sym->mask & N_PREDEF) && (mask & N_SUBPROGRAM) && !(mask & N_PREDEF)) { // User defined subprograms hide predefined in the same region type_t type = tree_type(d); for (int i = 0; i < sym->ndecls; i++) { decl_t *dd = get_decl_mutable(sym, i); assert(dd->origin == s); if ((dd->mask & mask & N_SUBPROGRAM) && (dd->mask & N_PREDEF) && type_eq(tree_type(dd->tree), type)) dd->visibility = HIDDEN; } } sym->mask |= mask; if ((mask & N_TYPE) && is_type_decl(d)) add_type_literals(s, tree_type(d), make_visible_fast); } static void make_potentially_visible(scope_t *s, ident_t id, tree_t d) { make_visible(s, id, d, POTENTIAL, s); } static void missing_record_field_cb(diag_t *d, ident_t name, void *arg) { type_t type = arg; diag_printf(d, "record type %s has no field named %s", type_pp(type), istr(name)); ident_t best = NULL; int bestd = INT_MAX; LOCAL_TEXT_BUF tb = tb_new(); int nfields = type_fields(type), i; tb_printf(tb, "type %s has field%s ", type_pp(type), nfields > 1 ? "s" : ""); for (i = 0; i < nfields; i++) { ident_t id = tree_ident(type_field(type, i)); const int d = ident_distance(id, name); if (d < bestd) { best = id; bestd = d; } if (i > 0 && i == nfields - 1) tb_cat(tb, ", and "); else if (i > 0) tb_cat(tb, ", "); tb_istr(tb, id); } diag_hint(d, NULL, "%s", tb_get(tb)); if (bestd <= 3) diag_hint(d, diag_get_loc(d), "did you mean %s?", istr(best)); } static scope_t *scope_for_type(nametab_t *tab, type_t type) { type_t base = type; while (is_anonymous_subtype(base)) base = type_base(base); scope_t *s = hash_get(tab->globalmap, base); if (s != NULL) return s; s = new_scope(); s->chain = tab->globals; if (type_is_record(base)) { s->formal_kind = F_RECORD; s->formal_fn = missing_record_field_cb; s->formal_arg = base; } else assert(type_is_protected(base)); const int nfields = type_fields(base); for (int i = 0; i < nfields; i++) { tree_t d = type_field(base, i); make_visible_fast(s, tree_ident(d), d); } hash_put(tab->globalmap, base, s); return (tab->globals = s); } static scope_t *private_scope_for(nametab_t *tab, tree_t unit) { const tree_kind_t kind = tree_kind(unit); hash_t *cache = tab->globalmap; lib_t lib = NULL; void *key = unit; if (kind == T_LIBRARY) key = lib = lib_require(tree_ident(unit)); // Tree pointer is not stable else if (is_well_known(tree_ident(unit)) < NUM_WELL_KNOWN) { // Standard packages can be safely stored in a global cache as we // know they won't change static hash_t *stdcache = NULL; INIT_ONCE(stdcache = hash_new(64)); cache = stdcache; } scope_t *s = hash_get(cache, key); if (s != NULL) return s; s = new_scope(); s->container = unit; if (cache == tab->globalmap) { s->chain = tab->globals; tab->globals = s; } if (kind == T_LIBRARY) make_library_visible(s, lib); else { // For package instances do not export the names declared only in // the body const int ndecls = kind == T_PACK_INST && tree_has_ref(unit) ? tree_decls(tree_ref(unit)) : tree_decls(unit); grow_symbol_table(s, ndecls); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(unit, i); const tree_kind_t dkind = tree_kind(d); if (dkind == T_ALIAS || dkind == T_TYPE_DECL) { // Handle special cases: an alias may make the same // enumeration literal visible multiple times and a type // declaration may hide an earlier incomplete type make_visible_slow(s, tree_ident(d), d); } else if (dkind != T_USE) make_visible_fast(s, tree_ident(d), d); } switch (kind) { case T_ENTITY: case T_BLOCK: { const int nports = tree_ports(unit); for (int i = 0; i < nports; i++) { tree_t p = tree_port(unit, i); make_visible_fast(s, tree_ident(p), p); } } // Fall-through case T_PACKAGE: case T_PACK_INST: { const int ngenerics = tree_generics(unit); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(unit, i), decl = g; const class_t class = tree_class(g); if (class == C_FUNCTION || class == C_PROCEDURE) { // A single subprogram could be visible both directly // and as a actual generic subprogram tree_t value = find_generic_map(unit, i, g); if (value == NULL) assert(error_count() > 0 || is_uninstantiated_package(unit)); else if (tree_kind(value) == T_REF && tree_has_ref(value)) { decl = tree_ref(value); assert(is_subprogram(decl)); } } make_visible_fast(s, tree_ident(g), decl); } } break; default: break; } } hash_put(cache, key, s); return s; } static bool is_forward_decl(tree_t decl, tree_t existing) { tree_kind_t tkind = tree_kind(decl); tree_kind_t ekind = tree_kind(existing); if ((tkind == T_TYPE_DECL || tkind == T_PROT_DECL) && ekind == T_TYPE_DECL) return type_kind(tree_type(existing)) == T_INCOMPLETE; else if ((tkind == T_FUNC_BODY && ekind == T_FUNC_DECL) || (tkind == T_PROC_BODY && ekind == T_PROC_DECL)) { return type_eq(tree_type(decl), tree_type(existing)) && !(tree_flags(existing) & TREE_F_PREDEFINED); } else if (tkind == T_PROT_BODY && ekind == T_PROT_DECL) return type_eq(tree_type(decl), tree_type(existing)); else if (tkind == T_CONST_DECL && ekind == T_CONST_DECL) return tree_has_value(decl) && !tree_has_value(existing); else return false; } tree_t find_forward_decl(nametab_t *tab, tree_t decl) { scope_t *region = tab->top_scope; if (region->container == decl) region = region->parent; const symbol_t *sym = lookup_symbol(region, tree_ident(decl)); if (sym == NULL) return NULL; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->origin == region && is_forward_decl(decl, dd->tree)) return dd->tree; } return NULL; } tree_t get_local_decl(nametab_t *tab, tree_t container, ident_t name, int nth) { scope_t *scope; if (container == NULL || container == tab->top_scope->container) scope = tab->top_scope; else scope = private_scope_for(tab, container); const symbol_t *sym = lookup_symbol(scope, name); if (sym == NULL) return NULL; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->origin != scope || dd->visibility == HIDDEN) continue; else if (nth-- == 0) return dd->tree; } return NULL; } bool is_same_region(nametab_t *tab, tree_t decl) { const symbol_t *sym = lookup_symbol(tab->top_scope, tree_ident(decl)); if (sym == NULL) return false; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->origin == tab->top_scope && dd->tree == decl) return true; } return false; } tree_t get_container(nametab_t *tab, tree_t decl) { const symbol_t *sym = symbol_for(tab->top_scope, tree_ident(decl)); if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->tree == decl) return dd->origin->container; } } return NULL; } psl_node_t find_default_clock(nametab_t *tab) { ident_t id = well_known(W_DEFAULT_CLOCK); const symbol_t *sym = symbol_for(tab->top_scope, id); if (sym == NULL) return NULL; const decl_t *dd = get_decl(sym, 0); assert(dd->kind == T_PSL_DECL); return tree_psl(dd->tree); } static bool is_predef_for_type(tree_t d, type_t type) { if (!is_subprogram(d)) return false; else if (!is_operator_symbol(tree_ident(d)) && !(tree_flags(d) & TREE_F_PREDEFINED)) return false; else if (tree_ports(d) == 0) return false; else return type_strict_eq(tree_type(tree_port(d, 0)), type); } void walk_predefs(nametab_t *tab, ident_t name, predef_cb_t fn, void *context) { const symbol_t *sym = iterate_symbol_for(tab, name); assert(sym != NULL); for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (!(dd->mask & N_TYPE) || !is_type_decl(dd->tree)) continue; tree_t region = NULL; for (scope_t *s = dd->origin; (region = s->container) == NULL; s = s->parent) ; type_t type = tree_type(dd->tree); const int ndecls = tree_decls(region); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(region, i); if (is_predef_for_type(d, type)) (*fn)(d, context); } } } void insert_name(nametab_t *tab, tree_t decl, ident_t alias) { make_visible_slow(tab->top_scope, alias ?: tree_ident(decl), decl); } void hide_name(nametab_t *tab, ident_t name) { const symbol_t *exist = symbol_for(tab->top_scope, name); if (exist == NULL || exist->owner == tab->top_scope) return; else if (opt_get_int(OPT_RELAXED)) return; symbol_t *sym = local_symbol_for(tab->top_scope, name); for (int i = 0; i < sym->ndecls; i++) { decl_t *dd = get_decl_mutable(sym, i); if (dd->origin != tab->top_scope && dd->visibility == DIRECT) dd->visibility = HIDDEN; } } void insert_spec(nametab_t *tab, tree_t spec, spec_kind_t kind, ident_t ident, int depth) { scope_t *scope; for (scope = tab->top_scope; depth > 0; depth--, scope = scope->parent) ; assert(scope != NULL); spec_t **p; for (p = &(scope->specs); *p != NULL; p = &((*p)->next)) { if (kind == SPEC_EXACT && (*p)->ident == ident) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(spec)); diag_printf(d, "duplicate specification for instance %s", istr(ident)); diag_hint(d, tree_loc((*p)->tree), "previous specification was here"); diag_hint(d, tree_loc(spec), "duplicate specification here"); diag_emit(d); return; } } spec_t *s = xmalloc(sizeof(spec_t)); s->next = NULL; s->kind = kind; s->ident = ident; s->tree = spec; s->matches = 0; *p = s; } void continue_proc_labelling_from(tree_t t, nametab_t *tab) { if (t == NULL) { tab->top_scope->lbl_cnts.proc = 0; return; } assert (tree_kind(t) == T_ENTITY); const int nstmts = tree_stmts(t); int cnt = 0; ident_t prefix = ident_new("_P"); for (int i = 0; i < nstmts; i++) { tree_t stmt = tree_stmt(t, i); // Entity statements for sure have labels since they have been implicitly // labelled if (ident_starts_with(tree_ident(stmt), prefix)) cnt++; } tab->top_scope->lbl_cnts.proc = cnt; } ident_t get_implicit_label(tree_t t, nametab_t *tab) { int *cnt; char c; char buf[22]; switch (tree_kind(t)) { case T_CONCURRENT: case T_PROCESS: case T_PSL_DIRECT: cnt = &(tab->top_scope->lbl_cnts.proc); c = 'P'; break; case T_FOR: case T_WHILE: case T_LOOP: cnt = NULL; for (scope_t *s = tab->top_scope; s != NULL; s = s->parent) { if (s->container == NULL) continue; if (is_subprogram(s->container) || tree_kind(s->container) == T_PROCESS) { cnt = &(s->lbl_cnts.loop); break; } } c = 'L'; break; default: return NULL; } checked_sprintf(buf, sizeof(buf), "_%c%d", c, (*cnt)++); return ident_new(buf); } type_t resolve_type(nametab_t *tab, type_t incomplete) { assert(type_kind(incomplete) == T_INCOMPLETE); ident_t name = ident_rfrom(type_ident(incomplete), '.'); const symbol_t *sym = symbol_for(tab->top_scope, name); if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->kind == T_TYPE_DECL || dd->kind == T_PROT_DECL) { type_t def = tree_type(dd->tree); if (type_kind(def) != T_INCOMPLETE && type_eq(def, incomplete)) return def; } } } return incomplete; } name_mask_t query_name(nametab_t *tab, ident_t name, tree_t *p_decl) { const symbol_t *sym = iterate_symbol_for(tab, name); if (sym == NULL) return 0; name_mask_t mask = 0; tree_t uniq = NULL; int count = 0; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility != HIDDEN && dd->visibility != ATTRIBUTE) { count++; uniq = dd->tree; mask |= dd->mask; } } if (p_decl && count == 1) *p_decl = uniq; mask |= count << 16; return mask; } tree_t query_spec(nametab_t *tab, tree_t object) { if (!tree_has_ref(object)) return NULL; // Was earlier error spec_t *others = NULL; for (spec_t *it = tab->top_scope->specs; it != NULL; it = it->next) { switch (it->kind) { case SPEC_ALL: if (tree_ident(tree_ref(object)) == tree_ident2(it->tree)) { it->matches++; return it->tree; } break; case SPEC_OTHERS: if (tree_ident(tree_ref(object)) == tree_ident2(it->tree)) others = it; break; case SPEC_EXACT: if (it->ident == tree_ident(object)) { it->matches++; return it->tree; } break; } } if (others != NULL) { others->matches++; return others->tree; } return NULL; } static bool denotes_same_object(tree_t a, tree_t b) { if (tree_kind(a) == T_ALIAS) { tree_t value = tree_value(a); if (tree_kind(value) == T_REF && tree_has_ref(value)) return denotes_same_object(tree_ref(value), b); } else if (tree_kind(b) == T_ALIAS) { tree_t value = tree_value(b); if (tree_kind(value) == T_REF && tree_has_ref(value)) return denotes_same_object(a, tree_ref(value)); } return a == b; } static const symbol_t *iterate_symbol_for(nametab_t *tab, ident_t name) { for (scope_t *s = tab->top_scope, *ss = NULL; ; s = ss, ss = NULL) { ident_t next = ident_walk_selected(&name); const symbol_t *sym = lazy_symbol_for(s, next); if (sym == NULL || name == NULL) return sym; for (int i = 0; i < sym->ndecls && ss == NULL; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN) continue; else if (dd->kind == T_LIBRARY || is_container(dd->tree)) ss = private_scope_for(tab, dd->tree); } if (ss == NULL) return NULL; } } static void hint_for_typo(scope_t *top_scope, diag_t *d, ident_t name, name_mask_t filter) { if (ident_runtil(name, '.') != name) return; // Ignore selected names const symbol_t *best = NULL; int bestd = INT_MAX; for (scope_t *s = top_scope; s != NULL; s = s->parent) { for (sym_chunk_t *chunk = &(s->symbols); chunk; chunk = chunk->chain) { for (int i = 0; i < chunk->count; i++) { if (chunk->symbols[i].mask & filter) { const int d = ident_distance(chunk->symbols[i].name, name); if (d > 0 && d < bestd) { best = &(chunk->symbols[i]); bestd = d; } } } } if (s->formal_kind != F_NONE) break; } if (bestd <= (ident_len(name) <= 4 ? 2 : 3)) diag_hint(d, diag_get_loc(d), "did you mean %s?", istr(best->name)); } static type_t get_result_type(nametab_t *tab, tree_t decl) { if (tree_kind(decl) == T_ALIAS && !tree_has_type(decl)) return tree_type(tree_value(decl)); type_t type = tree_type(decl); if (type_kind(type) != T_SIGNATURE || !type_has_result(type)) return type; type_t rtype = type_result(type); if (type_is_incomplete(rtype)) return resolve_type(tab, rtype); return rtype; } static tree_t get_aliased_subprogram(tree_t t) { assert(tree_kind(t) == T_ALIAS); tree_t aliased = tree_value(t); const tree_kind_t kind = tree_kind(aliased); if (kind == T_REF && tree_has_ref(aliased)) { tree_t decl = tree_ref(aliased); if (tree_kind(decl) == T_ALIAS) return get_aliased_subprogram(decl); else return decl; } else if (kind == T_PROT_REF) return aliased; else return NULL; } static bool can_call_no_args(tree_t t) { switch (tree_kind(t)) { case T_FUNC_DECL: case T_FUNC_BODY: case T_FUNC_INST: case T_PROC_DECL: case T_PROC_BODY: case T_PROC_INST: case T_GENERIC_DECL: return !!(tree_flags(t) & TREE_F_CALL_NO_ARGS); case T_ALIAS: return can_call_no_args(get_aliased_subprogram(t)); case T_PROT_REF: return can_call_no_args(tree_ref(t)); default: return false; } } static tree_t try_resolve_name(nametab_t *tab, ident_t name) { const symbol_t *sym = iterate_symbol_for(tab, name); if (sym == NULL) return NULL; if (sym->ndecls == 1) { const decl_t *dd = get_decl(sym, 0); if (dd->visibility != HIDDEN) return dd->tree; } // Check if all but one declaration is hidden int hidden = 0, overload = 0, subprograms = 0; tree_t result = NULL; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN || dd->visibility == ATTRIBUTE) hidden++; else result = dd->tree; if (dd->visibility == OVERLOAD) { overload++; if (dd->mask & N_SUBPROGRAM) subprograms++; } } if (hidden == sym->ndecls - 1) return result; else if (overload == 0 || tab->top_type_set == NULL) return NULL; // Use the context to determine the correct overload SCOPED_A(tree_t) m = AINIT; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == OVERLOAD || tab->top_type_set->members.count == 0) APUSH(m, dd->tree); } if (m.count > 1 && subprograms > 0) { unsigned wptr = 0; for (int i = 0; i < m.count; i++) { if (is_subprogram(m.items[i])) { // Remove subprograms that cannot be called with zero // arguments if (!can_call_no_args(m.items[i])) continue; // Remove subprograms where the result does not satisfy the // required predicate type_pred_t p = tab->top_type_set->pred; if (p != NULL && !(*p)(get_result_type(tab, m.items[i]))) continue; } m.items[wptr++] = m.items[i]; } ATRIM(m, wptr); } if (m.count > 1) { // Remove any duplicates from aliases unsigned wptr = 0; for (int i = 0; i < m.count; i++) { bool is_dup = false; for (int j = 0; !is_dup && j < i; j++) { if (denotes_same_object(m.items[i], m.items[j])) is_dup = true; } if (!is_dup) m.items[wptr++] = m.items[i]; } assert(wptr >= 1); ATRIM(m, wptr); } if (m.count == 1) return m.items[0]; if (tab->top_type_set == NULL) return NULL; const bool type_set_empty = tab->top_type_set->members.count == 0; unsigned wptr = 0; for (unsigned i = 0; i < m.count; i++) { if (class_has_type(class_of(m.items[i]))) { type_t type = get_result_type(tab, m.items[i]); if (type_set_empty) type_set_add(tab, type, m.items[i]); else if (type_set_contains(tab, type)) m.items[wptr++] = m.items[i]; } } ATRIM(m, wptr); if (m.count == 1) return m.items[0]; return NULL; } tree_t resolve_name(nametab_t *tab, const loc_t *loc, ident_t name) { tree_t decl = try_resolve_name(tab, name); if (decl != NULL) return decl; const symbol_t *sym = iterate_symbol_for(tab, name); if (sym == NULL) { if (tab->top_scope->suppress) { // Suppressing cascading errors assert(error_count() > 0); } else if (name == well_known(W_ERROR)) { // Was a parse error, suppress further errors } else if (tab->top_scope->overload && !tab->top_scope->overload->error) { diag_t *d = diag_new(DIAG_ERROR, loc); diag_printf(d, "no possible overload of %s has formal %s", istr(tab->top_scope->overload->name), istr(name)); diag_hint(d, loc, "formal argument name %s", istr(name)); hint_for_typo(tab->top_scope, d, name, N_OBJECT); const unsigned count = tab->top_scope->overload->candidates.count; for (unsigned i = 0; i < count; i++) { tree_t t = tab->top_scope->overload->candidates.items[i]; const int nports = tree_ports(t); if (nports > 0) { LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "subprogram %s has argument%s ", type_pp(tree_type(t)), nports > 1 ? "s" : ""); for (int j = 0; j < nports; j++) tb_printf(tb, "%s%s", j > 0 ? ", " : "", istr(tree_ident(tree_port(t, j)))); diag_hint(d, tree_loc(t), "%s", tb_get(tb)); } } diag_emit(d); tab->top_scope->overload->error = true; } else if (tab->top_scope->formal_kind != F_NONE) { diag_t *d = diag_new(DIAG_ERROR, loc); if (tab->top_scope->formal_fn != NULL) (*tab->top_scope->formal_fn)(d, name, tab->top_scope->formal_arg); else diag_printf(d, "invalid formal name %s", istr(name)); diag_emit(d); } else if (tab->top_scope->overload == NULL) { diag_t *d = diag_new(DIAG_ERROR, loc); ident_t prefix = ident_runtil(name, '.'); const symbol_t *psym = prefix ? iterate_symbol_for(tab, prefix) : NULL; if (psym != NULL) { for (int i = 0; i < psym->ndecls; i++) { const decl_t *dd = get_decl(psym, i); if (dd->visibility == HIDDEN) diag_hint(d, tree_loc(dd->tree), "%s %s is hidden", class_str(class_of(dd->tree)), istr(psym->name)); else if (dd->kind == T_LIBRARY) { lib_t lib = lib_require(psym->name); if (lib_had_errors(lib, name)) { diag_printf(d, "design unit depends on %s which was " "analysed with errors", istr(name)); tab->top_scope->suppress = true; } else diag_printf(d, "design unit %s not found in library %s", istr(ident_rfrom(name, '.')), istr(psym->name)); break; } else { diag_printf(d, "name %s not found in %s %s", istr(ident_rfrom(name, '.')), class_str(class_of(dd->tree)), istr(psym->name)); break; } } } else diag_printf(d, "no visible declaration for %s", istr(name)); hint_for_typo(tab->top_scope, d, name, N_OBJECT | N_TYPE | N_FUNC); diag_emit(d); } // Suppress further errors for this name local_symbol_for(tab->top_scope, name)->mask |= N_ERROR; return NULL; } int hidden = 0, overload = 0; for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN || dd->visibility == ATTRIBUTE) hidden++; else if (dd->visibility == OVERLOAD) overload++; } if (type_set_any(tab, type_is_none)) return NULL; // Suppress cascading errors else if ((sym->mask & N_ERROR) || tab->top_scope->suppress) return NULL; // Was an earlier error tree_kind_t what = T_LAST_TREE_KIND; for (unsigned i = 0; i < sym->ndecls; i++) { const tree_kind_t kind = tree_kind(get_decl(sym, i)->tree); if (what == T_LAST_TREE_KIND) what = kind; else if (what != kind) what = T_REF; } diag_t *d = diag_new(DIAG_ERROR, loc); if (hidden > 0 && hidden == sym->ndecls) { diag_printf(d, "declaration of %s is hidden", istr(name)); diag_hint(d, NULL, "the $bold$--relaxed$$ option suppresses this error"); } else if (overload == 0) diag_printf(d, "multiple conflicting visible declarations of %s", istr(name)); else diag_printf(d, "ambiguous use of %s %s", what == T_ENUM_LIT ? "enumeration literal" : (what == T_UNIT_DECL ? "physical literal" : "name"), istr(name)); for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); LOCAL_TEXT_BUF tb = tb_new(); switch (dd->visibility) { case HIDDEN: tb_cat(tb, "hidden"); break; case OVERLOAD: tb_cat(tb, "visible"); break; case DIRECT: tb_cat(tb, "directly visible"); break; case POTENTIAL: tb_cat(tb, "potentially visible"); break; case ATTRIBUTE: continue; } tb_printf(tb, " declaration of %s", istr(name)); type_t type = get_type_or_null(dd->tree); if (type != NULL && !is_type_decl(dd->tree)) tb_printf(tb, " as %s", type_pp(tree_type(dd->tree))); const bool has_named_origin = dd->origin->container != NULL && (tree_kind(dd->origin->container) != T_PROCESS || !(tree_flags(dd->origin->container) & TREE_F_SYNTHETIC_NAME)); if (has_named_origin) { tree_t primary = is_design_unit(dd->origin->container) ? primary_unit_of(dd->origin->container) : dd->origin->container; tb_printf(tb, " from %s%s", istr(tree_ident(primary)), primary != dd->origin->container ? " body" : ""); } diag_hint(d, tree_loc(dd->tree), "%s", tb_get(tb)); } diag_hint(d, loc, "use of name %s here", istr(name)); diag_emit(d); return NULL; } static tree_t resolve_method_name(nametab_t *tab, tree_t ref, type_t constraint) { assert(tree_kind(ref) == T_PROT_REF); assert(constraint != NULL); type_t ptype = tree_type(tree_value(ref)); assert(type_is_protected(ptype)); scope_t *scope = scope_for_type(tab, ptype); const symbol_t *sym = symbol_for(scope, tree_ident(ref)); SCOPED_A(tree_t) matching = AINIT; if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN) continue; else if (dd->mask & N_SUBPROGRAM) { type_t signature = tree_type(dd->tree); if (type_eq_map(constraint, signature, tab->top_scope->gmap)) APUSH(matching, dd->tree); } } } assert(matching.count <= 1); if (matching.count == 1) return matching.items[0]; else if (tab->top_scope->suppress) return NULL; else { const char *signature = strchr(type_pp(constraint), '['); error_at(tree_loc(ref), "no visible method %s in protected type %s " "matches signature %s", istr(tree_ident(ref)), type_pp(ptype), signature); return NULL; } } tree_t resolve_uninstantiated_subprogram(nametab_t *tab, const loc_t *loc, ident_t name, type_t constraint) { const symbol_t *sym = iterate_symbol_for(tab, name); SCOPED_A(tree_t) m = AINIT; if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN) continue; else if (dd->mask & N_SUBPROGRAM) { if (constraint == NULL) APUSH(m, dd->tree); else { type_t signature = tree_type(dd->tree); if (type_eq_map(constraint, signature, tab->top_scope->gmap)) APUSH(m, dd->tree); } } } } if (m.count > 1) { unsigned wptr = 0; for (unsigned i = 0; i < m.count; i++) { if (is_uninstantiated_subprogram(m.items[i])) m.items[wptr++] = m.items[i]; } ATRIM(m, wptr); } if (m.count == 1) { if (is_uninstantiated_subprogram(m.items[0])) return m.items[0]; else { error_at(loc, "%s %s is not an uninstantiated subprogram", class_str(class_of(m.items[0])), istr(name)); return NULL; } } else if (tab->top_scope->suppress) return NULL; else if (constraint != NULL) { const char *signature = strchr(type_pp(constraint), '['); error_at(loc, "no visible uninstantiated subprogram %s matches " "signature %s", istr(name), signature); return NULL; } else if (m.count == 0) { error_at(loc,"no visible uninstantiated subprogram declaration for %s", istr(name)); return NULL; } else { diag_t *d = diag_new(DIAG_ERROR, loc); diag_printf(d, "multiple visible uninstantiated subprograms with " "name %s", istr(name)); for (int i = 0; i < m.count; i++) diag_hint(d, tree_loc(m.items[i]), "visible declaration of %s", type_pp(tree_type(m.items[i]))); diag_hint(d, loc, "use of name %s here", istr(name)); diag_hint(d, NULL, "use an explicit subprogram signature to select " "a particular overload"); diag_emit(d); return NULL; } } tree_t resolve_subprogram_name(nametab_t *tab, const loc_t *loc, ident_t name, type_t constraint) { const bool allow_enum = type_kind(constraint) == T_SIGNATURE && type_params(constraint) == 0 && type_has_result(constraint); const symbol_t *sym = iterate_symbol_for(tab, name); SCOPED_A(tree_t) matching = AINIT; if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN) continue; else if (dd->mask & N_SUBPROGRAM) { type_t signature = tree_type(dd->tree); if (type_eq_map(constraint, signature, tab->top_scope->gmap)) APUSH(matching, dd->tree); } else if (allow_enum && dd->kind == T_ENUM_LIT && type_eq(type_result(constraint), tree_type(dd->tree))) APUSH(matching, dd->tree); } } if (matching.count == 1) return matching.items[0]; else if (tab->top_scope->suppress) return NULL; else { const char *signature = strchr(type_pp(constraint), '['); error_at(loc, "no visible subprogram%s %s matches signature %s", allow_enum ? " or enumeration literal" : "", istr(name), signature); return NULL; } } tree_t resolve_field_name(nametab_t *tab, const loc_t *loc, ident_t name, type_t type) { assert(type_is_record(type)); scope_t *tmp = tab->top_scope; tab->top_scope = scope_for_type(tab, type); tree_t decl = resolve_name(tab, loc, name); assert(decl == NULL || tree_kind(decl) == T_FIELD_DECL); tab->top_scope = tmp; return decl; } static tree_t resolve_ref(nametab_t *tab, tree_t ref) { const loc_t *loc = tree_loc(ref); ident_t name = tree_ident(ref); type_t constraint; if (type_set_uniq(tab, &constraint) && type_is_subprogram(constraint)) { // Reference to subprogram or enumeration literal with signature return resolve_subprogram_name(tab, loc, name, constraint); } else { // Ordinary reference return resolve_name(tab, loc, name); } } void resolve_resolution(nametab_t *tab, tree_t rname, type_t type) { // Finding the resolution function is a special case of overload resolution switch (tree_kind(rname)) { case T_ELEM_RESOLUTION: if (type_is_record(type)) error_at(tree_loc(rname), "sorry, record element resolution is not " "supported yet"); else if (!type_is_array(type)) error_at(tree_loc(rname), "non-composite type %s may not have element " "resolution indication", type_pp(type)); else if (tree_assocs(rname) != 1) error_at(tree_loc(rname), "non-record type %s may not have record " "element resolution indication", type_pp(type)); else { tree_t a0 = tree_value(tree_assoc(rname, 0)); resolve_resolution(tab, a0, type_elem(type)); } break; case T_REF: { tree_set_ref(rname, NULL); type_set_t ts = {}; type_set_push(tab, &ts); type_set_add(tab, type, NULL); overload_t o = { .tree = rname, .state = O_IDLE, .nametab = tab, .trace = false, .name = tree_ident(rname) }; begin_overload_resolution(&o); tree_set_ref(rname, finish_overload_resolution(&o)); type_set_pop(tab, &ts); } break; default: error_at(tree_loc(rname), "not a valid resolution function for type %s", type_pp(type)); tree_set_type(rname, type_new(T_NONE)); break; } } tree_t find_std(nametab_t *tab) { if (tab->std != NULL) return tab->std; else if (opt_get_int(OPT_BOOTSTRAP)) return (tab->std = tab->top_scope->container); else { tab->std = resolve_name(tab, NULL, ident_new("STD.STANDARD")); if (tab->std == NULL) fatal_trace("cannot continue without STD.STANDARD"); return tab->std; } } void insert_names_from_use(nametab_t *tab, tree_t use) { assert(tree_kind(use) == T_USE); if (!tree_has_ref(use) || !tree_has_ident2(use)) return; // Was earlier error tree_t unit = tree_ref(use); ident_t what = tree_ident2(use); if (tree_kind(unit) == T_GENERIC_DECL) { assert(tree_class(unit) == C_PACKAGE); tree_t map = tree_value(unit); assert(tree_kind(map) == T_PACKAGE_MAP); if (!tree_has_ref(map)) return; // Was earlier error unit = tree_ref(map); assert(is_uninstantiated_package(unit)); } if (tree_kind(unit) == T_LIBRARY) { ident_t lib_name = tree_ident2(unit); ident_t unit_name = ident_prefix(lib_name, what, '.'); lib_t lib = lib_require(lib_name); bool error; if (what == well_known(W_ALL)) { make_library_visible(tab->top_scope, lib); return; } else if ((unit = lib_get_allow_error(lib, unit_name, &error)) == NULL) { error_at(tree_loc(use), "design unit %s not found in library %s", istr(what), istr(lib_name)); return; } else if (error) { error_at(tree_loc(use), "design unit %s was analysed with errors", istr(unit_name)); return; } make_visible(tab->top_scope, what, unit, POTENTIAL, tab->top_scope); return; } assert(is_package(unit)); scope_t *s = private_scope_for(tab, unit); assert(s->container == unit); if (what == well_known(W_ALL)) { for (int i = 0; i < tab->top_scope->imported.count; i++) { if (tab->top_scope->imported.items[i] == unit) return; } merge_scopes(tab->top_scope, s); APUSH(tab->top_scope->imported, unit); } else { const symbol_t *sym = symbol_for(s, what); if (sym == NULL) { error_at(tree_loc(use), "name %s not found in %s %s", istr(what), class_str(class_of(unit)), istr(tree_ident(unit))); return; } merge_symbol(tab->top_scope, sym); if (standard() >= STD_08) { // If this is an enumeration or physical type then also make // the literals and operators visible for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (!(dd->mask & N_TYPE) || !is_type_decl(dd->tree)) continue; type_t type = type_base_recur(tree_type(dd->tree)); add_type_literals(tab->top_scope, type, make_potentially_visible); const int ndecls = tree_decls(unit); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(unit, i); if (is_predef_for_type(d, type)) make_visible(tab->top_scope, tree_ident(d), d, POTENTIAL, s); } } } } } void insert_decls(nametab_t *tab, tree_t container) { int ndecls = tree_decls(container); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(container, i); if (tree_kind(d) == T_USE) insert_names_from_use(tab, d); else insert_name(tab, d, NULL); } } void insert_ports(nametab_t *tab, tree_t container) { const int nports = tree_ports(container); for (int i = 0; i < nports; i++) insert_name(tab, tree_port(container, i), NULL); } void insert_generics(nametab_t *tab, tree_t container) { const int ngenerics = tree_generics(container); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(container, i); make_visible_slow(tab->top_scope, tree_ident(g), g); } } void insert_names_from_context(nametab_t *tab, tree_t unit) { const int ncontext = tree_contexts(unit); for (int i = 0; i < ncontext; i++) { tree_t c = tree_context(unit, i); switch (tree_kind(c)) { case T_LIBRARY: lib_require(tree_ident(c)); insert_name(tab, c, NULL); break; case T_USE: insert_names_from_use(tab, c); break; case T_CONTEXT_REF: if (tree_has_ref(c)) insert_names_from_context(tab, tree_ref(c)); break; default: fatal_trace("nametab cannot handle context kind %s", tree_kind_str(tree_kind(c))); } } } void insert_names_for_psl(nametab_t *tab) { if (tab->psl == NULL) { tree_t nvc = tree_new(T_LIBRARY); ident_t nvc_i = well_known(W_NVC); tree_set_ident(nvc, nvc_i); tree_set_ident2(nvc, nvc_i); insert_name(tab, nvc, nvc_i); ident_t psl_support_i = well_known(W_NVC_PSL_SUPPORT); lib_t lnvc = lib_require(nvc_i); tree_t psl_support = lib_get(lnvc, psl_support_i); if (psl_support == NULL) fatal("required package %s not found", istr(psl_support_i)); tree_t u = tree_new(T_USE); tree_set_ident(u, psl_support_i); tree_set_ident2(u, well_known(W_ALL)); tree_set_ref(u, psl_support); tab->psl = u; } insert_names_from_use(tab, tab->psl); } static void missing_generic_cb(diag_t *d, ident_t id, void *arg) { diag_printf(d, "%s has no generic named %s", istr(tree_ident((tree_t)arg)), istr(id)); } static void missing_port_cb(diag_t *d, ident_t id, void *arg) { tree_t unit = arg; diag_printf(d, "%s has no port named %s", istr(tree_ident(arg)), istr(id)); diag_hint(d, diag_get_loc(d), "use of name %s in port map", istr(id)); const int nports = tree_ports(unit); if (nports > 0) { LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "%s %s has port%s ", tree_kind(unit) == T_COMPONENT ? "component" : "entity", istr(tree_ident(unit)), nports > 1 ? "s" : ""); for (int j = 0; j < nports; j++) { if (j > 0 && j == nports - 1) tb_cat(tb, " and "); else if (j > 0) tb_cat(tb, ", "); tb_cat(tb, istr(tree_ident(tree_port(unit, j)))); } diag_hint(d, tree_loc(unit), "%s", tb_get(tb)); } } void push_scope_for_formals(nametab_t *tab, formal_kind_t kind, tree_t unit) { push_scope(tab); tab->top_scope->formal_kind = kind; tab->top_scope->formal_arg = unit; if (unit != NULL) { switch (kind) { case F_GENERIC_MAP: tab->top_scope->formal_fn = missing_generic_cb; insert_generics(tab, unit); break; case F_PORT_MAP: tab->top_scope->formal_fn = missing_port_cb; insert_ports(tab, unit); break; case F_SUBPROGRAM: break; case F_RECORD: case F_NONE: fatal_trace("invalid kind in push_scope_for_formals"); break; } } } void insert_names_for_config(nametab_t *tab, tree_t unit) { switch (tree_kind(unit)) { case T_ARCH: insert_names_from_context(tab, tree_primary(unit)); // Fall-through case T_ENTITY: insert_names_from_context(tab, unit); break; default: break; } const int ndecls = tree_decls(unit); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(unit, i); if (tree_kind(d) == T_COMPONENT) insert_name(tab, d, NULL); } const int nstmts = tree_stmts(unit); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(unit, i); insert_name(tab, s, NULL); } } //////////////////////////////////////////////////////////////////////////////// // Name mangling void mangle_func(nametab_t *tab, tree_t decl) { if (tree_has_ident2(decl)) return; LOCAL_TEXT_BUF buf = tb_new(); tb_istr(buf, tab->top_scope->prefix); tb_append(buf, '.'); tb_istr(buf, tree_ident(decl)); type_t type = tree_type(decl); const bool is_func = type_has_result(type); const int nports = tree_ports(decl); if (nports > 0 || is_func) tb_append(buf, '('); for (int i = 0; i < nports; i++) { tree_t p = tree_port(decl, i); if (tree_class(p) == C_SIGNAL) tb_append(buf, 's'); if (tree_has_type(p)) mangle_one_type(buf, tree_type(p)); } if (nports > 0 || is_func) tb_append(buf, ')'); if (is_func) mangle_one_type(buf, type_result(type)); if (tree_flags(decl) & TREE_F_PREDEFINED) tb_cat(buf, "$predef"); tree_set_ident2(decl, ident_new(tb_get(buf))); } void mangle_type(nametab_t *tab, type_t type) { ident_t id = ident_prefix(tab->top_scope->prefix, type_ident(type), '.'); type_set_ident(type, id); } void mangle_decl(nametab_t *tab, tree_t decl) { ident_t id = ident_prefix(tab->top_scope->prefix, tree_ident(decl), '.'); tree_set_ident2(decl, id); } //////////////////////////////////////////////////////////////////////////////// // Subprogram overload resolution static void overload_trace_candidates(overload_t *o, const char *phase) { if (o->trace) { printf("%s: %s\n", istr(o->name), phase); for (unsigned i = 0; i < o->candidates.count; i++) { tree_t d = o->candidates.items[i]; printf(" %s%s\n", type_pp(tree_type(d)), (tree_flags(d) & TREE_F_PREDEFINED) ? " (predefined)" : ""); } } } static void overload_prune_candidate(overload_t *o, int index) { if (o->trace) { tree_t d = o->candidates.items[index]; printf("%s: prune candidate %s%s\n", istr(o->name), type_pp(tree_type(o->candidates.items[index])), (tree_flags(d) & TREE_F_PREDEFINED) ? " (predefined)" : ""); } o->candidates.items[index] = NULL; } static void overload_add_candidate(overload_t *o, tree_t d) { tree_kind_t dkind = tree_kind(d); type_t dtype = tree_type(d); // Prefer subprogram bodies to declarations if both are visible tree_kind_t skind = T_LAST_TREE_KIND; bool prefer = false; switch (dkind) { case T_FUNC_BODY: skind = T_FUNC_DECL; prefer = true; break; case T_PROC_BODY: skind = T_PROC_DECL; prefer = true; break; case T_FUNC_DECL: skind = T_FUNC_BODY; break; case T_PROC_DECL: skind = T_PROC_BODY; break; default: break; } for (unsigned i = 0; i < o->candidates.count; i++) { if (o->candidates.items[i] == d) return; // Duplicate from alias else if (tree_kind(o->candidates.items[i]) != skind) continue; else if (type_eq(tree_type(o->candidates.items[i]), dtype)) { if (prefer) o->candidates.items[i] = d; return; } } APUSH(o->candidates, d); } static type_t get_protected_type(nametab_t *tab, tree_t t) { switch (tree_kind(t)) { case T_ALL: case T_ALIAS: return get_protected_type(tab, tree_value(t)); case T_REF: return get_protected_type(tab, tree_ref(t)); case T_VAR_DECL: case T_PARAM_DECL: case T_PORT_DECL: case T_ATTR_REF: case T_FCALL: case T_PROT_FCALL: { type_t type = tree_type(t); for (;;) { if (type_is_access(type)) type = type_designated(type); else if (type_is_protected(type)) return type; else if (type_is_incomplete(type)) { type_t next = resolve_type(tab, type); if (next == type) return NULL; type = next; } else return NULL; } } default: return NULL; } } static void begin_overload_resolution(overload_t *o) { if (o->prefix != NULL) { type_t type = get_protected_type(o->nametab, o->prefix); if (type != NULL) { scope_t *scope = scope_for_type(o->nametab, type); o->symbol = symbol_for(scope, o->name); } } else if (tree_has_ref(o->tree)) { // Already bound to a particular subprogram tree_t decl = tree_ref(o->tree); if (tree_kind(decl) == T_ALIAS) decl = get_aliased_subprogram(decl); overload_add_candidate(o, decl); } else o->symbol = iterate_symbol_for(o->nametab, o->name); if (o->symbol != NULL) { for (int i = 0; i < o->symbol->ndecls; i++) { const decl_t *dd = get_decl(o->symbol, i); if (dd->visibility == HIDDEN) continue; else if (!(dd->mask & N_SUBPROGRAM)) continue; tree_t next = dd->tree; if (dd->kind == T_ALIAS && !(next = get_aliased_subprogram(next))) continue; overload_add_candidate(o, next); } } overload_trace_candidates(o, "initial candidates"); if (o->trace && o->nametab->top_type_set->members.count > 0) { printf("%s: context ", istr(o->name)); for (unsigned n = 0; n < o->nametab->top_type_set->members.count; n++) { if (n > 0) printf(", "); printf("%s", type_pp(o->nametab->top_type_set->members.items[n].type)); } printf("\n"); } o->initial = o->candidates.count; o->error = type_set_any(o->nametab, type_is_none); if (o->candidates.count > 1) { unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { type_t type = tree_type(o->candidates.items[i]); if (type_has_result(type)) { type_t result = type_result(type); if (type_set_contains(o->nametab, result)) o->candidates.items[wptr++] = o->candidates.items[i]; else if (tree_subkind(o->candidates.items[i]) == S_DIV_PP) { // LRM 93 section 7.3.5 allows an implicit conversion of // the result of dividing two physical types to any // integer type if (type_set_any(o->nametab, type_is_integer)) { o->candidates.items[wptr++] = o->candidates.items[i]; o->implicit_conversion = true; } else overload_prune_candidate(o, i); } else overload_prune_candidate(o, i); } else o->candidates.items[wptr++] = o->candidates.items[i]; } ATRIM(o->candidates, wptr); } const tree_kind_t kind = tree_kind(o->tree); const bool is_fcall = kind == T_FCALL || kind == T_PROT_FCALL; // Remove procedures in a function call context and functions in a // procedure call context if (o->candidates.count > 1) { unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { type_t type = tree_type(o->candidates.items[i]); if (is_fcall ^ type_has_result(type)) overload_prune_candidate(o, i); else o->candidates.items[wptr++] = o->candidates.items[i]; } ATRIM(o->candidates, wptr); } // Prune candidates with more required arguments than supplied if (o->candidates.count > 1) { int first_named = 0; unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { tree_t d = o->candidates.items[i]; int nrequired = 0; const int nports = tree_ports(d); for (int i = 0; i < nports; i++) { tree_t port = tree_port(d, i); if (!tree_has_value(port)) nrequired++; else if (first_named < o->nactuals) { // Named optional arguments should not count against the // required argument total ident_t id = tree_ident(port); for (int j = first_named; j < o->nactuals; j++) { tree_t p = tree_param(o->tree, j); if (tree_subkind(p) == P_NAMED) { tree_t ref = name_to_ref(tree_name(p)); if (ref != NULL && tree_ident(ref) == id) { nrequired++; break; } } else if (j <= first_named) first_named = j + 1; } } } if (o->nactuals < nrequired) overload_prune_candidate(o, i); else o->candidates.items[wptr++] = d; } ATRIM(o->candidates, wptr); } // Filter based on required type predicate if available if (o->candidates.count > 1 && o->nametab->top_type_set->pred) { unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { type_t rtype = type_result(tree_type(o->candidates.items[i])); if ((*o->nametab->top_type_set->pred)(rtype)) o->candidates.items[wptr++] = o->candidates.items[i]; else overload_prune_candidate(o, i); } ATRIM(o->candidates, wptr); } if (o->candidates.count == 0 && !o->error && !o->trial) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(o->tree)); if (o->symbol != NULL) { const bool hinted = diag_hints(d) > 0; for (int i = 0; i < o->symbol->ndecls; i++) { const decl_t *dd = get_decl(o->symbol, i); if ((dd->mask & N_SUBPROGRAM) && dd->visibility == HIDDEN) diag_hint(d, tree_loc(dd->tree), "subprogram %s is hidden", type_pp(tree_type(dd->tree))); } if (!hinted) diag_hint(d, tree_loc(o->tree), "%s called here", istr(o->name)); } type_t ptype = o->prefix ? get_type_or_null(o->prefix) : NULL; if (ptype != NULL && type_is_protected(ptype)) { diag_printf(d, "protected type %s has no method named %s", type_pp(ptype), istr(o->name)); scope_t *s = scope_for_type(o->nametab, ptype); hint_for_typo(s, d, o->name, N_SUBPROGRAM); } else if (o->initial > 0) { diag_printf(d, "no applicable subprogram declaration for %s", istr(o->name)); type_set_describe(o->nametab, d, tree_loc(o->tree), o->nametab->top_type_set->pred, NULL); diag_hint(d, NULL, "there are %d visible overloads of %s but none " "can be called in this context", o->initial, istr(o->name)); } else { diag_printf(d, "no visible subprogram declaration for %s", istr(o->name)); hint_for_typo(o->nametab->top_scope, d, o->name, N_SUBPROGRAM); } diag_suppress(d, o->nametab->top_scope->suppress); diag_emit(d); o->error = true; } // Determine if this expression could be interpreted as an indexed name if (is_fcall && o->nactuals > 0) { for (unsigned i = 0; i < o->candidates.count; i++) { if (!can_call_no_args(o->candidates.items[i])) continue; type_t rtype = get_result_type(o->nametab, o->candidates.items[i]); if (!type_is_array(rtype)) continue; o->could_be_index = true; break; } if (o->could_be_index) { for (int i = 0; i < o->nactuals; i++) { if (tree_subkind(tree_param(o->tree, i)) == P_NAMED) { // Indexed name cannot have named parameters o->could_be_index = false; break; } } } } if (o->trial && o->nametab->top_type_set->members.count == 0) { // Fill in the empty type set with the result types from the // possible overloads for (unsigned i = 0; i < o->candidates.count; i++) { type_t type = get_result_type(o->nametab, o->candidates.items[i]); type_set_add(o->nametab, type, o->candidates.items[i]); } } if (o->candidates.count != o->initial) overload_trace_candidates(o, "after initial pruning"); } static int param_compar(const void *pa, const void *pb) { // Define a sort order for parameters tree_t a = *(tree_t *)pa; tree_t b = *(tree_t *)pb; if (tree_subkind(a) == P_POS) { if (tree_subkind(b) == P_POS) return tree_pos(a) - tree_pos(b); else return INT_MAX; } else return INT_MAX; } static tree_t finish_overload_resolution(overload_t *o) { assert(o->state == O_IDLE); overload_trace_candidates(o, "before final pruning"); // Allow explicitly defined operators to hide implicitly defined ones // in different scopes. This is required behaviour in VHDL-2008 (see // section 12.4) and an optional rule relaxation in earlier revisions. const bool prefer_explicit = standard() >= STD_08 || relaxed_rules(); if (o->candidates.count > 1 && prefer_explicit) { int nexplicit = 0; for (unsigned i = 0; i < o->candidates.count; i++) { if (!(tree_flags(o->candidates.items[i]) & TREE_F_PREDEFINED)) nexplicit++; } if (nexplicit > 0) { unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { if (tree_flags(o->candidates.items[i]) & TREE_F_PREDEFINED) overload_prune_candidate(o, i); else o->candidates.items[wptr++] = o->candidates.items[i]; } ATRIM(o->candidates, wptr); } } // Prune candidates which do not have all the required arguments if (o->candidates.count > 1) { unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { tree_t d = o->candidates.items[i]; const int nports = tree_ports(d); bool all_match = true; for (int j = 0; all_match && j < nports; j++) { tree_t port = tree_port(d, j); if (tree_has_value(port)) continue; bool match = false; for (int k = 0; !match && k < o->params.count; k++) { tree_t param = o->params.items[k]; switch (tree_subkind(param)) { case P_POS: match = tree_pos(param) == j; break; case P_NAMED: { tree_t ref = name_to_ref(tree_name(param)); if (ref != NULL) match = ident_casecmp(tree_ident(ref), tree_ident(port)); } break; } } all_match = match; } if (!all_match) overload_prune_candidate(o, i); else o->candidates.items[wptr++] = d; } ATRIM(o->candidates, wptr); } overload_trace_candidates(o, "final candidates"); // Restrict the type set to contain only the result types of the // final candidates if (o->trial && o->candidates.count > 0) { type_set_t *ts = o->nametab->top_type_set; unsigned wptr = 0; for (unsigned i = 0; i < ts->members.count; i++) { bool found = false; for (unsigned j = 0; !found && j < o->candidates.count; j++) { type_t rtype = get_result_type(o->nametab, o->candidates.items[j]); if (type_eq(rtype, ts->members.items[i].type)) found = true; else if (o->could_be_index && type_is_array(rtype) && type_eq(type_elem(rtype), ts->members.items[i].type)) found = true; else if (o->implicit_conversion && tree_subkind(o->candidates.items[j]) == S_DIV_PP && type_is_integer(ts->members.items[i].type)) found = true; } if (found) ts->members.items[wptr++] = ts->members.items[i]; } ATRIM(ts->members, wptr); } tree_t result = NULL; if (o->candidates.count > 1 && !o->error && !o->trial) { const loc_t *loc = tree_loc(o->tree); diag_t *d = diag_new(DIAG_ERROR, loc); diag_printf(d, "ambiguous %s %s", ident_char(o->name, 0) == '"' ? "use of operator" : (tree_kind(o->tree) == T_FCALL ? "call to function" : "call to procedure"), istr(o->name)); int explicit = 0; for (unsigned i = 0; i < o->candidates.count; i++) { const loc_t *cloc = tree_loc(o->candidates.items[i]); if (cloc->file_ref == loc->file_ref) diag_hint(d, cloc, "candidate %s", type_pp(tree_type(o->candidates.items[i]))); else { tree_t container = tree_container(o->candidates.items[i]); tree_t primary = primary_unit_of(container); diag_hint(d, NULL, "candidate %s from %s%s", type_pp(tree_type(o->candidates.items[i])), istr(tree_ident(primary)), primary != container ? " body" : ""); } if (!(tree_flags(o->candidates.items[i]) & TREE_F_PREDEFINED)) explicit++; } if (diag_hints(d) > 0) diag_hint(d, tree_loc(o->tree), "use of name %s here", istr(o->name)); if (explicit == 1 && !prefer_explicit) diag_hint(d, NULL, "this would be resolved in favour of the " "explicitly defined operator with $bold$--relaxed$$"); diag_emit(d); } else if (o->candidates.count == 0 && !o->error && !o->trial) { LOCAL_TEXT_BUF tb = tb_new(); tb_printf(tb, "%s [", istr(o->name)); qsort(o->params.items, o->params.count, sizeof(tree_t), param_compar); for (unsigned i = 0; i < o->params.count; i++) tb_printf(tb, "%s%s", i > 0 ? ", " : "", type_pp(tree_type(tree_value(o->params.items[i])))); type_set_t *ts = o->nametab->top_type_set; if (ts != NULL && ts->members.count > 0) { tb_printf(tb, "%sreturn ", o->params.count > 0 ? " " : ""); for (unsigned i = 0; i < ts->members.count; i++) tb_printf(tb, "%s%s", i > 0 ? " | " : "", type_pp(ts->members.items[i].type)); } tb_append(tb, ']'); diag_t *d = diag_new(DIAG_ERROR, tree_loc(o->tree)); diag_printf(d, "no matching %s %s", ident_char(o->name, 0) == '"' ? "operator" : "subprogram", tb_get(tb)); if (o->initial > 0) { for (unsigned i = 0; i < o->params.count; i++) { tree_t pv = tree_value(o->params.items[i]); const tree_kind_t kind = tree_kind(pv); if (kind != T_LITERAL && kind != T_ATTR_REF) continue; else if (type_is_universal(tree_type(pv))) { diag_hint(d, NULL, "no implicit conversion was performed on " "the %s argument as the innermost complete context " "did not determine a unique numeric type", ordinal_str(i + 1)); diag_lrm(d, STD_08, "9.3.6"); break; } } } diag_emit(d); } else if (o->candidates.count == 1 && !o->cancelled) result = o->candidates.items[0]; ACLEAR(o->candidates); ACLEAR(o->params); return result; } static void overload_add_argument_type(overload_t *o, type_t type, tree_t d) { type_set_add(o->nametab, type, d); } static void overload_positional_argument(overload_t *o, int pos) { assert(o->state == O_IDLE); o->typeset = (type_set_t){}; type_set_push(o->nametab, &o->typeset); if (o->trace) printf("%s: positional argument %d\n", istr(o->name), pos); // Prune any overloads which do not have this argument position unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { tree_t d = o->candidates.items[i]; if (pos < tree_ports(d)) { tree_t p = tree_port(d, pos); overload_add_argument_type(o, tree_type(p), d); o->candidates.items[wptr++] = d; } else if (o->initial > 1) overload_prune_candidate(o, i); else o->candidates.items[wptr++] = d; } ATRIM(o->candidates, wptr); if (o->could_be_index) { for (unsigned i = 0; i < o->candidates.count; i++) { if (!can_call_no_args(o->candidates.items[i])) continue; type_t rtype = get_result_type(o->nametab, o->candidates.items[i]); if (!type_is_array(rtype)) continue; type_t index_type = index_type_of(rtype, pos); if (index_type != NULL) overload_add_argument_type(o, index_type, o->candidates.items[i]); } } o->state = O_POS; } static type_t overload_get_name_type(tree_t port, ident_t ident, tree_t name) { if (tree_ident(port) != ident) return NULL; switch (tree_kind(name)) { case T_RECORD_REF: { type_t ptype = tree_type(port); if (!type_is_record(ptype)) return NULL; const int nfields = type_fields(ptype); ident_t fname = tree_ident(name); tree_t field = NULL; for (int i = 0; i < nfields; i++) { tree_t f = type_field(ptype, i); if (tree_ident(f) == fname) { field = f; break; } } if (field == NULL) return NULL; // Argument does not have this field name return tree_type(field); } case T_ARRAY_REF: { type_t ptype = tree_type(port); if (!type_is_array(ptype)) return false; return type_elem(ptype); } case T_ARRAY_SLICE: { type_t ptype = tree_type(port); if (!type_is_array(ptype)) return false; return ptype; } default: return tree_type(port); } } static void overload_named_argument(overload_t *o, tree_t name) { assert(o->state == O_IDLE); o->typeset = (type_set_t){}; type_set_push(o->nametab, &o->typeset); push_scope(o->nametab); o->nametab->top_scope->formal_kind = F_SUBPROGRAM; o->nametab->top_scope->overload = o; tree_t ref = name_to_ref(name); if (ref == NULL) { // TODO: conversion functions not yet supported for formals o->state = O_NAMED; return; } ident_t ident = tree_ident(ref); if (o->trace) printf("%s: named argument %s\n", istr(o->name), istr(ident)); // See if any possible overload matches this argument name int first_match = -1; for (unsigned i = 0; first_match < 0 && i < o->candidates.count; i++) { const int nports = tree_ports(o->candidates.items[i]); for (int j = 0; j < nports; j++) { tree_t p = tree_port(o->candidates.items[i], j); type_t ntype = overload_get_name_type(p, ident, name); if (ntype == NULL) continue; for (int j = 0; j < nports; j++) { tree_t p = tree_port(o->candidates.items[i], j); make_visible_slow(o->nametab->top_scope, tree_ident(p), p); } overload_add_argument_type(o, ntype, o->candidates.items[i]); first_match = i; break; } } if (first_match == -1) { // No possible matches so make every parameter visible to improve // error messages later for (unsigned i = 0; i < o->candidates.count; i++) { const int nports = tree_ports(o->candidates.items[i]); for (int j = 0; j < nports; j++) { tree_t p = tree_port(o->candidates.items[i], j); make_visible_slow(o->nametab->top_scope, tree_ident(p), p); } } } else { // Prune all overloads up to first_match for (int i = 0; i < first_match; i++) overload_prune_candidate(o, i); unsigned wptr = 0; o->candidates.items[wptr++] = o->candidates.items[first_match]; // Prune any remaining overloads which do not have this named argument for (unsigned i = first_match + 1; i < o->candidates.count; i++) { const int nports = tree_ports(o->candidates.items[i]); tree_t port = NULL; for (int j = 0; j < nports; j++) { tree_t p = tree_port(o->candidates.items[i], j); type_t ntype = overload_get_name_type(p, ident, name); if (ntype == NULL) continue; overload_add_argument_type(o, ntype, o->candidates.items[i]); port = p; break; } if (port == NULL) overload_prune_candidate(o, i); else { o->candidates.items[wptr++] = o->candidates.items[i]; for (int j = 0; j < nports; j++) { tree_t p = tree_port(o->candidates.items[i], j); make_visible_slow(o->nametab->top_scope, tree_ident(p), p); } } } ATRIM(o->candidates, wptr); } o->state = O_NAMED; } static tree_t overload_find_port(tree_t decl, tree_t param) { switch (tree_subkind(param)) { case P_POS: { unsigned pos = tree_pos(param); if (pos < tree_ports(decl)) return tree_port(decl, pos); else return NULL; } case P_NAMED: { tree_t ref = name_to_ref(tree_name(param)); if (ref != NULL) { ident_t name = tree_ident(ref); const int nports = tree_ports(decl); for (int j = 0; j < nports; j++) { tree_t port_j = tree_port(decl, j); if (tree_ident(port_j) == name) return port_j; } } } break; } return NULL; } static void overload_next_argument(overload_t *o, tree_t p) { assert(tree_kind(p) == T_PARAM); assert(o->state != O_IDLE); tree_t value = tree_value(p); type_t type = tree_type(value); if (o->trace) { printf("%s: next argument %s %s\n", istr(o->name), tree_kind_str(tree_kind(value)), type_pp(type)); } const bool is_partial = tree_subkind(p) == P_NAMED && tree_kind(tree_name(p)) != T_REF; if (o->initial > 1 && !is_partial) { unsigned wptr = 0; int first_match = -1; bool found_port = false; for (unsigned i = 0; i < o->candidates.count; i++) { tree_t port = overload_find_port(o->candidates.items[i], p); if (port != NULL && type != NULL) { type_t ptype = tree_type(port); found_port = true; if (type_eq(ptype, type)) { // We've found at least one candidate with a matching // argument. Prune all the previous candidates that were // speculatively allowed through. if (first_match == -1) { assert(wptr == i); for (unsigned j = 0; j < wptr; j++) overload_prune_candidate(o, j); wptr = 0; first_match = i; } } else if (first_match != -1) { overload_prune_candidate(o, i); continue; } } o->candidates.items[wptr++] = o->candidates.items[i]; } ATRIM(o->candidates, wptr); if (first_match == -1 && found_port) { // No candidates matched this positional argument. Delete all // those that were speculatively allowed through. for (unsigned i = 0; i < wptr; i++) overload_prune_candidate(o, i); ATRIM(o->candidates, 0); } } // If the parameter is not of a discrete type then this definitely // cannot be an indexed name if (o->could_be_index && !type_is_discrete(type)) o->could_be_index = false; if (type != NULL && type_is_none(type)) o->error = true; // Suppress further errors APUSH(o->params, p); type_set_pop(o->nametab, &o->typeset); o->state = O_IDLE; } static void overload_cancel_argument(overload_t *o, tree_t p) { assert(o->state != O_IDLE); if (o->trace) printf("%s: cancel argument\n", istr(o->name)); // Use the restricted type set to prune candidates which could never // match this argument type_set_t *ts = o->nametab->top_type_set; if (ts->members.count > 0 && o->candidates.count > 1) { if (o->trace) { printf("%s: restrict to: ", istr(o->name)); for (unsigned n = 0; n < ts->members.count; n++) { if (n > 0) printf(", "); printf("%s", type_pp(ts->members.items[n].type)); } printf("\n"); } unsigned wptr = 0; for (unsigned i = 0; i < o->candidates.count; i++) { tree_t port = overload_find_port(o->candidates.items[i], p); if (port != NULL && type_set_contains(o->nametab, tree_type(port))) o->candidates.items[wptr++] = o->candidates.items[i]; else overload_prune_candidate(o, i); } ATRIM(o->candidates, wptr); } APUSH(o->params, p); type_set_pop(o->nametab, &o->typeset); o->state = O_IDLE; } void map_generic_box(nametab_t *tab, tree_t inst, tree_t g, unsigned pos) { // Find the actual for the <> "box" default generic subprogram assert(tree_kind(g) == T_GENERIC_DECL); tree_t box = tree_value(g); assert(tree_kind(box) == T_BOX); tree_t ref = tree_new(T_REF); tree_set_loc(ref, tree_loc(inst)); type_t type = tree_type(g); tree_t decl = NULL; if (tree_has_ref(box)) { tree_set_ident(ref, tree_ident(box)); decl = tree_ref(box); } else if (tree_has_ident(box)) { // Lookup of default subprogram failed assert(error_count() > 0); suppress_errors(tab); } else { const symbol_t *sym = iterate_symbol_for(tab, type_ident(type)); if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN || !(dd->mask & N_SUBPROGRAM)) continue; else if (dd->tree == g) continue; tree_t sub = dd->tree; if (dd->kind == T_ALIAS && !(sub = get_aliased_subprogram(sub))) continue; type_t signature = tree_type(sub); if (!type_eq_map(type, signature, tab->top_scope->gmap)) continue; decl = sub; break; } } } if (decl != NULL) { tree_set_ref(ref, decl); tree_set_type(ref, tree_type(decl)); tree_set_ident(ref, tree_ident(decl)); map_generic_subprogram(tab, g, decl); } else if (!tab->top_scope->suppress) { const char *signature = strchr(type_pp(type), '['); diag_t *d = diag_new(DIAG_ERROR, tree_loc(inst)); diag_printf(d, "no visible subprogram %s matches signature %s", istr(type_ident(type)), signature); diag_hint(d, tree_loc(box), "while resolving interface subprogram " "default for %s", istr(type_ident(type))); if (tree_flags(g) & TREE_F_PREDEFINED) { type_t actual = NULL; if (tab->top_scope->gmap != NULL) actual = hash_get(tab->top_scope->gmap, type_param(type, 0)); if (actual != NULL && !type_is_none(actual)) { diag_hint(d, NULL, "add a use clause that makes the operators for " "%s visible", istr(type_ident(actual))); if (standard() == STD_08) diag_hint(d, NULL, "the 2008 LRM is unclear on the visibility " "requirements for the implicit operators associated " "with a generic type, and behaviour varies between " "implementations; the interpretation here is " "consistent with the 2019 LRM"); diag_lrm(d, STD_08, "6.5.3"); } suppress_errors(tab); // Avoid error for both "=" and "/=" } diag_emit(d); } tree_t map = tree_new(T_PARAM); tree_set_loc(ref, tree_loc(inst)); tree_set_subkind(map, P_POS); tree_set_pos(map, pos); tree_set_value(map, ref); tree_add_genmap(inst, map); } //////////////////////////////////////////////////////////////////////////////// // Type solver static bool is_unambiguous(tree_t t) { if (tree_has_type(t)) return true; const tree_kind_t kind = tree_kind(t); return kind == T_QUALIFIED || kind == T_ARRAY_REF || kind == T_ARRAY_SLICE || kind == T_TYPE_CONV || kind == T_RECORD_REF || kind == T_ALL || kind == T_PSL_FCALL || (kind == T_REF && tree_has_ref(t)); } static bool solve_one_param(nametab_t *tab, tree_t p, overload_t *o, bool trial) { switch (tree_subkind(p)) { case P_POS: overload_positional_argument(o, tree_pos(p)); break; case P_NAMED: { tree_t name = tree_name(p); overload_named_argument(o, name); if (!trial || is_unambiguous(name)) solve_types(tab, name, NULL); else if (!try_solve_type(o->nametab, name)) { pop_scope(o->nametab); overload_cancel_argument(o, p); return false; } pop_scope(o->nametab); } break; } tree_t value = tree_value(p); if (!trial || is_unambiguous(value)) { _solve_types(o->nametab, value); overload_next_argument(o, p); return true; } else if (!try_solve_type(o->nametab, value)) { overload_cancel_argument(o, p); return false; } else { overload_next_argument(o, p); return true; } } static void solve_subprogram_params(nametab_t *tab, tree_t call, overload_t *o) { const int nparams = tree_params(call); LOCAL_BIT_MASK pmask; mask_init(&pmask, nparams); // Make an initial pass over the parameters and solve the "easy" ones for (int i = 0; i < nparams; i++) { tree_t p = tree_param(call, i); tree_t value = tree_value(p); if (is_unambiguous(value)) { solve_one_param(tab, p, o, o->trial); mask_set(&pmask, i); } } // Attempt to solve remaining parameters but suppress errors for (int i = 0; i < nparams; i++) { if (mask_test(&pmask, i)) continue; tree_t p = tree_param(call, i); tree_t value = tree_value(p); const bool trial = o->trial || (o->candidates.count > 1 && mask_popcount(&pmask) + 1 < nparams); if (o->error) { // Avoid cascading errors from an undefined subprogram tree_set_type(value, type_new(T_NONE)); mask_set(&pmask, i); } else if (solve_one_param(tab, p, o, trial)) mask_set(&pmask, i); } if (o->trial && mask_popcount(&pmask) < nparams) { o->cancelled = true; return; // Cannot identify the overload yet } // Catch-all pass for remaining parameters for (int i = 0; i < nparams; i++) { if (mask_test(&pmask, i)) continue; tree_t p = tree_param(call, i); if (o->error) tree_set_type(tree_value(p), type_new(T_NONE)); else solve_one_param(tab, p, o, false); } } static type_t resolve_fcall_or_index(nametab_t *tab, tree_t fcall, tree_t decl) { // The expression A(X) can be parsed as a call to subprogram A with // no arguments, returning an array that is indexed by X, or a call // to subprogram A with argument X. We prefer the latter and then // fix-up here based on the context. type_t rtype = get_result_type(tab, decl); if (!type_is_array(rtype)) return rtype; if (!can_call_no_args(decl)) return rtype; if (tree_params(fcall) != dimension_of(rtype)) return rtype; if (tab->top_type_set->members.count == 0) return rtype; // Context cannot disambiguate type_t etype = type_elem(rtype); if (!type_set_contains(tab, etype)) return rtype; const tree_kind_t kind = tree_kind(fcall); tree_t new = tree_new(kind); tree_set_ref(new, decl); tree_set_ident(new, tree_ident(fcall)); tree_set_loc(new, tree_loc(fcall)); tree_set_type(new, rtype); if (kind == T_PROT_FCALL && tree_has_name(fcall)) tree_set_name(new, tree_name(fcall)); tree_change_kind(fcall, T_ARRAY_REF); tree_set_value(fcall, new); return etype; } static void nest_protected_call(tree_t call, tree_t pref) { tree_t prefix = tree_name(call); tree_t value = tree_value(pref); tree_t nest = tree_new(T_PROT_REF); tree_set_value(nest, prefix); tree_set_ref(nest, tree_ref(value)); tree_set_ident(nest, tree_ident(value)); tree_set_type(nest, tree_type(value)); tree_set_name(call, nest); tree_set_ref(call, tree_ref(pref)); } static type_t resolve_fcall(nametab_t *tab, tree_t fcall, tree_t decl, bool could_be_index) { type_t ftype = tree_type(decl); if (!type_has_result(ftype)) { error_at(tree_loc(fcall), "procedure %s not allowed in an expression", istr(tree_ident(fcall))); return type_new(T_NONE); } if (tree_kind(decl) == T_PROT_REF) { // Calling an alias of a protected type method if (tree_kind(fcall) == T_PROT_FCALL) nest_protected_call(fcall, decl); else { tree_change_kind(fcall, T_PROT_FCALL); tree_set_name(fcall, tree_value(decl)); } decl = tree_ref(decl); } tree_set_ref(fcall, decl); const tree_flags_t flags = tree_flags(decl); if ((flags & TREE_F_PROTECTED) && tree_kind(fcall) != T_PROT_FCALL) tree_change_kind(fcall, T_PROT_FCALL); if ((flags & TREE_F_KNOWS_SUBTYPE) && tab->top_type_set->target == NULL) error_at(tree_loc(fcall), "function %s with return identifier %s " "cannot be called in this context as the result subtype " "is not known", istr(tree_ident(decl)), istr(type_ident(type_result(ftype)))); if (could_be_index) return resolve_fcall_or_index(tab, fcall, decl); else if (tree_subkind(decl) == S_DIV_PP) { // LRM 93 section 7.3.5 an implicit conversion is applied if the // operand is an expression consisting of the division of a value // of a physical type by a value of the same type and the context // determines a unique numeric type type_set_restrict(tab, type_is_integer); type_t type; if (type_set_uniq(tab, &type)) return type; } return get_result_type(tab, decl); } static type_t try_solve_fcall(nametab_t *tab, tree_t fcall) { if (tree_has_type(fcall)) return tree_type(fcall); const tree_kind_t kind = tree_kind(fcall); overload_t o = { .tree = fcall, .state = O_IDLE, .nametab = tab, .trace = false, .trial = true, .prefix = kind == T_PROT_FCALL ? tree_name(fcall) : NULL, .nactuals = tree_params(fcall), .name = tree_ident(fcall), }; begin_overload_resolution(&o); solve_subprogram_params(tab, fcall, &o); tree_t decl = finish_overload_resolution(&o); if (decl == NULL) return NULL; // This expression may stil be ambiguous between a function call and // an indexed name if the context has more than one type if (o.could_be_index && tab->top_type_set->members.count > 1) return NULL; type_t type = resolve_fcall(tab, fcall, decl, o.could_be_index); tree_set_type(fcall, type); return type; } static type_t solve_fcall(nametab_t *tab, tree_t fcall) { if (tree_has_type(fcall)) return tree_type(fcall); const tree_kind_t kind = tree_kind(fcall); overload_t o = { .tree = fcall, .state = O_IDLE, .nametab = tab, .trace = false, .prefix = kind == T_PROT_FCALL ? tree_name(fcall) : NULL, .nactuals = tree_params(fcall), .name = tree_ident(fcall), }; begin_overload_resolution(&o); solve_subprogram_params(tab, fcall, &o); type_t type; tree_t decl = finish_overload_resolution(&o); if (decl == NULL) type = type_new(T_NONE); else type = resolve_fcall(tab, fcall, decl, o.could_be_index); tree_set_type(fcall, type); return type; } static type_t solve_pcall(nametab_t *tab, tree_t pcall) { const tree_kind_t kind = tree_kind(pcall); overload_t o = { .name = tree_ident2(pcall), .tree = pcall, .state = O_IDLE, .nametab = tab, .trace = false, .prefix = kind == T_PROT_PCALL ? tree_name(pcall) : NULL, .nactuals = tree_params(pcall) }; begin_overload_resolution(&o); solve_subprogram_params(tab, pcall, &o); tree_t decl = finish_overload_resolution(&o); if (decl != NULL && tree_kind(decl) == T_PROT_REF) { // Calling an alias of a protected type method if (kind == T_PROT_PCALL) nest_protected_call(pcall, decl); else { tree_change_kind(pcall, T_PROT_PCALL); tree_set_ref(pcall, tree_ref(decl)); tree_set_name(pcall, tree_value(decl)); } } else if (decl != NULL) { tree_set_ref(pcall, decl); if ((tree_flags(decl) & TREE_F_PROTECTED) && kind == T_PCALL) tree_change_kind(pcall, T_PROT_PCALL); } return NULL; // Procedure call has no type } static type_t try_solve_string(nametab_t *tab, tree_t str) { if (tree_has_type(str)) return tree_type(str); else if (type_set_any(tab, type_is_none)) { type_t type = type_new(T_NONE); // Suppress cascading errors tree_set_type(str, type); return type; } // The type must be determinable soley from the context excluding the // literal itself but using the fact that the type must be a one // dimensional array of a character type type_set_restrict(tab, type_is_character_array); type_t type = NULL; if (!type_set_uniq(tab, &type)) return NULL; type_t elem = type_elem(type); const int nchars = tree_chars(str); for (int i = 0; i < nchars; i++) solve_types(tab, tree_char(str, i), elem); type_t sub = subtype_for_string(str, type); tree_set_type(str, sub); return sub; } static type_t solve_string(nametab_t *tab, tree_t str) { type_t type = try_solve_string(tab, str); if (type != NULL) return type; diag_t *d = diag_new(DIAG_ERROR, tree_loc(str)); diag_printf(d, "type of string literal cannot be determined " "from the surrounding context"); type_set_describe(tab, d, tree_loc(str), type_is_character_array, "a one dimensional array of character type"); diag_emit(d); tree_set_type(str, (type = type_new(T_NONE))); return type; } static type_t try_solve_literal(nametab_t *tab, tree_t lit) { if (tree_has_type(lit)) return tree_type(lit); switch (tree_subkind(lit)) { case L_NULL: { type_set_restrict(tab, type_is_access); type_t type; if (!type_set_uniq(tab, &type)) return NULL; tree_set_type(lit, type); return type; } case L_PHYSICAL: { ident_t id = tree_ident(lit); type_t type; tree_t decl = resolve_name(tab, tree_loc(lit), id); if (decl == NULL) return NULL; else if (class_of(decl) != C_UNITS) { error_at(tree_loc(lit), "%s is not a physical unit", istr(id)); type = type_new(T_NONE); } else { tree_set_ref(lit, decl); type = tree_type(decl); } tree_set_type(lit, type); return type; } case L_INT: { type_set_restrict(tab, type_is_integer); type_t type; if (!type_set_uniq(tab, &type)) return NULL; tree_set_type(lit, type); return type; } case L_REAL: { type_set_restrict(tab, type_is_real); type_t type; if (!type_set_uniq(tab, &type)) return NULL; tree_set_type(lit, type); return type; } default: fatal_at(tree_loc(lit), "cannot solve literal"); } } static type_t solve_literal(nametab_t *tab, tree_t lit) { type_t type = try_solve_literal(tab, lit); if (type != NULL) return type; switch (tree_subkind(lit)) { case L_INT: tree_set_type(lit, (type = std_type(NULL, STD_UNIVERSAL_INTEGER))); return type; case L_REAL: tree_set_type(lit, (type = std_type(NULL, STD_UNIVERSAL_REAL))); return type; case L_NULL: error_at(tree_loc(lit), "type of null expression cannot be determined " "from the surrounding context"); // Fall-through default: tree_set_type(lit, (type = type_new(T_NONE))); return type; } } static type_t try_solve_ref(nametab_t *tab, tree_t ref) { if (tree_has_type(ref)) return tree_type(ref); tree_t decl = try_resolve_name(tab, tree_ident(ref)); if (decl == NULL) return NULL; type_t type = get_type_or_null(decl); if (type == NULL) return NULL; else if (type_is_subprogram(type)) { tree_change_kind(ref, T_FCALL); type = get_result_type(tab, decl); } tree_set_ref(ref, decl); tree_set_type(ref, type); return type; } static type_t solve_ref(nametab_t *tab, tree_t ref) { if (tree_has_type(ref)) return tree_type(ref); tree_t decl = resolve_ref(tab, ref); type_t type = NULL; if (decl == NULL) { tree_set_type(ref, (type = type_new(T_NONE))); return type; } const class_t class = class_of(decl); if (!class_has_type(class)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(ref)); diag_printf(d, "invalid use of %s %s", class_str(class_of(decl)), istr(tree_ident(ref))); // Try to provide a more helpful error if an object with the same // name is hidden const symbol_t *sym = iterate_symbol_for(tab, tree_ident(ref)); for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility == HIDDEN && get_type_or_null(dd->tree) != NULL) diag_hint(d, tree_loc(dd->tree), "declaration of %s %s is hidden", class_str(class_of(dd->tree)), istr(sym->name)); } diag_hint(d, tree_loc(decl), "name %s refers to this %s", istr(sym->name), class_str(class)); diag_suppress(d, tab->top_scope->suppress); diag_emit(d); tree_set_ref(ref, NULL); tree_set_type(ref, (type = type_new(T_NONE))); return type; } if (tree_kind(decl) == T_ALIAS) { // An alias declaration for an enumeration literal may contain a // signature so make sure it doesn't look like a subprogram tree_t aliased = tree_value(decl); if (!tree_has_type(decl) || class_of(aliased) == C_LITERAL) type = tree_type(aliased); else type = tree_type(decl); } else type = tree_type(decl); if (type_is_subprogram(type)) { type_t constraint; const bool want_ref = (type_set_uniq(tab, &constraint) && type_is_subprogram(constraint)) || tab->top_scope->formal_kind != F_NONE; if (can_call_no_args(decl) && !want_ref) { tree_change_kind(ref, T_FCALL); return solve_fcall(tab, ref); } } tree_set_ref(ref, decl); tree_set_type(ref, type); return type; } static type_t solve_prot_ref(nametab_t *tab, tree_t pref) { type_t constraint; if (type_set_uniq(tab, &constraint) && type_is_subprogram(constraint)) { // Reference to protected type subprogram with signature tree_t decl = resolve_method_name(tab, pref, constraint); type_t type = decl ? tree_type(decl) : type_new(T_NONE); tree_set_type(pref, type); tree_set_ref(pref, decl); return type; } error_at(tree_loc(pref), "invalid use of name %s", istr(tree_ident(pref))); type_t type = type_new(T_NONE); tree_set_type(pref, type); return type; } static type_t solve_field_subtype(type_t rtype, tree_t field) { type_t ftype = tree_type(field); if (type_is_unconstrained(ftype)) { // Get the subtype from the record element constraint tree_t cons = type_constraint_for_field(rtype, field); if (cons != NULL) { type_t sub = tree_type(cons); assert(type_kind(sub) == T_SUBTYPE); return sub; } } return ftype; } static type_t solve_record_ref(nametab_t *tab, tree_t rref) { if (tree_has_type(rref)) return tree_type(rref); type_t value_type = solve_types(tab, tree_value(rref), NULL); if (type_is_none(value_type)) { tree_set_type(rref, value_type); return value_type; } else if (!type_is_record(value_type)) { error_at(tree_loc(rref), "type %s is not a record", type_pp(value_type)); tree_set_type(rref, (value_type = type_new(T_NONE))); return value_type; } ident_t name = tree_ident(rref); tree_t f = resolve_field_name(tab, tree_loc(rref), name, value_type); if (f == NULL) { type_t type = type_new(T_NONE); tree_set_type(rref, type); return type; } else { type_t type = solve_field_subtype(value_type, f); tree_set_ref(rref, f); tree_set_type(rref, type); return type; } } static type_t solve_array_ref(nametab_t *tab, tree_t ref) { if (tree_has_type(ref)) return tree_type(ref); type_t base_type = solve_types(tab, tree_value(ref), NULL); const int nparams = tree_params(ref); for (int i = 0; i < nparams; i++) { tree_t p = tree_param(ref, i); assert(tree_subkind(p) == P_POS); type_t index_type = index_type_of(base_type, i); if (index_type == NULL) index_type = type_new(T_NONE); // Out of bounds or earlier error solve_types(tab, tree_value(p), index_type); } type_t elem_type; if (type_is_array(base_type)) elem_type = type_elem(base_type); else if (type_is_none(base_type)) elem_type = base_type; else { error_at(tree_loc(ref), "cannot index non-array type %s", type_pp(base_type)); elem_type = type_new(T_NONE); } tree_set_type(ref, elem_type); return elem_type; } static type_t solve_array_slice(nametab_t *tab, tree_t slice) { if (tree_has_type(slice)) return tree_type(slice); type_t base_type = _solve_types(tab, tree_value(slice)); tree_t r = tree_range(slice, 0); tree_t constraint = tree_new(T_CONSTRAINT); tree_set_subkind(constraint, C_INDEX); tree_add_range(constraint, r); type_t slice_type = type_new(T_SUBTYPE); type_set_constraint(slice_type, constraint); type_set_base(slice_type, base_type); tree_set_type(slice, slice_type); return slice_type; } static type_t try_solve_attr_ref(nametab_t *tab, tree_t aref) { if (tree_has_type(aref)) return tree_type(aref); tree_t prefix = tree_name(aref); type_t prefix_type = NULL; if (tree_kind(prefix) == T_REF && !tree_has_type(prefix)) { tree_t decl; if (tree_has_ref(prefix)) decl = tree_ref(prefix); else if ((decl = resolve_ref(tab, prefix))) tree_set_ref(prefix, decl); if (decl != NULL) { if (class_has_type(class_of(decl))) tree_set_type(prefix, (prefix_type = tree_type(decl))); } } else if (type_is_none((prefix_type = solve_types(tab, prefix, NULL)))) { tree_set_type(aref, prefix_type); return prefix_type; } const int nparams = tree_params(aref); assert(nparams <= 1); if (nparams == 1) { type_set_t ts = {}; type_set_push(tab, &ts); switch (tree_subkind(aref)) { case ATTR_IMAGE: case ATTR_LEFTOF: case ATTR_RIGHTOF: case ATTR_POS: case ATTR_PRED: case ATTR_SUCC: type_set_add(tab, prefix_type, NULL); break; case ATTR_VALUE: type_set_add(tab, std_type(NULL, STD_STRING), NULL); break; } _solve_types(tab, tree_value(tree_param(aref, 0))); type_set_pop(tab, &ts); } type_t type = NULL; switch (tree_subkind(aref)) { case ATTR_LENGTH: type = std_type(NULL, STD_INTEGER); break; case ATTR_LEFT: case ATTR_RIGHT: case ATTR_LOW: case ATTR_HIGH: case ATTR_RANGE: case ATTR_REVERSE_RANGE: { if (prefix_type == NULL) { error_at(tree_loc(aref), "prefix does not have a range"); type = type_new(T_NONE); } else if (type_is_array(prefix_type)) { int64_t dim = 1; if (nparams > 0) { tree_t pdim = tree_value(tree_param(aref, 0)); // The type can be wrong if this expression is not a literal // but there does not seem to be any easy way to handle this (void)folded_int(pdim, &dim); } if ((type = index_type_of(prefix_type, dim - 1)) == NULL) { error_at(tree_loc(aref), "dimension index %"PRIi64" out of range " "for type %s", dim, type_pp(prefix_type)); type = type_new(T_NONE); } } else type = prefix_type; } break; case ATTR_LAST_EVENT: case ATTR_LAST_ACTIVE: type = std_type(NULL, STD_TIME); break; case ATTR_ASCENDING: case ATTR_EVENT: case ATTR_ACTIVE: case ATTR_STABLE: case ATTR_QUIET: case ATTR_DRIVING: type = std_type(NULL, STD_BOOLEAN); break; case ATTR_LEFTOF: case ATTR_RIGHTOF: case ATTR_PRED: case ATTR_SUCC: case ATTR_VAL: case ATTR_DELAYED: case ATTR_LAST_VALUE: case ATTR_VALUE: case ATTR_DRIVING_VALUE: case ATTR_CONVERSE: type = prefix_type; break; case ATTR_PATH_NAME: case ATTR_INSTANCE_NAME: case ATTR_SIMPLE_NAME: case ATTR_IMAGE: type = std_type(NULL, STD_STRING); break; case ATTR_TRANSACTION: type = std_type(NULL, STD_BIT); break; case ATTR_POS: // LRM 08 section 9.3.6: implicit conversion of attribute to a // unique numeric type from the context type_set_restrict(tab, type_is_integer); if (!type_set_uniq(tab, &type)) return NULL; break; case ATTR_BASE: if (prefix_type != NULL) { if (type_kind(prefix_type) == T_SUBTYPE) type = type_base(prefix_type); else type = prefix_type; } break; case ATTR_SUBTYPE: case ATTR_ELEMENT: case ATTR_DESIGNATED_SUBTYPE: case ATTR_INDEX: // These should have been expanded by the parser so can only be // erroneous type = prefix_type; break; case ATTR_REFLECT: { bool prefix_is_type = false; switch (tree_kind(prefix)) { case T_REF: if (tree_has_ref(prefix)) prefix_is_type = (aliased_type_decl(tree_ref(prefix)) != NULL); break; case T_ATTR_REF: prefix_is_type = is_type_attribute(tree_subkind(prefix)); break; default: break; } if (prefix_is_type) type = reflection_type(REFLECT_SUBTYPE_MIRROR); else type = reflection_type(REFLECT_VALUE_MIRROR); } break; case ATTR_USER: { if (tree_kind(prefix) == T_REF) { tree_t decl = tree_ref(prefix); ident_t id = tree_ident(decl); ident_t attr = tree_ident(aref); class_t class = class_of(decl); tree_t a = NULL; // Hack to strip off any WORK. prefix id = ident_rfrom(id, '.') ?: id; scope_t *s = tab->top_scope; if (is_container(decl)) s = private_scope_for(tab, decl); const symbol_t *sym = symbol_for(s, attr); if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); if (dd->visibility != ATTRIBUTE) continue; else if (tree_class(dd->tree) != class) continue; const spec_kind_t kind = tree_subkind(dd->tree); if ((kind == SPEC_EXACT && tree_ident2(dd->tree) == id) || kind == SPEC_ALL) { a = dd->tree; break; } else if (kind == SPEC_OTHERS) a = dd->tree; } } if (a != NULL) { tree_set_value(aref, tree_value(a)); type = tree_type(a); } else { error_at(tree_loc(prefix), "object %s has no attribute %s", istr(tree_ident(prefix)), istr(tree_ident(aref))); type = type_new(T_NONE); } } else { error_at(tree_loc(prefix), "prefix of user defined attribute " "reference cannot denote a sub-element or slice of an " "object"); type = type_new(T_NONE); } } break; default: fatal_trace("unhandled attribute %s", istr(tree_ident(aref))); } tree_set_type(aref, type); return type; } static type_t solve_attr_ref(nametab_t *tab, tree_t aref) { type_t type = try_solve_attr_ref(tab, aref); if (type != NULL) return type; switch (tree_subkind(aref)) { case ATTR_POS: tree_set_type(aref, (type = std_type(NULL, STD_UNIVERSAL_INTEGER))); return type; default: fatal_trace("attribute %s cannot be ambiguous", istr(tree_ident(aref))); } } static type_t solve_record_aggregate(nametab_t *tab, tree_t agg, type_t type) { const int nfields = type_fields(type); const int nassocs = tree_assocs(agg); // Mask used for finding the types of an "others" association bit_mask_t fmask; mask_init(&fmask, nfields); scope_t *formals = scope_for_type(tab, type); for (int i = 0; i < nassocs; i++) { type_set_t ts = {}; type_set_push(tab, &ts); tree_t a = tree_assoc(agg, i); switch (tree_subkind(a)) { case A_POS: { int pos = tree_pos(a); if (pos < nfields) { tree_t f = type_field(type, pos); type_set_add(tab, solve_field_subtype(type, f), f); } if (pos < nfields) mask_set(&fmask, pos); } break; case A_NAMED: { scope_t *tmp = tab->top_scope; tab->top_scope = formals; tree_t name = tree_name(a); type_t ntype = solve_types(tab, name, NULL); tab->top_scope = tmp; if (!type_is_none(ntype) && tree_has_ref(name)) { tree_t field = tree_ref(name); type_set_add(tab, solve_field_subtype(type, field), field); if (tree_kind(field) == T_FIELD_DECL) { const int pos = tree_pos(field); if (pos < nfields) mask_set(&fmask, pos); } } else { // Error in field name type_set_add(tab, type_new(T_NONE), NULL); } } break; case A_OTHERS: // Add the types of all the fields that haven't already be // specified to the type set for (int i = 0; i < MIN(nfields, 64); i++) { if (!mask_test(&fmask, i)) { tree_t f = type_field(type, i); type_set_add(tab, tree_type(f), f); } } break; case A_RANGE: { // This is illegal and will generate an error during // semantic checking scope_t *tmp = tab->top_scope; tab->top_scope = formals; solve_types(tab, tree_range(a, 0), NULL); tab->top_scope = tmp; } break; } _solve_types(tab, a); type_set_pop(tab, &ts); } mask_free(&fmask); return type; } static type_t solve_array_aggregate(nametab_t *tab, tree_t agg, type_t type) { // All elements must be of the composite base type if this is a // one-dimensional array otherwise construct an array type with // n-1 dimensions. type_set_t ts = {}; type_set_push(tab, &ts); type_t t0, t1 = NULL; const int ndims = dimension_of(type); if (ndims == 1) { type_t elem = type_elem(type); type_set_add(tab, (t0 = elem), NULL); if (standard() >= STD_08) t1 = type_base_recur(type); } else t0 = array_aggregate_type(type, 1); type_t index_type = index_type_of(type, 0); const bool unconstrained = type_is_unconstrained(type); bool have_named = false, have_others = false; const int nassocs = tree_assocs(agg); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(agg, i); assoc_kind_t kind = tree_subkind(a); switch (kind) { case A_POS: break; case A_OTHERS: have_others = true; if (unconstrained && ts.down->target != NULL && relaxed_rules()) { // Non-standard but supported by many other implementations tree_t aref = tree_new(T_ATTR_REF); tree_set_subkind(aref, ATTR_RANGE); tree_set_name(aref, ts.down->target); tree_set_ident(aref, ident_new("RANGE")); tree_set_type(aref, index_type); tree_set_loc(aref, tree_loc(a)); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, aref); tree_set_type(r, index_type); tree_set_loc(r, tree_loc(a)); tree_add_range(a, r); } else if (unconstrained) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(agg)); diag_printf(d, "index range of array aggregate with others choice " "cannot be determined from the context"); if (ts.down->target != NULL) diag_hint(d, NULL, "this would be allowed with the " "$bold$--relaxed$$ option"); diag_lrm(d, STD_08, "9.3.3"); diag_emit(d); } break; case A_NAMED: { tree_t name = tree_name(a); type_t ntype = solve_types(tab, name, index_type); if (tree_kind(name) == T_REF && tree_has_ref(name)) { tree_t type_decl = aliased_type_decl(tree_ref(name)); if (type_decl != NULL) { // This should have been parsed as a range association tree_t tmp = tree_new(T_ATTR_REF); tree_set_name(tmp, name); tree_set_ident(tmp, ident_new("RANGE")); tree_set_loc(tmp, tree_loc(name)); tree_set_subkind(tmp, ATTR_RANGE); tree_set_type(tmp, ntype); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, tmp); tree_set_loc(r, tree_loc(name)); tree_set_type(r, ntype); tree_set_subkind(a, (kind = A_RANGE)); tree_add_range(a, r); } } have_named = true; } break; case A_RANGE: solve_types(tab, tree_range(a, 0), index_type); have_named = true; break; case A_CONCAT: case A_SLICE: should_not_reach_here(); break; } // Hack to avoid pushing/popping type set on each iteration ATRIM(tab->top_type_set->members, 0); type_set_add(tab, t0, NULL); tree_t value = tree_value(a); if (t1 != NULL && (kind == A_POS || kind == A_RANGE)) { // In the 2008 LRM the value may have the same type as the // aggregate it which case it behaves as a concatentation. // However we only choose this interpretation if the aggregate // would be illegal without it, as otherwise many previously // legal nested aggregates are ambiguous. type_t etype; if (is_unambiguous(value)) etype = _solve_types(tab, value); else if ((etype = try_solve_type(tab, value)) == NULL) { type_set_add(tab, t1, NULL); etype = _solve_types(tab, value); } if (type_eq(etype, t1)) { // VHDL-2008 slice in aggregate switch (kind) { case A_RANGE: tree_set_subkind(a, A_SLICE); break; case A_POS: tree_set_subkind(a, A_CONCAT); break; default: should_not_reach_here(); } } } else _solve_types(tab, value); } type_set_pop(tab, &ts); bool bounds_from_context = true; if (unconstrained) bounds_from_context = false; else if (have_named && !have_others && is_anonymous_subtype(type)) bounds_from_context = false; if (bounds_from_context) return type; type_t sub = calculate_aggregate_subtype(agg); if (sub == NULL) { sub = type_new(T_SUBTYPE); type_set_base(sub, type_base_recur(type)); type_set_elem(sub, type_elem(type)); } tree_set_type(agg, sub); return sub; } static type_t try_solve_aggregate(nametab_t *tab, tree_t agg) { if (tree_has_type(agg)) return tree_type(agg); // The type of an aggregate must be determinable solely from the // context in which the aggregate appears type_t type; if (type_set_any(tab, type_is_none)) type = type_new(T_NONE); else { type_set_restrict(tab, type_is_composite); if (!type_set_uniq(tab, &type)) return NULL; } tree_set_type(agg, type); if (type_is_record(type)) return solve_record_aggregate(tab, agg, type); else return solve_array_aggregate(tab, agg, type); } static type_t solve_aggregate(nametab_t *tab, tree_t agg) { type_t type = try_solve_aggregate(tab, agg); if (type != NULL) return type; diag_t *d = diag_new(DIAG_ERROR, tree_loc(agg)); diag_printf(d, "type of aggregate cannot be determined " "from the surrounding context"); type_set_describe(tab, d, tree_loc(agg), type_is_composite, "a composite type"); diag_emit(d); tree_set_type(agg, (type = type_new(T_NONE))); return type; } static type_t solve_assoc(nametab_t *tab, tree_t assoc) { switch (tree_subkind(assoc)) { case A_NAMED: _solve_types(tab, tree_name(assoc)); break; } return _solve_types(tab, tree_value(assoc)); } static type_t solve_qualified(nametab_t *tab, tree_t qual) { assert(tree_has_type(qual)); solve_types(tab, tree_value(qual), tree_type(qual)); return tree_type(qual); } static type_t solve_type_conv(nametab_t *tab, tree_t expr) { solve_types(tab, tree_value(expr), NULL); return tree_type(expr); } static type_t try_solve_new(nametab_t *tab, tree_t new) { if (tree_has_type(new)) return tree_type(new); type_set_restrict(tab, type_is_access); type_t type; if (!type_set_uniq(tab, &type)) return NULL; tree_set_type(new, type); return type; } static type_t solve_new(nametab_t *tab, tree_t new) { type_t type = try_solve_new(tab, new); if (type != NULL) return type; diag_t *d = diag_new(DIAG_ERROR, tree_loc(new)); diag_printf(d, "cannot determine type of allocator expression " "from the surrounding context"); type_set_describe(tab, d, NULL, type_is_access, "an access type"); diag_emit(d); tree_set_type(new, (type = type_new(T_NONE))); return type; } static type_t solve_all(nametab_t *tab, tree_t all) { if (tree_has_type(all)) return tree_type(all); tree_t prefix = tree_value(all); type_t type = solve_types(tab, prefix, NULL); if (type_is_access(type)) { type = type_designated(type); if (type_is_incomplete(type) && (type = resolve_type(tab, type)) == NULL) { error_at(tree_loc(prefix), "object with incomplete type %s " "cannot be dereferenced", type_pp(type)); type = type_new(T_NONE); } } tree_set_type(all, type); return type; } static type_t try_solve_open(nametab_t *tab, tree_t open) { if (tree_has_type(open)) return tree_type(open); type_t type; if (!type_set_uniq(tab, &type)) return NULL; tree_set_type(open, type); return type; } static type_t solve_open(nametab_t *tab, tree_t open) { type_t type = try_solve_open(tab, open); if (type != NULL) return NULL; error_at(tree_loc(open), "cannot determine type of OPEN expression"); tree_set_type(open, (type = type_new(T_NONE))); return type; } static type_t solve_external_name(nametab_t *tab, tree_t name) { if (tree_has_type(name)) return tree_type(name); assert(error_count() > 0); type_t none = type_new(T_NONE); tree_set_type(name, none); return none; } static type_t solve_cond_value(nametab_t *tab, tree_t value) { type_t type0 = NULL; const int nconds = tree_conds(value); for (int i = 0; i < nconds; i++) { type_t type = _solve_types(tab, tree_cond(value, i)); if (type0 == NULL) type0 = type; } type_t type; if (!type_set_uniq(tab, &type)) type = type0; tree_set_type(value, type); return type; } static type_t solve_cond_expr(nametab_t *tab, tree_t value) { // The condition should have already been checked by solve_condition if (tree_has_result(value)) return _solve_types(tab, tree_result(value)); else return NULL; } static type_t solve_view_element(nametab_t *tab, tree_t elem) { tree_t f = resolve_name(tab, tree_loc(elem), tree_ident(elem)); if (f == NULL) { type_t none = type_new(T_NONE); tree_set_type(elem, none); return none; } assert(tree_kind(f) == T_FIELD_DECL); tree_set_ref(elem, f); if (tree_has_type(elem)) return tree_type(elem); // Subtype from mode view else { type_t type = tree_type(f); tree_set_type(elem, type); return type; } } static type_t solve_inertial(nametab_t *tab, tree_t expr) { type_t type = _solve_types(tab, tree_value(expr)); tree_set_type(expr, type); return type; } static type_t solve_pair(nametab_t *tab, tree_t left, tree_t right) { // Constrain left and right to have the same type type_t ltype; if (is_unambiguous(left)) ltype = _solve_types(tab, left); else ltype = try_solve_type(tab, left); type_t rtype; if (is_unambiguous(right)) rtype = _solve_types(tab, right); else rtype = try_solve_type(tab, right); if (ltype != NULL) rtype = solve_types(tab, right, ltype); else if (rtype != NULL) ltype = solve_types(tab, left, rtype); else { // This relies on try_solve_type filling the empty type set // with the possible types of the left or right sides ltype = _solve_types(tab, left); rtype = _solve_types(tab, right); } return ltype; } static type_t solve_range(nametab_t *tab, tree_t r) { if (tree_has_type(r)) return tree_type(r); switch (tree_subkind(r)) { case RANGE_ERROR: { type_t type = type_new(T_NONE); tree_set_type(r, type); return type; } case RANGE_EXPR: { type_t type = _solve_types(tab, tree_value(r)); tree_set_type(r, type); return type; } case RANGE_TO: case RANGE_DOWNTO: { type_t type = solve_pair(tab, tree_left(r), tree_right(r)); const bool has_context = tab->top_type_set->members.count > 0; type_t result = has_context ? type : type_base_recur(type); tree_set_type(r, result); return result; } default: fatal_trace("invalid range subkind"); } } static type_t solve_psl_fcall(nametab_t *tab, tree_t t) { if (tree_has_type(t)) return tree_type(t); psl_node_t p = tree_psl(t); assert(psl_kind(p) == P_BUILTIN_FCALL); type_t type; switch (psl_subkind(p)) { case PSL_BUILTIN_STABLE: case PSL_BUILTIN_ROSE: case PSL_BUILTIN_FELL: case PSL_BUILTIN_ENDED: type = std_type(NULL, STD_BOOLEAN); break; case PSL_BUILTIN_PREV: case PSL_BUILTIN_NEXT: { psl_node_t arg = psl_operand(p, 0); assert(psl_kind(arg) == P_HDL_EXPR); type = tree_type(psl_tree(arg)); } break; default: should_not_reach_here(); } tree_set_type(t, type); return type; } static type_t solve_psl_union(nametab_t *tab, tree_t t) { psl_node_t p = tree_psl(t); tree_t lhs = psl_tree(psl_operand(p, 0)); tree_t rhs = psl_tree(psl_operand(p, 1)); type_t type = solve_pair(tab, lhs, rhs); tree_set_type(t, type); return type; } static type_t try_solve_psl_union(nametab_t *tab, tree_t t) { psl_node_t p = tree_psl(t); tree_t lhs = psl_tree(psl_operand(p, 0)); tree_t rhs = psl_tree(psl_operand(p, 1)); type_t ltype = try_solve_type(tab, lhs); type_t rtype = try_solve_type(tab, rhs); if (ltype != NULL && rtype != NULL) { tree_set_type(t, ltype); return ltype; } else return NULL; } static type_t try_solve_type(nametab_t *tab, tree_t expr) { switch (tree_kind(expr)) { case T_FCALL: case T_PROT_FCALL: return try_solve_fcall(tab, expr); case T_STRING: return try_solve_string(tab, expr); case T_AGGREGATE: return try_solve_aggregate(tab, expr); case T_REF: return try_solve_ref(tab, expr); case T_LITERAL: return try_solve_literal(tab, expr); case T_OPEN: return try_solve_open(tab, expr); case T_ATTR_REF: return try_solve_attr_ref(tab, expr); case T_PSL_UNION: return try_solve_psl_union(tab, expr); case T_NEW: return try_solve_new(tab, expr); default: fatal_trace("cannot solve types for %s", tree_kind_str(tree_kind(expr))); } } static type_t _solve_types(nametab_t *tab, tree_t expr) { switch (tree_kind(expr)) { case T_FCALL: case T_PROT_FCALL: return solve_fcall(tab, expr); case T_PCALL: case T_PROT_PCALL: return solve_pcall(tab, expr); case T_LITERAL: return solve_literal(tab, expr); case T_STRING: return solve_string(tab, expr); case T_REF: return solve_ref(tab, expr); case T_RECORD_REF: return solve_record_ref(tab, expr); case T_AGGREGATE: return solve_aggregate(tab, expr); case T_ARRAY_REF: return solve_array_ref(tab, expr); case T_ARRAY_SLICE: return solve_array_slice(tab, expr); case T_ASSOC: return solve_assoc(tab, expr); case T_ATTR_REF: return solve_attr_ref(tab, expr); case T_QUALIFIED: return solve_qualified(tab, expr); case T_TYPE_CONV: return solve_type_conv(tab, expr); case T_OPEN: return solve_open(tab, expr); case T_NEW: return solve_new(tab, expr); case T_ALL: return solve_all(tab, expr); case T_RANGE: return solve_range(tab, expr); case T_TYPE_REF: return tree_type(expr); case T_EXTERNAL_NAME: return solve_external_name(tab, expr); case T_PROT_REF: return solve_prot_ref(tab, expr); case T_COND_VALUE: return solve_cond_value(tab, expr); case T_COND_EXPR: return solve_cond_expr(tab, expr); case T_VIEW_ELEMENT: return solve_view_element(tab, expr); case T_INERTIAL: return solve_inertial(tab, expr); case T_PSL_FCALL: return solve_psl_fcall(tab, expr); case T_PSL_UNION: return solve_psl_union(tab, expr); default: fatal_trace("cannot solve types for %s", tree_kind_str(tree_kind(expr))); } return type_new(T_NONE); } type_t solve_types(nametab_t *tab, tree_t expr, type_t constraint) { type_set_t ts = {}; type_set_push(tab, &ts); type_set_add(tab, constraint, NULL); type_t type = _solve_types(tab, expr); type_set_pop(tab, &ts); return type; } type_t solve_known_subtype(nametab_t *tab, tree_t expr, tree_t target) { assert(tree_has_type(target)); type_set_t ts = { .target = target }; type_set_push(tab, &ts); type_set_add(tab, tree_type(target), NULL); type_t type = _solve_types(tab, expr); type_set_pop(tab, &ts); return type; } type_t solve_target(nametab_t *tab, tree_t target, tree_t value) { type_t value_type = NULL; if (tree_kind(target) == T_AGGREGATE) { type_set_t ts = { .pred = type_is_composite }; type_set_push(tab, &ts); value_type = _solve_types(tab, value); type_set_pop(tab, &ts); } return solve_types(tab, target, value_type); } type_t solve_condition(nametab_t *tab, tree_t *expr) { type_t boolean = std_type(NULL, STD_BOOLEAN); if (standard() < STD_08) return solve_types(tab, *expr, boolean); // Apply the rules for condition conversion from LRM 08 section 9.2.9 type_set_t ts1 = {}; type_set_push(tab, &ts1); type_set_add(tab, boolean, NULL); type_t type; if (is_unambiguous(*expr)) type = _solve_types(tab, *expr); else type = try_solve_type(tab, *expr); type_set_pop(tab, &ts1); if (type != NULL && type_eq(type, boolean)) return type; type_set_t ts2 = {}; type_set_push(tab, &ts2); type_set_add(tab, boolean, NULL); ident_t cconv = well_known(W_OP_CCONV); const symbol_t *sym = symbol_for(tab->top_scope, cconv); if (sym != NULL) { for (int i = 0; i < sym->ndecls; i++) { const decl_t *dd = get_decl(sym, i); tree_t sub = dd->tree; if (dd->kind == T_ALIAS && !(sub = get_aliased_subprogram(sub))) continue; if ((dd->mask & N_FUNC) && tree_ports(sub) == 1) { type_t p0_type = tree_type(tree_port(sub, 0)); type_set_add(tab, p0_type, dd->tree); } } } if (type == NULL) type = _solve_types(tab, *expr); const bool do_conversion = !type_eq(type, boolean) && tab->top_type_set->members.count > 0 && type_set_contains(tab, type); if (do_conversion) { tree_t fcall = tree_new(T_FCALL); tree_set_loc(fcall, tree_loc(*expr)); tree_set_ident(fcall, cconv); add_param(fcall, *expr, P_POS, NULL); type = solve_fcall(tab, fcall); *expr = fcall; } type_set_pop(tab, &ts2); return type; } type_t solve_psl_condition(nametab_t *tab, tree_t *expr) { if (standard() >= STD_08) return solve_condition(tab, expr); else { // Allow BIT and STD_LOGIC in PSL conditions for VHDL-93 type_set_t ts = {}; type_set_push(tab, &ts); type_set_add(tab, std_type(NULL, STD_BOOLEAN), NULL); type_set_add(tab, std_type(NULL, STD_BIT), NULL); type_set_add(tab, ieee_type(IEEE_STD_ULOGIC), NULL); type_t type = _solve_types(tab, *expr); type_set_pop(tab, &ts); return type; } } nvc-r1.17.1/src/names.h000066400000000000000000000115141504111170000146040ustar00rootroot00000000000000// // Copyright (C) 2020-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _NAMES_H #define _NAMES_H #include "util.h" #include "tree.h" typedef enum { F_NONE, F_GENERIC_MAP, F_PORT_MAP, F_SUBPROGRAM, F_RECORD } formal_kind_t; typedef enum { S_DESIGN_UNIT, S_LOOP, S_SUBPROGRAM, S_PROCESS, S_PROTECTED, S_CONCURRENT_BLOCK, S_DECLARATIVE_REGION, } scope_kind_t; typedef enum { N_OBJECT = (1 << 0), N_TYPE = (1 << 1), N_ERROR = (1 << 2), N_FUNC = (1 << 3), N_PROC = (1 << 4), N_LABEL = (1 << 5), N_PSL = (1 << 6), N_PREDEF = (1 << 7), N_OVERLOAD = (1 << 8), } name_mask_t; #define N_OVERLOADS(mask) (((mask) >> 16) & 0xffff) #define N_SUBPROGRAM (N_FUNC | N_PROC) nametab_t *nametab_new(void); void nametab_finish(nametab_t *tab); void push_scope(nametab_t *tab); void pop_scope(nametab_t *tab); void push_scope_for_formals(nametab_t *tab, formal_kind_t kind, tree_t unit); void scope_set_prefix(nametab_t *tab, ident_t prefix); ident_t scope_prefix(nametab_t *tab); formal_kind_t scope_formal_kind(nametab_t *tab); void scope_set_container(nametab_t *tab, tree_t container); void scope_set_subprogram(nametab_t *tab, tree_t subprog); tree_t find_enclosing(nametab_t *tab, scope_kind_t kind); bool is_enclosing(nametab_t *tab, tree_t container); bool is_same_region(nametab_t *tab, tree_t decl); tree_t get_container(nametab_t *tab, tree_t decl); void suppress_errors(nametab_t *tab); bool have_name_errors(nametab_t *tab); typedef void (*defer_check_fn_t)(tree_t, tree_t, nametab_t *); void defer_check(nametab_t *tab, defer_check_fn_t fn, tree_t t); void map_generic_type(nametab_t *tab, type_t generic, type_t actual); void map_generic_package(nametab_t *tab, tree_t generic, tree_t actual); void map_generic_box(nametab_t *tab, tree_t inst, tree_t g, unsigned pos); void map_generic_subprogram(nametab_t *tab, tree_t generic, tree_t actual); void map_generic_const(nametab_t *tab, tree_t generic, tree_t actual); hash_t *get_generic_map(nametab_t *tab); void mangle_func(nametab_t *tab, tree_t decl); void mangle_type(nametab_t *tab, type_t type); void mangle_decl(nametab_t *tab, tree_t decl); void insert_name(nametab_t *tab, tree_t decl, ident_t alias); void insert_names_from_use(nametab_t *tab, tree_t use); void insert_names_from_context(nametab_t *tab, tree_t unit); void insert_names_for_psl(nametab_t *tab); void insert_decls(nametab_t *tab, tree_t container); void insert_ports(nametab_t *tab, tree_t container); void insert_generics(nametab_t *tab, tree_t container); void insert_names_for_config(nametab_t *tab, tree_t unit); void insert_spec(nametab_t *tab, tree_t spec, spec_kind_t kind, ident_t ident, int depth); void hide_name(nametab_t *tab, ident_t name); ident_t get_implicit_label(tree_t t, nametab_t *tab); void continue_proc_labelling_from(tree_t t, nametab_t *tab); tree_t resolve_name(nametab_t *tab, const loc_t *loc, ident_t name); type_t resolve_type(nametab_t *tab, type_t incomplete); tree_t resolve_subprogram_name(nametab_t *tab, const loc_t *loc, ident_t name, type_t constraint); tree_t resolve_uninstantiated_subprogram(nametab_t *tab, const loc_t *loc, ident_t name, type_t constraint); tree_t resolve_field_name(nametab_t *tab, const loc_t *loc, ident_t name, type_t type); void resolve_resolution(nametab_t *tab, tree_t rname, type_t type); name_mask_t query_name(nametab_t *tab, ident_t name, tree_t *p_decl); tree_t query_spec(nametab_t *tab, tree_t object); tree_t find_std(nametab_t *tab); tree_t find_forward_decl(nametab_t *tab, tree_t decl); psl_node_t find_default_clock(nametab_t *tab); tree_t get_local_decl(nametab_t *tab, tree_t container, ident_t name, int nth); typedef void (*predef_cb_t)(tree_t, void *); void walk_predefs(nametab_t *tab, ident_t name, predef_cb_t fn, void *context); type_t solve_types(nametab_t *tab, tree_t expr, type_t constraint); type_t solve_known_subtype(nametab_t *tab, tree_t expr, tree_t target); type_t solve_target(nametab_t *tab, tree_t target, tree_t value); type_t solve_condition(nametab_t *tab, tree_t *expr); type_t solve_psl_condition(nametab_t *tab, tree_t *expr); #endif // _NAMES_H nvc-r1.17.1/src/nvc.c000066400000000000000000002247321504111170000142720ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "cov/cov-api.h" #include "diag.h" #include "jit/jit-llvm.h" #include "jit/jit.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "option.h" #include "phase.h" #include "rt/assert.h" #include "rt/model.h" #include "rt/mspace.h" #include "rt/rt.h" #include "rt/shell.h" #include "rt/wave.h" #include "scan.h" #include "server.h" #include "thread.h" #include "vhpi/vhpi-util.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include "vpi/vpi-model.h" #include #include #include #include #include #include #include #include #include #include #if HAVE_GIT_SHA #include "gitsha.h" #define GIT_SHA_ONLY(x) x #else #define GIT_SHA_ONLY(x) #endif #if !defined HAVE_LLVM || !defined SYSTEM_CC #define DEFAULT_JIT true #else #define DEFAULT_JIT true #endif typedef struct { jit_t *jit; unit_registry_t *registry; mir_context_t *mir; bool user_set_std; vhpi_context_t *vhpi; vpi_context_t *vpi; const char *plugins; rt_model_t *model; cover_data_t *cover; ident_t top_level; const char *top_level_arg; lib_t work; } cmd_state_t; const char copy_string[] = "Copyright (C) 2011-2025 Nick Gasson\n" "This program comes with ABSOLUTELY NO WARRANTY. This is free software, " "and\nyou are welcome to redistribute it under certain conditions. See " "the GNU\nGeneral Public Licence for details."; const char version_string[] = PACKAGE_STRING GIT_SHA_ONLY(" (" GIT_SHA ")") LLVM_ONLY(" (Using LLVM " LLVM_VERSION ")") DEBUG_ONLY(" [debug]"); static int process_command(int argc, char **argv, cmd_state_t *state); static int parse_int(const char *str); static jit_t *get_jit(unit_registry_t *ur, mir_context_t *mc); static ident_t to_unit_name(const char *str) { char *name LOCAL = xstrdup(str); for (char *p = name; *p; p++) { if (!isalnum_iso88591(*p) && (p == name || (*p != '_' && *p != '-'))) fatal("'%s' is not a valid design unit name", str); *p = toupper_iso88591(*p); } return ident_prefix(lib_name(lib_work()), ident_new(name), '.'); } static int scan_cmd(int start, int argc, char **argv) { const char *commands[] = { "-a", "-e", "-r", "-c", "--dump", "--make", "--syntax", "--list", "--init", "--install", "--print-deps", "--do", "-i", "--cover-export", "--preprocess", "--gui", "--cover-merge", "--cover-report", }; for (int i = start; i < argc; i++) { for (size_t j = 0; j < ARRAY_LEN(commands); j++) { if (commands[j][1] == '-') { if (strcmp(argv[i], commands[j]) == 0) return i; } else if (argv[i][0] == '-' && commands[j][1] == argv[i][1]) return i; } } return argc; } static void bad_option(const char *what, char **argv) { if (optopt == 0) fatal("unrecognised %s option $bold$%s$$", what, argv[optind - 1]); else fatal("unrecognised %s option $bold$-%c$$", what, optopt); } static void missing_argument(const char *what, char **argv) { fatal("%s option $bold$%s$$ requires an argument", what, argv[optind - 1]); } static void parse_pp_define(char *optarg) { char *eq = strchr(optarg, '='); if (eq == NULL) pp_defines_add(optarg, ""); else { *eq = '\0'; pp_defines_add(optarg, eq + 1); } } static void do_file_list(const char *file, jit_t *jit, unit_registry_t *ur, mir_context_t *mc) { FILE *f; if (strcmp(file, "-") == 0) f = stdin; else if ((f = fopen(file, "r")) == NULL) fatal_errno("failed to open %s", file); char *line = NULL; size_t nchars, bufsz = 0; while ((nchars = getline(&line, &bufsz, f)) != -1) { char *stop = strpbrk(line, "\r\n#") ?: line + nchars; *stop = '\0'; // Trim trailing whitespace while (stop > line && isspace_iso88591(*--stop)) *stop = '\0'; if (strlen(line) == 0) continue; analyse_file(line, jit, ur, mc); } free(line); fclose(f); } static int analyse(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "bootstrap", no_argument, 0, 'b' }, { "error-limit", required_argument, 0, 'l' }, { "dump-vcode", optional_argument, 0, 'v' }, { "psl", no_argument, 0, 'P' }, { "relax", required_argument, 0, 'X' }, { "relaxed", no_argument, 0, 'R' }, { "define", required_argument, 0, 'D' }, { "files", required_argument, 0, 'f' }, { "check-synthesis", no_argument, 0, 's' }, { "no-save", no_argument, 0, 'N' }, { "single-unit", no_argument, 0, 'u' }, { "preserve-case", no_argument, 0, 'p' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0, error_limit = 20; const char *file_list = NULL; const char *spec = ":D:f:"; bool no_save = false; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("analysis", argv); case ':': missing_argument("analysis", argv); case 'b': opt_set_int(OPT_BOOTSTRAP, 1); break; case 'v': opt_set_str(OPT_LOWER_VERBOSE, optarg ?: ""); break; case 'X': warnf("The $bold$--relax=$$ option is deprecated: use the combined " "$bold$--relaxed$$ option instead"); opt_set_int(OPT_RELAXED, 1); break; case 'l': error_limit = parse_int(optarg); break; case 'P': opt_set_int(OPT_PSL_COMMENTS, 1); break; case 'R': opt_set_int(OPT_RELAXED, 1); break; case 'D': parse_pp_define(optarg); break; case 'f': file_list = optarg; break; case 's': opt_set_int(OPT_CHECK_SYNTHESIS, 1); break; case 'N': no_save = true; break; case 'u': opt_set_int(OPT_SINGLE_UNIT, 1); break; case 'p': opt_set_int(OPT_PRESERVE_CASE, 1); break; default: should_not_reach_here(); } } set_error_limit(error_limit); if (state->mir == NULL) state->mir = mir_context_new(); if (state->registry == NULL) state->registry = unit_registry_new(state->mir); jit_t *jit = jit_new(state->registry, state->mir); if (file_list != NULL) do_file_list(file_list, jit, state->registry, state->mir); else if (optind == next_cmd) fatal("missing file name"); for (int i = optind; i < next_cmd; i++) { if (argv[i][0] == '@') do_file_list(argv[i] + 1, jit, state->registry, state->mir); else analyse_file(argv[i], jit, state->registry, state->mir); } jit_free(jit); set_error_limit(0); if (error_count() > 0) return EXIT_FAILURE; if (!no_save) lib_save(state->work); if (error_count() > 0) return EXIT_FAILURE; // May have errors saving library argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static void parse_generic(const char *str) { char *copy LOCAL = xstrdup(str); char *split = strchr(copy, '='); if (split == NULL || *(split + 1) == '\0' || *copy == '\0') fatal("invalid generic specification '%s' (use -gNAME=VALUE)", str); *split = '\0'; for (char *p = copy; *p != '\0'; p++) *p = toupper_iso88591(*p); elab_set_generic(copy, split + 1); } static void set_top_level(char **argv, int next_cmd, cmd_state_t *state) { if (optind == next_cmd) { if (state->top_level == NULL) fatal("missing top-level unit name"); } else if (optind != next_cmd - 1) fatal("excess positional argument '%s' following top-level unit name", argv[optind + 1]); else { state->top_level_arg = argv[optind]; state->top_level = to_unit_name(argv[optind]); } } static void parse_cover_options(const char *str, cover_mask_t *mask, int *array_limit, int *threshold) { static const struct { const char *name; cover_mask_t mask; } options[] = { { "statement", COVER_MASK_STMT }, { "toggle", COVER_MASK_TOGGLE }, { "branch", COVER_MASK_BRANCH }, { "expression", COVER_MASK_EXPRESSION }, { "fsm-state", COVER_MASK_STATE }, { "functional", COVER_MASK_FUNCTIONAL }, { "all", COVER_MASK_ALL }, { "count-from-undefined", COVER_MASK_TOGGLE_COUNT_FROM_UNDEFINED }, { "count-from-to-z", COVER_MASK_TOGGLE_COUNT_FROM_TO_Z }, { "include-mems", COVER_MASK_TOGGLE_INCLUDE_MEMS }, { "exclude-unreachable", COVER_MASK_EXCLUDE_UNREACHABLE }, { "fsm-no-default-enums", COVER_MASK_FSM_NO_DEFAULT_ENUMS } }; for (const char *start = str; ; str++) { if (*str == ',' || *str == '\0') { if (strncmp(start, "ignore-arrays-from-", 19) == 0) *array_limit = parse_int(start + 19); else if (strncmp(start, "threshold-", 10) == 0) *threshold = parse_int(start + 10); else { int pos = 0; for (; pos < ARRAY_LEN(options); pos++) { if (!strncmp(options[pos].name, start, str - start)) break; } if (pos == ARRAY_LEN(options)) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "unknown coverage type '%.*s'", (int)(str - start), start); diag_hint(d, NULL, "valid coverage types are: statement, " "toggle, branch, and expression"); diag_hint(d, NULL, "selected coverage types should be " "comma separated e.g $bold$--cover=toggle,branch$$"); diag_emit(d); fatal_exit(EXIT_FAILURE); } else *mask |= options[pos].mask; } if (*str == '\0') break; start = str + 1; } } } static int parse_optimise_level(const char *str) { char *eptr; const int level = strtoul(optarg, &eptr, 10); if (level > 3 || *eptr != '\0') fatal("invalid optimisation level %s", optarg); return level; } static void load_jit_pack(jit_t *jit, tree_t top) { char *name LOCAL = xasprintf("_%s.pack", istr(tree_ident(top))); FILE *f = lib_fopen(lib_work(), name, "rb"); if (f != NULL) { jit_load_pack(jit, f); fclose(f); } } static int elaborate(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "dump-llvm", no_argument, 0, 'd' }, { "dump-vcode", optional_argument, 0, 'v' }, { "cover", optional_argument, 0, 'c' }, { "cover-file", required_argument, 0, 'F' }, { "cover-spec", required_argument, 0, 's' }, { "sdf", required_argument, 0, 'f' }, { "verbose", no_argument, 0, 'V' }, { "no-save", no_argument, 0, 'N' }, { "jit", no_argument, 0, 'j' }, { "precompile", no_argument, 0, 'p' }, { "no-collapse", no_argument, 0, 'C' }, { "trace", no_argument, 0, 't' }, { 0, 0, 0, 0 } }; bool use_jit = DEFAULT_JIT, no_save = false; unit_meta_t meta = {}; cover_mask_t cover_mask = 0; const char *cover_spec_file = NULL, *sdf_args = NULL; int cover_array_limit = 0; int threshold = 1; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":Vg:O:jt"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 'O': opt_set_int(OPT_OPTIMISE, parse_optimise_level(optarg)); break; case 'd': opt_set_int(OPT_DUMP_LLVM, 1); break; case 'v': opt_set_str(OPT_LOWER_VERBOSE, optarg ?: ""); break; case 'c': if (optarg) parse_cover_options(optarg, &(cover_mask), &(cover_array_limit), &(threshold)); else cover_mask = COVER_MASK_ALL; break; case 'V': opt_set_int(OPT_VERBOSE, 1); break; case 'N': opt_set_int(OPT_NO_SAVE, 1); no_save = true; break; case 'C': opt_set_int(OPT_NO_COLLAPSE, 1); break; case 'j': use_jit = true; break; case 'p': use_jit = false; break; case 'g': parse_generic(optarg); break; case 's': cover_spec_file = optarg; break; case 'F': meta.cover_file = optarg; break; case 'f': sdf_args = optarg; break; case 't': opt_set_int(OPT_RT_TRACE, 1); break; case 0: // Set a flag break; case '?': bad_option("elaboration", argv); case ':': missing_argument("elaboration", argv); default: should_not_reach_here(); } } set_top_level(argv, next_cmd, state); progress("initialising"); object_t *obj = lib_get_generic(state->work, state->top_level, NULL); if (obj == NULL) fatal("cannot find unit %s in library %s", istr(state->top_level), istr(lib_name(state->work))); progress("loading top-level unit"); char *cover_default LOCAL = NULL; cover_data_t *cover = NULL; if (cover_mask != 0) { cover = cover_data_init(cover_mask, cover_array_limit, threshold); if (cover_spec_file != NULL) cover_load_spec_file(cover, cover_spec_file); if (meta.cover_file == NULL) { cover_default = xasprintf("%s.ncdb", state->top_level_arg); meta.cover_file = cover_default; } } if (sdf_args != NULL) { // TODO: Pass min-max spec to underlying sdf_parse somehow analyse_file(sdf_args, NULL, NULL, NULL); } if (state->model != NULL) { model_free(state->model); state->model = NULL; } if (state->jit != NULL) { jit_free(state->jit); state->jit = NULL; } if (state->registry != NULL) { unit_registry_free(state->registry); state->registry = NULL; } if (state->mir != NULL) { mir_context_free(state->mir); state->mir = NULL; } state->mir = mir_context_new(); state->registry = unit_registry_new(state->mir); state->jit = get_jit(state->registry, state->mir); state->model = model_new(state->jit, cover); if (state->vhpi == NULL) state->vhpi = vhpi_context_new(); tree_t top = elab(obj, state->jit, state->registry, state->mir, cover, NULL, state->model); if (top == NULL) return EXIT_FAILURE; lib_put_meta(state->work, top, &meta); progress("elaborating design"); if (cover != NULL) { fbuf_t *covdb = fbuf_open(meta.cover_file, FBUF_OUT, FBUF_CS_NONE); cover_dump_items(cover, covdb, COV_DUMP_ELAB, NULL); fbuf_close(covdb, NULL); progress("dumping coverage data"); } if (error_count() > 0) return EXIT_FAILURE; const char *elab_name = istr(tree_ident(top)); char *pack_name LOCAL = xasprintf("_%s.pack", elab_name); char *dll_name LOCAL = xasprintf("_%s." DLL_EXT, elab_name); // Delete any existing generated code to avoid accidentally loading // the wrong version later lib_delete(state->work, pack_name); lib_delete(state->work, dll_name); if (!no_save) { lib_save(state->work); progress("saving library"); } if (!use_jit) cgen(top, state->registry, state->mir, state->jit, CGEN_NATIVE); else if (!no_save) cgen(top, state->registry, state->mir, state->jit, CGEN_JIT_PACK); if (!use_jit || cover != NULL) { // Must discard current JIT state to load AOT library later model_free(state->model); jit_free(state->jit); state->jit = NULL; state->model = NULL; } argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static uint64_t parse_time(const char *str) { char unit[4]; unsigned base; uint64_t mult = 1; if (sscanf(str, "%u%3s", &base, unit) != 2) fatal("invalid time format: %s", str); if (strcmp(unit, "fs") == 0) mult = 1; else if (strcmp(unit, "ps") == 0) mult = 1000; else if (strcmp(unit, "ns") == 0) mult = 1000000; else if (strcmp(unit, "us") == 0) mult = 1000000000; else if (strcmp(unit, "ms") == 0) mult = 1000000000000; else if (strcmp(unit, "sec") == 0) mult = 1000000000000000; else fatal("invalid unit: %s", unit); return base * mult; } static int parse_int(const char *str) { char *eptr = NULL; int n = strtol(str, &eptr, 0); if ((eptr == NULL) || (*eptr != '\0')) fatal("invalid integer: %s", str); return n; } static ieee_warnings_t parse_ieee_warnings(const char *str) { if (strcasecmp(str, "off") == 0) return IEEE_WARNINGS_OFF; else if (strcasecmp(str, "on") == 0) return IEEE_WARNINGS_ON; else if (strcasecmp(str, "off-at-0") == 0) return IEEE_WARNINGS_OFF_AT_0; else fatal("specify 'on', 'off' or 'off-at-0' instead of '%s'", str); } static vhdl_severity_t parse_severity(const char *str) { if (strcasecmp(str, "note") == 0) return SEVERITY_NOTE; else if (strcasecmp(str, "warning") == 0) return SEVERITY_WARNING; else if (strcasecmp(str, "error") == 0) return SEVERITY_ERROR; else if (strcasecmp(str, "failure") == 0) return SEVERITY_FAILURE; else fatal("invalid severity level: %s", str); } static void parse_exit_severity(const char *str) { const vhdl_severity_t s = parse_severity(optarg); set_exit_severity(s); set_status_severity(s); } static int parse_stop_delta(const char *str) { const int ival = parse_int(str); if (ival < 1) fatal("$bold$--stop-delta$$ argument must be greater than zero"); else if (ival > DELTA_CYCLE_MAX) { warnf("the maxmimum number of supported delta cycles is %d", DELTA_CYCLE_MAX); return DELTA_CYCLE_MAX; } else return ival; } static void ctrl_c_handler(void *arg) { rt_model_t *model = arg; model_interrupt(model); } static jit_t *get_jit(unit_registry_t *ur, mir_context_t *mc) { jit_t *jit = jit_new(ur, mc); #if defined HAVE_LLVM && 1 jit_register_llvm_plugin(jit); #elif defined ARCH_X86_64 && 0 jit_register_native_plugin(jit); #endif _std_standard_init(); _std_env_init(); _std_reflection_init(); _file_io_init(); _nvc_sim_pkg_init(); return jit; } static int plusarg_cmp(const void *lptr, const void *rptr) { const char *lstr = *(const char **)lptr; const char *rstr = *(const char **)rptr; if (lstr[0] == '+' && rstr[0] != '+') return -1; else if (lstr[0] != '+' && rstr[0] == '+') return 1; else return lptr - rptr; } static cover_data_t *load_coverage(const unit_meta_t *meta, jit_t *j) { if (meta->cover_file == NULL) return NULL; fbuf_t *f = fbuf_open(meta->cover_file, FBUF_IN, FBUF_CS_NONE); if (f == NULL) fatal_errno("failed to open coverage database: %s", meta->cover_file); cover_data_t *db = cover_read_items(f, 0); // Pre-allocate coverage counters const int n_tags = cover_count_items(db); jit_get_cover_mem(j, n_tags); fbuf_close(f, NULL); return db; } static void emit_coverage(const unit_meta_t *meta, jit_t *j, cover_data_t *db) { assert(meta->cover_file != NULL); fbuf_t *f = fbuf_open(meta->cover_file, FBUF_OUT, FBUF_CS_NONE); if (f == NULL) fatal_errno("failed to open coverage database: %s", meta->cover_file); const int n_tags = cover_count_items(db); const int32_t *counts = jit_sync_cover_mem(j, n_tags); cover_dump_items(db, f, COV_DUMP_RUNTIME, counts); fbuf_close(f, NULL); } static void enable_ieee_warnings_cb(rt_model_t *m, void *ctx) { cmd_state_t *state = ctx; assert(opt_get_int(OPT_IEEE_WARNINGS) == IEEE_WARNINGS_OFF_AT_0); opt_set_int(OPT_IEEE_WARNINGS, IEEE_WARNINGS_ON); ident_t pkg_name = ident_new("NVC.SIM_PKG"); ident_t var_name = ident_new("IEEE_NO_WARNING"); jit_handle_t handle = jit_lazy_compile(state->jit, pkg_name); jit_link(state->jit, handle); uint8_t *ptr = jit_get_frame_var(state->jit, handle, var_name); assert(ptr != NULL); assert(*ptr == 1); *ptr = 0; } static int run_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "trace", no_argument, 0, 't' }, { "profile", no_argument, 0, 'p' }, // DEPRECATED 1.14 { "stop-time", required_argument, 0, 's' }, { "stats", no_argument, 0, 'S' }, { "wave", optional_argument, 0, 'w' }, { "stop-delta", required_argument, 0, 'd' }, { "format", required_argument, 0, 'f' }, { "include", required_argument, 0, 'i' }, { "ieee-warnings", required_argument, 0, 'I' }, // DEPRECATED 1.16 { "exclude", required_argument, 0, 'e' }, { "exit-severity", required_argument, 0, 'x' }, { "dump-arrays", optional_argument, 0, 'a' }, { "load", required_argument, 0, 'l' }, { "vhpi-debug", no_argument, 0, 'D' }, { "vhpi-trace", no_argument, 0, 'T' }, { "gtkw", optional_argument, 0, 'g' }, { "shuffle", no_argument, 0, 'H' }, { 0, 0, 0, 0 } }; wave_format_t wave_fmt = WAVE_FORMAT_FST; uint64_t stop_time = TIME_HIGH; const char *wave_fname = NULL; const char *gtkw_fname = NULL; const char *pli_plugins = NULL; static bool have_run = false; if (have_run) fatal("multiple run commands are not supported"); have_run = true; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":w::l:gi"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("run", argv); case ':': missing_argument("run", argv); case 't': opt_set_int(OPT_RT_TRACE, 1); break; case 'p': warnf("the $bold$--profile$$ option is deprecated and has no effect"); break; case 'T': opt_set_str(OPT_PLI_TRACE, "1"); opt_set_int(OPT_PLI_DEBUG, 1); break; case 'D': opt_set_int(OPT_PLI_DEBUG, 1); break; case 's': stop_time = parse_time(optarg); break; case 'f': if (strcmp(optarg, "vcd") == 0) wave_fmt = WAVE_FORMAT_VCD; else if (strcmp(optarg, "fst") == 0) wave_fmt = WAVE_FORMAT_FST; else fatal("invalid waveform format: %s", optarg); break; case 'S': opt_set_int(OPT_RT_STATS, 1); break; case 'w': if (optarg == NULL) wave_fname = ""; else wave_fname = optarg; break; case 'g': if (optarg == NULL) gtkw_fname = ""; else gtkw_fname = optarg; break; case 'd': opt_set_int(OPT_STOP_DELTA, parse_stop_delta(optarg)); break; case 'i': wave_include_glob(optarg); break; case 'e': wave_exclude_glob(optarg); break; case 'l': pli_plugins = optarg; break; case 'x': parse_exit_severity(optarg); break; case 'I': { const ieee_warnings_t on = parse_ieee_warnings(optarg); // TODO: add an unconditional warning after 1.16 if (state->jit != NULL && opt_get_int(OPT_IEEE_WARNINGS) != on) warnf("the $bold$--ieee-warnings$$ option may have no effect " "as the IEEE packages have already been initialised, pass " "$bold$--ieee-warnings$$ as a global option instead"); opt_set_int(OPT_IEEE_WARNINGS, on); } break; case 'a': if (optarg == NULL) opt_set_int(OPT_DUMP_ARRAYS, INT_MAX); else opt_set_int(OPT_DUMP_ARRAYS, parse_int(optarg)); break; case 'H': warnf("the $bold$--shuffle$$ option is intended for debug use only " "and may introduce significant performance overhead as well " "as non-deterministic behaviour"); opt_set_int(OPT_SHUFFLE_PROCS, 1); break; default: should_not_reach_here(); } } // Shuffle the arguments to put all the plusargs first qsort(argv + optind, next_cmd - optind, sizeof(char *), plusarg_cmp); int nplusargs = 0; char **plusargs = argv + optind; for (int i = optind; i < next_cmd; i++) { if (argv[i][0] == '+') nplusargs++, optind++; } set_top_level(argv, next_cmd, state); ident_t ename = ident_prefix(state->top_level, well_known(W_ELAB), '.'); const unit_meta_t *meta = NULL; object_t *obj = lib_get_generic(state->work, ename, &meta); if (obj == NULL) fatal("%s not elaborated", istr(state->top_level)); tree_t top = tree_from_object(obj); assert(top != NULL); wave_dumper_t *dumper = NULL; if (wave_fname != NULL) { const char *name_map[] = { "FST", "VCD" }; const char *ext_map[] = { "fst", "vcd" }; char *tmp LOCAL = NULL, *tmp2 LOCAL = NULL; if (*wave_fname == '\0') { tmp = xasprintf("%s.%s", state->top_level_arg, ext_map[wave_fmt]); wave_fname = tmp; notef("writing %s waveform data to %s", name_map[wave_fmt], tmp); } if (gtkw_fname != NULL && *gtkw_fname == '\0') { tmp2 = xasprintf("%s.gtkw", state->top_level_arg); gtkw_fname = tmp2; } wave_include_file(argv[optind]); dumper = wave_dumper_new(wave_fname, gtkw_fname, top, wave_fmt); } else if (gtkw_fname != NULL) warnf("$bold$--gtkw$$ option has no effect without $bold$--wave$$"); if (opt_get_size(OPT_HEAP_SIZE) < 0x100000) warnf("recommended heap size is at least 1M"); if (state->mir == NULL) state->mir = mir_context_new(); if (state->registry == NULL) state->registry = unit_registry_new(state->mir); if (state->jit == NULL) state->jit = get_jit(state->registry, state->mir); #ifdef ENABLE_LLVM jit_load_dll(state->jit, tree_ident(top)); #endif load_jit_pack(state->jit, top); if (state->cover == NULL) state->cover = load_coverage(meta, state->jit); if (state->model == NULL) { state->model = model_new(state->jit, state->cover); create_scope(state->model, top, NULL); } if (state->vhpi == NULL) state->vhpi = vhpi_context_new(); if (state->vpi == NULL) state->vpi = vpi_context_new(); if (pli_plugins != NULL || state->plugins != NULL) { vhpi_context_initialise(state->vhpi, top, state->model, state->jit, nplusargs, plusargs); vpi_context_initialise(state->vpi, top, state->model, state->jit, nplusargs, plusargs); } else if (nplusargs > 0) warnf("found plusargs on command line but no VHPI plugin was loaded"); if (pli_plugins != NULL) vhpi_load_plugins(pli_plugins); set_ctrl_c_handler(ctrl_c_handler, state->model); model_reset(state->model); if (dumper != NULL) wave_dumper_restart(dumper, state->model, state->jit); if (opt_get_int(OPT_IEEE_WARNINGS) == IEEE_WARNINGS_OFF_AT_0) model_set_global_cb(state->model, RT_END_TIME_STEP, enable_ieee_warnings_cb, state); model_run(state->model, stop_time); set_ctrl_c_handler(NULL, NULL); const int rc = model_exit_status(state->model); if (dumper != NULL) wave_dumper_free(dumper); if (state->cover != NULL) emit_coverage(meta, state->jit, state->cover); vhpi_context_free(state->vhpi); state->vhpi = NULL; vpi_context_free(state->vpi); state->vpi = NULL; model_free(state->model); state->model = NULL; argc -= next_cmd - 1; argv += next_cmd - 1; return rc == 0 && argc > 1 ? process_command(argc, argv, state) : rc; } static int print_deps_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; opt_set_int(OPT_MAKE_DEPS_ONLY, 1); const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: break; // Set a flag case '?': bad_option("make", argv); case ':': missing_argument("make", argv); default: abort(); } } const int count = next_cmd - optind; tree_t *targets = NULL; if (count > 0) targets = xmalloc_array(count, sizeof(tree_t)); for (int i = optind; i < next_cmd; i++) { ident_t name = to_unit_name(argv[i]); ident_t elab = ident_prefix(name, well_known(W_ELAB), '.'); if ((targets[i - optind] = lib_get(state->work, elab)) == NULL) { if ((targets[i - optind] = lib_get(state->work, name)) == NULL) fatal("cannot find unit %s in library %s", istr(name), istr(lib_name(state->work))); } } make(targets, count, stdout); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static int make_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "deps-only", no_argument, 0, 'd' }, { "posix", no_argument, 0, 'p' }, { 0, 0, 0, 0 } }; warnf("the $bold$--make$$ command is deprecated and may be repurposed in a " "future release"); notef("use $bold$--print-deps$$ to print Makefile dependencies instead"); const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case 'd': opt_set_int(OPT_MAKE_DEPS_ONLY, 1); break; case 'p': // Does nothing break; case '?': bad_option("make", argv); case ':': missing_argument("make", argv); default: abort(); } } const int count = next_cmd - optind; tree_t *targets = xmalloc_array(count, sizeof(tree_t)); for (int i = optind; i < next_cmd; i++) { ident_t name = to_unit_name(argv[i]); ident_t elab = ident_prefix(name, well_known(W_ELAB), '.'); if ((targets[i - optind] = lib_get(state->work, elab)) == NULL) { if ((targets[i - optind] = lib_get(state->work, name)) == NULL) fatal("cannot find unit %s in library %s", istr(name), istr(lib_name(state->work))); } } make(targets, count, stdout); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static void list_walk_fn(lib_t lib, ident_t ident, int kind, void *context) { const char *pretty = "???"; switch (kind) { case T_ELAB: pretty = "Elaborated"; break; case T_ARCH: pretty = "Architecture"; break; case T_ENTITY: pretty = "Entity"; break; case T_PACKAGE: pretty = "Package"; break; case T_PACK_BODY: pretty = "Package body"; break; case T_PACK_INST: pretty = "Instantiated package"; break; case T_CONFIGURATION: pretty = "Configuration"; break; case T_CONTEXT: pretty = "Context"; break; } printf("%-30s : %s\n", istr(ident), pretty); } static int list_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("list", argv); case ':': missing_argument("list", argv); default: abort(); } } lib_walk_index(state->work, list_walk_fn, NULL); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static int init_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("init", argv); case ':': missing_argument("init", argv); } } if (argc != optind) fatal("$bold$--init$$ command takes no positional arguments"); lib_save(state->work); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static void list_packages(void) { LOCAL_TEXT_BUF tb = tb_new(); get_libexec_dir(tb); DIR *dir = opendir(tb_get(tb)); tb_rewind(tb); if (dir != NULL) { struct dirent *d; while ((d = readdir(dir))) { if (strncmp(d->d_name, "install-", 8)) continue; const char *dot = strrchr(d->d_name, '.'); if (dot == NULL) continue; const int nchar = dot - d->d_name - 8; tb_printf(tb, " %.*s", nchar, d->d_name + 8); } closedir(dir); } notef("the following packages can be installed:%s", tb_get(tb)); } static int install_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "dest", required_argument, 0, 'd' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("install", argv); case ':': missing_argument("install", argv); case 'd': setenv("NVC_INSTALL_DEST", optarg , 1); break; } } if (argc == optind) { errorf("missing argument to $bold$--install$$ command"); list_packages(); return EXIT_FAILURE; } LOCAL_TEXT_BUF tb = tb_new(); if (get_exe_path(tb)) setenv("NVC", tb_get(tb), 1); if (state->user_set_std) setenv("NVC_STD", standard_text(standard()), 1); for (int i = optind; i < next_cmd; i++) { tb_rewind(tb); get_libexec_dir(tb); tb_printf(tb, DIR_SEP "install-%s.sh", argv[i]); file_info_t info; if (!get_file_info(tb_get(tb), &info) || info.type != FILE_REGULAR) { errorf("%s is not an executable script", tb_get(tb)); list_packages(); return EXIT_FAILURE; } const char *args[] = { #ifdef __MINGW32__ "bash", #endif tb_get(tb), NULL }; run_program(args); } argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static int syntax_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; warnf("the $bold$--syntax$$ command is deprecated, use " "$bold$-a --no-save$$ instead"); const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("syntax", argv); case ':': missing_argument("syntax", argv); } } for (int i = optind; i < next_cmd; i++) { input_from_file(argv[i]); while (parse()) ; } if (error_count() > 0) return EXIT_FAILURE; argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static void dump_one_unit(ident_t name, bool add_elab, bool add_body) { if (add_elab) name = ident_prefix(name, well_known(W_ELAB), '.'); else if (add_body) name = ident_prefix(name, well_known(W_BODY), '-'); tree_t top = lib_get(lib_work(), name); if (top == NULL) fatal("%s not analysed", istr(name)); dump(top); } static int dump_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "elab", no_argument, 0, 'E' }, { "body", no_argument, 0, 'b' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); bool add_elab = false, add_body = false; int c, index = 0; const char *spec = ":Eb"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case '?': bad_option("dump", argv); case ':': missing_argument("dump", argv); case 'E': add_elab = true; break; case 'b': add_body = true; break; default: abort(); } } if (optind == next_cmd) { if (state->top_level == NULL) fatal("missing top-level unit name"); else dump_one_unit(state->top_level, add_elab, add_body); } else { for (int i = optind; i < next_cmd; i++) dump_one_unit(to_unit_name(argv[i]), add_elab, add_body); } argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static int do_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: break; // Set a flag case '?': bad_option("do", argv); case ':': missing_argument("do", argv); default: abort(); } } if (state->mir == NULL) state->mir = mir_context_new(); if (state->registry == NULL) state->registry = unit_registry_new(state->mir); if (state->jit == NULL) state->jit = get_jit(state->registry, state->mir); #ifdef ENABLE_TCL tcl_shell_t *sh = shell_new(state->jit); if (optind < next_cmd && strpbrk(argv[optind], "./\\") == NULL) { ident_t unit_name = to_unit_name(argv[optind]); if (lib_get(state->work, unit_name) != NULL) { state->top_level_arg = xstrdup(argv[optind]); state->top_level = unit_name; optind++; } } if (state->top_level != NULL) { ident_t ename = ident_prefix(state->top_level, well_known(W_ELAB), '.'); tree_t top = lib_get(state->work, ename); if (top == NULL) fatal("%s not elaborated", istr(state->top_level)); #ifdef ENABLE_LLVM jit_load_dll(state->jit, tree_ident(top)); #endif load_jit_pack(state->jit, top); shell_reset(sh, top); } if (optind == next_cmd) fatal("no script file specified"); for (int i = optind; i < next_cmd; i++) { if (!shell_do(sh, argv[i])) { shell_free(sh); return EXIT_FAILURE; } } shell_free(sh); #else fatal("compiled without TCL support"); #endif argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static int interact_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index = 0; const char *spec = ":"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: break; // Set a flag case '?': bad_option("do", argv); case ':': missing_argument("do", argv); default: abort(); } } if (state->mir == NULL) state->mir = mir_context_new(); if (state->registry == NULL) state->registry = unit_registry_new(state->mir); if (state->jit == NULL) state->jit = get_jit(state->registry, state->mir); #ifdef ENABLE_TCL tcl_shell_t *sh = shell_new(state->jit); if (optind < next_cmd && strpbrk(argv[optind], "./\\") == NULL) { ident_t unit_name = to_unit_name(argv[optind]); if (lib_get(state->work, unit_name) != NULL) { state->top_level_arg = xstrdup(argv[optind]); state->top_level = unit_name; optind++; } } if (optind != next_cmd) fatal("unexpected argument \"%s\"", argv[optind]); if (state->top_level != NULL) { ident_t ename = ident_prefix(state->top_level, well_known(W_ELAB), '.'); tree_t top = lib_get(state->work, ename); if (top == NULL) fatal("%s not elaborated", istr(state->top_level)); #ifdef ENABLE_LLVM jit_load_dll(state->jit, tree_ident(top)); #endif load_jit_pack(state->jit, top); shell_reset(sh, top); } shell_interact(sh); shell_free(sh); #else fatal("compiled without TCL support"); #endif argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } static uint32_t parse_cover_print_spec(char *str) { uint32_t mask = 0; const char *delim = ","; for (char *tok = strtok(str, delim); tok; tok = strtok(NULL, delim)) { if (!strcmp(tok, "covered")) mask |= COVER_MASK_DONT_PRINT_COVERED; else if (!strcmp(tok, "uncovered")) mask |= COVER_MASK_DONT_PRINT_UNCOVERED; else if (!strcmp(tok, "excluded")) mask |= COVER_MASK_DONT_PRINT_EXCLUDED; else { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "invalid option: '%s' for $bold$--dont-print$$", tok); diag_hint(d, NULL, "valid options are: 'covered', 'uncovered', " "'excluded'"); diag_emit(d); fatal_exit(EXIT_FAILURE); } } return mask; } static merge_mode_t parse_cover_merge_mode(char *str) { if (strcmp(str, "intersect") == 0) return MERGE_INTERSECT; else if (strcmp(str, "union") == 0) return MERGE_UNION; else { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "invalid option: '%s' for $bold$--merge-mode$$", str); diag_hint(d, NULL, "valid options are: 'union', 'intersect'"); diag_emit(d); fatal_exit(EXIT_FAILURE); } return 0; } static int coverage_cmd(int argc, char **argv, cmd_state_t *state) { warnf("the $bold$-c$$ sub-command is deprecated, use $bold$--cover-report$$ " "or $bold$--cover-merge$$ instead"); static struct option long_options[] = { { "report", required_argument, 0, 'r' }, { "exclude-file", required_argument, 0, 'e' }, { "export", required_argument, 0, 'E' }, { "merge", required_argument, 0, 'm' }, { "dont-print", required_argument, 0, 'd' }, { "item-limit", required_argument, 0, 'l' }, { "verbose", no_argument, 0, 'V' }, { 0, 0, 0, 0 } }; const char *out_db = NULL, *rpt_file = NULL, *exclude_file = NULL; const char *export_file = NULL; int c, index; const char *spec = ":V"; cover_mask_t rpt_mask = 0; int item_limit = 5000; while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) { switch (c) { case 'r': rpt_file = optarg; break; case 'm': out_db = optarg; break; case 'e': exclude_file = optarg; break; case 'E': export_file = optarg; break; case 'd': rpt_mask = parse_cover_print_spec(optarg); break; case 'l': item_limit = parse_int(optarg); break; case 'V': opt_set_int(OPT_VERBOSE, 1); break; case '?': bad_option("coverage", argv); case ':': missing_argument("coverage", argv); default: abort(); } } progress("initialising"); if (optind == argc) fatal("no input coverage database FILE specified"); cover_data_t *cover = NULL; // Rest of inputs are coverage input files for (int i = optind; i < argc; i++) { fbuf_t *f = fbuf_open(argv[i], FBUF_IN, FBUF_CS_NONE); if (f != NULL) { progress("Loading input coverage database: %s", argv[i]); if (i == optind) cover = cover_read_items(f, rpt_mask); else cover_merge_items(f, cover, MERGE_UNION); } else fatal("Could not open coverage database: %s", argv[i]); fbuf_close(f, NULL); } if (out_db) { progress("Saving merged coverage database to: %s", out_db); fbuf_t *f = fbuf_open(out_db, FBUF_OUT, FBUF_CS_NONE); cover_dump_items(cover, f, COV_DUMP_PROCESSING, NULL); fbuf_close(f, NULL); } if (exclude_file && cover) { progress("Loading exclude file: %s", exclude_file); cover_load_exclude_file(exclude_file, cover); } if (rpt_file && cover) { progress("Generating code coverage report."); cover_report(rpt_file, cover, item_limit); } if (export_file && cover) { progress("Exporting XML coverage report"); FILE *f = fopen(export_file, "w"); if (f == NULL) fatal_errno("cannot open %s", export_file); cover_export_cobertura(cover, f, NULL); fclose(f); } return 0; } #ifdef ENABLE_GUI static int gui_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "init", required_argument, 0, 'i' }, { "port", required_argument, 0, 'p' }, { "protocol", required_argument, 0, 'o' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); server_kind_t kind = SERVER_HTTP; int c, index = 0; const char *spec = ":", *init_cmd = NULL; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: break; // Set a flag case 'i': init_cmd = optarg; break; case 'p': { const int port = parse_int(optarg); if (port < 0 || port > UINT16_MAX) fatal("invalid port number %d", port); opt_set_int(OPT_SERVER_PORT, port); } break; case 'o': { if (strcmp(optarg, "http") == 0) kind = SERVER_HTTP; else if (strcmp(optarg, "cxxrtl") == 0) kind = SERVER_CXXRTL; else fatal("invalid protocol '%s', valid choices are " "'http' and 'cxxrtl'", optarg); } break; case '?': bad_option("gui", argv); case ':': missing_argument("gui", argv); default: abort(); } } if (argc != optind) fatal("$bold$--gui$$ command takes no positional arguments"); tree_t top = NULL; if (state->top_level != NULL) { ident_t ename = ident_prefix(state->top_level, well_known(W_ELAB), '.'); if ((top = lib_get(state->work, ename)) == NULL) fatal("%s not elaborated", istr(state->top_level)); } if (state->mir == NULL) state->mir = mir_context_new(); if (state->jit == NULL) state->jit = get_jit(state->registry, state->mir); start_server(kind, state->jit, top, NULL, NULL, init_cmd); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : EXIT_SUCCESS; } #endif static cover_data_t *merge_coverage_files(int argc, int next_cmd, char **argv, cover_mask_t rpt_mask, merge_mode_t mode) { // Merge all input coverage databases given on command line if (optind == next_cmd) fatal("no input coverage database specified"); cover_data_t *cover = NULL; for (int i = optind; i < next_cmd; i++) { fbuf_t *f = fbuf_open(argv[i], FBUF_IN, FBUF_CS_NONE); if (f == NULL) { // Attempt to redirect the old file name to the new one // TODO: this should be removed at some point char *slash = strrchr(argv[i], *DIR_SEP) ?: strrchr(argv[i], '/'); if (slash != NULL && slash[1] == '_') { char *tail = strstr(slash, ".covdb"); if (tail != NULL && tail[6] == '\0') { ident_t unit_name = ident_new_n(slash + 2, tail - slash - 2); lib_t lib = lib_find(ident_until(unit_name, '.')); if (lib != NULL) { const unit_meta_t *meta; object_t *obj = lib_get_generic(lib, unit_name, &meta); if (obj != NULL && meta->cover_file != NULL) { warnf("redirecting %s to %s, please update your scripts", argv[i], meta->cover_file); f = fbuf_open(meta->cover_file, FBUF_IN, FBUF_CS_NONE); } } } } } if (f == NULL) fatal_errno("could not open %s", argv[i]); progress("loading input coverage database %s", argv[i]); if (i == optind) cover = cover_read_items(f, rpt_mask); else cover_merge_items(f, cover, mode); fbuf_close(f, NULL); } return cover; } static int cover_export_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "format", required_argument, 0, 'f' }, { "output", required_argument, 0, 'o' }, { "relative", optional_argument, 0, 'r' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); enum { UNSET, COBERTURA, XML } format = UNSET; const char *output = NULL, *relative = NULL; int c, index; const char *spec = ":o:"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 'f': if (strcasecmp(optarg, "cobertura") == 0) format = COBERTURA; else if (strcasecmp(optarg, "xml") == 0) format = XML; else fatal("unknown format '%s', valid formats are: cobertura, xml", optarg); break; case 'o': output = optarg; break; case 'r': relative = optarg ?: "."; break; case '?': bad_option("coverage export", argv); case ':': missing_argument("coverage export", argv); default: abort(); } } if (format == UNSET) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "the $bold$--format$$ option is required"); diag_hint(d, NULL, "pass $bold$--format=cobertura$$ for Cobertura XML"); diag_emit(d); return EXIT_FAILURE; } // DEPRECATED 1.14 // Handle the old-style --cover-export which accepted a top-level unit name bool looks_like_file = false; if (argc != optind) { file_info_t info; if (get_file_info(argv[optind], &info)) looks_like_file = true; else if (strstr(argv[optind], "/")) looks_like_file = true; } cover_data_t *cover; if (looks_like_file) cover = merge_coverage_files(argc, next_cmd, argv, 0, MERGE_UNION); else { set_top_level(argv, next_cmd, state); char *fname LOCAL = xasprintf("_%s.elab.covdb", istr(state->top_level)); fbuf_t *f = lib_fbuf_open(state->work, fname, FBUF_IN, FBUF_CS_NONE); if (f == NULL) fatal("no coverage database for %s", istr(state->top_level)); cover = cover_read_items(f, 0); fbuf_close(f, NULL); warnf("exporting the coverage database using the top-level unit name " "is deprecated, pass the path to the coverage database instead"); } FILE *file = stdout; if (output != NULL && (file = fopen(output, "w")) == NULL) fatal_errno("cannot create %s", output); switch (format) { case COBERTURA: cover_export_cobertura(cover, file, relative); break; case XML: cover_export_xml(cover, file, relative); break; case UNSET: should_not_reach_here(); } if (file != stdout) fclose(file); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : 0; } static int cover_report_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "report", required_argument, 0, 'r' }, // DEPRECATED 1.14 { "output", required_argument, 0, 'o' }, { "exclude-file", required_argument, 0, 'e' }, { "dont-print", required_argument, 0, 'd' }, { "item-limit", required_argument, 0, 'l' }, { "per-file", no_argument, 0, 'f' }, { "verbose", no_argument, 0, 'V' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); const char *outdir = NULL, *exclude_file = NULL; int c, index; const char *spec = ":Vo:"; cover_mask_t rpt_mask = 0; int item_limit = 5000; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 'r': warnf("the $bold$--report$$ option is deprecated, use " "$bold$--output$$ instead"); // Fall-through case 'o': outdir = optarg; break; case 'e': exclude_file = optarg; break; case 'd': rpt_mask |= parse_cover_print_spec(optarg); break; case 'l': item_limit = parse_int(optarg); break; case 'f': rpt_mask |= COVER_MASK_PER_FILE_REPORT; break; case 'V': opt_set_int(OPT_VERBOSE, 1); break; case '?': bad_option("coverage report", argv); case ':': missing_argument("coverage report", argv); default: should_not_reach_here(); } } if (outdir == NULL) fatal("the output directory must be specified with $bold$--output$$"); progress("initialising"); cover_data_t *cover = merge_coverage_files(argc, next_cmd, argv, rpt_mask, MERGE_UNION); if (exclude_file && cover) { progress("loading exclude file %s", exclude_file); cover_load_exclude_file(exclude_file, cover); } progress("generating code coverage report"); cover_report(outdir, cover, item_limit); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : 0; } static int cover_merge_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "output", required_argument, 0, 'o' }, { "merge-mode", required_argument, 0, 'm' }, { "verbose", no_argument, 0, 'V' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); const char *out_db = NULL; int c, index; const char *spec = ":Vo:"; merge_mode_t mode = MERGE_UNION; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 'o': out_db = optarg; break; case 'm': mode = parse_cover_merge_mode(optarg); break; case 'V': opt_set_int(OPT_VERBOSE, 1); break; case '?': bad_option("coverage merge", argv); case ':': missing_argument("coverage merge", argv); default: should_not_reach_here(); } } if (out_db == NULL) fatal("the output database must be specified with $bold$--output$$"); progress("initialising"); cover_data_t *cover = merge_coverage_files(argc, next_cmd, argv, 0, mode); progress("saving merged coverage database to %s", out_db); fbuf_t *f = fbuf_open(out_db, FBUF_OUT, FBUF_CS_NONE); cover_dump_items(cover, f, COV_DUMP_PROCESSING, NULL); fbuf_close(f, NULL); argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : 0; } static int preprocess_cmd(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "define", required_argument, 0, 'D' }, { "single-unit", no_argument, 0, 'u' }, { 0, 0, 0, 0 } }; const int next_cmd = scan_cmd(2, argc, argv); int c, index; const char *spec = ":D:"; while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) { switch (c) { case 'u': opt_set_int(OPT_SINGLE_UNIT, 1); break; case 'D': parse_pp_define(optarg); break; case ':': missing_argument("preprocess", argv); case '?': default: bad_option("preprocess", argv); } } if (optind == next_cmd) fatal("no input files"); LOCAL_TEXT_BUF tb = tb_new(); for (int i = optind; i < next_cmd; i++) { input_from_file(argv[i]); tb_rewind(tb); vlog_preprocess(tb, false); fputs(tb_get(tb), stdout); } argc -= next_cmd - 1; argv += next_cmd - 1; return argc > 1 ? process_command(argc, argv, state) : 0; } static void usage(void) { color_printf("$!cyan$Usage:$$ $bold$%s [OPTION]... " "COMMAND [OPTION]...$$\n\n", PACKAGE); wrapped_printf("Global options are placed before COMMAND, and " "command-specific options are placed afterwards. " "Multiple commands can be given and will be performed " "in order.\n\n"); static const struct { const char *group; struct { const char *args; const char *usage; } options[16]; } groups[] = { { "Commands", { { "-a [OPTION]... FILE...", "Analyse FILEs into work library" }, { "-e [OPTION]... TOP", "Elaborate design unit TOP" }, { "-r [OPTION]... TOP", "Execute previously elaborated TOP" }, #ifdef ENABLE_TCL { "-i [TOP]", "Launch interactive TCL shell" }, #endif { "--cover-export FILE...", "Export coverage database to external format" }, { "--cover-report FILE...", "Generate HTML report from coverage database" }, { "--cover-merge FILE...", "Merge multiple coverage databases" }, #ifdef ENABLE_TCL { "--do [TOP] FILE...", "Evaluate TCL script" }, #endif #ifdef ENABLE_GUI { "--gui", "Launch browser-based GUI" }, #endif { "--init", "Initialise work library directory" }, { "--install PKG", "Install third-party packages" }, { "--list", "Print all units in the library" }, { "--preprocess FILE...", "Expand FILEs with Verilog preprocessor" }, { "--print-deps [UNIT]...", "Print dependencies in Makefile format" }, } }, { "Global options", { { "-h, --help", "Display this message and exit" }, { "-H SIZE", "Set the maximum heap size to SIZE bytes" }, { "--ieee-warnings={on,off,off-at-0}", "Enable or disable warnings from IEEE packages" }, { "--ignore-time", "Skip source file timestamp check" }, { "--load=PLUGIN", "Load VHPI plugin at startup" }, { "-L PATH", "Add PATH to library search paths" }, { "-M SIZE", "Limit design unit heap space to SIZE bytes" }, { "--map=LIB:PATH", "Map library LIB to PATH" }, { "--messages={full,compact}", "Diagnostic message style, compact is less verbose" }, { "--seed=N", "Seed for random number generation" }, { "--std={1993,..,2019}", "VHDL standard revision to use" }, { "--stderr={note,warning,error,failure}", "Print messages of this severity level or higher to stderr" }, { "-v, --version", "Display version and copyright information" }, { "--vhpi-debug", "Report VHPI errors as diagnostic messages" }, { "--vhpi-trace", "Trace VHPI calls and events" }, { "--work=NAME", "Use NAME as the work library" }, } }, { "Analysis options", { { "--bootstrap", "Allow compilation of STANDARD package" }, { "--check-synthesis", "Warn on common synthesis mistakes" }, { "-D, --define NAME=VALUE", "Set preprocessor symbol NAME to VALUE" }, { "--error-limit=NUM", "Stop after NUM errors" }, { "-f, --files=LIST", "Read files to analyse from LIST" }, { "--no-save", "Do not save analysed design units" }, { "--preserve-case", "Preserve the original case of VHDL identifiers" }, { "--psl", "Enable parsing of PSL directives in comments" }, { "--relaxed", "Disable certain pedantic rule checks" }, { "--single-unit", "Treat all Verilog files as a single compilation unit" }, } }, { "Elaboration options", { { "--cover[={statement,branch,expression,toggle,...}]", "Enable code coverage collection" }, { "--cover-file=FILE", "Set the file name of the coverage database" }, { "--cover-spec=FILE", "Fine-grained coverage collection specification, see the manual " "for details" }, { "-g NAME=VALUE", "Set top level generic NAME to VALUE" }, { "-j, --jit", "Enable just-in-time compilation during simulation" }, { "-O0, -O1, -O2, -O3", "Set optimisation level (default is -O2)" }, { "--no-collapse", "Do not collapse multiple signals into one" }, { "--no-save", "Do not save the elaborated design to disk" }, { "-V, --verbose", "Print resource usage at each step" }, } }, { "Run options", { { "--dump-arrays[=N]", "Include nested arrays with up to N elements in waveform dump" }, { "--exclude=GLOB", "Exclude signals matching GLOB from waveform dump" }, { "--exit-severity={note,warning,error,failure}", "Exit after an assertion failure of this severity" }, { "--format={fst,vcd}", "Waveform dump format" }, { "--include=GLOB", "Include signals matching GLOB in waveform dump" }, { "--shuffle", "Run processes in random order" }, { "--stats", "Print time and memory usage at end of run" }, { "--stop-delta=N", "Stop after N delta cycles (default 10000)" }, { "--stop-after=T", "Stop after simulation time T (e.g. 5ns)" }, { "--trace", "Trace simulation events" }, { "-w, --wave[=FILE]", "Write waveform dump to FILE" }, } }, #ifdef ENABLE_GUI { "GUI options", { { "--init=CMDS", "Evaluate TCL commands on startup" }, { "--port=PORT", "Specify port for HTTP server" }, } }, #endif { "Coverage report options", { { "-o, --output=dir", "Output directory for HTML report" }, { "--exclude-file=FILE", "Apply exclude file when generating report, see manual for syntax" }, { "--dont-print={covered,uncovered,excluded}", "Exclude specified items from coverage report" }, { "--item-limit=LIMIT", "Display at most LIMIT items in a single report file " "(default 5000)" }, { "--per-file", "Create source file code coverage report." }, } }, { "Coverage merge options", { { "--merge-mode={union,intersect}", "Merge hierarchies by union or intersection, default is union" }, { "-o, --output=FILE", "Output database file name" }, } }, { "Coverage export options", { { "--format=FMT", "File format (must be 'cobertura')" }, { "-o, --output=FILE", "Output file name" }, { "--relative=PATH", "Strip PATH from prefix of absolute paths" }, } }, { "Install options", { { "--dest=DIR", "Compile libraries into directory DIR" } }, } }; const int right = MAX(60, terminal_width()); for (int i = 0; i < ARRAY_LEN(groups); i++) { color_printf("$bold$$cyan$%s:$$\n", groups[i].group); for (int j = 0; j < ARRAY_LEN(groups[i].options); j++) { const char *args = groups[i].options[j].args; const char *usage = groups[i].options[j].usage; if (args == NULL || usage == NULL) break; int col = 0; if (args[0] == '-' && args[1] == '-' && i > 0) col += color_printf(" $bold$%s$$ ", args); else col += color_printf(" $bold$%s$$ ", args); const int indent = i == 0 ? 30 : 20; if (col > indent) printf("\n%*.s", indent, ""); else col += printf("%*.s", indent - col, ""); col = indent; const char *p = usage, *begin = usage; for (; *p != '\0'; p++) { if (col + 1 >= right && p - begin + 1 < right - indent) { printf("\n%*s", indent, ""); col = indent + p - begin; } else if (isspace_iso88591(*p)) { fwrite(begin, 1, p - begin + 1, stdout); col++; begin = p + 1; } else ++col; } if (begin < p) fwrite(begin, 1, p - begin, stdout); printf("\n"); } printf("\n"); } LOCAL_TEXT_BUF tb = tb_new(); lib_print_search_paths(tb); color_printf("$!cyan$Library search paths:$$%s\n\n", tb_get(tb)); wrapped_printf("The full manual can be read with $bold$man 1 %s$$ and " "contains detailed explanations of the commands and options " "above as well as examples.\n", PACKAGE_NAME); color_printf("\nReport bugs at $link:%s\07%s$\n", PACKAGE_BUGREPORT, PACKAGE_BUGREPORT); } static vhdl_standard_t parse_standard(const char *str) { char *eptr = NULL; const int year = strtol(str, &eptr, 10); if ((eptr != NULL) && (*eptr == '\0')) { switch (year) { case 1987: case 87: fatal("VHDL standard 1076-1987 is not supported"); case 1993: case 93: return STD_93; case 2000: case 0: return STD_00; case 2002: case 2: return STD_02; case 2008: case 8: return STD_08; case 2019: case 19: return STD_19; } } fatal("invalid standard revision: %s (allowed 1993, 2000, 2002, " "2008, 2019)", str); } static message_style_t parse_message_style(const char *str) { if (strcmp(optarg, "full") == 0) return MESSAGE_FULL; else if (strcmp(optarg, "compact") == 0) return MESSAGE_COMPACT; fatal("invalid message style '%s' (allowed are 'full' and 'compact')", str); } static size_t parse_size(const char *str) { char *eptr; const ssize_t size = strtoll(str, &eptr, 0); if (size <= 0) fatal("invalid size '%s' (must be positive)", str); else if (*eptr == '\0') return size; else if (strcasecmp(eptr, "k") == 0) return size * 1024; else if (strcasecmp(eptr, "m") == 0) return size * 1024 * 1024; else if (strcasecmp(eptr, "g") == 0) return size * 1024 * 1024 * 1024; fatal("invalid size '%s' (expected a number with optional k, m, " "or g suffix)", str); } static void parse_library_map(char *str) { #ifdef __MINGW32__ char *split = strpbrk(str, ";:"); #else char *split = strchr(str, ':'); #endif if (split == NULL) fatal("invalid library map syntax '%s': use NAME:PATH", str); *split = '\0'; if (strcasecmp(str, "work") == 0) fatal("use --work option to specify work library name and path"); lib_add_map(str, split + 1); } static int process_command(int argc, char **argv, cmd_state_t *state) { static struct option long_options[] = { { "dump", no_argument, 0, 'd' }, { "make", no_argument, 0, 'm' }, // DEPRECATED 1.8 { "syntax", no_argument, 0, 's' }, // DEPRECATED 1.15 { "list", no_argument, 0, 'l' }, { "init", no_argument, 0, 'n' }, { "install", no_argument, 0, 'I' }, { "print-deps", no_argument, 0, 'P' }, { "do", no_argument, 0, 'D' }, { "cover-export", no_argument, 0, 'E' }, { "cover-merge", no_argument, 0, 'M' }, { "cover-report", no_argument, 0, 'p' }, { "preprocess", no_argument, 0, 'R' }, #ifdef ENABLE_GUI { "gui", no_argument, 0, 'g' }, #endif { 0, 0, 0, 0 } }; opterr = 0; optind = 1; int index = 0; const char *spec = "aerci"; switch (getopt_long(MIN(argc, 2), argv, spec, long_options, &index)) { case 'a': return analyse(argc, argv, state); case 'e': return elaborate(argc, argv, state); case 'r': return run_cmd(argc, argv, state); case 'c': // DEPRECATED 1.14 return coverage_cmd(argc, argv, state); case 'd': return dump_cmd(argc, argv, state); case 'm': return make_cmd(argc, argv, state); case 's': return syntax_cmd(argc, argv, state); case 'l': return list_cmd(argc, argv, state); case 'n': return init_cmd(argc, argv, state); case 'I': return install_cmd(argc, argv, state); case 'P': return print_deps_cmd(argc, argv, state); case 'D': return do_cmd(argc, argv, state); case 'i': return interact_cmd(argc, argv, state); case 'E': return cover_export_cmd(argc, argv, state); case 'M': return cover_merge_cmd(argc, argv, state); case 'p': return cover_report_cmd(argc, argv, state); case 'R': return preprocess_cmd(argc, argv, state); #ifdef ENABLE_GUI case 'g': return gui_cmd(argc, argv, state); #endif default: fatal("missing command, try $bold$%s --help$$ for usage", PACKAGE); return EXIT_FAILURE; } } int main(int argc, char **argv) { term_init(); thread_init(); set_default_options(); intern_strings(); register_signal_handlers(); mspace_stack_limit(MSPACE_CURRENT_FRAME); check_cpu_features(); atexit(fbuf_cleanup); static struct option long_options[] = { { "help", no_argument, 0, 'h' }, { "version", no_argument, 0, 'v' }, { "work", required_argument, 0, 'w' }, { "std", required_argument, 0, 's' }, { "messages", required_argument, 0, 'I' }, { "map", required_argument, 0, 'p' }, { "ieee-warnings", required_argument, 0, 'W' }, { "ignore-time", no_argument, 0, 'i' }, { "force-init", no_argument, 0, 'f' }, // DEPRECATED 1.7 { "stderr", required_argument, 0, 'E' }, { "load", required_argument, 0, 'l' }, { "vhpi-debug", no_argument, 0, 'D' }, { "vhpi-trace", no_argument, 0, 'T' }, { "seed", required_argument, 0, 'S' }, { 0, 0, 0, 0 } }; opterr = 0; const char *work_name = "work"; cmd_state_t state = {}; const int next_cmd = scan_cmd(1, argc, argv); int c, index = 0; const char *spec = ":hivL:M:P:G:H:"; while ((c = getopt_long(next_cmd, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case 'h': usage(); exit(EXIT_SUCCESS); case 'v': printf("%s\n%s\n", version_string, copy_string); exit(EXIT_SUCCESS); case 'w': work_name = optarg; break; case 'L': lib_add_search_path(optarg); break; case 's': set_standard(parse_standard(optarg)); state.user_set_std = true; break; case 'I': set_message_style(parse_message_style(optarg)); break; case 'p': parse_library_map(optarg); break; case 'i': opt_set_int(OPT_IGNORE_TIME, 1); break; case 'f': warnf("the --force-init option is deprecated and has no effect"); break; case 'M': opt_set_size(OPT_ARENA_SIZE, parse_size(optarg)); break; case 'P': case 'G': warnf("the -%c option is deprecated and has no effect (the new " "-H option sets a unified heap size)", c); break; case 'H': opt_set_size(OPT_HEAP_SIZE, parse_size(optarg)); break; case 'E': set_stderr_severity(parse_severity(optarg)); break; case 'l': state.plugins = optarg; break; case 'T': opt_set_str(OPT_PLI_TRACE, "1"); opt_set_int(OPT_PLI_DEBUG, 1); break; case 'D': opt_set_int(OPT_PLI_DEBUG, 1); break; case 'W': opt_set_int(OPT_IEEE_WARNINGS, parse_ieee_warnings(optarg)); break; case 'S': opt_set_int(OPT_RANDOM_SEED, parse_int(optarg)); break; case '?': bad_option("global", argv); case ':': missing_argument("global", argv); default: should_not_reach_here(); } } srand(opt_get_int(OPT_RANDOM_SEED)); state.work = lib_new(work_name); lib_set_work(state.work); argc -= next_cmd - 1; argv += next_cmd - 1; if (state.plugins != NULL) { state.vhpi = vhpi_context_new(); vhpi_load_plugins(state.plugins); } const int ret = process_command(argc, argv, &state); if (state.model != NULL) model_free(state.model); if (state.jit != NULL) jit_free(state.jit); // JIT must be shut down before exiting if (state.registry != NULL) unit_registry_free(state.registry); if (state.mir != NULL) mir_context_free(state.mir); return ret; } nvc-r1.17.1/src/object.c000066400000000000000000001222021504111170000147370ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "fbuf.h" #include "hash.h" #include "ident.h" #include "object.h" #include "option.h" #include "thread.h" #include #include #include #include typedef uint64_t mark_mask_t; typedef A(object_arena_t *) arena_array_t; typedef A(object_t **) object_ptr_array_t; typedef enum { OBJ_DISK, OBJ_FRESH } obj_src_t; typedef struct _object_arena { void *base; void *alloc; void *limit; uint32_t *forward; mark_mask_t *mark_bits; size_t mark_sz; size_t mark_low; size_t mark_high; uint32_t live_bytes; uint32_t flags; generation_t generation; arena_key_t key; arena_array_t deps; object_t *root; obj_src_t source; vhdl_standard_t std; uint32_t checksum; generation_t copygen; bool copyflag; bool frozen; bool obsolete; } object_arena_t; #if !ASAN_ENABLED #define OBJECT_UNMAP_UNUSED 1 #endif #define ITEM_IDENT (I_IDENT | I_IDENT2) #define ITEM_OBJECT (I_VALUE | I_SEVERITY | I_MESSAGE | I_TARGET \ | I_DELAY | I_REJECT | I_REF | I_FILE_MODE \ | I_NAME | I_SPEC | I_RESOLUTION \ | I_LEFT | I_RIGHT | I_TYPE | I_BASE | I_ELEM \ | I_DESIGNATED | I_RESULT | I_PRIMARY \ | I_GUARD | I_FOREIGN | I_CONSTRAINT) #define ITEM_OBJ_ARRAY (I_DECLS | I_STMTS | I_PORTS | I_GENERICS \ | I_WAVES | I_CONDS | I_TRIGGERS | I_PARAMS \ | I_GENMAPS | I_ASSOCS | I_CONTEXT \ | I_LITERALS | I_FIELDS | I_UNITS | I_CHARS \ | I_DIMS | I_RANGES | I_INDEXES | I_PARTS \ | I_PRAGMAS) #define ITEM_INT64 (I_POS | I_IVAL) #define ITEM_INT32 (I_SUBKIND | I_CLASS | I_FLAGS) #define ITEM_DOUBLE (I_DVAL) #define ITEM_NUMBER (I_NUMBER) static const char *item_text_map[] = { "I_IDENT", "I_VALUE", "I_PRIMARY", "I_GENERICS", "I_PORTS", "I_DECLS", "I_STMTS", "I_TARGET", "I_IVAL", "I_IDENT2", "I_SEVERITY", "I_GENMAPS", "I_PARAMS", "I_WAVES", "I_CONDS", "I_TYPE", "I_SUBKIND", "I_DELAY", "I_REJECT", "I_POS", "I_REF", "I_FILE_MODE", "I_ASSOCS", "I_CONTEXT", "I_TRIGGERS", "I_PARTS" , "I_CLASS", "I_RANGES", "I_NAME", "I_PRAGMAS", "I_DVAL", "I_SPEC", "I_FOREIGN", "I_INDEXES", "I_BASE", "I_ELEM", "I_DESIGNATED", "???", "I_RESOLUTION", "I_RESULT", "I_UNITS", "I_LITERALS", "I_DIMS", "I_FIELDS", "I_CLOCK", "I_GUARD", "???", "I_CHARS", "I_CONSTRAINT", "I_FLAGS", "???", "I_LEFT", "I_RIGHT", "I_NUMBER", "I_MESSAGE", }; static object_class_t *classes[4]; static uint32_t format_digest; static generation_t next_generation = 1; static arena_array_t all_arenas; static object_arena_t *global_arena = NULL; static chash_t *arena_lookup; static inline bool object_in_arena_p(object_arena_t *arena, object_t *object) { return (void *)object >= arena->base && (void *)object < arena->limit; } static inline object_arena_t *__object_arena(object_t *object) { assert(object->arena < all_arenas.count); assert(object->arena != 0); return all_arenas.items[object->arena]; } static ident_t object_arena_name(object_arena_t *arena) { if (arena->alloc > arena->base) { object_t *root = arena_root(arena); const object_class_t *class = classes[root->tag]; const imask_t has = class->has_map[root->kind]; if (has & I_IDENT) { const int n = __builtin_popcountll(has & (I_IDENT - 1)); return root->items[n].ident; } } return ident_new("???"); } static inline void zero_mark_bits(object_arena_t *arena, unsigned first, size_t count) { assert(first + count <= arena->mark_sz); assert(first > arena->mark_high || first + count <= arena->mark_low); if (count == 1) arena->mark_bits[first] = 0; else memset(arena->mark_bits + first, '\0', count * sizeof(uint64_t)); } static bool object_marked_p(object_t *object, generation_t generation) { object_arena_t *arena = __object_arena(object); const uintptr_t bit = ((void *)object - arena->base) >> OBJECT_ALIGN_BITS; const uintptr_t word = bit / 64; if (unlikely(arena->mark_bits == NULL)) { const size_t nbits = (arena->limit - arena->base) / OBJECT_ALIGN; arena->mark_sz = ALIGN_UP(nbits, 64) / 8; arena->mark_bits = xmalloc(arena->mark_sz); arena->mark_bits[word] = 0; arena->mark_low = arena->mark_high = word; arena->generation = generation; } else if (arena->generation != generation) { arena->mark_bits[word] = 0; arena->mark_low = arena->mark_high = word; arena->generation = generation; } // Lazy zeroing of mark bits helps performance with large arenas if (word < arena->mark_low) { zero_mark_bits(arena, word, arena->mark_low - word); arena->mark_low = word; } else if (word > arena->mark_high) { zero_mark_bits(arena, arena->mark_high + 1, word - arena->mark_high); arena->mark_high = word; } const uint64_t mask = UINT64_C(1) << (bit & 63); const bool marked = !!(arena->mark_bits[word] & mask); arena->mark_bits[word] |= mask; return marked; } void arena_set_checksum(object_arena_t *arena, uint32_t checksum) { arena->checksum = checksum; } object_t *arena_root(object_arena_t *arena) { return arena->root ?: (object_t *)arena->base; } bool arena_frozen(object_arena_t *arena) { return arena->frozen; } uint32_t arena_flags(object_arena_t *arena) { return arena->flags; } void arena_set_flags(object_arena_t *arena, uint32_t flags) { arena->flags |= flags; } void arena_set_obsolete(object_arena_t *arena, bool obsolete) { arena->obsolete = true; } object_arena_t *object_arena(object_t *object) { return __object_arena(object); } void __object_write_barrier(object_t *lhs, object_t *rhs) { const uintptr_t lhs_mask = (uintptr_t)lhs & ~OBJECT_PAGE_MASK; const uintptr_t rhs_mask = (uintptr_t)rhs & ~OBJECT_PAGE_MASK; if (lhs_mask == rhs_mask || rhs == NULL) return; else if (lhs->arena == rhs->arena) return; object_arena_t *larena = __object_arena(lhs); object_arena_t *rarena = __object_arena(rhs); assert(!larena->frozen); assert(rarena->frozen); for (unsigned i = 0; i < larena->deps.count; i++) { if (larena->deps.items[i] == rarena) return; } APUSH(larena->deps, rarena); } void object_lookup_failed(object_class_t *class, object_t *object, imask_t mask) { unsigned int item; for (item = 0; (mask & (UINT64_C(1) << item)) == 0; item++) ; assert(item < ARRAY_LEN(item_text_map)); diag_t *d = diag_new(DIAG_FATAL, &(object->loc)); diag_printf(d, "%s kind %s does not have item %s", class->name, class->kind_text_map[object->kind], item_text_map[item]); diag_set_consumer(NULL, NULL); diag_suppress(d, false); diag_emit(d); show_stacktrace(); fatal_exit(EXIT_FAILURE); } void obj_array_add(obj_array_t **a, object_t *o) { if (*a == NULL) { const int defsz = 8; *a = xmalloc_flex(sizeof(obj_array_t), defsz, sizeof(object_t *)); (*a)->count = 0; (*a)->limit = defsz; } else if ((*a)->count == (*a)->limit) { (*a)->limit *= 2; *a = xrealloc_flex(*a, sizeof(obj_array_t), (*a)->limit, sizeof(object_t *)); } (*a)->items[(*a)->count++] = o; } void obj_array_free(obj_array_t **a) { free(*a); *a = NULL; } void object_change_kind(const object_class_t *class, object_t *object, int kind) { if (kind == object->kind) return; bool allow = false; for (size_t i = 0; (class->change_allowed[i][0] != -1) && !allow; i++) { allow = (class->change_allowed[i][0] == object->kind) && (class->change_allowed[i][1] == kind); } if (!allow) fatal_trace("cannot change %s kind %s to %s", class->name, class->kind_text_map[object->kind], class->kind_text_map[kind]); const imask_t old_has = class->has_map[object->kind]; const imask_t new_has = class->has_map[kind]; const int old_nitems = __builtin_popcountll(old_has); const int new_nitems = __builtin_popcountll(new_has); const int max_items = MAX(old_nitems, new_nitems); item_t tmp[max_items]; memcpy(tmp, object->items, sizeof(item_t) * max_items); int op = 0, np = 0; for (imask_t mask = 1; np < new_nitems; mask <<= 1) { if ((old_has & mask) && (new_has & mask)) object->items[np++] = tmp[op++]; else if (old_has & mask) { if (ITEM_OBJ_ARRAY & mask) obj_array_free(&(tmp[op].obj_array)); ++op; } else if (new_has & mask) memset(&(object->items[np++]), '\0', sizeof(item_t)); } object->kind = kind; } static void object_init(object_class_t *class) { class->object_size = xmalloc_array(class->last_kind, sizeof(size_t)); assert(class->last_kind < (1 << (sizeof(uint8_t) * 8))); assert(class->tag < ARRAY_LEN(classes)); classes[class->tag] = class; #ifdef DEBUG imask_t all_items = 0; #endif for (int i = 0; i < class->last_kind; i++) { const int nitems = __builtin_popcountll(class->has_map[i]); class->object_size[i] = sizeof(object_t) + (nitems * sizeof(item_t)); DEBUG_ONLY(all_items |= class->has_map[i]); format_digest += knuth_hash(class->has_map[i] >> 32); format_digest += knuth_hash(class->has_map[i]); } bool changed = false; do { changed = false; for (int i = 0; i < class->last_kind; i++) { size_t max_size = class->object_size[i]; for (size_t j = 0; class->change_allowed[j][0] != -1; j++) { if (class->change_allowed[j][0] == i) max_size = MAX(max_size, class->object_size[class->change_allowed[j][1]]); else if (class->change_allowed[j][1] == i) max_size = MAX(max_size, class->object_size[class->change_allowed[j][0]]); } if (max_size != class->object_size[i]) { class->object_size[i] = max_size; changed = true; } } } while (changed); #ifdef DEBUG if (getenv("NVC_TREE_SIZES") != NULL) { for (int i = 0; i < class->last_kind; i++) printf("%-15s %d\n", class->kind_text_map[i], (int)class->object_size[i]); } const imask_t known_types = ITEM_IDENT | ITEM_OBJECT | ITEM_OBJ_ARRAY | ITEM_INT64 | ITEM_INT32 | ITEM_DOUBLE | ITEM_NUMBER; const imask_t missing = all_items & ~known_types; if (missing != 0) { int item; for (item = 0; (missing & (UINT64_C(1) << item)) == 0; item++) ; assert(item < ARRAY_LEN(item_text_map)); fatal_trace("item %s does not have a type", item_text_map[item]); } #endif } static void check_frozen_object_fault(int sig, void *addr, struct cpu_state *cpu, void *context) { if (sig != SIGSEGV) return; for (unsigned i = 1; i < all_arenas.count; i++) { object_arena_t *arena = AGET(all_arenas, i); if (!arena->frozen) continue; else if (addr < arena->base) continue; else if (addr >= arena->limit) continue; fatal_trace("Write to object in frozen arena %s [address=%p]", istr(object_arena_name(arena)), addr); } } static void object_one_time_init(void) { INIT_ONCE({ extern object_class_t tree_object; object_init(&tree_object); extern object_class_t type_object; object_init(&type_object); extern object_class_t vlog_object; object_init(&vlog_object); extern object_class_t psl_object; object_init(&psl_object); // Increment this each time a incompatible change is made to // the on-disk format not expressed in the object items table const uint32_t format_fudge = 45; format_digest += format_fudge * UINT32_C(2654435761); add_fault_handler(check_frozen_object_fault, NULL); arena_lookup = chash_new(64); }); } static bool is_gc_root(const object_class_t *class, int kind) { for (int j = 0; j < class->gc_num_roots; j++) { if (class->gc_roots[j] == kind) return true; } return false; } object_t *object_new(object_arena_t *arena, const object_class_t *class, int kind) { if (unlikely(kind >= class->last_kind)) fatal_trace("invalid kind %d for %s object", kind, class->name); object_one_time_init(); if (arena == NULL) arena = global_arena; if (unlikely(arena == NULL)) fatal_trace("allocating object without active arena"); const size_t size = ALIGN_UP(class->object_size[kind], OBJECT_ALIGN); assert(((uintptr_t)arena->alloc & (OBJECT_ALIGN - 1)) == 0); if (unlikely(arena->limit - arena->alloc < size)) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); diag_printf(d, "memory exhausted while creating unit %s", istr(object_arena_name(arena))); diag_hint(d, NULL, "The current limit is %zu bytes which you can " "increase with the $bold$-M$$ option, for example " "$bold$-M 32m$$", object_arena_default_size()); diag_emit(d); fatal_exit(EXIT_FAILURE); } object_t *object = arena->alloc; arena->alloc = (char *)arena->alloc + size; if (arena->root == NULL && is_gc_root(class, kind)) arena->root = object; memset(object, '\0', size); object->kind = kind; object->tag = class->tag; object->arena = arena->key; object->loc = LOC_INVALID; return object; } static void gc_mark_from_root(object_t *object, object_arena_t *arena, generation_t generation) { if (object == NULL) return; else if (!object_in_arena_p(arena, object)) return; else if (object_marked_p(object, generation)) return; const object_class_t *class = classes[object->tag]; imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; item_t *item = &(object->items[n]); if (ITEM_OBJECT & mask) gc_mark_from_root(item->object, arena, generation); else if (ITEM_OBJ_ARRAY & mask) { if (item->obj_array != NULL) { for (unsigned j = 0; j < item->obj_array->count; j++) gc_mark_from_root(item->obj_array->items[j], arena, generation); } } } } static void gc_free_external(object_t *object) { const object_class_t *class = classes[object->tag]; imask_t has = class->has_map[object->kind]; if ((has & ITEM_OBJ_ARRAY) == 0) return; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; item_t *item = &(object->items[n]); if (ITEM_OBJ_ARRAY & mask) obj_array_free(&(item->obj_array)); } } static void object_arena_gc(object_arena_t *arena) { const generation_t generation = object_next_generation(); const uint64_t start_ticks = get_timestamp_us(); // Mark for (void *p = arena->base; p != arena->alloc; ) { assert(p < arena->alloc); object_t *object = p; const object_class_t *class = classes[object->tag]; if (is_gc_root(class, object->kind)) gc_mark_from_root(object, arena, generation); const size_t size = ALIGN_UP(class->object_size[object->kind], OBJECT_ALIGN); p = (char *)p + size; } const size_t fwdsz = (arena->alloc - arena->base) / OBJECT_ALIGN; uint32_t *forward = xmalloc_array(fwdsz, sizeof(uint32_t)); // Must initialise here for the search in object_from_locus memset(forward, 0xff, fwdsz * sizeof(uint32_t)); // Calculate forwarding addresses unsigned woffset = 0, live = 0, dead = 0; for (void *rptr = arena->base; rptr != arena->alloc; ) { assert(rptr < arena->alloc); object_t *object = rptr; const object_class_t *class = classes[object->tag]; const size_t size = ALIGN_UP(class->object_size[object->kind], OBJECT_ALIGN); ptrdiff_t index = (rptr - arena->base) >> OBJECT_ALIGN_BITS; if (!object_marked_p(object, generation)) { forward[index] = UINT32_MAX; gc_free_external(object); dead++; } else { forward[index] = woffset; woffset += size; live++; } rptr = (char *)rptr + size; } if (woffset == 0) fatal_trace("GC removed all objects from arena %s", istr(object_arena_name(arena))); arena->forward = forward; arena->live_bytes = woffset; if (opt_get_verbose(OPT_OBJECT_VERBOSE, NULL)) { const int ticks = get_timestamp_us() - start_ticks; debugf("GC: %s: freed %d objects; %d allocated [%d us]", istr(object_arena_name(arena)), dead, live, ticks); } } void object_visit(object_t *object, object_visit_ctx_t *ctx) { // If `deep' then will follow links above the tree originally passed // to tree_visit - e.g. following references back to their declarations if (object == NULL) return; else if (object_marked_p(object, ctx->generation)) return; const object_class_t *class = classes[object->tag]; const bool visit = (object->tag == ctx->tag && object->kind == ctx->kind) || ctx->kind == class->last_kind; if (visit && ctx->preorder != NULL) (*ctx->preorder)(object, ctx->context); const imask_t deep_mask = ~(ctx->deep ? 0 : I_TYPE | I_REF); imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; if (mask & deep_mask) { item_t *item = &(object->items[n]); if (ITEM_OBJECT & mask) object_visit(item->object, ctx); else if (ITEM_OBJ_ARRAY & mask) { if (item->obj_array != NULL) { for (unsigned j = 0; j < item->obj_array->count; j++) object_visit(item->obj_array->items[j], ctx); } } } } if (visit) { if (ctx->postorder != NULL) (*ctx->postorder)(object, ctx->context); ctx->count++; } } static object_t *object_rewrite_iter(object_t *object, object_rewrite_ctx_t *ctx) { // The callback may return a new object or a pointer to an existing // object in the same arena that that needs to be rewritten so // iterate rewriting until we reach a fixed point object_t *new = (*ctx->post_fn[object->tag])(object, ctx->context); if (new == object) return new; else return object_rewrite(new, ctx); } object_t *object_rewrite(object_t *object, object_rewrite_ctx_t *ctx) { if (object == NULL) return NULL; if (!object_in_arena_p(ctx->arena, object)) return object; const ptrdiff_t index = ((void *)object - ctx->arena->base) >> OBJECT_ALIGN_BITS; // New objects can be allocated while rewrite is in progress so we // need to check if the index is greater than the current cache size if (unlikely(ctx->cache == NULL || index >= ctx->cache_sz)) { ctx->cache_sz = (ctx->arena->alloc - ctx->arena->base) / OBJECT_ALIGN; ctx->cache = xrealloc_array(ctx->cache, sizeof(object_t *), ctx->cache_sz); } if (object_marked_p(object, ctx->generation)) { if (ctx->cache[index] == (object_t *)-1) { // Found a circular reference: eagerly rewrite the object now // and break the cycle if (ctx->post_fn[object->tag] != NULL) { if (ctx->pre_fn[object->tag] != NULL) (*ctx->pre_fn[object->tag])(object, ctx->context); object_t *new = object_rewrite_iter(object, ctx); object_write_barrier(object, new); return (ctx->cache[index] = new); } else return (ctx->cache[index] = object); } else { // Already rewritten this tree so return the cached version return ctx->cache[index]; } } ctx->cache[index] = (object_t *)-1; // Rewrite in progress marker if (ctx->pre_fn[object->tag] != NULL) (*ctx->pre_fn[object->tag])(object, ctx->context); const imask_t skip_mask = I_REF | ITEM_INT64 | ITEM_INT32 | ITEM_DOUBLE | ITEM_NUMBER | ITEM_IDENT; const object_class_t *class = classes[object->tag]; imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; if (mask & ~skip_mask) { if (ITEM_OBJECT & mask) { object_t *o = object_rewrite(object->items[n].object, ctx); object->items[n].object = o; object_write_barrier(object, o); } else if (ITEM_OBJ_ARRAY & mask) { obj_array_t **a = &(object->items[n].obj_array); if (object->items[n].obj_array != NULL) { // The callback may add new items to the array so the // array pointer cannot be cached between iterations unsigned wptr = 0; for (size_t i = 0; i < object->items[n].obj_array->count; i++) { object_t *o = object->items[n].obj_array->items[i]; if ((o = object_rewrite(o, ctx))) { object_write_barrier(object, o); object->items[n].obj_array->items[wptr++] = o; } } if (wptr == 0) obj_array_free(a); else (*a)->count = wptr; } } else should_not_reach_here(); } } if (ctx->cache[index] != (object_t *)-1) { // The cache was already updated due to a circular reference return ctx->cache[index]; } else if (ctx->post_fn[object->tag] != NULL) { object_t *new = object_rewrite_iter(object, ctx); object_write_barrier(object, new); return (ctx->cache[index] = new); } else return (ctx->cache[index] = object); } static void object_write_ref(object_t *object, fbuf_t *f) { if (object == NULL) fbuf_put_uint(f, 0); else { object_arena_t *arena = __object_arena(object); assert(arena->key != 0); fbuf_put_uint(f, arena->key); ptrdiff_t index = ((void *)object - arena->base) >> OBJECT_ALIGN_BITS; if (arena->forward != NULL) fbuf_put_uint(f, arena->forward[index] >> OBJECT_ALIGN_BITS); else fbuf_put_uint(f, index); } } void object_write(object_t *root, fbuf_t *f, ident_wr_ctx_t ident_ctx, loc_wr_ctx_t *loc_ctx) { object_arena_t *arena = __object_arena(root); if (root != arena_root(arena)) fatal_trace("must write root object first"); else if (arena->source == OBJ_DISK) fatal_trace("writing arena %s originally read from disk", istr(object_arena_name(arena))); else if (!arena->frozen) fatal_trace("arena %s must be frozen before writing to disk", istr(object_arena_name(arena))); else if (arena->obsolete) fatal_trace("writing obsolete arena %s", istr(object_arena_name(arena))); write_u32(format_digest, f); fbuf_put_uint(f, standard()); fbuf_put_uint(f, ALIGN_UP(arena->live_bytes, OBJECT_PAGE_SZ)); fbuf_put_uint(f, arena->flags); fbuf_put_uint(f, arena->key); ident_write(object_arena_name(arena), ident_ctx); arena_key_t max_key = arena->key; for (unsigned i = 0; i < arena->deps.count; i++) max_key = MAX(max_key, arena->deps.items[i]->key); fbuf_put_uint(f, max_key); fbuf_put_uint(f, arena->deps.count); for (unsigned i = 0; i < arena->deps.count; i++) { fbuf_put_uint(f, arena->deps.items[i]->key); fbuf_put_uint(f, arena->deps.items[i]->std); fbuf_put_uint(f, arena->deps.items[i]->checksum); ident_write(object_arena_name(arena->deps.items[i]), ident_ctx); } for (void *p = arena->base, *next; p != arena->alloc; p = next) { assert(p < arena->alloc); object_t *object = p; object_class_t *class = classes[object->tag]; next = p + ALIGN_UP(class->object_size[object->kind], OBJECT_ALIGN); ptrdiff_t index = (p - arena->base) >> OBJECT_ALIGN_BITS; if (arena->forward[index] == UINT32_MAX) continue; // Dead object STATIC_ASSERT(OBJECT_TAG_COUNT <= 4); fbuf_put_uint(f, object->tag | (object->kind << 2)); if (class->has_loc) loc_write(&object->loc, loc_ctx); imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; item_t *item = &(object->items[n]); if (ITEM_IDENT & mask) ident_write(item->ident, ident_ctx); else if (ITEM_OBJECT & mask) object_write_ref(item->object, f); else if (ITEM_OBJ_ARRAY & mask) { if (item->obj_array != NULL) { const unsigned count = item->obj_array->count; fbuf_put_uint(f, count); for (unsigned i = 0; i < count; i++) object_write_ref(item->obj_array->items[i], f); } else fbuf_put_uint(f, 0); } else if (ITEM_INT64 & mask) fbuf_put_int(f, item->ival); else if (ITEM_INT32 & mask) fbuf_put_int(f, item->ival); else if (ITEM_DOUBLE & mask) write_double(item->dval, f); else if (ITEM_NUMBER & mask) number_write(item->number, f); else should_not_reach_here(); } } fbuf_put_uint(f, UINT16_MAX); // End of objects marker } static object_t *object_read_ref(fbuf_t *f, const arena_key_t *key_map) { arena_key_t key = fbuf_get_uint(f); if (key == 0) return NULL; arena_key_t mapped = key_map[key]; ptrdiff_t offset = fbuf_get_uint(f) << OBJECT_ALIGN_BITS; if (unlikely(mapped == 0)) fatal_trace("%s missing dependency with key %d", fbuf_file_name(f), key); assert(mapped < all_arenas.count); assert(mapped > 0); object_arena_t *arena = all_arenas.items[mapped]; assert(!arena->frozen || offset < arena->alloc - arena->base); return (object_t *)((char *)arena->base + offset); } object_t *object_read(fbuf_t *f, object_load_fn_t loader_fn, ident_rd_ctx_t ident_ctx, loc_rd_ctx_t *loc_ctx) { object_one_time_init(); const uint32_t ver = read_u32(f); if (ver != format_digest) fatal("%s: serialised format digest is %x expected %x. This design " "unit uses a library format from an earlier version of " PACKAGE_NAME " and should be reanalysed.", fbuf_file_name(f), ver, format_digest); const vhdl_standard_t std = fbuf_get_uint(f); // If this is the first design unit we've loaded then allow it to set // the default standard if (all_arenas.count == 0) set_default_standard(std); if (std > standard()) fatal("%s: design unit was analysed using standard revision %s which " "is more recent that the currently selected standard %s", fbuf_file_name(f), standard_text(std), standard_text(standard())); const unsigned size = fbuf_get_uint(f); if (size & OBJECT_PAGE_MASK) fatal("%s: arena size %x bad alignment", fbuf_file_name(f), size); object_arena_t *arena = object_arena_new(size, std); arena->source = OBJ_DISK; arena->flags = fbuf_get_uint(f); arena_key_t key = fbuf_get_uint(f); ident_t name = ident_read(ident_ctx); arena_key_t max_key = fbuf_get_uint(f); arena_key_t *key_map LOCAL = xcalloc_array(max_key + 1, sizeof(arena_key_t)); key_map[key] = arena->key; const int ndeps = fbuf_get_uint(f); for (int i = 0; i < ndeps; i++) { arena_key_t dkey = fbuf_get_uint(f); vhdl_standard_t dstd = fbuf_get_uint(f); uint32_t checksum = fbuf_get_uint(f); ident_t dep = ident_read(ident_ctx); object_arena_t *a = NULL; for (unsigned j = 1; a == NULL && j < all_arenas.count; j++) { if (dep == object_arena_name(all_arenas.items[j])) a = all_arenas.items[j]; } if (a == NULL) { object_t *droot = NULL; if (loader_fn) droot = (*loader_fn)(dep); if (droot == NULL) fatal("%s depends on %s which cannot be found", fbuf_file_name(f), istr(dep)); a = __object_arena(droot); } if (a->std != dstd) fatal("%s: design unit depends on %s version of %s but conflicting " "%s version has been loaded", fbuf_file_name(f), standard_text(dstd), istr(dep), standard_text(a->std)); else if (a->checksum != checksum) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); diag_printf(d, "%s: design unit depends on %s with checksum %08x " "but the current version in the library has checksum %08x", fbuf_file_name(f), istr(dep), checksum, a->checksum); diag_hint(d, NULL, "this usually means %s is outdated and needs to " "be reanalysed", istr(name)); diag_emit(d); fatal_exit(EXIT_FAILURE); } APUSH(arena->deps, a); assert(dkey <= max_key); key_map[dkey] = a->key; } for (;;) { const uint64_t hdr = fbuf_get_uint(f); if (hdr == UINT16_MAX) break; const unsigned tag = hdr & 3; const unsigned kind = hdr >> 2; assert(tag < OBJECT_TAG_COUNT); const object_class_t *class = classes[tag]; object_t *object = object_new(arena, class, kind); if (class->has_loc) loc_read(&(object->loc), loc_ctx); imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; item_t *item = &(object->items[n]); if (ITEM_IDENT & mask) item->ident = ident_read(ident_ctx); else if (ITEM_OBJECT & mask) item->object = object_read_ref(f, key_map); else if (ITEM_OBJ_ARRAY & mask) { const unsigned count = fbuf_get_uint(f); if (count > 0) { item->obj_array = xmalloc_flex(sizeof(obj_array_t), count, sizeof(object_t *)); item->obj_array->count = item->obj_array->limit = count; for (unsigned i = 0; i < count; i++) { object_t *o = object_read_ref(f, key_map); item->obj_array->items[i] = o; } } } else if ((ITEM_INT64 | ITEM_INT32) & mask) item->ival = fbuf_get_int(f); else if (ITEM_DOUBLE & mask) item->dval = read_double(f); else if (ITEM_NUMBER & mask) item->number = number_read(f); else should_not_reach_here(); } } assert(ALIGN_UP(arena->alloc - arena->base, OBJECT_PAGE_SZ) == size); object_arena_freeze(arena); return (object_t *)arena->base; } unsigned object_next_generation(void) { return next_generation++; } static bool object_copy_mark(object_t *object, object_copy_ctx_t *ctx) { if (object == NULL) return false; object_arena_t *arena = __object_arena(object); if (arena->copygen != ctx->generation || !arena->copyflag) return false; if (ctx->copy_map == NULL) ctx->copy_map = hash_new(1024); if (object_marked_p(object, ctx->generation)) return hash_get(ctx->copy_map, object) != NULL; const object_class_t *class = classes[object->tag]; bool marked = false; if (ctx->should_copy[object->tag] != NULL) marked = (*ctx->should_copy[object->tag])(object, ctx->pred_context); object_t *copy = NULL; if (marked) { copy = object_new(global_arena, class, object->kind); hash_put(ctx->copy_map, object, copy); } imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; item_t *item = &(object->items[n]); if (ITEM_OBJECT & mask) marked |= object_copy_mark(item->object, ctx); else if (ITEM_OBJ_ARRAY & mask) { if (item->obj_array != NULL) { for (unsigned i = 0; i < item->obj_array->count; i++) { object_t *o = item->obj_array->items[i]; marked |= object_copy_mark(o, ctx); } } } } if (marked && copy == NULL) { copy = object_new(global_arena, class, object->kind); hash_put(ctx->copy_map, object, copy); } return marked; } static object_t *object_copy_map(object_t *object, object_copy_ctx_t *ctx) { if (object == NULL) return NULL; object_t *map = hash_get(ctx->copy_map, object); return map ?: object; } static bool object_copy_root_closure(object_arena_t *a, object_copy_ctx_t *ctx) { bool include = false; if (a->copygen == ctx->generation) return a->copyflag; for (int i = 0; i < ctx->nroots; i++) include |= (__object_arena(ctx->roots[i]) == a); for (int i = 0; i < a->deps.count; i++) include |= object_copy_root_closure(a->deps.items[i], ctx); a->copygen = ctx->generation; a->copyflag = include; return include; } void object_copy(object_copy_ctx_t *ctx) { for (int i = 0; i < ctx->nroots; i++) { object_arena_t *a = __object_arena(ctx->roots[i]); object_copy_root_closure(a, ctx); } for (int i = 0; i < ctx->nroots; i++) (void)object_copy_mark(ctx->roots[i], ctx); unsigned ncopied = 0; const void *key; void *value; for (hash_iter_t it = HASH_BEGIN; hash_iter(ctx->copy_map, &it, &key, &value); ) { const object_t *object = key; object_t *copy = value; ncopied++; copy->loc = object->loc; const object_class_t *class = classes[object->tag]; imask_t has = class->has_map[object->kind]; for (int n = 0; has; has &= has - 1, n++) { const uint64_t mask = has & -has; const item_t *from = &(object->items[n]); item_t *to = &(copy->items[n]); if (ITEM_IDENT & mask) to->ident = from->ident; else if (ITEM_OBJECT & mask) { to->object = object_copy_map(from->object, ctx); object_write_barrier(copy, to->object); } else if (ITEM_DOUBLE & mask) to->dval = from->dval; else if (ITEM_OBJ_ARRAY & mask) { if (from->obj_array != NULL) { // TODO: make a resize macro to->obj_array = xmalloc_flex(sizeof(obj_array_t), from->obj_array->count, sizeof(object_t *)); to->obj_array->count = to->obj_array->limit = from->obj_array->count; for (size_t i = 0; i < from->obj_array->count; i++) { object_t *o = object_copy_map(from->obj_array->items[i], ctx); to->obj_array->items[i] = o; object_write_barrier(copy, o); } } } else if ((ITEM_INT64 | ITEM_INT32) & mask) to->ival = from->ival; else should_not_reach_here(); } } for (hash_iter_t it = HASH_BEGIN; hash_iter(ctx->copy_map, &it, &key, &value); ) { object_t *copy = value; if (ctx->callback[copy->tag] != NULL) (*ctx->callback[copy->tag])(copy, ctx->callback_context); } if (opt_get_verbose(OPT_OBJECT_VERBOSE, NULL)) debugf("copied %d objects into arena %s", ncopied, istr(object_arena_name(global_arena))); for (unsigned i = 0; i < ctx->nroots; i++) { object_t *copy = hash_get(ctx->copy_map, ctx->roots[i]); if (copy != NULL) ctx->roots[i] = copy; } hash_free(ctx->copy_map); } size_t object_arena_default_size(void) { return ALIGN_UP(opt_get_size(OPT_ARENA_SIZE), OBJECT_PAGE_SZ); } object_arena_t *object_arena_new(size_t size, unsigned std) { if (all_arenas.count == 0) APUSH(all_arenas, NULL); // Dummy null arena object_arena_t *arena = xcalloc(sizeof(object_arena_t)); arena->base = nvc_memalign(OBJECT_PAGE_SZ, size); arena->alloc = arena->base; arena->limit = (char *)arena->base + size; arena->key = all_arenas.count; arena->source = OBJ_FRESH; arena->std = std; APUSH(all_arenas, arena); if (all_arenas.count == UINT16_MAX - 1) fatal_trace("too many object arenas"); return arena; } void object_arena_freeze(object_arena_t *arena) { ident_t name = object_arena_name(arena); if (arena->frozen) fatal_trace("arena %s already frozen", istr(name)); if (arena->source == OBJ_FRESH) object_arena_gc(arena); if (opt_get_verbose(OPT_OBJECT_VERBOSE, NULL)) debugf("arena %s frozen (%d bytes)", istr(name), (int)(arena->alloc - arena->base)); chash_put(arena_lookup, name, arena); void *next_page = ALIGN_UP(arena->alloc, OBJECT_PAGE_SZ); nvc_memprotect(arena->base, next_page - arena->base, MEM_RO); if (next_page < arena->limit) { #if OBJECT_UNMAP_UNUSED nvc_munmap(next_page, arena->limit - next_page); arena->limit = next_page; #else // This can be useful for debugging use-after-free nvc_decommit(next_page, arena->limit - next_page); nvc_memprotect(next_page, arena->limit - next_page, MEM_NONE); #endif } arena->frozen = true; } void arena_walk_deps(object_arena_t *arena, arena_deps_fn_t fn, void *context) { for (unsigned i = 0; i < arena->deps.count; i++) (*fn)(object_arena_name(arena->deps.items[i]), context); } void arena_walk_obsolete_deps(object_arena_t *arena, arena_deps_fn_t fn, void *context) { for (unsigned i = 0; i < arena->deps.count; i++) { if (arena->deps.items[i]->obsolete) (*fn)(object_arena_name(arena->deps.items[i]), context); } } void object_locus(object_t *object, ident_t *module, ptrdiff_t *offset) { object_arena_t *arena = __object_arena(object); assert(arena->frozen); *module = object_arena_name(arena); const ptrdiff_t index = ((void *)object - arena->base) >> OBJECT_ALIGN_BITS; if (arena->forward != NULL) *offset = arena->forward[index] >> OBJECT_ALIGN_BITS; else *offset = index; } static object_arena_t *arena_by_name(ident_t module) { if (global_arena != NULL && object_arena_name(global_arena) == module) return global_arena; object_arena_t *a = chash_get(arena_lookup, module); if (a != NULL) return a; #if defined DEBUG && !defined __SANITIZE_THREAD__ for (int i = 1; i < all_arenas.count; i++) assert(module != object_arena_name(all_arenas.items[i])); #endif return NULL; } object_t *object_from_locus(ident_t module, ptrdiff_t offset, object_load_fn_t loader) { object_arena_t *arena = arena_by_name(module); if (arena == NULL) { object_t *droot = NULL; if (loader) droot = (*loader)(module); if (droot == NULL) fatal("cannot find object locus %s%+"PRIiPTR, istr(module), offset); arena = __object_arena(droot); } assert(arena->frozen); void *ptr = NULL; if (arena->forward != NULL) { // TODO: could do binary search here for (int i = 0; i < (arena->alloc - arena->base) / OBJECT_ALIGN; i++) { if (arena->forward[i] == offset << OBJECT_ALIGN_BITS) { ptr = arena->base + (i << OBJECT_ALIGN_BITS); break; } } assert(ptr != NULL); } else ptr = arena->base + (offset << OBJECT_ALIGN_BITS); if (ptr > arena->limit) fatal_trace("invalid object locus %s%+"PRIiPTR, istr(module), offset); object_t *obj = ptr; if (obj->tag >= OBJECT_TAG_COUNT) fatal_trace("invalid tag %d for object locus %s%+"PRIiPTR, obj->tag, istr(module), offset); else if (obj->arena != arena->key) fatal_trace("invalid arena key %d != %d for object locus %s%+"PRIiPTR, obj->arena, arena->key, istr(module), offset); return obj; } void freeze_global_arena(void) { object_one_time_init(); if (global_arena != NULL) { object_arena_freeze(global_arena); global_arena = NULL; } } void make_new_arena(void) { freeze_global_arena(); global_arena = object_arena_new(object_arena_default_size(), standard()); } nvc-r1.17.1/src/object.h000066400000000000000000000216671504111170000147610ustar00rootroot00000000000000// // Copyright (C) 2013-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _OBJECT_H #define _OBJECT_H #include "util.h" #include "array.h" #include "diag.h" #include "prim.h" #include "vlog/vlog-number.h" #include // // Structures shared between tree and type objects // #define ONE_HOT(x) (UINT64_C(1) << (x)) typedef uint64_t imask_t; #define I_IDENT ONE_HOT(0) #define I_VALUE ONE_HOT(1) #define I_PRIMARY ONE_HOT(2) #define I_GENERICS ONE_HOT(3) #define I_PORTS ONE_HOT(4) #define I_DECLS ONE_HOT(5) #define I_STMTS ONE_HOT(6) #define I_TARGET ONE_HOT(7) #define I_IVAL ONE_HOT(8) #define I_IDENT2 ONE_HOT(9) #define I_SEVERITY ONE_HOT(10) #define I_GENMAPS ONE_HOT(11) #define I_PARAMS ONE_HOT(12) #define I_WAVES ONE_HOT(13) #define I_CONDS ONE_HOT(14) #define I_TYPE ONE_HOT(15) #define I_SUBKIND ONE_HOT(16) #define I_DELAY ONE_HOT(17) #define I_REJECT ONE_HOT(18) #define I_POS ONE_HOT(19) #define I_REF ONE_HOT(20) #define I_FILE_MODE ONE_HOT(21) #define I_ASSOCS ONE_HOT(22) #define I_CONTEXT ONE_HOT(23) #define I_TRIGGERS ONE_HOT(24) #define I_PARTS ONE_HOT(25) #define I_CLASS ONE_HOT(26) #define I_RANGES ONE_HOT(27) #define I_NAME ONE_HOT(28) #define I_PRAGMAS ONE_HOT(29) #define I_DVAL ONE_HOT(30) #define I_SPEC ONE_HOT(31) #define I_FOREIGN ONE_HOT(32) #define I_INDEXES ONE_HOT(33) #define I_BASE ONE_HOT(34) #define I_ELEM ONE_HOT(35) #define I_DESIGNATED ONE_HOT(36) // Unused ONE_HOT(37) #define I_RESOLUTION ONE_HOT(38) #define I_RESULT ONE_HOT(39) #define I_UNITS ONE_HOT(40) #define I_LITERALS ONE_HOT(41) #define I_DIMS ONE_HOT(42) #define I_FIELDS ONE_HOT(43) // Unused ONE_HOT(44) #define I_GUARD ONE_HOT(45) // Unused ONE_HOT(46) #define I_CHARS ONE_HOT(47) #define I_CONSTRAINT ONE_HOT(48) #define I_FLAGS ONE_HOT(49) // Unused ONE_HOT(50) #define I_LEFT ONE_HOT(51) #define I_RIGHT ONE_HOT(52) #define I_NUMBER ONE_HOT(53) #define I_MESSAGE ONE_HOT(54) enum { OBJECT_TAG_TREE = 0, OBJECT_TAG_TYPE = 1, OBJECT_TAG_VLOG = 2, OBJECT_TAG_PSL = 3, OBJECT_TAG_COUNT }; #define OBJECT_PAGE_SZ (1 << 16) #define OBJECT_PAGE_MASK (OBJECT_PAGE_SZ - 1) #define OBJECT_ALIGN_BITS 4 #define OBJECT_ALIGN (1 << OBJECT_ALIGN_BITS) STATIC_ASSERT(OBJECT_ALIGN >= sizeof(double)); #define lookup_item(class, t, mask) ({ \ assert((t) != NULL); \ assert((mask & (mask - 1)) == 0); \ \ const imask_t __has = has_map[(t)->object.kind]; \ \ if (unlikely((__has & (mask)) == 0)) \ object_lookup_failed((class), &(t)->object, mask); \ \ const imask_t __below = __has & ((mask) - 1); \ const int __n = __builtin_popcountll(__below); \ \ &((t)->object.items[__n]); \ }) typedef uint16_t generation_t; typedef uint16_t arena_key_t; typedef struct { unsigned count; unsigned limit; object_t *items[0]; } obj_array_t; #define obj_array_nth(a, n) ({ \ assert((a) != NULL); \ assert((n) < (a)->count); \ (a)->items[(n)]; \ }) #define obj_array_count(a) ({ \ obj_array_t *_a = (a); \ (_a == NULL ? 0 : _a->count); \ }) void obj_array_add(obj_array_t **a, object_t *o); typedef union { ident_t ident; object_t *object; obj_array_t *obj_array; int64_t ival; double dval; char *text; number_t number; } item_t; STATIC_ASSERT(sizeof(item_t) == 8); struct _object { uint8_t kind; uint8_t tag; arena_key_t arena; uint16_t __pad; loc_t loc; item_t items[0]; }; STATIC_ASSERT(sizeof(object_t) == 16); typedef bool (*object_copy_pred_t)(object_t *, void *); typedef bool (*object_copy_fn_t)(object_t *, void *); typedef struct { generation_t generation; object_copy_pred_t should_copy[OBJECT_TAG_COUNT]; object_copy_fn_t callback[OBJECT_TAG_COUNT]; void *pred_context; void *callback_context; hash_t *copy_map; unsigned nroots; object_t *roots[0]; } object_copy_ctx_t; typedef void (*object_rewrite_pre_fn_t)(object_t *, void *); typedef object_t *(*object_rewrite_post_fn_t)(object_t *, void *); typedef struct { object_t **cache; unsigned cache_sz; generation_t generation; object_rewrite_pre_fn_t pre_fn[OBJECT_TAG_COUNT]; object_rewrite_post_fn_t post_fn[OBJECT_TAG_COUNT]; void *context; object_arena_t *arena; } object_rewrite_ctx_t; typedef void (*object_visit_fn_t)(object_t *, void *); typedef struct { unsigned count; object_visit_fn_t preorder; object_visit_fn_t postorder; void *context; int kind; int tag; unsigned generation; bool deep; } object_visit_ctx_t; typedef int change_allowed_t[2]; typedef struct { const char *name; const change_allowed_t *change_allowed; const imask_t *has_map; const char **kind_text_map; const int tag; const int last_kind; const int gc_roots[10]; const int gc_num_roots; const bool has_loc; size_t *object_size; } object_class_t; typedef object_t *(*object_load_fn_t)(ident_t); __attribute__((noreturn, cold, noinline)) void object_lookup_failed(object_class_t *class, object_t *obj, imask_t mask); void object_change_kind(const object_class_t *class, object_t *object, int kind); object_t *object_new(object_arena_t *arena, const object_class_t *class, int kind); void object_visit(object_t *object, object_visit_ctx_t *ctx); object_t *object_rewrite(object_t *object, object_rewrite_ctx_t *ctx); unsigned object_next_generation(void); void object_copy(object_copy_ctx_t *ctx); object_arena_t *object_arena(object_t *object); size_t object_arena_default_size(void); object_t *arena_root(object_arena_t *arena); void arena_set_checksum(object_arena_t *arena, uint32_t checksum); bool arena_frozen(object_arena_t *arena); uint32_t arena_flags(object_arena_t *arena); void arena_set_flags(object_arena_t *arena, uint32_t flags); void arena_set_obsolete(object_arena_t *arena, bool obsolete); void object_write(object_t *object, fbuf_t *f, ident_wr_ctx_t ident_ctx, loc_wr_ctx_t *loc_ctx); object_t *object_read(fbuf_t *f, object_load_fn_t loader, ident_rd_ctx_t ident_ctx, loc_rd_ctx_t *loc_ctx); #define object_write_barrier(lhs, rhs) do { \ uintptr_t __lp = (uintptr_t)(lhs) & ~OBJECT_PAGE_MASK; \ uintptr_t __rp = (uintptr_t)(rhs) & ~OBJECT_PAGE_MASK; \ if (__lp != __rp && (rhs) != NULL) \ __object_write_barrier((lhs), (rhs)); \ } while (0); void __object_write_barrier(object_t *lhs, object_t *rhs); object_arena_t *object_arena_new(size_t size, unsigned std); void object_arena_freeze(object_arena_t *arena); typedef void (*arena_deps_fn_t)(ident_t, void *); void arena_walk_deps(object_arena_t *arena, arena_deps_fn_t fn, void *context); void arena_walk_obsolete_deps(object_arena_t *arena, arena_deps_fn_t fn, void *context); void object_locus(object_t *object, ident_t *module, ptrdiff_t *offset); object_t *object_from_locus(ident_t module, ptrdiff_t offset, object_load_fn_t loader); void make_new_arena(void); void freeze_global_arena(void); #endif // _OBJECT_H nvc-r1.17.1/src/option.c000066400000000000000000000132601504111170000150040ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "option.h" #include #include #include #include typedef enum { OPT_KIND_UNDEF, OPT_KIND_INT, OPT_KIND_STRING, OPT_KIND_SIZE, } option_kind_t; typedef union { int i; char *s; size_t z; } optval_t; typedef struct { option_kind_t kind; optval_t value; } option_t; static option_t options[OPT_LAST_NAME]; static void opt_set_generic(opt_name_t name, option_kind_t kind, optval_t value) { assert(name < OPT_LAST_NAME); option_t *o = &(options[name]); if (o->kind == OPT_KIND_STRING) free(o->value.s); o->value = value; o->kind = kind; } static inline optval_t opt_get_generic(opt_name_t name, option_kind_t kind) { assert(name < OPT_LAST_NAME); const option_t *o = &(options[name]); if (likely(o->kind == kind)) return o->value; else if (o->kind == OPT_KIND_UNDEF) fatal_trace("initial value for option %d not set", name); else fatal_trace("wrong option kind for %d", name); } void opt_set_int(opt_name_t name, int val) { opt_set_generic(name, OPT_KIND_INT, (optval_t){ .i = val }); } int opt_get_int(opt_name_t name) { return opt_get_generic(name, OPT_KIND_INT).i; } void opt_set_size(opt_name_t name, size_t val) { opt_set_generic(name, OPT_KIND_SIZE, (optval_t){ .z = val }); } size_t opt_get_size(opt_name_t name) { return opt_get_generic(name, OPT_KIND_SIZE).z; } void opt_set_str(opt_name_t name, const char *val) { opt_set_generic(name, OPT_KIND_STRING, (optval_t){ .s = val ? strdup(val) : NULL }); } const char *opt_get_str(opt_name_t name) { return opt_get_generic(name, OPT_KIND_STRING).s; } bool opt_get_verbose(opt_name_t name, const char *filter) { const char *value = opt_get_str(name); if (value == NULL || *value == '\0') return false; else if (isdigit((int)*value)) return true; else if (filter == NULL) return false; else if (value[0] == '^') return strcmp(value + 1, filter) == 0; else return strstr(filter, value) != NULL; } static int get_int_env(const char *var, int def) { const char *env = getenv(var); if (env == NULL) return def; return atoi(env); } void set_default_options(void) { opt_set_int(OPT_RT_STATS, 0); opt_set_int(OPT_RT_TRACE, 0); opt_set_str(OPT_PLI_TRACE, getenv("NVC_VHPI_VERBOSE")); opt_set_int(OPT_DUMP_LLVM, 0); opt_set_int(OPT_OPTIMISE, 2); opt_set_int(OPT_BOOTSTRAP, 0); opt_set_int(OPT_STOP_DELTA, 10000); opt_set_int(OPT_UNIT_TEST, 0); opt_set_int(OPT_MAKE_DEPS_ONLY, 0); opt_set_str(OPT_LOWER_VERBOSE, getenv("NVC_LOWER_VERBOSE")); opt_set_int(OPT_IGNORE_TIME, 0); opt_set_int(OPT_VERBOSE, 0); opt_set_int(OPT_MISSING_BODY, 1); opt_set_int(OPT_IEEE_WARNINGS, IEEE_WARNINGS_ON); opt_set_size(OPT_ARENA_SIZE, 1 << 24); opt_set_int(OPT_DUMP_ARRAYS, 0); opt_set_str(OPT_OBJECT_VERBOSE, getenv("NVC_OBJECT_VERBOSE")); opt_set_str(OPT_GC_VERBOSE, getenv("NVC_GC_VERBOSE") DEBUG_ONLY(?: "1")); opt_set_str(OPT_EVAL_VERBOSE, getenv("NVC_EVAL_VERBOSE")); opt_set_str(OPT_ELAB_VERBOSE, getenv("NVC_ELAB_VERBOSE")); opt_set_size(OPT_HEAP_SIZE, 16 * 1024 * 1024); opt_set_int(OPT_GC_STRESS, 0 DEBUG_ONLY(|| get_int_env("NVC_GC_STRESS", 0))); opt_set_int(OPT_RELAXED, 0); opt_set_str(OPT_JIT_VERBOSE, getenv("NVC_JIT_VERBOSE")); opt_set_int(OPT_JIT_LOG, get_int_env("NVC_JIT_LOG", 0)); opt_set_int(OPT_NO_SAVE, 0); opt_set_str(OPT_LLVM_VERBOSE, getenv("NVC_LLVM_VERBOSE")); opt_set_int(OPT_JIT_THRESHOLD, get_int_env("NVC_JIT_THRESHOLD", 100)); opt_set_str(OPT_ASM_VERBOSE, getenv("NVC_ASM_VERBOSE")); opt_set_int(OPT_JIT_ASYNC, get_int_env("NVC_JIT_ASYNC", 1)); opt_set_int(OPT_PERF_MAP, get_int_env("NVC_PERF_MAP", 0)); opt_set_str(OPT_LIB_VERBOSE, getenv("NVC_LIB_VERBOSE")); opt_set_str(OPT_PSL_VERBOSE, getenv("NVC_PSL_VERBOSE")); opt_set_int(OPT_PSL_COMMENTS, 0); opt_set_int(OPT_NO_COLLAPSE, 0); opt_set_int(OPT_COVER_VERBOSE, get_int_env("NVC_COVER_VERBOSE", 0)); opt_set_int(OPT_COVER_TIMESTAMP, get_int_env("NVC_COVER_TIMESTAMP", -1)); opt_set_str(OPT_COVER_VERSION, getenv("NVC_COVER_VERSION")); opt_set_int(OPT_DRIVER_VERBOSE, get_int_env("NVC_DRIVER_VERBOSE", 0)); opt_set_int(OPT_JIT_INTRINSICS, get_int_env("NVC_JIT_INTRINSICS", 1)); opt_set_int(OPT_VECTOR_INTRINSICS, get_int_env("NVC_VECTOR_INTRINSICS", 1)); opt_set_int(OPT_SHUFFLE_PROCS, 0); opt_set_int(OPT_PLI_DEBUG, opt_get_str(OPT_PLI_TRACE) != NULL); opt_set_int(OPT_SERVER_PORT, 8888); opt_set_int(OPT_STDERR_LEVEL, DIAG_DEBUG); opt_set_int(OPT_CHECK_SYNTHESIS, 0); opt_set_int(OPT_MISSING_WAIT, 1); opt_set_int(OPT_LAYOUT_VERBOSE, get_int_env("NVC_LAYOUT_VERBOSE", 0)); opt_set_int(OPT_SINGLE_UNIT, 0); opt_set_int(OPT_PRESERVE_CASE, 0); opt_set_str(OPT_GVN_VERBOSE, getenv("NVC_GVN_VERBOSE")); opt_set_str(OPT_DCE_VERBOSE, getenv("NVC_DCE_VERBOSE")); opt_set_int(OPT_RANDOM_SEED, get_timestamp_us()); } nvc-r1.17.1/src/option.h000066400000000000000000000045041504111170000150120ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _OPTION_H #define _OPTION_H #include "prim.h" #include typedef enum { OPT_RT_STATS, OPT_PLI_TRACE, OPT_DUMP_LLVM, OPT_OPTIMISE, OPT_BOOTSTRAP, OPT_STOP_DELTA, OPT_UNIT_TEST, OPT_MAKE_DEPS_ONLY, OPT_LOWER_VERBOSE, OPT_IGNORE_TIME, OPT_VERBOSE, OPT_RT_TRACE, OPT_MISSING_BODY, OPT_IEEE_WARNINGS, OPT_ARENA_SIZE, OPT_DUMP_ARRAYS, OPT_GC_VERBOSE, OPT_EVAL_VERBOSE, OPT_ELAB_VERBOSE, OPT_HEAP_SIZE, OPT_OBJECT_VERBOSE, OPT_GC_STRESS, OPT_RELAXED, OPT_JIT_VERBOSE, OPT_JIT_LOG, OPT_NO_SAVE, OPT_LLVM_VERBOSE, OPT_JIT_THRESHOLD, OPT_ASM_VERBOSE, OPT_JIT_ASYNC, OPT_PERF_MAP, OPT_LIB_VERBOSE, OPT_PSL_VERBOSE, OPT_PSL_COMMENTS, OPT_NO_COLLAPSE, OPT_COVER_VERBOSE, OPT_COVER_TIMESTAMP, OPT_COVER_VERSION, OPT_DRIVER_VERBOSE, OPT_JIT_INTRINSICS, OPT_VECTOR_INTRINSICS, OPT_SHUFFLE_PROCS, OPT_PLI_DEBUG, OPT_SERVER_PORT, OPT_STDERR_LEVEL, OPT_CHECK_SYNTHESIS, OPT_MISSING_WAIT, OPT_LAYOUT_VERBOSE, OPT_SINGLE_UNIT, OPT_PRESERVE_CASE, OPT_GVN_VERBOSE, OPT_DCE_VERBOSE, OPT_RANDOM_SEED, OPT_LAST_NAME } opt_name_t; typedef enum { IEEE_WARNINGS_OFF, IEEE_WARNINGS_ON, IEEE_WARNINGS_OFF_AT_0 } ieee_warnings_t; void opt_set_int(opt_name_t name, int val); void opt_set_size(opt_name_t name, size_t val); void opt_set_str(opt_name_t name, const char *val); int opt_get_int(opt_name_t name); size_t opt_get_size(opt_name_t name); const char *opt_get_str(opt_name_t name); bool opt_get_verbose(opt_name_t name, const char *filter); void set_default_options(void); #endif // _OPTION_H nvc-r1.17.1/src/parse.c000066400000000000000000012335641504111170000146220ustar00rootroot00000000000000// // Copyright (C) 2014-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "inst.h" #include "lib.h" #include "names.h" #include "object.h" #include "option.h" #include "phase.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include "scan.h" #include "thread.h" #include "tree.h" #include "type.h" #include #include #include #include #include #include #include #include #include typedef struct { token_t token; yylval_t lval; loc_t loc; } tokenq_t; typedef bool (*look_fn_t)(token_t); typedef struct { token_t look[4]; token_t stop[4]; token_t abort; token_t nest_in; token_t nest_out; look_fn_t lookfn; int depth; } look_params_t; typedef A(tree_t) tree_list_t; typedef A(type_t) type_list_t; typedef struct _ident_list ident_list_t; struct _ident_list { ident_list_t *next; ident_t ident; loc_t loc; }; #define LOCAL_IDENT_LIST \ __attribute__((cleanup(_ident_list_cleanup))) ident_list_t * static loc_t start_loc; static loc_t last_loc; static const char *hint_str = NULL; static int n_correct = 0; static tokenq_t *tokenq; static int tokenq_sz; static int tokenq_head; static int tokenq_tail; static yylval_t last_lval; static token_t opt_hist[8]; static int nopt_hist = 0; static nametab_t *nametab = NULL; static bool bootstrapping = false; static tree_list_t pragmas = AINIT; extern loc_t yylloc; #define scan(...) _scan(1, __VA_ARGS__, -1) #define expect(...) _expect(1, __VA_ARGS__, -1) #define one_of(...) _one_of(1, __VA_ARGS__, -1) #define not_at_token(...) ((peek() != tEOF) && !_scan(1, __VA_ARGS__, -1)) #define peek() peek_nth(1) #define parse_error(loc, ...) do { \ if (n_correct >= RECOVER_THRESH) { \ error_at(loc, __VA_ARGS__); \ } \ } while (0) #define RECOVER_THRESH 5 #define TRACE_PARSE 0 #define WARN_LOOKAHEAD 0 #define TRACE_RECOVERY 0 #define STD(x, y) (standard() >= (STD_##x) ? y : -1) typedef void (*add_func_t)(tree_t, tree_t); typedef struct { const char *old_hint; loc_t old_start_loc; } state_t; #if TRACE_PARSE static int depth = 0; static void _push_state(const state_t *s); #else #define _push_state(s) #endif #define EXTEND(s) \ __attribute__((cleanup(_pop_state), unused)) \ const state_t _state = { hint_str, start_loc }; \ hint_str = s; \ _push_state(&_state); #define BEGIN_WITH_HEAD(s, t) \ EXTEND(s); \ start_loc = (t) ? *tree_loc(t) : LOC_INVALID; \ #define BEGIN(s) BEGIN_WITH_HEAD(s, NULL) #define CURRENT_LOC _diff_loc(&start_loc, &last_loc) static tree_t p_expression(void); static tree_t p_sequential_statement(void); static tree_t p_concurrent_statement(void); static tree_t p_package_declaration(tree_t unit); static tree_t p_package_body(tree_t unit); static tree_t p_subprogram_declaration(tree_t spec); static tree_t p_subprogram_body(tree_t spec); static tree_t p_subprogram_specification(void); static tree_t p_name(name_mask_t stop_mask); static tree_t p_block_configuration(tree_t of); static tree_t p_protected_type_body(ident_t id); static type_t p_signature(void); static type_t p_type_mark(void); static tree_t p_function_call(ident_t id, tree_t prefix); static tree_t p_resolution_indication(void); static void p_conditional_waveforms(tree_t stmt, tree_t target, tree_t s0); static void p_generic_map_aspect(tree_t inst, tree_t unit); static ident_t p_designator(void); static void p_interface_list(tree_t parent, tree_kind_t kind, bool ordered); static void p_trailing_label(ident_t label); static tree_t p_condition(void); static type_t p_subtype_indication(void); static tree_t p_record_constraint(type_t base); static tree_t p_qualified_expression(tree_t prefix); static tree_t p_concurrent_procedure_call_statement(ident_t label, tree_t name); static tree_t p_subprogram_instantiation_declaration(void); static tree_t p_record_element_constraint(type_t base); static void p_selected_waveforms(tree_t stmt, tree_t target, tree_t reject); static type_t p_index_subtype_definition(tree_t head); static type_t p_anonymous_type_indication(void); static void p_alias_declaration(tree_t parent); static void p_variable_declaration(tree_t parent); static void p_array_constraint(type_t type, type_t base); static void p_psl_declaration(tree_t parent); static psl_node_t p_psl_sequence(void); static psl_node_t p_psl_property(void); static psl_node_t p_psl_sere(void); static tree_t p_psl_directive(ident_t label); static psl_node_t p_psl_repeated_sere(psl_node_t head); static psl_node_t p_psl_braced_sere(void); static psl_node_t p_hdl_expression(tree_t head, psl_type_t type); static psl_node_t p_psl_builtin_function_call(void); static psl_node_t p_psl_union(tree_t head); static bool consume(token_t tok); static bool optional(token_t tok); static type_t get_element_subtype(tree_t expr); static void _pop_state(const state_t *s) { #if TRACE_PARSE printf("%*s<-- %s\n", depth--, "", hint_str); #endif hint_str = s->old_hint; if (s->old_start_loc.first_line != LINE_INVALID) start_loc = s->old_start_loc; } #if TRACE_PARSE static void _push_state(const state_t *s) { printf("%*s--> %s\n", depth++, "", hint_str); } #endif static void skip_pragma(pragma_kind_t kind) { if (nametab == NULL) warn_at(&yylloc, "ignoring pragma outside of design unit"); else { tree_t p = tree_new(T_PRAGMA); tree_set_loc(p, &yylloc); tree_set_subkind(p, kind); APUSH(pragmas, p); } } static token_t wrapped_yylex(void) { for (;;) { const token_t token = processed_yylex(); switch (token) { case tSYNTHON: skip_pragma(PRAGMA_SYNTHESIS_ON); break; case tSYNTHOFF: skip_pragma(PRAGMA_SYNTHESIS_OFF); break; case tCOVERAGEON: skip_pragma(PRAGMA_COVERAGE_ON); break; case tCOVERAGEOFF: skip_pragma(PRAGMA_COVERAGE_OFF); break; case tTRANSLATEON: skip_pragma(PRAGMA_TRANSLATE_ON); break; case tTRANSLATEOFF: skip_pragma(PRAGMA_TRANSLATE_OFF); break; default: return token; } } } static token_t peek_nth(int n) { while (((tokenq_head - tokenq_tail) & (tokenq_sz - 1)) < n) { const token_t token = wrapped_yylex(); int next = (tokenq_head + 1) & (tokenq_sz - 1); if (unlikely(next == tokenq_tail)) { const int newsz = tokenq_sz * 2; tokenq_t *new = xmalloc_array(newsz, sizeof(tokenq_t)); tokenq_t *p = new; for (int i = tokenq_tail; i != tokenq_head; i = (i + 1) & (tokenq_sz - 1)) *p++ = tokenq[i]; free(tokenq); tokenq = new; tokenq_sz = newsz; tokenq_head = p - new; tokenq_tail = 0; next = (tokenq_head + 1) & (tokenq_sz - 1); } extern yylval_t yylval; tokenq[tokenq_head].token = token; tokenq[tokenq_head].lval = yylval; tokenq[tokenq_head].loc = yylloc; tokenq_head = next; } const int pos = (tokenq_tail + n - 1) & (tokenq_sz - 1); return tokenq[pos].token; } static bool look_for(const look_params_t *params) { bool found = false; token_t tok = -1; int n, nest = 0; for (n = 1; ;) { tok = peek_nth(n++); if ((tok == tEOF) || (tok == params->abort)) goto stop_looking; else if (tok == params->nest_in) nest++; if (nest == params->depth) { for (int i = 0; i < ARRAY_LEN(params->look); i++) { if (tok == params->look[i]) { found = true; goto stop_looking; } } if (params->lookfn != NULL && (*params->lookfn)(tok)) { found = true; goto stop_looking; } for (int i = 0; i < ARRAY_LEN(params->stop); i++) { if (tok == params->stop[i]) goto stop_looking; } } if (tok == params->nest_out) nest--; } stop_looking: #if WARN_LOOKAHEAD > 0 if (n >= WARN_LOOKAHEAD) warn_at(&(tokenq[tokenq_tail].loc), "look ahead depth %d", n); #endif return found; } static void drop_token(void) { assert(tokenq_head != tokenq_tail); if (start_loc.first_line == LINE_INVALID) start_loc = tokenq[tokenq_tail].loc; last_lval = tokenq[tokenq_tail].lval; last_loc = tokenq[tokenq_tail].loc; tokenq_tail = (tokenq_tail + 1) & (tokenq_sz - 1); nopt_hist = 0; } static void drop_tokens_until(token_t tok) { token_t next = tEOF; do { free_token(tok, &last_lval); next = peek(); drop_token(); } while ((tok != next) && (next != tEOF)); #if TRACE_RECOVERY if (peek() != tEOF) fmt_loc(stdout, &(tokenq[tokenq_tail].loc)); #endif } static void _vexpect(va_list ap) { if (n_correct >= RECOVER_THRESH) { diag_t *d = diag_new(DIAG_ERROR, &(tokenq[tokenq_tail].loc)); diag_printf(d, "unexpected $yellow$%s$$ while parsing %s, expecting ", token_str(peek()), hint_str); bool first = true; for (int i = 0; i < nopt_hist; i++) { diag_printf(d, "%s$yellow$%s$$", i == 0 ? "one of " : ", ", token_str(opt_hist[i])); first = false; } int tok = va_arg(ap, int); while (tok != -1) { const int tmp = tok; tok = va_arg(ap, int); if (first && (tok != -1)) diag_printf(d, "one of "); else if (!first) diag_printf(d, (tok == -1) ? " or " : ", "); diag_printf(d, "$yellow$%s$$", token_str(tmp)); first = false; } diag_hint(d, &(tokenq[tokenq_tail].loc), "this token was unexpected"); diag_emit(d); } n_correct = 0; drop_token(); suppress_errors(nametab); } static void _expect(int dummy, ...) { va_list ap; va_start(ap, dummy); _vexpect(ap); va_end(ap); } static bool consume(token_t tok) { const token_t got = peek(); if (tok != got) { expect(tok); return false; } else { n_correct++; drop_token(); return true; } } static bool optional(token_t tok) { if (peek() == tok) { consume(tok); return true; } else { if (nopt_hist < ARRAY_LEN(opt_hist)) opt_hist[nopt_hist++] = tok; return false; } } static bool _scan(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); return found; } static int _one_of(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); if (found) { consume(p); return p; } else { va_start(ap, dummy); _vexpect(ap); va_end(ap); return -1; } } static const loc_t *_diff_loc(const loc_t *start, const loc_t *end) { static loc_t result; result = get_loc(start->first_line, start->first_column, end->first_line + end->line_delta, end->first_column + end->column_delta, start->file_ref); return &result; } static ident_t error_marker(void) { return well_known(W_ERROR); } static tree_t error_expr(void) { tree_t t = tree_new(T_REF); tree_set_ident(t, error_marker()); tree_set_type(t, type_new(T_NONE)); return t; } static tree_t find_binding(tree_t inst) { ident_t name; tree_t unit = NULL; if (tree_kind(inst) == T_BINDING) { name = tree_ident(inst); if (tree_has_ident2(inst)) name = ident_prefix(name, tree_ident2(inst), '-'); } else { name = tree_ident2(inst); if (tree_has_ref(inst)) unit = tree_ref(inst); } if (unit == NULL) unit = resolve_name(nametab, tree_loc(inst), name); if (unit == NULL) return NULL; const char *what = is_design_unit(unit) ? "design unit" : "object"; const tree_kind_t kind = tree_kind(unit); switch (tree_class(inst)) { case C_COMPONENT: if (kind != T_COMPONENT) { parse_error(tree_loc(inst), "%s %s is not a component declaration", what, istr(name)); return NULL; } break; case C_ENTITY: if (kind != T_ENTITY && kind != T_ARCH) { parse_error(tree_loc(inst), "%s %s is not an entity", what, istr(name)); return NULL; } break; case C_CONFIGURATION: if (kind != T_CONFIGURATION) { parse_error(tree_loc(inst), "%s %s is not a configuration", what, istr(name)); return NULL; } break; default: break; } return unit; } static void set_label_and_loc(tree_t t, ident_t label, const loc_t *loc) { tree_set_loc(t, loc); if (label == NULL) label = get_implicit_label(t, nametab); tree_set_ident(t, label); } static void require_std(vhdl_standard_t which, const char *feature) { static bool warned = false; if (standard() < which && !warned) { warned = true; if (n_correct >= RECOVER_THRESH) { diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); diag_printf(d, "%s %s not supported in VHDL-%s", feature, feature[strlen(feature)-1] == 's' ? "are" : "is", standard_text(standard())); diag_hint(d, NULL, "pass $bold$--std=%s$$ to enable this feature", standard_text(which)); diag_emit(d); } } } static tree_t bit_string_to_literal(const char *str, const loc_t *loc) { tree_t t = tree_new(T_STRING); tree_set_loc(t, loc); const char *p = str; int length = -1; if (isdigit_iso88591(*p)) { require_std(STD_08, "bit string literals with length specifier"); unsigned long slength = strtoul(p, (char **)&p, 10); if (slength > INT32_MAX) { error_at(loc, "sorry, bit strings longer than %d elements are " "not supported", INT32_MAX); return t; } length = slength; } enum { UNSIGNED, SIGNED } mode = UNSIGNED; switch (*p) { case 'U': case 'u': mode = UNSIGNED; ++p; break; case 'S': case 's': mode = SIGNED; ++p; break; } char base_ch = *p++; int base; switch (base_ch) { case 'X': case 'x': base = 16; break; case 'O': case 'o': base = 8; break; case 'B': case 'b': base = 2; break; case 'D': case 'd': base = 10; break; default: parse_error(loc, "invalid base '%c' for bit string", base_ch); return t; } tree_t one = tree_new(T_REF); tree_set_ident(one, ident_new("'1'")); tree_set_loc(one, loc); tree_t zero = tree_new(T_REF); tree_set_ident(zero, ident_new("'0'")); tree_set_loc(zero, loc); if (base == 10) { require_std(STD_08, "decimal bit string literals"); int ddigits = 0; uint8_t *decimal LOCAL = xmalloc(strlen(str)); for (++p; *p != '\"'; p++) { if (!isdigit_iso88591(*p)) { parse_error(loc, "invalid digit '%c' in decimal bit string", *p); return t; } else decimal[ddigits++] = *p - '0'; } const int maxbits = (length == -1 ? ddigits * 4 : length); tree_t *bits LOCAL = xmalloc_array(maxbits, sizeof(tree_t)); int pos = maxbits - 1; for (;;) { bool all_zero = true; int cout = 0; for (int i = 0, cin = 0; i < ddigits; i++, cin = cout) { all_zero &= (decimal[i] == 0); cout = decimal[i] & 1; decimal[i] >>= 1; if (cin) decimal[i] += 5; } if (all_zero) break; else if (pos < 0 && cout) { parse_error(CURRENT_LOC, "excess non-zero digits in " "decimal bit string literal"); return t; } else if (pos >= 0) bits[pos--] = cout ? one : zero; } if (length == -1) length = maxbits - pos - 1; for (int i = maxbits - length; i < maxbits; i++) tree_add_char(t, i <= pos ? zero : bits[i]); return t; } tree_t *bits LOCAL = NULL; if (length >= 0) bits = xmalloc_array(length, sizeof(tree_t)); tree_t pad = mode == UNSIGNED ? zero : NULL; int nbits = 0; for (++p; *p != '\"'; p++) { const bool extended = (isdigit_iso88591(*p) && *p < '0' + base) || (base > 10 && *p >= 'A' && *p < 'A' + base - 10) || (base > 10 && *p >= 'a' && *p < 'a' + base - 10); int n = (isdigit_iso88591(*p) ? (*p - '0') : 10 + (isupper_iso88591(*p) ? (*p - 'A') : (*p - 'a'))); tree_t digit = NULL; if (!extended) { if (standard() < STD_08 || !isprint_iso88591(*p)) { parse_error(loc, "invalid digit '%c' in bit string", *p); return t; } else { const char rune[] = { '\'', *p, '\'', '\0' }; digit = tree_new(T_REF); tree_set_ident(digit, ident_new(rune)); tree_set_loc(digit, loc); } } for (int d = (base >> 1); d > 0; n = n % d, d >>= 1) { tree_t bit = extended ? ((n / d) ? one : zero) : digit; if (pad == NULL) pad = bit; if (length >= 0) { tree_t left = nbits == 0 ? bit : bits[0]; if (nbits < length) bits[nbits++] = bit; else if (left != pad && tree_ident(left) != tree_ident(pad)) { parse_error(CURRENT_LOC, "excess %s digits in bit " "string literal", mode == SIGNED ? "significant" : "non-zero"); return t; } else if (length > 0) { for (int i = 0; i < length - 1; i++) bits[i] = bits[i + 1]; bits[length - 1] = bit; } } else tree_add_char(t, bit); } } if (pad == NULL && nbits < length) parse_error(CURRENT_LOC, "signed bit string literal cannot be an " "empty string"); else if (length >= 0) { // Left-pad with sign bit or zero int pos = 0; for (; pos < length - nbits; pos++) tree_add_char(t, pad); for (int i = 0; pos < length; pos++, i++) tree_add_char(t, bits[i]); } return t; } static tree_t get_time(int64_t fs, const loc_t *loc) { tree_t lit = tree_new(T_LITERAL); tree_set_subkind(lit, L_INT); tree_set_ival(lit, fs); tree_set_loc(lit, loc); tree_set_type(lit, std_type(NULL, STD_TIME)); return lit; } static void set_delay_mechanism(tree_t t, tree_t reject) { if (reject == NULL) { // Inertial delay with same value as waveform // LRM 93 section 8.4 the rejection limit in this case is // specified by the time expression of the first waveform tree_t assign = (tree_kind(t) == T_COND_ASSIGN ? tree_cond(t, 0) : t); if (tree_waveforms(assign) == 0) return; tree_t w = tree_waveform(assign, 0); if (tree_has_delay(w)) tree_set_reject(t, tree_delay(w)); } else { tree_set_reject(t, reject); solve_types(nametab, reject, std_type(NULL, STD_TIME)); } } static tree_t add_port(tree_t d, const char *name, type_t type, port_mode_t mode, tree_t def) { type_t ftype = tree_type(d); tree_t port = tree_new(T_PARAM_DECL); tree_set_ident(port, ident_new(name)); tree_set_loc(port, tree_loc(d)); tree_set_type(port, type); tree_set_subkind(port, mode); if (def != NULL) tree_set_value(port, def); if (type_is_file(type)) tree_set_class(port, C_FILE); tree_add_port(d, port); type_add_param(ftype, type); return port; } static tree_t builtin_proc(ident_t name, subprogram_kind_t kind, ...) { type_t f = type_new(T_SIGNATURE); type_set_ident(f, name); tree_t d = tree_new(T_PROC_DECL); tree_set_ident(d, name); tree_set_type(d, f); tree_set_subkind(d, kind); tree_set_flag(d, TREE_F_NEVER_WAITS); tree_set_flag(d, TREE_F_PREDEFINED); tree_set_loc(d, CURRENT_LOC); return d; } static tree_t builtin_fn(ident_t name, type_t result, subprogram_kind_t kind, ...) { type_t f = type_new(T_SIGNATURE); type_set_ident(f, name); type_set_result(f, result); tree_t d = tree_new(T_FUNC_DECL); tree_set_ident(d, name); tree_set_type(d, f); tree_set_subkind(d, kind); va_list ap; va_start(ap, kind); char *argname; while ((argname = va_arg(ap, char*))) { type_t type = va_arg(ap, type_t); assert(type != NULL); add_port(d, argname, type, PORT_IN, NULL); } va_end(ap); tree_set_flag(d, TREE_F_PREDEFINED); tree_set_loc(d, CURRENT_LOC); return d; } static void declare_binary(tree_t container, ident_t name, type_t lhs, type_t rhs, type_t result, subprogram_kind_t kind) { tree_t d = builtin_fn(name, result, kind, "L", lhs, "R", rhs, NULL); mangle_func(nametab, d); insert_name(nametab, d, NULL); tree_add_decl(container, d); } static void declare_unary(tree_t container, ident_t name, type_t operand, type_t result, subprogram_kind_t kind) { tree_t d = builtin_fn(name, result, kind, "VALUE", operand, NULL); mangle_func(nametab, d); insert_name(nametab, d, NULL); tree_add_decl(container, d); } static bool is_bit_or_std_ulogic(type_t type) { if (!type_is_enum(type)) return false; ident_t name = type_ident(type); return name == well_known(W_STD_BIT) || name == well_known(W_IEEE_ULOGIC); } static void declare_predefined_ops(tree_t container, type_t t) { // Prefined operators are defined in LRM 93 section 7.2 ident_t mult = well_known(W_OP_TIMES); ident_t div = well_known(W_OP_DIVIDE); ident_t plus = well_known(W_OP_ADD); ident_t minus = well_known(W_OP_MINUS); ident_t cmp_lt = well_known(W_OP_LESS_THAN); ident_t cmp_le = well_known(W_OP_LESS_EQUAL); ident_t cmp_gt = well_known(W_OP_GREATER_THAN); ident_t cmp_ge = well_known(W_OP_GREATER_EQUAL); ident_t eq = well_known(W_OP_EQUAL); ident_t neq = well_known(W_OP_NOT_EQUAL); ident_t min_i = NULL, max_i = NULL; if (standard() >= STD_08) { min_i = ident_new("MINIMUM"); max_i = ident_new("MAXIMUM"); } // Predefined operators tree_t std = find_std(nametab); type_t std_bool = std_type(std, STD_BOOLEAN); type_t std_int = NULL; type_t std_real = NULL; type_t std_uint = NULL; type_kind_t kind = type_kind(t); switch (kind) { case T_SUBTYPE: // Use operators of base type break; case T_FILE: // No predefined operators break; case T_ARRAY: // Operators on arrays declare_binary(container, eq, t, t, std_bool, S_ARRAY_EQ); declare_binary(container, neq, t, t, std_bool, S_ARRAY_NEQ); if (dimension_of(t) == 1) { type_t elem = type_elem(t); const bool scalar_elem = type_is_scalar(elem); const bool ordered = standard() >= STD_19 ? scalar_elem : type_is_discrete(elem); if (ordered) { declare_binary(container, cmp_lt, t, t, std_bool, S_ARRAY_LT); declare_binary(container, cmp_le, t, t, std_bool, S_ARRAY_LE); declare_binary(container, cmp_gt, t, t, std_bool, S_ARRAY_GT); declare_binary(container, cmp_ge, t, t, std_bool, S_ARRAY_GE); } ident_t concat = ident_new("\"&\""); declare_binary(container, concat, t, t, t, S_CONCAT); declare_binary(container, concat, t, elem, t, S_CONCAT); declare_binary(container, concat, elem, t, t, S_CONCAT); declare_binary(container, concat, elem, elem, t, S_CONCAT); if (standard() >= STD_08) { if (ordered) { declare_binary(container, min_i, t, t, t, S_MINIMUM); declare_binary(container, max_i, t, t, t, S_MAXIMUM); } if (scalar_elem) { declare_unary(container, min_i, t, elem, S_MINIMUM); declare_unary(container, max_i, t, elem, S_MAXIMUM); } } } break; case T_RECORD: // Operators on records declare_binary(container, eq, t, t, std_bool, S_RECORD_EQ); declare_binary(container, neq, t, t, std_bool, S_RECORD_NEQ); break; case T_PHYSICAL: std_int = std_type(std, STD_INTEGER); std_real = std_type(std, STD_REAL); std_uint = std_type(std, STD_UNIVERSAL_INTEGER); // Multiplication declare_binary(container, mult, t, std_int, t, S_MUL_PI); declare_binary(container, mult, t, std_real, t, S_MUL_PR); declare_binary(container, mult, std_int, t, t, S_MUL_IP); declare_binary(container, mult, std_real, t, t, S_MUL_RP); // Division declare_binary(container, div, t, std_int, t, S_DIV_PI); declare_binary(container, div, t, std_real, t, S_DIV_PR); declare_binary(container, div, t, t, std_uint, S_DIV_PP); // Addition declare_binary(container, plus, t, t, t, S_ADD); // Subtraction declare_binary(container, minus, t, t, t, S_SUB); // Sign operators declare_unary(container, plus, t, t, S_IDENTITY); declare_unary(container, minus, t, t, S_NEGATE); // Comparison declare_binary(container, cmp_lt, t, t, std_bool, S_SCALAR_LT); declare_binary(container, cmp_le, t, t, std_bool, S_SCALAR_LE); declare_binary(container, cmp_gt, t, t, std_bool, S_SCALAR_GT); declare_binary(container, cmp_ge, t, t, std_bool, S_SCALAR_GE); // Equality declare_binary(container, eq, t, t, std_bool, S_SCALAR_EQ); declare_binary(container, neq, t, t, std_bool, S_SCALAR_NEQ); // Absolute value declare_unary(container, well_known(W_OP_ABS), t, t, S_ABS); if (standard() >= STD_08) { declare_binary(container, min_i, t, t, t, S_MINIMUM); declare_binary(container, max_i, t, t, t, S_MAXIMUM); // Modulus and remainder in 2008 only declare_binary(container, well_known(W_OP_MOD), t, t, t, S_MOD); declare_binary(container, well_known(W_OP_REM), t, t, t, S_REM); } break; case T_INTEGER: // Modulus declare_binary(container, well_known(W_OP_MOD), t, t, t, S_MOD); // Remainder declare_binary(container, well_known(W_OP_REM), t, t, t, S_REM); // Fall-through case T_REAL: // Addition declare_binary(container, plus, t, t, t, S_ADD); // Subtraction declare_binary(container, minus, t, t, t, S_SUB); // Multiplication declare_binary(container, mult, t, t, t, S_MUL); // Division declare_binary(container, div, t, t, t, S_DIV); // Sign operators declare_unary(container, plus, t, t, S_IDENTITY); declare_unary(container, minus, t, t, S_NEGATE); // Exponentiation if (!bootstrapping) { std_int = std_type(std, STD_INTEGER); declare_binary(container, well_known(W_OP_EXPONENT), t, std_int, t, S_EXP); } // Absolute value declare_unary(container, well_known(W_OP_ABS), t, t, S_ABS); // Fall-through case T_ENUM: declare_binary(container, cmp_lt, t, t, std_bool, S_SCALAR_LT); declare_binary(container, cmp_le, t, t, std_bool, S_SCALAR_LE); declare_binary(container, cmp_gt, t, t, std_bool, S_SCALAR_GT); declare_binary(container, cmp_ge, t, t, std_bool, S_SCALAR_GE); if (standard() >= STD_08) { declare_binary(container, min_i, t, t, t, S_MINIMUM); declare_binary(container, max_i, t, t, t, S_MAXIMUM); } // Fall-through default: declare_binary(container, eq, t, t, std_bool, S_SCALAR_EQ); declare_binary(container, neq, t, t, std_bool, S_SCALAR_NEQ); break; } if (standard() >= STD_08 && !bootstrapping && type_is_representable(t)) { // The TO_STRING operators in STD.STANDARD are declared at // the end of the package according to LRM 08 section 5.2.6 declare_unary(container, ident_new("TO_STRING"), t, std_type(NULL, STD_STRING), S_TO_STRING); } // Universal integers and reals have some additional overloaded // operators that are not valid for regular integer and real types // See LRM 93 section 7.5 if (bootstrapping && kind == T_REAL && t == std_type(std, STD_UNIVERSAL_REAL)) { type_t uint = std_type(std, STD_UNIVERSAL_INTEGER); declare_binary(container, mult, t, uint, t, S_MUL_RI); declare_binary(container, mult, uint, t, t, S_MUL_IR); declare_binary(container, div, t, uint, t, S_DIV_RI); } // Matching comparison for BIT and STD_ULOGIC if (standard() >= STD_08) { if (kind == T_ARRAY) { type_t elem = type_elem(t); if (is_bit_or_std_ulogic(elem)) { declare_binary(container, ident_new("\"?=\""), t, t, elem, S_MATCH_EQ); declare_binary(container, ident_new("\"?/=\""), t, t, elem, S_MATCH_NEQ); } } else if (is_bit_or_std_ulogic(t)) { declare_binary(container, ident_new("\"?=\""), t, t, t, S_MATCH_EQ); declare_binary(container, ident_new("\"?/=\""), t, t, t, S_MATCH_NEQ); declare_binary(container, ident_new("\"?<\""), t, t, t, S_MATCH_LT); declare_binary(container, ident_new("\"?<=\""), t, t, t, S_MATCH_LE); declare_binary(container, ident_new("\"?>\""), t, t, t, S_MATCH_GT); declare_binary(container, ident_new("\"?>=\""), t, t, t, S_MATCH_GE); } } // Logical operators if (bootstrapping && (t == std_bool || t == std_type(std, STD_BIT))) { declare_binary(container, ident_new("\"and\""), t, t, t, S_SCALAR_AND); declare_binary(container, ident_new("\"or\""), t, t, t, S_SCALAR_OR); declare_binary(container, ident_new("\"xor\""), t, t, t, S_SCALAR_XOR); declare_binary(container, ident_new("\"nand\""), t, t, t, S_SCALAR_NAND); declare_binary(container, ident_new("\"nor\""), t, t, t, S_SCALAR_NOR); declare_binary(container, ident_new("\"xnor\""), t, t, t, S_SCALAR_XNOR); declare_unary(container, ident_new("\"not\""), t, t, S_SCALAR_NOT); } bool vec_logical = false; if (kind == T_ARRAY && dimension_of(t) == 1) { type_t base = type_elem(t); vec_logical = (base == std_bool || base == std_type(NULL, STD_BIT)); } if (vec_logical) { std_int = std_type(NULL, STD_INTEGER); ident_t and = well_known(W_OP_AND); ident_t or = well_known(W_OP_OR); ident_t xor = well_known(W_OP_XOR); ident_t nand = well_known(W_OP_NAND); ident_t nor = well_known(W_OP_NOR); ident_t xnor = well_known(W_OP_XNOR); declare_binary(container, and, t, t, t, S_ARRAY_AND); declare_binary(container, or, t, t, t, S_ARRAY_OR); declare_binary(container, xor, t, t, t, S_ARRAY_XOR); declare_binary(container, nand, t, t, t, S_ARRAY_NAND); declare_binary(container, nor, t, t, t, S_ARRAY_NOR); declare_binary(container, xnor, t, t, t, S_ARRAY_XNOR); declare_unary(container, well_known(W_OP_NOT), t, t, S_ARRAY_NOT); declare_binary(container, ident_new("\"sll\""), t, std_int, t, S_SLL); declare_binary(container, ident_new("\"srl\""), t, std_int, t, S_SRL); declare_binary(container, ident_new("\"sla\""), t, std_int, t, S_SLA); declare_binary(container, ident_new("\"sra\""), t, std_int, t, S_SRA); declare_binary(container, ident_new("\"rol\""), t, std_int, t, S_ROL); declare_binary(container, ident_new("\"ror\""), t, std_int, t, S_ROR); if (standard() >= STD_08) { type_t e = type_elem(t); declare_unary(container, and, t, e, S_REDUCE_AND); declare_unary(container, or, t, e, S_REDUCE_OR); declare_unary(container, xor, t, e, S_REDUCE_XOR); declare_unary(container, nand, t, e, S_REDUCE_NAND); declare_unary(container, nor, t, e, S_REDUCE_NOR); declare_unary(container, xnor, t, e, S_REDUCE_XNOR); declare_binary(container, and, t, e, t, S_MIXED_AND); declare_binary(container, or, t, e, t, S_MIXED_OR); declare_binary(container, xor, t, e, t, S_MIXED_XOR); declare_binary(container, nand, t, e, t, S_MIXED_NAND); declare_binary(container, nor, t, e, t, S_MIXED_NOR); declare_binary(container, xnor, t, e, t, S_MIXED_XNOR); declare_binary(container, and, e, t, t, S_MIXED_AND); declare_binary(container, or, e, t, t, S_MIXED_OR); declare_binary(container, xor, e, t, t, S_MIXED_XOR); declare_binary(container, nand, e, t, t, S_MIXED_NAND); declare_binary(container, nor, e, t, t, S_MIXED_NOR); declare_binary(container, xnor, e, t, t, S_MIXED_XNOR); } } // Predefined procedures switch (kind) { case T_FILE: { ident_t file_open_i = ident_new("FILE_OPEN"); ident_t file_close_i = ident_new("FILE_CLOSE"); ident_t read_i = ident_new("READ"); ident_t write_i = ident_new("WRITE"); ident_t endfile_i = ident_new("ENDFILE"); ident_t read_mode_i = ident_new("READ_MODE"); tree_t read_mode = get_local_decl(nametab, std, read_mode_i, 0); assert(read_mode != NULL); type_t open_kind = std_type(NULL, STD_FILE_OPEN_KIND); type_t open_status = std_type(NULL, STD_FILE_OPEN_STATUS); type_t std_string = std_type(NULL, STD_STRING); tree_t file_open1 = builtin_proc(file_open_i, S_FILE_OPEN1); add_port(file_open1, "F", t, PORT_INOUT, NULL); add_port(file_open1, "EXTERNAL_NAME", std_string, PORT_IN, NULL); add_port(file_open1, "OPEN_KIND", open_kind, PORT_IN, make_ref(read_mode)); insert_name(nametab, file_open1, file_open_i); tree_add_decl(container, file_open1); tree_t file_open2 = builtin_proc(file_open_i, S_FILE_OPEN2); add_port(file_open2, "STATUS", open_status, PORT_OUT, NULL); add_port(file_open2, "F", t, PORT_INOUT, NULL); add_port(file_open2, "EXTERNAL_NAME", std_string, PORT_IN, NULL); add_port(file_open2, "OPEN_KIND", open_kind, PORT_IN, make_ref(read_mode)); insert_name(nametab, file_open2, file_open_i); tree_add_decl(container, file_open2); tree_t file_close = builtin_proc(file_close_i, S_FILE_CLOSE); add_port(file_close, "F", t, PORT_INOUT, NULL); mangle_func(nametab, file_close); insert_name(nametab, file_close, file_close_i); tree_add_decl(container, file_close); if (standard() >= STD_08) { ident_t flush_i = ident_new("FLUSH"); tree_t flush = builtin_proc(flush_i, S_FILE_FLUSH); add_port(flush, "F", t, PORT_IN, NULL); mangle_func(nametab, flush); insert_name(nametab, flush, flush_i); tree_add_decl(container, flush); } if (standard() >= STD_19) { ident_t rewind_i = ident_new("FILE_REWIND"); ident_t seek_i = ident_new("FILE_SEEK"); ident_t begin_i = ident_new("FILE_ORIGIN_BEGIN"); ident_t truncate_i = ident_new("FILE_TRUNCATE"); ident_t state_i = ident_new("FILE_STATE"); ident_t mode_i = ident_new("FILE_MODE"); ident_t position_i = ident_new("FILE_POSITION"); ident_t size_i = ident_new("FILE_SIZE"); ident_t canseek_i = ident_new("FILE_CANSEEK"); type_t origin_kind = std_type(NULL, STD_FILE_ORIGIN_KIND); type_t open_state = std_type(NULL, STD_FILE_OPEN_STATE); tree_t origin_begin = get_local_decl(nametab, std, begin_i, 0); assert(origin_begin != NULL); tree_t file_open3 = builtin_fn(file_open_i, open_status, S_FILE_OPEN3, "F", t, "EXTERNAL_NAME", std_string, "OPEN_KIND", open_kind, NULL); tree_set_flag(file_open3, TREE_F_IMPURE); tree_set_class(tree_port(file_open3, 0), C_FILE); tree_set_value(tree_port(file_open3, 2), make_ref(read_mode)); mangle_func(nametab, file_open3); insert_name(nametab, file_open3, file_open_i); tree_add_decl(container, file_open3); tree_t rewind = builtin_proc(rewind_i, S_FILE_REWIND); add_port(rewind, "F", t, PORT_IN, NULL); mangle_func(nametab, rewind); insert_name(nametab, rewind, rewind_i); tree_add_decl(container, rewind); std_int = std_type(std, STD_INTEGER); tree_t seek = builtin_proc(seek_i, S_FILE_SEEK); add_port(seek, "F", t, PORT_IN, NULL); add_port(seek, "OFFSET", std_int, PORT_IN, NULL); add_port(seek, "ORIGIN", origin_kind, PORT_IN, make_ref(origin_begin)); mangle_func(nametab, seek); insert_name(nametab, seek, seek_i); tree_add_decl(container, seek); tree_t truncate = builtin_proc(truncate_i, S_FILE_TRUNCATE); add_port(truncate, "F", t, PORT_IN, NULL); add_port(truncate, "SIZE", std_int, PORT_IN, NULL); add_port(truncate, "ORIGIN", origin_kind, PORT_IN, make_ref(origin_begin)); mangle_func(nametab, truncate); insert_name(nametab, truncate, truncate_i); tree_add_decl(container, truncate); tree_t state = builtin_fn(state_i, open_state, S_FILE_STATE, "F", t, NULL); tree_set_class(tree_port(state, 0), C_FILE); mangle_func(nametab, state); insert_name(nametab, state, state_i); tree_add_decl(container, state); tree_t mode = builtin_fn(mode_i, open_kind, S_FILE_MODE, "F", t, NULL); tree_set_class(tree_port(mode, 0), C_FILE); mangle_func(nametab, mode); insert_name(nametab, mode, mode_i); tree_add_decl(container, mode); tree_t position = builtin_fn(position_i, std_int, S_FILE_POSITION, "F", t, "ORIGIN", origin_kind, NULL); tree_set_class(tree_port(position, 0), C_FILE); tree_set_value(tree_port(position, 1), make_ref(origin_begin)); mangle_func(nametab, position); insert_name(nametab, position, position_i); tree_add_decl(container, position); tree_t size = builtin_fn(size_i, std_int, S_FILE_SIZE, "F", t, NULL); tree_set_class(tree_port(size, 0), C_FILE); mangle_func(nametab, size); insert_name(nametab, size, size_i); tree_add_decl(container, size); tree_t canseek = builtin_fn(canseek_i, std_bool, S_FILE_CANSEEK, "F", t, NULL); tree_set_class(tree_port(canseek, 0), C_FILE); mangle_func(nametab, canseek); insert_name(nametab, canseek, canseek_i); tree_add_decl(container, canseek); } type_t of = type_designated(t); tree_t read = builtin_proc(read_i, S_FILE_READ); add_port(read, "F", t, PORT_INOUT, NULL); add_port(read, "VALUE", of, PORT_OUT, NULL); if (type_is_array(of) && type_is_unconstrained(of)) { type_t std_nat = std_type(NULL, STD_NATURAL); add_port(read, "LENGTH", std_nat, PORT_OUT, NULL); } insert_name(nametab, read, read_i); tree_add_decl(container, read); tree_t write = builtin_proc(write_i, S_FILE_WRITE); add_port(write, "F", t, PORT_INOUT, NULL); add_port(write, "VALUE", of, PORT_IN, NULL); insert_name(nametab, write, write_i); tree_add_decl(container, write); declare_unary(container, endfile_i, t, std_bool, S_ENDFILE); } break; case T_ACCESS: { ident_t deallocate_i = ident_new("DEALLOCATE"); tree_t deallocate = builtin_proc(deallocate_i, S_DEALLOCATE); add_port(deallocate, "P", t, PORT_INOUT, NULL); mangle_func(nametab, deallocate); insert_name(nametab, deallocate, deallocate_i); tree_add_decl(container, deallocate); } break; default: break; } if (bootstrapping && standard() >= STD_08) { // Special predefined operators only declared in STANDARD type_t std_bit = NULL; if (t == std_bool || t == (std_bit = std_type(NULL, STD_BIT))) { tree_t d1 = builtin_fn(ident_new("RISING_EDGE"), std_bool, S_RISING_EDGE, "S", t, NULL); mangle_func(nametab, d1); tree_set_class(tree_port(d1, 0), C_SIGNAL); tree_add_decl(container, d1); tree_t d2 = builtin_fn(ident_new("FALLING_EDGE"), std_bool, S_FALLING_EDGE, "S", t, NULL); mangle_func(nametab, d2); tree_set_class(tree_port(d2, 0), C_SIGNAL); tree_add_decl(container, d2); if (t == std_bit) declare_unary(container, well_known(W_OP_CCONV), t, std_bool, S_IDENTITY); } } } static void declare_alias(tree_t container, tree_t to, ident_t name) { tree_t alias = tree_new(T_ALIAS); tree_set_ident(alias, name); tree_set_value(alias, make_ref(to)); tree_set_type(alias, tree_type(to)); tree_set_flag(alias, TREE_F_PREDEFINED); tree_add_decl(container, alias); } static void declare_additional_standard_operators(tree_t unit) { assert(bootstrapping); // The exponentiation operator must be declared here after INTEGER is // declared type_t std_uint = std_type(unit, STD_UNIVERSAL_INTEGER); type_t std_ureal = std_type(unit, STD_UNIVERSAL_REAL); type_t std_int = std_type(unit, STD_INTEGER); type_t std_real = std_type(unit, STD_REAL); ident_t exp_i = well_known(W_OP_EXPONENT); declare_binary(unit, exp_i, std_uint, std_int, std_uint, S_EXP); declare_binary(unit, exp_i, std_ureal, std_int, std_ureal, S_EXP); declare_binary(unit, exp_i, std_int, std_int, std_int, S_EXP); declare_binary(unit, exp_i, std_real, std_int, std_real, S_EXP); if (standard() < STD_08) return; // LRM 08 5.2.6 says TO_STRING is declared at the end of the STANDARD // package ident_t to_string = ident_new("TO_STRING"); type_t std_string = std_type(unit, STD_STRING); type_t std_time = std_type(unit, STD_TIME); type_t std_natural = std_type(unit, STD_NATURAL); type_t std_bit_vec = std_type(unit, STD_BIT_VECTOR); const int ndecls = tree_decls(unit); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(unit, i); if (tree_kind(d) == T_TYPE_DECL) { type_t type = tree_type(d); if (type_is_representable(type)) declare_unary(unit, to_string, type, std_string, S_TO_STRING); } } // The following special cases are implicitly defined tree_t d1 = builtin_fn(to_string, std_string, S_TO_STRING_TIME, "VALUE", std_time, "UNIT", std_time, NULL); mangle_func(nametab, d1); tree_add_decl(unit, d1); tree_t d2 = builtin_fn(to_string, std_string, S_TO_STRING_REAL_DIGITS, "VALUE", std_real, "DIGITS", std_natural, NULL); mangle_func(nametab, d2); tree_add_decl(unit, d2); tree_t d3 = builtin_fn(to_string, std_string, S_TO_STRING_REAL_FORMAT, "VALUE", std_real, "FORMAT", std_string, NULL); mangle_func(nametab, d3); tree_add_decl(unit, d3); tree_t d4 = builtin_fn(ident_new("TO_HSTRING"), std_string, S_TO_HSTRING_BITVEC, "VALUE", std_bit_vec, NULL); mangle_func(nametab, d4); tree_add_decl(unit, d4); declare_alias(unit, d4, ident_new("TO_HEX_STRING")); tree_t d5 = builtin_fn(ident_new("TO_OSTRING"), std_string, S_TO_OSTRING_BITVEC, "VALUE", std_bit_vec, NULL); mangle_func(nametab, d5); tree_add_decl(unit, d5); declare_alias(unit, d5, ident_new("TO_OCTAL_STRING")); tree_t d6; for (int n = 0; (d6 = get_local_decl(nametab, NULL, to_string, n)); n++) { if (type_eq(tree_type(tree_port(d6, 0)), std_bit_vec)) break; } assert(d6 != NULL); declare_alias(unit, d6, ident_new("TO_BSTRING")); declare_alias(unit, d6, ident_new("TO_BINARY_STRING")); } static void unary_op(tree_t expr, tree_t (*arg_fn)(tree_t)) { tree_t right = (*arg_fn)(NULL); tree_set_loc(expr, CURRENT_LOC); add_param(expr, right, P_POS, NULL); } static void binary_op(tree_t expr, tree_t left, tree_t (*right_fn)(tree_t)) { add_param(expr, left, P_POS, NULL); tree_t right = (*right_fn)(NULL); tree_set_loc(expr, CURRENT_LOC); add_param(expr, right, P_POS, NULL); } static tree_t implicit_dereference(tree_t t) { type_t access = type_designated(tree_type(t)); tree_t all = tree_new(T_ALL); tree_set_loc(all, tree_loc(t)); tree_set_value(all, t); tree_set_type(all, access); return all; } static type_t prefix_type(tree_t prefix, type_t signature) { if (scope_formal_kind(nametab) == F_SUBPROGRAM) return NULL; // Check we can acutally resolve the base reference at this point tree_t ref = prefix; tree_kind_t kind; while ((kind = tree_kind(ref)) != T_REF) { switch (kind) { case T_ARRAY_SLICE: case T_ARRAY_REF: case T_RECORD_REF: case T_ALL: ref = tree_value(ref); break; default: return NULL; } } if (tree_has_ref(ref) && !class_has_type(class_of(tree_ref(ref)))) return NULL; return solve_types(nametab, prefix, signature); } static bool is_range_expr(tree_t t) { switch (tree_kind(t)) { case T_REF: if (tree_has_ref(t)) return aliased_type_decl(tree_ref(t)) != NULL; else return !!(query_name(nametab, tree_ident(t), NULL) & N_TYPE); case T_ATTR_REF: { const attr_kind_t predef = tree_subkind(t); return predef == ATTR_RANGE || predef == ATTR_REVERSE_RANGE; } default: return false; } } static tree_t ensure_labelled(tree_t t, ident_t label) { tree_set_ident(t, label ?: get_implicit_label(t, nametab)); return t; } static tree_t select_decl(tree_t prefix, ident_t suffix, name_mask_t *mask) { ident_t qual = ident_prefix(tree_ident(prefix), suffix, '.'); tree_t decl = NULL; *mask = query_name(nametab, qual, &decl); tree_t ref = tree_new(T_REF); tree_set_ident(ref, qual); tree_set_loc(ref, CURRENT_LOC); tree_set_ref(ref, decl); if (*mask == 0) { parse_error(CURRENT_LOC, "name %s not found in %s", istr(suffix), istr(tree_ident(prefix))); tree_set_type(ref, type_new(T_NONE)); } return ref; } static tree_t could_be_slice_name(tree_t fcall) { // The expression F(X) where X is a type name and F is a function // should be parsed as an array slice F(X'RANGE) where F is called // with no arguments if (tree_params(fcall) != 1) return fcall; tree_t p0 = tree_param(fcall, 0); if (tree_subkind(p0) != P_POS) return fcall; tree_t value = tree_value(p0); if (tree_kind(value) != T_REF) return fcall; if (!tree_has_ref(value)) return fcall; tree_t decl = tree_ref(value); if (!is_type_decl(decl)) return fcall; tree_t new = tree_new(T_FCALL); tree_set_ident(new, tree_ident(fcall)); tree_set_loc(new, tree_loc(fcall)); tree_t aref = tree_new(T_ATTR_REF); tree_set_name(aref, value); tree_set_ident(aref, ident_new("RANGE")); tree_set_loc(aref, tree_loc(value)); tree_set_subkind(aref, ATTR_RANGE); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, aref); tree_set_loc(r, tree_loc(p0)); solve_types(nametab, r, NULL); tree_t slice = tree_new(T_ARRAY_SLICE); tree_set_value(slice, new); tree_add_range(slice, r); tree_set_loc(slice, tree_loc(fcall)); return slice; } static bool is_implicit_block(tree_t t) { const tree_kind_t kind = tree_kind(t); return kind == T_ARCH || kind == T_BLOCK || kind == T_IF_GENERATE || kind == T_FOR_GENERATE; } static void make_universal_type(tree_t container, type_kind_t kind, const char *name, tree_t min, tree_t max) { assert(bootstrapping); ident_t name_i = ident_new(name); type_t type = type_new(kind); type_set_ident(type, name_i); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_TO); tree_set_left(r, min); tree_set_right(r, max); tree_set_type(r, type); type_add_dim(type, r); tree_set_type(min, type); tree_set_type(max, type); tree_t decl = tree_new(T_TYPE_DECL); tree_set_loc(decl, CURRENT_LOC); tree_set_ident(decl, name_i); tree_set_type(decl, type); tree_add_decl(container, decl); declare_predefined_ops(container, type); } static void make_universal_int(tree_t container) { tree_t min = tree_new(T_LITERAL); tree_set_subkind(min, L_INT); tree_set_ival(min, INT64_MIN); tree_t max = tree_new(T_LITERAL); tree_set_subkind(max, L_INT); tree_set_ival(max, INT64_MAX); make_universal_type(container, T_INTEGER, "universal_integer", min, max); } static void make_universal_real(tree_t container) { tree_t min = tree_new(T_LITERAL); tree_set_subkind(min, L_REAL); tree_set_dval(min, -DBL_MAX); tree_t max = tree_new(T_LITERAL); tree_set_subkind(max, L_REAL); tree_set_dval(max, DBL_MAX); make_universal_type(container, T_REAL, "universal_real", min, max); } static void make_implicit_guard_signal(tree_t block, tree_t expr) { tree_t guard = tree_new(T_IMPLICIT_SIGNAL); tree_set_subkind(guard, IMPLICIT_GUARD); tree_set_ident(guard, ident_new("GUARD")); tree_set_loc(guard, tree_loc(expr)); tree_set_type(guard, std_type(NULL, STD_BOOLEAN)); tree_set_value(guard, expr); tree_add_decl(block, guard); insert_name(nametab, guard, NULL); sem_check(guard, nametab); } static tree_t fcall_to_conv_func(tree_t value) { assert(tree_kind(value) == T_FCALL); if (!(tree_flags(value) & TREE_F_CONVERSION)) return value; if (!tree_has_ref(value)) return value; tree_t decl = tree_ref(value); if (tree_ports(decl) != 1) return value; tree_t p0 = tree_value(tree_param(value, 0)); tree_t ref = name_to_ref(p0); if (ref == NULL || class_of(ref) != C_SIGNAL) return value; tree_t conv = tree_new(T_CONV_FUNC); tree_set_loc(conv, tree_loc(value)); tree_set_value(conv, p0); tree_set_ident(conv, tree_ident(value)); tree_set_type(conv, tree_type(value)); tree_set_ref(conv, decl); return conv; } static void instantiate_subprogram(tree_t new, tree_t decl, tree_t body) { tree_t roots[] = { decl, body }; ident_t prefixes[] = { tree_ident(decl) }; ident_t dotted = ident_prefix(scope_prefix(nametab), tree_ident(new), '.'); new_instance(roots, body != NULL ? 2 :1, dotted, prefixes, 1); tree_t decl_copy = roots[0], body_copy = roots[1]; tree_t src = body_copy ?: decl_copy; tree_set_type(new, tree_type(src)); tree_set_flag(new, tree_flags(decl)); tree_set_global_flags(new, tree_global_flags(decl)); const int ngenerics = tree_generics(src); for (int i = 0; i < ngenerics; i++) tree_add_generic(new, tree_generic(src, i)); const int nports = tree_ports(src); for (int i = 0; i < nports; i++) tree_add_port(new, tree_port(src, i)); if (body != NULL) { const int ndecls = tree_decls(body_copy); for (int i = 0; i < ndecls; i++) tree_add_decl(new, tree_decl(body_copy, i)); const int nstmts = tree_stmts(body_copy); for (int i = 0; i < nstmts; i++) tree_add_stmt(new, tree_stmt(body_copy, i)); tree_set_flag(new, tree_flags(body)); tree_set_global_flags(new, tree_global_flags(body)); } // Allow recursive calls to the uninstantiated subprogram map_generic_subprogram(nametab, decl_copy, new); if (body != NULL) map_generic_subprogram(nametab, body_copy, new); } static void instantiate_package(tree_t new, tree_t pack, tree_t body) { assert(body == NULL || tree_primary(body) == pack); ident_t prefix = tree_ident(pack); tree_t container = tree_container(pack); if (container != pack) prefix = ident_prefix(tree_ident(container), prefix, '.'); tree_t roots[] = { pack, body }; ident_t prefixes[] = { prefix }; ident_t dotted = ident_prefix(scope_prefix(nametab), tree_ident(new), '.'); new_instance(roots, body != NULL ? 2 : 1, dotted, prefixes, 1); tree_t pack_copy = roots[0], body_copy = roots[1]; const int ngenerics = tree_generics(pack_copy); for (int i = 0; i < ngenerics; i++) tree_add_generic(new, tree_generic(pack_copy, i)); const int ndecls = tree_decls(pack_copy); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(pack_copy, i); if (tree_kind(d) == T_CONST_DECL && !tree_has_value(d)) continue; // Skip deferred constants tree_add_decl(new, d); } tree_set_global_flags(new, tree_global_flags(pack)); if (body != NULL) { // Copy all the declarations from the body into the package to // save keeping track of two separate units. The LRM says the // implicit instantiated package body is in the body of an // enclosing package if this is in a package declaration. Just // ignore that, it doesn't matter. const int ndecls = tree_decls(body_copy); for (int i = 0; i < ndecls; i++) tree_add_decl(new, tree_decl(body_copy, i)); tree_set_global_flags(new, tree_global_flags(body)); } } static void add_interface(tree_t container, tree_t decl, tree_kind_t kind) { if (kind == T_GENERIC_DECL) tree_add_generic(container, decl); else tree_add_port(container, decl); } static void ident_list_push(ident_list_t **list, ident_t i, loc_t loc) { ident_list_t *c = xmalloc(sizeof(ident_list_t)); c->ident = i; c->loc = loc; c->next = NULL; ident_list_t **it; for (it = list; *it; it = &((*it)->next)); *it = c; } static void _ident_list_cleanup(ident_list_t **list) { for (ident_list_t *it = *list, *tmp; it; it = tmp) { tmp = it->next; free(it); } *list = NULL; } static type_t get_subtype_for(tree_t expr) { type_t type = tree_type(expr); type_t sub = type_new(T_SUBTYPE); type_set_base(sub, type_base_recur(type)); const loc_t *loc = tree_loc(expr); tree_t c = tree_new(T_CONSTRAINT); tree_set_loc(c, loc); type_set_constraint(sub, c); if (type_is_record(type)) { tree_set_subkind(c, C_RECORD); const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { tree_t f = type_field(type, i); type_t ft = tree_type(f); if (type_is_unconstrained(ft)) { tree_t rref = tree_new(T_RECORD_REF); tree_set_ident(rref, tree_ident(f)); tree_set_loc(rref, loc); tree_set_ref(rref, f); tree_set_value(rref, expr); tree_set_type(rref, ft); tree_t ec = tree_new(T_ELEM_CONSTRAINT); tree_set_loc(ec, loc); tree_set_ident(ec, tree_ident(f)); tree_set_ref(ec, f); tree_set_type(ec, get_subtype_for(rref)); tree_add_range(c, ec); } } } else if (type_is_array(type)) { tree_set_subkind(c, C_INDEX); const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { tree_t rref = tree_new(T_ATTR_REF); tree_set_name(rref, expr); tree_set_ident(rref, ident_new("RANGE")); tree_set_loc(rref, loc); tree_set_subkind(rref, ATTR_RANGE); if (i > 0) { tree_t p = tree_new(T_LITERAL); tree_set_subkind(p, L_INT); tree_set_ival(p, i + 1); tree_set_loc(p, loc); tree_set_type(p, std_type(NULL, STD_UNIVERSAL_INTEGER)); add_param(rref, p, P_POS, NULL); } tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, rref); solve_types(nametab, r, NULL); tree_add_range(c, r); } type_set_elem(sub, get_element_subtype(expr)); } else if (type_is_scalar(type)) return type; // TODO: see test/regress/integer3.vhd else fatal_trace("unhandled type %s in get_subtype_for", type_pp(type)); return sub; } static type_t get_element_subtype(tree_t expr) { type_t type = tree_type(expr); assert(type_is_array(type)); type_t elem = type_elem(type); if (type_const_bounds(elem)) return elem; tree_t aref = tree_new(T_ARRAY_REF); tree_set_value(aref, expr); tree_set_type(aref, elem); tree_set_loc(aref, tree_loc(expr)); const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { tree_t left = tree_new(T_ATTR_REF); tree_set_loc(left, tree_loc(expr)); tree_set_name(left, expr); tree_set_subkind(left, ATTR_LEFT); tree_set_ident(left, ident_new("LEFT")); tree_set_type(left, index_type_of(type, i)); add_param(aref, left, P_POS, NULL); } return get_subtype_for(aref); } static type_t apply_subtype_attribute(tree_t aref) { assert(tree_subkind(aref) == ATTR_SUBTYPE); tree_t name = tree_name(aref); type_t type = get_type_or_null(name); if (type == NULL) { parse_error(tree_loc(aref), "prefix of 'SUBTYPE attribute does not " "have a type"); return type_new(T_NONE); } else if (type_const_bounds(type)) return type; else { // Construct a new subtype using the constraints from the prefix return get_subtype_for(name); } } static type_t apply_element_attribute(tree_t aref) { assert(tree_subkind(aref) == ATTR_ELEMENT); tree_t prefix = tree_name(aref); type_t type = get_type_or_null(prefix); if (type == NULL) { parse_error(tree_loc(aref), "prefix of 'ELEMENT attribute does not " "have a type"); return type_new(T_NONE); } else if (type_is_none(type)) return type; else if (!type_is_array(type)) { parse_error(tree_loc(aref), "prefix of 'ELEMENT attribute must be an " "array type"); return type_new(T_NONE); } return get_element_subtype(prefix); } static type_t apply_designated_subtype_attribute(tree_t aref) { assert(tree_subkind(aref) == ATTR_DESIGNATED_SUBTYPE); type_t type = get_type_or_null(tree_name(aref)); if (type == NULL) { parse_error(tree_loc(aref), "prefix of 'DESIGNATED_SUBTYPE attribute " "does not have a type"); return type_new(T_NONE); } else if (!type_is_file(type) && !type_is_access(type)) { parse_error(tree_loc(aref), "prefix of 'DESIGNATED_SUBTYPE attribute " "must be an access or file type"); return type_new(T_NONE); } return type_designated(type); } static type_t apply_base_attribute(tree_t aref) { assert(tree_subkind(aref) == ATTR_BASE); tree_t name = tree_name(aref); type_t type = NULL; if (tree_kind(name) == T_REF && tree_has_ref(name)) { tree_t decl = aliased_type_decl(tree_ref(name)); if (decl != NULL) type = tree_type(decl); } if (type == NULL) { parse_error(tree_loc(aref), "prefix of 'BASE attribute must be a type " "or subtype declaration"); return type_new(T_NONE); } else if (type_kind(type) == T_SUBTYPE) return type_base(type); else return type; } static type_t apply_index_attribute(tree_t aref) { assert(tree_subkind(aref) == ATTR_INDEX); type_t type = get_type_or_null(tree_name(aref)); if (!type_is_array(type)) { parse_error(tree_loc(aref), "prefix of 'INDEX attribute must be an " "array type"); return type_new(T_NONE); } const int ndims = dimension_of(type); const int nparams = tree_params(aref); int index = 0; if (nparams == 1) { // The LRM allows any locally static expression here but that is // difficult to implement and doesn't seem useful tree_t p = tree_value(tree_param(aref, 0)); if (tree_kind(p) != T_LITERAL) { parse_error(tree_loc(p), "only integer literals are supported " "for 'INDEX parameter"); return type_new(T_NONE); } const int64_t ival = tree_ival(p); if (ival < 1 || ival > ndims) { parse_error(tree_loc(p), "'INDEX parameter for type %s must be " "between 1 and %d", type_pp(type), ndims); return type_new(T_NONE); } index = ival - 1; } return index_type_of(type, index); } static type_t apply_type_attribute(tree_t aref) { switch (tree_subkind(aref)) { case ATTR_SUBTYPE: return apply_subtype_attribute(aref); case ATTR_ELEMENT: return apply_element_attribute(aref); case ATTR_BASE: return apply_base_attribute(aref); case ATTR_DESIGNATED_SUBTYPE: return apply_designated_subtype_attribute(aref); case ATTR_INDEX: return apply_index_attribute(aref); default: parse_error(tree_loc(aref), "attribute name is not a valid type mark"); return type_new(T_NONE); } } static void implicit_signal_attribute(tree_t aref) { if (find_enclosing(nametab, S_SUBPROGRAM) != NULL) { parse_error(tree_loc(aref), "implicit signal %s cannot be used in a " "subprogram body", istr(tree_ident(aref))); return; } tree_t b = find_enclosing(nametab, S_CONCURRENT_BLOCK); if (b == NULL) { parse_error(tree_loc(aref), "implicit signal %s cannot be used in " "this context", istr(tree_ident(aref))); return; } tree_t prefix = tree_name(aref); const attr_kind_t attr = tree_subkind(aref); tree_t delay = NULL; if (attr != ATTR_TRANSACTION && tree_params(aref) > 0) delay = tree_value(tree_param(aref, 0)); LOCAL_TEXT_BUF tb = tb_new(); tree_t ref = name_to_ref(prefix); if (ref != NULL) tb_istr(tb, tree_ident(ref)); tb_append(tb, '$'); switch (attr) { case ATTR_DELAYED: tb_cat(tb, "delayed"); break; case ATTR_TRANSACTION: tb_cat(tb, "transaction"); break; case ATTR_STABLE: tb_cat(tb, "stable"); break; case ATTR_QUIET: tb_cat(tb, "quiet"); break; default: break; } if (delay != NULL && tree_kind(delay) == T_LITERAL) { tb_printf(tb, "_%"PRIi64, tree_ival(delay)); if (tree_has_ident(delay)) tb_printf(tb, "_%s", istr(tree_ident(delay))); } else if (delay != NULL && tree_kind(delay) == T_REF) tb_printf(tb, "_%s", istr(tree_ident(delay))); ident_t id = ident_new(tb_get(tb)); implicit_kind_t kind; switch (attr) { case ATTR_DELAYED: kind = IMPLICIT_DELAYED; break; case ATTR_STABLE: kind = IMPLICIT_STABLE; break; case ATTR_QUIET: kind = IMPLICIT_QUIET; break; case ATTR_TRANSACTION: kind = IMPLICIT_TRANSACTION; break; default: fatal_trace("invalid implicit signal attribute"); } const int ndecls = tree_decls(b); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(b, i); if (tree_kind(d) != T_IMPLICIT_SIGNAL) continue; else if (tree_ident(d) != id || tree_subkind(d) != kind) continue; bool match = false; tree_t value = tree_value(d); if (attr == ATTR_DELAYED || attr == ATTR_STABLE || attr == ATTR_QUIET) { assert(tree_kind(value) == T_WAVEFORM); match = same_tree(tree_value(value), prefix) && ((delay == NULL && !tree_has_delay(value)) || (delay != NULL && tree_has_delay(value) && same_tree(tree_delay(value), delay))); } else if (attr == ATTR_TRANSACTION) match = same_tree(value, prefix); if (match) { tree_set_value(aref, make_ref(d)); return; } else { tb_append(tb, '_'); id = ident_new(tb_get(tb)); } } tree_t imp = tree_new(T_IMPLICIT_SIGNAL); tree_set_ident(imp, id); tree_set_loc(imp, tree_loc(aref)); tree_set_subkind(imp, kind); if (attr == ATTR_TRANSACTION) { tree_set_type(imp, std_type(NULL, STD_BIT)); tree_set_value(imp, prefix); } else { tree_t w = tree_new(T_WAVEFORM); tree_set_loc(w, CURRENT_LOC); tree_set_value(w, prefix); if (delay != NULL) tree_set_delay(w, delay); tree_set_type(imp, solve_types(nametab, aref, NULL)); tree_set_value(imp, w); } tree_add_decl(b, imp); tree_set_value(aref, make_ref(imp)); } static attr_kind_t parse_predefined_attr(ident_t ident) { static struct { const char *str; attr_kind_t attr; vhdl_standard_t std; uint32_t hash; ident_t ident; } predef[] = { { "RANGE", ATTR_RANGE }, { "REVERSE_RANGE", ATTR_REVERSE_RANGE }, { "LENGTH", ATTR_LENGTH }, { "LEFT", ATTR_LEFT }, { "RIGHT", ATTR_RIGHT }, { "LOW", ATTR_LOW }, { "HIGH", ATTR_HIGH }, { "EVENT", ATTR_EVENT }, { "ACTIVE", ATTR_ACTIVE }, { "IMAGE", ATTR_IMAGE }, { "ASCENDING", ATTR_ASCENDING }, { "LAST_VALUE", ATTR_LAST_VALUE }, { "LAST_EVENT", ATTR_LAST_EVENT }, { "LAST_ACTIVE", ATTR_LAST_ACTIVE }, { "PATH_NAME", ATTR_PATH_NAME }, { "INSTANCE_NAME", ATTR_INSTANCE_NAME }, { "SIMPLE_NAME", ATTR_SIMPLE_NAME }, { "DELAYED", ATTR_DELAYED }, { "STABLE", ATTR_STABLE }, { "QUIET", ATTR_QUIET }, { "TRANSACTION", ATTR_TRANSACTION }, { "DRIVING_VALUE", ATTR_DRIVING_VALUE }, { "DRIVING", ATTR_DRIVING }, { "VALUE", ATTR_VALUE }, { "SUCC", ATTR_SUCC }, { "PRED", ATTR_PRED }, { "LEFTOF", ATTR_LEFTOF }, { "RIGHTOF", ATTR_RIGHTOF }, { "POS", ATTR_POS }, { "VAL", ATTR_VAL }, { "BASE", ATTR_BASE }, { "ELEMENT", ATTR_ELEMENT, STD_08 }, { "CONVERSE", ATTR_CONVERSE, STD_19 }, { "DESIGNATED_SUBTYPE", ATTR_DESIGNATED_SUBTYPE, STD_19 }, { "INDEX", ATTR_INDEX, STD_19 }, { "REFLECT", ATTR_REFLECT, STD_19 }, }; INIT_ONCE({ for (int i = 0; i < ARRAY_LEN(predef); i++) { predef[i].ident = ident_new(predef[i].str); predef[i].hash = ident_casehash(predef[i].ident); } }); const vhdl_standard_t std = standard(); const uint32_t hash = ident_casehash(ident); for (int i = 0; i < ARRAY_LEN(predef) && predef[i].std <= std; i++) { if (predef[i].hash == hash && ident_casecmp(predef[i].ident, ident)) return predef[i].attr; } return ATTR_USER; } static void add_generic_type_op(tree_t parent, int nargs, type_t type, type_t result, const char *name) { ident_t id = ident_new(name); type_t ftype = type_new(T_SIGNATURE); type_set_ident(ftype, id); type_set_result(ftype, result); for (int i = 0; i < nargs; i++) type_add_param(ftype, type); tree_t p = tree_new(T_GENERIC_DECL); tree_set_class(p, C_FUNCTION); tree_set_ident(p, id); tree_set_type(p, ftype); tree_set_subkind(p, PORT_IN); tree_set_loc(p, CURRENT_LOC); tree_set_flag(p, TREE_F_PREDEFINED); // LRM 08 section 6.5.3.1: the *predefined* [..] operators, // implicitly declared as formal generic subprograms // // LCS2016-59 changed the wording here: additional operators are // implicitly declared as formal generic subprograms with an // interface subprogram default in form of a box (<>) // // The 2008 LRM seems to be ambiguous as to whether we should map the // predefined operator or do a lookup for a matching visible // operator. We always follow the 2019 behaviour here. tree_t box = tree_new(T_BOX); tree_set_loc(box, CURRENT_LOC); tree_set_value(p, box); for (int j = 0; j < nargs; j++) { tree_t arg = tree_new(T_PARAM_DECL); tree_set_ident(arg, ident_new(j == 0 ? "L" : "R")); tree_set_type(arg, type); tree_set_subkind(arg, PORT_IN); tree_set_class(arg, C_CONSTANT); tree_set_loc(arg, CURRENT_LOC); tree_add_port(p, arg); } add_interface(parent, p, T_GENERIC_DECL); insert_name(nametab, p, NULL); } static void declare_generic_ops(tree_t parent, type_t type) { type_t std_bool = std_type(NULL, STD_BOOLEAN); type_t std_string = std_type(NULL, STD_STRING); const gtype_class_t class = type_subkind(type); switch (class) { case GTYPE_INTEGER: add_generic_type_op(parent, 2, type, type, "\"**\""); // Fall-through case GTYPE_PHYSICAL: add_generic_type_op(parent, 2, type, type, "\"mod\""); add_generic_type_op(parent, 2, type, type, "\"rem\""); // Fall-through case GTYPE_FLOATING: add_generic_type_op(parent, 2, type, type, "\"+\""); add_generic_type_op(parent, 2, type, type, "\"-\""); add_generic_type_op(parent, 1, type, type, "\"+\""); add_generic_type_op(parent, 1, type, type, "\"-\""); if (class != GTYPE_PHYSICAL) { add_generic_type_op(parent, 2, type, type, "\"*\""); add_generic_type_op(parent, 2, type, type, "\"/\""); } add_generic_type_op(parent, 1, type, type, "\"abs\""); // Fall-through case GTYPE_DISCRETE: case GTYPE_SCALAR: add_generic_type_op(parent, 2, type, std_bool, "\"<\""); add_generic_type_op(parent, 2, type, std_bool, "\">\""); add_generic_type_op(parent, 2, type, std_bool, "\"<=\""); add_generic_type_op(parent, 2, type, std_bool, "\">=\""); add_generic_type_op(parent, 2, type, type, "MINIMUM"); add_generic_type_op(parent, 2, type, type, "MAXIMUM"); add_generic_type_op(parent, 1, type, std_string, "TO_STRING"); // Fall-through case GTYPE_ARRAY: case GTYPE_FILE: case GTYPE_ACCESS: case GTYPE_PRIVATE: add_generic_type_op(parent, 2, type, std_bool, "\"=\""); add_generic_type_op(parent, 2, type, std_bool, "\"/=\""); break; } if (class == GTYPE_ACCESS) { ident_t id = ident_new("DEALLOCATE"); type_t ftype = type_new(T_SIGNATURE); type_set_ident(ftype, id); type_add_param(ftype, type); tree_t p = tree_new(T_GENERIC_DECL); tree_set_class(p, C_PROCEDURE); tree_set_ident(p, id); tree_set_type(p, ftype); tree_set_subkind(p, PORT_IN); tree_set_loc(p, CURRENT_LOC); tree_set_flag(p, TREE_F_PREDEFINED); tree_t box = tree_new(T_BOX); tree_set_loc(box, CURRENT_LOC); tree_set_value(p, box); tree_t arg = tree_new(T_PARAM_DECL); tree_set_ident(arg, ident_new("PTR")); tree_set_type(arg, type); tree_set_subkind(arg, PORT_INOUT); tree_set_class(arg, C_VARIABLE); tree_set_loc(arg, CURRENT_LOC); tree_add_port(p, arg); add_interface(parent, p, T_GENERIC_DECL); insert_name(nametab, p, NULL); } else if (class == GTYPE_ARRAY) { // Declare predefined operators for any anonymous element or index type_t elem = type_elem(type); if (type_kind(elem) == T_GENERIC && !type_has_ident(elem)) declare_generic_ops(parent, elem); const int nindex = type_indexes(type); for (int i = 0; i < nindex; i++) { type_t index = type_index(type, i); if (type_kind(index) == T_GENERIC && !type_has_ident(index)) declare_generic_ops(parent, index); } } } static bool is_vhdl_infix_op(token_t tok) { return tok == tEQ || tok == tNEQ || tok == tLT || tok == tGT || tok == tLE || tok == tGE || tok == tNAND || tok == tNOR || tok == tXOR || tok == tXNOR || tok == tMOD || tok == tREM || tok == tPLUS || tok == tMINUS || tok == tTIMES || tok == tOVER || tok == tPOWER || tok == tMEQ || tok == tMNEQ || tok == tMLT || tok == tMLE || tok == tMGT || tok == tMGE; } static void add_predef_alias(tree_t t, void *context) { tree_t parent = context; assert(is_subprogram(t)); tree_t a = tree_new(T_ALIAS); tree_set_loc(a, CURRENT_LOC); tree_set_ident(a, tree_ident(t)); tree_set_value(a, make_ref(t)); tree_set_type(a, tree_type(t)); tree_set_flag(a, TREE_F_PREDEFINED); insert_name(nametab, a, NULL); tree_add_decl(parent, a); } static void convert_universal_bounds(tree_t r) { // LRM 08 section 5.3.2.2: an implicit conversion to the predefined // type INTEGER is assumed if the type of both bounds is the type // universal_integer assert(tree_kind(r) == T_RANGE); const range_kind_t kind = tree_subkind(r); if (kind != RANGE_TO && kind != RANGE_DOWNTO) return; tree_t left = tree_left(r); tree_t right = tree_right(r); type_t ltype = tree_type(left); type_t rtype = tree_type(right); type_t uint = std_type(NULL, STD_UNIVERSAL_INTEGER); if (!type_eq(ltype, uint) || !type_eq(rtype, uint)) return; type_t std_int = std_type(NULL, STD_INTEGER); tree_set_type(r, std_int); tree_t lconv = tree_new(T_TYPE_CONV); tree_set_loc(lconv, tree_loc(left)); tree_set_type(lconv, std_int); tree_set_value(lconv, left); tree_set_left(r, lconv); tree_t rconv = tree_new(T_TYPE_CONV); tree_set_loc(rconv, tree_loc(right)); tree_set_type(rconv, std_int); tree_set_value(rconv, right); tree_set_right(r, rconv); } static type_t name_to_type_mark(tree_t name) { type_t type = solve_types(nametab, name, NULL); if (type_is_none(type)) return type; const tree_kind_t namek = tree_kind(name); if (namek == T_ATTR_REF) return type; tree_t decl = NULL; if (namek == T_REF && tree_has_ref(name)) decl = aliased_type_decl(tree_ref(name)); if (decl == NULL) { diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); const char *id = namek == T_REF ? istr(tree_ident(name)) : NULL; diag_printf(d, "type mark%s%s does not denote a type or a subtype", id ? " " : "", id ?: ""); diag_hint(d, CURRENT_LOC, "%s is a %s name", id ?: "this", class_str(class_of(name))); diag_emit(d); return type_new(T_NONE); } return tree_type(decl); } static void find_disconnect_specification(tree_t guard, tree_t target) { if (tree_kind(target) != T_REF) return; else if (!tree_has_ref(target)) return; tree_t decl = tree_ref(target); // TODO: use insert_spec for this ident_t name = ident_prefix(tree_ident(decl), ident_new("disconnect"), '$'); tree_t spec = NULL; query_name(nametab, name, &spec); if (spec != NULL) tree_set_spec(guard, spec); } static tree_t find_subprogram_body(tree_t decl) { const tree_kind_t decl_kind = tree_kind(decl); if (decl_kind == T_FUNC_BODY || decl_kind == T_PROC_BODY) return decl; // Attempt to load the package body if available tree_t pack = tree_container(decl); if (tree_kind(pack) != T_PACKAGE) return NULL; tree_t du = find_enclosing(nametab, S_DESIGN_UNIT); if (du == pack) return NULL; // Avoid referencing old version of current package tree_t pack_body, d; if (tree_kind(du) == T_PACK_BODY && tree_primary(du) == pack) pack_body = du; else if ((pack_body = body_of(pack)) == NULL) return NULL; type_t type = tree_type(decl); ident_t id = tree_ident(decl); for (int nth = 0; (d = get_local_decl(nametab, pack_body, id, nth)); nth++) { if (is_subprogram(d) && is_body(d) && type_eq(tree_type(d), type)) return d; } return NULL; } static void package_body_deferred_instantiation(tree_t pack, tree_t container) { // LRM 08 section 4.4: if the subprogram instantiation declaration // occurs immediately within an enclosing package declaration, the // generic-mapped subprogram body occurs at the end of the package // body corresponding to the enclosing package declaration assert(standard() >= STD_08); const int ndecls = tree_decls(pack); for (int i = 0; i < ndecls; i++) { tree_t decl = tree_decl(pack, i); const tree_kind_t dkind = tree_kind(decl); if (dkind != T_FUNC_INST && dkind != T_PROC_INST) continue; else if (!tree_has_ref(decl)) continue; tree_t ref = tree_ref(decl); if (is_body(ref)) continue; tree_t body = find_subprogram_body(ref); if (body == NULL) { diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); diag_printf(d, "subprogram %s cannot be instantiated until its " "body has been analysed", type_pp(tree_type(decl))); diag_hint(d, tree_loc(decl), "subprogram instantiation in package " "declarative part"); diag_hint(d, NULL, "the instantiated subprogram body occurs at " "the end of the package body corresponding to the " "enclosing package declaration"); diag_lrm(d, STD_08, "4.4"); diag_emit(d); } else { tree_t inst = tree_new(dkind); tree_set_ident(inst, tree_ident(decl)); tree_set_ident2(inst, tree_ident2(decl)); tree_set_ref(inst, body); instantiate_subprogram(inst, ref, body); hash_t *gmap = hash_new(16); const int ngenmaps = tree_genmaps(decl); for (int i = 0; i < ngenmaps; i++) { tree_t map = tree_genmap(decl, i); assert(tree_subkind(map) == P_POS); tree_add_genmap(inst, map); tree_t g = tree_generic(inst, tree_pos(map)); tree_t value = tree_value(map); switch (tree_class(g)) { case C_TYPE: hash_put(gmap, tree_type(g), tree_type(value)); break; case C_FUNCTION: case C_PROCEDURE: hash_put(gmap, g, tree_ref(value)); break; case C_CONSTANT: if (is_literal(value)) hash_put(gmap, g, value); break; default: should_not_reach_here(); } } instance_fixup(inst, gmap); tree_add_decl(container, inst); } } } static tree_t find_generic_subprogram_body(tree_t inst, tree_t decl) { tree_t body = find_subprogram_body(decl); if (body == NULL) { tree_t du = find_enclosing(nametab, S_DESIGN_UNIT); if (tree_kind(du) != T_PACKAGE) parse_error(CURRENT_LOC, "subprogram %s cannot be instantiated " "until its body has been analysed", istr(tree_ident(decl))); else { // Will be instantiated at end of package body tree_set_ref(inst, decl); tree_set_global_flags(inst, TREE_GF_DEFERRED_INST); } } else tree_set_ref(inst, body); return body; } static psl_node_t with_default_clock(psl_node_t prop) { if (psl_kind(prop) == P_CLOCKED) return prop; psl_node_t def = find_default_clock(nametab); if (def == NULL) return prop; psl_node_t p = psl_new(P_CLOCKED); psl_set_value(p, prop); psl_set_ref(p, def); psl_set_loc(p, psl_loc(prop)); return p; } //////////////////////////////////////////////////////////////////////////////// // Parser rules static ident_t p_identifier(void) { // basic_identifier | extended_identifier if (consume(tID)) return last_lval.ident; else return error_marker(); } static ident_t p_selected_identifier(void) { // identifier { . identifier } ident_t id = p_identifier(); while (optional(tDOT)) id = ident_prefix(id, p_identifier(), '.'); return id; } static ident_list_t *p_identifier_list(void) { // identifier { , identifier } ident_list_t *result = NULL; ident_list_push(&result, p_identifier(), last_loc); while (optional(tCOMMA)) ident_list_push(&result, p_identifier(), last_loc); return result; } static ident_t p_operator_symbol(void) { // string_literal consume(tSTRING); char *s = last_lval.str; for (char *p = s; *p != '\0'; p++) *p = tolower_iso88591(*p); ident_t id = ident_new(s); if (!is_operator_symbol(id)) parse_error(CURRENT_LOC, "%s is not an operator symbol", s); free(s); return id; } static void p_library_clause(tree_t unit) { // library logical_name_list ; BEGIN("library clause"); consume(tLIBRARY); LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t l = tree_new(T_LIBRARY); tree_set_ident(l, it->ident); tree_set_loc(l, &(it->loc)); tree_add_context(unit, l); lib_t lib = lib_find(it->ident); if (lib == NULL) { LOCAL_TEXT_BUF tb = tb_new(); lib_print_search_paths(tb); diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); diag_printf(d, "library %s not found", istr(it->ident)); lib_search_paths_to_diag(d); diag_emit(d); } else tree_set_ident2(l, lib_name(lib)); insert_name(nametab, l, NULL); } } static void p_use_clause(tree_t unit, add_func_t addf) { // use selected_name { , selected_name } ; BEGIN("use clause"); consume(tUSE); do { tree_t u = tree_new(T_USE); ident_t i1 = p_identifier(), i2 = NULL; consume(tDOT); do { i1 = ident_prefix(i1, i2, '.'); switch (peek()) { case tID: i2 = p_identifier(); break; case tSTRING: i2 = p_operator_symbol(); break; case tALL: consume(tALL); i2 = well_known(W_ALL); break; default: expect(tID, tSTRING, tALL); i2 = NULL; break; } } while (optional(tDOT)); tree_set_ident(u, i1); tree_set_ident2(u, i2); tree_set_loc(u, CURRENT_LOC); (*addf)(unit, u); tree_t head = resolve_name(nametab, CURRENT_LOC, i1); if (head == NULL) continue; const tree_kind_t kind = tree_kind(head); if (kind == T_LIBRARY && !tree_has_ident2(head)) { // Library declaration had an error } else if (is_uninstantiated_package(head)) parse_error(CURRENT_LOC, "cannot use an uninstantiated package"); else if (kind == T_LIBRARY || kind == T_PACKAGE || kind == T_PACK_INST || (kind == T_GENERIC_DECL && tree_class(head) == C_PACKAGE)) { tree_set_ref(u, head); insert_names_from_use(nametab, u); } else parse_error(CURRENT_LOC, "%s is not a library or %spackage", istr(i1), standard() >= STD_08 ? "instantiated " : ""); } while (optional(tCOMMA)); consume(tSEMI); } static void p_context_reference(tree_t unit) { // context selected_name { , selected_name } ; BEGIN("context reference"); consume(tCONTEXT); do { ident_t name = p_selected_identifier(); tree_t c = tree_new(T_CONTEXT_REF); tree_set_ident(c, name); tree_set_loc(c, CURRENT_LOC); tree_t ctx = resolve_name(nametab, CURRENT_LOC, name); if (ctx != NULL && tree_kind(ctx) == T_CONTEXT) { insert_names_from_context(nametab, ctx); tree_set_ref(c, ctx); } else if (ctx != NULL) parse_error(CURRENT_LOC, "%s%s is not a context declaration", is_design_unit(ctx) ? "design unit " : "", istr(name)); tree_add_context(unit, c); } while (optional(tCOMMA)); consume(tSEMI); } static void p_context_item(tree_t unit) { // library_clause | use_clause | 2008: context_reference BEGIN("context item"); switch (peek()) { case tLIBRARY: p_library_clause(unit); break; case tUSE: p_use_clause(unit, tree_add_context); break; case tCONTEXT: p_context_reference(unit); break; default: expect(tLIBRARY, tUSE, tCONTEXT); } } static void p_context_clause(tree_t unit) { // { context_item } BEGIN("context clause"); const int start_errors = error_count(); while (scan(tLIBRARY, tUSE, tCONTEXT)) { if (peek() == tCONTEXT && peek_nth(3) == tIS) break; else p_context_item(unit); } // Suppress further errors if there are errors in the context if (error_count() > start_errors) suppress_errors(nametab); } static port_mode_t p_mode(void) { // in | out | inout | buffer | linkage switch (one_of(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) { case tIN: return PORT_IN; case tOUT: return PORT_OUT; case tINOUT: return PORT_INOUT; case tBUFFER: return PORT_BUFFER; case tLINKAGE: return PORT_LINKAGE; default: return PORT_INVALID; } } static tree_t p_range(tree_t left) { // attribute_name | simple_expression direction simple_expression EXTEND("range"); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_ERROR); if (is_range_expr(left)) { tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, left); tree_set_loc(r, tree_loc(left)); } else { tree_set_left(r, left); switch (one_of(tTO, tDOWNTO)) { case tTO: tree_set_subkind(r, RANGE_TO); tree_set_right(r, p_expression()); break; case tDOWNTO: tree_set_subkind(r, RANGE_DOWNTO); tree_set_right(r, p_expression()); break; } tree_set_loc(r, CURRENT_LOC); } return r; } static tree_t p_range_constraint(type_t constraint) { // range range BEGIN("range constraint"); consume(tRANGE); tree_t t = tree_new(T_CONSTRAINT); tree_set_subkind(t, C_RANGE); tree_t expr1 = p_expression(); switch (peek()) { case tTO: case tDOWNTO: { tree_t r = p_range(expr1); solve_types(nametab, r, constraint); tree_add_range(t, r); } break; default: { tree_t r = tree_new(T_RANGE); tree_set_loc(r, tree_loc(expr1)); tree_set_subkind(r, RANGE_EXPR); tree_set_value(r, expr1); solve_types(nametab, r, constraint); tree_add_range(t, r); } } tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_discrete_range(tree_t head) { // subtype_indication | range BEGIN_WITH_HEAD("discrete range", head); tree_t expr1 = head ?: p_expression(); switch (peek()) { case tTO: case tDOWNTO: case tTICK: return p_range(expr1); case tRANGE: { type_t constraint = solve_types(nametab, expr1, NULL); const bool is_type = tree_kind(expr1) == T_REF && tree_has_ref(expr1) && is_type_decl(tree_ref(expr1)); if (!is_type && !type_is_none(constraint)) { parse_error(tree_loc(expr1), "expected type mark while parsing " "discrete range"); constraint = type_new(T_NONE); } consume(tRANGE); tree_t left = p_expression(); tree_t r = p_range(left); solve_types(nametab, r, constraint); tree_set_type(r, constraint); return r; } default: { type_t type = solve_types(nametab, expr1, NULL); if (tree_kind(expr1) == T_ATTR_REF) return p_range(expr1); // Special attributes such as 'RANGE else if (tree_kind(expr1) == T_REF && tree_has_ref(expr1)) { // A type name T may stand in for a discrete range // equivalent to T'RANGE if (aliased_type_decl(tree_ref(expr1)) != NULL) { tree_t tmp = tree_new(T_ATTR_REF); tree_set_name(tmp, expr1); tree_set_ident(tmp, ident_new("RANGE")); tree_set_loc(tmp, tree_loc(expr1)); tree_set_subkind(tmp, ATTR_RANGE); return p_range(tmp); } else parse_error(CURRENT_LOC, "name %s in discrete range does not " "refer to a type", istr(tree_ident(expr1))); } else if (!type_is_none(type)) parse_error(CURRENT_LOC, "expecting a discrete range"); // Not a valid discrete range tree_t r = tree_new(T_RANGE); tree_set_loc(r, CURRENT_LOC); tree_set_subkind(r, RANGE_ERROR); return r; } } } static tree_t p_slice_name(tree_t prefix, tree_t head) { // prefix ( discrete_range ) EXTEND("slice name"); type_t type = prefix_type(prefix, NULL); if (type != NULL && type_is_access(type)) { prefix = implicit_dereference(prefix); type = tree_type(prefix); } tree_t t = tree_new(T_ARRAY_SLICE); tree_set_value(t, prefix); type_t index_type = NULL; if (type != NULL && type_is_array(type)) index_type = index_type_of(type, 0); tree_t r = p_discrete_range(head); solve_types(nametab, r, index_type); convert_universal_bounds(r); tree_add_range(t, r); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_formal_part(type_t *signature) { // formal_designator // | name ( formal_designator ) // | type_mark ( formal_designator ) BEGIN("formal part"); tree_t name = p_name(0); switch (tree_kind(name)) { case T_RECORD_REF: case T_ARRAY_REF: case T_ARRAY_SLICE: case T_TYPE_CONV: break; case T_FCALL: if (tree_params(name) == 1) tree_set_flag(name, TREE_F_CONVERSION); break; case T_REF: // 2019 allows signature for generic formal designator if (peek() == tLSQUARE) { require_std(STD_19, "signature in generic formal designator"); *signature = p_signature(); tree_set_loc(name, CURRENT_LOC); } break; default: parse_error(CURRENT_LOC, "illegal formal designator"); return error_expr(); } return name; } static tree_t p_actual_part(class_t class, formal_kind_t kind) { // actual_designator // | name ( actual_designator ) // | type_mark ( actual_designator ) BEGIN("actual part"); if (optional(tOPEN)) { tree_t t = tree_new(T_OPEN); tree_set_loc(t, CURRENT_LOC); return t; } if (class == C_FUNCTION || class == C_PROCEDURE || class == C_PACKAGE) return p_name(N_SUBPROGRAM); else if (class == C_TYPE) { type_t type = p_subtype_indication(); tree_t ref = tree_new(T_TYPE_REF); tree_set_ident(ref, type_ident(type)); tree_set_type(ref, type); tree_set_loc(ref, CURRENT_LOC); return ref; } if (optional(tINERTIAL)) { require_std(STD_08, "inertial in actual designator"); tree_t expr = p_expression(); if (kind == F_PORT_MAP) { tree_t w = tree_new(T_INERTIAL); tree_set_loc(w, CURRENT_LOC); tree_set_value(w, expr); return w; } else { parse_error(CURRENT_LOC, "the reserved word INERTIAL can only be " "used in port map association elements"); return expr; } } // If the actual part takes either the second or third form above then the // argument to the function call is the actual designator but only if the // call is to a named function rather than an operator. // This is important for identifying conversion functions later. const token_t next = peek(); const bool had_name = (next == tID || next == tSTRING); tree_t designator = p_expression(); const bool could_be_conversion = had_name && tree_kind(designator) == T_FCALL && tree_params(designator) == 1; if (could_be_conversion) tree_set_flag(designator, TREE_F_CONVERSION); return designator; } static void p_association_element(tree_t map, int pos, tree_t unit, formal_kind_t kind) { // [ formal_part => ] actual_part BEGIN("association element"); tree_t p = tree_new(T_PARAM); const look_params_t lookp = { .look = { tASSOC }, .stop = { tCOMMA, tRPAREN }, .abort = tSEMI, .nest_in = tLPAREN, .nest_out = tRPAREN, .depth = 0 }; class_t class = C_DEFAULT; type_t type = NULL; if (look_for(&lookp)) { tree_set_subkind(p, P_NAMED); push_scope_for_formals(nametab, kind, unit); type_t signature = NULL; tree_t name = p_formal_part(&signature); tree_t ref = name_to_ref(name); if (ref != NULL && tree_has_ref(ref)) { tree_t decl = tree_ref(ref); const tree_kind_t kind = tree_kind(decl); if (kind == T_PORT_DECL || kind == T_PARAM_DECL || kind == T_GENERIC_DECL) class = tree_class(decl); } if (signature != NULL && kind != F_GENERIC_MAP) { parse_error(tree_loc(name), "a signature is only allowed in a " "generic formal designator"); signature = NULL; } if (class != C_PACKAGE && (kind == F_GENERIC_MAP || kind == F_PORT_MAP)) type = solve_types(nametab, name, signature); if (kind == F_PORT_MAP && tree_kind(name) == T_FCALL) name = fcall_to_conv_func(name); tree_set_name(p, name); pop_scope(nametab); consume(tASSOC); } else { tree_set_subkind(p, P_POS); tree_set_pos(p, pos); tree_t formal = NULL; switch (kind) { case F_GENERIC_MAP: if (unit != NULL && pos < tree_generics(unit)) formal = tree_generic(unit, pos); break; case F_PORT_MAP: if (unit != NULL && pos < tree_ports(unit)) formal = tree_port(unit, pos); break; default: break; } if (formal != NULL && (class = tree_class(formal)) != C_PACKAGE) type = tree_type(formal); } tree_t value = p_actual_part(class, kind); if (kind == F_PORT_MAP) solve_types(nametab, value, type); else if (kind == F_GENERIC_MAP && class != C_PACKAGE) { type_t value_type = solve_types(nametab, value, type); // Make the mapped type available immediately as it may be used in // later actuals if (class == C_TYPE && type != NULL) map_generic_type(nametab, type, value_type); } if (kind == F_PORT_MAP && tree_kind(value) == T_FCALL) value = fcall_to_conv_func(value); tree_set_value(p, value); tree_set_loc(p, CURRENT_LOC); switch (kind) { case F_GENERIC_MAP: tree_add_genmap(map, p); break; case F_PORT_MAP: case F_SUBPROGRAM: tree_add_param(map, p); break; default: fatal_trace("unexpected formal kind in p_association_element"); } } static void p_association_list(tree_t map, tree_t unit, formal_kind_t kind) { // association_element { , association_element } BEGIN("association list"); int pos = 0; do { p_association_element(map, pos++, unit, kind); } while (optional(tCOMMA)); } static void p_actual_parameter_part(tree_t call) { // association_list BEGIN("actual parameter part"); p_association_list(call, call, F_SUBPROGRAM); } static void p_parameter_map_aspect(tree_t call) { // [ parameter map ] ( parameter_association_list ) BEGIN("actual parameter part"); consume(tPARAMETER); consume(tMAP); require_std(STD_19, "parameter map aspect"); consume(tLPAREN); p_association_list(call, call, F_SUBPROGRAM); consume(tRPAREN); } static tree_t p_function_call(ident_t id, tree_t prefix) { // name [ ( actual_parameter_part ) ] // 2019: name [ generic_map_aspect] [ parameter_map_aspect ] EXTEND("function call"); tree_t call; if (prefix != NULL) { call = tree_new(T_PROT_FCALL); tree_set_ident(call, id); tree_set_name(call, prefix); } else { call = tree_new(T_FCALL); tree_set_ident(call, id); } if (peek() == tGENERIC) { tree_t inst = tree_new(T_FUNC_INST); tree_set_ident(inst, ident_prefix(id, ident_uniq("inst"), '$')); tree_t decl = resolve_uninstantiated_subprogram(nametab, CURRENT_LOC, id, NULL); if (decl != NULL) { tree_t body = find_generic_subprogram_body(inst, decl); instantiate_subprogram(inst, decl, body); } else { // Create a dummy subprogram type to avoid later errors type_t type = type_new(T_SIGNATURE); type_set_ident(type, id); type_set_result(type, type_new(T_NONE)); tree_set_type(inst, type); } p_generic_map_aspect(inst, inst); require_std(STD_19, "generic map on function call"); tree_set_loc(inst, CURRENT_LOC); sem_check(inst, nametab); hash_t *map = get_generic_map(nametab); if (map != NULL) instance_fixup(inst, map); tree_set_ref(call, inst); mangle_func(nametab, inst); tree_t container = find_enclosing(nametab, S_DECLARATIVE_REGION); tree_add_decl(container, inst); } if (peek() == tPARAMETER) p_parameter_map_aspect(call); else if (optional(tLPAREN)) { p_actual_parameter_part(call); consume(tRPAREN); } tree_set_loc(call, CURRENT_LOC); return could_be_slice_name(call); } static tree_t p_attribute_name(tree_t prefix) { // prefix [ signature ] ' attribute_designator [ ( expression ) ] EXTEND("attribute name"); type_t signature = NULL; if (peek() == tLSQUARE) signature = p_signature(); consume(tTICK); attr_kind_t kind; ident_t id; switch (peek()) { case tRANGE: consume(tRANGE); id = ident_new("RANGE"); kind = ATTR_RANGE; break; case tREVRANGE: consume(tREVRANGE); id = ident_new("REVERSE_RANGE"); kind = ATTR_REVERSE_RANGE; break; case tSUBTYPE: consume(tSUBTYPE); require_std(STD_08, "subtype attribute"); id = ident_new("SUBTYPE"); kind = ATTR_SUBTYPE; break; case tID: id = p_identifier(); kind = parse_predefined_attr(id); break; default: one_of(tRANGE, tREVRANGE, tID, tSUBTYPE); kind = ATTR_USER; id = error_marker(); } type_t type = prefix_type(prefix, signature); if (signature != NULL) { bool valid_signature = false; if (type == NULL) valid_signature = false; else if (type_is_subprogram(type)) valid_signature = true; else if (class_of(prefix) == C_LITERAL && type_is_enum(type)) valid_signature = true; else if (type_is_none(type)) valid_signature = true; // Prevent cascading errors if (!valid_signature) parse_error(CURRENT_LOC, "prefix of attribute name with signature " "does not denote a subprogram or enumeration literal"); } if (type != NULL && type_kind(type) == T_INCOMPLETE) { type = resolve_type(nametab, type); tree_set_type(prefix, type); } const bool deref_prefix = !is_type_attribute(kind) && kind != ATTR_REFLECT && type != NULL && type_is_access(type); if (deref_prefix) { prefix = implicit_dereference(prefix); type = tree_type(prefix); } tree_t t = tree_new(T_ATTR_REF); tree_set_name(t, prefix); tree_set_ident(t, id); tree_set_subkind(t, kind); tree_set_loc(t, CURRENT_LOC); if (attribute_has_param(kind) && optional(tLPAREN)) { add_param(t, p_expression(), P_POS, NULL); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); } if (is_type_attribute(kind)) tree_set_type(t, apply_type_attribute(t)); else if (kind == ATTR_DELAYED || kind == ATTR_TRANSACTION || kind == ATTR_STABLE || kind == ATTR_QUIET) implicit_signal_attribute(t); return t; } static tree_t p_selected_name(tree_t prefix, name_mask_t *mask) { // prefix . suffix EXTEND("selected name"); // If the prefix is a reference to a function then convert it to a // call unless it matches the name of the enclosing subprogram tree_kind_t prefix_kind = tree_kind(prefix); if ((*mask & N_FUNC) && prefix_kind == T_REF) { ident_t id = tree_ident(prefix); tree_t sub = find_enclosing(nametab, S_SUBPROGRAM); if (sub != NULL && tree_ident(sub) == id) tree_set_ref(prefix, sub); else { prefix = p_function_call(id, NULL); prefix_kind = T_FCALL; } } else if (prefix_kind == T_PROT_REF) { prefix = p_function_call(tree_ident(prefix), tree_value(prefix)); prefix_kind = T_FCALL; } consume(tDOT); *mask = 0; ident_t suffix = NULL; switch (peek()) { case tID: suffix = p_identifier(); break; case tSTRING: suffix = p_operator_symbol(); break; case tALL: { consume(tALL); tree_t all = tree_new(T_ALL); tree_set_loc(all, CURRENT_LOC); tree_set_value(all, prefix); *mask |= N_OBJECT; return all; } default: expect(tID, tSTRING, tALL); *mask |= N_ERROR; return prefix; } if (prefix_kind == T_REF && tree_has_ref(prefix)) { tree_t decl = tree_ref(prefix); const tree_kind_t kind = tree_kind(decl); if (kind == T_LIBRARY) { ident_t unit_name = ident_prefix(tree_ident(prefix), suffix, '.'); tree_t unit = resolve_name(nametab, CURRENT_LOC, unit_name); if (unit == NULL) { tree_t dummy = tree_new(T_REF); tree_set_ident(dummy, unit_name); tree_set_type(dummy, type_new(T_NONE)); *mask |= N_ERROR; return dummy; } else { assert(is_design_unit(unit)); tree_t ref = tree_new(T_REF); tree_set_loc(ref, CURRENT_LOC); tree_set_ident(ref, unit_name); tree_set_ref(ref, unit); return ref; } } else if (kind == T_GENERIC_DECL && tree_class(decl) == C_PACKAGE) return select_decl(tree_value(decl), suffix, mask); else if (is_container(decl)) { tree_t ref = select_decl(prefix, suffix, mask); if (!tree_has_ref(ref)) return ref; // Was error // LRM 08 section 8.3 rules for expanded names tree_t du = find_enclosing(nametab, S_DESIGN_UNIT); if (du == decl || (kind == T_ENTITY && primary_unit_of(du) == decl)) return ref; else if (kind == T_PACKAGE && is_uninstantiated_package(decl)) parse_error(CURRENT_LOC, "cannot reference %s in uninstantiated " "package %s outside of the package itself", istr(suffix), istr(tree_ident(decl))); else if (kind != T_PACKAGE && kind != T_PACK_INST && !is_enclosing(nametab, decl)) { diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); diag_printf(d, "expanded name cannot reference %s in %s %s " "outside of the construct itself", istr(suffix), class_str(class_of(decl)), istr(tree_ident(decl))); diag_lrm(d, STD_08, "8.3"); diag_emit(d); } return ref; } else if (is_type_decl(decl)) { diag_t *d = pedantic_diag(tree_loc(prefix)); if (d != NULL) { diag_printf(d, "type mark cannot be the prefix of a selected name"); diag_emit(d); } *mask |= N_TYPE; } } if (scope_formal_kind(nametab) == F_SUBPROGRAM) { tree_t rref = tree_new(T_RECORD_REF); tree_set_value(rref, prefix); tree_set_ident(rref, suffix); tree_set_loc(rref, CURRENT_LOC); *mask |= N_OBJECT; return rref; } type_t type = solve_types(nametab, prefix, NULL); if (type_is_access(type)) { prefix = implicit_dereference(prefix); type = tree_type(prefix); prefix_kind = T_ALL; } if (type_kind(type) == T_INCOMPLETE) { type = resolve_type(nametab, type); tree_set_type(prefix, type); } if (type_is_record(type) || type_is_none(type)) { tree_t rref = tree_new(T_RECORD_REF); tree_set_value(rref, prefix); tree_set_ident(rref, suffix); tree_set_loc(rref, CURRENT_LOC); *mask |= N_OBJECT; return rref; } else if (type_is_protected(type)) { tree_t pref = tree_new(T_PROT_REF); tree_set_value(pref, prefix); tree_set_ident(pref, suffix); tree_set_loc(pref, CURRENT_LOC); *mask |= N_SUBPROGRAM; return pref; } else if (type_kind(type) == T_INCOMPLETE) { parse_error(tree_loc(prefix), "object with incomplete type %s cannot be " "selected", type_pp(type)); *mask |= N_ERROR; return prefix; } else if (prefix_kind == T_REF) { parse_error(tree_loc(prefix), "object %s with type %s cannot be selected", istr(tree_ident(prefix)), type_pp(type)); tree_set_type(prefix, type_new(T_NONE)); *mask |= N_ERROR; return prefix; } else { parse_error(tree_loc(prefix), "object with type %s cannot be selected", type_pp(type)); tree_set_type(prefix, type_new(T_NONE)); *mask |= N_ERROR; return prefix; } } static tree_t p_indexed_name(tree_t prefix, tree_t head) { // prefix ( expression { , expression } ) EXTEND("indexed name"); type_t type = prefix_type(prefix, NULL); if (type != NULL && type_is_access(type)) { prefix = implicit_dereference(prefix); type = tree_type(prefix); } tree_t t = tree_new(T_ARRAY_REF); tree_set_value(t, prefix); do { tree_t index = head ?: p_expression(); head = NULL; add_param(t, index, P_POS, NULL); } while (optional(tCOMMA)); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_type_conversion(tree_t prefix) { // type_conversion ::= type_mark ( expression ) EXTEND("type conversion"); consume(tLPAREN); type_t type = NULL; if (tree_kind(prefix) == T_ATTR_REF) type = tree_type(prefix); else { assert(tree_kind(prefix) == T_REF); tree_t tdecl = resolve_name(nametab, CURRENT_LOC, tree_ident(prefix)); if (tdecl == NULL) type = type_new(T_NONE); else { tdecl = aliased_type_decl(tdecl); assert(tdecl); // Call to this is guarded by N_TYPE mask type = tree_type(tdecl); } } tree_t value = p_expression(); solve_types(nametab, value, NULL); tree_t conv = tree_new(T_TYPE_CONV); tree_set_type(conv, type); tree_set_value(conv, value); consume(tRPAREN); tree_set_loc(conv, CURRENT_LOC); return conv; } static void p_partial_pathname(tree_t name) { // { pathname_element . } object_simple_name BEGIN("partial pathname"); do { tree_t pe = tree_new(T_PATH_ELT); tree_set_ident(pe, p_identifier()); if (optional(tLPAREN)) { tree_t expr = p_expression(); solve_types(nametab, expr, NULL); tree_set_subkind(pe, PE_GENERATE); tree_set_value(pe, expr); consume(tRPAREN); tree_set_loc(pe, CURRENT_LOC); } else { tree_set_subkind(pe, PE_SIMPLE); tree_set_loc(pe, &last_loc); } tree_add_part(name, pe); } while (optional(tDOT)); } static void p_package_pathname(tree_t name) { // @ library_logical_name . package_simple_name . { package_simple_name . } // object_simple_name BEGIN("package pathname"); consume(tAT); tree_t pe = tree_new(T_PATH_ELT); tree_set_subkind(pe, PE_LIBRARY); tree_set_ident(pe, p_identifier()); tree_set_loc(pe, CURRENT_LOC); tree_add_part(name, pe); consume(tDOT); p_partial_pathname(name); } static void p_absolute_pathname(tree_t name) { // . partial_pathname BEGIN("absolute pathname"); consume(tDOT); tree_t pe = tree_new(T_PATH_ELT); tree_set_subkind(pe, PE_ABSOLUTE); tree_set_loc(pe, CURRENT_LOC); tree_add_part(name, pe); p_partial_pathname(name); } static void p_relative_pathname(tree_t name) { // { ^ . } partial_pathname BEGIN("relative pathname"); tree_t pe = tree_new(T_PATH_ELT); tree_set_subkind(pe, PE_RELATIVE); tree_add_part(name, pe); while (peek() == tCARET) { consume(tCARET); consume(tDOT); tree_t pe = tree_new(T_PATH_ELT); tree_set_loc(pe, CURRENT_LOC); tree_set_subkind(pe, PE_CARET); tree_add_part(name, pe); } p_partial_pathname(name); } static void p_external_pathname(tree_t name) { // package_pathname | absolute_pathname | relative_pathname BEGIN("external pathname"); switch (peek()) { case tDOT: p_absolute_pathname(name); break; case tCARET: case tID: p_relative_pathname(name); break; case tAT: p_package_pathname(name); break; default: one_of(tDOT, tCARET, tID, tAT); } } static tree_t p_external_name(void) { // << constant external_pathname : subtype_indication >> // | << signal external_pathname : subtype_indication >> // | << variable external_pathname : subtype_indication >> BEGIN("external name"); consume(tLTLT); require_std(STD_08, "external names"); tree_t t = tree_new(T_EXTERNAL_NAME); switch (one_of(tCONSTANT, tSIGNAL, tVARIABLE)) { case tSIGNAL: tree_set_class(t, C_SIGNAL); break; case tCONSTANT: tree_set_class(t, C_CONSTANT); break; case tVARIABLE: tree_set_class(t, C_VARIABLE); break; } p_external_pathname(t); consume(tCOLON); tree_set_type(t, p_subtype_indication()); consume(tGTGT); tree_set_global_flags(t, TREE_GF_EXTERNAL_NAME); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_name(name_mask_t stop_mask) { // simple_name | operator_symbol | selected_name | indexed_name // | slice_name | attribute_name | 2008: external_name BEGIN("name"); ident_t id = NULL; switch (peek()) { case tSTRING: id = p_operator_symbol(); break; case tID: id = p_identifier(); break; case tLTLT: return p_external_name(); default: { expect(tSTRING, tID); tree_t dummy = tree_new(T_REF); tree_set_loc(dummy, CURRENT_LOC); tree_set_ident(dummy, error_marker()); tree_set_type(dummy, type_new(T_NONE)); return dummy; } } tree_t decl = NULL; name_mask_t mask = query_name(nametab, id, &decl); tree_t prefix = tree_new(T_REF); tree_set_ident(prefix, id); tree_set_loc(prefix, CURRENT_LOC); tree_set_ref(prefix, decl); for (;;) { switch (peek()) { case tLPAREN: break; case tDOT: prefix = p_selected_name(prefix, &mask); continue; case tTICK: if (peek_nth(2) == tLPAREN) { if (mask & stop_mask) return prefix; else { prefix = p_qualified_expression(prefix); mask = N_OBJECT; } } else { prefix = p_attribute_name(prefix); mask = is_type_attribute(tree_subkind(prefix)) ? N_TYPE : N_OBJECT; } continue; case tPARAMETER: case tGENERIC: if ((mask & stop_mask) || !(mask & N_SUBPROGRAM)) return prefix; else { prefix = p_function_call(tree_ident(prefix), NULL); mask = N_OBJECT; continue; } default: return prefix; } // Prefix could either be an array to be indexed or sliced, a // subprogram to be called, or a type conversion. if (mask & stop_mask) return prefix; if (!(mask & N_FUNC) && scope_formal_kind(nametab) == F_SUBPROGRAM) { // Assume that A in F(A(N) => ...) is a parameter name mask |= N_OBJECT; } const tree_kind_t prefix_kind = tree_kind(prefix); if (mask & N_TYPE) { // Type conversion prefix = p_type_conversion(prefix); mask = N_OBJECT; continue; } else if ((mask & N_SUBPROGRAM) && prefix_kind == T_REF) { // Function call prefix = p_function_call(tree_ident(prefix), NULL); mask = N_OBJECT; continue; } else if (!(mask & N_OBJECT) && prefix_kind == T_PROT_REF) { // Protected function call prefix = p_function_call(tree_ident(prefix), tree_value(prefix)); mask = N_OBJECT; continue; } // Must be a slice or index name: we have to parse up to the first // expression to know which consume(tLPAREN); tree_t head = p_expression(); if (scan(tDOWNTO, tTO) || is_range_expr(head)) prefix = p_slice_name(prefix, head); else prefix = p_indexed_name(prefix, head); } } static type_t p_type_mark(void) { // name BEGIN("type mark"); tree_t name = p_name(N_TYPE); return name_to_type_mark(name); } static tree_t p_index_constraint(type_t base) { // ( discrete_range { , discrete_range } ) BEGIN("index constraint"); consume(tLPAREN); int n = 0; tree_t t = tree_new(T_CONSTRAINT); tree_set_subkind(t, C_INDEX); do { type_t index_type = base ? index_type_of(base, n++) : NULL; tree_t r = p_discrete_range(NULL); solve_types(nametab, r, index_type); tree_add_range(t, r); } while (optional(tCOMMA)); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); return t; } static type_t p_element_constraint(type_t base) { // array_constraint | record_constraint BEGIN("element constraint"); type_t sub = type_new(T_SUBTYPE); if (is_anonymous_subtype(base)) { type_set_base(sub, type_base(base)); if (type_has_constraint(base)) type_set_constraint(sub, type_constraint(base)); if (type_has_elem(base)) type_set_elem(sub, type_elem(base)); } else type_set_base(sub, base); if (type_is_record(base)) type_set_constraint(sub, p_record_constraint(sub)); else p_array_constraint(sub, base); return sub; } static void p_array_constraint(type_t type, type_t base) { // index_constraint [ array_element_constraint ] // | ( open ) [ array_element_constraint ] BEGIN("array constraint"); if (peek_nth(2) == tOPEN) { consume(tLPAREN); consume(tOPEN); consume(tRPAREN); if (!type_is_array(type) && !type_is_none(type)) parse_error(CURRENT_LOC, "open array constraint cannot be used " "with non-array type %s", type_pp(type)); } else { tree_t c = p_index_constraint(base); if (type_has_constraint(type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(c)); diag_printf(d, "array element is already constrained"); diag_hint(d, tree_loc(type_constraint(type)), "location of existing constraint"); diag_emit(d); } else type_set_constraint(type, c); } if (peek() != tLPAREN) return; // Base type may not actually be an array due to earlier errors type_t elem = base; if (type_is_array(base)) elem = type_elem(base); type_set_elem(type, p_element_constraint(elem)); } static tree_t p_record_element_constraint(type_t base) { // simple_name element_constraint BEGIN("record element constraint"); ident_t id = p_identifier(); // Base type may not actually be a record due to earlier errors tree_t decl = NULL; if (type_is_record(base)) decl = resolve_field_name(nametab, &last_loc, id, base); type_t ftype; if (decl != NULL) { assert(tree_kind(decl) == T_FIELD_DECL); tree_t cons = type_constraint_for_field(base, decl); ftype = cons ? tree_type(cons) : tree_type(decl); } else ftype = type_new(T_NONE); tree_t elem = tree_new(T_ELEM_CONSTRAINT); tree_set_ident(elem, id); tree_set_ref(elem, decl); type_t sub = p_element_constraint(ftype); tree_set_type(elem, sub); tree_set_loc(elem, CURRENT_LOC); return elem; } static tree_t p_record_constraint(type_t base) { // ( record_element_constraint { , record_element_constraint } ) BEGIN("record constraint"); consume(tLPAREN); tree_t c = tree_new(T_CONSTRAINT); tree_set_subkind(c, C_RECORD); do { tree_add_range(c, p_record_element_constraint(base)); } while (optional(tCOMMA)); consume(tRPAREN); tree_set_loc(c, CURRENT_LOC); return c; } static void p_constraint(type_t type) { // range_constraint | index_constraint // 2008: range_constraint | array_constraint | record_constraint BEGIN("constraint"); assert(type_kind(type) == T_SUBTYPE); type_t base = type_base(type); switch (peek()) { case tRANGE: type_set_constraint(type, p_range_constraint(base)); break; case tLPAREN: if (standard() < STD_08) type_set_constraint(type, p_index_constraint(base)); else if (type_is_record(base)) type_set_constraint(type, p_record_constraint(base)); else p_array_constraint(type, base); break; default: one_of(tRANGE, tLPAREN); } } static tree_t p_element_resolution(void) { // array_element_resolution | record_resolution BEGIN("element resolution"); tree_t t = tree_new(T_ELEM_RESOLUTION); do { tree_t a = tree_new(T_ASSOC); tree_set_subkind(a, A_POS); tree_set_value(a, p_resolution_indication()); tree_set_loc(a, CURRENT_LOC); tree_add_assoc(t, a); } while (optional(tCOMMA)); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_resolution_indication(void) { // resolution_function_name | 2008: ( element_resolution ) BEGIN("resolution indication"); if (peek() == tID || standard() < STD_08) return p_name(N_SUBPROGRAM); else { one_of(tLPAREN, tID); tree_t rname = p_element_resolution(); consume(tRPAREN); return rname; } } static type_t p_subtype_indication(void) { // [ name ] type_mark [ constraint ] BEGIN("subtype indication"); bool made_subtype = false; type_t type = NULL; tree_t rname = NULL; if (peek() == tLPAREN) rname = p_resolution_indication(); else { tree_t name = p_name(N_TYPE); if (peek() == tID) rname = name; else type = name_to_type_mark(name); } if (rname != NULL) { type = type_new(T_SUBTYPE); made_subtype = true; type_set_resolution(type, rname); type_set_base(type, p_type_mark()); resolve_resolution(nametab, rname, type); } if (type == NULL) type = p_type_mark(); if (scan(tRANGE, tLPAREN)) { if (!made_subtype) { type_t sub = type_new(T_SUBTYPE); type_set_base(sub, type); type = sub; } p_constraint(type); } return type; } static tree_t p_abstract_literal(void) { // decimal_literal | based_literal BEGIN("abstract literal"); tree_t t = tree_new(T_LITERAL); switch (one_of(tINT, tREAL)) { case tINT: tree_set_subkind(t, L_INT); tree_set_ival(t, last_lval.i64); break; case tREAL: tree_set_subkind(t, L_REAL); tree_set_dval(t, last_lval.real); break; } tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_physical_literal(void) { // [ abstract_literal ] name BEGIN("physical literal"); tree_t mult; if (scan(tINT, tREAL)) mult = p_abstract_literal(); else { mult = tree_new(T_LITERAL); tree_set_ival(mult, 1); } ident_t ident = p_identifier(); tree_set_subkind(mult, L_PHYSICAL); tree_set_loc(mult, CURRENT_LOC); tree_set_ident(mult, ident); tree_set_type(mult, NULL); return mult; } static tree_t p_numeric_literal(void) { // abstract_literal | physical_literal BEGIN("numeric literal"); if (peek_nth(2) == tID) return p_physical_literal(); else return p_abstract_literal(); } static tree_t p_string_literal(void) { // string_literal BEGIN("string literal"); consume(tSTRING); tree_t t = tree_new(T_STRING); tree_set_loc(t, CURRENT_LOC); for (const char *p = last_lval.str + 1; *(p + 1) != '\0'; p++) { const char ch[] = { '\'', *p, '\'', '\0' }; tree_t ref = tree_new(T_REF); tree_set_loc(ref, CURRENT_LOC); tree_set_ident(ref, ident_new(ch)); tree_add_char(t, ref); } free(last_lval.str); return t; } static tree_t p_literal(void) { // numeric_literal | enumeration_literal | string_literal // | bit_string_literal | null BEGIN("literal"); switch (peek()) { case tNULL: { consume(tNULL); tree_t t = tree_new(T_LITERAL); tree_set_loc(t, CURRENT_LOC); tree_set_subkind(t, L_NULL); return t; } case tINT: case tREAL: return p_numeric_literal(); case tSTRING: return p_string_literal(); case tBITSTRING: { consume(tBITSTRING); tree_t t = bit_string_to_literal(last_lval.str, CURRENT_LOC); free(last_lval.str); return t; } default: expect(tNULL, tINT, tREAL); return error_expr(); } } static void p_choice(tree_t parent, tree_t head, type_t constraint) { // simple_expression | discrete_range | simple_name | others BEGIN("choice"); tree_t t = tree_new(T_ASSOC); if (head == NULL && optional(tOTHERS)) tree_set_subkind(t, A_OTHERS); else { tree_t name = head ?: p_expression(); const tree_kind_t name_kind = tree_kind(name); bool is_range = false; if (scan(tDOWNTO, tTO, tRANGE, tREVRANGE)) is_range = true; else if (constraint != NULL && name_kind == T_REF && tree_has_ref(name)) is_range = is_type_decl(tree_ref(name)); else if (name_kind == T_ATTR_REF) { const attr_kind_t attr = tree_subkind(name); is_range = attr == ATTR_RANGE || attr == ATTR_REVERSE_RANGE; } tree_t choice = NULL; if (is_range) { tree_set_subkind(t, A_RANGE); tree_add_range(t, (choice = p_discrete_range(name))); } else { tree_set_subkind(t, A_NAMED); tree_set_name(t, (choice = name)); } if (constraint != NULL) solve_types(nametab, choice, constraint); } tree_set_loc(t, CURRENT_LOC); tree_add_assoc(parent, t); } static void p_choices(tree_t parent, tree_t head, type_t constraint) { // choices ::= choice { | choice } BEGIN("choices"); p_choice(parent, head, constraint); while (optional(tBAR)) p_choice(parent, NULL, constraint); } static void p_element_association(tree_t agg, tree_t head) { // [ choices => ] expression BEGIN("element association"); if (head == NULL && peek() != tOTHERS) head = p_expression(); const int nstart = tree_assocs(agg); if (scan(tBAR, tASSOC, tTO, tDOWNTO, tOTHERS)) { p_choices(agg, head, NULL); consume(tASSOC); tree_t value = p_expression(); const int nassocs = tree_assocs(agg); for (int i = nstart; i < nassocs; i++) { tree_t a = tree_assoc(agg, i); tree_set_value(a, value); tree_set_loc(a, CURRENT_LOC); } } else { tree_t t = tree_new(T_ASSOC); tree_set_subkind(t, A_POS); tree_set_value(t, head ?: p_expression()); tree_set_loc(t, CURRENT_LOC); tree_set_pos(t, nstart); tree_add_assoc(agg, t); } } static tree_t p_aggregate(void) { // ( element_association { , element_association } ) BEGIN("aggregate"); tree_t t = tree_new(T_AGGREGATE); consume(tLPAREN); do { p_element_association(t, NULL); } while (optional(tCOMMA)); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_aggregate_or_expression(void) { // aggregate | expression BEGIN("aggregate or expression"); if (peek_nth(2) == tOTHERS) return p_aggregate(); consume(tLPAREN); tree_t head = p_expression(); switch (peek()) { case tRPAREN: consume(tRPAREN); return head; case tASSOC: case tCOMMA: case tTO: case tDOWNTO: case tBAR: { tree_t t = tree_new(T_AGGREGATE); p_element_association(t, head); while (optional(tCOMMA)) p_element_association(t, NULL); consume(tRPAREN); tree_set_loc(t, CURRENT_LOC); return t; } default: expect(tRPAREN, tASSOC, tCOMMA, tTO, tDOWNTO, tBAR); drop_tokens_until(tRPAREN); return head; } } static tree_t p_qualified_expression(tree_t prefix) { // type_mark ' ( expression ) | type_mark ' aggregate EXTEND("qualified expression"); type_t type; if (prefix == NULL) type = p_type_mark(); else { tree_t decl = NULL; if (tree_kind(prefix) == T_REF && tree_has_ref(prefix)) decl = aliased_type_decl(tree_ref(prefix)); if (decl != NULL) type = tree_type(decl); else { parse_error(tree_loc(prefix), "expecting type mark while parsing " "qualified expression"); type = type_new(T_NONE); } } tree_t qual = tree_new(T_QUALIFIED); tree_set_type(qual, type); tree_set_ident(qual, type_ident(type)); consume(tTICK); tree_t value = p_aggregate_or_expression(); tree_set_value(qual, value); solve_types(nametab, value, type); tree_set_loc(qual, CURRENT_LOC); return qual; } static tree_t p_allocator(void) { // new subtype_indication | new qualified_expression BEGIN("allocator"); consume(tNEW); tree_t new = tree_new(T_NEW); tree_t value; if (peek_nth(2) == tTICK && peek_nth(3) == tLPAREN) value = p_qualified_expression(NULL); else { type_t type = p_subtype_indication(); value = tree_new(T_QUALIFIED); tree_set_type(value, type); tree_set_loc(value, CURRENT_LOC); } tree_set_value(new, value); tree_set_loc(new, CURRENT_LOC); return new; } static tree_t p_primary(tree_t head) { // name | literal | aggregate | function_call | qualified_expression // | type_conversion | allocator | ( expression ) | // | PSL: Built_In_Function_Call BEGIN("primary"); assert(head == NULL); switch (peek()) { case tLPAREN: return p_aggregate_or_expression(); case tINT: case tREAL: case tNULL: case tBITSTRING: return p_literal(); case tSTRING: if (peek_nth(2) != tLPAREN && peek_nth(2) != tDOT) return p_literal(); // Fall-through case tID: { tree_t expr = p_name(0); if (peek() == tLSQUARE) return p_attribute_name(expr); else if (tree_kind(expr) == T_PROT_REF) return p_function_call(tree_ident(expr), tree_value(expr)); else return expr; } case tLTLT: return p_name(N_SUBPROGRAM); case tNEW: return p_allocator(); case tPREV: case tPSLNEXT: case tROSE: case tFELL: case tENDED: case tSTABLE: { psl_node_t p = p_psl_builtin_function_call(); psl_check(p, nametab); tree_t t = tree_new(T_PSL_FCALL); tree_set_psl(t, p); tree_set_loc(t, CURRENT_LOC); return t; } default: expect(tLPAREN, tINT, tREAL, tNULL, tID, tSTRING, tBITSTRING, tNEW); return error_expr(); } } static ident_t p_logical_operator(void) { switch (one_of(tAND, tOR, tNAND, tNOR, tXOR, tXNOR)) { case tAND: return well_known(W_OP_AND); case tOR: return well_known(W_OP_OR); case tNAND: return well_known(W_OP_NAND); case tNOR: return well_known(W_OP_NOR); case tXOR: return well_known(W_OP_XOR); case tXNOR: return well_known(W_OP_XNOR); default: return error_marker(); } } static tree_t p_unary_expression(tree_t head) { // primary | abs primary | not primary | unary_logical_operator primary BEGIN("unary expression"); if (head != NULL) return head; // Injected from mis-parsed PSL property ident_t op = NULL; switch (peek()) { case tNOT: consume(tNOT); op = well_known(W_OP_NOT); break; case tABS: consume(tABS); op = well_known(W_OP_ABS); break; case tAND: case tOR: case tNAND: case tNOR: case tXOR: case tXNOR: require_std(STD_08, "unary logical operators"); op = p_logical_operator(); break; default: break; } if (op != NULL) { tree_t t = tree_new(T_FCALL); tree_set_ident(t, op); unary_op(t, p_primary); tree_set_loc(t, CURRENT_LOC); return t; } else return p_primary(NULL); } static tree_t p_factor(tree_t head) { // unary_expression [ ** unary_expression ] BEGIN("factor"); tree_t operand = p_unary_expression(head); if (optional(tPOWER)) { tree_t second = p_primary(NULL); tree_t t = tree_new(T_FCALL); tree_set_loc(t, CURRENT_LOC); tree_set_ident(t, well_known(W_OP_EXPONENT)); add_param(t, operand, P_POS, NULL); add_param(t, second, P_POS, NULL); return t; } return operand; } static ident_t p_multiplying_operator(void) { switch (one_of(tTIMES, tOVER, tMOD, tREM)) { case tTIMES: return well_known(W_OP_TIMES); case tOVER: return well_known(W_OP_DIVIDE); case tMOD: return well_known(W_OP_MOD); case tREM: return well_known(W_OP_REM); default: return error_marker(); } } static tree_t p_term(tree_t head) { // factor { multiplying_operator factor } BEGIN("term"); tree_t term = p_factor(head); while (scan(tTIMES, tOVER, tMOD, tREM)) { ident_t op = p_multiplying_operator(); tree_t left = term; term = tree_new(T_FCALL); tree_set_ident(term, op); binary_op(term, left, p_factor); } return term; } static ident_t p_adding_operator(void) { switch (one_of(tPLUS, tMINUS, tAMP)) { case tPLUS: return well_known(W_OP_ADD); case tMINUS: return well_known(W_OP_MINUS); case tAMP: return well_known(W_OP_CONCAT); default: return error_marker(); } } static ident_t p_sign(void) { switch (one_of(tPLUS, tMINUS)) { case tPLUS: return well_known(W_OP_ADD); case tMINUS: return well_known(W_OP_MINUS); default: return error_marker(); } } static tree_t p_simple_expression(tree_t head) { // [ sign ] term { adding_operator term } BEGIN("simple expression"); tree_t expr = NULL; if (head == NULL && scan(tPLUS, tMINUS)) { ident_t sign = p_sign(); expr = tree_new(T_FCALL); tree_set_ident(expr, sign); unary_op(expr, p_term); tree_set_loc(expr, CURRENT_LOC); } else expr = p_term(head); while (scan(tPLUS, tMINUS, tAMP)) { tree_t left = expr; expr = tree_new(T_FCALL); tree_set_ident(expr, p_adding_operator()); binary_op(expr, left, p_term); } return expr; } static ident_t p_shift_operator(void) { switch (one_of(tSLL, tSRL, tSLA, tSRA, tROL, tROR)) { case tSLL: return well_known(W_OP_SLL); case tSRL: return well_known(W_OP_SRL); case tSLA: return well_known(W_OP_SLA); case tSRA: return well_known(W_OP_SRA); case tROL: return well_known(W_OP_ROL); case tROR: return well_known(W_OP_ROR); default: return error_marker(); } } static tree_t p_shift_expression(tree_t head) { // simple_expression [ shift_operator simple_expression ] BEGIN("shift expression"); tree_t shift = p_simple_expression(head); while (scan(tSLL, tSRL, tSLA, tSRA, tROL, tROR)) { ident_t op = p_shift_operator(); tree_t left = shift; tree_t right = p_simple_expression(NULL); shift = tree_new(T_FCALL); tree_set_ident(shift, op); tree_set_loc(shift, CURRENT_LOC); add_param(shift, left, P_POS, NULL); add_param(shift, right, P_POS, NULL); } return shift; } static ident_t p_relational_operator(void) { switch (one_of(tEQ, tNEQ, tLT, tLE, tGT, tGE, tMEQ, tMNEQ, tMLT, tMLE, tMGT, tMGE)) { case tEQ: return well_known(W_OP_EQUAL); case tNEQ: return well_known(W_OP_NOT_EQUAL); case tLT: return well_known(W_OP_LESS_THAN); case tLE: return well_known(W_OP_LESS_EQUAL); case tGT: return well_known(W_OP_GREATER_THAN); case tGE: return well_known(W_OP_GREATER_EQUAL); case tMEQ: return well_known(W_OP_MATCH_EQUAL); case tMNEQ: return well_known(W_OP_MATCH_NOT_EQUAL); case tMLT: return well_known(W_OP_MATCH_LESS_THAN); case tMLE: return well_known(W_OP_MATCH_LESS_EQUAL); case tMGT: return well_known(W_OP_MATCH_GREATER_THAN); case tMGE: return well_known(W_OP_MATCH_GREATER_EQUAL); default: return error_marker(); } } static tree_t p_relation(tree_t head) { // shift_expression [ relational_operator shift_expression ] BEGIN("relation"); tree_t rel = p_shift_expression(head); while (scan(tEQ, tNEQ, tLT, tLE, tGT, tGE, tMEQ, tMNEQ, STD(08, tMLT), tMLE, tMGT, tMGE)) { ident_t op = p_relational_operator(); tree_t left = rel; rel = tree_new(T_FCALL); tree_set_ident(rel, op); binary_op(rel, left, p_shift_expression); } return rel; } static tree_t p_expression_with_head(tree_t head) { // relation { and relation } | relation { or relation } // | relation { xor relation } | relation [ nand relation ] // | relation [ nor relation ] | relation { xnor relation } // | 2008: condition_operator primary // | PSL: relation { union relation } BEGIN("expression"); tree_t expr = p_relation(head); for (;;) { const token_t tok = peek(); if (tok == tUNION) { psl_node_t un = p_psl_union(expr); tree_t new = tree_new(T_PSL_UNION); tree_set_psl(new, un); tree_set_loc(new, CURRENT_LOC); expr = new; } else if (tok == tNOR || tok == tNAND) { tree_t new = tree_new(T_FCALL); tree_set_ident(new, p_logical_operator()); binary_op(new, expr, p_relation); expr = new; break; } else if (tok == tAND || tok == tOR || tok == tXOR || tok == tXNOR) { tree_t new = tree_new(T_FCALL); tree_set_ident(new, p_logical_operator()); binary_op(new, expr, p_relation); expr = new; } else break; } return expr; } static inline tree_t p_expression(void) { // expression | 2008: condition_operator primary if (optional(tCCONV)) { require_std(STD_08, "condition conversion"); tree_t expr = tree_new(T_FCALL); tree_set_ident(expr, well_known(W_OP_CCONV)); unary_op(expr, p_primary); return expr; } else return p_expression_with_head(NULL); } static type_t p_interface_type_indication(tree_t parent) { // subtype_indication | anonymous_type_indication BEGIN("interface type indication"); if (peek() == tTYPE) { require_std(STD_19, "anonymous type indication"); type_t type = p_anonymous_type_indication(); tree_t g = tree_new(T_GENERIC_DECL); tree_set_loc(g, CURRENT_LOC); tree_set_ident(g, ident_uniq("anonymous")); tree_set_subkind(g, PORT_IN); tree_set_class(g, C_TYPE); tree_set_type(g, type); tree_add_generic(parent, g); return type; } else return p_subtype_indication(); } static void p_interface_constant_declaration(tree_t parent, tree_kind_t kind, bool ordered) { // [ constant ] identifier_list : [ in ] subtype_indication [ := expression ] BEGIN("interface constant declaration"); const bool explicit_constant = optional(tCONSTANT); tree_flags_t flags = (explicit_constant) ? TREE_F_EXPLICIT_CLASS : 0; LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); // The grammar only allows IN here but we are more leniant to avoid // having disambiguate constant and variable interface declarations // See LRM 93 section 2.1.1 for default class port_mode_t mode = PORT_IN; if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) { flags |= TREE_F_EXPLICIT_MODE; mode = p_mode(); } class_t class = C_CONSTANT; if ((mode == PORT_OUT || mode == PORT_INOUT) && !explicit_constant) class = C_VARIABLE; if (kind == T_GENERIC_DECL) { // In the 2008 standard generics in packages or subprograms are // locally static if they have a locally static subtype switch (tree_kind(parent)) { case T_PACKAGE: case T_FUNC_DECL: case T_PROC_DECL: flags |= TREE_F_LOCALLY_STATIC; break; default: break; } } type_t type = p_interface_type_indication(parent); tree_t init = NULL; if (optional(tWALRUS)) { init = p_expression(); solve_types(nametab, init, type); } for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t d = tree_new(kind); tree_set_ident(d, it->ident); tree_set_loc(d, &(it->loc)); tree_set_subkind(d, mode); tree_set_type(d, type); tree_set_class(d, class); tree_set_flag(d, flags); if (init != NULL) tree_set_value(d, init); add_interface(parent, d, kind); sem_check(d, nametab); if (ordered) insert_name(nametab, d, NULL); flags |= TREE_F_CONTINUATION; } } static void p_array_mode_view_indication(type_t *type, tree_t *name) { // view ( name ) of subtype_indication BEGIN("array mode view indication"); consume(tVIEW); consume(tLPAREN); *name = p_name(0); solve_types(nametab, *name, NULL); consume(tRPAREN); consume(tOF); *type = p_subtype_indication(); } static void p_record_mode_view_indication(type_t *type, tree_t *name) { // view name [ of subtype_indication ] BEGIN("record mode view indication"); consume(tVIEW); *name = p_name(0); type_t name_type = solve_types(nametab, *name, NULL); if (optional(tOF)) *type = p_subtype_indication(); else if (type_kind(name_type) != T_VIEW) { parse_error(tree_loc(*name), "name in mode view indication does not " "denote a mode view"); *type = type_new(T_NONE); } else *type = type_designated(name_type); } static port_mode_t p_mode_view_indication(type_t *type, tree_t *name) { // record_mode_view_indication | array_mode_view_indication BEGIN("mode view indication"); if (peek_nth(2) == tLPAREN) { p_array_mode_view_indication(type, name); return PORT_ARRAY_VIEW; } else { p_record_mode_view_indication(type, name); return PORT_RECORD_VIEW; } } static void p_interface_signal_declaration(tree_t parent, tree_kind_t kind, bool ordered) { // [signal] identifier_list : [ mode ] subtype_indication [ bus ] // [ := expression ] // 2019: [ signal ] identifier_list : mode_indication BEGIN("interface signal declaration"); tree_flags_t flags = optional(tSIGNAL) ? TREE_F_EXPLICIT_CLASS : 0; LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); type_t type = NULL; tree_t init = NULL; port_mode_t mode = PORT_IN; if (peek() == tVIEW) { require_std(STD_19, "mode view indication"); mode = p_mode_view_indication(&type, &init); } else { if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) { mode = p_mode(); flags |= TREE_F_EXPLICIT_MODE; } type = p_interface_type_indication(parent); if (optional(tBUS)) flags |= TREE_F_BUS; if (optional(tWALRUS)) { init = p_expression(); solve_types(nametab, init, type); } } for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t d = tree_new(kind); tree_set_ident(d, it->ident); tree_set_loc(d, &(it->loc)); tree_set_subkind(d, mode); tree_set_type(d, type); tree_set_class(d, C_SIGNAL); tree_set_flag(d, flags); if (init != NULL) tree_set_value(d, init); add_interface(parent, d, kind); sem_check(d, nametab); if (ordered) insert_name(nametab, d, NULL); flags |= TREE_F_CONTINUATION; } } static void p_interface_variable_declaration(tree_t parent, tree_kind_t kind) { // [variable] identifier_list : [ mode ] subtype_indication [ := expression ] BEGIN("interface variable declaration"); tree_flags_t flags = optional(tVARIABLE) ? TREE_F_EXPLICIT_CLASS : 0; LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); port_mode_t mode = PORT_IN; if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) { mode = p_mode(); flags |= TREE_F_EXPLICIT_MODE; } type_t type = p_interface_type_indication(parent); tree_t init = NULL; if (optional(tWALRUS)) { init = p_expression(); solve_types(nametab, init, type); } for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t d = tree_new(kind); tree_set_ident(d, it->ident); tree_set_loc(d, &(it->loc)); tree_set_type(d, type); tree_set_class(d, C_VARIABLE); tree_set_subkind(d, mode); tree_set_flag(d, flags); if (init != NULL) tree_set_value(d, init); add_interface(parent, d, kind); sem_check(d, nametab); if (standard() >= STD_19) insert_name(nametab, d, NULL); flags |= TREE_F_CONTINUATION; } } static void p_interface_file_declaration(tree_t parent, tree_kind_t kind) { // file identifier_list : subtype_indication BEGIN("interface file declaration"); consume(tFILE); LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); type_t type = p_subtype_indication(); tree_flags_t flags = 0; for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t d = tree_new(kind); tree_set_ident(d, it->ident); tree_set_loc(d, &(it->loc)); tree_set_subkind(d, PORT_IN); tree_set_flag(d, flags); tree_set_type(d, type); tree_set_class(d, C_FILE); add_interface(parent, d, kind); sem_check(d, nametab); if (standard() >= STD_19) insert_name(nametab, d, NULL); flags |= TREE_F_CONTINUATION; } } static void p_private_incomplete_type_definition(type_t type) { // 2019: private BEGIN("private incomplete type definition"); consume(tPRIVATE); type_set_subkind(type, GTYPE_PRIVATE); } static void p_scalar_incomplete_type_definition(type_t type) { // 2019: <> BEGIN("scalar incomplete type definition"); consume(tBOX); type_set_subkind(type, GTYPE_SCALAR); } static void p_discrete_incomplete_type_definition(type_t type) { // 2019: ( <> ) BEGIN("discrete incomplete type definition"); consume(tLPAREN); consume(tBOX); consume(tRPAREN); type_set_subkind(type, GTYPE_DISCRETE); } static void p_integer_incomplete_type_definition(type_t type) { // 2019: range <> BEGIN("integer incomplete type definition"); consume(tRANGE); consume(tBOX); type_set_subkind(type, GTYPE_INTEGER); } static void p_physical_incomplete_type_definition(type_t type) { // 2019: units <> BEGIN("physical incomplete type definition"); consume(tUNITS); consume(tBOX); type_set_subkind(type, GTYPE_PHYSICAL); } static void p_floating_incomplete_type_definition(type_t type) { // 2019: range <> . <> BEGIN("floating incomplete type definition"); consume(tRANGE); consume(tBOX); consume(tDOT); consume(tBOX); type_set_subkind(type, GTYPE_FLOATING); } static type_t p_array_index_incomplete_type(void) { // index_subtype_definition | index_constraint | anonymous_type_indication BEGIN("array index incomplete type"); if (peek() == tTYPE) return p_anonymous_type_indication(); else return p_index_subtype_definition(NULL); } static void p_array_index_incomplete_type_list(type_t type) { // array_index_incomplete_type { , array_index_incomplete_type } BEGIN("array index incomplete type list"); do { type_add_index(type, p_array_index_incomplete_type()); } while (optional(tCOMMA)); } static type_t p_incomplete_subtype_indication(void) { // subtype_indication | anonymous_type_indication BEGIN("incomplete subtype indication"); if (peek() == tTYPE) return p_anonymous_type_indication(); else return p_subtype_indication(); } static void p_array_incomplete_type_definition(type_t type) { // 2019: array ( array_index_incomplete_type_list ) // of element_incomplete_subtype_indication BEGIN("array incomplete type definition"); consume(tARRAY); consume(tLPAREN); p_array_index_incomplete_type_list(type); consume(tRPAREN); consume(tOF); type_set_elem(type, p_incomplete_subtype_indication()); type_set_subkind(type, GTYPE_ARRAY); } static void p_access_incomplete_type_definition(type_t type) { // 2019: access incomplete_subtype_indication BEGIN("access incomplete type definition"); consume(tACCESS); type_set_designated(type, p_incomplete_subtype_indication()); type_set_subkind(type, GTYPE_ACCESS); } static void p_file_incomplete_type_definition(type_t type) { // 2019: file of incomplete_subtype_indication BEGIN("file incomplete type definition"); consume(tFILE); consume(tOF); type_set_designated(type, p_incomplete_subtype_indication()); type_set_subkind(type, GTYPE_FILE); } static void p_incomplete_type_definition(type_t type) { // private_incomplete_type_definition // | scalar_incomplete_type_definition // | discrete_incomplete_type_definition // | integer_incomplete_type_definition // | physical_incomplete_type_definition // | floating_incomplete_type_definition // | array_incomplete_type_definition // | access_incomplete_type_definition // | file_incomplete_type_definition BEGIN("incomplete type definition"); switch (peek()) { case tPRIVATE: p_private_incomplete_type_definition(type); break; case tBOX: p_scalar_incomplete_type_definition(type); break; case tLPAREN: p_discrete_incomplete_type_definition(type); break; case tRANGE: if (peek_nth(3) == tDOT) p_floating_incomplete_type_definition(type); else p_integer_incomplete_type_definition(type); break; case tUNITS: p_physical_incomplete_type_definition(type); break; case tARRAY: p_array_incomplete_type_definition(type); break; case tACCESS: p_access_incomplete_type_definition(type); break; case tFILE: p_file_incomplete_type_definition(type); break; default: one_of(tPRIVATE, tBOX, tLPAREN, tRANGE, tUNITS, tARRAY, tACCESS, tFILE); } require_std(STD_19, "incomplete type definition"); } static type_t p_anonymous_type_indication(void) { // type is incomplete_type_definition BEGIN("anonymous type indication"); consume(tTYPE); consume(tIS); type_t type = type_new(T_GENERIC); p_incomplete_type_definition(type); return type; } static void p_interface_type_declaration(tree_t parent, tree_kind_t kind) { // 2008: type identifier // 2019: type identifier [ is incomplete_type_definition ] BEGIN("interface type declaration"); consume(tTYPE); ident_t id = p_identifier(); require_std(STD_08, "interface type declarations"); type_t type = type_new(T_GENERIC); type_set_ident(type, id); if (optional(tIS)) p_incomplete_type_definition(type); else type_set_subkind(type, GTYPE_PRIVATE); tree_t d = tree_new(kind); tree_set_ident(d, id); tree_set_loc(d, CURRENT_LOC); tree_set_type(d, type); tree_set_class(d, C_TYPE); tree_set_subkind(d, PORT_IN); add_interface(parent, d, kind); sem_check(d, nametab); // Type generics are immediately visible insert_name(nametab, d, NULL); // LRM 08 section 6.5.3: the predefined equality and inequality // operators are implicitly declared as formal generic subprograms // immediately following the interface type declaration in the // enclosing interface list if (kind == T_GENERIC_DECL) declare_generic_ops(parent, type); } static void p_formal_parameter_list(tree_t decl, type_t type) { // interface_list BEGIN("formal parameter list"); p_interface_list(decl, T_PARAM_DECL, standard() >= STD_19); const int nports = tree_ports(decl); if (nports == 0) return; // Was parse error for (int i = 0; i < nports; i++) { tree_t p = tree_port(decl, i); if (i == 0 && tree_has_value(p)) tree_set_flag(decl, TREE_F_CALL_NO_ARGS); if (tree_has_type(p)) type_add_param(type, tree_type(p)); else type_add_param(type, type_new(T_NONE)); // Will raise error later } } static tree_t p_interface_function_specification(void) { // [ pure | impure ] function designator // [ [ parameter ] ( formal_parameter_list ) ] return type_mark // 2019: // [ pure | impure ] function designator // [ [ parameter ] ( formal_parameter_list ) ] // return [ return_identifier of ] type_mark BEGIN("interface function specification"); bool impure = false; switch (peek()) { case tPURE: consume(tPURE); break; case tIMPURE: consume(tIMPURE); impure = true; break; default: break; } consume(tFUNCTION); ident_t id = p_designator(); type_t type = type_new(T_SIGNATURE); type_set_ident(type, id); tree_t d = tree_new(T_GENERIC_DECL); tree_set_class(d, C_FUNCTION); tree_set_ident(d, id); tree_set_type(d, type); tree_set_subkind(d, PORT_IN); if (impure) tree_set_flag(d, TREE_F_IMPURE); if (optional(tLPAREN)) { push_scope(nametab); p_formal_parameter_list(d, type); consume(tRPAREN); pop_scope(nametab); } else tree_set_flag(d, TREE_F_CALL_NO_ARGS); consume(tRETURN); if (peek_nth(2) != tOF) type_set_result(type, p_type_mark()); else { require_std(STD_19, "function knows return type"); ident_t id = p_identifier(); consume(tOF); type_t sub = type_new(T_SUBTYPE); type_set_ident(sub, id); type_set_base(sub, p_type_mark()); type_set_result(type, sub); } tree_set_loc(d, CURRENT_LOC); return d; } static tree_t p_interface_procedure_specification(void) { // procedure designator [ [ parameter ] ( formal_parameter_list ) ] BEGIN("interface procedure specification"); consume(tPROCEDURE); ident_t id = p_designator(); type_t type = type_new(T_SIGNATURE); type_set_ident(type, id); tree_t d = tree_new(T_GENERIC_DECL); tree_set_class(d, C_PROCEDURE); tree_set_ident(d, id); tree_set_type(d, type); tree_set_subkind(d, PORT_IN); if (optional(tLPAREN)) { push_scope(nametab); p_formal_parameter_list(d, type); consume(tRPAREN); pop_scope(nametab); } else tree_set_flag(d, TREE_F_CALL_NO_ARGS); tree_set_loc(d, CURRENT_LOC); return d; } static void p_interface_subprogram_declaration(tree_t parent, tree_kind_t kind) { // interface_subprogram_specification [ is interface_subprogram_default ] BEGIN("interface subprogram declaration"); tree_t d = NULL; require_std(STD_08, "interface subprogram declarations"); switch (peek()) { case tFUNCTION: case tPURE: case tIMPURE: d = p_interface_function_specification(); break; case tPROCEDURE: d = p_interface_procedure_specification(); break; default: one_of(tFUNCTION, tPROCEDURE, tPURE, tIMPURE); return; } if (optional(tIS)) { switch (peek()) { case tID: { ident_t id = p_identifier(); type_t constraint = tree_type(d); tree_t decl = resolve_subprogram_name(nametab, &last_loc, id, constraint); tree_t box = tree_new(T_BOX); tree_set_loc(box, &last_loc); tree_set_type(box, constraint); tree_set_ident(box, id); tree_set_ref(box, decl); tree_set_value(d, box); } break; case tBOX: { consume(tBOX); tree_t box = tree_new(T_BOX); tree_set_loc(box, CURRENT_LOC); tree_set_type(box, tree_type(d)); tree_set_value(d, box); } break; default: expect(tID, tBOX); } } add_interface(parent, d, kind); sem_check(d, nametab); insert_name(nametab, d, NULL); } static void p_interface_package_generic_map_aspect(tree_t map, tree_t pack) { // generic_map_aspect | generic map ( <> ) | generic map ( default ) BEGIN("interface package generic map aspect"); consume(tGENERIC); consume(tMAP); consume(tLPAREN); switch (peek()) { case tBOX: consume(tBOX); tree_set_subkind(map, PACKAGE_MAP_BOX); break; case tDEFAULT: consume(tDEFAULT); tree_set_subkind(map, PACKAGE_MAP_DEFAULT); break; default: tree_set_subkind(map, PACKAGE_MAP_MATCHING); p_association_list(map, pack, F_GENERIC_MAP); break; } consume(tRPAREN); tree_set_loc(map, CURRENT_LOC); } static void p_interface_package_declaration(tree_t parent, tree_kind_t kind) { // package identifier is new uninstantiated_package_name // interface_package_generic_map_aspect BEGIN("interface package declaration"); consume(tPACKAGE); require_std(STD_08, "interface package declarations"); tree_t d = tree_new(T_GENERIC_DECL); tree_set_class(d, C_PACKAGE); tree_set_ident(d, p_identifier()); tree_set_subkind(d, PORT_IN); consume(tIS); consume(tNEW); ident_t unit_name = p_selected_identifier(); tree_t pack = resolve_name(nametab, CURRENT_LOC, unit_name); if (pack != NULL && !is_uninstantiated_package(pack)) { parse_error(CURRENT_LOC, "unit %s is not an uninstantiated package", istr(unit_name)); pack = NULL; } tree_t map = tree_new(T_PACKAGE_MAP); tree_set_ident(map, unit_name); tree_set_loc(map, CURRENT_LOC); tree_set_ref(map, pack); tree_set_value(d, map); p_interface_package_generic_map_aspect(map, pack); tree_set_loc(d, CURRENT_LOC); add_interface(parent, d, kind); sem_check(d, nametab); insert_name(nametab, d, NULL); } static void p_interface_declaration(tree_t parent, tree_kind_t kind, bool ordered) { // interface_constant_declaration | interface_signal_declaration // | interface_variable_declaration | interface_file_declaration // | 2008: interface_type_declaration // | 2008: interface_subprogram_declaration // | 2008: interface_package_declaration BEGIN("interface declaration"); switch (peek()) { case tCONSTANT: p_interface_constant_declaration(parent, kind, ordered); break; case tSIGNAL: p_interface_signal_declaration(parent, kind, ordered); break; case tVARIABLE: p_interface_variable_declaration(parent, kind); break; case tFILE: p_interface_file_declaration(parent, kind); break; case tTYPE: p_interface_type_declaration(parent, kind); break; case tFUNCTION: case tPROCEDURE: case tPURE: case tIMPURE: p_interface_subprogram_declaration(parent, kind); break; case tPACKAGE: p_interface_package_declaration(parent, kind); break; case tID: if (kind == T_PORT_DECL) p_interface_signal_declaration(parent, kind, ordered); else p_interface_constant_declaration(parent, kind, ordered); break; default: expect(tCONSTANT, tSIGNAL, tVARIABLE, tFILE, tID, tTYPE, STD(08, tFUNCTION), tPROCEDURE, tPURE, tIMPURE, tPACKAGE); } } static void p_interface_element(tree_t parent, tree_kind_t kind, bool ordered) { // interface_declaration BEGIN("interface element"); p_interface_declaration(parent, kind, ordered); } static void p_interface_list(tree_t parent, tree_kind_t kind, bool ordered) { // interface_element { ; interface_element } BEGIN("interface list"); if (peek() == tRPAREN) { parse_error(&last_loc, "interface list cannot be empty"); return; } if (ordered) push_scope(nametab); p_interface_element(parent, kind, ordered); while (optional(tSEMI)) { if (peek() == tRPAREN) { require_std(STD_19, "optional trailing semicolons on interface lists"); break; } p_interface_element(parent, kind, ordered); } if (ordered) pop_scope(nametab); } static void p_port_list(tree_t parent) { // port_list ::= interface_list BEGIN("port list"); p_interface_list(parent, T_PORT_DECL, standard() >= STD_19); } static void p_port_clause(tree_t parent) { // port ( port_list ) ; BEGIN("port clause"); consume(tPORT); consume(tLPAREN); p_port_list(parent); consume(tRPAREN); consume(tSEMI); } static void p_generic_list(tree_t parent) { // generic_list ::= interface_list BEGIN("generic list"); p_interface_list(parent, T_GENERIC_DECL, standard() >= STD_08); } static void p_generic_clause(tree_t parent) { // generic ( generic_list ) ; BEGIN("generic clause"); consume(tGENERIC); consume(tLPAREN); p_generic_list(parent); consume(tRPAREN); consume(tSEMI); } static void p_entity_header(tree_t entity) { // [ generic_clause ] [ port_clause ] BEGIN("entity header"); if (scan(tGENERIC)) { p_generic_clause(entity); insert_generics(nametab, entity); } if (scan(tPORT)) { p_port_clause(entity); insert_ports(nametab, entity); } } static tree_t p_attribute_declaration(void) { // attribute identifier : type_mark ; BEGIN("attribute declaration"); tree_t t = tree_new(T_ATTR_DECL); consume(tATTRIBUTE); tree_set_ident(t, p_identifier()); consume(tCOLON); tree_set_type(t, p_type_mark()); consume(tSEMI); tree_set_loc(t, CURRENT_LOC); insert_name(nametab, t, NULL); sem_check(t, nametab); return t; } static class_t p_entity_class(void) { // entity | procedure | type | signal | label | group | architecture // | function | subtype | variable | literal | file | configuration // | package | constant | component | units BEGIN("entity class"); switch (one_of(tENTITY, tPROCEDURE, tTYPE, tSIGNAL, tLABEL, tGROUP, tARCHITECTURE, tFUNCTION, tSUBTYPE, tVARIABLE, tLITERAL, tFILE, tCONFIGURATION, tPACKAGE, tCONSTANT, tCOMPONENT, tUNITS)) { case tENTITY: return C_ENTITY; case tPROCEDURE: return C_PROCEDURE; case tTYPE: return C_TYPE; case tSIGNAL: return C_SIGNAL; case tLABEL: return C_LABEL; case tGROUP: return C_DEFAULT; case tARCHITECTURE: return C_ARCHITECTURE; case tFUNCTION: return C_FUNCTION; case tSUBTYPE: return C_SUBTYPE; case tVARIABLE: return C_VARIABLE; case tLITERAL: return C_LITERAL; case tFILE: return C_FILE; case tCONFIGURATION: return C_CONFIGURATION; case tPACKAGE: return C_PACKAGE; case tCONSTANT: return C_CONSTANT; case tCOMPONENT: return C_COMPONENT; case tUNITS: return C_UNITS; default: return C_DEFAULT; } } static tree_t p_entity_designator(void) { // entity_tag [ signature ] BEGIN("entity designator"); ident_t id = p_designator(); tree_t t = tree_new(T_ATTR_SPEC); tree_set_loc(t, CURRENT_LOC); tree_set_subkind(t, SPEC_EXACT); tree_set_ident2(t, id); if (peek() == tLSQUARE) { type_t signature = p_signature(); tree_t d = resolve_subprogram_name(nametab, tree_loc(t), id, signature); tree_set_ref(t, d); } return t; } static void p_entity_name_list(tree_list_t *list) { // entity_designator { , entity_designator } | others | all BEGIN("entity name list"); switch (peek()) { case tOTHERS: { consume(tOTHERS); tree_t t = tree_new(T_ATTR_SPEC); tree_set_loc(t, CURRENT_LOC); tree_set_subkind(t, SPEC_OTHERS); APUSH(*list, t); } break; case tALL: { consume(tALL); tree_t t = tree_new(T_ATTR_SPEC); tree_set_loc(t, CURRENT_LOC); tree_set_subkind(t, SPEC_ALL); APUSH(*list, t); } break; default: do { APUSH(*list, p_entity_designator()); } while (optional(tCOMMA)); } } static class_t p_entity_specification(tree_list_t *list) { // entity_name_list : entity_class BEGIN("entity specification"); p_entity_name_list(list); consume(tCOLON); return p_entity_class(); } static void p_attribute_specification(tree_t parent) { // attribute attribute_designator of entity_specification is expression ; BEGIN("attribute specification"); consume(tATTRIBUTE); ident_t head = p_identifier(); type_t type; tree_t attr_decl = resolve_name(nametab, CURRENT_LOC, head); if (attr_decl == NULL) type = type_new(T_NONE); else if (tree_kind(attr_decl) != T_ATTR_DECL) { parse_error(CURRENT_LOC, "name %s is not an attribute declaration", istr(head)); type = type_new(T_NONE); } else type = tree_type(attr_decl); consume(tOF); tree_list_t specs = AINIT; class_t class = p_entity_specification(&specs); consume(tIS); tree_t value = p_expression(); solve_types(nametab, value, type); consume(tSEMI); const loc_t *loc = CURRENT_LOC; for (int i = 0; i < specs.count; i++) { tree_t t = specs.items[i]; assert(tree_kind(t) == T_ATTR_SPEC); if (class == C_LITERAL || class == C_LABEL) ; // Cannot check name now else if (tree_subkind(t) == SPEC_EXACT && !tree_has_ref(t)) tree_set_ref(t, resolve_name(nametab, loc, tree_ident2(t))); tree_set_class(t, class); tree_set_ident(t, head); tree_set_value(t, value); tree_set_type(t, type); insert_name(nametab, t, NULL); tree_add_decl(parent, t); sem_check(t, nametab); } ACLEAR(specs); } static type_t p_integer_type_definition(tree_t r, ident_t id) { // range_constraint EXTEND("integer type definition"); type_t t = type_new(T_INTEGER); type_add_dim(t, r); type_set_ident(t, id); mangle_type(nametab, t); return t; } static type_t p_real_type_definition(tree_t r, ident_t id) { // range_constraint EXTEND("real type definition"); type_t t = type_new(T_REAL); type_add_dim(t, r); type_set_ident(t, id); mangle_type(nametab, t); return t; } static tree_t p_base_unit_declaration(void) { // identifier ; BEGIN("base unit declaration"); ident_t id = p_identifier(); consume(tSEMI); tree_t value = tree_new(T_LITERAL); tree_set_loc(value, CURRENT_LOC); tree_set_subkind(value, L_PHYSICAL); tree_set_ident(value, id); tree_set_ival(value, 1); tree_t t = tree_new(T_UNIT_DECL); tree_set_loc(t, CURRENT_LOC); tree_set_value(t, value); tree_set_ident(t, id); return t; } static tree_t p_secondary_unit_declaration(type_t type) { // identifier = physical_literal ; BEGIN("secondary unit declaration"); ident_t id = p_identifier(); consume(tEQ); tree_t value = p_physical_literal(); consume(tSEMI); tree_t u = tree_new(T_UNIT_DECL); tree_set_ident(u, id); tree_set_value(u, value); tree_set_loc(u, CURRENT_LOC); tree_set_type(u, type); return u; } static type_t p_physical_type_definition(tree_t range, ident_t id) { // range_constraint units base_unit_declaration // { secondary_unit_declaration } end units [ name ] EXTEND("physical type definition"); type_t t = type_new(T_PHYSICAL); type_set_ident(t, id); mangle_type(nametab, t); consume(tUNITS); tree_t base = p_base_unit_declaration(); tree_set_type(base, t); tree_set_type(tree_value(base), t); type_add_unit(t, base); type_add_dim(t, range); push_scope(nametab); insert_name(nametab, base, NULL); while (scan(tINT, tREAL, tID)) { tree_t unit = p_secondary_unit_declaration(t); type_add_unit(t, unit); insert_name(nametab, unit, NULL); } pop_scope(nametab); consume(tEND); consume(tUNITS); if (peek() == tID) { ident_t trailing = p_identifier(); if (trailing != id) parse_error(&yylloc, "expected physical type definition trailing " "identifier to match %s", istr(id)); } return t; } static tree_t p_enumeration_literal(void) { // identifier | character_literal BEGIN("enumeration literal"); tree_t t = tree_new(T_ENUM_LIT); tree_set_ident(t, p_identifier()); tree_set_loc(t, CURRENT_LOC); return t; } static type_t p_enumeration_type_definition(ident_t id) { // ( enumeration_literal { , enumeration_literal } ) BEGIN("enumeration type definition"); type_t t = type_new(T_ENUM); type_set_ident(t, id); mangle_type(nametab, t); consume(tLPAREN); unsigned pos = 0; do { tree_t lit = p_enumeration_literal(); tree_set_pos(lit, pos++); tree_set_type(lit, t); type_enum_add_literal(t, lit); } while (optional(tCOMMA)); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_TO); tree_set_left(r, make_ref(type_enum_literal(t, 0))); tree_set_right(r, make_ref(type_enum_literal(t, pos - 1))); tree_set_loc(r, CURRENT_LOC); tree_set_type(r, t); type_add_dim(t, r); consume(tRPAREN); return t; } static type_t p_scalar_type_definition(ident_t id) { // enumeration_type_definition | integer_type_definition // | floating_type_definition | physical_type_definition BEGIN("scalar type definition"); switch (peek()) { case tRANGE: { tree_t r = tree_range(p_range_constraint(NULL), 0); if (peek() == tUNITS) return p_physical_type_definition(r, id); else if (type_is_real(tree_type(r))) return p_real_type_definition(r, id); else return p_integer_type_definition(r, id); } case tLPAREN: return p_enumeration_type_definition(id); default: one_of(tRANGE, tLPAREN); return type_new(T_NONE); } } static type_t p_access_type_definition(ident_t id) { // access subtype_indication BEGIN("access type definition"); consume(tACCESS); type_t t = type_new(T_ACCESS); type_set_ident(t, id); type_set_designated(t, p_subtype_indication()); mangle_type(nametab, t); return t; } static type_t p_file_type_definition(ident_t id) { // file of type_mark BEGIN("file type definition"); consume(tFILE); consume(tOF); type_t t = type_new(T_FILE); type_set_ident(t, id); type_set_designated(t, p_type_mark()); mangle_type(nametab, t); return t; } static void p_element_declaration(type_t rec) { // identifier_list : element_subtype_definition ; BEGIN("element declaration"); LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); type_t type = p_subtype_indication(); consume(tSEMI); int pos = type_fields(rec); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t f = tree_new(T_FIELD_DECL); tree_set_ident(f, it->ident); tree_set_type(f, type); tree_set_pos(f, pos++); tree_set_loc(f, &(it->loc)); type_add_field(rec, f); } } static type_t p_record_type_definition(ident_t id) { // record element_declaration { element_declaration } end record // [ simple_name ] // 2019: record { element_declaration } end record [ simple_name ] BEGIN("record type definition"); consume(tRECORD); type_t r = type_new(T_RECORD); type_set_ident(r, id); mangle_type(nametab, r); if (peek() == tEND) require_std(STD_19, "empty record"); else { do { p_element_declaration(r); } while (peek() == tID); } consume(tEND); consume(tRECORD); if (peek() == tID) { ident_t trailing = p_identifier(); if (trailing != id) parse_error(&yylloc, "expected record type definition trailing " "identifier to match %s", istr(id)); } return r; } static type_t p_index_subtype_definition(tree_t head) { // type_mark range <> BEGIN_WITH_HEAD("index subtype definition", head); type_t type; if (head != NULL) type = name_to_type_mark(head); else type = p_type_mark(); consume(tRANGE); consume(tBOX); return type; } static type_t p_unconstrained_array_definition(type_t base, tree_t head) { // array ( index_subtype_definition { , index_subtype_definition } ) // of subtype_indication EXTEND("unconstrained array definition"); type_add_index(base, p_index_subtype_definition(head)); while (optional(tCOMMA)) type_add_index(base, p_index_subtype_definition(NULL)); mangle_type(nametab, base); consume(tRPAREN); consume(tOF); type_set_elem(base, p_subtype_indication()); return base; } static type_t p_constrained_array_definition(type_t base, tree_t head) { // array index_constraint of element_subtype_indication EXTEND("constrained array definition"); tree_t constraint = tree_new(T_CONSTRAINT); tree_set_subkind(constraint, C_INDEX); type_t sub = type_new(T_SUBTYPE); type_set_base(sub, base); type_set_constraint(sub, constraint); type_set_ident(sub, type_ident(base)); mangle_type(nametab, sub); do { tree_t r = p_discrete_range(head); solve_types(nametab, r, NULL); convert_universal_bounds(r); tree_add_range(constraint, r); type_add_index(base, tree_type(r)); head = NULL; } while (optional(tCOMMA)); consume(tRPAREN); tree_set_loc(constraint, CURRENT_LOC); consume(tOF); type_set_elem(base, p_subtype_indication()); return sub; } static type_t p_array_type_definition(ident_t id) { // unconstrained_array_definition | constrained_array_definition BEGIN("array type definition"); type_t base = type_new(T_ARRAY); type_set_ident(base, id); consume(tARRAY); consume(tLPAREN); tree_t head = p_expression(); if (peek_nth(2) == tBOX) return p_unconstrained_array_definition(base, head); else return p_constrained_array_definition(base, head); } static type_t p_composite_type_definition(ident_t id) { // array_type_definition | record_type_definition BEGIN("composite type definition"); switch (peek()) { case tRECORD: return p_record_type_definition(id); case tARRAY: return p_array_type_definition(id); default: expect(tRECORD, tARRAY); return type_new(T_NONE); } } static void p_private_variable_declaration(tree_t decl) { // 2019: private variable_declaration BEGIN("private variable declaration"); consume(tPRIVATE); require_std(STD_19, "private variable declarations"); p_variable_declaration(decl); } static void p_protected_type_declarative_item(tree_t decl) { // subprogram_declaration | 2008: subprogram_instantiation_declaration // | attribute_specification | use_clause // | 2019: private_variable_declaration | alias_declaration BEGIN("protected type declarative item"); switch (peek()) { case tATTRIBUTE: p_attribute_specification(decl); break; case tUSE: p_use_clause(decl, tree_add_decl); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(decl, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); tree_set_flag(spec, TREE_F_PROTECTED); tree_add_decl(decl, p_subprogram_declaration(spec)); } break; case tPRIVATE: p_private_variable_declaration(decl); break; case tALIAS: p_alias_declaration(decl); break; default: expect(tATTRIBUTE, tUSE, STD(08, tFUNCTION), tPROCEDURE, tIMPURE, tPURE, STD(19, tPRIVATE), tALIAS); } } static void p_protected_type_declarative_part(tree_t decl) { // { protected_type_declarative_item } BEGIN("protected type declarative part"); while (not_at_token(tEND)) p_protected_type_declarative_item(decl); } static tree_t p_protected_type_declaration(ident_t id) { // protected protected_type_declarative_part end protected [ simple_name ] BEGIN("protected type declaration"); consume(tPROTECTED); type_t type = type_new(T_PROTECTED); type_set_ident(type, id); mangle_type(nametab, type); tree_t t = tree_new(T_PROT_DECL); tree_set_ident(t, id); tree_set_type(t, type); tree_set_loc(t, CURRENT_LOC); insert_name(nametab, t, NULL); push_scope(nametab); scope_set_prefix(nametab, id); p_protected_type_declarative_part(t); const int ndecls = tree_decls(t); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(t, i); if (is_subprogram(d) || tree_kind(d) == T_ALIAS) type_add_field(type, d); } pop_scope(nametab); consume(tEND); consume(tPROTECTED); p_trailing_label(id); tree_set_loc(t, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_protected_type_definition(ident_t id) { // protected_type_declaration | protected_type_body BEGIN("protected type definition"); if (peek_nth(2) == tBODY) return p_protected_type_body(id); else return p_protected_type_declaration(id); } static type_t p_type_definition(tree_t tdecl) { // scalar_type_definition | composite_type_definition // | access_type_definition | file_type_definition // | 2000: protected_type_definition BEGIN("type definition"); ident_t id = tree_ident(tdecl); switch (peek()) { case tRANGE: case tLPAREN: return p_scalar_type_definition(id); case tACCESS: return p_access_type_definition(id); case tFILE: return p_file_type_definition(id); case tRECORD: case tARRAY: return p_composite_type_definition(id); default: expect(tRANGE, tACCESS, tFILE, tRECORD); return type_new(T_NONE); } } static type_t p_full_type_declaration(tree_t tdecl) { // type identifier is type_definition ; EXTEND("full type declaration"); consume(tIS); type_t t = p_type_definition(tdecl); consume(tSEMI); return t; } static type_t p_incomplete_type_declaration(ident_t id) { // type identifier ; EXTEND("incomplete type declaration"); consume(tSEMI); type_t t = type_new(T_INCOMPLETE); type_set_ident(t, id); mangle_type(nametab, t); return t; } static void p_type_declaration(tree_t container) { // full_type_declaration | incomplete_type_declaration BEGIN("type declaration"); consume(tTYPE); ident_t id = p_identifier(); hide_name(nametab, id); // Protected type definitions are trees rather than types if (peek_nth(1) == tIS && peek_nth(2) == tPROTECTED) { consume(tIS); tree_add_decl(container, p_protected_type_definition(id)); consume(tSEMI); } else { // Insert univeral_integer and universal_real predefined functions // before STD.INTEGER and STD.REAL respectively if (bootstrapping) { if (id == ident_new("INTEGER")) make_universal_int(container); else if (id == ident_new("REAL")) make_universal_real(container); } tree_t t = tree_new(T_TYPE_DECL); tree_set_ident(t, id); tree_set_loc(t, CURRENT_LOC); type_t type; if (peek() == tSEMI) type = p_incomplete_type_declaration(id); else type = p_full_type_declaration(t); tree_set_type(t, type); tree_set_loc(t, CURRENT_LOC); insert_name(nametab, t, id); tree_add_decl(container, t); const type_kind_t kind = type_kind(type); type_t base = type; if (kind == T_SUBTYPE) { base = type_base(type); assert(type_kind(base) == T_ARRAY); mangle_type(nametab, base); } if (kind != T_INCOMPLETE) declare_predefined_ops(container, base); if (kind == T_PHYSICAL) { const int nunits = type_units(type); for (int i = 0; i < nunits; i++) solve_types(nametab, tree_value(type_unit(type, i)), type); } sem_check(t, nametab); } } static tree_t p_subtype_declaration(void) { // subtype identifier is subtype_indication ; BEGIN("subtype declaration"); consume(tSUBTYPE); ident_t id = p_identifier(); hide_name(nametab, id); consume(tIS); type_t sub = p_subtype_indication(); consume(tSEMI); if (type_kind(sub) != T_SUBTYPE || type_has_ident(sub)) { // Case where subtype_indication did not impose any // constraint so we must create the subtype object here type_t new = type_new(T_SUBTYPE); type_set_base(new, sub); sub = new; } type_set_ident(sub, id); mangle_type(nametab, sub); tree_t t = tree_new(T_SUBTYPE_DECL); tree_set_ident(t, id); tree_set_type(t, sub); tree_set_loc(t, CURRENT_LOC); insert_name(nametab, t, id); sem_check(t, nametab); return t; } static tree_t p_conditional_expression(void) { // expression { when condition else expression } BEGIN("conditional expression"); tree_t expr0 = p_expression(); if (optional(tWHEN)) { require_std(STD_19, "conditional expressions"); tree_t value = tree_new(T_COND_VALUE); do { tree_t cond = tree_new(T_COND_EXPR); tree_set_result(cond, expr0); tree_set_value(cond, p_condition()); tree_set_loc(cond, CURRENT_LOC); tree_add_cond(value, cond); consume(tELSE); expr0 = p_expression(); } while (optional(tWHEN)); tree_t last = tree_new(T_COND_EXPR); tree_set_result(last, expr0); tree_set_loc(last, CURRENT_LOC); tree_add_cond(value, last); tree_set_loc(value, CURRENT_LOC); return value; } else return expr0; } static tree_t p_expression_or_unaffected(void) { // expression | unaffected BEGIN("expression or unaffected"); if (optional(tUNAFFECTED)) { require_std(STD_19, "unaffected in conditional expression"); return NULL; } else return p_expression(); } static tree_t p_conditional_or_unaffected_expression(vhdl_standard_t minstd) { // expression_or_unaffected { when condition else expression_or_unaffected } // [ when condition ] BEGIN("conditional expression"); tree_t expr0 = p_expression_or_unaffected(); if (optional(tWHEN)) { require_std(minstd, "conditional expressions"); tree_t value = tree_new(T_COND_VALUE); tree_t c0 = tree_new(T_COND_EXPR); tree_set_result(c0, expr0); tree_set_value(c0, p_condition()); tree_set_loc(c0, CURRENT_LOC); tree_add_cond(value, c0); while (optional(tELSE)) { tree_t cond = tree_new(T_COND_EXPR); tree_set_result(cond, p_expression_or_unaffected()); tree_set_loc(cond, CURRENT_LOC); tree_add_cond(value, cond); if (!optional(tWHEN)) break; tree_set_value(cond, p_condition()); tree_set_loc(cond, CURRENT_LOC); } tree_set_loc(value, CURRENT_LOC); return value; } else return expr0; } static void p_constant_declaration(tree_t parent) { // constant identifier_list : subtype_indication [ := expression ] ; BEGIN("constant declaration"); consume(tCONSTANT); LOCAL_IDENT_LIST ids = p_identifier_list(); for (ident_list_t *it = ids; it != NULL; it = it->next) hide_name(nametab, it->ident); consume(tCOLON); type_t type = p_subtype_indication(); tree_t init = NULL; if (optional(tWALRUS)) init = p_conditional_expression(); // According to the LRM all constants are globally static but that // leads to a number of logical inconsistencies so we retrict to only // constants in certain regions where the value can be computed // during elaboration tree_flags_t flags = 0; switch (tree_kind(parent)) { case T_ENTITY: case T_ARCH: case T_PACKAGE: case T_PACK_BODY: case T_BLOCK: case T_FOR_GENERATE: case T_COND_STMT: // If-generate case T_ALTERNATIVE: // For-generate flags |= TREE_F_GLOBALLY_STATIC; break; default: break; } consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_CONST_DECL); tree_set_ident(t, it->ident); tree_set_type(t, type); tree_set_flag(t, flags); tree_set_loc(t, &(it->loc)); if (init != NULL) { tree_set_value(t, init); if (standard() < STD_19 || type_is_unconstrained(type)) solve_types(nametab, init, type); else solve_known_subtype(nametab, init, t); } tree_add_decl(parent, t); insert_name(nametab, t, it->ident); sem_check(t, nametab); } } static tree_t p_condition(void) { BEGIN("condition"); tree_t value = p_expression(); solve_condition(nametab, &value); return value; } static tree_t p_assertion(void) { // assert condition [ report expression ] [ severity expression ] BEGIN("assertion"); tree_t s = tree_new(T_ASSERT); consume(tASSERT); tree_set_value(s, p_condition()); if (optional(tREPORT)) { tree_t message = p_expression(); solve_types(nametab, message, std_type(NULL, STD_STRING)); tree_set_message(s, message); } if (optional(tSEVERITY)) { tree_t severity = p_expression(); solve_types(nametab, severity, std_type(NULL, STD_SEVERITY_LEVEL)); tree_set_severity(s, severity); } tree_set_loc(s, CURRENT_LOC); return s; } static tree_t p_concurrent_assertion_statement(ident_t label) { // [ label : ] [ postponed ] assertion ; BEGIN("concurrent assertion statement"); tree_t conc = tree_new(T_CONCURRENT); if (optional(tPOSTPONED)) tree_set_flag(conc, TREE_F_POSTPONED); tree_t s = p_assertion(); tree_add_stmt(conc, s); consume(tSEMI); tree_set_loc(s, CURRENT_LOC); tree_set_loc(conc, CURRENT_LOC); ensure_labelled(conc, label); if (label) insert_name(nametab, conc, NULL); sem_check(conc, nametab); return conc; } static ident_t p_designator(void) { // identifier | operator_symbol BEGIN("designator"); switch (peek()) { case tID: return p_identifier(); case tSTRING: return p_operator_symbol(); default: expect(tID, tSTRING); return error_marker(); } } static void p_subprogram_header(tree_t spec) { // 2008: [ generic ( generic_list ) [ generic_map_aspect ] ] if (optional(tGENERIC)) { require_std(STD_08, "generic subprograms"); consume(tLPAREN); p_generic_list(spec); consume(tRPAREN); insert_generics(nametab, spec); } } static tree_t p_subprogram_specification(void) { // procedure designator subprogram_header // [ [parameter] ( formal_parameter_list ) ] // | [ pure | impure ] function designator subprogram_header // [ [parameter] ( formal_parameter_list ) ] return type_mark // 2019: // [ pure | impure ] function designator subprogram_header // [ [parameter] ( formal_parameter_list ) ] // return [ return_identifier of ] type_mark BEGIN("subprogram specification"); tree_t t = NULL; type_t type = NULL; bool impure = false; switch (one_of(tFUNCTION, tPROCEDURE, tPURE, tIMPURE)) { case tIMPURE: impure = true; // Fall-through case tPURE: consume(tFUNCTION); // Fall-through case tFUNCTION: t = tree_new(T_FUNC_DECL); break; case tPROCEDURE: t = tree_new(T_PROC_DECL); break; default: return tree_new(T_FUNC_DECL); } type = type_new(T_SIGNATURE); tree_set_type(t, type); tree_set_ident(t, p_designator()); tree_set_subkind(t, S_USER); type_set_ident(type, tree_ident(t)); if (impure) tree_set_flag(t, TREE_F_IMPURE); push_scope(nametab); p_subprogram_header(t); bool has_param_list = false; if (optional(tLPAREN)) has_param_list = true; else if (standard() >= STD_08 && optional(tPARAMETER)) { consume(tLPAREN); has_param_list = true; } if (has_param_list) { p_formal_parameter_list(t, type); consume(tRPAREN); } else tree_set_flag(t, TREE_F_CALL_NO_ARGS); if (tree_kind(t) == T_FUNC_DECL) { consume(tRETURN); if (peek_nth(2) != tOF) type_set_result(type, p_type_mark()); else { require_std(STD_19, "function knows return type"); ident_t id = p_identifier(); consume(tOF); type_t of = p_type_mark(), sub; if (type_is_unconstrained(of)) { tree_t rref = tree_new(T_REF); tree_set_loc(rref, CURRENT_LOC); tree_set_ident(rref, ident_new("result")); tree_set_ref(rref, t); tree_set_type(rref, of); sub = get_subtype_for(rref); } else { parse_error(CURRENT_LOC, "type mark of return identifier must " "denote an unconstrained type"); sub = type_new(T_SUBTYPE); type_set_base(sub, of); } type_set_ident(sub, id); type_set_result(type, sub); tree_set_flag(t, TREE_F_KNOWS_SUBTYPE); } } pop_scope(nametab); mangle_func(nametab, t); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_subprogram_instantiation_declaration(void) { // subprogram_kind designator is new uninstantiated_subprogram_name // [ signature ] [ generic_map_aspect ] ; tree_kind_t kind; switch (one_of(tFUNCTION, tPROCEDURE)) { case tFUNCTION: kind = T_FUNC_INST; break; case tPROCEDURE: kind = T_PROC_INST; break; default: return NULL; } tree_t inst = tree_new(kind); tree_set_ident(inst, p_designator()); consume(tIS); consume(tNEW); require_std(STD_08, "subprogram instantiation declarations"); tree_t name = p_name(N_SUBPROGRAM | N_TYPE); type_t constraint = NULL; if (peek() == tLSQUARE) constraint = p_signature(); tree_t decl = NULL; if (tree_kind(name) != T_REF) parse_error(CURRENT_LOC, "expecting uninstantiated subprogram name"); else { decl = resolve_uninstantiated_subprogram(nametab, tree_loc(name), tree_ident(name), constraint); } if (decl != NULL) { tree_t body = find_generic_subprogram_body(inst, decl); instantiate_subprogram(inst, decl, body); } else { // Create a dummy subprogram type to avoid later errors type_t type = type_new(T_SIGNATURE); type_set_ident(type, error_marker()); if (kind == T_FUNC_INST) type_set_result(type, type_new(T_NONE)); tree_set_type(inst, type); } if (peek() == tGENERIC) p_generic_map_aspect(inst, inst); consume(tSEMI); tree_set_loc(inst, CURRENT_LOC); sem_check(inst, nametab); hash_t *map = get_generic_map(nametab); if (map != NULL) instance_fixup(inst, map); mangle_func(nametab, inst); insert_name(nametab, inst, NULL); return inst; } static void p_variable_declaration(tree_t parent) { // [ shared ] variable identifier_list : subtype_indication // [ := expression ] ; BEGIN("variable declaration"); const bool shared = optional(tSHARED); consume(tVARIABLE); LOCAL_IDENT_LIST ids = p_identifier_list(); for (ident_list_t *it = ids; it != NULL; it = it->next) hide_name(nametab, it->ident); consume(tCOLON); type_t type = p_subtype_indication(); tree_t init = NULL; if (optional(tWALRUS)) { init = p_conditional_expression(); solve_types(nametab, init, type); } consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_VAR_DECL); tree_set_loc(t, &(it->loc)); tree_set_ident(t, it->ident); tree_set_type(t, type); if (init != NULL) tree_set_value(t, init); if (shared) tree_set_flag(t, TREE_F_SHARED); tree_add_decl(parent, t); insert_name(nametab, t, it->ident); sem_check(t, nametab); } } static tree_flags_t p_signal_kind(void) { // register | bus switch (peek()) { case tBUS: consume(tBUS); return TREE_F_BUS; case tREGISTER: consume(tREGISTER); return TREE_F_REGISTER; default: return 0; } } static void p_signal_declaration(tree_t parent) { // signal identifier_list : subtype_indication [ signal_kind ] // [ := expression ] ; BEGIN("signal declaration"); consume(tSIGNAL); LOCAL_IDENT_LIST ids = p_identifier_list(); for (ident_list_t *it = ids; it != NULL; it = it->next) hide_name(nametab, it->ident); consume(tCOLON); type_t type = p_subtype_indication(); tree_flags_t flags = p_signal_kind(); tree_t init = NULL; if (optional(tWALRUS)) init = p_conditional_expression(); consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_SIGNAL_DECL); tree_set_loc(t, &(it->loc)); tree_set_ident(t, it->ident); tree_set_type(t, type); tree_set_flag(t, flags); if (init != NULL) { solve_known_subtype(nametab, init, t); tree_set_value(t, init); } tree_add_decl(parent, t); insert_name(nametab, t, it->ident); sem_check(t, nametab); } } static type_t p_signature(void) { // [ [ type_mark { , type_mark } ] [ return type_mark ] ] BEGIN("signature"); type_t type = type_new(T_SIGNATURE); consume(tLSQUARE); bool error = false; if (not_at_token(tRETURN, tRSQUARE)) { do { type_t param = p_type_mark(); type_add_param(type, param); error = error || type_is_none(param); } while (optional(tCOMMA)); } if (optional(tRETURN)) { type_t ret = p_type_mark(); type_set_result(type, ret); error = error || type_is_none(ret); } consume(tRSQUARE); return error ? type_new(T_NONE) : type; } static void p_alias_declaration(tree_t parent) { // alias alias_designator [ : subtype_indication ] is name [ signature ] ; BEGIN("alias declaration"); tree_t t = tree_new(T_ALIAS); consume(tALIAS); ident_t id = p_designator(); tree_set_ident(t, id); hide_name(nametab, id); bool has_subtype_indication = false; if (optional(tCOLON)) { tree_set_type(t, p_subtype_indication()); has_subtype_indication = true; } consume(tIS); tree_t value = p_name(N_SUBPROGRAM | N_TYPE); tree_set_value(t, value); if (peek() == tLPAREN) { parse_error(tree_loc(value), "name cannot be indexed or sliced"); tree_set_type(t, type_new(T_NONE)); drop_tokens_until(tRPAREN); } const tree_kind_t value_kind = tree_kind(value); bool nonobject_alias = false, type_alias = false; if (peek() == tLSQUARE) { type_t type = p_signature(); if (has_subtype_indication) { parse_error(CURRENT_LOC, "alias declaration may not contain both a " "signature and a subtype indication"); type = type_new(T_NONE); } else if (value_kind != T_REF && value_kind != T_PROT_REF) { if (!type_is_none((type = solve_types(nametab, value, NULL)))) { parse_error(tree_loc(value), "invalid name in subprogram alias"); type = type_new(T_NONE); } } else { ident_t id = tree_ident(value); type_set_ident(type, ident_rfrom(id, '.') ?: id); solve_types(nametab, value, type); } tree_set_type(t, type); } else if (value_kind == T_REF && tree_has_ref(value)) { // A nonobject alias may be a design unit which does not have a type tree_t decl = tree_ref(value); if (is_design_unit(decl)) { tree_set_flag(t, TREE_F_NONOBJECT_ALIAS); nonobject_alias = true; } else solve_types(nametab, value, NULL); } else solve_types(nametab, value, NULL); if (value_kind == T_REF && tree_has_ref(value)) { tree_t decl = tree_ref(value); if (is_type_decl(decl)) type_alias = true; } if ((type_alias || nonobject_alias) && has_subtype_indication) parse_error(CURRENT_LOC, "nonobject alias may not have a " "subtype indication"); consume(tSEMI); tree_set_loc(t, CURRENT_LOC); insert_name(nametab, t, NULL); sem_check(t, nametab); tree_add_decl(parent, t); if (type_alias) { // LRM 08 section 6.6.3 an implicit alias declaration exists for // each enumeration literal, unit, and predefined operators type_t type = tree_type(value); switch (type_kind(type)) { case T_ENUM: { const int nlits = type_enum_literals(type); for (int i = 0; i < nlits; i++) { tree_t lit = type_enum_literal(type, i); tree_t a = tree_new(T_ALIAS); tree_set_loc(a, CURRENT_LOC); tree_set_ident(a, tree_ident(lit)); tree_set_value(a, make_ref(lit)); tree_set_type(a, type); tree_set_flag(a, TREE_F_PREDEFINED); insert_name(nametab, a, NULL); tree_add_decl(parent, a); } } break; case T_PHYSICAL: { const int nunits = type_units(type); for (int i = 0; i < nunits; i++) { tree_t unit = type_unit(type, i); tree_t a = tree_new(T_ALIAS); tree_set_loc(a, CURRENT_LOC); tree_set_ident(a, tree_ident(unit)); tree_set_value(a, make_ref(unit)); tree_set_type(a, type); tree_set_flag(a, TREE_F_PREDEFINED); insert_name(nametab, a, NULL); tree_add_decl(parent, a); } } default: break; } walk_predefs(nametab, tree_ident(value), add_predef_alias, parent); } } static void p_file_open_information(tree_t *mode, tree_t *name) { // [ open expression ] is file_logical_name BEGIN("file open information"); if (optional(tOPEN)) { *mode = p_expression(); solve_types(nametab, *mode, std_type(NULL, STD_FILE_OPEN_KIND)); } else *mode = NULL; if (optional(tIS)) { ident_t mode_name = ident_new("READ_MODE"); if ((*mode == NULL) && scan(tIN, tOUT)) { // VHDL-87 compatibility switch (one_of(tIN, tOUT)) { case tIN: break; case tOUT: mode_name = ident_new("WRITE_MODE"); break; } } *name = p_expression(); solve_types(nametab, *name, std_type(NULL, STD_STRING)); if (*mode == NULL) { tree_t decl = get_local_decl(nametab, find_std(nametab), mode_name, 0); *mode = make_ref(decl); } } else *name = NULL; } static void p_file_declaration(tree_t parent) { // file identifier_list : subtype_indication [ file_open_information ] ; BEGIN("file declaration"); consume(tFILE); LOCAL_IDENT_LIST ids = p_identifier_list(); for (ident_list_t *it = ids; it != NULL; it = it->next) hide_name(nametab, it->ident); consume(tCOLON); type_t type = p_subtype_indication(); tree_t mode, name; p_file_open_information(&mode, &name); consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_FILE_DECL); tree_set_ident(t, it->ident); tree_set_type(t, type); if (name != NULL) { tree_set_file_mode(t, mode); tree_set_value(t, name); } tree_set_loc(t, &(it->loc)); tree_add_decl(parent, t); insert_name(nametab, t, it->ident); sem_check(t, nametab); } } static void p_disconnection_specification(tree_t container) { // disconnect guarded_signal_specification after time_expression ; BEGIN("disconnection specification"); consume(tDISCONNECT); LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); type_t type = p_type_mark(); consume(tAFTER); tree_t delay = p_expression(); solve_types(nametab, delay, std_type(NULL, STD_TIME)); consume(tSEMI); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t d = tree_new(T_DISCONNECT); tree_set_loc(d, &(it->loc)); tree_set_ident(d, it->ident); tree_set_type(d, type); tree_set_delay(d, delay); tree_set_ref(d, resolve_name(nametab, CURRENT_LOC, it->ident)); // TODO: we should use insert_spec for this ident_t name = ident_prefix(it->ident, ident_new("disconnect"), '$'); insert_name(nametab, d, name); tree_add_decl(container, d); sem_check(d, nametab); } } static void p_entity_class_entry_list(tree_t group) { // entity_class [ <> ] { , entity_class [ <> ] } BEGIN("entity class entry list"); do { p_entity_class(); optional(tBOX); } while (optional(tCOMMA)); } static tree_t p_group_template_declaration(void) { // group identifier is ( entity_class_entry_list ) ; BEGIN("group template declaration"); consume(tGROUP); tree_t g = tree_new(T_GROUP_TEMPLATE); tree_set_ident(g, p_identifier()); consume(tIS); consume(tLPAREN); p_entity_class_entry_list(g); consume(tRPAREN); consume(tSEMI); tree_set_loc(g, CURRENT_LOC); insert_name(nametab, g, NULL); return g; } static void p_group_constituent_list(tree_t group) { // group_constituent_list ::= group_constituent { , group_constituent } BEGIN("group constituent list"); do { (void)p_name(0); // Do nothing with groups currently } while (optional(tCOMMA)); } static tree_t p_group_declaration(void) { // group identifier : group_template_name ( group_constituent_list ) ; BEGIN("group declaration"); consume(tGROUP); tree_t g = tree_new(T_GROUP); tree_set_ident(g, p_identifier()); consume(tCOLON); ident_t template_name = p_identifier(); tree_t template = resolve_name(nametab, CURRENT_LOC, template_name); if (template != NULL && tree_kind(template) != T_GROUP_TEMPLATE) { parse_error(CURRENT_LOC, "%s does not name a group template", istr(template_name)); template = NULL; } tree_set_ref(g, template); consume(tLPAREN); p_group_constituent_list(g); consume(tRPAREN); consume(tSEMI); tree_set_loc(g, CURRENT_LOC); insert_name(nametab, g, NULL); return g; } static void p_protected_type_body_declarative_item(tree_t body) { // subprogram_declaration | subprogram_body | type_declaration // | subtype_declaration | constant_declaration | variable_declaration // | file_declaration | alias_declaration | attribute_declaration // | attribute_specification | use_clause | group_template_declaration // | group_declaration | 2008: subprogram_instantiation_declaration BEGIN("protected type body declarative item"); switch (peek()) { case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(body); else tree_add_decl(body, p_attribute_declaration()); break; case tTYPE: p_type_declaration(body); break; case tSUBTYPE: tree_add_decl(body, p_subtype_declaration()); break; case tCONSTANT: p_constant_declaration(body); break; case tALIAS: p_alias_declaration(body); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(body, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); tree_set_flag(spec, TREE_F_PROTECTED); if (peek() == tSEMI) tree_add_decl(body, p_subprogram_declaration(spec)); else tree_add_decl(body, p_subprogram_body(spec)); } break; case tVARIABLE: p_variable_declaration(body); break; case tUSE: p_use_clause(body, tree_add_decl); break; case tFILE: p_file_declaration(body); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(body, p_group_template_declaration()); else tree_add_decl(body, p_group_declaration()); break; default: expect(tATTRIBUTE, tTYPE, tSUBTYPE, tCONSTANT, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tALIAS, tVARIABLE, tUSE, tFILE, tGROUP); } } static void p_protected_type_body_declarative_part(tree_t body) { // { protected_type_body_declarative_item } BEGIN("protected type body declarative part"); while (not_at_token(tEND)) p_protected_type_body_declarative_item(body); } static tree_t p_protected_type_body(ident_t id) { // protected body protected_type_body_declarative_part end protected body // [ simple name ] BEGIN("protected type body"); consume(tPROTECTED); consume(tBODY); tree_t body = tree_new(T_PROT_BODY); tree_set_ident(body, id); tree_set_loc(body, CURRENT_LOC); tree_t decl = resolve_name(nametab, CURRENT_LOC, id); if (decl != NULL) { switch (tree_kind(decl)) { case T_PROT_BODY: // Duplicate body will trigger an error later if (!tree_has_primary(decl)) { assert(error_count() > 0); // Fallout from previous error, ignore decl = NULL; break; } decl = tree_primary(decl); // Fall-through case T_PROT_DECL: tree_set_primary(body, decl); break; default: parse_error(CURRENT_LOC, "object %s is not a protected type " "declaration", istr(id)); decl = NULL; } } if (decl == NULL) tree_set_type(body, type_new(T_NONE)); else { type_t type = tree_type(decl); assert(type_is_protected(type)); tree_set_type(body, type); } insert_name(nametab, body, NULL); push_scope(nametab); if (decl != NULL) insert_decls(nametab, decl); scope_set_prefix(nametab, id); scope_set_container(nametab, body); p_protected_type_body_declarative_part(body); consume(tEND); consume(tPROTECTED); consume(tBODY); p_trailing_label(id); tree_set_loc(body, CURRENT_LOC); sem_check(body, nametab); pop_scope(nametab); return body; } static tree_t p_package_instantiation_declaration(tree_t unit) { // 2008: package identifier is new name [ generic_map_aspect ] ; consume(tPACKAGE); ident_t id = p_identifier(); consume(tIS); consume(tNEW); require_std(STD_08, "package instantiation declarations"); ident_t unit_name = p_selected_identifier(); tree_t pack = resolve_name(nametab, CURRENT_LOC, unit_name); if (pack != NULL && !is_uninstantiated_package(pack)) { parse_error(CURRENT_LOC, "unit %s is not an uninstantiated package", istr(unit_name)); pack = NULL; } tree_t new; if (unit != NULL) { // Package instantiation declaration as primary unit assert(tree_kind(unit) == T_DESIGN_UNIT); tree_change_kind(unit, T_PACK_INST); new = unit; ident_t qual = ident_prefix(lib_name(lib_work()), id, '.'); tree_set_ident(new, qual); } else { new = tree_new(T_PACK_INST); tree_set_ident(new, id); } tree_t body = NULL; if (pack != NULL) { if (package_needs_body(pack) && (body = body_of(pack)) == NULL) parse_error(CURRENT_LOC, "package %s cannot be instantiated until " "its body has been analysed", istr(unit_name)); instantiate_package(new, pack, body); } tree_set_ref(new, pack); if (peek() == tGENERIC) p_generic_map_aspect(new, new); consume(tSEMI); tree_set_loc(new, CURRENT_LOC); insert_name(nametab, new, NULL); sem_check(new, nametab); hash_t *map = get_generic_map(nametab); if (map != NULL) instance_fixup(new, map); return new; } static tree_t p_element_array_mode_view_indication(void) { // view ( name ) BEGIN("element array mode view indication"); consume(tVIEW); consume(tLPAREN); tree_t name = p_name(0); solve_types(nametab, name, NULL); consume(tRPAREN); return name; } static tree_t p_element_record_mode_view_indication(void) { // view name BEGIN("element record mode view indication"); consume(tVIEW); tree_t name = p_name(0); solve_types(nametab, name, NULL); return name; } static port_mode_t p_element_mode_view_indication(tree_t *name) { // element_record_mode_view_indication | element_array_mode_view_indication BEGIN("element mode view indication"); if (peek_nth(2) == tLPAREN) { *name = p_element_array_mode_view_indication(); return PORT_ARRAY_VIEW; } else { *name = p_element_record_mode_view_indication(); return PORT_RECORD_VIEW; } } static void p_mode_view_element_declaration(type_t view, type_t of) { // record_element_list : element_mode_indication ; BEGIN("mode view element declaration"); LOCAL_IDENT_LIST ids = p_identifier_list(); consume(tCOLON); tree_t name = NULL; port_mode_t mode; if (peek() == tVIEW) mode = p_element_mode_view_indication(&name); else mode = p_mode(); for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t elt = tree_new(T_VIEW_ELEMENT); tree_set_ident(elt, it->ident); tree_set_loc(elt, &(it->loc)); tree_set_subkind(elt, mode); tree_set_value(elt, name); type_add_field(view, elt); tree_t f = resolve_field_name(nametab, &(it->loc), it->ident, of); if (f == NULL) tree_set_type(elt, type_new(T_NONE)); else { tree_set_ref(elt, f); tree_set_type(elt, tree_type(f)); } } consume(tSEMI); } static tree_t p_mode_view_declaration(void) { // view identifier of subtype_indication is // { mode_view_element_definition } end view [ mode_view_simple_name ] ; BEGIN("mode view declaration"); consume(tVIEW); tree_t view = tree_new(T_VIEW_DECL); ident_t id = p_identifier(); tree_set_ident(view, id); consume(tOF); type_t of = p_subtype_indication(); type_t type = type_new(T_VIEW); type_set_ident(type, id); type_set_designated(type, of); tree_set_type(view, type); consume(tIS); if (type_is_record(of)) { while (not_at_token(tEND)) p_mode_view_element_declaration(type, of); consume(tEND); } else { parse_error(CURRENT_LOC, "subtype indication of a mode view declaration " "must denote a record type"); drop_tokens_until(tEND); } consume(tVIEW); p_trailing_label(id); consume(tSEMI); tree_set_loc(view, CURRENT_LOC); insert_name(nametab, view, NULL); sem_check(view, nametab); return view; } static void p_entity_declarative_item(tree_t entity) { // subprogram_declaration | subprogram_body | type_declaration // | subtype_declaration | constant_declaration | signal_declaration // | shared_variable_declaration | file_declaration | alias_declaration // | attribute_declaration | attribute_specification // | disconnection_specification | use_clause | group_template_declaration // | group_declaration | 2008: subprogram_instantiation_declaration // | 2019: mode_view_declaration BEGIN("entity declarative item"); switch (peek()) { case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(entity); else tree_add_decl(entity, p_attribute_declaration()); break; case tTYPE: p_type_declaration(entity); break; case tSUBTYPE: tree_add_decl(entity, p_subtype_declaration()); break; case tCONSTANT: p_constant_declaration(entity); break; case tALIAS: p_alias_declaration(entity); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(entity, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); if (peek() == tSEMI) tree_add_decl(entity, p_subprogram_declaration(spec)); else tree_add_decl(entity, p_subprogram_body(spec)); } break; case tUSE: p_use_clause(entity, tree_add_decl); break; case tDISCONNECT: p_disconnection_specification(entity); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(entity, p_group_template_declaration()); else tree_add_decl(entity, p_group_declaration()); break; case tSHARED: p_variable_declaration(entity); break; case tSIGNAL: p_signal_declaration(entity); break; case tVIEW: tree_add_decl(entity, p_mode_view_declaration()); break; default: expect(tATTRIBUTE, tTYPE, tSUBTYPE, tCONSTANT, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tALIAS, tUSE, tDISCONNECT, tGROUP, tSHARED, tSIGNAL, STD(19, tVIEW)); } } static void p_entity_declarative_part(tree_t entity) { // { entity_declarative_item } BEGIN("entity declarative part"); while (not_at_token(tEND, tBEGIN)) p_entity_declarative_item(entity); } static void p_subprogram_declarative_item(tree_t sub) { // subprogram_declaration | subprogram_body | type_declaration // | subtype_declaration | constant_declaration | variable_declaration // | file_declaration | alias_declaration | attribute_declaration // | attribute_specification | use_clause | group_template_declaration // | group_declaration | 2008: subprogram_instantiation_declaration BEGIN("subprogram declarative item"); switch (peek()) { case tVARIABLE: p_variable_declaration(sub); break; case tTYPE: p_type_declaration(sub); break; case tALIAS: p_alias_declaration(sub); break; case tCONSTANT: p_constant_declaration(sub); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(sub, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); tree_set_flag(spec, tree_flags(sub) & TREE_F_PROTECTED); if (peek() == tSEMI) tree_add_decl(sub, p_subprogram_declaration(spec)); else tree_add_decl(sub, p_subprogram_body(spec)); } break; case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(sub); else tree_add_decl(sub, p_attribute_declaration()); break; case tSUBTYPE: tree_add_decl(sub, p_subtype_declaration()); break; case tUSE: p_use_clause(sub, tree_add_decl); break; case tFILE: p_file_declaration(sub); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(sub, p_group_template_declaration()); else tree_add_decl(sub, p_group_declaration()); break; default: expect(tVARIABLE, tTYPE, tALIAS, tCONSTANT, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tATTRIBUTE, tSUBTYPE, tUSE, tFILE, tGROUP); } } static void p_subprogram_declarative_part(tree_t sub) { // { subprogram_declarative_item } BEGIN("subprogram declarative part"); while (not_at_token(tBEGIN)) p_subprogram_declarative_item(sub); } static void p_sequence_of_statements(tree_t parent) { // { sequential_statement } BEGIN("sequence of statements"); while (not_at_token(tEND, tELSE, tELSIF, tWHEN)) tree_add_stmt(parent, p_sequential_statement()); } static void p_trailing_label(ident_t label) { // [ label ] if ((peek() == tID) || (peek() == tSTRING)) { ident_t trailing = p_designator(); if (label == NULL) parse_error(&last_loc, "unexpected trailing label for %s without " "label", hint_str); else if (trailing != label) parse_error(&last_loc, "expected trailing %s label to match %s", hint_str, istr(label)); } } static tree_t p_subprogram_body(tree_t spec) { // subprogram_specification is subprogram_declarative_part begin // subprogram_statement_part end [ subprogram_kind ] [ designator ] ; EXTEND("subprogram body"); consume(tIS); const tree_kind_t kind = (tree_kind(spec) == T_FUNC_DECL) ? T_FUNC_BODY : T_PROC_BODY; tree_change_kind(spec, kind); insert_name(nametab, spec, NULL); push_scope(nametab); scope_set_subprogram(nametab, spec); insert_generics(nametab, spec); insert_ports(nametab, spec); sem_check(spec, nametab); if (tree_flags(spec) & TREE_F_KNOWS_SUBTYPE) { // LRM 19 section 4.2.1: an implicit subtype declaration is // created as the first declarative item when the function // includes a return identifier type_t sub = type_result(tree_type(spec)); assert(type_kind(sub) == T_SUBTYPE); tree_t d = tree_new(T_SUBTYPE_DECL); tree_set_ident(d, type_ident(sub)); tree_set_type(d, sub); tree_set_loc(d, CURRENT_LOC); insert_name(nametab, d, NULL); tree_add_decl(spec, d); } p_subprogram_declarative_part(spec); consume(tBEGIN); p_sequence_of_statements(spec); consume(tEND); pop_scope(nametab); if (scan(tFUNCTION, tPROCEDURE)) consume(kind == T_FUNC_BODY ? tFUNCTION : tPROCEDURE); p_trailing_label(tree_ident(spec)); consume(tSEMI); tree_set_loc(spec, CURRENT_LOC); return spec; } static tree_t p_subprogram_declaration(tree_t spec) { // subprogram_specification ; EXTEND("subprogram declaration"); insert_name(nametab, spec, NULL); consume(tSEMI); tree_set_loc(spec, CURRENT_LOC); sem_check(spec, nametab); return spec; } static void p_sensitivity_list(tree_t proc) { // name { , name } BEGIN("sensitivity list"); do { tree_t name = p_name(0); tree_add_trigger(proc, name); solve_types(nametab, name, NULL); } while (optional(tCOMMA)); } static void p_process_declarative_item(tree_t proc) { // subprogram_declaration | subprogram_body | type_declaration // | subtype_declaration | constant_declaration | variable_declaration // | file_declaration | alias_declaration | attribute_declaration // | attribute_specification | use_clause | group_template_declaration // | group_declaration | 2008: subprogram_instantiation_declaration BEGIN("process declarative item"); switch (peek()) { case tVARIABLE: p_variable_declaration(proc); break; case tTYPE: p_type_declaration(proc); break; case tSUBTYPE: tree_add_decl(proc, p_subtype_declaration()); break; case tCONSTANT: p_constant_declaration(proc); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(proc, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); if (peek() == tSEMI) tree_add_decl(proc, p_subprogram_declaration(spec)); else tree_add_decl(proc, p_subprogram_body(spec)); } break; case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(proc); else tree_add_decl(proc, p_attribute_declaration()); break; case tUSE: p_use_clause(proc, tree_add_decl); break; case tALIAS: p_alias_declaration(proc); break; case tFILE: p_file_declaration(proc); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(proc, p_group_template_declaration()); else tree_add_decl(proc, p_group_declaration()); break; default: expect(tVARIABLE, tTYPE, tSUBTYPE, tCONSTANT, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tATTRIBUTE, tUSE, tALIAS, tFILE, tGROUP); } } static void p_process_declarative_part(tree_t proc) { // { process_declarative_item } BEGIN("process declarative part"); while (not_at_token(tBEGIN)) p_process_declarative_item(proc); } static void p_process_statement_part(tree_t proc) { // { sequential_statement } BEGIN("process statement part"); p_sequence_of_statements(proc); } static void p_process_sensitivity_list(tree_t proc) { // 2008: all | sensitivity_list BEGIN("process sensitivity list"); if (peek() == tALL) { consume(tALL); tree_t all = tree_new(T_ALL); tree_set_loc(all, CURRENT_LOC); tree_add_trigger(proc, all); } else p_sensitivity_list(proc); } static tree_t p_process_statement(ident_t label) { // [ process_label : ] [ postponed ] process [ ( sensitivity_list ) ] [ is ] // process_declarative_part begin process_statement_part end [ postponed ] // process [ label ] ; EXTEND("process statement"); tree_t t = tree_new(T_PROCESS); const bool postponed = optional(tPOSTPONED); consume(tPROCESS); if (optional(tLPAREN)) { if (standard() < STD_08) p_sensitivity_list(t); else p_process_sensitivity_list(t); consume(tRPAREN); } optional(tIS); if (label == NULL) { tree_set_ident(t, get_implicit_label(t, nametab)); tree_set_flag(t, TREE_F_SYNTHETIC_NAME); } else { tree_set_loc(t, CURRENT_LOC); tree_set_ident(t, label); insert_name(nametab, t, label); } push_scope(nametab); scope_set_container(nametab, t); scope_set_prefix(nametab, tree_ident(t)); p_process_declarative_part(t); consume(tBEGIN); p_process_statement_part(t); consume(tEND); if (postponed) optional(tPOSTPONED); consume(tPROCESS); p_trailing_label(label); consume(tSEMI); pop_scope(nametab); tree_set_loc(t, CURRENT_LOC); if (postponed) tree_set_flag(t, TREE_F_POSTPONED); sem_check(t, nametab); return t; } static tree_t p_entity_statement(void) { // concurrent_assertion_statement | concurrent_procedure_call_statement // | process_statement BEGIN("entity statement"); ident_t label = NULL; if ((peek() == tID) && (peek_nth(2) == tCOLON)) { label = p_identifier(); consume(tCOLON); } switch (peek()) { case tASSERT: return p_concurrent_assertion_statement(label); case tPROCESS: return p_process_statement(label); case tID: return p_concurrent_procedure_call_statement(label, NULL); case tPOSTPONED: if (peek_nth(2) == tASSERT) return p_concurrent_assertion_statement(label); else if (peek_nth(2) == tPROCESS) return p_process_statement(label); else return p_concurrent_procedure_call_statement(label, NULL); default: expect(tASSERT, tPROCESS, tPOSTPONED); return tree_new(T_NULL); } } static void p_entity_statement_part(tree_t entity) { // { entity_statement } BEGIN("entity statement part"); while (not_at_token(tEND)) tree_add_stmt(entity, p_entity_statement()); } static void p_entity_declaration(tree_t unit) { // entity identifier is entity_header entity_declarative_part // [ begin entity_statement_part ] end [ entity ] [ entity_simple_name ] ; BEGIN("entity declaration"); tree_change_kind(unit, T_ENTITY); consume(tENTITY); ident_t id = p_identifier(); tree_set_ident(unit, id); consume(tIS); push_scope(nametab); tree_set_loc(unit, CURRENT_LOC); insert_name(nametab, unit, id); push_scope(nametab); ident_t qual = ident_prefix(lib_name(lib_work()), id, '.'); scope_set_prefix(nametab, qual); p_entity_header(unit); p_entity_declarative_part(unit); if (optional(tBEGIN)) p_entity_statement_part(unit); consume(tEND); optional(tENTITY); p_trailing_label(id); consume(tSEMI); tree_set_ident(unit, qual); tree_set_loc(unit, CURRENT_LOC); sem_check(unit, nametab); pop_scope(nametab); pop_scope(nametab); } static tree_t p_component_declaration(void) { // component identifier [ is ] [ generic_clause ] [ port_clause ] // end component [ simple_name ] ; // 2019: // component identifier [ is ] [ generic_clause ] [ port_clause ] // end [ component ] [ simple_name ] ; BEGIN("component declaration"); tree_t c = tree_new(T_COMPONENT); consume(tCOMPONENT); tree_set_ident(c, p_identifier()); optional(tIS); push_scope(nametab); if (peek() == tGENERIC) { p_generic_clause(c); insert_generics(nametab, c); } if (peek() == tPORT) { p_port_clause(c); insert_ports(nametab, c); } pop_scope(nametab); consume(tEND); if (peek() != tCOMPONENT) require_std(STD_19, "optional end component"); else consume(tCOMPONENT); p_trailing_label(tree_ident(c)); consume(tSEMI); tree_set_loc(c, CURRENT_LOC); insert_name(nametab, c, NULL); sem_check(c, nametab); return c; } static void p_package_declarative_item(tree_t pack) { // subprogram_declaration | type_declaration | subtype_declaration // | constant_declaration | signal_declaration // | shared_variable_declaration | file_declaration | alias_declaration // | component_declaration | attribute_declaration // | attribute_specification | disconnection_specification | use_clause // | group_template_declaration | group_declaration // | 2008: package_instantiation_declaration // | 2008: package_declaration | 2019: mode_view_declaration // BEGIN("package declarative item"); switch (peek()) { case tTYPE: p_type_declaration(pack); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(pack, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); if (peek() == tSEMI) tree_add_decl(pack, p_subprogram_declaration(spec)); else tree_add_decl(pack, p_subprogram_body(spec)); } break; case tSUBTYPE: tree_add_decl(pack, p_subtype_declaration()); break; case tSIGNAL: p_signal_declaration(pack); break; case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(pack); else tree_add_decl(pack, p_attribute_declaration()); break; case tCONSTANT: p_constant_declaration(pack); break; case tCOMPONENT: tree_add_decl(pack, p_component_declaration()); break; case tFILE: p_file_declaration(pack); break; case tSHARED: p_variable_declaration(pack); break; case tALIAS: p_alias_declaration(pack); break; case tUSE: p_use_clause(pack, tree_add_decl); break; case tDISCONNECT: p_disconnection_specification(pack); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(pack, p_group_template_declaration()); else tree_add_decl(pack, p_group_declaration()); break; case tPACKAGE: if (peek_nth(4) == tNEW) tree_add_decl(pack, p_package_instantiation_declaration(NULL)); else { require_std(STD_08, "nested package declarations"); tree_add_decl(pack, p_package_declaration(NULL)); } break; case tVIEW: tree_add_decl(pack, p_mode_view_declaration()); break; default: expect(tTYPE, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tSUBTYPE, tSIGNAL, tATTRIBUTE, tCONSTANT, tCOMPONENT, tFILE, tSHARED, tALIAS, tUSE, tDISCONNECT, tGROUP, tPACKAGE, STD(19, tVIEW)); } } static void p_package_declarative_part(tree_t pack) { // { package_declarative_item } BEGIN("package declarative part"); while (not_at_token(tEND)) p_package_declarative_item(pack); } static void p_package_header(tree_t unit) { // 2008: [ generic_clause [ generic_map_aspect ; ] ] BEGIN("package header"); if (peek() == tGENERIC) { p_generic_clause(unit); if (peek() == tGENERIC) { p_generic_map_aspect(unit, unit); consume(tSEMI); } insert_generics(nametab, unit); } } static tree_t p_package_declaration(tree_t unit) { // package identifier is package_declarative_part end [ package ] // [ simple_name ] ; // // 2008: package identifier is package_header package_declarative_part // end [ package ] [ simple_name ] ; BEGIN("package declaration"); consume(tPACKAGE); ident_t name = p_identifier(), qual = name; tree_t pack; if (unit != NULL) { // Package declaration as primary unit assert(tree_kind(unit) == T_DESIGN_UNIT); tree_change_kind(unit, T_PACKAGE); pack = unit; qual = ident_prefix(lib_name(lib_work()), name, '.'); scope_set_prefix(nametab, qual); } else { pack = tree_new(T_PACKAGE); scope_set_prefix(nametab, name); } tree_set_ident(pack, name); tree_set_loc(pack, CURRENT_LOC); insert_name(nametab, pack, NULL); push_scope(nametab); consume(tIS); push_scope(nametab); scope_set_container(nametab, pack); if (standard() >= STD_08) p_package_header(pack); p_package_declarative_part(pack); if (bootstrapping) declare_additional_standard_operators(pack); pop_scope(nametab); consume(tEND); optional(tPACKAGE); p_trailing_label(name); consume(tSEMI); tree_set_ident(pack, qual); tree_set_loc(pack, CURRENT_LOC); sem_check(pack, nametab); pop_scope(nametab); return pack; } static ident_list_t *p_instantiation_list(void) { // label { , label } | others | all switch (peek()) { case tID: return p_identifier_list(); case tOTHERS: consume(tOTHERS); return NULL; case tALL: { consume(tALL); ident_list_t *result = NULL; ident_list_push(&result, well_known(W_ALL), last_loc); return result; } default: expect(tID, tOTHERS, tALL); return NULL; } } static ident_list_t *p_component_specification(ident_t *comp_name) { // instantiation_list : name BEGIN("component specification"); ident_list_t *ids = p_instantiation_list(); consume(tCOLON); *comp_name = p_identifier(); return ids; } static void p_port_map_aspect(tree_t inst, tree_t unit) { // port map ( association_list ) BEGIN("port map aspect"); consume(tPORT); consume(tMAP); consume(tLPAREN); p_association_list(inst, unit, F_PORT_MAP); consume(tRPAREN); } static void p_generic_map_aspect(tree_t inst, tree_t unit) { // generic map ( association_list ) BEGIN("generic map aspect"); consume(tGENERIC); consume(tMAP); consume(tLPAREN); p_association_list(inst, unit, F_GENERIC_MAP); consume(tRPAREN); } static tree_t p_entity_aspect(void) { // entity name [ ( identifier) ] | configuration name | open switch (one_of(tENTITY, tCONFIGURATION, tOPEN)) { case tENTITY: { tree_t bind = tree_new(T_BINDING); tree_set_class(bind, C_ENTITY); tree_set_ident(bind, p_selected_identifier()); if (optional(tLPAREN)) { tree_set_ident2(bind, p_identifier()); consume(tRPAREN); } tree_set_loc(bind, CURRENT_LOC); return bind; } case tCONFIGURATION: { tree_t bind = tree_new(T_BINDING); tree_set_class(bind, C_CONFIGURATION); tree_set_ident(bind, p_selected_identifier()); tree_set_loc(bind, CURRENT_LOC); return bind; } case tOPEN: default: return NULL; } } static tree_t p_binding_indication(tree_t comp) { // [ use entity_aspect ] [ generic_map_aspect ] [ port_map_aspect ] BEGIN("binding indication"); tree_t bind = NULL, unit = NULL; if (optional(tUSE)) { if ((bind = p_entity_aspect()) && (unit = find_binding(bind))) { tree_set_ref(bind, unit); unit = primary_unit_of(unit); } } if (comp) { insert_generics(nametab, comp); insert_ports(nametab, comp); } if (peek() == tGENERIC) { if (bind == NULL) { consume(tGENERIC); parse_error(CURRENT_LOC, "sorry, binding indication with generic map " "aspect and OPEN entity aspect is not yet supported"); drop_tokens_until(tRPAREN); } else p_generic_map_aspect(bind, unit); } if (peek() == tPORT) { if (bind == NULL) { consume(tPORT); parse_error(CURRENT_LOC, "sorry, binding indication with port map " "aspect and OPEN entity aspect is not yet supported"); drop_tokens_until(tRPAREN); } else p_port_map_aspect(bind, unit); } if (bind != NULL) tree_set_loc(bind, CURRENT_LOC); return bind; } static void p_configuration_specification(tree_t parent) { // for component_specification binding_indication ; BEGIN("configuration specification"); consume(tFOR); ident_t comp_name; LOCAL_IDENT_LIST ids = p_component_specification(&comp_name); tree_t comp = resolve_name(nametab, CURRENT_LOC, comp_name); if (comp != NULL && tree_kind(comp) != T_COMPONENT) { parse_error(CURRENT_LOC, "%s does not name a component", istr(comp_name)); comp = NULL; } push_scope(nametab); bool is_open = (peek() == tUSE && peek_nth(2) == tOPEN); tree_t bind = p_binding_indication(comp); if (!is_open && bind == NULL) parse_error(CURRENT_LOC, "a binding indication in an explicit " "configuration specification must contain an entity aspect"); consume(tSEMI); if (ids != NULL) { for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_SPEC); tree_set_loc(t, &(it->loc)); tree_set_ident(t, it->ident); tree_set_ident2(t, comp_name); tree_set_value(t, bind); tree_set_ref(t, comp); const spec_kind_t kind = it->ident == well_known(W_ALL) ? SPEC_ALL : SPEC_EXACT; tree_add_decl(parent, t); insert_spec(nametab, t, kind, it->ident, 1); sem_check(t, nametab); } } else { // Instantiation list was "others" tree_t t = tree_new(T_SPEC); tree_set_loc(t, CURRENT_LOC); tree_set_ident2(t, comp_name); tree_set_value(t, bind); tree_set_ref(t, comp); tree_add_decl(parent, t); insert_spec(nametab, t, SPEC_OTHERS, NULL, 1); sem_check(t, nametab); } pop_scope(nametab); } static void p_configuration_declarative_part(tree_t unit) { // use_clause | attribute_specification | group_declaration BEGIN("configuration declarative part"); switch (peek()) { case tUSE: p_use_clause(unit, tree_add_decl); break; case tATTRIBUTE: p_attribute_specification(unit); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(unit, p_group_template_declaration()); else tree_add_decl(unit, p_group_declaration()); break; default: expect(tUSE, tATTRIBUTE, tGROUP); } } static void p_component_configuration(tree_t unit) { // for component_specification [ binding_indication ; ] // [ block_configuration ] end for ; BEGIN("component configuration"); consume(tFOR); ident_t comp_name; LOCAL_IDENT_LIST ids = p_component_specification(&comp_name); tree_t comp = resolve_name(nametab, CURRENT_LOC, comp_name); if (comp != NULL && tree_kind(comp) != T_COMPONENT) { parse_error(CURRENT_LOC, "%s does not name a component", istr(comp_name)); comp = NULL; } push_scope(nametab); tree_t bind = NULL; if (peek() != tEND && peek() != tFOR) { bind = p_binding_indication(comp); consume(tSEMI); } tree_t bcfg = NULL; if (peek() == tFOR) { tree_t of = bind != NULL && tree_has_ref(bind) ? tree_ref(bind) : NULL; bcfg = p_block_configuration(of); } if (ids != NULL) { for (ident_list_t *it = ids; it != NULL; it = it->next) { tree_t t = tree_new(T_SPEC); tree_set_loc(t, &(it->loc)); tree_set_ident(t, it->ident); tree_set_ident2(t, comp_name); tree_set_value(t, bind); tree_set_ref(t, comp); if (bcfg != NULL) tree_add_decl(t, bcfg); const spec_kind_t kind = it->ident == well_known(W_ALL) ? SPEC_ALL : SPEC_EXACT; tree_add_decl(unit, t); sem_check(t, nametab); insert_spec(nametab, t, kind, it->ident, 1); } } else { // Instantiation list was "others" tree_t t = tree_new(T_SPEC); tree_set_loc(t, CURRENT_LOC); tree_set_ident2(t, comp_name); tree_set_value(t, bind); tree_set_ref(t, comp); if (bcfg != NULL) tree_add_decl(t, bcfg); tree_add_decl(unit, t); sem_check(t, nametab); insert_spec(nametab, t, SPEC_OTHERS, NULL, 1); } pop_scope(nametab); consume(tEND); consume(tFOR); consume(tSEMI); } static void p_configuration_item(tree_t unit) { // block_configuration | component_configuration BEGIN("configuration item"); const token_t third = peek_nth(3); if ((third == tCOLON) || (third == tCOMMA)) p_component_configuration(unit); else tree_add_decl(unit, p_block_configuration(NULL)); } static tree_t p_index_specification(void) { // discrete_range | expression tree_t head = p_expression(); if (scan(tTO, tDOWNTO)) return p_discrete_range(head); else return head; } static void p_block_specification(tree_t b) { // label | label [ ( index_specification ) ] BEGIN("block specification"); ident_t id = p_identifier(); tree_set_ident(b, id); if (optional(tLPAREN)) { (void)p_index_specification(); // XXX: not used consume(tRPAREN); } } static tree_t p_block_configuration(tree_t of) { // for block_specification { use_clause } { configuration_item } end for ; BEGIN("block configuration"); consume(tFOR); tree_t b = tree_new(T_BLOCK_CONFIG); p_block_specification(b); push_scope(nametab); tree_t sub = NULL; if (of != NULL) { switch (tree_kind(of)) { case T_ENTITY: { ident_t qual = ident_prefix(tree_ident(of), tree_ident(b), '-'); if ((sub = lib_get_qualified(qual)) == NULL) parse_error(CURRENT_LOC, "cannot find architecture %s of " "entity %s", istr(tree_ident(b)), istr(tree_ident(of))); } break; case T_ARCH: { ident_t expect = ident_rfrom(tree_ident(of), '-'); if (tree_ident(b) != expect) parse_error(CURRENT_LOC, "block specification label %s does not " "match architecture name %s", istr(tree_ident(b)), istr(expect)); else sub = of; } break; default: fatal_trace("unexpected unit type %s in block configuration", tree_kind_str(tree_kind(of))); break; } } else sub = resolve_name(nametab, CURRENT_LOC, tree_ident(b)); if (sub != NULL && !is_implicit_block(sub)) { parse_error(CURRENT_LOC, "%s is not a block that can be configured", istr(tree_ident(b))); sub = NULL; } if (sub != NULL) { tree_set_ref(b, sub); if (tree_kind(sub) == T_IF_GENERATE) sub = tree_cond(sub, 0); insert_names_for_config(nametab, sub); } else suppress_errors(nametab); while (not_at_token(tEND)) p_configuration_item(b); if (sub != NULL) { const int nstmts = tree_stmts(sub); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(sub, i); if (tree_kind(s) == T_INSTANCE) query_spec(nametab, s); } } pop_scope(nametab); consume(tEND); consume(tFOR); consume(tSEMI); tree_set_loc(b, CURRENT_LOC); sem_check(b, nametab); return b; } static ident_t p_entity_name(tree_t *entity) { // name BEGIN("entity name"); ident_t ename = p_selected_identifier(); ident_t qual = ename; if (ident_runtil(ename, '.') == ename) qual = ident_prefix(lib_name(lib_work()), ename, '.'); *entity = resolve_name(nametab, CURRENT_LOC, qual); if (*entity != NULL && tree_kind(*entity) != T_ENTITY) { diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC); diag_printf(d, "%s%s is not an entity", is_design_unit(*entity) ? "design unit " : "", istr(ename)); diag_hint(d, tree_loc(*entity), "%s is a %s", istr(ename), class_str(class_of(*entity))); diag_emit(d); *entity = NULL; return ename; } return ename; } static void p_configuration_declaration(tree_t unit) { // configuration identifier of name is configuration_declarative_part // block_configuration end [ configuration ] [ simple_name ] ; BEGIN("configuration declaration"); consume(tCONFIGURATION); tree_change_kind(unit, T_CONFIGURATION); ident_t id = p_identifier(); tree_set_ident(unit, id); push_scope(nametab); consume(tOF); tree_t of = NULL; ident_t ename = p_entity_name(&of); tree_set_ident2(unit, ename); if (of != NULL) { tree_set_primary(unit, of); insert_name(nametab, of, ename); insert_decls(nametab, of); } consume(tIS); while (not_at_token(tFOR)) p_configuration_declarative_part(unit); tree_add_decl(unit, p_block_configuration(of)); consume(tEND); optional(tCONFIGURATION); p_trailing_label(id); consume(tSEMI); pop_scope(nametab); tree_set_loc(unit, CURRENT_LOC); sem_check(unit, nametab); tree_set_ident(unit, ident_prefix(lib_name(lib_work()), id, '.')); } static void p_context_declaration(tree_t unit) { // 2008: context identifier is context_clause end [ context ] // [ context_simple_name ] ; BEGIN("context declaration"); consume(tCONTEXT); tree_change_kind(unit, T_CONTEXT); ident_t id = p_identifier(); tree_set_ident(unit, ident_prefix(lib_name(lib_work()), id, '.')); consume(tIS); push_scope(nametab); // LRM 08 section 13.1 forbids preceeding context clause if (tree_contexts(unit) != 3) // Implicit WORK and STD parse_error(tree_loc(tree_context(unit, 3)), "context clause preceeding " "context declaration must be empty"); p_context_clause(unit); consume(tEND); optional(tCONTEXT); p_trailing_label(id); consume(tSEMI); tree_set_loc(unit, CURRENT_LOC); sem_check(unit, nametab); pop_scope(nametab); } static void p_primary_unit(tree_t unit) { // entity_declaration | configuration_declaration | package_declaration // | 2008: package_instantiation_declaration BEGIN("primary unit"); switch (peek()) { case tENTITY: p_entity_declaration(unit); break; case tPACKAGE: if (standard() >= STD_08 && peek_nth(4) == tNEW) p_package_instantiation_declaration(unit); else p_package_declaration(unit); break; case tCONFIGURATION: p_configuration_declaration(unit); break; case tCONTEXT: p_context_declaration(unit); break; default: expect(tENTITY, tPACKAGE, tCONFIGURATION); } } static void p_block_declarative_item(tree_t parent) { // subprogram_declaration | subprogram_body // | 2008: package_instantiation_declaration | type_declaration // | subtype_declaration | constant_declaration | signal_declaration // | shared_variable_declaration | file_declaration | alias_declaration // | component_declaration | attribute_declaration // | attribute_specification | configuration_specification // | disconnection_specification | use_clause | group_template_declaration // | group_declaration | 2008: subprogram_instantiation_declaration // | 2008: psl_clock_declaration | 2008: package_declaration // | 2019: mode_view_declaration BEGIN("block declarative item"); switch (peek()) { case tSIGNAL: p_signal_declaration(parent); break; case tTYPE: p_type_declaration(parent); break; case tSUBTYPE: tree_add_decl(parent, p_subtype_declaration()); break; case tFILE: p_file_declaration(parent); break; case tCONSTANT: p_constant_declaration(parent); break; case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(parent, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); if (peek() == tSEMI) tree_add_decl(parent, p_subprogram_declaration(spec)); else tree_add_decl(parent, p_subprogram_body(spec)); } break; case tALIAS: p_alias_declaration(parent); break; case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(parent); else tree_add_decl(parent, p_attribute_declaration()); break; case tFOR: p_configuration_specification(parent); break; case tCOMPONENT: tree_add_decl(parent, p_component_declaration()); break; case tUSE: p_use_clause(parent, tree_add_decl); break; case tSHARED: p_variable_declaration(parent); break; case tDISCONNECT: p_disconnection_specification(parent); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(parent, p_group_template_declaration()); else tree_add_decl(parent, p_group_declaration()); break; case tPACKAGE: if (peek_nth(4) == tNEW) tree_add_decl(parent, p_package_instantiation_declaration(NULL)); else if (peek_nth(2) == tBODY) { require_std(STD_08, "nested package declarations"); tree_add_decl(parent, p_package_body(NULL)); } else { require_std(STD_08, "nested package declarations"); tree_add_decl(parent, p_package_declaration(NULL)); } break; case tSTARTPSL: consume(tSTARTPSL); p_psl_declaration(parent); break; case tDEFAULT: case tSEQUENCE: case tPROPERTY: case tENDPOINT: p_psl_declaration(parent); break; case tVIEW: tree_add_decl(parent, p_mode_view_declaration()); break; default: expect(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE, tPURE, tPROCEDURE, tALIAS, tATTRIBUTE, tFOR, tCOMPONENT, tUSE, tSHARED, tDISCONNECT, tGROUP, STD(08, tPACKAGE), STD(19, tVIEW)); } } static tree_t p_target(tree_t name) { // name | aggregate BEGIN("target"); if (name == NULL) { if (peek() == tLPAREN) return p_aggregate(); else return p_name(0); } else return name; } static tree_t p_simple_variable_assignment(ident_t label, tree_t name) { // [ label : ] target := expression ; // 2019: [ label : ] target := conditional_or_unaffected_expression ; EXTEND("simple variable assignment"); tree_t target = p_target(name); consume(tWALRUS); tree_t value = p_conditional_or_unaffected_expression(STD_08); solve_target(nametab, target, value); solve_known_subtype(nametab, value, target); tree_t t = tree_new(T_VAR_ASSIGN); tree_set_target(t, target); tree_set_value(t, value); consume(tSEMI); tree_set_loc(t, CURRENT_LOC); ensure_labelled(t, label); sem_check(t, nametab); return t; } static void p_selected_expressions(tree_t stmt, tree_t target) { // { expression when choices , } expression when choices BEGIN("selected waveforms"); type_t with_type = tree_type(tree_value(stmt)); do { tree_t expr = p_expression(); if (!tree_has_type(target)) solve_target(nametab, target, expr); solve_known_subtype(nametab, expr, target); tree_t a = tree_new(T_VAR_ASSIGN); tree_set_target(a, target); tree_set_value(a, expr); sem_check(a, nametab); consume(tWHEN); tree_t alt = tree_new(T_ALTERNATIVE); tree_add_stmt(alt, a); p_choices(alt, NULL, with_type); tree_set_loc(alt, CURRENT_LOC); tree_add_stmt(stmt, alt); } while (optional(tCOMMA)); } static tree_t p_selected_variable_assignment(ident_t label) { // with expression select [ ? ] target := selected_expressions ; BEGIN("selected variable assignment"); require_std(STD_08, "selected variable assignment"); consume(tWITH); tree_t value = p_expression(); solve_types(nametab, value, NULL); consume(tSELECT); tree_kind_t kind = T_SELECT; if (optional(tQUESTION)) kind = T_MATCH_SELECT; tree_t t = tree_new(kind); tree_set_value(t, value); tree_t target = p_target(NULL); // This is the easiest place to disambiguate variable and signal // assignment without a deep lookahead switch (one_of(tWALRUS, tLE)) { case tLE: p_selected_waveforms(t, target, NULL); break; case tWALRUS: default: p_selected_expressions(t, target); break; } consume(tSEMI); tree_set_loc(t, CURRENT_LOC); ensure_labelled(t, label); sem_check(t, nametab); return t; } static tree_t p_variable_assignment_statement(ident_t label, tree_t name) { // [ label : ] simple_variable_assignment // | 2008: [ label : ] conditional_variable_assignment // | 2008: [ label : ] selected_variable_assignment EXTEND("variable assignment statement"); if (name == NULL && peek() == tWITH) return p_selected_variable_assignment(label); else return p_simple_variable_assignment(label, name); } static tree_t p_waveform_element(tree_t target) { // expression [ after expression ] | null [ after expression ] BEGIN("waveform element"); tree_t w = tree_new(T_WAVEFORM); if (!optional(tNULL)) { tree_t value = p_expression(); tree_set_value(w, value); if (!tree_has_type(target)) solve_target(nametab, target, value); solve_known_subtype(nametab, value, target); } else if (!tree_has_type(target)) solve_types(nametab, target, NULL); if (optional(tAFTER)) { tree_t delay = p_expression(); tree_set_delay(w, delay); solve_types(nametab, delay, std_type(NULL, STD_TIME)); } tree_set_loc(w, CURRENT_LOC); return w; } static void p_waveform(tree_t stmt, tree_t target) { // waveform_element { , waveform_element } | unaffected BEGIN("waveform"); if (optional(tUNAFFECTED)) { solve_types(nametab, target, NULL); return; } do { tree_add_waveform(stmt, p_waveform_element(target)); } while (optional(tCOMMA)); tree_set_loc(stmt, CURRENT_LOC); } static tree_t p_delay_mechanism(void) { // transport | [ reject expression ] inertial BEGIN("delay mechanism"); switch (peek()) { case tTRANSPORT: consume(tTRANSPORT); return get_time(0, CURRENT_LOC); case tREJECT: { consume(tREJECT); tree_t t = p_expression(); consume(tINERTIAL); return t; } case tINERTIAL: consume(tINERTIAL); return NULL; default: return NULL; } } static port_mode_t p_force_mode(void) { // in | out BEGIN("force mode"); switch (peek()) { case tIN: consume(tIN); return PORT_IN; case tOUT: consume(tOUT); return PORT_OUT; default: return PORT_INVALID; } } static tree_t p_simple_force_assignment(ident_t label, tree_t target) { // target <= force [ force_mode ] conditional_or_unaffected_expression ; EXTEND("simple force assignment"); consume(tFORCE); require_std(STD_08, "simple force assignments"); type_t target_type; if (tree_kind(target) == T_AGGREGATE) { parse_error(CURRENT_LOC, "target of a simple force assignment may " "not be an aggregate"); target_type = type_new(T_NONE); } else target_type = solve_types(nametab, target, NULL); tree_set_type(target, target_type); tree_t t = tree_new(T_FORCE); tree_set_target(t, target); tree_set_subkind(t, p_force_mode()); tree_t expr = p_conditional_or_unaffected_expression(STD_08); solve_types(nametab, expr, target_type); tree_set_value(t, expr); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_simple_release_assignment(ident_t label, tree_t target) { // target <= release [ force_mode ] ; EXTEND("simple force assignment"); consume(tRELEASE); require_std(STD_08, "simple release assignments"); type_t target_type; if (tree_kind(target) == T_AGGREGATE) { parse_error(CURRENT_LOC, "target of a simple release assignment may " "not be an aggregate"); target_type = type_new(T_NONE); } else target_type = solve_types(nametab, target, NULL); tree_set_type(target, target_type); tree_t t = tree_new(T_RELEASE); tree_set_target(t, target); tree_set_subkind(t, p_force_mode()); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_signal_assignment_statement(ident_t label, tree_t name) { // [ label : ] target <= [ delay_mechanism ] waveform ; EXTEND("signal assignment statement"); tree_t target = p_target(name); consume(tLE); switch (peek()) { case tFORCE: return p_simple_force_assignment(label, target); case tRELEASE: return p_simple_release_assignment(label, target); default: break; } tree_t t = tree_new(T_SIGNAL_ASSIGN); tree_set_target(t, target); tree_t reject = p_delay_mechanism(); p_waveform(t, target); if (peek() == tWHEN) { require_std(STD_08, "conditional signal assignment statements"); tree_t stmt = tree_new(T_COND_ASSIGN); tree_set_target(stmt, target); p_conditional_waveforms(stmt, target, t); const int nconds = tree_conds(stmt); for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(stmt, i); assert(tree_stmts(c) == 1); set_delay_mechanism(tree_stmt(c, 0), reject); } t = stmt; } else set_delay_mechanism(t, reject); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static void p_sensitivity_clause(tree_t wait) { // on sensitivity_list BEGIN("sensitivity clause"); consume(tON); p_sensitivity_list(wait); } static void p_condition_clause(tree_t wait) { // until condition BEGIN("condition clause"); consume(tUNTIL); tree_set_value(wait, p_condition()); } static void p_timeout_clause(tree_t wait) { // for expression BEGIN("timeout clause"); consume(tFOR); tree_t delay = p_expression(); tree_set_delay(wait, delay); solve_types(nametab, delay, std_type(NULL, STD_TIME)); } static tree_t p_wait_statement(ident_t label) { // [ label : ] wait [ sensitivity_clause ] [ condition_clause ] // [ timeout_clause ] ; EXTEND("wait statement"); tree_t t = tree_new(T_WAIT); consume(tWAIT); if (peek() == tON) p_sensitivity_clause(t); if (peek() == tUNTIL) p_condition_clause(t); if (peek() == tFOR) p_timeout_clause(t); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_assertion_statement(ident_t label) { // [ label : ] assertion ; EXTEND("assertion statement"); tree_t t = p_assertion(); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_report_statement(ident_t label) { // [ label : ] report expression [ severity expression ] ; EXTEND("report statement"); tree_t t = tree_new(T_REPORT); consume(tREPORT); tree_t m = p_expression(); tree_set_message(t, m); solve_types(nametab, m, std_type(NULL, STD_STRING)); if (optional(tSEVERITY)) { tree_t s = p_expression(); solve_types(nametab, s, std_type(NULL, STD_SEVERITY_LEVEL)); tree_set_severity(t, s); } consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_if_statement(ident_t label) { // [ label : ] if condition then sequence_of_statements // { elsif condition then sequence_of_statements } // [ else sequence_of_statements ] end if [ label ] ; EXTEND("if statement"); tree_t t = tree_new(T_IF); consume(tIF); tree_t c0 = tree_new(T_COND_STMT); tree_set_value(c0, p_condition()); tree_add_cond(t, c0); consume(tTHEN); p_sequence_of_statements(c0); tree_set_loc(c0, CURRENT_LOC); while (optional(tELSIF)) { tree_t c = tree_new(T_COND_STMT); tree_set_value(c, p_condition()); tree_add_cond(t, c); consume(tTHEN); p_sequence_of_statements(c); tree_set_loc(c, CURRENT_LOC); } if (optional(tELSE)) { tree_t c = tree_new(T_COND_STMT); tree_add_cond(t, c); p_sequence_of_statements(c); tree_set_loc(c, CURRENT_LOC); } consume(tEND); consume(tIF); p_trailing_label(label); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_null_statement(ident_t label) { // [ label : ] null ; EXTEND("null statement"); consume(tNULL); consume(tSEMI); tree_t t = tree_new(T_NULL); set_label_and_loc(t, label, CURRENT_LOC); return t; } static void p_parameter_specification(tree_t loop, tree_kind_t pkind) { // identifier in discrete_range BEGIN("paremeter specification"); ident_t id = p_identifier(); const loc_t id_loc = last_loc; consume(tIN); tree_t r = p_discrete_range(NULL); solve_types(nametab, r, NULL); convert_universal_bounds(r); tree_add_range(loop, r); // LRM 08 section 10.10: the loop parameter is an object whose type // is the base type of the discrete range type_t base = type_base_recur(tree_type(r)); tree_t constraint = tree_new(T_CONSTRAINT); tree_set_subkind(constraint, C_RANGE); tree_add_range(constraint, r); type_t sub = type_new(T_SUBTYPE); type_set_base(sub, base); type_set_constraint(sub, constraint); tree_t param = tree_new(pkind); tree_set_ident(param, id); tree_set_type(param, sub); tree_set_loc(param, &id_loc); tree_set_class(param, C_CONSTANT); tree_set_subkind(param, PORT_IN); tree_add_decl(loop, param); insert_name(nametab, param, NULL); } static tree_t p_iteration_scheme(void) { // while condition | for parameter_specification BEGIN("iteration scheme"); if (optional(tWHILE)) { tree_t t = tree_new(T_WHILE); tree_set_value(t, p_condition()); return t; } else if (optional(tFOR)) { tree_t t = tree_new(T_FOR); scope_set_container(nametab, t); p_parameter_specification(t, T_PARAM_DECL); return t; } else return tree_new(T_LOOP); } static tree_t p_loop_statement(ident_t label) { // [ loop_label : ] [ iteration_scheme ] loop sequence_of_statements // end loop [ loop_label ] ; BEGIN("loop statement"); push_scope(nametab); tree_t t = p_iteration_scheme(); consume(tLOOP); scope_set_container(nametab, t); set_label_and_loc(t, label, CURRENT_LOC); if (label != NULL) insert_name(nametab, t, NULL); sem_check(t, nametab); p_sequence_of_statements(t); consume(tEND); consume(tLOOP); p_trailing_label(label); consume(tSEMI); pop_scope(nametab); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_return_statement(ident_t label) { // [ label : ] return [ expression ] ; // 2019: [ label : ] return [ when condition ] ; // 2019: [ label : ] return conditional_or_unaffected_expression ; EXTEND("return statement"); consume(tRETURN); tree_t stmt = NULL; if (optional(tWHEN)) { require_std(STD_19, "conditional return statement"); stmt = tree_new(T_COND_RETURN); tree_set_value(stmt, p_condition()); } else { stmt = tree_new(T_RETURN); if (peek() != tSEMI) { type_t return_type = NULL; tree_t subprog = find_enclosing(nametab, S_SUBPROGRAM); if (subprog != NULL && tree_kind(subprog) == T_FUNC_BODY) { return_type = type_result(tree_type(subprog)); tree_set_type(stmt, return_type); } tree_t value = p_conditional_or_unaffected_expression(STD_19); solve_types(nametab, value, return_type); tree_set_value(stmt, value); } } consume(tSEMI); set_label_and_loc(stmt, label, CURRENT_LOC); sem_check(stmt, nametab); return stmt; } static tree_t p_exit_statement(ident_t label) { // [ label : ] exit [ label ] [ when condition ] ; EXTEND("exit statement"); consume(tEXIT); tree_t t = tree_new(T_EXIT); if (peek() == tID) { ident_t id = p_identifier(); tree_set_ident2(t, id); tree_t loop = resolve_name(nametab, CURRENT_LOC, id); if (loop != NULL && !is_loop_stmt(loop)) parse_error(CURRENT_LOC, "%s is not a loop statement", istr(id)); } else { tree_t loop = find_enclosing(nametab, S_LOOP); if (loop == NULL) parse_error(CURRENT_LOC, "cannot use exit statement outside loop"); else tree_set_ident2(t, tree_ident(loop)); } if (optional(tWHEN)) tree_set_value(t, p_condition()); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_next_statement(ident_t label) { // [ label : ] next [ label ] [ when condition ] ; EXTEND("next statement"); consume(tNEXT); tree_t t = tree_new(T_NEXT); if (peek() == tID) { ident_t id = p_identifier(); tree_set_ident2(t, id); tree_t loop = resolve_name(nametab, CURRENT_LOC, id); if (loop != NULL && !is_loop_stmt(loop)) parse_error(CURRENT_LOC, "%s is not a loop statement", istr(id)); } else { tree_t loop = find_enclosing(nametab, S_LOOP); if (loop == NULL) parse_error(CURRENT_LOC, "cannot use next statement outside loop"); else tree_set_ident2(t, tree_ident(loop)); } if (optional(tWHEN)) tree_set_value(t, p_condition()); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static tree_t p_procedure_call_statement(ident_t label, tree_t name) { // [ label : ] procedure_call ; // // name [ ( actual_parameter_part ) ] // 2019: name [ generic_map_aspect ] [ parameter_map_aspect ] EXTEND("procedure call statement"); tree_t call = NULL; switch (tree_kind(name)) { case T_REF: call = tree_new(T_PCALL); tree_set_ident2(call, tree_ident(name)); break; case T_PROT_REF: call = tree_new(T_PROT_PCALL); tree_set_ident2(call, tree_ident(name)); tree_set_name(call, tree_value(name)); break; default: // Only print an error if name is a valid expression if (!type_is_none(solve_types(nametab, name, NULL))) parse_error(CURRENT_LOC, "expected procedure name"); call = tree_new(T_PCALL); tree_set_ident2(call, error_marker()); set_label_and_loc(call, label, CURRENT_LOC); drop_tokens_until(tSEMI); return call; } if (peek() == tGENERIC) { ident_t id = tree_ident(name); tree_t inst = tree_new(T_PROC_INST); tree_set_ident(inst, ident_prefix(id, ident_uniq("inst"), '$')); tree_t decl = resolve_uninstantiated_subprogram(nametab, CURRENT_LOC, id, NULL); if (decl != NULL) { tree_t body = find_generic_subprogram_body(inst, decl); instantiate_subprogram(inst, decl, body); } else { // Create a dummy subprogram type to avoid later errors type_t type = type_new(T_SIGNATURE); type_set_ident(type, id); tree_set_type(inst, type); } p_generic_map_aspect(inst, inst); require_std(STD_19, "generic map on procedure call"); tree_set_loc(inst, CURRENT_LOC); sem_check(inst, nametab); hash_t *map = get_generic_map(nametab); if (map != NULL) instance_fixup(inst, map); tree_set_ref(call, inst); mangle_func(nametab, inst); tree_t container = find_enclosing(nametab, S_DECLARATIVE_REGION); tree_add_decl(container, inst); } if (peek() == tPARAMETER) p_parameter_map_aspect(call); else if (optional(tLPAREN)) { p_actual_parameter_part(call); consume(tRPAREN); } consume(tSEMI); set_label_and_loc(call, label, CURRENT_LOC); solve_types(nametab, call, NULL); sem_check(call, nametab); return call; } static tree_t p_case_statement_alternative(type_t type) { // when choices => sequence_of_statements BEGIN("case statement alternative"); consume(tWHEN); tree_t alt = tree_new(T_ALTERNATIVE); p_choices(alt, NULL, type); consume(tASSOC); p_sequence_of_statements(alt); tree_set_loc(alt, CURRENT_LOC); return alt; } static tree_t p_case_statement(ident_t label) { // [ label : ] case [?] expression is case_statement_alternative // { case_statement_alternative } end case [?] [ label ] ; EXTEND("case statement"); consume(tCASE); tree_kind_t kind = T_CASE; if (optional(tQUESTION)) { require_std(STD_08, "matching case statements"); kind = T_MATCH_CASE; } tree_t t = tree_new(kind); tree_t value = p_expression(); tree_set_value(t, value); type_t type = solve_types(nametab, value, NULL); consume(tIS); do { tree_add_stmt(t, p_case_statement_alternative(type)); } while (peek() == tWHEN); consume(tEND); consume(tCASE); if (kind == T_MATCH_CASE) consume(tQUESTION); p_trailing_label(label); consume(tSEMI); set_label_and_loc(t, label, CURRENT_LOC); sem_check(t, nametab); return t; } static void p_sequential_block_declarative_part(tree_t block) { // { process_declarative_item } BEGIN("sequential block declarative part"); while (not_at_token(tBEGIN)) p_process_declarative_item(block); } static void p_sequential_block_statement_part(tree_t block) { // { sequential_statement } BEGIN("sequential block statement part"); p_sequence_of_statements(block); } static tree_t p_sequential_block_statement(ident_t label) { // [ label : ] block [ is ] sequential_block_declarative_part // begin sequential_block_statement_part end [ block ] [ label ] ; BEGIN("sequential block statement"); consume(tBLOCK); optional(tIS); require_std(STD_19, "sequential block statements"); push_scope(nametab); tree_t t = tree_new(T_SEQUENCE); scope_set_container(nametab, t); set_label_and_loc(t, label, CURRENT_LOC); p_sequential_block_declarative_part(t); consume(tBEGIN); p_sequential_block_statement_part(t); consume(tEND); optional(tBLOCK); p_trailing_label(label); consume(tSEMI); tree_set_loc(t, CURRENT_LOC); sem_check(t, nametab); pop_scope(nametab); return t; } static tree_t p_sequential_statement(void) { // wait_statement | assertion_statement | report_statement // | signal_assignment_statement | variable_assignment_statement // | procedure_call_statement | if_statement | case_statement // | loop_statement | next_statement | exit_statement | return_statement // | null_statement | 2019: sequential_block_statement BEGIN("sequential statement"); ident_t label = NULL; if ((peek() == tID) && (peek_nth(2) == tCOLON)) { label = p_identifier(); consume(tCOLON); } switch (peek()) { case tWAIT: return p_wait_statement(label); case tASSERT: return p_assertion_statement(label); case tREPORT: return p_report_statement(label); case tIF: return p_if_statement(label); case tNULL: return p_null_statement(label); case tRETURN: return p_return_statement(label); case tCASE: return p_case_statement(label); case tWHILE: case tLOOP: case tFOR: return p_loop_statement(label); case tEXIT: return p_exit_statement(label); case tNEXT: return p_next_statement(label); case tWITH: return p_variable_assignment_statement(label, NULL); case tID: case tLTLT: break; case tLPAREN: { tree_t agg = p_aggregate(); switch (peek()) { case tWALRUS: return p_variable_assignment_statement(label, agg); case tLE: return p_signal_assignment_statement(label, agg); default: expect(tWALRUS, tLE); return tree_new(T_NULL); } } case tBLOCK: return p_sequential_block_statement(label); default: expect(tWAIT, tID, tASSERT, tREPORT, tIF, tNULL, tRETURN, tCASE, tWHILE, tFOR, tLOOP, tEXIT, tNEXT, tWITH, tLTLT, tLPAREN, tBLOCK); drop_tokens_until(tSEMI); return tree_new(T_NULL); } tree_t name = p_name(N_SUBPROGRAM); switch (peek()) { case tWALRUS: return p_variable_assignment_statement(label, name); case tLE: return p_signal_assignment_statement(label, name); case tSEMI: case tLPAREN: case tGENERIC: case tPARAMETER: return p_procedure_call_statement(label, name); default: expect(tWALRUS, tLE, tSEMI); drop_tokens_until(tSEMI); return tree_new(T_NULL); } } static tree_t p_instantiated_unit(tree_t name) { // [ component ] name // | entity name [ ( identifier ) ] // | configuration name BEGIN("instantiated unit"); tree_t t = tree_new(T_INSTANCE); switch (peek()) { case tENTITY: consume(tENTITY); tree_set_class(t, C_ENTITY); break; case tCONFIGURATION: consume(tCONFIGURATION); tree_set_class(t, C_CONFIGURATION); break; case tCOMPONENT: consume(tCOMPONENT); // Fall-through default: tree_set_class(t, C_COMPONENT); } if (name != NULL) { if (tree_kind(name) == T_REF) { tree_set_ident2(t, tree_ident(name)); if (tree_has_ref(name)) tree_set_ref(t, tree_ref(name)); } else { parse_error(tree_loc(name), "invalid instantiated unit name"); tree_set_ident2(t, error_marker()); } } else tree_set_ident2(t, p_selected_identifier()); if ((tree_class(t) == C_ENTITY) && optional(tLPAREN)) { tree_set_ident2(t, ident_prefix(tree_ident2(t), p_identifier(), '-')); consume(tRPAREN); } tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_component_instantiation_statement(ident_t label, tree_t name) { // label : instantiated_unit [ generic_map_aspect ] [ port_map_aspect ] ; EXTEND("component instantiation statement"); tree_t t = p_instantiated_unit(name); tree_set_ident(t, label); tree_set_loc(t, CURRENT_LOC); tree_t ref = find_binding(t); tree_set_ref(t, ref); tree_t entity = ref ? primary_unit_of(ref) : NULL; tree_t spec = query_spec(nametab, t); if (spec != NULL) tree_set_spec(t, spec); if (label != NULL) insert_name(nametab, t, NULL); push_scope(nametab); if (ref == NULL) suppress_errors(nametab); if (peek() == tGENERIC) p_generic_map_aspect(t, entity); if (peek() == tPORT) p_port_map_aspect(t, entity); consume(tSEMI); tree_set_loc(t, CURRENT_LOC); if (label == NULL){ parse_error(CURRENT_LOC, "component instantiation statement must " "have a label"); tree_set_ident(t, error_marker()); } sem_check(t, nametab); pop_scope(nametab); return t; } static void p_options(tree_t *reject, tree_t *guard) { // [ guarded ] [ delay_mechanism ] BEGIN("options"); if (optional(tGUARDED)) { tree_t decl = NULL; name_mask_t mask = query_name(nametab, ident_new("GUARD"), &decl); if ((mask & N_OBJECT) && decl != NULL) { tree_t g = tree_new(T_GUARD); tree_set_loc(g, CURRENT_LOC); tree_set_ref(g, decl); tree_set_type(g, tree_type(decl)); *guard = g; } else parse_error(CURRENT_LOC, "guarded assignment has no visible " "guard signal"); } *reject = p_delay_mechanism(); } static void p_conditional_waveforms(tree_t stmt, tree_t target, tree_t s0) { // { waveform when condition else } waveform [ when condition ] BEGIN("conditional waveforms"); for (;;) { tree_t c = tree_new(T_COND_STMT); tree_t a = s0; if (a == NULL) { a = tree_new(T_SIGNAL_ASSIGN); tree_set_target(a, target); p_waveform(a, target); } else { s0 = NULL; tree_set_loc(a, CURRENT_LOC); } tree_add_stmt(c, a); tree_add_cond(stmt, c); if (optional(tWHEN)) { tree_t when = p_condition(); tree_set_value(c, when); tree_set_loc(c, tree_loc(when)); solve_types(nametab, when, std_type(NULL, STD_BOOLEAN)); if (!optional(tELSE)) break; } else break; } } static tree_t p_conditional_signal_assignment(tree_t name) { // target <= options conditional_waveforms ; BEGIN("conditional signal assignment"); tree_t conc = tree_new(T_CONCURRENT); tree_t stmt = tree_new(T_COND_ASSIGN); tree_add_stmt(conc, stmt); tree_t target = p_target(name); tree_set_target(stmt, target); consume(tLE); tree_t reject = NULL, guard = NULL; p_options(&reject, &guard); if (guard != NULL) { tree_set_guard(stmt, guard); find_disconnect_specification(guard, target); } p_conditional_waveforms(stmt, target, NULL); const int nconds = tree_conds(stmt); for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(stmt, i); assert(tree_stmts(c) == 1); set_delay_mechanism(tree_stmt(c, 0), reject); } consume(tSEMI); tree_set_loc(stmt, CURRENT_LOC); tree_set_loc(conc, CURRENT_LOC); return conc; } static void p_selected_waveforms(tree_t stmt, tree_t target, tree_t reject) { // { waveform when choices , } waveform when choices BEGIN("selected waveforms"); type_t with_type = tree_type(tree_value(stmt)); do { tree_t a = tree_new(T_SIGNAL_ASSIGN); tree_set_target(a, target); if (reject != NULL) tree_set_reject(a, reject); p_waveform(a, target); sem_check(a, nametab); consume(tWHEN); tree_t alt = tree_new(T_ALTERNATIVE); tree_add_stmt(alt, a); p_choices(alt, NULL, with_type); tree_set_loc(alt, CURRENT_LOC); tree_add_stmt(stmt, alt); } while (optional(tCOMMA)); } static tree_t p_selected_signal_assignment(void) { // with expression select target <= options selected_waveforms ; BEGIN("selected signal assignment"); consume(tWITH); tree_t value = p_expression(); solve_types(nametab, value, NULL); consume(tSELECT); tree_t stmt; if (optional(tQUESTION)) { require_std(STD_08, "matching select statements"); stmt = tree_new(T_MATCH_SELECT); } else stmt = tree_new(T_SELECT); tree_set_value(stmt, value); tree_t conc = tree_new(T_CONCURRENT); tree_add_stmt(conc, stmt); tree_t target = p_target(NULL); consume(tLE); tree_t reject = NULL, guard = NULL; p_options(&reject, &guard); if (guard != NULL) { tree_set_guard(stmt, guard); find_disconnect_specification(guard, target); } p_selected_waveforms(stmt, target, reject); consume(tSEMI); tree_set_loc(stmt, CURRENT_LOC); tree_set_loc(conc, CURRENT_LOC); return conc; } static tree_t p_concurrent_signal_assignment_statement(ident_t label, tree_t name) { // [ label : ] [ postponed ] conditional_signal_assignment // | [ label : ] [ postponed ] selected_signal_assignment EXTEND("concurrent signal assignment statement"); const bool postponed = name == NULL && optional(tPOSTPONED); tree_t t; if (peek() == tWITH) { assert(name == NULL); t = p_selected_signal_assignment(); } else t = p_conditional_signal_assignment(name); tree_set_loc(t, CURRENT_LOC); ensure_labelled(t, label); if (postponed) tree_set_flag(t, TREE_F_POSTPONED); if (label) insert_name(nametab, t, NULL); sem_check(t, nametab); return t; } static tree_t p_concurrent_procedure_call_statement(ident_t label, tree_t name) { // [ label : ] [ postponed ] procedure_call ; EXTEND("concurrent procedure call statement"); const bool postponed = name == NULL && optional(tPOSTPONED); tree_t call = NULL; if (name == NULL) { call = tree_new(T_PCALL); tree_set_ident2(call, p_identifier()); } else if (tree_kind(name) == T_PROT_REF) { call = tree_new(T_PROT_PCALL); tree_set_ident2(call, tree_ident(name)); tree_set_name(call, tree_value(name)); } else { call = tree_new(T_PCALL); tree_set_ident2(call, tree_ident(name)); } if (optional(tLPAREN)) { p_actual_parameter_part(call); consume(tRPAREN); } consume(tSEMI); tree_set_loc(call, CURRENT_LOC); solve_types(nametab, call, NULL); tree_t conc = tree_new(T_CONCURRENT); tree_add_stmt(conc, call); if (postponed) tree_set_flag(conc, TREE_F_POSTPONED); tree_set_loc(conc, CURRENT_LOC); ensure_labelled(conc, label); tree_set_ident(call, tree_ident(conc)); if (label) insert_name(nametab, conc, NULL); sem_check(conc, nametab); return conc; } static void p_concurrent_statement_or_psl(tree_t parent) { // Allow PSL declarations in concurrent statement part when using // "--psl" comments if (peek() == tSTARTPSL) { consume(tSTARTPSL); if (peek() == tID) { ident_t label = p_identifier(); consume(tCOLON); tree_add_stmt(parent, p_psl_directive(label)); } else if (scan(tDEFAULT, tSEQUENCE, tPROPERTY, tENDPOINT)) p_psl_declaration(parent); else tree_add_stmt(parent, p_psl_directive(NULL)); } else tree_add_stmt(parent, p_concurrent_statement()); } static void p_block_statement_part(tree_t arch) { // { concurrent_statement } BEGIN("block statement part"); while (not_at_token(tEND)) p_concurrent_statement_or_psl(arch); } static void p_block_declarative_part(tree_t arch) { // { block_declarative_item } BEGIN("block declarative part"); while (not_at_token(tBEGIN)) p_block_declarative_item(arch); } static void p_block_header(tree_t block) { // [ generic_clause [ generic_map_aspect ; ] ] // [ port_clause [ port_map_aspect ; ] ] if (peek() == tGENERIC) { p_generic_clause(block); if (peek() == tGENERIC) { p_generic_map_aspect(block, block); consume(tSEMI); } insert_generics(nametab, block); } if (peek() == tPORT) { p_port_clause(block); if (peek() == tPORT) { p_port_map_aspect(block, block); consume(tSEMI); } insert_ports(nametab, block); } } static tree_t p_block_statement(ident_t label) { // label : block [ ( expression ) ] [ is ] block_header // block_declarative_part begin block_statement_part end block [ label ] ; EXTEND("block statement"); tree_t b = tree_new(T_BLOCK); tree_set_ident(b, label); consume(tBLOCK); if (label == NULL) parse_error(CURRENT_LOC, "block statement must have a label"); else { tree_set_loc(b, CURRENT_LOC); insert_name(nametab, b, NULL); } push_scope(nametab); scope_set_prefix(nametab, label ?: error_marker()); scope_set_container(nametab, b); if (peek() == tLPAREN) { consume(tLPAREN); tree_t expr = p_expression(); solve_condition(nametab, &expr); make_implicit_guard_signal(b, expr); consume(tRPAREN); } optional(tIS); p_block_header(b); p_block_declarative_part(b); consume(tBEGIN); p_block_statement_part(b); consume(tEND); consume(tBLOCK); p_trailing_label(label); consume(tSEMI); tree_set_loc(b, CURRENT_LOC); sem_check(b, nametab); hash_t *map = get_generic_map(nametab); if (map != NULL) instance_fixup(b, map); pop_scope(nametab); return b; } static void p_generate_statement_body(tree_t container, ident_t alt_label) { // [ block_declarative_part begin ] { concurrent_statement } // [ end [ alternative_label ] ; ] BEGIN("generate statement body"); if (scan(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE, tPURE, tALIAS, tATTRIBUTE, tBEGIN, tPROCEDURE, tFOR, tCOMPONENT, tUSE, tSHARED)) { while (not_at_token(tBEGIN)) p_block_declarative_item(container); consume(tBEGIN); } while (not_at_token(tEND, tELSIF, tELSE, tWHEN)) p_concurrent_statement_or_psl(container); if (peek() == tEND && (peek_nth(2) == tID || peek_nth(2) == tSEMI)) { consume(tEND); p_trailing_label(alt_label); consume(tSEMI); } } static tree_t p_for_generate_statement(ident_t label) { // for generate_parameter_specification generate generate_statement_body // end generate [ generate_label ] ; EXTEND("for generate statement"); consume(tFOR); tree_t g = tree_new(T_FOR_GENERATE); tree_set_ident(g, label); if (label != NULL) insert_name(nametab, g, NULL); push_scope(nametab); scope_set_prefix(nametab, label); scope_set_container(nametab, g); p_parameter_specification(g, T_GENERIC_DECL); consume(tGENERATE); p_generate_statement_body(g, NULL); consume(tEND); consume(tGENERATE); p_trailing_label(label); consume(tSEMI); pop_scope(nametab); if (label == NULL) parse_error(CURRENT_LOC, "generate statement must have a label"); tree_set_loc(g, CURRENT_LOC); sem_check(g, nametab); return g; } static tree_t p_if_generate_statement(ident_t label) { // if [ alternative_label : ] condition generate generate_statement_body // { elsif [ alternative_label : ] condition generate // generate_statement_body } // [ else [ alternative_label : ] generate generate_statement_body ] // end generate [ generate_label ] ; EXTEND("if generate statement"); consume(tIF); tree_t g = tree_new(T_IF_GENERATE); tree_set_ident(g, label); if (label != NULL) insert_name(nametab, g, NULL); ident_t alt_label = NULL; if (peek() == tID && peek_nth(2) == tCOLON) { require_std(STD_08, "alternative labels"); alt_label = p_identifier(); consume(tCOLON); } push_scope(nametab); scope_set_container(nametab, g); scope_set_prefix(nametab, alt_label ?: label); tree_t c0 = tree_new(T_COND_STMT); tree_set_ident(c0, alt_label ?: label); tree_set_value(c0, p_condition()); tree_add_cond(g, c0); consume(tGENERATE); p_generate_statement_body(c0, alt_label); pop_scope(nametab); tree_set_loc(c0, CURRENT_LOC); while (optional(tELSIF)) { require_std(STD_08, "elsif in generate statements"); ident_t alt_label = NULL; if (peek() == tID && peek_nth(2) == tCOLON) { alt_label = p_identifier(); consume(tCOLON); } push_scope(nametab); scope_set_prefix(nametab, alt_label ?: label); tree_t c = tree_new(T_COND_STMT); tree_set_ident(c, alt_label ?: label); tree_set_value(c, p_condition()); consume(tGENERATE); p_generate_statement_body(c, alt_label); pop_scope(nametab); tree_set_loc(c, CURRENT_LOC); tree_add_cond(g, c); } if (optional(tELSE)) { require_std(STD_08, "else in generate statements"); ident_t alt_label = label; if (peek() == tID && peek_nth(2) == tCOLON) { alt_label = p_identifier(); consume(tCOLON); } push_scope(nametab); scope_set_prefix(nametab, alt_label ?: label); tree_t c = tree_new(T_COND_STMT); tree_set_ident(c, alt_label ?: label); consume(tGENERATE); p_generate_statement_body(c, alt_label); pop_scope(nametab); tree_set_loc(c, CURRENT_LOC); tree_add_cond(g, c); } consume(tEND); consume(tGENERATE); p_trailing_label(label); consume(tSEMI); if (label == NULL) parse_error(CURRENT_LOC, "generate statement must have a label"); tree_set_loc(g, CURRENT_LOC); sem_check(g, nametab); return g; } static tree_t p_case_generate_alternative(type_t type) { // when [ alternative_label : ] choices => generate_statement_body BEGIN("case generate alternative"); consume(tWHEN); ident_t alt_label = NULL; if (peek() == tID && peek_nth(2) == tCOLON) { alt_label = p_identifier(); consume(tCOLON); } tree_t alt = tree_new(T_ALTERNATIVE); tree_set_ident(alt, alt_label); p_choices(alt, NULL, type); consume(tASSOC); push_scope(nametab); scope_set_prefix(nametab, alt_label); p_generate_statement_body(alt, alt_label); tree_set_loc(alt, CURRENT_LOC); pop_scope(nametab); return alt; } static tree_t p_case_generate_statement(ident_t label) { // case expression generate case_generate_alternative // { case_generate_alternative } end generate [ generate_label ] ; EXTEND("case generate statement"); consume(tCASE); require_std(STD_08, "case generate statements"); tree_t g = tree_new(T_CASE_GENERATE); tree_set_ident(g, label); if (label != NULL) insert_name(nametab, g, NULL); tree_t value = p_expression(); tree_set_value(g, value); type_t type = solve_types(nametab, value, NULL); consume(tGENERATE); do { tree_add_stmt(g, p_case_generate_alternative(type)); } while (peek() == tWHEN); consume(tEND); consume(tGENERATE); p_trailing_label(label); consume(tSEMI); if (label == NULL) parse_error(CURRENT_LOC, "generate statement must have a label"); tree_set_loc(g, CURRENT_LOC); sem_check(g, nametab); return g; } static tree_t p_generate_statement(ident_t label) { // for_generate_statement | if_generate_statement | case_generate_statement EXTEND("generate statement"); switch (peek()) { case tFOR: return p_for_generate_statement(label); case tIF: return p_if_generate_statement(label); case tCASE: return p_case_generate_statement(label); default: expect(tFOR, tIF, tCASE); drop_tokens_until(tSEMI); return ensure_labelled(tree_new(T_BLOCK), label); } } static psl_node_t p_psl_low_bound(tree_t head) { // Number | MIN_VAL BEGIN_WITH_HEAD("PSL Low Bound", head); return p_hdl_expression(head, PSL_TYPE_NUMERIC); } static psl_node_t p_psl_high_bound(void) { // Number | MAX_VAL BEGIN("PSL Low Bound"); if (optional(tINF)) { tree_t inf = tree_new(T_LITERAL); tree_set_loc(inf, CURRENT_LOC); tree_set_subkind(inf, L_INT); tree_set_ival(inf, INT32_MAX); psl_node_t p = psl_new(P_HDL_EXPR); psl_set_type(p, PSL_TYPE_NUMERIC); psl_set_tree(p, inf); psl_set_loc(p, CURRENT_LOC); return p; } else return p_hdl_expression(NULL, PSL_TYPE_NUMERIC); } static psl_node_t p_psl_range(tree_t head) { // Low_Bound RANGE_SYM High_Bound BEGIN_WITH_HEAD("PSL Range", head); psl_node_t low = p_psl_low_bound(head); consume(tTO); psl_node_t high = p_psl_high_bound(); psl_node_t p = psl_new(P_RANGE); psl_set_left(p, low); psl_set_right(p, high); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_value_range(void) { // Value | Range BEGIN("PSL Value Range"); tree_t tree = p_expression(); if (peek() == tTO) return p_psl_range(tree); psl_node_t p = psl_new(P_HDL_EXPR); psl_set_tree(p, tree); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_value_set(void) { // { Value_Range { , Value_Range } } | boolean BEGIN("PSL Value Set"); psl_node_t p = psl_new(P_VALUE_SET); switch (one_of(tBOOLEAN, tLBRACE)) { case tBOOLEAN: psl_set_subkind(p, PSL_VALUE_SET_BOOLEAN); break; case tLBRACE: { psl_set_subkind(p, PSL_VALUE_SET_EXPLICIT); do { psl_add_operand(p, p_psl_value_range()); } while (optional(tCOMMA)); consume(tRBRACE); } break; } psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_union(tree_t head) { consume(tUNION); psl_node_t lhs = psl_new(P_HDL_EXPR); psl_set_tree(lhs, head); psl_set_loc(lhs, tree_loc(head)); psl_set_type(lhs, PSL_TYPE_ANY); psl_set_loc(lhs, CURRENT_LOC); psl_node_t un = psl_new(P_UNION); psl_add_operand(un, lhs); psl_add_operand(un, p_hdl_expression(NULL, PSL_TYPE_ANY)); psl_set_loc(un, CURRENT_LOC); return un; } static psl_node_t p_hdl_expression(tree_t head, psl_type_t type) { BEGIN("PSL HDL expression"); tree_t expr = p_relation(head); // AND and OR must be parsed as PSL operators for (;;) { const token_t tok = peek(); if (tok == tUNION) { psl_node_t un = p_psl_union(expr); tree_t new = tree_new(T_PSL_UNION); tree_set_psl(new, un); tree_set_loc(new, CURRENT_LOC); expr = new; } else if (tok == tNOR || tok == tNAND) { tree_t new = tree_new(T_FCALL); tree_set_ident(new, p_logical_operator()); binary_op(new, expr, p_relation); expr = new; break; } else if (tok == tXOR || tok == tXNOR) { tree_t new = tree_new(T_FCALL); tree_set_ident(new, p_logical_operator()); binary_op(new, expr, p_relation); expr = new; } else break; } psl_node_t p = psl_new(P_HDL_EXPR); psl_set_tree(p, expr); psl_set_loc(p, tree_loc(expr)); psl_set_type(p, type); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_boolean(tree_t head) { // HDL_Expression | PSL_Expression | Built_In_Function_Call // | Union_Expression BEGIN_WITH_HEAD("PSL Boolean", head); psl_node_t p = p_hdl_expression(head, PSL_TYPE_BOOLEAN); const token_t infix = peek(); switch (infix) { case tAND: case tOR: { consume(infix); psl_node_t right = p_psl_boolean(NULL); tree_t fcall = tree_new(T_FCALL); tree_set_ident(fcall, well_known(infix == tOR ? W_OP_OR : W_OP_AND)); tree_set_loc(fcall, CURRENT_LOC); add_param(fcall, psl_tree(p), P_POS, NULL); add_param(fcall, psl_tree(right), P_POS, NULL); psl_set_tree(p, fcall); psl_set_loc(p, CURRENT_LOC); return p; } default: return p; } } static psl_node_t p_psl_clock_expression(void) { tree_t expr = p_expression(); solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN)); psl_node_t p = psl_new(P_CLOCK_DECL); psl_set_tree(p, expr); return p; } static tree_t p_psl_clock_declaration(void) { // default clock is Clock_Expression ; BEGIN("PSL clock declaration"); scan_as_psl(); consume(tDEFAULT); consume(tCLOCK); consume(tIS); scan_as_vhdl(); psl_node_t p = p_psl_clock_expression(); tree_t t = tree_new(T_PSL_DECL); tree_set_psl(t, p); tree_set_ident(t, well_known(W_DEFAULT_CLOCK)); consume(tSEMI); psl_set_loc(p, CURRENT_LOC); psl_check(p, nametab); insert_name(nametab, t, NULL); tree_set_loc(t, CURRENT_LOC); return t; } static psl_node_t p_psl_builtin_function_call(void) { // prev (Any_Type [ , Number [ , Clock_Expression ]] ) // | next ( Any_Type ) // | stable ( Any_Type [ , Clock_Expression ] ) // | rose ( Bit [ , Clock_Expression ] ) // | fell ( Bit [ , Clock_Expression ] ) // | ended ( Sequence [ , Clock_Expression ]) // | nondet ( Value_Set ) // | nondet_vector ( Number, Value_Set) BEGIN("PSL Built-in Function call"); psl_builtin_kind_t kind; switch (one_of(tPSLNEXT, tPREV, tSTABLE, tROSE, tFELL, tENDED, tNONDET, tNONDETV)) { case tPSLNEXT: kind = PSL_BUILTIN_NEXT; break; case tPREV: kind = PSL_BUILTIN_PREV; break; case tSTABLE: kind = PSL_BUILTIN_STABLE; break; case tROSE: kind = PSL_BUILTIN_ROSE; break; case tFELL: kind = PSL_BUILTIN_FELL; break; case tENDED: kind = PSL_BUILTIN_ENDED; break; case tNONDET: kind = PSL_BUILTIN_NONDET; break; case tNONDETV: kind = PSL_BUILTIN_NONDET_VECTOR; break; default: should_not_reach_here(); } psl_node_t p = psl_new(P_BUILTIN_FCALL); psl_set_subkind(p, kind); consume(tLPAREN); switch (kind) { case PSL_BUILTIN_PREV: { psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_ANY); psl_add_operand(p, p1); if (optional(tCOMMA)) { psl_node_t p2 = p_hdl_expression(NULL, PSL_TYPE_NUMERIC); psl_add_operand(p, p2); if (optional(tCOMMA)) (void)p_psl_clock_expression(); } } break; case PSL_BUILTIN_NEXT: { psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_ANY); psl_add_operand(p, p1); } break; case PSL_BUILTIN_FELL: case PSL_BUILTIN_ROSE: case PSL_BUILTIN_STABLE: { psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_BIT); psl_add_operand(p, p1); if (optional(tCOMMA)) (void)p_psl_clock_expression(); } break; case PSL_BUILTIN_ENDED: { psl_node_t p1 = p_psl_sequence(); psl_add_operand(p, p1); if (optional(tCOMMA)) (void)p_psl_clock_expression(); } break; case PSL_BUILTIN_NONDET: { psl_node_t p1 = p_psl_value_set(); psl_add_operand(p, p1); } break; case PSL_BUILTIN_NONDET_VECTOR: { psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_NUMERIC); psl_add_operand(p, p1); consume(tCOMMA); psl_node_t p2 = p_psl_value_set(); psl_add_operand(p, p2); } break; } consume(tRPAREN); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_index_range(void) { // ( Range ) BEGIN("PSL Index Range"); consume(tLPAREN); psl_node_t p = p_psl_range(NULL); consume(tRPAREN); return p; } static psl_node_t p_psl_parameter_definition(void) { // Identifier [ Index_Range ] in Value_Set BEGIN("PSL Parameter Definition"); tree_t decl = tree_new(T_PARAM_DECL); tree_set_ident(decl, p_identifier()); insert_name(nametab, decl, NULL); psl_node_t p = psl_new(P_PARAM_DECL); psl_set_tree(p, decl); if (peek() == tLPAREN) (void)p_psl_index_range(); consume(tIN); psl_set_value(p, p_psl_value_set()); psl_set_loc(p, CURRENT_LOC); return p; } static void p_psl_parameters_definition(psl_node_t p) { // Parameter_Definition {, Parameter_Definition } BEGIN("PSL Parameters Definition"); do { psl_add_operand(p, p_psl_parameter_definition()); } while (optional(tCOMMA)); } static psl_node_t p_psl_parametrized_sere(void) { // for Parameters_Definition : And_Or_SERE_OP { SERE } BEGIN("PSL Parametrized SERE"); consume(tFOR); psl_node_t p = psl_new(P_PARAM_SERE); p_psl_parameters_definition(p); consume(tCOLON); switch (one_of(tAMP, tDBLAMP, tBAR)) { case tAMP: psl_set_subkind(p, PSL_SERE_NEQ_AND); break; case tDBLAMP: psl_set_subkind(p, PSL_SERE_EQU_AND); break; case tBAR: psl_set_subkind(p, PSL_SERE_OR); break; } consume(tLBRACE); psl_set_value(p, p_psl_sere()); consume(tRBRACE); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_count(void) { // Number | Range BEGIN("PSL Count"); tree_t count = p_expression(); if (peek() == tTO) return p_psl_range(count); else return p_hdl_expression(count, PSL_TYPE_NUMERIC); } static psl_node_t p_psl_proc_block(psl_node_t value) { // [[ Proc_Block_Item { Proc_Block_Item }]] BEGIN("PSL Procedural Block"); consume(t2LSQUARE); tree_t b = tree_new(T_SEQUENCE); psl_node_t p = psl_new(P_PROC_BLOCK); psl_set_value(p, value); psl_set_tree(p, b); scan_as_vhdl(); while (not_at_token(t2RSQUARE)) { if (scan(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE, tPURE, tPROCEDURE, tALIAS, tATTRIBUTE, tFOR, tCOMPONENT, tUSE, tSHARED, tDISCONNECT, tGROUP, tPACKAGE)) p_block_declarative_item(b); else tree_add_stmt(b, p_sequential_statement()); } scan_as_psl(); consume(t2RSQUARE); tree_set_loc(b, CURRENT_LOC); psl_set_loc(p, CURRENT_LOC); return p; } static type_t p_psl_subtype_indication(void) { BEGIN("PSL subtype indication"); // Handle ambiguity in "p_subtype_indication". Two consecutive IDs // may indicate resolution function, or only "type_mark" followed by // actual parameter name. token_t third = peek_nth(3); if (peek() == tID && peek_nth(1) == tID && (third == tSEMI || third == tCOMMA || third == tRPAREN)) return p_type_mark(); else return p_subtype_indication(); } static type_t p_psl_param_spec(psl_node_t node, psl_type_t *psl_type, class_t *class) { // const // | [const | mutable] Value_Parameter // | sequence // | property // // Value_Parameter ::= // HDL_Type // | PSL_Type_Class // // HDL_Type ::= // hdltype HDL_VARIABLE_TYPE // // PSL_Type_Class ::= // boolean | bit | bitvector | numeric | string BEGIN("PSL Parameter specification"); *class = C_SIGNAL; switch (peek()) { case tPROPERTY: consume(tPROPERTY); *psl_type = PSL_TYPE_PROPERTY; break; case tSEQUENCE: consume(tSEQUENCE); *psl_type = PSL_TYPE_SEQUENCE; break; case tCONST: *class = C_CONSTANT; // Handle PSL 1.1 "const" only if (peek_nth(2) == tID) { consume(tCONST); *psl_type = PSL_TYPE_NUMERIC; return std_type(NULL, STD_INTEGER); } case tMUTABLE: one_of(tCONST, tMUTABLE); case tHDLTYPE: case tBOOLEAN: case tBIT: case tBITVECTOR: case tNUMERIC: case tSTRINGK: switch (one_of(tHDLTYPE, tBOOLEAN, tBIT, tBITVECTOR, tNUMERIC, tSTRINGK)) { case tHDLTYPE: *psl_type = PSL_TYPE_HDLTYPE; scan_as_vhdl(); type_t t = p_psl_subtype_indication(); scan_as_psl(); return t; case tBOOLEAN: *psl_type = PSL_TYPE_BOOLEAN; return std_type(NULL, STD_BOOLEAN); case tBIT: *psl_type = PSL_TYPE_BIT; return std_type(NULL, STD_BIT); break; case tBITVECTOR: *psl_type = PSL_TYPE_BITVECTOR; return std_type(NULL, STD_BIT_VECTOR); break; case tNUMERIC: *psl_type = PSL_TYPE_NUMERIC; return std_type(NULL, STD_INTEGER); break; case tSTRINGK: *psl_type = PSL_TYPE_STRING; return std_type(NULL, STD_STRING); } } return type_new(T_NONE); } static void p_psl_formal_parameter(psl_node_t node) { // Param_Spec PSL_Identifier { , PSL_Identifier } BEGIN("PSL Formal parameter"); psl_type_t psl_type = PSL_TYPE_NUMERIC; class_t class; type_t type = p_psl_param_spec(node, &psl_type, &class); do { tree_t p = tree_new(T_PARAM_DECL); tree_set_ident(p, p_identifier()); tree_set_loc(p, CURRENT_LOC); tree_set_class(p, class); tree_set_subkind(p, psl_type); tree_set_type(p, type); psl_add_port(node, p); insert_name(nametab, p, NULL); } while (optional(tCOMMA)); } static void p_psl_formal_parameter_list(psl_node_t node) { // Formal_Parameter { ; Formal_Parameter } BEGIN("PSL Formal parameter list"); p_psl_formal_parameter(node); while (optional(tSEMI)) p_psl_formal_parameter(node); } static void p_psl_actual_parameter(psl_node_t node, bool seq) { // Actual_Parameter ::= // AnyType | Sequence | Property // sequence_Actual_Parameter ::= // AnyType | Sequence BEGIN("PSL Actual parameter"); // "Sequence" includes "Any_Type" parsing (HDL or PSL expression) // "Property" includes "Sequence" parsing psl_add_operand(node, (seq) ? p_psl_sequence() : p_psl_property()); } static void p_psl_actual_parameter_list(psl_node_t node, bool seq) { // sequence_Actual_Parameter { , sequence_Actual_Parameter } // Actual_Parameter { , Actual_Parameter } BEGIN("PSL Actual parameter list"); p_psl_actual_parameter(node, seq); while (optional(tCOMMA)) p_psl_actual_parameter(node, seq); } static psl_node_t p_psl_clocked_sere(psl_node_t head) { // Braced_SERE @ Clock_Expression BEGIN("PSL Clocked SERE"); consume(tAT); tree_t expr = p_expression(); solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN)); psl_node_t p = psl_new(P_CLOCKED); psl_set_value(p, head); psl_set_tree(p, expr); psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_compound_sere(psl_node_t head) { // Repeated_SERE | Braced_SERE | Clocked_SERE // | Compound_SERE '|' Compound_SERE // | Compound_SERE & Compound_SERE // | Compound_SERE && Compound_SERE // | Compound_SERE within Compound_SERE // | Parameterized_SERE BEGIN("PSL Compound SERE"); if (head == NULL) { switch (peek()) { case tLBRACE: head = p_psl_braced_sere(); break; case tFOR: head = p_psl_parametrized_sere(); break; default: head = p_psl_boolean(NULL); break; } } for (;;) { switch (peek()) { case tBAR: { consume(tBAR); psl_node_t p = psl_new(P_SERE); psl_add_operand(p, head); psl_set_subkind(p, PSL_SERE_OR); psl_add_operand(p, p_psl_compound_sere(NULL)); psl_set_loc(p, CURRENT_LOC); head = p; } break; case tAMP: { consume(tAMP); psl_node_t p = psl_new(P_SERE); psl_add_operand(p, head); psl_set_subkind(p, PSL_SERE_NEQ_AND); psl_add_operand(p, p_psl_compound_sere(NULL)); psl_set_loc(p, CURRENT_LOC); head = p; } break; case tDBLAMP: { consume(tDBLAMP); psl_node_t p = psl_new(P_SERE); psl_add_operand(p, head); psl_set_subkind(p, PSL_SERE_EQU_AND); psl_add_operand(p, p_psl_compound_sere(NULL)); psl_set_loc(p, CURRENT_LOC); head = p; } break; case tWITHIN: { consume(tWITHIN); psl_node_t p = psl_new(P_SERE); psl_add_operand(p, head); psl_set_subkind(p, PSL_SERE_WITHIN); psl_add_operand(p, p_psl_compound_sere(NULL)); psl_set_loc(p, CURRENT_LOC); head = p; } break; case tPLUSRPT: case tTIMESRPT: case tGOTORPT: case tEQRPT: case t2LSQUARE: head = p_psl_repeated_sere(head); break; case tAT: head = p_psl_clocked_sere(head); break; default: return head; } } } static psl_node_t p_psl_sere(void) { // Boolean | Boolean Proc_Block | Sequence | SERE ; SERE // | SERE : SERE | Compound_SERE BEGIN("PSL SERE"); psl_node_t head; switch (peek()) { case tLBRACE: case tPLUSRPT: case tTIMESRPT: case tGOTORPT: case tEQRPT: case tID: head = p_psl_sequence(); break; case tFOR: head = p_psl_compound_sere(NULL); break; default: head = p_psl_boolean(NULL); break; } for (;;) { const token_t tok = peek(); switch (tok) { case tCOLON: case tSEMI: { consume(tok); const psl_sere_kind_t kind = tok == tCOLON ? PSL_SERE_FUSION : PSL_SERE_CONCAT; psl_node_t rhs = p_psl_sere(); psl_node_t p = psl_new(P_SERE); psl_set_subkind(p, kind); psl_add_operand(p, head); psl_set_loc(p, CURRENT_LOC); if (psl_kind(rhs) == P_SERE && psl_subkind(rhs) == kind) { const int nops = psl_operands(rhs); for (int i = 0; i < nops; i++) psl_add_operand(p, psl_operand(rhs, i)); } else psl_add_operand(p, rhs); head = p; } break; case tBAR: case tAMP: case tDBLAMP: case tWITHIN: case tLSQUARE: case tPLUSRPT: case tTIMESRPT: case tEQRPT: case tGOTORPT: head = p_psl_compound_sere(head); continue; default: return head; } } } static psl_node_t p_psl_braced_sere(void) { // { [ [[ HDL DECL {HDL DECL} ]] ] SERE } // | { [free HDL Identifier {HDL Identifier} ] SERE } BEGIN("PSL Braced SERE"); consume(tLBRACE); psl_node_t sere = p_psl_sere(); consume(tRBRACE); psl_set_loc(sere, CURRENT_LOC); return sere; } static psl_node_t p_psl_repeated_sere(psl_node_t head) { // Boolean [* [ Count ] ] | Sequence [* [ Count ] ] | [* [ Count ] ] // | Boolean [+] | Sequence [+] | [+] | Boolean [= Count ] // | Boolean [-> [ positive_Count ] ] | Boolean Proc_Block // | Sequence Proc_Block EXTEND("PSL Repeated SERE"); assert(head != NULL); if (peek() == t2LSQUARE) return p_psl_proc_block(head); psl_node_t p = psl_new(P_REPEAT); psl_set_value(p, head); switch (one_of(tPLUSRPT, tTIMESRPT, tGOTORPT, tEQRPT, t2LSQUARE)) { case tPLUSRPT: psl_set_subkind(p, PSL_PLUS_REPEAT); break; case tTIMESRPT: psl_set_subkind(p, PSL_TIMES_REPEAT); if (peek() != tRSQUARE) psl_set_delay(p, p_psl_count()); consume(tRSQUARE); break; case tGOTORPT: psl_set_subkind(p, PSL_GOTO_REPEAT); if (peek() != tRSQUARE) psl_set_delay(p, p_psl_count()); consume(tRSQUARE); break; case tEQRPT: psl_set_subkind(p, PSL_EQUAL_REPEAT); if (peek() != tRSQUARE) psl_set_delay(p, p_psl_count()); consume(tRSQUARE); break; default: return head; } psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_sequence_instance(tree_t decl) { // Name [ ( Actual_Parameter_List ) ] EXTEND("PSL Sequence Instance"); psl_node_t s_decl = tree_psl(decl); if (psl_kind(s_decl) != P_SEQUENCE_DECL) parse_error(CURRENT_LOC, "%s is not a PSL sequence", istr(tree_ident(decl))); psl_node_t p = psl_new(P_SEQUENCE_INST); psl_set_ref(p, s_decl); if (optional(tLPAREN)) { p_psl_actual_parameter_list(p, true); consume(tRPAREN); } psl_set_loc(p, CURRENT_LOC); return p; } static psl_node_t p_psl_sequence(void) { // Sequence_Instance | Repeated_SERE | Braced_SERE | Clocked_SERE BEGIN("PSL Sequence"); psl_node_t head = NULL; switch (peek()) { case tLBRACE: head = p_psl_braced_sere(); break; case tID: { tree_t name = p_name(N_PSL); // Check for sequence instance if (tree_kind(name) == T_REF && tree_has_ref(name)) { tree_t decl = tree_ref(name); if (tree_kind(decl) == T_PSL_DECL) head = p_sequence_instance(decl); } if (head == NULL) head = p_psl_boolean(name); } break; case tTIMESRPT: case tPLUSRPT: { // Empty SERE is equivalent to TRUE type_t std_bool = std_type(NULL, STD_BOOLEAN); tree_t true_ref = make_ref(type_enum_literal(std_bool, 1)); head = psl_new(P_HDL_EXPR); psl_set_tree(head, true_ref); psl_set_type(head, PSL_TYPE_BOOLEAN); } break; default: head = p_psl_boolean(NULL); break; } for (;;) { switch (peek()) { case tPLUSRPT: case tTIMESRPT: case tGOTORPT: case tEQRPT: case t2LSQUARE: head = p_psl_repeated_sere(head); break; case tAT: head = p_psl_clocked_sere(head); break; default: return head; } } } static psl_node_t p_psl_fl_property(void) { // Boolean | ( FL_Property ) | FL_Property @ Clock_Expression // | always FL_Property // | never FL_Property // | eventually! FL_Property // | next FL_Property | next [ Number ] FL_Property // | next! FL_Property | next! [ Number ] FL_Property // | next_event ( Boolean ) ( FL_Property ) // | next_event ( Boolean ) ( FL_Property ) // | next_event! ( Boolean ) [ Number ] ( FL_Property ) // | next_event! ( Boolean ) [ Number ] ( FL_Property ) // | FL_Property -> FL_Property // | FL_Property <-> FL_Property // | FL_Property or FL_Property // | FL_Property and FL_Property // | FL_Property until! FL_Property // | FL_Property until!_ FL_Property // | FL_Property until FL_Property // | FL_Property until_ FL_Property // | FL_Property sync_abort Boolean // | FL_Property async_abort Boolean // | FL_Property abort Boolean // | Sequence [ ! ] // | Sequence |-> FL_Property // | Sequence |=> FL_Property BEGIN("FL property"); psl_node_t p = NULL; const token_t tok = peek(); switch (tok) { case tALWAYS: { consume(tALWAYS); p = psl_new(P_ALWAYS); psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tNEVER: { consume(tNEVER); p = psl_new(P_NEVER); psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tEVENTUALLY: { consume(tEVENTUALLY); p = psl_new(P_EVENTUALLY); psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tPSLNEXT: case tNEXT1: { consume(tok); p = psl_new(P_NEXT); if (tok == tNEXT1) psl_set_flag(p, PSL_F_STRONG); if (optional(tLSQUARE)) { psl_node_t count = p_hdl_expression(NULL, PSL_TYPE_NUMERIC); psl_set_delay(p, count); consume(tRSQUARE); } psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tNEXTA: case tNEXTA1: { consume(tok); p = psl_new(P_NEXT_A); if (tok == tNEXTA1) psl_set_flag(p, PSL_F_STRONG); consume(tLSQUARE); psl_set_delay(p, p_psl_range(NULL)); consume(tRSQUARE); psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tNEXTE: case tNEXTE1: { consume(tok); p = psl_new(P_NEXT_E); if (tok == tNEXTE1) psl_set_flag(p, PSL_F_STRONG); consume(tLSQUARE); psl_set_delay(p, p_psl_range(NULL)); consume(tRSQUARE); psl_set_value(p, p_psl_fl_property()); psl_set_loc(p, CURRENT_LOC); } break; case tNEXTEVENT: case tNEXTEVENT1: { consume(tok); p = psl_new(P_NEXT_EVENT); if (tok == tNEXTEVENT1) psl_set_flag(p, PSL_F_STRONG); consume(tLPAREN); (void)p_psl_fl_property(); consume(tRPAREN); if (optional(tLSQUARE)) { psl_node_t count = p_hdl_expression(NULL, PSL_TYPE_NUMERIC); psl_set_delay(p, count); consume(tRSQUARE); } consume(tLPAREN); psl_set_value(p, p_psl_fl_property()); consume(tRPAREN); psl_set_loc(p, CURRENT_LOC); } break; case tLPAREN: { consume(tLPAREN); p = p_psl_fl_property(); consume(tRPAREN); if (psl_kind(p) == P_HDL_EXPR && is_vhdl_infix_op(peek())) { // Handle awkward cases like "always x -> (x or y) = '1'" // where we cannot determine ahead-of-time whether (x or y) // is a VHDL expression or PSL property tree_t expr = p_expression_with_head(psl_tree(p)); psl_set_tree(p, expr); } psl_set_loc(p, CURRENT_LOC); } break; case tLBRACE: case tPLUSRPT: case tTIMESRPT: case tGOTORPT: case tEQRPT: p = p_psl_sequence(); break; default: p = p_hdl_expression(NULL, PSL_TYPE_BOOLEAN); break; } const token_t infix = peek(); switch (infix) { case tIFIMPL: case tIFFIMPL: case tAND: case tOR: { consume(infix); psl_logic_t kind; switch (infix) { case tAND: kind = PSL_LOGIC_AND; break; case tOR: kind = PSL_LOGIC_OR; break; case tIFIMPL: kind = PSL_LOGIC_IF; break; case tIFFIMPL: kind = PSL_LOGIC_IFF; break; default: should_not_reach_here(); } psl_node_t right = p_psl_fl_property(); // A logical operation where the two operands are HDL // expressions should be parsed as a single HDL expression const bool prefer_hdl = (kind == PSL_LOGIC_OR || kind == PSL_LOGIC_AND) && psl_kind(p) == P_HDL_EXPR && psl_kind(right) == P_HDL_EXPR; if (prefer_hdl) { ident_t op = well_known(kind == PSL_LOGIC_OR ? W_OP_OR : W_OP_AND); tree_t fcall = tree_new(T_FCALL); tree_set_ident(fcall, op); tree_set_loc(fcall, CURRENT_LOC); add_param(fcall, psl_tree(p), P_POS, NULL); add_param(fcall, psl_tree(right), P_POS, NULL); psl_set_tree(p, fcall); psl_set_loc(p, CURRENT_LOC); return p; } else { psl_node_t log = psl_new(P_LOGICAL); psl_set_subkind(log, kind); psl_add_operand(log, p); psl_add_operand(log, right); psl_set_loc(log, CURRENT_LOC); return log; } } case tSUFFIXOVR: case tSUFFIXNON: { consume(infix); const psl_suffix_impl_t kind = infix == tSUFFIXOVR ? PSL_SUFFIX_OVERLAP : PSL_SUFFIX_NON; psl_node_t suff = psl_new(P_SUFFIX_IMPL); psl_set_subkind(suff, kind); psl_add_operand(suff, p); psl_add_operand(suff, p_psl_fl_property()); psl_set_loc(suff, CURRENT_LOC); return suff; } case tUNTIL: case tUNTIL_: case tUNTIL1: case tUNTIL1_: { consume(infix); psl_flags_t flags = 0; if (infix == tUNTIL1 || infix == tUNTIL1_) flags |= PSL_F_STRONG; if (infix == tUNTIL_ || infix == tUNTIL1_) flags |= PSL_F_INCLUSIVE; psl_node_t until = psl_new(P_UNTIL); psl_set_flag(until, flags); psl_add_operand(until, p); psl_add_operand(until, p_psl_fl_property()); psl_set_loc(until, CURRENT_LOC); return until; } case tBEFORE: case tBEFORE_: case tBEFORE1: case tBEFORE1_: { consume(infix); psl_flags_t flags = 0; if (infix == tBEFORE1 || infix == tBEFORE1_) flags |= PSL_F_STRONG; if (infix == tBEFORE_ || infix == tBEFORE1_) flags |= PSL_F_INCLUSIVE; psl_node_t until = psl_new(P_BEFORE); psl_set_flag(until, flags); psl_add_operand(until, p); psl_add_operand(until, p_psl_fl_property()); psl_set_loc(until, CURRENT_LOC); return until; } case tABORT: case tASYNC_ABORT: case tSYNC_ABORT: { consume(infix); const psl_abort_t kind = infix == tSYNC_ABORT ? PSL_ABORT_SYNC : PSL_ABORT_ASYNC; psl_node_t abort = psl_new(P_ABORT); psl_set_subkind(abort, kind); psl_add_operand(abort, p); psl_add_operand(abort, p_hdl_expression(NULL, PSL_TYPE_BOOLEAN)); psl_set_loc(abort, CURRENT_LOC); return abort; } case tAT: { consume(tAT); tree_t expr = p_expression(); solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN)); psl_node_t clk = psl_new(P_CLOCKED); psl_set_value(clk, p); psl_set_tree(clk, expr); psl_set_loc(clk, CURRENT_LOC); return clk; } default: return p; } } static void p_psl_report(psl_node_t p) { consume(tREPORT); tree_t m = p_expression(); psl_set_message(p, m); solve_types(nametab, m, std_type(NULL, STD_STRING)); } static psl_node_t p_psl_property(void) { // Replicator Property | FL_Property | OBE_Property BEGIN("property"); return p_psl_fl_property(); } static psl_node_t p_psl_assert_directive(void) { // assert Property [ report String ] ; BEGIN("assert directive"); consume(tASSERT); psl_node_t p = with_default_clock(p_psl_property()); psl_node_t a = psl_new(P_ASSERT); psl_set_value(a, p); if (peek() == tREPORT) p_psl_report(a); consume(tSEMI); psl_set_loc(a, CURRENT_LOC); return a; } static psl_node_t p_psl_assume_directive(void) { // assume Property ; // assume_guarantee Property [ report String ] ; BEGIN("assume directive"); token_t tok = one_of(tASSUME, tASSUMEG); psl_node_t a = psl_new(P_ASSUME); if (tok == tASSUME) psl_set_subkind(a, PSL_NO_GUARANTEE); else psl_set_subkind(a, PSL_GUARANTEE); psl_node_t p = with_default_clock(p_psl_property()); psl_set_value(a, p); if (peek() == tREPORT && tok == tASSUMEG) p_psl_report(a); consume(tSEMI); psl_set_loc(a, CURRENT_LOC); return a; } static psl_node_t p_psl_restrict_directive(void) { // restrict Sequence ; // restrict_guarantee Sequence [ report String ] ; BEGIN("restrict directive"); token_t tok = peek(); assert(tok == tRESTRICT || tok == tRESTRICTG); consume(tok); psl_node_t a = psl_new(P_RESTRICT); if (tok == tRESTRICT) psl_set_subkind(a, PSL_NO_GUARANTEE); else psl_set_subkind(a, PSL_GUARANTEE); psl_node_t p = with_default_clock(p_psl_sequence()); psl_set_value(a, p); if (peek() == tREPORT && tok == tRESTRICTG) p_psl_report(a); consume(tSEMI); psl_set_loc(a, CURRENT_LOC); return a; } static psl_node_t p_psl_fairness(void) { // fairness Boolean ; // strong fairness Boolean , Boolean ; BEGIN("fairness statement"); psl_flags_t flags = 0; if (optional(tSTRONG)) flags |= PSL_F_STRONG; consume(tFAIRNESS); psl_node_t a = psl_new(P_FAIRNESS); psl_set_flag(a, flags); tree_t e1 = p_expression(); solve_psl_condition(nametab, &e1); psl_node_t p1 = psl_new(P_HDL_EXPR); psl_set_tree(p1, e1); psl_add_operand(a, p1); if (flags & PSL_F_STRONG) { consume(tCOMMA); tree_t e2 = p_expression(); solve_psl_condition(nametab, &e2); psl_node_t p2 = psl_new(P_HDL_EXPR); psl_set_tree(p2, e2); psl_add_operand(a, p2); } consume(tSEMI); psl_set_loc(a, CURRENT_LOC); return a; } static psl_node_t p_psl_cover_directive(void) { // cover Sequence [ report String ] ; BEGIN("cover directive"); consume(tCOVER); psl_node_t p = with_default_clock(p_psl_sequence()); psl_node_t a = psl_new(P_COVER); psl_set_value(a, p); if (peek() == tREPORT) p_psl_report(a); consume(tSEMI); psl_set_loc(a, CURRENT_LOC); return a; } static psl_node_t p_psl_verification_directive(void) { // Assert_Directive | Assume_Directive | Restrict_Directive // | Restrict!_Directive | Cover_Directive | Fairness_Statement BEGIN("verification directive"); switch (peek()) { case tASSERT: return p_psl_assert_directive(); case tASSUME: case tASSUMEG: return p_psl_assume_directive(); case tRESTRICT: case tRESTRICTG: return p_psl_restrict_directive(); case tFAIRNESS: case tSTRONG: return p_psl_fairness(); case tCOVER: return p_psl_cover_directive(); default: one_of(tASSERT, tASSUME, tASSUMEG, tRESTRICT, tRESTRICTG, tFAIRNESS, tSTRONG, tCOVER); return NULL; } } static tree_t p_psl_directive(ident_t label) { // [ Label : ] Verification_Directive BEGIN("PSL directive"); tree_t t = tree_new(T_PSL_DIRECT); scan_as_psl(); // Verification directive can contain Proc_Block with // local declarations -> Push scope push_scope(nametab); insert_names_for_psl(nametab); psl_node_t p = p_psl_verification_directive(); scan_as_vhdl(); if (p != NULL) { tree_set_psl(t, p); psl_check(p, nametab); } pop_scope(nametab); tree_set_loc(t, CURRENT_LOC); ensure_labelled(t, label); if (label) insert_name(nametab, t, NULL); return t; } static tree_t p_psl_property_declaration(void) { // property PSL_Identifier [ ( Formal_Parameter_List ) ] is Property ; BEGIN("PSL property declaration"); scan_as_psl(); psl_node_t decl = psl_new(P_PROPERTY_DECL); consume(tPROPERTY); ident_t ident = p_identifier(); psl_set_ident(decl, ident); tree_t t = tree_new(T_PSL_DECL); tree_set_psl(t, decl); tree_set_ident(t, ident); insert_name(nametab, t, NULL); push_scope(nametab); scope_set_container(nametab, t); insert_names_for_psl(nametab); if (optional(tLPAREN)) { p_psl_formal_parameter_list(decl); consume(tRPAREN); } consume(tIS); psl_node_t prop = p_psl_property(); psl_set_value(decl, prop); consume(tSEMI); psl_set_loc(decl, CURRENT_LOC); psl_check(decl, nametab); pop_scope(nametab); scan_as_vhdl(); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_psl_sequence_declaration(void) { // sequence PSL_Identifier [ ( Formal_Parameter_List ) ] is Sequence ; BEGIN("PSL sequence declaration"); scan_as_psl(); psl_node_t decl = psl_new(P_SEQUENCE_DECL); consume(tSEQUENCE); ident_t ident = p_identifier(); psl_set_ident(decl, ident); tree_t t = tree_new(T_PSL_DECL); tree_set_psl(t, decl); tree_set_ident(t, ident); insert_name(nametab, t, NULL); push_scope(nametab); scope_set_container(nametab, t); insert_names_for_psl(nametab); if (optional(tLPAREN)) { p_psl_formal_parameter_list(decl); consume(tRPAREN); } consume(tIS); psl_node_t prop = p_psl_sequence(); psl_set_value(decl, prop); consume(tSEMI); psl_set_loc(decl, CURRENT_LOC); psl_check(decl, nametab); pop_scope(nametab); scan_as_vhdl(); tree_set_loc(t, CURRENT_LOC); return t; } static tree_t p_psl_endpoint_declaration(void) { // sequence PSL_Identifier is Sequence ; BEGIN("PSL endpoint declaration"); scan_as_psl(); psl_node_t decl = psl_new(P_ENDPOINT_DECL); consume(tENDPOINT); ident_t ident = p_identifier(); psl_set_ident(decl, ident); tree_t t = tree_new(T_PSL_DECL); tree_set_psl(t, decl); tree_set_ident(t, ident); insert_name(nametab, t, NULL); push_scope(nametab); insert_names_for_psl(nametab); consume(tIS); psl_node_t prop = p_psl_sequence(); psl_set_value(decl, prop); consume(tSEMI); psl_set_loc(decl, CURRENT_LOC); psl_check(decl, nametab); pop_scope(nametab); scan_as_vhdl(); tree_set_loc(t, CURRENT_LOC); return t; } static void p_psl_declaration(tree_t parent) { // Property_Declaration | Sequence_Declaration | Clock_Declaration BEGIN("PSL declaration"); switch (peek()) { case tPROPERTY: tree_add_decl(parent, p_psl_property_declaration()); break; case tSEQUENCE: tree_add_decl(parent, p_psl_sequence_declaration()); break; case tDEFAULT: tree_add_decl(parent, p_psl_clock_declaration()); break; case tENDPOINT: tree_add_decl(parent, p_psl_endpoint_declaration()); break; default: one_of(tPROPERTY, tSEQUENCE, tDEFAULT, tENDPOINT); break; } } static tree_t p_psl_or_concurrent_assert(ident_t label) { // Handle the ambiguity between a PSL assertion and a normal VHDL // concurrent assertion statement. // // assert condition [ report expression ] [ severity expression ] ; // | assert Property [ report String ] ; BEGIN("PSL or concurrent assertion statement"); if (peek() == tPOSTPONED) return p_concurrent_assertion_statement(label); // Cannot be PSL consume(tASSERT); push_scope(nametab); insert_names_for_psl(nametab); scan_as_psl(); psl_node_t p = p_psl_property(); scan_as_vhdl(); tree_t conc; if (psl_kind(p) == P_HDL_EXPR) { tree_t value = psl_tree(p); solve_condition(nametab, &value); tree_t s = tree_new(T_ASSERT); tree_set_value(s, value); if (optional(tREPORT)) { tree_t message = p_expression(); solve_types(nametab, message, std_type(NULL, STD_STRING)); tree_set_message(s, message); } if (optional(tSEVERITY)) { tree_t severity = p_expression(); solve_types(nametab, severity, std_type(NULL, STD_SEVERITY_LEVEL)); tree_set_severity(s, severity); } consume(tSEMI); tree_set_loc(s, CURRENT_LOC); conc = tree_new(T_CONCURRENT); tree_add_stmt(conc, s); } else { psl_node_t a = psl_new(P_ASSERT); psl_set_value(a, with_default_clock(p)); if (peek() == tREPORT) p_psl_report(a); consume(tSEMI); psl_set_loc(a, CURRENT_LOC); psl_check(a, nametab); conc = tree_new(T_PSL_DIRECT); tree_set_psl(conc, a); } pop_scope(nametab); tree_set_loc(conc, CURRENT_LOC); ensure_labelled(conc, label); if (label) insert_name(nametab, conc, NULL); sem_check(conc, nametab); return conc; } static tree_t p_concurrent_statement(void) { // block_statement | process_statement | concurrent_procedure_call_statement // | concurrent_assertion_statement // | concurrent_signal_assignment_statement // | component_instantiation_statement | generate_statement // | 2008: psl_directive BEGIN("concurrent statement"); ident_t label = NULL; if ((peek() == tID) && (peek_nth(2) == tCOLON)) { label = p_identifier(); consume(tCOLON); } switch (peek()) { case tPROCESS: return p_process_statement(label); case tCOMPONENT: case tENTITY: case tCONFIGURATION: return p_component_instantiation_statement(label, NULL); case tWITH: return p_concurrent_signal_assignment_statement(label, NULL); case tASSERT: if (standard() >= STD_08) return p_psl_or_concurrent_assert(label); else return p_concurrent_assertion_statement(label); case tCOVER: return p_psl_directive(label); case tBLOCK: return p_block_statement(label); case tIF: case tFOR: case tCASE: return p_generate_statement(label); case tLPAREN: case tLTLT: return p_concurrent_signal_assignment_statement(label, NULL); case tID: { const token_t p2 = peek_nth(2); if ((label != NULL && p2 == tSEMI) || p2 == tGENERIC || p2 == tPORT) return p_component_instantiation_statement(label, NULL); else { tree_t name = p_name(N_SUBPROGRAM), conc; if (peek() == tLE) return p_concurrent_signal_assignment_statement(label, name); else if (scan(tGENERIC, tPORT)) return p_component_instantiation_statement(label, name); else { switch (tree_kind(name)) { case T_REF: if (tree_has_ref(name)) { tree_t decl = tree_ref(name); if (tree_kind(decl) == T_COMPONENT) return p_component_instantiation_statement(label, name); } // Fall-through case T_PROT_REF: return p_concurrent_procedure_call_statement(label, name); default: parse_error(CURRENT_LOC, "expected concurrent statement"); drop_tokens_until(tSEMI); return ensure_labelled(tree_new(T_CONCURRENT), label); } } return conc; } } case tPOSTPONED: { const token_t tok2 = peek_nth(2); if (tok2 == tASSERT) return p_concurrent_assertion_statement(label); else if (tok2 == tID || tok2 == tLPAREN) { consume(tPOSTPONED); tree_t name = p_name(N_SUBPROGRAM), conc; if (peek() == tLE) conc = p_concurrent_signal_assignment_statement(label, name); else conc = p_concurrent_procedure_call_statement(label, name); tree_set_flag(conc, TREE_F_POSTPONED); return conc; } else return p_process_statement(label); } default: expect(tPROCESS, tPOSTPONED, tCOMPONENT, tENTITY, tCONFIGURATION, tWITH, tASSERT, tBLOCK, tIF, tFOR, tCASE, tLPAREN, tID, STD(08, tLTLT)); drop_tokens_until(tSEMI); return ensure_labelled(tree_new(T_BLOCK), label); } } static void p_architecture_declarative_part(tree_t arch) { // { block_declarative_item } BEGIN("architecture declarative part"); while (not_at_token(tBEGIN)) p_block_declarative_item(arch); } static void p_architecture_statement_part(tree_t arch) { // { concurrent_statement } BEGIN("architecture statement part"); while (not_at_token(tEND)) p_concurrent_statement_or_psl(arch); } static void p_architecture_body(tree_t unit) { // architecture identifier of entity_name is architecture_declarative_part // begin architecture_statement_part end [ architecture ] // [ architecture_simple_name ] ; BEGIN("architecture body"); tree_change_kind(unit, T_ARCH); consume(tARCHITECTURE); ident_t arch_name = p_identifier(); tree_set_ident(unit, arch_name); consume(tOF); tree_t e = NULL; ident_t entity_name = p_entity_name(&e); tree_set_ident2(unit, entity_name); consume(tIS); if (e != NULL) { tree_set_primary(unit, e); insert_names_from_context(nametab, e); } push_scope(nametab); if (entity_name != arch_name && e != NULL) insert_name(nametab, e, entity_name); ident_t ename = ident_prefix(lib_name(lib_work()), entity_name, '.'); ident_t qual = ident_prefix(ename, arch_name, '-'); scope_set_prefix(nametab, qual); tree_set_loc(unit, CURRENT_LOC); insert_name(nametab, unit, NULL); push_scope(nametab); scope_set_container(nametab, unit); if (e != NULL) { insert_generics(nametab, e); insert_ports(nametab, e); insert_decls(nametab, e); } continue_proc_labelling_from(e, nametab); p_architecture_declarative_part(unit); consume(tBEGIN); p_architecture_statement_part(unit); consume(tEND); optional(tARCHITECTURE); p_trailing_label(arch_name); consume(tSEMI); tree_set_ident(unit, qual); tree_set_loc(unit, CURRENT_LOC); sem_check(unit, nametab); pop_scope(nametab); pop_scope(nametab); } static void p_package_body_declarative_item(tree_t parent) { // subprogram_declaration | subprogram_body | type_declaration // | subtype_declaration | constant_declaration // | shared_variable_declaration | file_declaration | alias_declaration // | use_clause | group_template_declaration | group_declaration // // 2008: subprogram_instantiation_declaration | attribute_declaration // | attribute_specification | package_instantiation_declaration // | package_declaration BEGIN("package body declarative item"); switch (peek()) { case tFUNCTION: case tPROCEDURE: case tIMPURE: case tPURE: if (peek_nth(3) == tIS && peek_nth(4) == tNEW) tree_add_decl(parent, p_subprogram_instantiation_declaration()); else { tree_t spec = p_subprogram_specification(); if (peek() == tSEMI) tree_add_decl(parent, p_subprogram_declaration(spec)); else tree_add_decl(parent, p_subprogram_body(spec)); } break; case tSHARED: p_variable_declaration(parent); break; case tFILE: p_file_declaration(parent); break; case tATTRIBUTE: if (peek_nth(3) == tOF) p_attribute_specification(parent); else tree_add_decl(parent, p_attribute_declaration()); if (standard() < STD_08) parse_error(tree_loc(tree_decl(parent, tree_decls(parent) - 1)), "package body may not contain attribute declarations or" " specifications in VHDL-%s", standard_text(standard())); break; case tTYPE: p_type_declaration(parent); break; case tCONSTANT: p_constant_declaration(parent); break; case tSUBTYPE: tree_add_decl(parent, p_subtype_declaration()); break; case tALIAS: p_alias_declaration(parent); break; case tUSE: p_use_clause(parent, tree_add_decl); break; case tGROUP: if (peek_nth(3) == tIS) tree_add_decl(parent, p_group_template_declaration()); else tree_add_decl(parent, p_group_declaration()); break; case tPACKAGE: if (peek_nth(4) == tNEW) tree_add_decl(parent, p_package_instantiation_declaration(NULL)); else if (peek_nth(2) == tBODY) { require_std(STD_08, "nested package declarations"); tree_add_decl(parent, p_package_body(NULL)); } else { require_std(STD_08, "nested package declarations"); tree_add_decl(parent, p_package_declaration(NULL)); } break; default: expect(tFUNCTION, tPROCEDURE, tSHARED, tIMPURE, tPURE, tATTRIBUTE, tTYPE, tCONSTANT, tSUBTYPE, tFILE, tALIAS, tUSE, tGROUP, STD(08, tPACKAGE)); } } static void p_package_body_declarative_part(tree_t unit) { // { package_body_declarative_item } BEGIN("package body declarative part"); while (not_at_token(tEND)) p_package_body_declarative_item(unit); } static tree_t p_package_body(tree_t unit) { // package body simple_name is package_body_declarative_part // end [ package body ] [ simple_name ] ; BEGIN("package body"); consume(tPACKAGE); consume(tBODY); ident_t name = p_identifier(), qual = name; tree_t body; if (unit != NULL) { // Package body as primary unit assert(tree_kind(unit) == T_DESIGN_UNIT); tree_change_kind(unit, T_PACK_BODY); body = unit; qual = ident_prefix(lib_name(lib_work()), name, '.'); } else body = tree_new(T_PACK_BODY); tree_t pack = resolve_name(nametab, CURRENT_LOC, qual); if (pack != NULL && tree_kind(pack) != T_PACKAGE) { parse_error(CURRENT_LOC, "unit %s is not a package", istr(qual)); pack = NULL; } else if (pack != NULL) { tree_set_primary(body, pack); insert_names_from_context(nametab, pack); } push_scope(nametab); tree_set_ident(body, ident_prefix(qual, ident_new("body"), '-')); tree_set_loc(body, CURRENT_LOC); scope_set_prefix(nametab, qual); insert_name(nametab, body, name); consume(tIS); push_scope(nametab); scope_set_container(nametab, body); if (pack != NULL) { insert_generics(nametab, pack); insert_decls(nametab, pack); } p_package_body_declarative_part(body); if (pack != NULL && (tree_global_flags(pack) & TREE_GF_DEFERRED_INST)) package_body_deferred_instantiation(pack, body); consume(tEND); if (optional(tPACKAGE)) consume(tBODY); p_trailing_label(name); consume(tSEMI); tree_set_loc(body, CURRENT_LOC); sem_check(body, nametab); pop_scope(nametab); pop_scope(nametab); return body; } static void p_secondary_unit(tree_t unit) { // architecture_body | package_body BEGIN("secondary unit"); switch (peek()) { case tARCHITECTURE: p_architecture_body(unit); break; case tPACKAGE: p_package_body(unit); break; default: expect(tARCHITECTURE, tPACKAGE); } } static void p_library_unit(tree_t unit) { // primary_unit | secondary_unit BEGIN("library unit"); switch (peek()) { case tENTITY: case tCONFIGURATION: case tCONTEXT: p_primary_unit(unit); break; case tARCHITECTURE: p_secondary_unit(unit); break; case tPACKAGE: if (peek_nth(2) == tBODY) p_secondary_unit(unit); else p_primary_unit(unit); break; default: expect(tENTITY, tCONFIGURATION, tARCHITECTURE, tPACKAGE, STD(08, tCONTEXT)); } if (bootstrapping && unit != find_std(nametab)) parse_error(tree_loc(unit), "--bootstrap must only be used with " "STANDARD package"); } static tree_t p_design_unit(void) { BEGIN("design unit"); push_scope(nametab); tree_t unit = tree_new(T_DESIGN_UNIT); scope_set_container(nametab, unit); ident_t std_i = well_known(W_STD); tree_t std = tree_new(T_LIBRARY); tree_set_ident(std, std_i); tree_set_ident2(std, std_i); tree_add_context(unit, std); insert_name(nametab, std, std_i); ident_t work_name = lib_name(lib_work()); tree_t work = tree_new(T_LIBRARY); tree_set_ident(work, work_name); tree_set_ident2(work, work_name); tree_add_context(unit, work); insert_name(nametab, work, well_known(W_WORK)); insert_name(nametab, work, NULL); // The std.standard package is implicit unless we are bootstrapping if (!bootstrapping) { lib_t lstd = lib_require(std_i); ident_t standard_i = well_known(W_STD_STANDARD); tree_t std_pkg = lib_get(lstd, standard_i); if (std_pkg == NULL) fatal("cannot find %s package", istr(standard_i)); tree_t u = tree_new(T_USE); tree_set_ident(u, standard_i); tree_set_ident2(u, well_known(W_ALL)); tree_set_ref(u, std_pkg); tree_add_context(unit, u); insert_names_from_use(nametab, u); } p_context_clause(unit); p_library_unit(unit); pop_scope(nametab); return unit; } static void flush_pragmas(tree_t unit) { // Make sure pragmas always appear in off/on pairs tree_t coverage_off = NULL, synthesis_off = NULL, translate_off = NULL; for (int i = 0; i < pragmas.count; i++) { tree_t p = pragmas.items[i]; tree_add_pragma(unit, p); switch (tree_subkind(p)) { case PRAGMA_SYNTHESIS_ON: synthesis_off = NULL; break; case PRAGMA_SYNTHESIS_OFF: synthesis_off = p; break; case PRAGMA_COVERAGE_ON: coverage_off = NULL; break; case PRAGMA_COVERAGE_OFF: coverage_off = p; break; case PRAGMA_TRANSLATE_ON: translate_off = NULL; break; case PRAGMA_TRANSLATE_OFF: translate_off = p; break; } } if (coverage_off != NULL) warn_at(tree_loc(coverage_off), "no matching $bold$coverage on$$ " "directive seen before end of design unit"); if (synthesis_off != NULL) warn_at(tree_loc(synthesis_off), "no matching $bold$synthesis " "translate_on$$ directive seen before end of design unit"); if (translate_off != NULL) warn_at(tree_loc(translate_off), "no matching $bold$pragma " "translate_on$$ directive seen before end of design unit"); ACLEAR(pragmas); } tree_t parse(void) { n_correct = RECOVER_THRESH; scan_as_vhdl(); if (peek() == tEOF) return NULL; make_new_arena(); nametab = nametab_new(); tree_t unit = p_design_unit(); nametab_finish(nametab); nametab = NULL; flush_pragmas(unit); if (tree_kind(unit) == T_DESIGN_UNIT) return NULL; return unit; } void reset_vhdl_parser(void) { bootstrapping = opt_get_int(OPT_BOOTSTRAP); if (tokenq == NULL) { tokenq_sz = 128; tokenq = xmalloc_array(tokenq_sz, sizeof(tokenq_t)); } tokenq_head = tokenq_tail = 0; } nvc-r1.17.1/src/phase.h000066400000000000000000000042341504111170000146020ustar00rootroot00000000000000// // Copyright (C) 2011-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _PHASE_H #define _PHASE_H #include "prim.h" #include #include // Annotate types and perform other semantics checks on a tree. // Returns false on error. bool sem_check(tree_t t, nametab_t *tab); // Rewrite to simpler forms folding locally static expressions void simplify_local(tree_t top, jit_t *jit, unit_registry_t *ur, mir_context_t *mc); // Rewrite to simpler forms folding globally static expressions void simplify_global(tree_t top, hash_t *generics, jit_t *jit, unit_registry_t *ur, mir_context_t *mc); // Perform static bounds checking void bounds_check(tree_t top); // Elaborate a top level design unit tree_t elab(object_t *top, jit_t *jit, unit_registry_t *ur, mir_context_t *mc, cover_data_t *cover, sdf_file_t *sdf, rt_model_t *m); // Set the value of a top-level generic void elab_set_generic(const char *name, const char *value); typedef enum { CGEN_NATIVE, CGEN_JIT_PACK, } cgen_mode_t; // Generate LLVM bitcode for a design unit void cgen(tree_t top, unit_registry_t *ur, mir_context_t *mc, jit_t *jit, cgen_mode_t mode); // Dump out a VHDL representation of the given unit void dump(tree_t top); // Dump VHDL node with indentation no trailing newline void vhdl_dump(tree_t t, int indent); // Generate a makefile for the givein unit void make(tree_t *targets, int count, FILE *out); // Read the next unit from the input file tree_t parse(void); #endif // _PHASE_H nvc-r1.17.1/src/prim.h000066400000000000000000000065041504111170000144530ustar00rootroot00000000000000// // Copyright (C) 2013-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _PRIM_H #define _PRIM_H #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include typedef struct _lib *lib_t; typedef struct _object object_t; typedef struct _object_arena object_arena_t; typedef struct _ident *ident_t; typedef struct _tree *tree_t; typedef struct _type *type_t; typedef struct _vlog_node *vlog_node_t; typedef struct _sdf_file sdf_file_t; typedef struct loc loc_t; typedef struct _fbuf fbuf_t; typedef struct _hash hash_t; typedef struct _shash shash_t; typedef struct _ihash ihash_t; typedef struct _chash chash_t; typedef struct _ghash ghash_t; typedef struct _hset hset_t; typedef struct _eval_frame eval_frame_t; typedef struct text_buf text_buf_t; typedef struct _nametab nametab_t; typedef struct _diag diag_t; typedef struct _mspace mspace_t; typedef struct _tlab tlab_t; typedef struct _jit jit_t; typedef struct _sig_shared sig_shared_t; typedef struct _ffi_uarray ffi_uarray_t; typedef struct _ffi_closure ffi_closure_t; typedef struct _wave_dumper wave_dumper_t; typedef struct _jit_pack jit_pack_t; typedef struct _lower_unit lower_unit_t; typedef struct _psl_node *psl_node_t; typedef struct _tcl_shell tcl_shell_t; typedef struct _bit_mask bit_mask_t; typedef struct _printer printer_t; typedef struct _unit_registry unit_registry_t; typedef struct _driver_set driver_set_t; typedef struct _vhpi_context vhpi_context_t; typedef struct _mem_pool mem_pool_t; typedef struct _vpi_context vpi_context_t; typedef struct _mir_context mir_context_t; typedef struct _mir_unit mir_unit_t; typedef struct _mir_shape mir_shape_t; typedef struct _vlog_symtab vlog_symtab_t; typedef struct _rt_model rt_model_t; typedef struct _rt_watch rt_watch_t; typedef struct _rt_signal rt_signal_t; typedef struct _rt_scope rt_scope_t; typedef struct _rt_nexus rt_nexus_t; typedef struct _rt_source rt_source_t; typedef struct _rt_proc rt_proc_t; typedef struct _rt_alias rt_alias_t; typedef struct _rt_implicit rt_implicit_t; typedef struct _rt_resolution rt_resolution_t; typedef struct _rt_trigger rt_trigger_t; typedef struct _rt_prop rt_prop_t; typedef struct _rt_conv_func rt_conv_func_t; typedef struct waveform waveform_t; typedef struct sens_list sens_list_t; typedef struct _vcode_unit *vcode_unit_t; typedef struct _cover_data cover_data_t; typedef struct _cover_item cover_item_t; typedef struct _cover_scope cover_scope_t; typedef struct loc_wr_ctx loc_wr_ctx_t; typedef struct loc_rd_ctx loc_rd_ctx_t; typedef struct ident_wr_ctx *ident_wr_ctx_t; typedef struct ident_rd_ctx *ident_rd_ctx_t; typedef union _number number_t; #endif // _PRIM_H nvc-r1.17.1/src/psl/000077500000000000000000000000001504111170000141245ustar00rootroot00000000000000nvc-r1.17.1/src/psl/Makemodule.am000066400000000000000000000003071504111170000165260ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/psl/psl-node.h \ src/psl/psl-node.c \ src/psl/psl-phase.h \ src/psl/psl-sem.c \ src/psl/psl-lower.c \ src/psl/psl-dump.c \ src/psl/psl-fsm.h \ src/psl/psl-fsm.c nvc-r1.17.1/src/psl/psl-dump.c000066400000000000000000000150331504111170000160330ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "ident.h" #include "phase.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include static void psl_dump_assert(psl_node_t p) { print_syntax("#assert "); psl_dump(psl_value(p)); } static void psl_dump_assume(psl_node_t p) { if (psl_subkind(p) == PSL_GUARANTEE) print_syntax("#assume guarantee"); else print_syntax("#assume"); psl_dump(psl_value(p)); } static void psl_dump_restrict(psl_node_t p) { if (psl_subkind(p) == PSL_GUARANTEE) print_syntax("#restrict guarantee"); else print_syntax("#restrict"); psl_dump(psl_value(p)); } static void psl_dump_fairness(psl_node_t p) { if (psl_flags(p) & PSL_F_STRONG) print_syntax("#strong "); print_syntax("#fairness"); for (int i = 0; i < psl_operands(p); i++) psl_dump(psl_operand(p, i)); } static void psl_dump_cover(psl_node_t p) { print_syntax("#cover "); psl_dump(psl_value(p)); if (psl_has_message(p)) { print_syntax(" #report "); vhdl_dump(psl_message(p), 0); } } static void psl_dump_always(psl_node_t p) { print_syntax("#always "); psl_dump(psl_value(p)); } static void psl_dump_never(psl_node_t p) { print_syntax("#never "); psl_dump(psl_value(p)); } static void psl_dump_logical(psl_node_t p) { static const char *map[] = { "->", "<->", "and", "or" }; psl_dump(psl_operand(p, 0)); print_syntax(" %s (", map[psl_subkind(p)]); psl_dump(psl_operand(p, 1)); print_syntax(")"); } static void psl_dump_next(psl_node_t p) { print_syntax("#next "); if (psl_has_delay(p)) { print_syntax("["); psl_dump(psl_delay(p)); print_syntax("] "); } psl_dump(psl_value(p)); } static void psl_dump_next_a(psl_node_t p) { print_syntax("#next_a "); if (psl_has_delay(p)) { print_syntax("["); psl_dump(psl_delay(p)); print_syntax("] "); } psl_dump(psl_value(p)); } static void psl_dump_next_event(psl_node_t p) { print_syntax("#next_event ("); psl_dump(psl_value(p)); print_syntax(")"); } static void psl_dump_until(psl_node_t p) { print_syntax("("); psl_dump(psl_operand(p, 0)); print_syntax(" #until"); if (psl_flags(p) & PSL_F_STRONG) print_syntax("!"); if (psl_flags(p) & PSL_F_INCLUSIVE) print_syntax("_"); print_syntax(" "); psl_dump(psl_operand(p, 1)); print_syntax(")"); } static void psl_dump_before(psl_node_t p) { print_syntax("("); psl_dump(psl_operand(p, 0)); print_syntax(" #before"); if (psl_flags(p) & PSL_F_STRONG) print_syntax("!"); if (psl_flags(p) & PSL_F_INCLUSIVE) print_syntax("_"); print_syntax(" "); psl_dump(psl_operand(p, 1)); print_syntax(")"); } static void psl_dump_abort(psl_node_t p) { print_syntax("("); psl_dump(psl_operand(p, 0)); if (psl_subkind(p) == PSL_ABORT_SYNC) print_syntax(" #sync_abort"); else print_syntax(" #async_abort"); print_syntax(" "); psl_dump(psl_operand(p, 1)); print_syntax(")"); } static void psl_dump_sere(psl_node_t p) { print_syntax("{"); const int n = psl_operands(p); for (int i = 0; i < n; i++) { if (i > 0) { static const char *map[] = { ";", ":", "|", "&&", "&", " within " }; print_syntax("%s", map[psl_subkind(p)]); } psl_dump(psl_operand(p, i)); } print_syntax("}"); } static void psl_dump_repeat(psl_node_t p) { psl_dump(psl_value(p)); switch (psl_subkind(p)) { case PSL_TIMES_REPEAT: print_syntax("[*"); if (psl_has_delay(p)) psl_dump(psl_delay(p)); print_syntax("]"); break; default: should_not_reach_here(); } } static void psl_dump_clock_decl(psl_node_t p) { print_syntax("#default #clock #is "); vhdl_dump(psl_tree(p), 0); } static void psl_dump_range(psl_node_t p) { psl_dump(psl_left(p)); print_syntax(" to "); psl_dump(psl_right(p)); } static void psl_dump_proc_block(psl_node_t p) { psl_dump(psl_value(p)); print_syntax(" [["); tree_t b = psl_tree(p); const int ndecls = tree_decls(b); for (int i = 0; i < ndecls; i++) vhdl_dump(tree_decl(b, i), 0); const int nstmts = tree_stmts(b); for (int i = 0; i < nstmts; i++) vhdl_dump(tree_stmt(b, i), 0); print_syntax("]]"); } static void psl_dump_clocked(psl_node_t p) { psl_dump(psl_value(p)); if (psl_has_ref(p)) print_syntax("/*@(default clock)*/"); else { print_syntax("@"); vhdl_dump(psl_tree(p), 0); } } void psl_dump(psl_node_t p) { switch (psl_kind(p)) { case P_ASSERT: psl_dump_assert(p); break; case P_ASSUME: psl_dump_assume(p); break; case P_RESTRICT: psl_dump_restrict(p); break; case P_FAIRNESS: psl_dump_fairness(p); break; case P_COVER: psl_dump_cover(p); break; case P_ALWAYS: psl_dump_always(p); break; case P_NEVER: psl_dump_never(p); break; case P_HDL_EXPR: vhdl_dump(psl_tree(p), 0); break; case P_LOGICAL: psl_dump_logical(p); break; case P_NEXT: psl_dump_next(p); break; case P_NEXT_A: psl_dump_next_a(p); break; case P_NEXT_EVENT: psl_dump_next_event(p); break; case P_UNTIL: psl_dump_until(p); break; case P_BEFORE: psl_dump_before(p); break; case P_ABORT: psl_dump_abort(p); break; case P_CLOCK_DECL: psl_dump_clock_decl(p); break; case P_SERE: psl_dump_sere(p); break; case P_REPEAT: psl_dump_repeat(p); break; case P_RANGE: psl_dump_range(p); break; case P_PROC_BLOCK: psl_dump_proc_block(p); break; case P_CLOCKED: psl_dump_clocked(p); break; default: print_syntax("\n"); fflush(stdout); fatal_trace("cannot dump %s", psl_kind_str(psl_kind(p))); } } nvc-r1.17.1/src/psl/psl-fsm.c000066400000000000000000000636111504111170000156600ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "mask.h" #include "option.h" #include "phase.h" #include "psl/psl-fsm.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include #include #include #include #define CANNOT_HANDLE(p) do { \ fatal_at(psl_loc(p), "cannot handle PSL kind %s in %s", \ psl_kind_str(psl_kind(p)), __FUNCTION__); \ } while (0) static fsm_state_t *build_node(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p); static void psl_simplify(psl_fsm_t *fsm); static fsm_state_t *add_state(psl_fsm_t *fsm, psl_node_t where) { fsm_state_t *s = pool_calloc(fsm->pool, sizeof(fsm_state_t)); s->id = fsm->next_id++; s->where = where; *(fsm->tail) = s; fsm->tail = &(s->next); return s; } static bool same_guard(psl_guard_t g1, psl_guard_t g2) { if (g1 == g2) return true; const guard_kind_t g1_kind = psl_guard_kind(g1); const guard_kind_t g2_kind = psl_guard_kind(g2); if (g1_kind != g2_kind) return false; else if (g1_kind != GUARD_BINOP) return false; const guard_binop_t *bop1 = psl_guard_binop(g1); const guard_binop_t *bop2 = psl_guard_binop(g1); if (bop1->kind != bop2->kind) return false; return same_guard(bop1->left, bop2->left) && same_guard(bop1->right, bop2->right); } static void add_edge(psl_fsm_t *fsm, fsm_state_t *from, fsm_state_t *to, edge_kind_t kind, psl_guard_t guard) { fsm_edge_t **p = &(from->edges); for (; *p; p = &((*p)->next)) { if ((*p)->kind != kind || (*p)->dest != to) continue; else if (same_guard((*p)->guard, guard)) return; // Duplicate edge } fsm_edge_t *e = pool_malloc(fsm->pool, sizeof(fsm_edge_t)); e->next = *p; e->kind = kind; e->dest = to; e->guard = guard; *p = e; } static int64_t get_number(tree_t t) { int64_t result = 0; if (!folded_int(t, &result)) error_at(tree_loc(t), "static value of PSL Number is not known"); else if (result < 0) warn_at(tree_loc(t), "PSL Number %"PRIi64" is negative", result); return result; } static psl_guard_t make_binop_guard(psl_fsm_t *fsm, binop_kind_t kind, psl_guard_t left, psl_guard_t right) { if (left == NULL) return right; else if (right == NULL || left == right) return left; guard_binop_t *bop = pool_malloc(fsm->pool, sizeof(guard_binop_t)); bop->kind = kind; bop->left = left; bop->right = right; return tag_pointer(bop, GUARD_BINOP); } static inline psl_guard_t or_guard(psl_fsm_t *fsm, psl_guard_t left, psl_guard_t right) { return make_binop_guard(fsm, BINOP_OR, left, right); } static inline psl_guard_t and_guard(psl_fsm_t *fsm, psl_guard_t left, psl_guard_t right) { return make_binop_guard(fsm, BINOP_AND, left, right); } static psl_guard_t not_guard(psl_guard_t g) { assert(psl_guard_kind(g) == GUARD_EXPR); psl_node_t p = psl_guard_expr(g); return tag_pointer(p, p == NULL ? GUARD_FALSE : GUARD_NOT); } static psl_guard_t build_else_guard(psl_fsm_t *fsm, fsm_state_t *state) { psl_guard_t g = NULL; for (fsm_edge_t *e = state->edges; e; e = e->next) g = and_guard(fsm, g, not_guard(e->guard)); return g; } static void connect_abort(psl_fsm_t *fsm, fsm_state_t *from, fsm_state_t *to, psl_node_t guard, bit_mask_t *visited) { if (from->edges == NULL) return; // Final state else if (mask_test_and_set(visited, from->id)) return; // Cycle for (fsm_edge_t *e = from->edges; e; e = e->next) connect_abort(fsm, e->dest, to, guard, visited); add_edge(fsm, from, to, EDGE_EPSILON, guard); } static void connect_default(psl_fsm_t *fsm, fsm_state_t *from, fsm_state_t *to, bit_mask_t *visited) { if (from->edges == NULL) return; // Final state else if (mask_test_and_set(visited, from->id)) return; // Cycle bool have_def = false; for (fsm_edge_t *e = from->edges; e; e = e->next) { connect_default(fsm, e->dest, to, visited); have_def |= e->guard == NULL; } if (!have_def) add_edge(fsm, from, to, EDGE_NEXT, build_else_guard(fsm, from)); } static fsm_state_t *intersect_fsm(psl_fsm_t *fsm, fsm_state_t *initial, fsm_state_t *l_initial, fsm_state_t *l_final, fsm_state_t *r_initial, fsm_state_t *r_final) { // See chapter 3.5 of "Martin, J.C. (2003) Introduction to languages // and the theory of computation" for basic idea. ihash_t *map = ihash_new((fsm->next_id - initial->id) * 2); // Remove all epsilon transitions before continuing l_final->accept = true; r_final->accept = true; psl_simplify(fsm); fsm_state_t *final = add_state(fsm, l_final->where); typedef struct { fsm_state_t *left; fsm_state_t *right; fsm_state_t *into; } work_item_t; SCOPED_A(work_item_t) worklist = AINIT; const work_item_t seed = { l_initial, r_initial, initial }; APUSH(worklist, seed); while (worklist.count > 0) { const work_item_t wi = APOP(worklist); for (fsm_edge_t *e1 = wi.left->edges; e1; e1 = e1->next) { for (fsm_edge_t *e2 = wi.right->edges; e2; e2 = e2->next) { fsm_state_t *dest; if (e1->dest == e2->dest) dest = e1->dest; else { const uint64_t key = (uint64_t)e1->dest->id << 32 | e2->dest->id; if ((dest = ihash_get(map, key)) == NULL) { dest = add_state(fsm, wi.left->where); DEBUG_ONLY(dest->mergekey = key); ihash_put(map, key, dest); const work_item_t new = { e1->dest, e2->dest, dest }; APUSH(worklist, new); } } assert(e1->kind == e2->kind); psl_guard_t guard = and_guard(fsm, e1->guard, e2->guard); add_edge(fsm, wi.into, dest, e1->kind, guard); } } if (wi.left->accept && wi.right->accept) { psl_guard_t guard = and_guard(fsm, wi.left->guard, wi.right->guard); add_edge(fsm, wi.into, final, EDGE_EPSILON, guard); } } ihash_free(map); return final; } static fsm_state_t *build_logical(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { psl_node_t lhs = psl_operand(p, 0); psl_node_t rhs = psl_operand(p, 1); switch (psl_subkind(p)) { case PSL_LOGIC_IFF: { // Only legal with Boolean HDL expression fsm_state_t *left = add_state(fsm, p); fsm_state_t *right = add_state(fsm, p); fsm_state_t *accept = add_state(fsm, p); add_edge(fsm, state, left, EDGE_EPSILON, lhs); add_edge(fsm, state, right, EDGE_EPSILON, rhs); add_edge(fsm, left, accept, EDGE_EPSILON, rhs); add_edge(fsm, right, accept, EDGE_EPSILON, lhs); psl_guard_t def = build_else_guard(fsm, state); add_edge(fsm, state, accept, EDGE_EPSILON, def); return accept; } case PSL_LOGIC_IF: { fsm_state_t *left = add_state(fsm, p); fsm_state_t *right = build_node(fsm, left, rhs); add_edge(fsm, state, left, EDGE_EPSILON, lhs); psl_guard_t def = build_else_guard(fsm, state); add_edge(fsm, state, right, EDGE_EPSILON, def); return right; } case PSL_LOGIC_OR: { fsm_state_t *accept = add_state(fsm, p), *final; // At least one operand must be Boolean if (psl_kind(lhs) == P_HDL_EXPR) { add_edge(fsm, state, accept, EDGE_EPSILON, lhs); final = build_node(fsm, state, rhs); } else { add_edge(fsm, state, accept, EDGE_EPSILON, rhs); final = build_node(fsm, state, lhs); } add_edge(fsm, final, accept, EDGE_EPSILON, NULL); return accept; } default: CANNOT_HANDLE(p); } } static fsm_state_t *build_until(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { psl_node_t lhs = psl_operand(p, 0); psl_node_t rhs = psl_operand(p, 1); if (psl_flags(p) & PSL_F_INCLUSIVE) { fsm_state_t *test = add_state(fsm, p); add_edge(fsm, state, test, EDGE_EPSILON, lhs); fsm_state_t *new = add_state(fsm, p); add_edge(fsm, test, new, EDGE_NEXT, rhs); add_edge(fsm, test, state, EDGE_NEXT, NULL); return new; } else { fsm_state_t *new = add_state(fsm, p); add_edge(fsm, state, new, EDGE_NEXT, rhs); add_edge(fsm, state, state, EDGE_NEXT, lhs); return new; } } static fsm_state_t *build_abort(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { psl_node_t lhs = psl_operand(p, 0); psl_node_t rhs = psl_operand(p, 1); fsm_state_t *final = build_node(fsm, state, lhs); fsm_state_t *sink = add_state(fsm, p); sink->accept = true; LOCAL_BIT_MASK visited; mask_init(&visited, fsm->next_id); connect_abort(fsm, state, sink, rhs, &visited); return final; } static fsm_state_t *build_sere(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { const psl_sere_kind_t kind = psl_subkind(p); const int nops = psl_operands(p); switch (kind) { case PSL_SERE_FUSION: case PSL_SERE_CONCAT: { for (int i = 0; i < nops; i++) { fsm_state_t *new = build_node(fsm, state, psl_operand(p, i)); if (i + 1 < nops && new != state) { const edge_kind_t ekind = kind == PSL_SERE_FUSION ? EDGE_EPSILON : EDGE_NEXT; state = add_state(fsm, p); add_edge(fsm, new, state, ekind, NULL); } else state = new; } return state; } case PSL_SERE_EQU_AND: { assert(nops == 2); fsm_state_t *l_initial = add_state(fsm, p); fsm_state_t *l_final = build_node(fsm, l_initial, psl_operand(p, 0)); fsm_state_t *r_initial = add_state(fsm, p); fsm_state_t *r_final = build_node(fsm, r_initial, psl_operand(p, 1)); return intersect_fsm(fsm, state, l_initial, l_final, r_initial, r_final); } default: CANNOT_HANDLE(p); } } static void get_repeat_bounds(psl_node_t p, int *low, int *high, bool *infinite, bool *noncon, bool *goto_rep) { psl_repeat_t kind = psl_subkind(p); *low = 0; *high = 0; *noncon = false; *goto_rep = false; *infinite = false; switch (kind) { case PSL_PLUS_REPEAT: *low = 1; *high = INT32_MAX; break; case PSL_GOTO_REPEAT: *goto_rep = true; // Fall-through case PSL_EQUAL_REPEAT: *noncon = true; // Fall-through case PSL_TIMES_REPEAT: if (psl_has_delay(p)) { psl_node_t count = psl_delay(p); switch (psl_kind(count)) { case P_RANGE: *low = get_number(psl_tree(psl_left(count))); *high = get_number(psl_tree(psl_right(count))); break; case P_HDL_EXPR: *low = *high = get_number(psl_tree(count)); break; default: should_not_reach_here(); } } else { *low = 0; *high = INT32_MAX; } break; default: CANNOT_HANDLE(p); } if (*high == INT32_MAX) { *infinite = true; *high = *low; } } static fsm_state_t *build_repeat(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { int low, high; bool infinite, noncon, goto_rep; get_repeat_bounds(p, &low, &high, &infinite, &noncon, &goto_rep); fsm_state_t *skip = (high > low) ? add_state(fsm, p) : NULL; fsm_state_t *initial = state; fsm_state_t *last_but_one = NULL; psl_node_t seq = psl_value(p); for (int i = 0; i < high; i++) { bool is_last = (i == high - 1) ? true : false; last_but_one = state; state = build_node(fsm, state, seq); if (noncon) { fsm_state_t *wait = add_state(fsm, p); psl_guard_t guard = build_else_guard(fsm, last_but_one); add_edge(fsm, last_but_one, wait, EDGE_EPSILON, guard); add_edge(fsm, wait, last_but_one, EDGE_NEXT, NULL); } if (!is_last) { if (i >= low - 1) add_edge(fsm, state, skip, EDGE_EPSILON, NULL); fsm_state_t *curr = state; state = add_state(fsm, p); add_edge(fsm, curr, state, EDGE_NEXT, NULL); } else if (noncon && !goto_rep) { assert(psl_kind(seq) == P_HDL_EXPR); fsm_state_t *aux = add_state(fsm, p); fsm_state_t *dead = add_state(fsm, p); fsm_state_t *wait = add_state(fsm, p); add_edge(fsm, state, aux, EDGE_NEXT, NULL); add_edge(fsm, aux, dead, EDGE_EPSILON, seq); add_edge(fsm, aux, wait, EDGE_EPSILON, build_else_guard(fsm, aux)); add_edge(fsm, wait, aux, EDGE_NEXT, NULL); add_edge(fsm, wait, state, EDGE_EPSILON, NULL); } } if (skip) add_edge(fsm, skip, state, EDGE_EPSILON, NULL); if (initial != state) { if (low == 0) add_edge(fsm, initial, state, EDGE_EPSILON, NULL); if (infinite) add_edge(fsm, state, last_but_one, EDGE_NEXT, NULL); } return state; } static fsm_state_t *build_next(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { if (psl_has_delay(p)) { const int cycles = get_number(psl_tree(psl_delay(p))); for (int i = 0; i < cycles; i++) { fsm_state_t *new = add_state(fsm, p); add_edge(fsm, state, new, EDGE_NEXT, NULL); state = new; } } else { fsm_state_t *new = add_state(fsm, p); add_edge(fsm, state, new, EDGE_NEXT, NULL); state = new; } return build_node(fsm, state, psl_value(p)); } static fsm_state_t *build_eventually(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { fsm_state_t *wait = add_state(fsm, p); fsm_state_t *accept = build_node(fsm, wait, psl_value(p)); LOCAL_BIT_MASK visited; mask_init(&visited, fsm->next_id); connect_default(fsm, wait, wait, &visited); add_edge(fsm, state, wait, EDGE_NEXT, NULL); wait->strong = true; return accept; } static fsm_state_t *build_before(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { fsm_state_t *accept = add_state(fsm, p); fsm_state_t *fail = add_state(fsm, p); state->strong = !!(psl_flags(p) & PSL_F_STRONG); if (psl_flags(p) & PSL_F_INCLUSIVE) { add_edge(fsm, state, accept, EDGE_EPSILON, psl_operand(p, 0)); add_edge(fsm, state, fail, EDGE_EPSILON, psl_operand(p, 1)); } else { add_edge(fsm, state, fail, EDGE_EPSILON, psl_operand(p, 1)); add_edge(fsm, state, accept, EDGE_EPSILON, psl_operand(p, 0)); } add_edge(fsm, state, state, EDGE_NEXT, NULL); return accept; } static fsm_state_t *build_suffix_impl(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { fsm_state_t *left = build_node(fsm, state, psl_operand(p, 0)); fsm_state_t *right = add_state(fsm, p); fsm_state_t *vacuous = add_state(fsm, p); if (psl_subkind(p) == PSL_SUFFIX_OVERLAP) add_edge(fsm, left, right, EDGE_EPSILON, NULL); else add_edge(fsm, left, right, EDGE_NEXT, NULL); LOCAL_BIT_MASK visited; mask_init(&visited, fsm->next_id); connect_default(fsm, state, vacuous, &visited); fsm_state_t *final = build_node(fsm, right, psl_operand(p, 1)); add_edge(fsm, vacuous, final, EDGE_EPSILON, NULL); return final; } static fsm_state_t *build_node(psl_fsm_t *fsm, fsm_state_t *state, psl_node_t p) { switch (psl_kind(p)) { case P_NEVER: fsm->kind = FSM_NEVER; return build_node(fsm, state, psl_value(p)); case P_ALWAYS: fsm->kind = FSM_ALWAYS; return build_node(fsm, state, psl_value(p)); case P_HDL_EXPR: { fsm_state_t *new = add_state(fsm, p); add_edge(fsm, state, new, EDGE_EPSILON, p); return new; } case P_NEXT: return build_next(fsm, state, p); case P_SERE: return build_sere(fsm, state, p); case P_REPEAT: return build_repeat(fsm, state, p); case P_LOGICAL: return build_logical(fsm, state, p); case P_UNTIL: return build_until(fsm, state, p); case P_EVENTUALLY: return build_eventually(fsm, state, p); case P_ABORT: return build_abort(fsm, state, p); case P_BEFORE: return build_before(fsm, state, p); case P_SUFFIX_IMPL: return build_suffix_impl(fsm, state, p); case P_CLOCKED: return build_node(fsm, state, psl_value(p)); default: CANNOT_HANDLE(p); } } #ifdef DEBUG static void psl_loops_dfs(psl_fsm_t *fsm, fsm_state_t *state, bit_mask_t *discovered, bit_mask_t *finished) { mask_set(discovered, state->id); bool have_epsilon = false, have_unguarded = false; for (fsm_edge_t *e = state->edges; e; e = e->next) { if (e->kind != EDGE_EPSILON || mask_test(finished, e->dest->id)) continue; else if (mask_test(discovered, e->dest->id)) { psl_fsm_dump(fsm, "loop"); fatal_trace("detected loop in PSL state machine %d -> %d", state->id, e->dest->id); } else psl_loops_dfs(fsm, e->dest, discovered, finished); if (have_unguarded || (have_epsilon && e->guard == NULL)) { psl_fsm_dump(fsm, "unguarded"); fatal_trace("unguarded epsilon edge must be only epsilon edge " "(%d -> %d)", state->id, e->dest->id); } have_epsilon = true; have_unguarded |= (e->guard == NULL); } mask_clear(discovered, state->id); mask_set(finished, state->id); } static void psl_detect_loops(psl_fsm_t *fsm) { LOCAL_BIT_MASK discovered, finished; mask_init(&discovered, fsm->next_id); mask_init(&finished, fsm->next_id); for (fsm_state_t *it = fsm->states; it; it = it->next) { if (!mask_test(&finished, it->id)) psl_loops_dfs(fsm, it, &discovered, &finished); } assert(mask_popcount(&discovered) == 0); assert(mask_popcount(&finished) == fsm->next_id); } #endif static void psl_simplify_dfs(psl_fsm_t *fsm, fsm_state_t *state, bit_mask_t *visited) { mask_set(visited, state->id); for (fsm_edge_t **p = &(state->edges), *e = *p; e; e = *p) { if (e->kind == EDGE_EPSILON) { if (!mask_test(visited, e->dest->id)) psl_simplify_dfs(fsm, e->dest, visited); if (e->dest->accept) { psl_guard_t guard = and_guard(fsm, e->guard, e->dest->guard); state->guard = or_guard(fsm, state->guard, guard); state->accept = true; } fsm_edge_t *first = e->dest->edges; if (first == NULL) *p = e->next; else { for (fsm_edge_t *e2 = first->next; e2; e2 = e2->next) { assert(e2->kind != EDGE_EPSILON); psl_guard_t guard = and_guard(fsm, e->guard, e2->guard); add_edge(fsm, state, e2->dest, e2->kind, guard); } assert(first->kind != EDGE_EPSILON); e->kind = first->kind; e->dest = first->dest; e->guard = and_guard(fsm, e->guard, first->guard); p = &(e->next); } } else p = &(e->next); } } static void psl_simplify(psl_fsm_t *fsm) { LOCAL_BIT_MASK visited; mask_init(&visited, fsm->next_id); for (fsm_state_t *it = fsm->states; it; it = it->next) { if (!mask_test(&visited, it->id)) psl_simplify_dfs(fsm, it, &visited); } assert(mask_popcount(&visited) == fsm->next_id); } static void psl_prune_dfs(psl_fsm_t *fsm, fsm_state_t *state, bit_mask_t *visited) { if (mask_test_and_set(visited, state->id)) return; state->next = NULL; *fsm->tail = state; fsm->tail = &(state->next); if (state->accept && state->guard == NULL) state->edges = NULL; // Unreachable for (fsm_edge_t *e = state->edges; e; e = e->next) { assert(e->kind != EDGE_EPSILON); psl_prune_dfs(fsm, e->dest, visited); } } static void psl_prune(psl_fsm_t *fsm) { LOCAL_BIT_MASK visited; mask_init(&visited, fsm->next_id); fsm_state_t *s0 = fsm->states; assert(s0->initial); mask_clearall(&visited); fsm->next_id = 0; fsm->tail = &(fsm->states); fsm->states = NULL; psl_prune_dfs(fsm, s0, &visited); for (fsm_state_t *it = fsm->states; it; it = it->next) it->id = fsm->next_id++; } psl_fsm_t *psl_fsm_new(psl_node_t p, ident_t label) { psl_fsm_t *fsm = xcalloc(sizeof(psl_fsm_t)); fsm->pool = pool_new(); fsm->label = label; fsm->tail = &(fsm->states); fsm->src = p; fsm->kind = psl_kind(p) == P_COVER ? FSM_COVER : FSM_BARE; fsm_state_t *initial = add_state(fsm, p), *final = initial; initial->initial = true; final = build_node(fsm, initial, psl_value(p)); final->accept = true; DEBUG_ONLY(psl_detect_loops(fsm)); const bool verbose = opt_get_verbose(OPT_PSL_VERBOSE, istr(label)); if (verbose) psl_fsm_dump(fsm, "initial"); psl_simplify(fsm); psl_prune(fsm); if (verbose) psl_fsm_dump(fsm, "final"); return fsm; } void psl_fsm_free(psl_fsm_t *fsm) { pool_free(fsm->pool); free(fsm); } bool psl_fsm_repeating(psl_fsm_t *fsm) { return fsm->kind == FSM_COVER || fsm->kind == FSM_ALWAYS || fsm->kind == FSM_NEVER; } guard_kind_t psl_guard_kind(psl_guard_t g) { const unsigned tag = pointer_tag(g); switch (tag) { case GUARD_EXPR: case GUARD_BINOP: case GUARD_NOT: case GUARD_FALSE: return tag; default: should_not_reach_here(); } } const guard_binop_t *psl_guard_binop(psl_guard_t g) { assert(psl_guard_kind(g) == GUARD_BINOP); return untag_pointer(g, guard_binop_t); } psl_node_t psl_guard_expr(psl_guard_t g) { switch (pointer_tag(g)) { case GUARD_EXPR: case GUARD_NOT: return untag_pointer(g, struct _psl_node); default: should_not_reach_here(); } } // LCOV_EXCL_START ///////////////////////////////////////////////////////////// static void psl_dump_guard(psl_guard_t g, text_buf_t *tb, bool nested) { switch (psl_guard_kind(g)) { case GUARD_NOT: tb_cat(tb, "!"); // Fall-through case GUARD_EXPR: { psl_node_t p = psl_guard_expr(g); assert(psl_kind(p) == P_HDL_EXPR); tree_t t = psl_tree(p); const bool is_cconv = tree_kind(t) == T_FCALL && is_well_known(tree_ident(t)) == W_OP_CCONV; vhdl_dump(is_cconv ? tree_param(t, 0) : t, 0); } break; case GUARD_BINOP: { if (nested) tb_append(tb, '('); const guard_binop_t *bop = psl_guard_binop(g); psl_dump_guard(bop->left, tb, true); switch (bop->kind) { case BINOP_AND: tb_cat(tb, " && "); break; case BINOP_OR: tb_cat(tb, " || "); break; default: should_not_reach_here(); } psl_dump_guard(bop->right, tb, true); if (nested) tb_append(tb, ')'); } break; case GUARD_FALSE: tb_cat(tb, "false"); break; default: should_not_reach_here(); } } static void psl_dump_label(FILE *f, psl_guard_t g) { LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); psl_dump_guard(g, tb, false); for (const char *p = tb_get(tb); *p; p++) { if (*p == '"') fputs("\\\"", f); else fputc(*p, f); } capture_syntax(NULL); } void psl_fsm_dump(psl_fsm_t *fsm, const char *tag) { #ifdef HAVE_POPEN char *cmd LOCAL = xasprintf("dot -Tsvg -o %s.%s.svg", istr(fsm->label), tag); FILE *f = popen(cmd, "w"); if (f == NULL) fatal_errno("failed to start dot process"); fprintf(f, "digraph psl {\n"); for (fsm_state_t *s = fsm->states; s; s = s->next) { if (s->accept || s->initial) { fprintf(f, "%d [", s->id); if (s->accept) fprintf(f, "peripheries=2,"); if (s->initial) fprintf(f, "style=bold,"); if (s->guard != NULL) { fprintf(f, "label=\"%d: ", s->id); psl_dump_label(f, s->guard); fputs("\",", f); } fputs("];\n", f); } #ifdef DEBUG else if (s->mergekey != 0) fprintf(f, "%d [label=\"%d (%d ∩ %d)\"]", s->id, s->id, (int)(s->mergekey >> 32), (int)s->mergekey); #endif for (fsm_edge_t *e = s->edges; e; e = e->next) { fprintf(f, "%d -> %d [", s->id, e->dest->id); if (e->guard != NULL) { fprintf(f, "label=\""); psl_dump_label(f, e->guard); fputs("\",", f); } if (e->kind == EDGE_EPSILON) fputs("style=dashed,", f); fprintf(f, "];\n"); } } fprintf(f, "}\n"); if (pclose(f) != 0) fatal_errno("dot process failed"); debugf("wrote PSL state machine graph to %s.%s.svg", istr(fsm->label), tag); #else warnf("PSL state machine graph is not supported on this platform"); #endif } // LCOV_EXCL_STOP ////////////////////////////////////////////////////////////// nvc-r1.17.1/src/psl/psl-fsm.h000066400000000000000000000042621504111170000156620ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _PSL_FSM_H #define _PSL_FSM_H #include "prim.h" typedef struct _fsm_edge fsm_edge_t; typedef struct _fsm_state fsm_state_t; typedef enum { EDGE_NEXT, EDGE_EPSILON } edge_kind_t; typedef enum { GUARD_EXPR = 0b00, GUARD_BINOP = 0b01, GUARD_NOT = 0b10, GUARD_FALSE = 0b11, } guard_kind_t; typedef void *psl_guard_t; typedef enum { BINOP_AND, BINOP_OR, } binop_kind_t; typedef struct { binop_kind_t kind; psl_guard_t left; psl_guard_t right; } guard_binop_t; typedef struct _fsm_edge { fsm_edge_t *next; fsm_state_t *dest; edge_kind_t kind; psl_guard_t guard; } fsm_edge_t; typedef struct _fsm_state { unsigned id; fsm_state_t *next; fsm_edge_t *edges; psl_node_t where; psl_guard_t guard; bool initial; bool accept; bool strong; #ifdef DEBUG uint64_t mergekey; #endif } fsm_state_t; typedef enum { FSM_BARE, FSM_ALWAYS, FSM_NEVER, FSM_COVER } fsm_kind_t; typedef struct { fsm_state_t *states; fsm_state_t **tail; mem_pool_t *pool; ident_t label; psl_node_t src; unsigned next_id; fsm_kind_t kind; } psl_fsm_t; psl_fsm_t *psl_fsm_new(psl_node_t p, ident_t label); void psl_fsm_free(psl_fsm_t *fsm); void psl_fsm_dump(psl_fsm_t *fsm, const char *tag); bool psl_fsm_repeating(psl_fsm_t *fsm); guard_kind_t psl_guard_kind(psl_guard_t g); const guard_binop_t *psl_guard_binop(psl_guard_t g); psl_node_t psl_guard_expr(psl_guard_t g); #endif // _PSL_FSM_H nvc-r1.17.1/src/psl/psl-lower.c000066400000000000000000000403751504111170000162250ustar00rootroot00000000000000// // Copyright (C) 2023-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "cov/cov-api.h" #include "lib.h" #include "lower.h" #include "option.h" #include "psl/psl-fsm.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include "tree.h" #include "type.h" #include "vcode.h" #include #include #define PSL_BLOCK_CASE 1 #define PSL_BLOCK_ABORT 2 #define PSL_BLOCK_PREV 3 static void psl_wait_cb(tree_t t, void *ctx) { lower_unit_t *lu = ctx; vcode_reg_t nets_reg = lower_lvalue(lu, t); vcode_reg_t count_reg = emit_const(vtype_offset(), type_width(tree_type(t))); emit_sched_event(nets_reg, count_reg); } static vcode_reg_t psl_lower_boolean(lower_unit_t *lu, psl_node_t p) { assert(psl_kind(p) == P_HDL_EXPR); vcode_reg_t test_reg = lower_rvalue(lu, psl_tree(p)); if (!vtype_eq(vcode_reg_type(test_reg), vtype_bool())) { vcode_type_t std_logic = vtype_int(0, 8); vcode_reg_t one_reg = emit_const(std_logic, 3); return emit_cmp(VCODE_CMP_EQ, test_reg, one_reg); } else return test_reg; } vcode_reg_t psl_lower_union(lower_unit_t *lu, psl_node_t p) { vcode_reg_t lhs = lower_rvalue(lu, psl_tree(psl_operand(p, 0))); vcode_reg_t rhs = lower_rvalue(lu, psl_tree(psl_operand(p, 1))); ident_t func = ident_new("NVC.RANDOM.GET_RANDOM()B"); vcode_reg_t context_reg = emit_link_package(ident_new("NVC.RANDOM")); vcode_reg_t args[] = { context_reg }; vcode_type_t vbool = vtype_bool(); vcode_reg_t sel = emit_fcall(func, vbool, vbool, args, 1); return emit_select(sel, lhs, rhs); } static vcode_reg_t psl_debug_locus(psl_node_t p) { return emit_debug_locus(psl_to_object(p)); } static vcode_reg_t psl_assert_severity(void) { return emit_const(vtype_int(0, 3), 2); } static vcode_reg_t psl_lower_guard(lower_unit_t *lu, psl_guard_t g) { switch (psl_guard_kind(g)) { case GUARD_EXPR: return psl_lower_boolean(lu, psl_guard_expr(g)); case GUARD_BINOP: { const guard_binop_t *bop = psl_guard_binop(g); vcode_reg_t left_reg = psl_lower_guard(lu, bop->left); vcode_reg_t right_reg = psl_lower_guard(lu, bop->right); switch (bop->kind) { case BINOP_AND: return emit_and(left_reg, right_reg); case BINOP_OR: return emit_or(left_reg, right_reg); default: should_not_reach_here(); } } case GUARD_NOT: return emit_not(psl_lower_boolean(lu, psl_guard_expr(g))); default: should_not_reach_here(); } } static void psl_lower_cover(lower_unit_t *lu, psl_node_t p, cover_data_t *cover, cover_scope_t *cscope) { if (psl_has_message(p)) { tree_t m = psl_message(p); vcode_reg_t msg_reg = lower_rvalue(lu, m); vcode_type_t voffset = vtype_offset(); vcode_reg_t count_reg = emit_const(voffset, type_width(tree_type(m))); vcode_reg_t severity_reg = emit_const(vtype_int(0, 3), 0); vcode_reg_t locus = psl_debug_locus(p); emit_report(msg_reg, count_reg, severity_reg, locus); } if (!cover_enabled(cover, COVER_MASK_FUNCTIONAL)) return; cover_item_t *item = cover_add_items_for(cover, cscope, psl_to_object(p), COV_ITEM_FUNCTIONAL); if (item == NULL) return; emit_cover_stmt(item->tag); } static void psl_enter_state(fsm_state_t *state) { vcode_reg_t strong_reg = VCODE_INVALID_REG; if (state->strong) strong_reg = emit_const(vtype_bool(), 1); vcode_type_t vint32 = vtype_int(INT32_MIN, INT32_MAX); emit_enter_state(emit_const(vint32, state->id), strong_reg); } static void psl_lower_state(lower_unit_t *lu, psl_fsm_t *fsm, fsm_state_t *state, vcode_block_t *state_bb, cover_data_t *cover, cover_scope_t *cscope) { emit_comment("Property state %d", state->id); if (state->initial && psl_fsm_repeating(fsm)) psl_enter_state(state); vcode_type_t vbool = vtype_bool(); vcode_reg_t vfalse = emit_const(vbool, 0); vcode_reg_t vtrue = emit_const(vbool, 1); if (state->accept) { vcode_block_t cont_bb = vcode_active_block(); if (state->guard != NULL) { vcode_block_t accept_bb = emit_block(); cont_bb = emit_block(); vcode_reg_t guard_reg = psl_lower_guard(lu, state->guard); emit_cond(guard_reg, accept_bb, cont_bb); vcode_select_block(accept_bb); } if (fsm->kind == FSM_COVER) psl_lower_cover(lu, fsm->src, cover, cscope); else if (fsm->kind == FSM_NEVER) { vcode_reg_t severity_reg = psl_assert_severity(); vcode_reg_t locus = psl_debug_locus(fsm->src); emit_assert(vfalse, VCODE_INVALID_REG, VCODE_INVALID_REG, severity_reg, locus, VCODE_INVALID_REG, VCODE_INVALID_REG); } emit_return(VCODE_INVALID_REG); if (state->guard == NULL) return; else vcode_select_block(cont_bb); } vcode_reg_t taken_reg = vfalse; for (fsm_edge_t *e = state->edges; e; e = e->next) { assert(e->kind == EDGE_NEXT); if (e->guard != NULL) { vcode_reg_t guard_reg = psl_lower_guard(lu, e->guard); vcode_block_t enter_bb = emit_block(); vcode_block_t skip_bb = emit_block(); emit_cond(guard_reg, enter_bb, skip_bb); vcode_select_block(enter_bb); psl_enter_state(e->dest); emit_jump(skip_bb); vcode_select_block(skip_bb); taken_reg = emit_or(taken_reg, guard_reg); } else { psl_enter_state(e->dest); taken_reg = vtrue; } } if (fsm->kind != FSM_COVER && fsm->kind != FSM_NEVER) { vcode_reg_t severity_reg = psl_assert_severity(); vcode_reg_t locus = psl_debug_locus(state->where); emit_assert(taken_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, severity_reg, locus, VCODE_INVALID_REG, VCODE_INVALID_REG); } emit_return(VCODE_INVALID_REG); } static psl_node_t psl_outer_async_abort(psl_node_t p) { switch (psl_kind(p)) { case P_ABORT: if (psl_subkind(p) == PSL_ABORT_ASYNC) return psl_operand(p, 1); else return NULL; case P_ALWAYS: case P_NEVER: case P_ASSUME: case P_COVER: case P_CLOCKED: return psl_outer_async_abort(psl_value(p)); default: return NULL; } } static vcode_reg_t psl_lower_async_abort(unit_registry_t *ur, lower_unit_t *parent, psl_node_t hdl_expr, ident_t name_prefix) { vcode_state_t state; vcode_state_save(&state); vcode_unit_t context = get_vcode(parent); vcode_select_unit(context); ident_t prefix = vcode_unit_name(context); ident_t name = ident_prefix(name_prefix, ident_new("async_abort"), '$'); vcode_unit_t vu = emit_function(name, psl_to_object(hdl_expr), context); vcode_set_result(vtype_bool()); vcode_type_t vcontext = vtype_context(prefix); emit_param(vcontext, vcontext, ident_new("context")); lower_unit_t *lu = lower_unit_new(ur, parent, vu, NULL, NULL); unit_registry_put(ur, lu); vcode_reg_t result_reg = psl_lower_boolean(lu, hdl_expr); emit_return(result_reg); unit_registry_finalise(ur, lu); vcode_state_restore(&state); vcode_reg_t context_reg = emit_context_upref(1); vcode_reg_t args[] = { context_reg }; return emit_function_trigger(name, args, ARRAY_LEN(args)); } static vcode_reg_t psl_lower_prev_shift_reg(lower_unit_t *lu, tree_t expr, int cycles) { vcode_state_t state; vcode_state_save(&state); vcode_select_block(PSL_BLOCK_PREV); type_t type = tree_type(expr); vcode_type_t vtype = lower_type(type); vcode_type_t vbounds = lower_bounds(type); vcode_var_t *vars LOCAL = xmalloc_array(cycles, sizeof(vcode_var_t)); for (int i = 0; i < cycles; i++) vars[i] = emit_var(vtype, vbounds, ident_uniq("prev"), 0); vcode_reg_t cur_reg = lower_rvalue(lu, expr); vcode_reg_t count_reg = VCODE_INVALID_REG; const bool is_array = type_is_array(type); if (is_array) { int64_t length; if (!folded_length(range_of(type, 0), &length)) fatal_at(tree_loc(expr), "sorry, only constant length arrays " "are supported"); count_reg = emit_const(vtype_offset(), length); } for (int i = 0; i < cycles - 1; i++) { if (is_array) { vcode_reg_t src_ptr = emit_index(vars[i + 1], VCODE_INVALID_REG); vcode_reg_t dst_ptr = emit_index(vars[i], VCODE_INVALID_REG); emit_copy(dst_ptr, src_ptr, count_reg); } else { vcode_reg_t tmp = emit_load(vars[i + 1]); emit_store(tmp, vars[i]); } } if (is_array) { vcode_reg_t dst_ptr = emit_index(vars[cycles - 1], VCODE_INVALID_REG); emit_copy(dst_ptr, cur_reg, count_reg); } else emit_store(cur_reg, vars[cycles - 1]); vcode_state_restore(&state); if (is_array) return emit_index(vars[0], VCODE_INVALID_REG); else return emit_load(vars[0]); } vcode_reg_t psl_lower_fcall(lower_unit_t *lu, psl_node_t p) { assert(psl_kind(p) == P_BUILTIN_FCALL); tree_t expr = psl_tree(psl_operand(p, 0)); switch (psl_subkind(p)) { case PSL_BUILTIN_PREV: { int num = 1; if (psl_operands(p) > 1) num = assume_int(psl_tree(psl_operand(p, 1))); if (num > 512) fatal_at(psl_loc(p), "sorry, no more than 512 cycles " "are supported"); return psl_lower_prev_shift_reg(lu, expr, num); } case PSL_BUILTIN_ROSE: { vcode_reg_t prev = psl_lower_prev_shift_reg(lu, expr, 1); vcode_reg_t prev_n = emit_not(prev); vcode_reg_t rhs = lower_rvalue(lu, expr); return emit_and(prev_n, rhs); } case PSL_BUILTIN_FELL: { vcode_reg_t prev = psl_lower_prev_shift_reg(lu, expr, 1); vcode_reg_t expr_n = emit_not(lower_rvalue(lu, expr)); return emit_and(prev, expr_n); } case PSL_BUILTIN_STABLE: { vcode_reg_t prev = psl_lower_prev_shift_reg(lu, expr, 1); vcode_reg_t rhs = lower_rvalue(lu, expr); return emit_cmp(VCODE_CMP_EQ, prev, rhs); } default: fatal_at(psl_loc(p), "sorry, this built-in function is not supported"); } } void psl_lower_directive(unit_registry_t *ur, lower_unit_t *parent, cover_data_t *cover, tree_t wrapper) { psl_node_t p = tree_psl(wrapper); ident_t label = tree_ident(wrapper); cover_scope_t *parent_cscope = lower_get_cover_scope(parent); cover_scope_t *cscope = cover_create_scope(cover, parent_cscope, wrapper, NULL); psl_fsm_t *fsm = psl_fsm_new(p, label); vcode_unit_t context = get_vcode(parent); ident_t prefix = vcode_unit_name(context); ident_t name = ident_prefix(prefix, label, '.'); vcode_unit_t vu = emit_property(name, psl_to_object(p), context); lower_unit_t *lu = lower_unit_new(ur, parent, vu, NULL, NULL); unit_registry_put(ur, lu); vcode_type_t vcontext = vtype_context(prefix); emit_param(vcontext, vcontext, ident_new("context")); vcode_type_t vint32 = vtype_int(INT32_MIN, INT32_MAX); vcode_reg_t state_reg = emit_param(vint32, vint32, ident_new("state")); vcode_block_t case_bb = emit_block(); vcode_block_t abort_bb = emit_block(); vcode_block_t prev_bb = emit_block(); assert(case_bb == PSL_BLOCK_CASE); assert(abort_bb == PSL_BLOCK_ABORT); assert(prev_bb == PSL_BLOCK_PREV); // Only handle a single clock for the whole property psl_node_t top = psl_value(p); assert(psl_kind(top) == P_CLOCKED); assert(psl_has_ref(top)); psl_node_t clk = psl_ref(top); tree_t clk_expr = psl_tree(psl_ref(top)); int hops; vcode_var_t trigger_var = lower_search_vcode_obj(clk, lu, &hops); assert(trigger_var != VCODE_INVALID_VAR); emit_comment("Reset property"); build_wait(clk_expr, psl_wait_cb, lu); vcode_reg_t trigger_ptr = emit_var_upref(hops, trigger_var); vcode_reg_t trigger_reg = emit_load_indirect(trigger_ptr); // Only handle async_abort at the top level psl_node_t async_abort = psl_outer_async_abort(top); if (async_abort != NULL) { build_wait(psl_tree(async_abort), psl_wait_cb, lu); vcode_reg_t abort_reg = psl_lower_async_abort(ur, parent, async_abort, name); trigger_reg = emit_or_trigger(trigger_reg, abort_reg); } emit_add_trigger(trigger_reg); emit_jump(prev_bb); vcode_select_block(case_bb); vcode_block_t *state_bb LOCAL = xmalloc_array(fsm->next_id + 1, sizeof(vcode_block_t)); vcode_reg_t *state_ids LOCAL = xmalloc_array(fsm->next_id + 1, sizeof(vcode_reg_t)); for (int i = 0; i < fsm->next_id; i++) { state_bb[i] = emit_block(); state_ids[i] = emit_const(vint32, i); } state_bb[fsm->next_id] = prev_bb; state_ids[fsm->next_id] = emit_const(vint32, fsm->next_id); bool strong = false; for (fsm_state_t *s = fsm->states; s; s = s->next) { vcode_select_block(state_bb[s->id]); psl_lower_state(lu, fsm, s, state_bb, cover, cscope); strong |= s->strong; } vcode_select_block(abort_bb); if (strong) { vcode_reg_t severity_reg = psl_assert_severity(); vcode_reg_t false_reg = emit_const(vtype_bool(), 0); vcode_reg_t locus = psl_debug_locus(fsm->src); emit_assert(false_reg, VCODE_INVALID_REG, VCODE_INVALID_REG, severity_reg, locus, VCODE_INVALID_REG, VCODE_INVALID_REG); emit_return(VCODE_INVALID_REG); } else emit_unreachable(VCODE_INVALID_REG); vcode_select_block(prev_bb); const bool has_prev = vcode_count_ops() > 0; emit_return(emit_const(vint32, fsm->next_id + 1)); vcode_select_block(case_bb); if (has_prev) emit_enter_state(emit_const(vint32, fsm->next_id), VCODE_INVALID_REG); emit_case(state_reg, abort_bb, state_ids, state_bb, fsm->next_id + 1); unit_registry_finalise(ur, lu); psl_fsm_free(fsm); } static void psl_lower_clock_func(lower_unit_t *lu, object_t *obj) { psl_node_t p = psl_from_object(obj); assert(psl_kind(p) == P_CLOCK_DECL); vcode_unit_t context = vcode_unit_context(get_vcode(lu)); ident_t prefix = vcode_unit_name(context); vcode_type_t vcontext = vtype_context(prefix); emit_param(vcontext, vcontext, ident_new("context")); vcode_set_result(vtype_bool()); vcode_reg_t clk_reg = lower_rvalue(lu, psl_tree(p)); emit_return(clk_reg); } static void psl_lower_clock_decl(unit_registry_t *ur, lower_unit_t *parent, psl_node_t p, ident_t label) { vcode_unit_t context = get_vcode(parent); ident_t prefix = vcode_unit_name(context); ident_t name = ident_prefix(prefix, label, '.'); unit_registry_defer(ur, name, parent, emit_function, psl_lower_clock_func, NULL, psl_to_object(p)); vcode_type_t vtrigger = vtype_trigger(); vcode_var_t var = emit_var(vtrigger, vtrigger, label, 0); vcode_reg_t context_reg = emit_context_upref(0); vcode_reg_t args[] = { context_reg }; vcode_reg_t trigger_reg = emit_function_trigger(name, args, ARRAY_LEN(args)); emit_store(trigger_reg, var); lower_put_vcode_obj(p, var, parent); } void psl_lower_decl(unit_registry_t *ur, lower_unit_t *parent, psl_node_t p, ident_t label) { switch (psl_kind(p)) { case P_CLOCK_DECL: psl_lower_clock_decl(ur, parent, p, label); break; default: fatal_at(psl_loc(p), "cannot lower PSL declaration kind %s", psl_kind_str(psl_kind(p))); } } nvc-r1.17.1/src/psl/psl-node.c000066400000000000000000000225511504111170000160160ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "object.h" #include "psl/psl-node.h" static const imask_t has_map[P_LAST_PSL_KIND] = { // P_ASSERT (I_VALUE | I_MESSAGE), // P_ASSUME (I_SUBKIND | I_VALUE | I_MESSAGE), // P_RESTRICT (I_SUBKIND | I_VALUE | I_MESSAGE), // P_FAIRNESS (I_PARAMS | I_MESSAGE | I_FLAGS), // P_COVER (I_VALUE | I_MESSAGE), // P_ALWAYS (I_VALUE), // P_HDL_EXPR (I_FOREIGN | I_CLASS), // P_PROPERTY_DECL (I_VALUE | I_IDENT | I_PORTS), // P_SEQUENCE_DECL (I_VALUE | I_IDENT | I_PORTS), // P_CLOCK_DECL (I_FOREIGN), // P_NEXT (I_VALUE | I_DELAY | I_FLAGS), // P_NEVER (I_VALUE), // P_EVENTUALLY (I_VALUE), // P_NEXT_A (I_VALUE | I_DELAY | I_FLAGS), // P_NEXT_E (I_VALUE | I_DELAY | I_FLAGS), // P_NEXT_EVENT (I_VALUE | I_DELAY | I_FLAGS), // P_SERE (I_SUBKIND | I_PARAMS), // P_REPEAT (I_SUBKIND | I_DELAY | I_VALUE), // P_PROPERTY_INST (I_REF | I_PARAMS), // P_SEQUENCE_INST (I_REF | I_PARAMS), // P_UNION (I_PARAMS), // P_BUILTIN_FCALL (I_SUBKIND | I_PARAMS), // P_VALUE_SET (I_SUBKIND | I_PARAMS), // P_PARAM (I_FOREIGN | I_VALUE), // P_UNTIL (I_PARAMS | I_FLAGS), // P_ABORT (I_PARAMS | I_SUBKIND), // P_BEFORE (I_PARAMS | I_FLAGS), // P_SUFFIX_IMPL (I_SUBKIND | I_PARAMS), // P_LOGICAL (I_SUBKIND | I_PARAMS), // P_RANGE (I_LEFT | I_RIGHT), // P_PROC_BLOCK (I_FOREIGN | I_VALUE), // P_PARAM_SERE (I_SUBKIND | I_PARAMS | I_VALUE), // P_CLOCKED (I_FOREIGN | I_VALUE | I_REF), // P_ENDPOINT_DECL (I_IDENT | I_VALUE), }; static const char *kind_text_map[P_LAST_PSL_KIND] = { "P_ASSERT", "P_ASSUME", "P_RESTRICT", "P_FAIRNESS", "P_COVER", "P_ALWAYS", "P_HDL_EXPR", "P_PROPERTY_DECL", "P_SEQUENCE_DECL", "P_CLOCK_DECL", "P_NEXT", "P_NEVER", "P_EVENTUALLY", "P_NEXT_A", "P_NEXT_E", "P_NEXT_EVENT", "P_SERE", "P_REPEAT", "P_PROPERTY_INST", "P_SEQUENCE_INST", "P_UNION", "P_BUILTIN_FCALL", "P_VALUE_SET", "P_PARAM_DECL", "P_UNTIL", "P_ABORT", "P_BEFORE", "P_SUFFIX_IMPL", "P_LOGICAL", "P_RANGE", "P_PROC_BLOCK", "P_PARAM_SERE", "P_CLOCKED", "P_ENDPOINT_DECL", }; static const change_allowed_t change_allowed[] = { { -1, -1 } }; struct _psl_node { object_t object; }; struct _tree { object_t object; }; struct _type { object_t object; }; object_class_t psl_object = { .name = "psl", .change_allowed = change_allowed, .has_map = has_map, .kind_text_map = kind_text_map, .has_loc = true, .tag = OBJECT_TAG_PSL, .last_kind = P_LAST_PSL_KIND }; static inline psl_node_t psl_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _psl_node, object); } static inline void psl_array_add(item_t *item, psl_node_t p) { obj_array_add(&(item->obj_array), &(p->object)); } static inline tree_t tree_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _tree, object); } static inline void tree_array_add(item_t *item, tree_t t) { obj_array_add(&(item->obj_array), &(t->object)); } psl_node_t psl_new(psl_kind_t kind) { object_t *o = object_new(NULL, &psl_object, kind); return container_of(o, struct _psl_node, object); } psl_kind_t psl_kind(psl_node_t p) { return p->object.kind; } const char *psl_kind_str(psl_kind_t kind) { return kind_text_map[kind]; } const loc_t *psl_loc(psl_node_t p) { assert(p != NULL); return &(p->object.loc); } void psl_set_loc(psl_node_t p, const loc_t *loc) { assert(p != NULL); assert(loc != NULL); p->object.loc = *loc; } unsigned psl_subkind(psl_node_t p) { return lookup_item(&psl_object, p, I_SUBKIND)->ival; } void psl_set_subkind(psl_node_t p, unsigned sub) { lookup_item(&psl_object, p, I_SUBKIND)->ival = sub; } psl_type_t psl_type(psl_node_t p) { return lookup_item(&psl_object, p, I_CLASS)->ival; } void psl_set_type(psl_node_t p, psl_type_t type) { lookup_item(&psl_object, p, I_CLASS)->ival = type; } bool psl_has_tree(psl_node_t p) { return lookup_item(&psl_object, p, I_FOREIGN)->object != NULL; } tree_t psl_tree(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_FOREIGN); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void psl_set_tree(psl_node_t p, tree_t t) { assert(p != NULL); lookup_item(&psl_object, p, I_FOREIGN)->object = &(t->object); object_write_barrier(&(p->object), &(t->object)); } psl_node_t psl_value(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_VALUE); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } void psl_set_value(psl_node_t p, psl_node_t v) { lookup_item(&psl_object, p, I_VALUE)->object = &(v->object); object_write_barrier(&(p->object), &(v->object)); } psl_node_t psl_delay(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_DELAY); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } void psl_set_delay(psl_node_t p, psl_node_t d) { lookup_item(&psl_object, p, I_DELAY)->object = &(d->object); object_write_barrier(&(p->object), &(d->object)); } bool psl_has_delay(psl_node_t p) { return lookup_item(&psl_object, p, I_DELAY)->object != NULL; } unsigned psl_operands(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_PARAMS); return obj_array_count(item->obj_array); } psl_node_t psl_operand(psl_node_t p, unsigned n) { item_t *item = lookup_item(&psl_object, p, I_PARAMS); return psl_array_nth(item, n); } void psl_add_operand(psl_node_t p, psl_node_t o) { assert(o != NULL); psl_array_add(lookup_item(&psl_object, p, I_PARAMS), o); object_write_barrier(&(p->object), &(o->object)); } tree_t psl_message(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_MESSAGE); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool psl_has_message(psl_node_t p) { return lookup_item(&psl_object, p, I_MESSAGE)->object != NULL; } void psl_set_message(psl_node_t p, tree_t m) { lookup_item(&psl_object, p, I_MESSAGE)->object = &(m->object); object_write_barrier(&(p->object), &(m->object)); } unsigned psl_ports(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_PORTS); return obj_array_count(item->obj_array); } tree_t psl_port(psl_node_t p, unsigned n) { item_t *item = lookup_item(&psl_object, p, I_PORTS); return tree_array_nth(item, n); } void psl_add_port(psl_node_t p, tree_t o) { assert(o != NULL); tree_array_add(lookup_item(&psl_object, p, I_PORTS), o); object_write_barrier(&(p->object), &(o->object)); } ident_t psl_ident(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_IDENT); assert(item->ident != NULL); return item->ident; } bool psl_has_ident(psl_node_t p) { return lookup_item(&psl_object, p, I_IDENT)->ident != NULL; } void psl_set_ident(psl_node_t p, ident_t i) { lookup_item(&psl_object, p, I_IDENT)->ident = i; } void psl_set_ref(psl_node_t p, psl_node_t r) { lookup_item(&psl_object, p, I_REF)->object = &(r->object); object_write_barrier(&(p->object), &(r->object)); } bool psl_has_ref(psl_node_t p) { return lookup_item(&psl_object, p, I_REF)->object != NULL; } psl_node_t psl_ref(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_REF); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } psl_node_t psl_left(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_LEFT); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } void psl_set_left(psl_node_t p, psl_node_t left) { lookup_item(&psl_object, p, I_LEFT)->object = &(left->object); object_write_barrier(&(p->object), &(left->object)); } psl_node_t psl_right(psl_node_t p) { item_t *item = lookup_item(&psl_object, p, I_RIGHT); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } void psl_set_right(psl_node_t p, psl_node_t right) { lookup_item(&psl_object, p, I_RIGHT)->object = &(right->object); object_write_barrier(&(p->object), &(right->object)); } psl_flags_t psl_flags(psl_node_t p) { return lookup_item(&psl_object, p, I_FLAGS)->ival; } void psl_set_flag(psl_node_t p, psl_flags_t mask) { lookup_item(&psl_object, p, I_FLAGS)->ival |= mask; } object_t *psl_to_object(psl_node_t p) { return &(p->object); } psl_node_t psl_from_object(object_t *obj) { assert(obj != NULL); if (obj->tag == OBJECT_TAG_PSL) return container_of(obj, struct _psl_node, object); else return NULL; } nvc-r1.17.1/src/psl/psl-node.h000066400000000000000000000102511504111170000160150ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _PSL_NODE_H #define _PSL_NODE_H #include "prim.h" typedef enum { P_ASSERT, P_ASSUME, P_RESTRICT, P_FAIRNESS, P_COVER, P_ALWAYS, P_HDL_EXPR, P_PROPERTY_DECL, P_SEQUENCE_DECL, P_CLOCK_DECL, P_NEXT, P_NEVER, P_EVENTUALLY, P_NEXT_A, P_NEXT_E, P_NEXT_EVENT, P_SERE, P_REPEAT, P_PROPERTY_INST, P_SEQUENCE_INST, P_UNION, P_BUILTIN_FCALL, P_VALUE_SET, P_PARAM_DECL, P_UNTIL, P_ABORT, P_BEFORE, P_SUFFIX_IMPL, P_LOGICAL, P_RANGE, P_PROC_BLOCK, P_PARAM_SERE, P_CLOCKED, P_ENDPOINT_DECL, P_LAST_PSL_KIND } psl_kind_t; typedef enum { PSL_IMPL_IF, PSL_IMPL_IFF, } psl_impl_kind_t; typedef enum { PSL_LOGIC_IF, PSL_LOGIC_IFF, PSL_LOGIC_AND, PSL_LOGIC_OR, } psl_logic_t; typedef enum { PSL_TYPE_HDLTYPE, PSL_TYPE_BOOLEAN, PSL_TYPE_BIT, PSL_TYPE_BITVECTOR, PSL_TYPE_NUMERIC, PSL_TYPE_STRING, PSL_TYPE_SEQUENCE, PSL_TYPE_PROPERTY, PSL_TYPE_ANY, } psl_type_t; typedef enum { PSL_GUARANTEE, PSL_NO_GUARANTEE, } psl_guarantee_t; typedef enum { PSL_PLUS_REPEAT, PSL_TIMES_REPEAT, PSL_GOTO_REPEAT, PSL_EQUAL_REPEAT } psl_repeat_t; typedef enum { PSL_SERE_CONCAT, PSL_SERE_FUSION, PSL_SERE_OR, PSL_SERE_EQU_AND, PSL_SERE_NEQ_AND, PSL_SERE_WITHIN, } psl_sere_kind_t; typedef enum { PSL_BUILTIN_NEXT, PSL_BUILTIN_PREV, PSL_BUILTIN_STABLE, PSL_BUILTIN_ROSE, PSL_BUILTIN_FELL, PSL_BUILTIN_ENDED, PSL_BUILTIN_NONDET, PSL_BUILTIN_NONDET_VECTOR } psl_builtin_kind_t; typedef enum { PSL_VALUE_SET_BOOLEAN, PSL_VALUE_SET_EXPLICIT } psl_value_set_kind_t; typedef enum { PSL_ABORT_ASYNC, PSL_ABORT_SYNC, } psl_abort_t; typedef enum { PSL_SUFFIX_OVERLAP, PSL_SUFFIX_NON, } psl_suffix_impl_t; typedef enum { PSL_F_STRONG = (1 << 0), PSL_F_INCLUSIVE = (1 << 1), } psl_flags_t; psl_node_t psl_new(psl_kind_t kind); psl_kind_t psl_kind(psl_node_t p); const char *psl_kind_str(psl_kind_t kind); const loc_t *psl_loc(psl_node_t p); void psl_set_loc(psl_node_t p, const loc_t *loc); unsigned psl_subkind(psl_node_t p); void psl_set_subkind(psl_node_t p, unsigned sub); psl_type_t psl_type(psl_node_t p); void psl_set_type(psl_node_t p, psl_type_t type); tree_t psl_tree(psl_node_t p); bool psl_has_tree(psl_node_t p); void psl_set_tree(psl_node_t p, tree_t t); psl_node_t psl_value(psl_node_t p); void psl_set_value(psl_node_t p, psl_node_t v); psl_node_t psl_delay(psl_node_t p); void psl_set_delay(psl_node_t p, psl_node_t d); bool psl_has_delay(psl_node_t p); unsigned psl_operands(psl_node_t p); psl_node_t psl_operand(psl_node_t p, unsigned n); void psl_add_operand(psl_node_t p, psl_node_t o); tree_t psl_message(psl_node_t p); bool psl_has_message(psl_node_t p); void psl_set_message(psl_node_t, tree_t m); unsigned psl_ports(psl_node_t p); tree_t psl_port(psl_node_t p, unsigned n); void psl_add_port(psl_node_t p, tree_t o); ident_t psl_ident(psl_node_t p); bool psl_has_ident(psl_node_t p); void psl_set_ident(psl_node_t p, ident_t i); void psl_set_ref(psl_node_t p, psl_node_t r); bool psl_has_ref(psl_node_t p); psl_node_t psl_ref(psl_node_t p); psl_node_t psl_left(psl_node_t p); void psl_set_left(psl_node_t p, psl_node_t left); psl_node_t psl_right(psl_node_t p); void psl_set_right(psl_node_t p, psl_node_t right); psl_flags_t psl_flags(psl_node_t p); void psl_set_flag(psl_node_t p, psl_flags_t mask); object_t *psl_to_object(psl_node_t p); psl_node_t psl_from_object(object_t *obj); #endif // _PSL_NODE_H nvc-r1.17.1/src/psl/psl-phase.h000066400000000000000000000027441504111170000162000ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _PSL_PHASE_H #define _PSL_PHASE_H #include "prim.h" typedef int32_t vcode_reg_t; // Check PSL statements for errors. void psl_check(psl_node_t p, nametab_t *tab); // Print PSL expression for debugging. void psl_dump(psl_node_t p); // Convert PSL verification directive to vcode unit. void psl_lower_directive(unit_registry_t *ur, lower_unit_t *parent, cover_data_t *cover, tree_t wrapper); // Convert PSL declaration to vcode variable void psl_lower_decl(unit_registry_t *ur, lower_unit_t *parent, psl_node_t p, ident_t name); // Lower embedded PSL function call vcode_reg_t psl_lower_fcall(lower_unit_t *lu, psl_node_t p); // Lower PSL union expression vcode_reg_t psl_lower_union(lower_unit_t *lu, psl_node_t p); #endif // _PSL_PHASE_H nvc-r1.17.1/src/psl/psl-sem.c000066400000000000000000000350751504111170000156620ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "names.h" #include "phase.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include "type.h" #include static void psl_check_clocked(psl_node_t p, nametab_t *tab, bool toplevel); static void psl_check_static(tree_t t) { switch (tree_kind(t)) { case T_LITERAL: return; case T_FCALL: if (tree_flags(t) & (TREE_F_LOCALLY_STATIC | TREE_F_GLOBALLY_STATIC)) return; break; case T_REF: if (class_of(tree_ref(t)) == C_CONSTANT) return; break; case T_RANGE: { const range_kind_t kind = tree_subkind(t); if (kind == RANGE_TO || kind == RANGE_DOWNTO) { psl_check_static(tree_left(t)); psl_check_static(tree_right(t)); return; } } break; default: break; } error_at(tree_loc(t), "expression must be static"); } static void psl_check_clock_decl(psl_node_t p) { } static void psl_check_property_decl(psl_node_t p) { } static void psl_check_sequence_decl(psl_node_t p, nametab_t *tab) { psl_check(psl_value(p), tab); } static void psl_check_endpoint_decl(psl_node_t p, nametab_t *tab) { psl_check(psl_value(p), tab); error_at(psl_loc(p), "PSL endpoint declarations are not supported as they " "were not part of IEEE Std 1850-2010 or later standards"); } static void psl_check_top_level(psl_node_t p, nametab_t *tab) { if (psl_kind(p) == P_CLOCKED) psl_check_clocked(p, tab, true); else { psl_check(p, tab); static bool warned = false; if (!warned) { diag_t *d = diag_new(DIAG_ERROR, psl_loc(p)); diag_printf(d, "sorry, unclocked properties are not supported"); if (!query_name(tab, well_known(W_DEFAULT_CLOCK), NULL)) diag_hint(d, NULL, "there is no default clock declaration in " "this design unit"); diag_emit(d); warned = true; } } } static void psl_check_assert(psl_node_t p, nametab_t *tab) { psl_check_top_level(psl_value(p), tab); } static void psl_check_assume(psl_node_t p, nametab_t *tab) { psl_check_top_level(psl_value(p), tab); } static void psl_check_restrict(psl_node_t p, nametab_t *tab) { psl_check_top_level(psl_value(p), tab); } static void psl_check_fairness(psl_node_t p) { } static void psl_check_cover(psl_node_t p, nametab_t *tab) { psl_check_top_level(psl_value(p), tab); } static void psl_check_always(psl_node_t p, nametab_t *tab) { psl_check(psl_value(p), tab); } static void psl_check_never(psl_node_t p, nametab_t *tab) { psl_node_t value = psl_value(p); psl_check(value, tab); const psl_kind_t kind = psl_kind(value); if (kind != P_HDL_EXPR && kind != P_SERE) error_at(psl_loc(p), "property is not in the simple subset as the " "operand of never is not a Boolean or Sequence"); } static void psl_check_eventually(psl_node_t p, nametab_t *tab) { psl_node_t value = psl_value(p); psl_check(value, tab); const psl_kind_t kind = psl_kind(value); if (kind != P_HDL_EXPR && kind != P_SERE) error_at(psl_loc(p), "property is not in the simple subset as the " "operand of eventually! is not a Boolean or Sequence"); } static void psl_check_boolean(psl_node_t p, nametab_t *tab) { tree_t value = psl_tree(p); type_t type = solve_psl_condition(tab, &value); if (type_is_none(type)) return; psl_set_tree(p, value); // May be replaced with condition conversion if (!sem_check(value, tab)) return; type_t std_bool = std_type(NULL, STD_BOOLEAN); bool ok = type_eq(type, std_bool); if (!ok && standard() < STD_08) { // Later standards use condition conversion operator type_t std_bit = std_type(NULL, STD_BIT); type_t ulogic = ieee_type(IEEE_STD_ULOGIC); ok = type_eq(type, std_bit) || type_eq(type, ulogic); } if (!ok) error_at(tree_loc(value), "expression must be a PSL Boolean but " "have type %s", type_pp(type)); } static void psl_check_number(psl_node_t p, nametab_t *tab) { tree_t value = psl_tree(p); type_t std_int = std_type(NULL, STD_INTEGER); type_t type = solve_types(tab, value, std_int); if (type_is_none(type)) return; // Prevent cascading errors if (!sem_check(value, tab)) return; if (!type_eq(type, std_int)) { error_at(tree_loc(value), "expression must be a PSL Number but have " "type %s", type_pp(type)); return; } psl_check_static(value); } static void psl_check_bit(psl_node_t p, nametab_t *tab) { tree_t value = psl_tree(p); type_t std_bit = std_type(NULL, STD_BIT); type_t std_ulogic = ieee_type(IEEE_STD_ULOGIC); type_t type = solve_types(tab, value, std_ulogic); if (type_is_none(type)) return; // Prevent cascading errors if (!sem_check(value, tab)) return; if (!type_eq(type, std_ulogic) && !type_eq(type, std_bit)) error_at(tree_loc(value), "expression must be a PSL Bit but have " "type %s", type_pp(type)); } static void psl_check_any(psl_node_t p, nametab_t *tab) { tree_t value = psl_tree(p); type_t type = solve_types(tab, value, NULL); if (type_is_none(type)) return; // Prevent cascading errors if (!sem_check(value, tab)) return; } static void psl_check_hdl_expr(psl_node_t p, nametab_t *tab) { switch (psl_type(p)) { case PSL_TYPE_BOOLEAN: psl_check_boolean(p, tab); break; case PSL_TYPE_NUMERIC: psl_check_number(p, tab); break; case PSL_TYPE_BIT: psl_check_bit(p, tab); break; case PSL_TYPE_ANY: psl_check_any(p, tab); break; default: should_not_reach_here(); } } static void psl_check_range(psl_node_t p, nametab_t *tab) { psl_node_t low = psl_left(p); psl_check(low, tab); psl_node_t high = psl_right(p); psl_check(high, tab); } static void psl_check_property_inst(psl_node_t p) { } static void psl_check_sequence_inst(psl_node_t p) { } static void psl_check_sere(psl_node_t p, nametab_t *tab) { const int nops = psl_operands(p); for (int i = 0; i < nops; i++) psl_check(psl_operand(p, i), tab); } static void psl_check_param_sere(psl_node_t p, nametab_t *tab) { const int nops = psl_operands(p); for (int i = 0; i < nops; i++) psl_check(psl_operand(p, i), tab); psl_check(psl_value(p), tab); } static void psl_check_repeat(psl_node_t p, nametab_t *tab) { psl_node_t value = psl_value(p); psl_check(value, tab); if (psl_has_delay(p)) psl_check(psl_delay(p), tab); switch (psl_subkind(p)) { case PSL_GOTO_REPEAT: if (psl_kind(value) != P_HDL_EXPR) error_at(psl_loc(p), "operand of goto repetition operator must " "be Boolean"); break; case PSL_EQUAL_REPEAT: if (psl_kind(value) != P_HDL_EXPR) error_at(psl_loc(p), "operand of non-consecutive repetition " "operator must be Boolean"); break; } } static void psl_check_logical(psl_node_t p, nametab_t *tab) { assert(psl_operands(p) == 2); psl_node_t left = psl_operand(p, 0); psl_check(left, tab); psl_node_t right = psl_operand(p, 1); psl_check(right, tab); switch (psl_subkind(p)) { case PSL_LOGIC_IFF: if (psl_kind(right) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the " "right hand side of this implication is non-Boolean"); // Fall-through case PSL_LOGIC_IF: if (psl_kind(left) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the " "left hand side of this implication is non-Boolean"); break; case PSL_LOGIC_OR: if (psl_kind(left) != P_HDL_EXPR && psl_kind(right) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as both " "operands of this logical OR are non-Boolean"); break; case PSL_LOGIC_AND: break; } } static void psl_check_next(psl_node_t p, nametab_t *tab) { if (psl_has_delay(p)) psl_check(psl_delay(p), tab); psl_check(psl_value(p), tab); } static void psl_check_next_e(psl_node_t p, nametab_t *tab) { if (psl_has_delay(p)) psl_check(psl_delay(p), tab); psl_node_t value = psl_value(p); psl_check(value, tab); if (psl_kind(value) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the " "operand of this next_e operator is non-Boolean"); } static void psl_check_until(psl_node_t p, nametab_t *tab) { assert(psl_operands(p) == 2); psl_node_t left = psl_operand(p, 0); psl_check(left, tab); psl_node_t right = psl_operand(p, 1); psl_check(right, tab); const psl_flags_t flags = psl_flags(p); if ((flags & PSL_F_INCLUSIVE) && psl_kind(right) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the right " "hand side of this overlapping until operator is non-Boolean"); else if (psl_kind(left) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the left " "hand side of this until operator is non-Boolean"); } static void psl_check_before(psl_node_t p, nametab_t *tab) { assert(psl_operands(p) == 2); psl_node_t left = psl_operand(p, 0); psl_check(left, tab); psl_node_t right = psl_operand(p, 1); psl_check(right, tab); if (psl_kind(left) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the left " "hand side of this before operator is non-Boolean"); else if (psl_kind(right) != P_HDL_EXPR) error_at(psl_loc(p), "property is not in the simple subset as the right " "hand side of this before operator is non-Boolean"); } static void psl_check_abort(psl_node_t p, nametab_t *tab) { assert(psl_operands(p) == 2); psl_node_t left = psl_operand(p, 0); psl_check(left, tab); psl_node_t right = psl_operand(p, 1); psl_check(right, tab); } static void psl_check_suffix_impl(psl_node_t p, nametab_t *tab) { assert(psl_operands(p) == 2); psl_node_t left = psl_operand(p, 0); psl_check(left, tab); const psl_kind_t lkind = psl_kind(left); if (lkind != P_HDL_EXPR && lkind != P_SERE) error_at(psl_loc(left), "left hand side of suffix implication operator " "must be a Sequence"); psl_node_t right = psl_operand(p, 1); psl_check(right, tab); } static void psl_check_param_decl(psl_node_t p, nametab_t *tab) { // TODO } static void psl_check_proc_block(psl_node_t p, nametab_t *tab) { psl_check(psl_value(p), tab); } static void psl_check_clocked(psl_node_t p, nametab_t *tab, bool toplevel) { psl_check(psl_value(p), tab); if (psl_has_tree(p)) psl_check_boolean(p, tab); if (!toplevel) error_at(psl_loc(p), "sorry, clock expressions are only supported at the " "outermost level of a property"); } static void psl_check_builtin_fcall(psl_node_t p, nametab_t *tab) { const int nparams = psl_operands(p); for (int i = 0; i < nparams; i++) psl_check(psl_operand(p, i), tab); } static void psl_check_union(psl_node_t p, nametab_t *tab) { psl_node_t lhs = psl_operand(p, 0); psl_node_t rhs = psl_operand(p, 1); psl_check(lhs, tab); psl_check(rhs, tab); type_t ltype = tree_type(psl_tree(lhs)); type_t rtype = tree_type(psl_tree(rhs)); if (type_is_none(ltype) || type_is_none(rtype)) return; if (!type_eq(ltype, rtype)) { diag_t *d = diag_new(DIAG_ERROR, psl_loc(p)); diag_printf(d, "PSL union operands must be the same type"); diag_hint(d, psl_loc(p), "have %s and %s", type_pp2(ltype, rtype), type_pp2(rtype, ltype)); diag_emit(d); } } void psl_check(psl_node_t p, nametab_t *tab) { switch (psl_kind(p)) { case P_ALWAYS: psl_check_always(p, tab); break; case P_ASSERT: psl_check_assert(p, tab); break; case P_ASSUME: psl_check_assume(p, tab); break; case P_RESTRICT: psl_check_restrict(p, tab); break; case P_FAIRNESS: psl_check_fairness(p); break; case P_COVER: psl_check_cover(p, tab); break; case P_CLOCK_DECL: psl_check_clock_decl(p); break; case P_PROPERTY_DECL: psl_check_property_decl(p); break; case P_SEQUENCE_DECL: psl_check_sequence_decl(p, tab); break; case P_ENDPOINT_DECL: psl_check_endpoint_decl(p, tab); break; case P_HDL_EXPR: psl_check_hdl_expr(p, tab); break; case P_PROPERTY_INST: psl_check_property_inst(p); break; case P_SEQUENCE_INST: psl_check_sequence_inst(p); break; case P_NEVER: psl_check_never(p, tab); break; case P_EVENTUALLY: psl_check_eventually(p, tab); break; case P_SERE: psl_check_sere(p, tab); break; case P_REPEAT: psl_check_repeat(p, tab); break; case P_LOGICAL: psl_check_logical(p, tab); break; case P_NEXT: case P_NEXT_A: case P_NEXT_EVENT: psl_check_next(p, tab); break; case P_NEXT_E: psl_check_next_e(p, tab); break; case P_UNTIL: psl_check_until(p, tab); break; case P_BEFORE: psl_check_before(p, tab); break; case P_ABORT: psl_check_abort(p, tab); break; case P_SUFFIX_IMPL: psl_check_suffix_impl(p, tab); break; case P_PARAM_DECL: psl_check_param_decl(p, tab); break; case P_RANGE: psl_check_range(p, tab); break; case P_PROC_BLOCK: psl_check_proc_block(p, tab); break; case P_PARAM_SERE: psl_check_param_sere(p, tab); break; case P_CLOCKED: psl_check_clocked(p, tab, false); break; case P_BUILTIN_FCALL: psl_check_builtin_fcall(p, tab); break; case P_UNION: psl_check_union(p, tab); break; default: fatal_trace("cannot check PSL kind %s", psl_kind_str(psl_kind(p))); } } nvc-r1.17.1/src/rt/000077500000000000000000000000001504111170000137535ustar00rootroot00000000000000nvc-r1.17.1/src/rt/Makemodule.am000066400000000000000000000011361504111170000163560ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/rt/heap.c \ src/rt/cover.c \ src/rt/wave.c \ src/rt/wave.h \ src/rt/rt.h \ src/rt/heap.h \ src/rt/mspace.h \ src/rt/mspace.c \ src/rt/stdenv.c \ src/rt/standard.c \ src/rt/simpkg.c \ src/rt/standard.c \ src/rt/structs.h \ src/rt/model.h \ src/rt/model.c \ src/rt/fileio.c \ src/rt/fileio.h \ src/rt/printer.h \ src/rt/printer.c \ src/rt/reflect.c \ src/rt/assert.c \ src/rt/assert.h \ src/rt/ename.c \ src/rt/copy.h \ src/rt/copy.c \ src/rt/random.h \ src/rt/random.c if ENABLE_TCL lib_libnvc_a_SOURCES += \ src/rt/shell.h \ src/rt/shell.c endif nvc-r1.17.1/src/rt/assert.c000066400000000000000000000347421504111170000154320ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "jit/jit-exits.h" #include "jit/jit.h" #include "object.h" #include "option.h" #include "psl/psl-node.h" #include "rt/assert.h" #include "rt/model.h" #include "rt/rt.h" #include "rt/structs.h" #include "tree.h" #include #include #include #include #include typedef struct _format_part format_part_t; typedef enum { PART_TEXT, PART_REPLACEMENT } part_kind_t; typedef struct { char variable; char fill; char align; int width; uint64_t precision; const char *units; } replacement_t; typedef struct _format_part { format_part_t *next; part_kind_t kind; union { char *text; replacement_t rep; }; } format_part_t; static const struct { const char *name; uint64_t value; } precision[] = { { "fs", 1 }, { "ps", 1000 }, { "ns", 1000000 }, { "us", 1000000000 }, { "ms", UINT64_C(1000000000000) }, { "sec", UINT64_C(1000000000000000) }, { "m", UINT64_C(60000000000000000) }, { "min", UINT64_C(60000000000000000) }, // Non-standard { "hr", UINT64_C(3600000000000000000) }, }; static format_part_t *format[SEVERITY_FAILURE + 1]; static vhdl_severity_t exit_severity = SEVERITY_FAILURE; static vhdl_severity_t status_severity = SEVERITY_ERROR; static unsigned counts[SEVERITY_FAILURE + 1]; static unsigned enable_mask = ~0u; static void free_format(format_part_t *f) { for (format_part_t *tmp; f; f = tmp) { tmp = f->next; if (f->kind == PART_TEXT) free(f->text); free(f); } } static format_part_t *check_format(const char *str) { // string_replacement ::= "{" variable [format_specification] "}" // format_specification ::= ":" [ [fill] align] [width] ["." precision] // variable ::= "s" | "S" | "r" | "t" | "i" // fill ::= graphic_character // align ::= "<" | ">" | "^" // precision ::= "fs" | "ps" | "ns" | "us" | "ms" | "sec" | "m" | "hr" format_part_t *result = NULL, **f = &result; const char *p = str, *start = str; while (*p) { if (*p++ != '{') continue; *f = xcalloc(sizeof(format_part_t)); (*f)->kind = PART_TEXT; (*f)->text = xstrndup(start, p - start - 1); f = &((*f)->next); *f = xcalloc(sizeof(format_part_t)); (*f)->kind = PART_REPLACEMENT; switch (((*f)->rep.variable = *p++)) { case 's': case 'S': case 'r': case 't': case 'i': break; default: errorf("invalid string replacement variable '%c'", (*f)->rep.variable); goto failed; } (*f)->rep.fill = ' '; (*f)->rep.align = ((*f)->rep.variable == 't' ? '>' : '<'); if (*p == ':') { p++; int flen = 0; for (const char *pp = p; *pp && *pp != '}'; pp++) flen++; if (flen >= 2 && (p[1] == '<' || p[1] == '>' || p[1] == '^')) { // Fill and align (*f)->rep.fill = *p++; (*f)->rep.align = *p++; } else if (p[0] == '<' || p[0] == '>' || p[0] == '^') { // Align only (*f)->rep.fill = ' '; (*f)->rep.align = *p++; } if (isdigit_iso88591(*p)) (*f)->rep.width = strtol(p, (char **)&p, 10); if (*p == '.') { p++; for (int i = 0; i < ARRAY_LEN(precision); i++) { const size_t len = strlen(precision[i].name); if (strncmp(p, precision[i].name, len) == 0) { (*f)->rep.precision = precision[i].value; (*f)->rep.units = precision[i].name; p += len; break; } } if ((*f)->rep.precision == 0) { errorf("invalid precision '%.*s' in format string", (int)(strchrnul(p, '}') - p), p); goto failed; } else if ((*f)->rep.variable != 't') { errorf("precision is only valid for 't' variable"); goto failed; } } } if (*p != '}') { errorf("expected '}' but found '%c' in format string", *p); goto failed; } start = ++p; f = &((*f)->next); } *f = xcalloc(sizeof(format_part_t)); (*f)->kind = PART_TEXT; (*f)->text = xstrndup(start, p - start); return result; failed: free_format(result); return NULL; } DLLEXPORT void _std_env_set_assert_format_valid(jit_scalar_t *args) { uint8_t level = args[2].integer; const uint8_t *format_ptr = args[3].pointer; int64_t format_len = ffi_array_length(args[5].integer); int8_t *valid = args[6].pointer; assert(level <= SEVERITY_FAILURE); char *cstr LOCAL = null_terminate(format_ptr, format_len); format_part_t *f = check_format(cstr); if (f == NULL) *valid = 0; else { free_format(format[level]); format[level] = f; *valid = 1; } } DLLEXPORT void _std_env_set_assert_format(jit_scalar_t *args) { uint8_t level = args[2].integer; const uint8_t *format_ptr = args[3].pointer; int64_t format_len = ffi_array_length(args[5].integer); assert(level <= SEVERITY_FAILURE); char *cstr LOCAL = null_terminate(format_ptr, format_len); format_part_t *f = check_format(cstr); if (f == NULL) jit_msg(NULL, DIAG_FATAL, "invalid assert format: %.*s", (int)format_len, format_ptr); free_format(format[level]); format[level] = f; } DLLEXPORT void _std_env_get_assert_format(jit_scalar_t *args, tlab_t *tlab) { uint8_t level = args[1].integer; assert(level <= SEVERITY_FAILURE); if (format[level] == NULL) ffi_return_string("", args, tlab); else { LOCAL_TEXT_BUF tb = tb_new(); for (format_part_t *p = format[level]; p; p = p->next) { switch (p->kind) { case PART_TEXT: tb_cat(tb, p->text); break; case PART_REPLACEMENT: tb_append(tb, '{'); tb_append(tb, p->rep.variable); tb_append(tb, ':'); tb_append(tb, p->rep.fill); tb_append(tb, p->rep.align); if (p->rep.width > 0) tb_printf(tb, "%d", p->rep.width); if (p->rep.precision > 0) { for (int i = 0; i < ARRAY_LEN(precision); i++) { if (p->rep.precision == precision[i].value) { tb_printf(tb, ".%s", precision[i].name); break; } } } tb_append(tb, '}'); break; } } ffi_return_string(tb_get(tb), args, tlab); } } static const char *get_severity_string(vhdl_severity_t severity) { static const char *levels[] = { "note", "warning", "error", "failure" }; assert(severity < ARRAY_LEN(levels)); return levels[severity]; } static void apply_format(diag_t *d, format_part_t *p, vhdl_severity_t severity, const uint8_t *msg, size_t msg_len) { diag_clear(d); // Suppress all default output diag_show_source(d, false); LOCAL_TEXT_BUF tb = tb_new(); for (; p; p = p->next) { switch (p->kind) { case PART_TEXT: diag_printf(d, "%s", p->text); break; case PART_REPLACEMENT: { tb_rewind(tb); switch (p->rep.variable) { case 'r': tb_catn(tb, (const char *)msg, msg_len); break; case 's': tb_cat(tb, get_severity_string(severity)); tb_downcase(tb); break; case 'S': tb_cat(tb, get_severity_string(severity)); tb_upcase(tb); break; case 't': { rt_model_t *model = get_model_or_null(); const uint64_t now = model ? model_now(model, NULL) : 0; if (p->rep.precision == 0) tb_printf(tb, "%"PRIi64" fs", now); else { const double frac = (double)now / (double)p->rep.precision; tb_printf(tb, "%.*g %s", DBL_DIG, frac, p->rep.units); } } break; case 'i': { rt_proc_t *proc = get_active_proc(); if (proc != NULL) { // The LRM says this produces the "instance path" // but that is not defined anywhere get_instance_name(proc->scope, tb); } } break; } const int tlen = tb_len(tb); int lpad = 0, rpad = 0; switch (p->rep.align) { case '>': lpad = p->rep.width - tlen; break; case '<': rpad = p->rep.width - tlen; break; case '^': lpad = (p->rep.width - tlen) / 2; rpad = p->rep.width - tlen - MAX(lpad, 0); break; } while (lpad-- > 0) diag_printf(d, "%c", p->rep.fill); diag_write(d, tb_get(tb), tlen); while (rpad-- > 0) diag_printf(d, "%c", p->rep.fill); } break; } } } diag_level_t get_diag_severity(vhdl_severity_t severity) { switch (severity) { case SEVERITY_NOTE: return DIAG_NOTE; case SEVERITY_WARNING: return DIAG_WARN; case SEVERITY_ERROR: return DIAG_ERROR; case SEVERITY_FAILURE: return DIAG_FAILURE; } return DIAG_ERROR; } void emit_vhdl_diag(diag_t *d, vhdl_severity_t severity) { if (severity >= exit_severity && severity < SEVERITY_FAILURE) diag_hint(d, NULL, "this will be treated as a fatal error due to " "$bold$--exit-severity=%s$$", get_severity_string(exit_severity)); diag_emit(d); relaxed_add(&counts[severity], 1); if (severity >= exit_severity) jit_abort_with_status(EXIT_FAILURE); } void x_report(const uint8_t *msg, int32_t msg_len, int8_t severity, object_t *where) { assert(severity <= SEVERITY_FAILURE); if (!(enable_mask & (1 << severity))) return; const diag_level_t level = get_diag_severity(severity); diag_t *d = diag_new(level, &(where->loc)); psl_node_t p = psl_from_object(where); if (p != NULL && psl_kind(p) == P_COVER) diag_write(d, (const char *)msg, msg_len); else if (format[severity] != NULL) { apply_format(d, format[severity], severity, msg, msg_len); diag_show_source(d, false); } else { diag_write(d, (const char *)msg, msg_len); diag_show_source(d, false); } emit_vhdl_diag(d, severity); } void x_assert_fail(const uint8_t *msg, int32_t msg_len, int8_t severity, int64_t hint_left, int64_t hint_right, int8_t hint_valid, object_t *where) { // LRM 93 section 8.2 // The error message consists of at least // a) An indication that this message is from an assertion // b) The value of the severity level // c) The value of the message string // d) The name of the design unit containing the assertion assert(severity <= SEVERITY_FAILURE); if (!(enable_mask & (1 << severity))) return; const diag_level_t level = get_diag_severity(severity); diag_t *d = diag_new(level, &(where->loc)); if (format[severity] != NULL) apply_format(d, format[severity], severity, msg, msg_len); else if (msg == NULL) { psl_node_t p = psl_from_object(where); if (p == NULL) diag_printf(d, "Assertion violation."); else diag_printf(d, "PSL assertion failed"); } else { diag_write(d, (const char *)msg, msg_len); // Assume we don't want to dump the source code if the user // provided their own message diag_show_source(d, false); } if (hint_valid) { tree_t tree = tree_from_object(where); assert(tree != NULL); assert(tree_kind(tree) == T_FCALL); type_t p0_type = tree_type(tree_value(tree_param(tree, 0))); type_t p1_type = tree_type(tree_value(tree_param(tree, 1))); LOCAL_TEXT_BUF tb = tb_new(); to_string(tb, p0_type, hint_left); switch (tree_subkind(tree_ref(tree))) { case S_SCALAR_EQ: tb_cat(tb, " = "); break; case S_SCALAR_NEQ: tb_cat(tb, " /= "); break; case S_SCALAR_LT: tb_cat(tb, " < "); break; case S_SCALAR_GT: tb_cat(tb, " > "); break; case S_SCALAR_LE: tb_cat(tb, " <= "); break; case S_SCALAR_GE: tb_cat(tb, " >= "); break; } to_string(tb, p1_type, hint_right); tb_cat(tb, " is false"); diag_hint(d, &(where->loc), "%s", tb_get(tb)); } emit_vhdl_diag(d, severity); } vhdl_severity_t set_exit_severity(vhdl_severity_t severity) { const vhdl_severity_t old = exit_severity; exit_severity = severity; return old; } void set_stderr_severity(vhdl_severity_t severity) { opt_set_int(OPT_STDERR_LEVEL, get_diag_severity(severity)); } void set_status_severity(vhdl_severity_t severity) { status_severity = severity; } int64_t get_vhdl_assert_count(vhdl_severity_t severity) { assert(severity <= SEVERITY_FAILURE); return counts[severity]; } void clear_vhdl_assert(void) { for (int i = SEVERITY_NOTE; i <= SEVERITY_FAILURE; i++) counts[i] = 0; } void set_vhdl_assert_enable(vhdl_severity_t severity, bool enable) { assert(severity <= SEVERITY_FAILURE); if (enable) enable_mask |= (1 << severity); else enable_mask &= ~(1 << severity); } bool get_vhdl_assert_enable(vhdl_severity_t severity) { assert(severity <= SEVERITY_FAILURE); return !!(enable_mask & (1 << severity)); } int get_vhdl_assert_exit_status(void) { for (int s = status_severity; s <= SEVERITY_FAILURE; s++) { if (counts[s] > 0) return EXIT_FAILURE; } return 0; } nvc-r1.17.1/src/rt/assert.h000066400000000000000000000026751504111170000154370ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_ASSERT_H #define _RT_ASSERT_H #include "prim.h" #include "diag.h" typedef enum { SEVERITY_NOTE = 0, SEVERITY_WARNING = 1, SEVERITY_ERROR = 2, SEVERITY_FAILURE = 3 } vhdl_severity_t; vhdl_severity_t set_exit_severity(vhdl_severity_t severity); void set_status_severity(vhdl_severity_t severity); void set_stderr_severity(vhdl_severity_t severity); int64_t get_vhdl_assert_count(vhdl_severity_t severity); void clear_vhdl_assert(void); void set_vhdl_assert_enable(vhdl_severity_t severity, bool enable); bool get_vhdl_assert_enable(vhdl_severity_t severity); int get_vhdl_assert_exit_status(void); diag_level_t get_diag_severity(vhdl_severity_t severity); void emit_vhdl_diag(diag_t *d, vhdl_severity_t severity); #endif // _RT_ASSERT_H nvc-r1.17.1/src/rt/copy.c000066400000000000000000000057561504111170000151060ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "copy.h" #include #ifdef ARCH_X86_64 #include #endif #if defined __GNUC__ && !defined __clang__ #pragma GCC optimize ("O2") #endif void _copy2(void *p1, void *p2, const void *src, size_t len) { #ifdef ARCH_X86_64 for (; len > 15; len -= 16, p1 += 16, p2 += 16, src += 16) { __m128i v2 = _mm_loadu_si128((const __m128i *)p2); __m128i vsrc = _mm_loadu_si128((const __m128i *)src); _mm_storeu_si128((__m128i *)p1, v2); _mm_storeu_si128((__m128i *)p2, vsrc); } #endif for (; len > 7; len -= 8, p1 += 8, p2 += 8, src += 8) { memcpy(p1, p2, 8); memcpy(p2, src, 8); } for (; len > 3; len -= 4, p1 += 4, p2 += 4, src += 4) { memcpy(p1, p2, 4); memcpy(p2, src, 4); } for (; len > 0; len--, p1++, p2++, src++) { *(unsigned char *)p1 = *(unsigned char *)p2; *(unsigned char *)p2 = *(unsigned char *)src; } } #if defined HAVE_SSE41 __attribute__((aligned(16))) static const uint8_t lane_iota[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; #endif #ifdef HAVE_SSE41 __attribute__((target("sse4.1"), always_inline)) static inline bool cmp_bytes_sse41(const void *a, const void *b, size_t size) { __m128i allmask = _mm_set1_epi8(0xff); int pos = 0; for (; pos + 15 < size; pos += 16) { __m128i left1 = _mm_loadu_si128((const __m128i *)(a + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(b + pos)); __m128i xor = _mm_xor_si128(left1, right1); if (!_mm_test_all_zeros(xor, allmask)) return false; } if (pos < size) { __m128i iota = _mm_load_si128((const __m128i *)lane_iota); __m128i mask = _mm_cmplt_epi8(iota, _mm_set1_epi8(size - pos)); __m128i left1 = _mm_loadu_si128((const __m128i *)(a + pos)); __m128i right1 = _mm_loadu_si128((const __m128i *)(b + pos)); __m128i xor = _mm_xor_si128(left1, right1); if (!_mm_test_all_zeros(xor, mask)) return false; } return true; } #endif #ifdef HAVE_SSE41 __attribute__((target("sse4.1"))) #endif bool _cmp_bytes(const void *a, const void *b, size_t size) { #if defined HAVE_SSE41 && !ASAN_ENABLED if (likely(__builtin_cpu_supports("sse4.1"))) return cmp_bytes_sse41(a, b, size); #endif return memcmp(a, b, size) == 0; } nvc-r1.17.1/src/rt/copy.h000066400000000000000000000026521504111170000151030ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_COPY_H #define _RT_COPY_H #include "prim.h" void _copy2(void *p1, void *p2, const void *src, size_t len); __attribute__((always_inline)) static inline void copy2(void *p1, void *p2, const void *src, size_t len) { if (len == 1) { *(unsigned char *)p1 = *(unsigned char *)p2; *(unsigned char *)p2 = *(const unsigned char *)src; } else return _copy2(p1, p2, src, len); } bool _cmp_bytes(const void *a, const void *b, size_t size) __attribute__((pure)); __attribute__((always_inline)) static inline bool cmp_bytes(const void *a, const void *b, size_t size) { if (size == 1) return *(unsigned char *)a == *(unsigned char *)b; else return _cmp_bytes(a, b, size); } #endif // _RT_COPY_H nvc-r1.17.1/src/rt/cover.c000066400000000000000000000424351504111170000152450ustar00rootroot00000000000000// // Copyright (C) 2013-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "cov/cov-api.h" #include "cov/cov-data.h" #include "hash.h" #include "lib.h" #include "option.h" #include "rt/model.h" #include "rt/rt.h" #include "rt/structs.h" #include "type.h" #include #include #include #include enum std_ulogic { _U = 0x0, _X = 0x1, _0 = 0x2, _1 = 0x3, _Z = 0x4, _W = 0x5, _L = 0x6, _H = 0x7, _DC = 0x8 }; //#define COVER_DEBUG_CALLBACK /////////////////////////////////////////////////////////////////////////////// // Toggle coverage /////////////////////////////////////////////////////////////////////////////// static inline void increment_counter(int32_t *ptr) { *ptr = saturate_add(*ptr, 1); } static inline void cover_toggle_check_0_1(uint8_t old, uint8_t new, int32_t *toggle_01, int32_t *toggle_10) { if (old == _0 && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _0) increment_counter(toggle_10); } static inline void cover_toggle_check_0_1_u(uint8_t old, uint8_t new, int32_t *toggle_01, int32_t *toggle_10) { if (old == _0 && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _0) increment_counter(toggle_10); else if ((old == _U || old == _X) && new == _1) increment_counter(toggle_01); else if ((old == _U || old == _X) && new == _0) increment_counter(toggle_10); } static inline void cover_toggle_check_0_1_z(uint8_t old, uint8_t new, int32_t *toggle_01, int32_t *toggle_10) { if (old == _0 && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _0) increment_counter(toggle_10); else if (old == _0 && new == _Z) increment_counter(toggle_01); else if (old == _Z && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _Z) increment_counter(toggle_10); else if (old == _Z && new == _0) increment_counter(toggle_10); } static inline void cover_toggle_check_0_1_u_z(uint8_t old, uint8_t new, int32_t *toggle_01, int32_t *toggle_10) { if (old == _0 && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _0) increment_counter(toggle_10); else if ((old == _U || old == _X) && new == _1) increment_counter(toggle_01); else if ((old == _U || old == _X) && new == _0) increment_counter(toggle_10); else if (old == _0 && new == _Z) increment_counter(toggle_01); else if (old == _Z && new == _1) increment_counter(toggle_01); else if (old == _1 && new == _Z) increment_counter(toggle_10); else if (old == _Z && new == _0) increment_counter(toggle_10); } #ifdef COVER_DEBUG_CALLBACK #define COVER_TGL_CB_MSG(signal) \ do { \ printf("Time: %lu Callback on signal: %s with size: %d \n", \ now, istr(tree_ident(signal->where)), s->shared.size); \ } while (0); #define COVER_TGL_SIGNAL_DETAILS(signal, size) \ do { \ printf("New signal value:\n"); \ for (int i = 0; i < size; i++) \ printf("0x%x ", ((uint8_t*)signal_value(signal))[i]); \ printf("\n"); \ printf("Old signal value:\n"); \ for (int i = 0; i < size; i++) \ printf("0x%x ", ((const uint8_t *)signal_last_value(signal))[i]); \ printf("\n\n"); \ } while (0); #else #define COVER_TGL_CB_MSG(signal) #define COVER_TGL_SIGNAL_DETAILS(signal, size) #endif // Callback is optimized for performance // Check only group of 8 bytes that do have change of signal value // Optimize for assumption that most bits don't change in large signals #define DEFINE_COVER_TOGGLE_CB(name, check_fnc) \ static void name(uint64_t now, rt_signal_t *s, rt_watch_t *w, void *user) \ { \ uint32_t s_size = s->shared.size; \ rt_model_t *m = get_model(); \ const int32_t tag = (uintptr_t)user; \ COVER_TGL_CB_MSG(s) \ uint32_t batches = ((s_size - 1) / sizeof(uint64_t)) + 1; \ for (int i = 0; i < batches; i++) { \ bool walk = false; \ int batch_size = sizeof(uint64_t); \ if (i < batches - 1) { \ const void *batch_new = signal_value(s) + i * sizeof(uint64_t); \ const void *batch_old = signal_last_value(s) + i * sizeof(uint64_t); \ if (unaligned_load(batch_new, uint64_t) != \ unaligned_load(batch_old, uint64_t)) \ walk = true; \ } \ else { \ batch_size = ((s_size - 1) % sizeof(uint64_t)) + 1; \ walk = true; \ } \ if (walk) { \ int32_t low = i * sizeof(uint64_t); \ int32_t high = low + batch_size; \ int32_t *toggle_01 = get_cover_counter(m, tag, 2) + low * 2; \ int32_t *toggle_10 = toggle_01 + 1; \ for (int j = low; j < high; j++) { \ uint8_t new = ((uint8_t*)signal_value(s))[j]; \ uint8_t old = ((uint8_t*)signal_last_value(s))[j]; \ if (new != old) \ check_fnc(old, new, toggle_01, toggle_10); \ toggle_01 += 2; \ toggle_10 += 2; \ } \ } \ } \ COVER_TGL_SIGNAL_DETAILS(s, s_size) \ } \ DEFINE_COVER_TOGGLE_CB(cover_toggle_cb_0_1, cover_toggle_check_0_1) DEFINE_COVER_TOGGLE_CB(cover_toggle_cb_0_1_u, cover_toggle_check_0_1_u) DEFINE_COVER_TOGGLE_CB(cover_toggle_cb_0_1_z, cover_toggle_check_0_1_z) DEFINE_COVER_TOGGLE_CB(cover_toggle_cb_0_1_u_z, cover_toggle_check_0_1_u_z) static bool is_constant_input(rt_signal_t *s) { tree_t decl = s->where; tree_kind_t kind = tree_kind(decl); if (kind == T_FIELD_DECL) { rt_scope_t *sc = s->parent; while (is_signal_scope(sc)) sc = sc->parent; decl = sc->where; } if (tree_kind(decl) != T_PORT_DECL) return false; else if (tree_subkind(decl) != PORT_IN) return false; else { rt_nexus_t *n = &(s->nexus); for (unsigned i = 0; i < s->n_nexus; i++, n = n->chain) { if (n->n_sources > 0) return false; } return true; } } void x_cover_setup_toggle_cb(sig_shared_t *ss, int32_t tag) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); rt_model_t *m = get_model(); cover_data_t *data = get_coverage(m); if (data == NULL) return; cover_mask_t op_mask = data->mask; if (is_constant_input(s)) { int32_t *toggle_01 = get_cover_counter(m, tag, 2 * s->shared.size); int32_t *toggle_10 = toggle_01 + 1; // Each std_logic bit encoded as single byte. There are two run-time // counters for each std_logic bit for (int i = 0; i < s->shared.size; i++) { // Remember constant driver in run-time data. // Unreachable mask not available at run-time. *toggle_01 = COV_FLAG_UNREACHABLE; *toggle_10 = COV_FLAG_UNREACHABLE; toggle_01 += 2; toggle_10 += 2; } return; } sig_event_fn_t fn = &cover_toggle_cb_0_1; if ((op_mask & COVER_MASK_TOGGLE_COUNT_FROM_UNDEFINED) && (op_mask & COVER_MASK_TOGGLE_COUNT_FROM_TO_Z)) fn = &cover_toggle_cb_0_1_u_z; else if (op_mask & COVER_MASK_TOGGLE_COUNT_FROM_UNDEFINED) fn = &cover_toggle_cb_0_1_u; else if (op_mask & COVER_MASK_TOGGLE_COUNT_FROM_TO_Z) fn = &cover_toggle_cb_0_1_z; rt_watch_t *w = watch_new(m, fn, (void *)(uintptr_t)tag, WATCH_EVENT, 1); model_set_event_cb(m, s, w); } /////////////////////////////////////////////////////////////////////////////// // FSM state coverage /////////////////////////////////////////////////////////////////////////////// #define READ_STATE(type) offset = *((type *)signal_value(s)); static void cover_state_cb(uint64_t now, rt_signal_t *s, rt_watch_t *w, void *user) { // I-th enum literal is encoded in i-th tag from first tag, that corresponds // to enum value. int size = signal_size(s); int32_t offset = 0; FOR_ALL_SIZES(size, READ_STATE); rt_model_t *m = get_model(); int32_t *mask = get_cover_counter(m, ((uintptr_t)user) + offset, 1); increment_counter(mask); } void x_cover_setup_state_cb(sig_shared_t *ss, int64_t low, int32_t tag) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); rt_model_t *m = get_model(); cover_data_t *data = get_coverage(m); if (data == NULL) return; int32_t *mask = get_cover_counter(m, tag, 1); // TYPE'left is a default value of enum type that does not // cause an event. First tag needs to be flagged as covered manually. *mask = 1; rt_watch_t *w = watch_new(m, cover_state_cb, (void *)(uintptr_t)(tag - low), WATCH_EVENT, 1); model_set_event_cb(m, s, w); } /////////////////////////////////////////////////////////////////////////////// // Run-time API /////////////////////////////////////////////////////////////////////////////// static cover_scope_t *find_cover_scope(cover_data_t *data, rt_model_t *m, rt_scope_t *inst) { if (inst->parent == NULL) return data->root_scope; cover_scope_t *parent = find_cover_scope(data, m, inst->parent); if (parent == NULL) return NULL; ident_t suffix = ident_rfrom(inst->name, '.'); for (int i = 0; i < parent->children.count; i++) { if (parent->children.items[i]->name == suffix) return parent->children.items[i]; } tree_t hier = tree_decl(inst->parent->where, 0); assert(tree_kind(hier) == T_HIER); if (tree_kind(tree_ref(hier)) == T_COMPONENT) return parent; // Skip over implicit block for components return NULL; } static void sanitise_name(text_buf_t *tb, const char *bytes, size_t len) { for (size_t i = 0; i < len; i++) { const char ch = bytes[i]; if (isalnum_iso88591(ch) || ch == '_') tb_append(tb, ch); else tb_printf(tb, "&#%d;", ch); } } DLLEXPORT void _nvc_create_cover_scope(jit_scalar_t *args) { cover_scope_t **ptr = args[2].pointer; const char *name_bytes = args[3].pointer; size_t name_len = ffi_array_length(args[5].integer); *ptr = NULL; if (name_len == 0) jit_msg(NULL, DIAG_FATAL, "coverage scope name cannot be empty"); rt_model_t *m = get_model_or_null(); if (m == NULL) return; cover_data_t *data = get_coverage(m); if (data == NULL || !cover_enabled(data, COVER_MASK_FUNCTIONAL)) return; rt_scope_t *inst = get_active_scope(m); assert(inst->kind == SCOPE_INSTANCE); cover_scope_t *parent = find_cover_scope(data, m, inst); if (parent == NULL) return; LOCAL_TEXT_BUF tb = tb_new(); sanitise_name(tb, name_bytes, name_len); const size_t pfxlen = tb_len(tb); for (int i = 0, dup = 0; i < parent->children.count; i++) { if (icmp(parent->children.items[i]->name, tb_get(tb))) { tb_trim(tb, pfxlen); tb_printf(tb, "#%d", ++dup); } } ident_t name = ident_new(tb_get(tb)); *ptr = cover_create_scope(data, parent, inst->where, name); (*ptr)->block_name = name; } DLLEXPORT void _nvc_set_cover_scope_name(jit_scalar_t *args) { cover_scope_t *s = *(cover_scope_t **)args[2].pointer; const char *name_bytes = args[3].pointer; size_t name_len = ffi_array_length(args[5].integer); if (name_len == 0) jit_msg(NULL, DIAG_FATAL, "coverage scope name cannot be empty"); if (s == NULL) return; LOCAL_TEXT_BUF tb = tb_new(); sanitise_name(tb, name_bytes, name_len); ident_t name_id = ident_new(tb_get(tb)); if (s->items.count > 0) jit_msg(NULL, DIAG_FATAL, "cannot change name of cover scope after " "items are created"); s->name = name_id; s->block_name = name_id; ident_t prefix = ident_runtil(s->hier,'.'); s->hier = ident_prefix(prefix, name_id, '.'); } DLLEXPORT void _nvc_add_cover_item(jit_scalar_t *args) { cover_scope_t *s = *(cover_scope_t **)args[2].pointer; int32_t *index_ptr = args[3].pointer; const char *name_bytes = args[4].pointer; size_t name_len = ffi_array_length(args[6].integer); *index_ptr = -1; if (name_len == 0) jit_msg(NULL, DIAG_FATAL, "coverage item name cannot be empty"); if (s == NULL || !s->emit) return; rt_model_t *m = get_model_or_null(); if (m == NULL) return; cover_data_t *data = get_coverage(m); if (data == NULL || !cover_enabled(data, COVER_MASK_FUNCTIONAL)) return; LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, s->hier); tb_append(tb, '.'); sanitise_name(tb, name_bytes, name_len); const size_t pfxlen = tb_len(tb); for (int i = 0, dup = 0; i < s->items.count; i++) { if (icmp(s->items.items[i].hier, tb_get(tb))) { tb_trim(tb, pfxlen); tb_printf(tb, "#%d", ++dup); } } cover_item_t *item = cover_add_items_for(data, s, NULL, COV_ITEM_FUNCTIONAL); assert(item != NULL); // Preconditions checked above item->hier = ident_new(tb_get(tb)); item->loc = s->loc; // XXX: keeps report from crashing but location // does not make sense here // Name remembered at the time of cover point creation in its scope item->func_name = s->block_name; item->source = COV_SRC_USER_COVER; item->atleast = args[7].integer; item->flags = COV_FLAG_USER_DEFINED; if (item->atleast == 0) item->flags |= (COV_FLAG_EXCLUDED | COV_FLAG_EXCLUDED_USER); item->n_ranges = ffi_array_length(args[10].integer); item->ranges = xcalloc_array(item->n_ranges, sizeof(cover_range_t)); int64_t *ptr = (int64_t *)args[8].pointer; for (int i = 0; i < item->n_ranges; i++) { item->ranges[i].min = *ptr++; item->ranges[i].max = *ptr++; } *index_ptr = item - s->items.items; cover_item_t *first = AREF(s->items, 0); first->consecutive = s->items.count; } DLLEXPORT void _nvc_increment_cover_item(jit_scalar_t *args) { cover_scope_t *s = *(cover_scope_t **)args[2].pointer; int32_t index = args[3].integer; if (s == NULL || !s->emit) return; rt_model_t *m = get_model_or_null(); if (m == NULL) return; cover_data_t *data = get_coverage(m); if (data == NULL || !cover_enabled(data, COVER_MASK_FUNCTIONAL)) return; if (index < 0 || index >= s->items.count) jit_msg(NULL, DIAG_FATAL, "cover item index %d out of range", index); int32_t *counter = get_cover_counter(m, s->items.items[index].tag, 1); increment_counter(counter); } nvc-r1.17.1/src/rt/ename.c000066400000000000000000000211641504111170000152100ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "ident.h" #include "jit/jit.h" #include "jit/jit-exits.h" #include "lib.h" #include "rt/model.h" #include "rt/structs.h" #include "tree.h" #include "type.h" #include #include #include #include static tree_t select_name(tree_t where, ident_t id) { const int ndecls = tree_decls(where); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(where, i); if (tree_ident(d) == id) return d; } const int ngenerics = tree_generics(where); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(where, i); if (tree_ident(g) == id) return g; } switch (tree_kind(where)) { case T_PACKAGE: return select_name(body_of(where), id); case T_PACK_BODY: return NULL; default: break; } const int nstmts = tree_stmts(where); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(where, i); if (tree_ident(s) == id) return s; } const int nports = tree_ports(where); for (int i = 0; i < nports; i++) { tree_t p = tree_port(where, i); if (tree_ident(p) == id) return p; } return NULL; } static bool is_implicit_block(tree_t block) { if (tree_kind(block) != T_BLOCK) return false; tree_t hier = tree_decl(block, 0); assert(tree_kind(hier) == T_HIER); return tree_subkind(hier) == T_COMPONENT; } void x_bind_external(tree_t name, jit_handle_t scope, jit_scalar_t *result) { assert(tree_kind(name) == T_EXTERNAL_NAME); jit_t *j = jit_for_thread(); tree_t where = tree_from_object(jit_get_object(j, scope)), next = NULL; ident_t path = jit_get_name(j, scope); const int nparts = tree_parts(name); for (int i = 0; i < nparts; i++, where = next, next = NULL) { tree_t pe = tree_part(name, i); assert(tree_kind(pe) == T_PATH_ELT); ident_t id = NULL; switch (tree_subkind(pe)) { case PE_ABSOLUTE: { tree_t top; rt_model_t *m = get_model_or_null(); if (m == NULL) top = tree_container(where); else top = root_scope(m)->where; if (tree_kind(top) != T_ELAB) jit_msg(tree_loc(pe), DIAG_FATAL, "design hieararchy root has " "not yet been elaborated"); tree_t root = tree_stmt(top, 0); tree_t entity = tree_part(name, ++i); assert(tree_subkind(entity) == PE_SIMPLE); if (root == NULL || tree_ident(root) != tree_ident(entity)) jit_msg(tree_loc(pe), DIAG_FATAL, "%s is not the name of " "the root of the design hierarchy", istr(tree_ident(entity))); path = ident_prefix(lib_name(lib_work()), tree_ident(root), '.'); next = root; } continue; case PE_SIMPLE: id = tree_ident(pe); break; case PE_GENERATE: { LOCAL_TEXT_BUF tb = tb_new(); tb_istr(tb, tree_ident(pe)); tb_printf(tb, "(%"PRIi64")", assume_int(tree_value(pe))); id = ident_new(tb_get(tb)); } break; case PE_LIBRARY: { lib_t lib = lib_require(tree_ident(pe)); pe = tree_part(name, ++i); assert(tree_subkind(pe) == PE_SIMPLE); ident_t qual = ident_prefix(lib_name(lib), tree_ident(pe), '.'); tree_t pack = lib_get(lib, qual); if (pack == NULL || !is_package(pack)) jit_msg(tree_loc(pe), DIAG_FATAL, "%s is not a package", istr(qual)); path = tree_ident(pack); next = pack; } continue; case PE_RELATIVE: next = where; continue; case PE_CARET: do { ident_t parent = ident_runtil(path, '.'); assert(parent != NULL); if (parent == lib_name(lib_work()) || tree_kind(where) != T_BLOCK) jit_msg(tree_loc(pe), DIAG_FATAL, "relative pathname has " "no containing declarative region"); scope = jit_lazy_compile(j, parent); path = jit_get_name(j, scope); next = tree_from_object(jit_get_object(j, scope)); } while (is_implicit_block(next)); continue; default: should_not_reach_here(); } if (!is_concurrent_block(where) && !is_package(where)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(pe)); diag_printf(d, "%s is not a concurrent region", istr(tree_ident(where))); diag_hint(d, tree_loc(where), "location of %s", istr(tree_ident(where))); diag_emit(d); jit_abort_with_status(1); } else if (is_implicit_block(where)) { // Skip over implicit block for component declaration where = tree_stmt(where, 0); assert(tree_kind(where) == T_BLOCK); path = ident_prefix(path, tree_ident(where), '.'); } if ((next = select_name(where, id)) == NULL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(pe)); diag_printf(d, "external name %s not found", istr(tree_ident(tree_part(name, nparts - 1)))); diag_hint(d, tree_loc(pe), "name %s not found inside %s", istr(id), istr(tree_ident(where))); if (!tree_frozen(where)) diag_hint(d, NULL, "an object cannot be referenced by an " "external name until it has been elaborated"); diag_emit(d); jit_abort_with_status(1); } if (i + 1 < nparts) path = ident_prefix(path, id, '.'); } if (class_of(where) != tree_class(name)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(name)); diag_printf(d, "class of object %s is not %s", istr(tree_ident(where)), class_str(tree_class(name))); diag_hint(d, tree_loc(name), "external name with class %s", class_str(tree_class(name))); diag_hint(d, tree_loc(where), "declaration of %s as %s", istr(tree_ident(where)), class_str(class_of(where))); diag_emit(d); jit_abort_with_status(1); } type_t type = tree_type(where); type_t expect = tree_type(name); if (!type_eq(type, expect)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(name)); diag_printf(d, "type of %s %s is not %s", class_str(tree_class(name)), istr(tree_ident(where)), type_pp2(expect, type)); diag_hint(d, tree_loc(name), "external name with type %s", type_pp2(expect, type)); diag_hint(d, tree_loc(where), "declaration of %s with type %s", istr(tree_ident(where)), type_pp2(type, expect)); diag_emit(d); jit_abort_with_status(1); } jit_handle_t handle = jit_compile(j, path); (void)jit_link(j, handle); // Package may not be loaded void *ptr = jit_get_frame_var(j, handle, tree_ident(where)); if (type_is_array(type) && type_const_bounds(type)) { const int ndims = dimension_of(type); jit_scalar_t *slots = jit_mspace_alloc(16 * (ndims + 1)); int pos = 0; if (tree_class(name) == C_SIGNAL && type_is_homogeneous(type)) { slots[pos++].pointer = *(sig_shared_t **)ptr; slots[pos++].integer = *(int32_t *)(ptr + 8); } else slots[pos++].pointer = ptr; for (int i = 0; i < ndims; i++) { tree_t r = range_of(type, i); const range_kind_t dir = tree_subkind(r); const int64_t left = assume_int(tree_left(r)); const int64_t right = assume_int(tree_right(r)); const int64_t length = MAX(0, dir == RANGE_TO ? right - left + 1 : left - right + 1); slots[pos++].integer = left; slots[pos++].integer = dir == RANGE_TO ? length : ~length; } result[0].pointer = slots; } else result[0].pointer = ptr; } nvc-r1.17.1/src/rt/fileio.c000066400000000000000000000266001504111170000153720ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "jit/jit-exits.h" #include "jit/jit-ffi.h" #include "jit/jit.h" #include "rt/fileio.h" #include "rt/rt.h" #include #include #include #include #include #include #include #include #ifdef __MINGW32__ #include #include #endif #ifdef HAVE_STDIO_EXT_H #include #endif typedef enum { FILE_ORIGIN_BEGIN, FILE_ORIGIN_CURRENT, FILE_ORIGIN_END } file_origin_kind_t; typedef enum { STATE_OPEN, STATE_CLOSED } file_open_state_t; typedef enum { OPEN_OK = 0, STATUS_ERROR = 1, NAME_ERROR = 2, MODE_ERROR = 3, } file_open_status_t; typedef enum { READ_MODE, WRITE_MODE, APPEND_MODE, READ_WRITE_MODE } file_open_kind_t; typedef enum { FILE_USER, FILE_PREDEF, } file_kind_t; typedef struct { FILE *file; char *name; file_kind_t kind; file_mode_t mode; uint16_t generation; } file_slot_t; #define HANDLE_BITS (sizeof(file_handle_t) * 8) #define HANDLE_MAX_INDEX ((UINT64_C(1) << (HANDLE_BITS / 2)) - 1) static file_slot_t *handles; static unsigned num_handles; static unsigned free_hint; static file_slot_t *decode_handle(file_handle_t handle) { const uintptr_t bits = (uintptr_t)handle; const uint32_t index = bits & HANDLE_MAX_INDEX; const uint32_t generation = bits >> HANDLE_BITS/2; if (handle == 0 || index >= num_handles) return NULL; file_slot_t *slot = &(handles[index]); if (slot->file == NULL) return NULL; else if (slot->generation != generation) return NULL; // Use-after-free return slot; } static file_handle_t handle_for(FILE *f, const char *name, file_kind_t kind, file_mode_t mode) { assert(f != NULL); uint32_t index = free_hint; if (index >= num_handles || handles[index].file != NULL) { for (index = 0; index < num_handles; index++) { if (handles[index].file == NULL && handles[index].generation < HANDLE_MAX_INDEX) break; } } if (index > HANDLE_MAX_INDEX) fatal("too many active file handles"); else if (index == num_handles) { const int new_size = MAX(num_handles * 2, 16); handles = xrealloc_array(handles, new_size, sizeof(file_slot_t)); num_handles = new_size; for (int i = index; i < new_size; i++) { handles[i].file = NULL; handles[i].generation = 1; } } file_slot_t *slot = &(handles[index]); slot->file = f; slot->name = xstrdup(name); slot->kind = kind; slot->mode = mode; free_hint = index + 1; return (file_handle_t)slot->generation << HANDLE_BITS/2 | index; } static void drop_handle(file_handle_t handle) { file_slot_t *slot = decode_handle(handle); if (slot == NULL) return; if (slot->kind == FILE_USER) fclose(slot->file); free(slot->name); slot->file = NULL; slot->generation++; free_hint = slot - handles; } bool file_mode(file_handle_t fh, file_mode_t *mode) { file_slot_t *slot = decode_handle(fh); if (slot == NULL) return false; *mode = slot->mode; return true; } bool file_logical_name(file_handle_t fh, const char **name) { file_slot_t *slot = decode_handle(fh); if (slot == NULL) return false; *name = slot->name; return true; } DLLEXPORT void __nvc_file_close(jit_scalar_t *args) { file_handle_t *handle = args[2].pointer; drop_handle(*handle); *handle = 0; } DLLEXPORT void __nvc_endfile(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "ENDFILE called on closed file"); int c = fgetc(slot->file); if (c == EOF) args[0].integer = 1; else { ungetc(c, slot->file); args[0].integer = 0; } } DLLEXPORT void __nvc_flush(jit_scalar_t *args) { file_handle_t *handle = args[2].pointer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FLUSH called on closed file"); fflush(slot->file); } DLLEXPORT void __nvc_rewind(jit_scalar_t *args) { file_handle_t *handle = args[2].pointer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_REWIND called on closed file"); rewind(slot->file); } DLLEXPORT void __nvc_seek(jit_scalar_t *args) { file_handle_t *handle = args[2].pointer; off_t offset = args[3].integer; int8_t origin = args[4].integer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_SEEK called on closed file"); const int whence[3] = { SEEK_SET, SEEK_CUR, SEEK_END }; assert(origin >= 0 && origin < ARRAY_LEN(whence)); if (fseeko(slot->file, offset, whence[origin]) < 0) jit_msg(NULL, DIAG_FATAL, "FILE_SEEK failed: %s", strerror(errno)); } DLLEXPORT void __nvc_truncate(jit_scalar_t *args) { file_handle_t *handle = args[2].pointer; int64_t size = args[3].integer; int8_t origin = args[4].integer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_TRUNCATE called on closed file"); fflush(slot->file); #ifdef __MINGW32__ HANDLE os_handle = (HANDLE)_get_osfhandle(_fileno(slot->file)); LARGE_INTEGER distance = { .QuadPart = size }; if (!SetFilePointerEx(os_handle, distance, NULL, origin)) goto failed; if (!SetEndOfFile(os_handle)) goto failed; #else // !__MINGW32__ off_t asize = size, oldpos = ftello(slot->file); switch (origin) { case FILE_ORIGIN_END: fseek(slot->file, 0, SEEK_END); asize = ftello(slot->file) + size; break; case FILE_ORIGIN_CURRENT: asize = oldpos + size; break; } if (ftruncate(fileno(slot->file), asize) != 0) goto failed; if (oldpos > asize || origin == FILE_ORIGIN_END) { if (fseeko(slot->file, asize, SEEK_SET) != 0) goto failed; } #if defined HAVE_FPURGE if (fpurge(slot->file) != 0) goto failed; #elif defined HAVE___FPURGE __fpurge(slot->file); #endif #endif // !__MINGW32__ return; failed: jit_msg(NULL, DIAG_FATAL, "FILE_TRUNCATE failed: %s", strerror(errno)); } DLLEXPORT void __nvc_file_state(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; file_slot_t *slot = decode_handle(*handle); args[0].integer = (slot == NULL ? STATE_CLOSED : STATE_OPEN); } DLLEXPORT void __nvc_file_mode(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_MODE called on closed file"); args[0].integer = slot->mode; } DLLEXPORT void __nvc_file_position(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; int8_t origin = args[2].integer; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_POSITION called on closed file"); off_t off = ftello(slot->file); if (off < 0) jit_msg(NULL, DIAG_FATAL, "FILE_POSITION failed: %s", strerror(errno)); switch (origin) { case FILE_ORIGIN_BEGIN: args[0].integer = off; break; case FILE_ORIGIN_END: { fseeko(slot->file, 0, SEEK_END); off_t end = ftello(slot->file); fseeko(slot->file, off, SEEK_SET); args[0].integer = end - off; } break; case FILE_ORIGIN_CURRENT: args[0].integer = 0; break; } } DLLEXPORT void __nvc_file_size(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; file_slot_t *slot = decode_handle(*handle); if (slot->file == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_SIZE called on closed file"); fflush(slot->file); file_info_t info; if (!get_handle_info(fileno(slot->file), &info)) jit_msg(NULL, DIAG_FATAL, "FILE_SIZE failed: %s", strerror(errno)); args[0].integer = info.size; } DLLEXPORT void __nvc_file_canseek(jit_scalar_t *args) { file_handle_t *handle = args[1].pointer; file_slot_t *slot = decode_handle(*handle); if (slot->file == NULL) jit_msg(NULL, DIAG_FATAL, "FILE_CANSEEK called on closed file"); args[0].integer = fseek(slot->file, 0, SEEK_CUR) == 0; } void x_file_open(int8_t *status, void **_fp, const uint8_t *name_bytes, int32_t name_len, int8_t mode) { file_handle_t *handle = (file_handle_t *)_fp; char *fname LOCAL = xmalloc(name_len + 1); memcpy(fname, name_bytes, name_len); fname[name_len] = '\0'; const char *mode_str[] = { "rb", "wb", "ab", "r+" }; assert(mode < ARRAY_LEN(mode_str)); if (status != NULL) *status = OPEN_OK; if (*handle != 0) { if (status == NULL) jit_msg(NULL, DIAG_FATAL, "file object already associated " "with an external file"); else *status = STATUS_ERROR; } else if (name_len == 0) { if (status == NULL) jit_msg(NULL, DIAG_FATAL, "empty file name in FILE_OPEN"); else *status = NAME_ERROR; } else if (strcmp(fname, "STD_INPUT") == 0) *handle = handle_for(stdin, fname, FILE_PREDEF, mode); else if (strcmp(fname, "STD_OUTPUT") == 0) *handle = handle_for(stdout, fname, FILE_PREDEF, mode); else { #ifdef __MINGW32__ FILE *fp = _fsopen(fname, mode_str[mode], _SH_DENYNO); #else FILE *fp = fopen(fname, mode_str[mode]); #endif if (fp == NULL) { if (status == NULL) jit_msg(NULL, DIAG_FATAL, "failed to open %s: %s", fname, strerror(errno)); else { switch (errno) { case ENOENT: *status = NAME_ERROR; break; case EACCES: *status = MODE_ERROR; break; default: *status = NAME_ERROR; break; } } } else *handle = handle_for(fp, fname, FILE_USER, mode); } } void x_file_write(void **_fp, void *data, int64_t size, int64_t count) { file_handle_t *handle = (file_handle_t *)_fp; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "write to closed file"); if (fwrite(data, size, count, slot->file) != count) jit_msg(NULL, DIAG_FATAL, "write to file failed"); } int64_t x_file_read(void **_fp, void *data, int64_t size, int64_t count) { file_handle_t *handle = (file_handle_t *)_fp; file_slot_t *slot = decode_handle(*handle); if (slot == NULL) jit_msg(NULL, DIAG_FATAL, "read from closed file"); const unsigned long actual = fread(data, size, count, slot->file); if (actual != count && ferror(slot->file)) jit_msg(NULL, DIAG_FATAL, "read from file failed"); return actual; } void _file_io_init(void) { // Dummy function to force linking } nvc-r1.17.1/src/rt/fileio.h000066400000000000000000000020301504111170000153660ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_FILEIO_H #define _RT_FILEIO_H #include "prim.h" typedef enum { FILE_READ = 0, FILE_WRITE = 1, FILE_APPEND = 2, FILE_READ_WRITE = 3, } file_mode_t; typedef uint32_t file_handle_t; bool file_mode(file_handle_t fh, file_mode_t *mode); bool file_logical_name(file_handle_t fh, const char **name); #endif // _RT_FILEIO_H nvc-r1.17.1/src/rt/heap.c000066400000000000000000000070001504111170000150310ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "rt/heap.h" #include "rt/rt.h" #include #include #include #define PARENT(i) (i >> 1) #define LEFT(i) (i << 1) #define RIGHT(i) ((i << 1) + 1) struct heap_node { void *user; uint64_t key; }; #define NODE(h, i) (h->nodes[i - 1]) #define KEY(h, i) (NODE(h, i).key) #define USER(h, i) (NODE(h, i).user) static inline void exchange(heap_t *h, size_t i, size_t j) { heap_node_t tmp = NODE(h, j); NODE(h, j) = NODE(h, i); NODE(h, i) = tmp; } static void min_heapify(heap_t *h, size_t i) { for (;;) { const size_t l = LEFT(i); const size_t r = RIGHT(i); size_t smallest; if (l <= h->size && KEY(h, l) < KEY(h, i)) smallest = l; else smallest = i; if (r <= h->size && KEY(h, r) < KEY(h, smallest)) smallest = r; if (smallest == i) break; exchange(h, i, smallest); i = smallest; } } static inline void heap_decrease_key(heap_t *h, size_t i, uint64_t key) { assert(key <= KEY(h, i)); KEY(h, i) = key; while (i > 1 && KEY(h, PARENT(i)) > KEY(h, i)) { exchange(h, i, PARENT(i)); i = PARENT(i); } } heap_t *heap_new(size_t init_size) { heap_t *h = xcalloc(sizeof(heap_t)); h->nodes = xmalloc_array(init_size, sizeof(heap_node_t)); h->max_size = init_size; h->size = 0; return h; } void heap_free(heap_t *h) { free(h->nodes); free(h); } void *heap_extract_min(heap_t *h) { RT_LOCK(h->lock); assert(h->size >= 1); void *min = USER(h, 1); NODE(h, 1) = NODE(h, h->size); --(h->size); min_heapify(h, 1); return min; } void *heap_min(heap_t *h) { RT_LOCK(h->lock); assert(h->size >= 1); return USER(h, 1); } uint64_t heap_min_key(heap_t *h) { RT_LOCK(h->lock); assert(h->size >= 1); return KEY(h, 1); } void heap_insert(heap_t *h, uint64_t key, void *user) { RT_LOCK(h->lock); if (unlikely(h->size == h->max_size)) { h->max_size *= 2; h->nodes = xrealloc_array(h->nodes, h->max_size, sizeof(heap_node_t)); } ++(h->size); KEY(h, h->size) = UINT64_MAX; USER(h, h->size) = user; heap_decrease_key(h, h->size, key); } void heap_walk(heap_t *h, heap_walk_fn_t fn, void *context) { RT_LOCK(h->lock); for (size_t i = 1; i <= h->size; i++) (*fn)(KEY(h, i), USER(h, i), context); } bool heap_delete(heap_t *h, heap_delete_fn_t fn, void *context) { RT_LOCK(h->lock); for (size_t i = 1; i <= h->size; i++) { if ((*fn)(KEY(h, i), USER(h, i), context)) { if (i == h->size) --(h->size); else if (i < h->size) { NODE(h, i) = NODE(h, h->size); --(h->size); heap_decrease_key(h, i, KEY(h, i)); min_heapify(h, i); } return true; } } return false; } nvc-r1.17.1/src/rt/heap.h000066400000000000000000000027661504111170000150540ustar00rootroot00000000000000// // Copyright (C) 2011-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _HEAP_H #define _HEAP_H #include "thread.h" #include #include #include typedef struct heap_node heap_node_t; typedef struct { heap_node_t *nodes; size_t size; size_t max_size; nvc_lock_t lock; } heap_t; typedef void (*heap_walk_fn_t)(uint64_t key, void *user, void *context); typedef bool (*heap_delete_fn_t)(uint64_t key, void *user, void *context); heap_t *heap_new(size_t init_size); void heap_free(heap_t *h); void *heap_extract_min(heap_t *h); void *heap_min(heap_t *h); uint64_t heap_min_key(heap_t *h); void heap_insert(heap_t *h, uint64_t key, void *user); void heap_walk(heap_t *h, heap_walk_fn_t fn, void *context); bool heap_delete(heap_t *h, heap_delete_fn_t fn, void *context); #define heap_size(h) atomic_load(&(h)->size) #endif nvc-r1.17.1/src/rt/model.c000066400000000000000000004117361504111170000152330ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "debug.h" #include "hash.h" #include "jit/jit-exits.h" #include "jit/jit.h" #include "lib.h" #include "option.h" #include "psl/psl-node.h" #include "rt/assert.h" #include "rt/copy.h" #include "rt/heap.h" #include "rt/model.h" #include "rt/random.h" #include "rt/structs.h" #include "thread.h" #include "tree.h" #include "type.h" #include "vlog/vlog-node.h" #include "vlog/vlog-util.h" #include #include #include #include typedef struct _rt_callback rt_callback_t; typedef struct _memblock memblock_t; typedef struct _rt_callback { rt_event_fn_t fn; void *user; rt_callback_t *next; } rt_callback_t; typedef enum { EVENT_TIMEOUT, EVENT_DRIVER, EVENT_PROCESS, } event_kind_t; #define MEMBLOCK_ALIGN 64 #define MEMBLOCK_PAGE_SZ 0x800000 #define TRIGGER_TAB_SIZE 64 #if ASAN_ENABLED #define MEMBLOCK_REDZONE 16 #else #define MEMBLOCK_REDZONE 0 #endif typedef struct _memblock { memblock_t *chain; size_t alloc; size_t limit; uint8_t data[]; } memblock_t; STATIC_ASSERT(sizeof(memblock_t) <= MEMBLOCK_ALIGN); typedef struct { waveform_t *free_waveforms; tlab_t *tlab; rt_wakeable_t *active_obj; rt_scope_t *active_scope; } __attribute__((aligned(64))) model_thread_t; typedef void (*defer_fn_t)(rt_model_t *, void *); typedef struct { defer_fn_t fn; void *arg; } defer_task_t; typedef struct { defer_task_t *tasks; unsigned count; unsigned max; } deferq_t; typedef struct _rt_model { tree_t top; hash_t *scopes; rt_scope_t *root; mspace_t *mspace; jit_t *jit; rt_nexus_t *nexuses; rt_nexus_t **nexus_tail; delta_cycle_t stop_delta; int iteration; uint64_t now; bool can_create_delta; bool next_is_delta; bool force_stop; unsigned n_signals; heap_t *eventq_heap; ihash_t *res_memo; rt_watch_t *watches; deferq_t procq; deferq_t delta_procq; deferq_t driverq; deferq_t delta_driverq; deferq_t postponedq; deferq_t implicitq; heap_t *driving_heap; heap_t *effective_heap; rt_callback_t *global_cbs[RT_LAST_EVENT]; cover_data_t *cover; nvc_rusage_t ready_rusage; nvc_lock_t memlock; memblock_t *memblocks; model_thread_t *threads[MAX_THREADS]; signal_list_t eventsigs; bool shuffle; bool liveness; rt_trigger_t *triggertab[TRIGGER_TAB_SIZE]; } rt_model_t; #define FMT_VALUES_SZ 128 #define NEXUS_INDEX_MIN 8 #define TRACE_SIGNALS 1 #define WAVEFORM_CHUNK 256 #define PENDING_MIN 4 #define MAX_RANK UINT8_MAX #define TRACE(...) do { \ if (unlikely(__trace_on)) \ __model_trace(get_model(), __VA_ARGS__); \ } while (0) #define MODEL_ENTRY(m) \ rt_model_t *__save __attribute__((unused, cleanup(__model_exit))); \ __model_entry(m, &__save); \ #if USE_EMUTLS static rt_model_t *__model = NULL; #else static __thread rt_model_t *__model = NULL; #endif static bool __trace_on = false; static void *source_value(rt_nexus_t *nexus, rt_source_t *src); static void free_value(rt_nexus_t *n, rt_value_t v); static rt_nexus_t *clone_nexus(rt_model_t *m, rt_nexus_t *old, int offset); static void put_driving(rt_model_t *m, rt_nexus_t *n, const void *value); static void put_effective(rt_model_t *m, rt_nexus_t *n, const void *value); static void update_implicit_signal(rt_model_t *m, rt_implicit_t *imp); static bool run_trigger(rt_model_t *m, rt_trigger_t *t); static void reset_scope(rt_model_t *m, rt_scope_t *s); static void async_run_process(rt_model_t *m, void *arg); static void async_update_property(rt_model_t *m, void *arg); static void async_update_driver(rt_model_t *m, void *arg); static void async_fast_driver(rt_model_t *m, void *arg); static void async_fast_all_drivers(rt_model_t *m, void *arg); static void async_pseudo_source(rt_model_t *m, void *arg); static void async_transfer_signal(rt_model_t *m, void *arg); static void async_update_implicit_signal(rt_model_t *m, void *arg); static int fmt_time_r(char *buf, size_t len, int64_t t, const char *sep) { static const struct { int64_t time; const char *unit; } units[] = { { INT64_C(1), "fs" }, { INT64_C(1000), "ps" }, { INT64_C(1000000), "ns" }, { INT64_C(1000000000), "us" }, { INT64_C(1000000000000), "ms" }, { 0, NULL } }; int u = 0; while (units[u + 1].unit && (t % units[u + 1].time == 0)) ++u; return checked_sprintf(buf, len, "%"PRIi64"%s%s", t / units[u].time, sep, units[u].unit); } __attribute__((format(printf, 2, 3))) static void __model_trace(rt_model_t *m, const char *fmt, ...) { va_list ap; va_start(ap, fmt); static nvc_lock_t lock = 0; { SCOPED_LOCK(lock); if (m->iteration < 0) fprintf(stderr, "TRACE (init): "); else { char buf[64]; fmt_time_r(buf, sizeof(buf), m->now, ""); fprintf(stderr, "TRACE %s+%d: ", buf, m->iteration); } vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); fflush(stderr); } va_end(ap); } static const char *trace_time(uint64_t value) { static __thread char buf[2][32]; static __thread int which = 0; which ^= 1; fmt_time_r(buf[which], 32, value, ""); return buf[which]; } static const char *trace_states(bit_mask_t *mask) { static __thread text_buf_t *tb = NULL; if (tb == NULL) tb = tb_new(); tb_rewind(tb); tb_append(tb, '{'); size_t bit = -1; while (mask_iter(mask, &bit)) tb_printf(tb, "%s%zd", tb_len(tb) > 1 ? "," : "", bit); tb_append(tb, '}'); return tb_get(tb); } static const char *trace_nexus(rt_nexus_t *n) { static __thread text_buf_t *tb = NULL; if (tb == NULL) tb = tb_new(); tb_rewind(tb); if (is_signal_scope(n->signal->parent)) tb_printf(tb, "%s.", istr(n->signal->parent->name)); tb_istr(tb, tree_ident(n->signal->where)); if (n->width * n->size < n->signal->shared.size) tb_printf(tb, "[%d:%d]", n->offset, n->offset + n->width - 1); return tb_get(tb); } static void model_diag_cb(diag_t *d, void *arg) { rt_model_t *m = arg; if (m->iteration < 0) diag_printf(d, "(init): "); else { char tmbuf[64]; fmt_time_r(tmbuf, sizeof(tmbuf), m->now, ""); diag_printf(d, "%s+%d: ", tmbuf, m->iteration); } } static void __model_entry(rt_model_t *m, rt_model_t **save) { if (__model == NULL) diag_add_hint_fn(model_diag_cb, m); *save = __model; __model = m; } static void __model_exit(rt_model_t **save) { __model = *save; *save = NULL; if (__model == NULL) diag_remove_hint_fn(model_diag_cb); } static char *fmt_values_r(const void *values, size_t len, char *buf, size_t max) { char *p = buf; const uint8_t *vptr = values; for (unsigned i = 0; i < len; i++) { if (buf + max - p <= 5) { checked_sprintf(p, buf + max - p, "..."); break; } else p += checked_sprintf(p, buf + max - p, "%02x", *vptr++); } return buf; } static const char *fmt_nexus(rt_nexus_t *n, const void *values) { static char buf[FMT_VALUES_SZ*2 + 2]; return fmt_values_r(values, n->size * n->width, buf, sizeof(buf)); } static const char *fmt_values(const void *values, uint32_t len) { static char buf[FMT_VALUES_SZ*2 + 2]; return fmt_values_r(values, len, buf, sizeof(buf)); } static const char *fmt_jit_value(jit_scalar_t value, bool scalar, uint32_t len) { static char buf[FMT_VALUES_SZ*2 + 2]; if (scalar) { checked_sprintf(buf, sizeof(buf), "%"PRIx64, value.integer); return buf; } else return fmt_values_r(value.pointer, len, buf, sizeof(buf)); } static model_thread_t *model_thread(rt_model_t *m) { #if RT_MULTITHREADED const int my_id = thread_id(); if (unlikely(m->threads[my_id] == NULL)) return (m->threads[my_id] = xcalloc(sizeof(model_thread_t))); return m->threads[my_id]; #else assert(thread_id() == 0); return m->threads[0]; #endif } __attribute__((cold, noinline)) static void deferq_grow(deferq_t *dq) { dq->max = MAX(dq->max * 2, 64); dq->tasks = xrealloc_array(dq->tasks, dq->max, sizeof(defer_task_t)); } static inline void deferq_do(deferq_t *dq, defer_fn_t fn, void *arg) { if (unlikely(dq->count == dq->max)) deferq_grow(dq); dq->tasks[dq->count++] = (defer_task_t){ fn, arg }; } static void deferq_scan(deferq_t *dq, scan_fn_t fn, void *arg) { for (int i = 0; i < dq->count; i++) (*fn)(dq->tasks[i].fn, dq->tasks[i].arg, arg); } static void deferq_shuffle(deferq_t *dq) { int cur = dq->count; while (cur > 0) { const int swap = get_random() % cur--; const defer_task_t tmp = dq->tasks[cur]; dq->tasks[cur] = dq->tasks[swap]; dq->tasks[swap] = tmp; } } static void deferq_run(rt_model_t *m, deferq_t *dq) { const defer_task_t *tasks = dq->tasks; const int count = dq->count; int i = 0; for (; i < count - 1; i++) { // Prefetch ahead the next task argument to avoid cache misses // when we execute it prefetch_read(tasks[i + 1].arg); (*tasks[i].fn)(m, tasks[i].arg); } for (; i < count; i++) (*tasks[i].fn)(m, tasks[i].arg); assert(dq->tasks == tasks); assert(dq->count == count); dq->count = 0; } static void *static_alloc(rt_model_t *m, size_t size) { const int total_bytes = ALIGN_UP(size + MEMBLOCK_REDZONE, MEMBLOCK_ALIGN); RT_LOCK(m->memlock); memblock_t *mb = m->memblocks; if (mb == NULL || mb->alloc + total_bytes > mb->limit) { const size_t pagesz = MAX(MEMBLOCK_PAGE_SZ, total_bytes + 2 * MEMBLOCK_ALIGN); mb = map_huge_pages(MEMBLOCK_ALIGN, pagesz); mb->alloc = MEMBLOCK_ALIGN; mb->limit = pagesz - MEMBLOCK_ALIGN; // Allow overreading in intrinsics ASAN_POISON(mb->data, pagesz - sizeof(memblock_t)); m->memblocks = mb; } assert((mb->alloc & (MEMBLOCK_ALIGN - 1)) == 0); void *ptr = (void *)mb + mb->alloc; mb->alloc += total_bytes; ASAN_UNPOISON(ptr, size); return ptr; } static void global_event(rt_model_t *m, rt_event_t kind) { rt_callback_t *list = m->global_cbs[kind]; m->global_cbs[kind] = NULL; for (rt_callback_t *it = list, *tmp; it; it = tmp) { tmp = it->next; (*it->fn)(m, it->user); free(it); } } static void restore_scopes(rt_model_t *m, tree_t block, rt_scope_t *parent) { rt_scope_t *s = create_scope(m, block, parent); const int nstmts = tree_stmts(block); for (int i = 0; i < nstmts; i++) { tree_t t = tree_stmt(block, i); if (tree_kind(t) == T_BLOCK) restore_scopes(m, t, s); } } rt_model_t *model_new(jit_t *jit, cover_data_t *cover) { rt_model_t *m = xcalloc(sizeof(rt_model_t)); m->scopes = hash_new(256); m->mspace = jit_get_mspace(jit); m->jit = jit; m->nexus_tail = &(m->nexuses); m->iteration = -1; m->eventq_heap = heap_new(512); m->res_memo = ihash_new(128); m->cover = cover; m->driving_heap = heap_new(64); m->effective_heap = heap_new(64); m->can_create_delta = true; m->threads[thread_id()] = static_alloc(m, sizeof(model_thread_t)); __trace_on = opt_get_int(OPT_RT_TRACE); return m; } rt_model_t *get_model(void) { assert(__model != NULL); #ifdef USE_EMUTLS assert(thread_id() == 0); #endif return __model; } rt_model_t *get_model_or_null(void) { return __model; } static rt_wakeable_t *get_active_wakeable(void) { return __model ? model_thread(__model)->active_obj : NULL; } rt_proc_t *get_active_proc(void) { rt_wakeable_t *obj = get_active_wakeable(); if (obj == NULL) return NULL; assert(obj->kind == W_PROC); return container_of(obj, rt_proc_t, wakeable); } rt_scope_t *get_active_scope(rt_model_t *m) { return model_thread(m)->active_scope; } static void free_waveform(rt_model_t *m, waveform_t *w) { model_thread_t *thread = model_thread(m); w->next = thread->free_waveforms; thread->free_waveforms = w; } static void cleanup_nexus(rt_model_t *m, rt_nexus_t *n) { for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag != SOURCE_PORT) continue; rt_conv_func_t *cf = s->u.port.conv_func; if (cf == NULL) continue; else if (cf->inputs != NULL && cf->inputs != cf->tail) { free(cf->inputs); s->u.port.conv_func->inputs = NULL; } } if (n->pending != NULL && pointer_tag(n->pending) == 0) free(n->pending); } static void cleanup_signal(rt_model_t *m, rt_signal_t *s) { rt_nexus_t *n = &(s->nexus), *tmp; for (int i = 0; i < s->n_nexus; i++, n = tmp) { tmp = n->chain; cleanup_nexus(m, n); } free(s->index); } static void cleanup_scope(rt_model_t *m, rt_scope_t *scope) { for (int i = 0; i < scope->procs.count; i++) { rt_proc_t *p = scope->procs.items[i]; mptr_free(m->mspace, &(p->privdata)); tlab_release(p->tlab); free(p); } ACLEAR(scope->procs); for (int i = 0; i < scope->signals.count; i++) cleanup_signal(m, scope->signals.items[i]); ACLEAR(scope->signals); for (int i = 0; i < scope->aliases.count; i++) free(scope->aliases.items[i]); ACLEAR(scope->aliases); for (int i = 0; i < scope->properties.count; i++) { rt_prop_t *p = scope->properties.items[i]; mask_free(&p->state); mask_free(&p->newstate); mptr_free(m->mspace, &(p->privdata)); free(p); } ACLEAR(scope->properties); for (int i = 0; i < scope->children.count; i++) cleanup_scope(m, scope->children.items[i]); ACLEAR(scope->children); mptr_free(m->mspace, &(scope->privdata)); free(scope); } void model_free(rt_model_t *m) { if (opt_get_int(OPT_RT_STATS)) { nvc_rusage_t ru; nvc_rusage(&ru); unsigned mem = 0; for (memblock_t *mb = m->memblocks; mb; mb = mb->chain) mem += mb->alloc; notef("setup:%ums run:%ums user:%ums sys:%ums maxrss:%ukB static:%ukB", m->ready_rusage.ms, ru.ms, ru.user, ru.sys, ru.rss, mem / 1024); } while (heap_size(m->eventq_heap) > 0) { void *e = heap_extract_min(m->eventq_heap); if (pointer_tag(e) == EVENT_TIMEOUT) free(untag_pointer(e, rt_callback_t)); } if (m->root != NULL) cleanup_scope(m, m->root); for (int i = 0; i < MAX_THREADS; i++) { model_thread_t *thread = m->threads[i]; if (thread != NULL) tlab_release(thread->tlab); } free(m->procq.tasks); free(m->delta_procq.tasks); free(m->postponedq.tasks); free(m->implicitq.tasks); free(m->driverq.tasks); free(m->delta_driverq.tasks); for (rt_watch_t *it = m->watches, *tmp; it; it = tmp) { tmp = it->chain_all; free(it); } for (int i = 0; i < RT_LAST_EVENT; i++) { for (rt_callback_t *it = m->global_cbs[i], *tmp; it; it = tmp) { tmp = it->next; free(it); } } for (memblock_t *mb = m->memblocks, *tmp; mb; mb = tmp) { tmp = mb->chain; nvc_munmap(mb, mb->limit + MEMBLOCK_ALIGN); } heap_free(m->effective_heap); heap_free(m->driving_heap); heap_free(m->eventq_heap); hash_free(m->scopes); ihash_free(m->res_memo); ACLEAR(m->eventsigs); free(m); } bool is_signal_scope(rt_scope_t *s) { return s->kind == SCOPE_RECORD || s->kind == SCOPE_ARRAY; } rt_signal_t *find_signal(rt_scope_t *scope, tree_t decl) { for (int i = 0; i < scope->signals.count; i++) { if (scope->signals.items[i]->where == decl) return scope->signals.items[i]; } for (int i = 0; i < scope->aliases.count; i++) { if (scope->aliases.items[i]->where == decl) return scope->aliases.items[i]->signal; } return NULL; } rt_proc_t *find_proc(rt_scope_t *scope, tree_t proc) { for (int i = 0; i < scope->procs.count; i++) { if (scope->procs.items[i]->where == proc) return scope->procs.items[i]; } return NULL; } rt_watch_t *find_watch(rt_nexus_t *n, sig_event_fn_t fn) { if (n->pending == NULL) return NULL; else if (pointer_tag(n->pending) == 1) { rt_wakeable_t *obj = untag_pointer(n->pending, rt_wakeable_t); if (obj->kind == W_WATCH) { rt_watch_t *w = container_of(obj, rt_watch_t, wakeable); if (w->fn == fn) return w; } return NULL; } else { rt_pending_t *p = untag_pointer(n->pending, rt_pending_t); for (int i = 0; i < p->count; i++) { rt_wakeable_t *obj = untag_pointer(p->wake[i], rt_wakeable_t); if (obj->kind == W_WATCH) { rt_watch_t *w = container_of(obj, rt_watch_t, wakeable); if (w->fn == fn) return w; } } return NULL; } } rt_scope_t *create_scope(rt_model_t *m, tree_t block, rt_scope_t *parent) { if (parent == NULL) { assert(m->top == NULL); assert(tree_kind(block) == T_ELAB); m->top = block; m->root = xcalloc(sizeof(rt_scope_t)); m->root->kind = SCOPE_ROOT; m->root->where = block; m->root->privdata = MPTR_INVALID; m->root->name = lib_name(lib_work()); if (tree_stmts(block) > 0) restore_scopes(m, tree_stmt(block, 0), m->root); return m->root; } else { rt_scope_t *s = xcalloc(sizeof(rt_scope_t)); s->where = block; s->kind = SCOPE_INSTANCE; s->privdata = mptr_new(m->mspace, "block privdata"); s->parent = parent; s->name = ident_prefix(parent->name, tree_ident(block), '.'); APUSH(parent->children, s); hash_put(m->scopes, block, s); MODEL_ENTRY(m); TRACE("initialise scope %s", istr(s->name)); model_thread_t *thread = model_thread(m); thread->active_scope = s; jit_handle_t handle = jit_lazy_compile(m->jit, s->name); if (handle == JIT_HANDLE_INVALID) fatal_trace("failed to compile %s", istr(s->name)); jit_scalar_t result, context = { .pointer = NULL }; jit_scalar_t p2 = { .integer = 0 }; if (s->parent->kind != SCOPE_ROOT) context.pointer = *mptr_get(s->parent->privdata); tlab_t tlab = jit_null_tlab(m->jit); if (jit_fastcall(m->jit, handle, &result, context, p2, &tlab)) *mptr_get(s->privdata) = result.pointer; else m->force_stop = true; assert(thread->active_scope == s); thread->active_scope = NULL; return s; } } rt_scope_t *find_scope(rt_model_t *m, tree_t container) { return hash_get(m->scopes, container); } rt_scope_t *root_scope(rt_model_t *m) { return m->root; } rt_scope_t *child_scope(rt_scope_t *scope, tree_t decl) { for (int i = 0; i < scope->children.count; i++) { rt_scope_t *s = scope->children.items[i]; if (s->where == decl) return s; } return NULL; } rt_scope_t *child_scope_at(rt_scope_t *scope, int index) { return AGET(scope->children, index); } const void *signal_value(rt_signal_t *s) { return s->shared.data; } const void *signal_last_value(rt_signal_t *s) { return s->shared.data + s->shared.size; } uint8_t signal_size(rt_signal_t *s) { return s->nexus.size; } uint32_t signal_width(rt_signal_t *s) { return s->shared.size / s->nexus.size; } size_t signal_expand(rt_signal_t *s, uint64_t *buf, size_t max) { const size_t total = s->shared.size / s->nexus.size; #define SIGNAL_READ_EXPAND_U64(type) do { \ const type *sp = (type *)s->shared.data; \ for (int i = 0; i < max && i < total; i++) \ buf[i] = sp[i]; \ } while (0) FOR_ALL_SIZES(s->nexus.size, SIGNAL_READ_EXPAND_U64); return total; } static inline void set_pending(rt_wakeable_t *wake) { assert(!wake->pending); assert(!wake->delayed); wake->pending = true; } static void deltaq_insert_proc(rt_model_t *m, uint64_t delta, rt_proc_t *proc) { if (delta == 0) { set_pending(&proc->wakeable); deferq_do(&m->delta_procq, async_run_process, proc); m->next_is_delta = true; } else { assert(!proc->wakeable.delayed); proc->wakeable.delayed = true; void *e = tag_pointer(proc, EVENT_PROCESS); heap_insert(m->eventq_heap, m->now + delta, e); } } static void deltaq_insert_driver(rt_model_t *m, uint64_t delta, rt_source_t *source) { if (delta == 0) { deferq_do(&m->delta_driverq, async_update_driver, source); m->next_is_delta = true; } else { void *e = tag_pointer(source, EVENT_DRIVER); heap_insert(m->eventq_heap, m->now + delta, e); } } static void deltaq_insert_pseudo_source(rt_model_t *m, rt_source_t *src) { deferq_do(&m->delta_driverq, async_pseudo_source, src); m->next_is_delta = true; } static void reset_process(rt_model_t *m, rt_proc_t *proc) { TRACE("reset process %s", istr(proc->name)); assert(proc->tlab == NULL); assert(model_thread(m)->tlab == NULL); // Not used during reset model_thread_t *thread = model_thread(m); thread->active_obj = &(proc->wakeable); thread->active_scope = proc->scope; jit_scalar_t context = { .pointer = *mptr_get(proc->scope->privdata) }; jit_scalar_t state = { .pointer = NULL }; jit_scalar_t result; tlab_t tlab = jit_null_tlab(m->jit); if (jit_fastcall(m->jit, proc->handle, &result, state, context, &tlab)) *mptr_get(proc->privdata) = result.pointer; else m->force_stop = true; thread->active_obj = NULL; thread->active_scope = NULL; // Schedule the process to run immediately deltaq_insert_proc(m, 0, proc); } static void reset_property(rt_model_t *m, rt_prop_t *prop) { TRACE("reset property %s", istr(prop->name)); assert(model_thread(m)->tlab == NULL); // Not used during reset model_thread_t *thread = model_thread(m); thread->active_obj = &(prop->wakeable); thread->active_scope = prop->scope; tlab_t tlab = jit_null_tlab(m->jit); jit_scalar_t args[] = { { .pointer = NULL }, { .pointer = *mptr_get(prop->scope->privdata) }, { .integer = -1 }, }, results[2]; if (jit_vfastcall(m->jit, prop->handle, args, ARRAY_LEN(args), results, ARRAY_LEN(results), &tlab)) *mptr_get(prop->privdata) = results[0].pointer; else m->force_stop = true; TRACE("needs %"PRIi64" state bits", results[1].integer); mask_init(&prop->state, results[1].integer); mask_init(&prop->newstate, results[1].integer); mask_set(&prop->state, 0); mask_set(&prop->state, results[1].integer - 1); // Update prev() variables thread->active_obj = NULL; thread->active_scope = NULL; } static void run_process(rt_model_t *m, rt_proc_t *proc) { TRACE("run %sprocess %s", *mptr_get(proc->privdata) ? "" : "stateless ", istr(proc->name)); rt_wakeable_t *obj = &(proc->wakeable); if (obj->trigger != NULL && !run_trigger(m, obj->trigger)) return; // Filtered model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); assert(thread->tlab->alloc == 0); thread->active_obj = obj; thread->active_scope = proc->scope; // Stateless processes have NULL privdata so pass a dummy pointer // value in so it can be distinguished from a reset jit_scalar_t state = { .pointer = *mptr_get(proc->privdata) ?: (void *)-1 }; jit_scalar_t result; jit_scalar_t context = { .pointer = *mptr_get(proc->scope->privdata) }; if (!jit_fastcall(m->jit, proc->handle, &result, state, context, proc->tlab ?: thread->tlab)) m->force_stop = true; if (proc->tlab != NULL && result.pointer == NULL) { tlab_release(proc->tlab); proc->tlab = NULL; } else if (proc->tlab == NULL && result.pointer != NULL) { TRACE("claiming TLAB for private use (used %u/%u)", thread->tlab->alloc, thread->tlab->limit); proc->tlab = thread->tlab; thread->tlab = tlab_acquire(m->mspace); } else if (proc->tlab == NULL) tlab_reset(thread->tlab); // All data inside the TLAB is dead thread->active_obj = NULL; thread->active_scope = NULL; } static void reset_scope(rt_model_t *m, rt_scope_t *s) { for (int i = 0; i < s->children.count; i++) reset_scope(m, s->children.items[i]); for (int i = 0; i < s->procs.count; i++) reset_process(m, s->procs.items[i]); for (int i = 0; i < s->properties.count; i++) reset_property(m, s->properties.items[i]); } static res_memo_t *memo_resolution_fn(rt_model_t *m, rt_signal_t *signal, ffi_closure_t closure, int32_t nlits, res_flags_t flags) { // Optimise some common resolution functions by memoising them res_memo_t *memo = ihash_get(m->res_memo, closure.handle); if (memo != NULL) return memo; memo = static_alloc(m, sizeof(res_memo_t)); memo->closure = closure; memo->flags = flags; ihash_put(m->res_memo, memo->closure.handle, memo); if (nlits == 0 || nlits > 16) return memo; const vhdl_severity_t old_severity = set_exit_severity(SEVERITY_NOTE); jit_set_silent(m->jit, true); // Memoise the function for all two value cases for (int i = 0; i < nlits; i++) { for (int j = 0; j < nlits; j++) { int8_t args[2] = { i, j }; jit_scalar_t result; if (jit_try_call(m->jit, memo->closure.handle, &result, memo->closure.context, args, 2)) { assert(result.integer < nlits && result.integer >= 0); memo->tab2[i][j] = result.integer; } } } // Memoise the function for all single value cases and determine if the // function behaves like the identity function bool identity = true; for (int i = 0; i < nlits; i++) { int8_t args[1] = { i }; jit_scalar_t result; if (jit_try_call(m->jit, memo->closure.handle, &result, memo->closure.context, args, 1)) { memo->tab1[i] = result.integer; identity = identity && (memo->tab1[i] == i); } } if (model_exit_status(m) == 0) { memo->flags |= R_MEMO; if (identity) memo->flags |= R_IDENT; } TRACE("memoised resolution function %s for type %s", istr(jit_get_name(m->jit, closure.handle)), type_pp(tree_type(signal->where))); jit_set_silent(m->jit, false); jit_reset_exit_status(m->jit); set_exit_severity(old_severity); return memo; } static inline void *nexus_effective(rt_nexus_t *n) { return n->signal->shared.data + n->offset; } static inline void *nexus_last_value(rt_nexus_t *n) { return n->signal->shared.data + n->offset + n->signal->shared.size; } static inline void *nexus_driving(rt_nexus_t *n) { assert(n->flags & NET_F_EFFECTIVE); return n->signal->shared.data + n->offset + 2*n->signal->shared.size; } static inline void *nexus_initial(rt_nexus_t *n) { assert(n->flags & NET_F_HAS_INITIAL); return n->signal->shared.data + n->offset + 2*n->signal->shared.size; } static rt_value_t alloc_value(rt_model_t *m, rt_nexus_t *n) { rt_value_t result = {}; const size_t valuesz = n->size * n->width; if (valuesz > sizeof(rt_value_t)) { if (n->free_value != NULL) { result.ext = n->free_value; n->free_value = *(void **)result.ext; } else result.ext = static_alloc(m, valuesz); } return result; } static void free_value(rt_nexus_t *n, rt_value_t v) { const size_t valuesz = n->width * n->size; if (valuesz > sizeof(rt_value_t)) { *(void **)v.ext = n->free_value; n->free_value = v.ext; } } static inline uint8_t *value_ptr(rt_nexus_t *n, rt_value_t *v) { const size_t valuesz = n->width * n->size; if (valuesz <= sizeof(rt_value_t)) return v->bytes; else return v->ext; } static void copy_value_ptr(rt_nexus_t *n, rt_value_t *v, const void *p) { const size_t valuesz = n->width * n->size; if (valuesz <= sizeof(rt_value_t)) { #if ASAN_ENABLED memcpy(v->bytes, p, valuesz); #else v->qword = unaligned_load(p, uint64_t); #endif } else memcpy(v->ext, p, valuesz); } static inline bool cmp_values(rt_nexus_t *n, rt_value_t a, rt_value_t b) { const size_t valuesz = n->width * n->size; if (valuesz <= sizeof(rt_value_t)) return a.qword == b.qword; else return cmp_bytes(a.ext, b.ext, valuesz); } static inline bool is_pseudo_source(source_kind_t kind) { return kind == SOURCE_FORCING || kind == SOURCE_DEPOSIT || kind == SOURCE_IMPLICIT; } static void check_multiple_sources(rt_nexus_t *n, source_kind_t kind) { if (n->signal->resolution != NULL || is_pseudo_source(kind)) return; diag_t *d; if (is_signal_scope(n->signal->parent)) { rt_scope_t *root = n->signal->parent; for (; is_signal_scope(root->parent); root = root->parent); d = diag_new(DIAG_FATAL, tree_loc(root->where)); diag_printf(d, "element %s of signal %s has multiple sources", istr(tree_ident(n->signal->where)), istr(tree_ident(root->where))); diag_hint(d, tree_loc(n->signal->where), "element %s declared here", istr(tree_ident(n->signal->where))); diag_hint(d, tree_loc(root->where), "composite signal %s declared with " "unresolved type %s", istr(tree_ident(root->where)), type_pp(tree_type(root->where))); } else { d = diag_new(DIAG_FATAL, tree_loc(n->signal->where)); diag_printf(d, "unresolved signal %s has multiple sources", istr(tree_ident(n->signal->where))); diag_hint(d, tree_loc(n->signal->where), "signal %s declared with " "unresolved type %s", istr(tree_ident(n->signal->where)), type_pp(tree_type(n->signal->where))); } if (n->sources.tag == SOURCE_DRIVER) { const rt_proc_t *p = n->sources.u.driver.proc; diag_hint(d, tree_loc(p->where), "driven by process %s", istr(p->name)); } else if (n->sources.tag == SOURCE_PORT) { const rt_signal_t *s = n->sources.u.port.input->signal; tree_t where = s->where; if (is_signal_scope(s->parent)) { for (rt_scope_t *it = s->parent; is_signal_scope(it); it = it->parent) where = it->where; } if (tree_kind(where) == T_PORT_DECL) diag_hint(d, tree_loc(where), "connected to %s port %s", port_mode_str(tree_subkind(where)), istr(tree_ident(where))); else diag_hint(d, tree_loc(where), "connected to signal %s", istr(tree_ident(where))); } if (kind == SOURCE_DRIVER) { const rt_proc_t *p = get_active_proc(); diag_hint(d, tree_loc(p->where), "driven by process %s", istr(p->name)); } diag_emit(d); jit_abort_with_status(EXIT_FAILURE); } static rt_source_t *add_source(rt_model_t *m, rt_nexus_t *n, source_kind_t kind) { rt_source_t *src = NULL; if (n->n_sources == 0) src = &(n->sources); else { check_multiple_sources(n, kind); rt_source_t **p; for (p = &(n->sources.chain_input); *p; p = &((*p)->chain_input)) ; *p = src = static_alloc(m, sizeof(rt_source_t)); } // The only interesting values of n_sources are 0, 1, and 2 if (n->n_sources < UINT8_MAX) n->n_sources++; if (n->n_sources > 1) n->flags &= ~NET_F_FAST_DRIVER; src->chain_input = NULL; src->chain_output = NULL; src->tag = kind; src->disconnected = 0; src->fastqueued = 0; src->sigqueued = 0; src->pseudoqueued = 0; switch (kind) { case SOURCE_DRIVER: { src->u.driver.proc = NULL; src->u.driver.nexus = n; waveform_t *w0 = &(src->u.driver.waveforms); w0->when = TIME_HIGH; w0->next = NULL; } break; case SOURCE_PORT: src->u.port.conv_func = NULL; src->u.port.input = NULL; src->u.port.output = n; break; case SOURCE_DEPOSIT: case SOURCE_FORCING: case SOURCE_IMPLICIT: src->u.pseudo.nexus = n; src->u.pseudo.value = alloc_value(m, n); break; } return src; } static inline int map_index(rt_index_t *index, unsigned offset) { if (likely(index->how >= 0)) return offset >> index->how; else return offset / -(index->how); } static inline int unmap_index(rt_index_t *index, unsigned key) { if (likely(index->how >= 0)) return key << index->how; else return key * -(index->how); } static inline bool index_valid(rt_index_t *index, unsigned offset) { if (likely(index->how >= 0)) return (offset >> index->how) << index->how == offset; else return offset % -(index->how) == 0; } static void build_index(rt_signal_t *signal) { const unsigned signal_w = signal->shared.size / signal->nexus.size; int shift = INT_MAX, gcd = 0; rt_nexus_t *n = &(signal->nexus); for (int i = 0, offset = 0; i < signal->n_nexus; i++, offset += n->width, n = n->chain) { if (offset > 0) { const int tzc = __builtin_ctz(offset); shift = MIN(shift, tzc); } // Compute greatest common divisor for (int b = offset; b > 0;) { int temp = b; b = gcd % b; gcd = temp; } } const int how = gcd > 1 && gcd > (1 << shift) && gcd > 1 ? -gcd : shift; const int count = how < 0 ? (signal_w - how - 1) / -how : (signal_w >> shift) + 1; TRACE("create index for signal %s how=%d count=%d", istr(tree_ident(signal->where)), how, count); rt_index_t *index = xcalloc_flex(sizeof(rt_index_t), count, sizeof(rt_nexus_t *)); index->how = how; n = &(signal->nexus); for (int i = 0, offset = 0; i < signal->n_nexus; i++, offset += n->width, n = n->chain) { index->nexus[map_index(index, offset)] = n; } free(signal->index); signal->index = index; } static void update_index(rt_signal_t *s, rt_nexus_t *n) { const unsigned offset = n->offset / n->size; if (!index_valid(s->index, offset)) { TRACE("rebuild index for %s offset=%d how=%d", istr(tree_ident(s->where)), offset, s->index->how); build_index(s); assert(s->index->nexus[map_index(s->index, offset)] == n); } else { const int elt = map_index(s->index, offset); assert(s->index->nexus[elt] == NULL); s->index->nexus[elt] = n; } } static rt_nexus_t *lookup_index(rt_signal_t *s, int *offset) { if (likely(offset == 0 || s->index == NULL)) return &(s->nexus); else if (!index_valid(s->index, *offset)) { TRACE("invalid index for %s offset=%d how=%d", istr(tree_ident(s->where)), *offset, s->index->how); free(s->index); s->index = NULL; return &(s->nexus); } else { const int key = map_index(s->index, *offset); for (int k = key; k >= 0; k--) { rt_nexus_t *n = s->index->nexus[k]; if (n != NULL) { *offset = unmap_index(s->index, key - k); return n; } } return &(s->nexus); } } static waveform_t *alloc_waveform(rt_model_t *m) { model_thread_t *thread = model_thread(m); if (thread->free_waveforms == NULL) { // Ensure waveforms are always within one cache line STATIC_ASSERT(sizeof(waveform_t) <= 32); char *mem = static_alloc(m, WAVEFORM_CHUNK * 32); for (int i = 1; i < WAVEFORM_CHUNK; i++) free_waveform(m, (waveform_t *)(mem + i*32)); return (waveform_t *)mem; } else { waveform_t *w = thread->free_waveforms; thread->free_waveforms = w->next; prefetch_write(w->next); w->next = NULL; return w; } } static void add_conversion_input(rt_model_t *m, rt_conv_func_t *cf, rt_nexus_t *in) { if (cf->ninputs == cf->maxinputs) { const size_t per_block = MEMBLOCK_ALIGN / sizeof(conv_input_t); cf->maxinputs = ALIGN_UP(MAX(4, cf->maxinputs * 2), per_block); if (cf->inputs == cf->tail) { void *new = xmalloc_array(cf->maxinputs, sizeof(conv_input_t)); memcpy(new, cf->inputs, cf->ninputs * sizeof(conv_input_t)); cf->inputs = new; } else cf->inputs = xrealloc_array(cf->inputs, cf->maxinputs, sizeof(conv_input_t)); } cf->inputs[cf->ninputs++] = (conv_input_t){ .nexus = in, .result = alloc_value(m, in), }; } static rt_value_t *find_conversion_input(rt_conv_func_t *cf, rt_nexus_t *n) { for (int i = 0; i < cf->ninputs; i++) { if (cf->inputs[i].nexus == n) return &(cf->inputs[i].result); } return NULL; } static void split_value(rt_nexus_t *nexus, rt_value_t *v_new, rt_value_t *v_old, int offset) { const int split = offset * nexus->size; const int oldsz = (offset + nexus->width) * nexus->size; const int newsz = nexus->width * nexus->size; if (split > sizeof(rt_value_t) && newsz > sizeof(rt_value_t)) { // Split the external memory with no copying v_new->ext = (char *)v_old->ext + split; } else if (newsz > sizeof(rt_value_t)) { // Wasting up to eight bytes at the start of the the old waveform char *ext = v_old->ext; v_old->qword = *(uint64_t *)ext; v_new->ext = ext + split; } else if (split > sizeof(rt_value_t)) { // Wasting up to eight bytes at the end of the the old waveform memcpy(v_new->bytes, v_old->ext + split, newsz); } else if (oldsz > sizeof(rt_value_t)) { // The memory backing this waveform is lost now but this can only // happen a bounded number of times as nexuses only ever shrink char *ext = v_old->ext; memcpy(v_new->bytes, ext + split, newsz); v_old->qword = *(uint64_t *)ext; } else { // This trick with shifting probably only works on little-endian // systems v_new->qword = v_old->qword >> (split * 8); } } static void clone_source(rt_model_t *m, rt_nexus_t *nexus, rt_source_t *old, int offset) { rt_source_t *new = add_source(m, nexus, old->tag); switch (old->tag) { case SOURCE_PORT: { new->u.port.input = old->u.port.input; if (old->u.port.conv_func != NULL) { new->u.port.conv_func = old->u.port.conv_func; new->u.port.conv_result = alloc_value(m, nexus); rt_source_t **p = &(old->u.port.conv_func->outputs); for (; *p != NULL; p = &((*p)->chain_output)); *p = new; } else { if (old->u.port.input->width == offset) new->u.port.input = old->u.port.input->chain; // Cycle breaking else { RT_LOCK(old->u.port.input->signal->lock); rt_nexus_t *n = clone_nexus(m, old->u.port.input, offset); new->u.port.input = n; } assert(new->u.port.input->width == nexus->width); } } break; case SOURCE_DRIVER: { new->u.driver.proc = old->u.driver.proc; // Current transaction waveform_t *w_new = &(new->u.driver.waveforms); waveform_t *w_old = &(old->u.driver.waveforms); w_new->when = w_old->when; w_new->next = NULL; split_value(nexus, &w_new->value, &w_old->value, offset); // Pending fast driver update if ((nexus->flags & NET_F_FAST_DRIVER) && old->fastqueued) { rt_nexus_t *n0 = &(nexus->signal->nexus); if (!n0->sources.sigqueued) deferq_do(&m->delta_driverq, async_fast_driver, new); new->fastqueued = 1; } new->was_active = old->was_active; // Future transactions for (w_old = w_old->next; w_old; w_old = w_old->next) { w_new = (w_new->next = alloc_waveform(m)); w_new->when = w_old->when; w_new->next = NULL; split_value(nexus, &w_new->value, &w_old->value, offset); assert(w_old->when >= m->now); deltaq_insert_driver(m, w_new->when - m->now, new); } } break; case SOURCE_FORCING: case SOURCE_DEPOSIT: split_value(nexus, &(new->u.pseudo.value), &(old->u.pseudo.value), offset); assert(!old->pseudoqueued); // TODO break; case SOURCE_IMPLICIT: break; } } static rt_nexus_t *clone_nexus(rt_model_t *m, rt_nexus_t *old, int offset) { assert(offset < old->width); rt_signal_t *signal = old->signal; MULTITHREADED_ONLY(assert_lock_held(&signal->lock)); signal->n_nexus++; if (signal->n_nexus == 2 && (old->flags & NET_F_FAST_DRIVER)) signal->shared.flags |= NET_F_FAST_DRIVER; rt_nexus_t *new = static_alloc(m, sizeof(rt_nexus_t)); new->width = old->width - offset; new->size = old->size; new->signal = signal; new->offset = old->offset + offset * old->size; new->chain = old->chain; new->flags = old->flags; new->active_delta = old->active_delta; new->event_delta = old->event_delta; new->last_event = old->last_event; new->rank = old->rank; old->chain = new; old->width = offset; if (old->pending == NULL) new->pending = NULL; else if (pointer_tag(old->pending) == 1) new->pending = old->pending; else { rt_pending_t *old_p = untag_pointer(old->pending, rt_pending_t); rt_pending_t *new_p = xmalloc_flex(sizeof(rt_pending_t), old_p->count, sizeof(rt_wakeable_t *)); new_p->count = new_p->max = old_p->count; for (int i = 0; i < old_p->count; i++) new_p->wake[i] = old_p->wake[i]; new->pending = tag_pointer(new_p, 0); } if (new->chain == NULL) m->nexus_tail = &(new->chain); if (old->n_sources > 0) { for (rt_source_t *it = &(old->sources); it; it = it->chain_input) clone_source(m, new, it, offset); } for (rt_source_t *old_o = old->outputs; old_o; old_o = old_o->chain_output) { assert(old_o->tag == SOURCE_PORT || old_o->tag == SOURCE_IMPLICIT); if (old_o->tag == SOURCE_PORT && old_o->u.port.conv_func != NULL) { new->outputs = old_o; add_conversion_input(m, old_o->u.port.conv_func, new); } else { rt_nexus_t *out_n; if (old_o->tag == SOURCE_IMPLICIT) out_n = old_o->u.port.output; else if (old_o->u.port.output->width == offset) out_n = old_o->u.port.output->chain; // Cycle breaking else { RT_LOCK(old_o->u.port.output->signal->lock); out_n = clone_nexus(m, old_o->u.port.output, offset); } for (rt_source_t *s = &(out_n->sources); s; s = s->chain_input) { if (s->tag != old_o->tag) continue; else if (s->u.port.input == new || s->u.port.input == old) { s->u.port.input = new; s->chain_output = new->outputs; new->outputs = s; break; } } } } if (signal->index == NULL && signal->n_nexus >= NEXUS_INDEX_MIN) build_index(signal); else if (signal->index != NULL) update_index(signal, new); return new; } static rt_nexus_t *split_nexus_slow(rt_model_t *m, rt_signal_t *s, int offset, int count) { rt_nexus_t *result = NULL; for (rt_nexus_t *it = lookup_index(s, &offset); count > 0; it = it->chain) { if (offset >= it->width) { offset -= it->width; continue; } else if (offset > 0) { clone_nexus(m, it, offset); offset = 0; continue; } else { if (it->width > count) clone_nexus(m, it, count); count -= it->width; if (result == NULL) result = it; } } return result; } static inline rt_nexus_t *split_nexus(rt_model_t *m, rt_signal_t *s, int offset, int count) { MULTITHREADED_ONLY(assert_lock_held(&s->lock)); rt_nexus_t *n0 = &(s->nexus); if (likely(offset == 0 && n0->width == count)) return n0; else if (offset == 0 && count == s->shared.size / n0->size) return n0; return split_nexus_slow(m, s, offset, count); } static void setup_signal(rt_model_t *m, rt_signal_t *s, tree_t where, unsigned count, unsigned size, sig_flags_t flags, unsigned offset) { rt_scope_t *parent = model_thread(m)->active_scope; s->where = where; s->n_nexus = 1; s->offset = offset; s->parent = parent; s->shared.flags = flags; s->shared.size = count * size; APUSH(parent->signals, s); s->nexus.width = count; s->nexus.size = size; s->nexus.n_sources = 0; s->nexus.offset = 0; s->nexus.flags = flags | NET_F_FAST_DRIVER | NET_F_HAS_INITIAL; s->nexus.signal = s; s->nexus.pending = NULL; s->nexus.active_delta = DELTA_CYCLE_MAX; s->nexus.event_delta = DELTA_CYCLE_MAX; s->nexus.last_event = TIME_HIGH; *m->nexus_tail = &(s->nexus); m->nexus_tail = &(s->nexus.chain); m->n_signals++; } static void copy_sub_signal_sources(rt_scope_t *scope, void *buf, int stride) { assert(is_signal_scope(scope)); for (int i = 0; i < scope->signals.count; i++) { rt_signal_t *s = scope->signals.items[i]; rt_nexus_t *n = &(s->nexus); for (unsigned i = 0; i < s->n_nexus; i++) { unsigned o = 0; for (rt_source_t *src = &(n->sources); src; src = src->chain_input) { const void *data = source_value(n, src); if (data == NULL) continue; memcpy(buf + s->offset + (o++ * stride), data, n->size * n->width); } } } for (int i = 0; i < scope->children.count; i++) copy_sub_signal_sources(scope->children.items[i], buf, stride); } static void convert_driving(rt_conv_func_t *cf) { rt_model_t *m = get_model(); if (cf->effective.handle == JIT_HANDLE_INVALID) { // Ensure effective value is only updated once per cycle if (cf->when == m->now && cf->iteration == m->iteration) return; cf->when = m->now; cf->iteration = m->iteration; } TRACE("call driving conversion function %s", istr(jit_get_name(m->jit, cf->driving.handle))); model_thread_t *thread = model_thread(m); jit_scalar_t context = { .pointer = cf->driving.context }; jit_scalar_t arg = { .pointer = cf }, result; if (!jit_fastcall(m->jit, cf->driving.handle, &result, context, arg, thread->tlab)) m->force_stop = true; tlab_reset(thread->tlab); // No allocations can be live past here } static void convert_effective(rt_conv_func_t *cf) { rt_model_t *m = get_model(); // Ensure effective value is only updated once per cycle if (cf->when == m->now && cf->iteration == m->iteration) return; cf->when = m->now; cf->iteration = m->iteration; TRACE("call effective conversion function %s", istr(jit_get_name(m->jit, cf->effective.handle))); model_thread_t *thread = model_thread(m); jit_scalar_t context = { .pointer = cf->effective.context }; jit_scalar_t arg = { .pointer = cf }, result; if (!jit_fastcall(m->jit, cf->effective.handle, &result, context, arg, thread->tlab)) m->force_stop = true; tlab_reset(thread->tlab); // No allocations can be live past here } static void *source_value(rt_nexus_t *nexus, rt_source_t *src) { switch (src->tag) { case SOURCE_DRIVER: if (unlikely(src->disconnected)) return NULL; else return value_ptr(nexus, &(src->u.driver.waveforms.value)); case SOURCE_PORT: if (likely(src->u.port.conv_func == NULL)) { if (src->u.port.input->flags & NET_F_EFFECTIVE) return nexus_driving(src->u.port.input); else return nexus_effective(src->u.port.input); } else { convert_driving(src->u.port.conv_func); return value_ptr(nexus, &src->u.port.conv_result); } case SOURCE_FORCING: case SOURCE_DEPOSIT: assert(src->disconnected); return NULL; case SOURCE_IMPLICIT: return NULL; } return NULL; } static void call_resolution(rt_model_t *m, rt_nexus_t *n, res_memo_t *r, int nonnull, rt_source_t *s0) { if ((n->flags & NET_F_R_IDENT) && nonnull == 1) { // Resolution function behaves like identity for a single driver put_driving(m, n, source_value(n, s0)); } else if ((r->flags & R_MEMO) && nonnull == 1) { // Resolution function has been memoised so do a table lookup model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); void *resolved = tlab_alloc(thread->tlab, n->width * n->size); char *p0 = source_value(n, s0); for (int j = 0; j < n->width; j++) { const int index = ((uint8_t *)p0)[j]; ((int8_t *)resolved)[j] = r->tab1[index]; } put_driving(m, n, resolved); tlab_reset(thread->tlab); // No allocations can be live past here } else if ((r->flags & R_MEMO) && nonnull == 2) { // Resolution function has been memoised so do a table lookup model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); void *resolved = tlab_alloc(thread->tlab, n->width * n->size); char *p0 = source_value(n, s0), *p1 = NULL; for (rt_source_t *s1 = s0->chain_input; s1 && (p1 = source_value(n, s1)) == NULL; s1 = s1->chain_input) ; for (int j = 0; j < n->width; j++) ((int8_t *)resolved)[j] = r->tab2[(int)p0[j]][(int)p1[j]]; put_driving(m, n, resolved); tlab_reset(thread->tlab); // No allocations can be live past here } else if (r->flags & R_COMPOSITE) { // Call resolution function of composite type rt_scope_t *scope = n->signal->parent, *rscope = scope; while (is_signal_scope(scope->parent)) { scope = scope->parent; if (scope->flags & SCOPE_F_RESOLVED) rscope = scope; } TRACE("resolved composite signal needs %d bytes", scope->size); model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); uint8_t *inputs = tlab_alloc(thread->tlab, nonnull * scope->size); copy_sub_signal_sources(scope, inputs, scope->size); jit_scalar_t result; if (jit_try_call(m->jit, r->closure.handle, &result, r->closure.context, inputs, nonnull)) put_driving(m, n, result.pointer + n->signal->offset + n->offset - rscope->offset); else m->force_stop = true; tlab_reset(thread->tlab); // No allocations can be live past here } else { model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); void *resolved = tlab_alloc(thread->tlab, n->width * n->size); for (int j = 0; j < n->width; j++) { #define CALL_RESOLUTION_FN(type) do { \ type vals[nonnull]; \ unsigned o = 0; \ for (rt_source_t *s = s0; s; s = s->chain_input) { \ const void *data = source_value(n, s); \ if (data != NULL) \ vals[o++] = ((const type *)data)[j]; \ } \ assert(o == nonnull); \ type *p = (type *)resolved; \ jit_scalar_t result; \ if (!jit_try_call(m->jit, r->closure.handle, &result, \ r->closure.context, vals, nonnull)) \ m->force_stop = true; \ p[j] = result.integer; \ } while (0) FOR_ALL_SIZES(n->size, CALL_RESOLUTION_FN); } put_driving(m, n, resolved); tlab_reset(thread->tlab); // No allocations can be live past here } } static rt_source_t *get_pseudo_source(rt_model_t *m, rt_nexus_t *n, source_kind_t kind) { assert(is_pseudo_source(kind)); if (n->n_sources > 0) { for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag == kind) return s; } } return add_source(m, n, kind); } __attribute__((cold, noinline)) static void schedule_implicit_update(rt_model_t *m, rt_nexus_t *n) { rt_implicit_t *imp = container_of(n->signal, rt_implicit_t, signal); if (!imp->wakeable.pending) { deferq_do(&m->implicitq, async_update_implicit_signal, imp); set_pending(&imp->wakeable); } } static void calculate_driving_value(rt_model_t *m, rt_nexus_t *n) { // Algorithm for driving values is in LRM 08 section 14.7.3.2 // If S has no source, then the driving value of S is given by the // default value associated with S if (n->n_sources == 0) { put_driving(m, n, nexus_initial(n)); return; } res_memo_t *r = n->signal->resolution; int nonnull = 0; rt_source_t *s0 = NULL; for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->disconnected) continue; else if (s->tag == SOURCE_FORCING) { // If S is driving-value forced, the driving value of S is // unchanged from its previous value; no further steps are // required. put_driving(m, n, value_ptr(n, &(s->u.pseudo.value))); return; } else if (s->tag == SOURCE_DEPOSIT) { // If a driving-value deposit is scheduled for S or for a // signal of which S is a subelement, the driving value of S is // the driving deposit value for S or the element of the // driving deposit value for the signal of which S is a // subelement, as appropriate. s->disconnected = 1; put_driving(m, n, value_ptr(n, &(s->u.pseudo.value))); return; } else if (unlikely(s->tag == SOURCE_IMPLICIT)) { // At least one of the inputs is active so schedule an update // to the value of an implicit 'TRANSACTION or 'QUIET signal schedule_implicit_update(m, n); return; } else if (s0 == NULL) s0 = s; nonnull++; } if (unlikely(s0 == NULL)) { // If S is of signal kind register and all the sources of S have // values determined by the null transaction, then the driving // value of S is unchanged from its previous value. if (n->signal->shared.flags & SIG_F_REGISTER) put_driving(m, n, nexus_effective(n)); else if (r == NULL || is_pseudo_source(n->sources.tag)) put_driving(m, n, nexus_initial(n)); else call_resolution(m, n, r, nonnull, s0); } else if (r == NULL) { switch (s0->tag) { case SOURCE_DRIVER: // If S has one source that is a driver and S is not a resolved // signal, then the driving value of S is the current value of // that driver. assert(!s0->disconnected); put_driving(m, n, value_ptr(n, &(s0->u.driver.waveforms.value))); break; case SOURCE_PORT: // If S has one source that is a port and S is not a resolved // signal, then the driving value of S is the driving value of // the formal part of the association element that associates S // with that port if (likely(s0->u.port.conv_func == NULL)) { if (s0->u.port.input->flags & NET_F_EFFECTIVE) put_driving(m, n, nexus_driving(s0->u.port.input)); else put_driving(m, n, nexus_effective(s0->u.port.input)); } else { convert_driving(s0->u.port.conv_func); put_driving(m, n, value_ptr(n, &(s0->u.port.conv_result))); } break; default: break; } } else { // Otherwise, the driving value of S is obtained by executing the // resolution function associated with S call_resolution(m, n, r, nonnull, s0); } } static void calculate_effective_value(rt_model_t *m, rt_nexus_t *n) { // Algorithm for effective values is in LRM 08 section 14.7.7.3 // If S is a connected port of mode in or inout, then the effective // value of S is the same as the effective value of the actual part // of the association element that associates an actual with S if (n->flags & NET_F_INOUT) { for (rt_source_t *s = n->outputs; s; s = s->chain_output) { if (s->tag == SOURCE_PORT) { if (likely(s->u.port.conv_func == NULL)) put_effective(m, n, nexus_effective(s->u.port.output)); else { rt_value_t *v = find_conversion_input(s->u.port.conv_func, n); assert(v != NULL); convert_effective(s->u.port.conv_func); put_effective(m, n, value_ptr(n, v)); } return; } } } // If S is a signal declared by a signal declaration, a port of mode // out or buffer, or an unconnected port of mode inout, then the // effective value of S is the same as the driving value of S. if (n->flags & NET_F_EFFECTIVE) put_effective(m, n, nexus_driving(n)); // If S is an unconnected port of mode in, the effective value of S // is given by the default value associated with S. } static void calculate_initial_value(rt_model_t *m, rt_nexus_t *n) { calculate_driving_value(m, n); if (n->flags & NET_F_EFFECTIVE) { // Driving and effective values must be calculated separately assert(n->flags & NET_F_PENDING); } else { // Effective value is always the same as the driving value memcpy(nexus_last_value(n), nexus_effective(n), n->size * n->width); } } static int nexus_rank(rt_nexus_t *n) { if (n->rank > 0) return n->rank; // Already calculated else if (n->n_sources > 0) { int rank = 0; for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag != SOURCE_PORT) continue; else if (s->u.port.conv_func != NULL) { rt_conv_func_t *cf = s->u.port.conv_func; for (int i = 0; i < cf->ninputs; i++) rank = MAX(rank, nexus_rank(cf->inputs[i].nexus) + 1); } else rank = MAX(rank, nexus_rank(s->u.port.input) + 1); } return (n->rank = rank); } else return 0; } cover_data_t *get_coverage(rt_model_t *m) { return m->cover; } #if TRACE_SIGNALS static void dump_one_signal(rt_model_t *m, rt_scope_t *scope, rt_signal_t *s, tree_t alias) { rt_nexus_t *n = &(s->nexus); LOCAL_TEXT_BUF tb = tb_new(); if (is_signal_scope(scope)) tb_printf(tb, "%s.", istr(scope->name)); tb_cat(tb, istr(tree_ident(alias ?: s->where))); if (alias != NULL) tb_append(tb, '*'); for (int nth = 0; nth < s->n_nexus; nth++, n = n->chain) { int n_outputs = 0; for (rt_source_t *s = n->outputs; s != NULL; s = s->chain_output) n_outputs++; const void *driving = NULL; if (n->flags & NET_F_EFFECTIVE) driving = nexus_driving(n); fprintf(stderr, "%-20s %-5d %-4d %-7d %-7d %-4d ", nth == 0 ? tb_get(tb) : "+", n->width, n->size, n->n_sources, n_outputs, n->rank); if (n->event_delta == m->iteration && n->last_event == m->now) fprintf(stderr, "%s -> ", fmt_nexus(n, nexus_last_value(n))); fputs(fmt_nexus(n, nexus_effective(n)), stderr); if (driving != NULL) fprintf(stderr, " (%s)", fmt_nexus(n, driving)); fputs("\n", stderr); } } static void dump_signals(rt_model_t *m, rt_scope_t *scope) { if (scope->signals.count == 0 && scope->children.count == 0) return; if (!is_signal_scope(scope)) { const char *sname = istr(scope->name); fprintf(stderr, "== %s ", sname); for (int pad = 74 - strlen(sname); pad > 0; pad--) fputc('=', stderr); fputc('\n', stderr); fprintf(stderr, "%-20s %5s %4s %7s %7s %4s %s\n", "Signal", "Width", "Size", "Sources", "Outputs", "Rank", "Value"); } for (int i = 0; i < scope->signals.count; i++) dump_one_signal(m, scope, scope->signals.items[i], NULL); for (int i = 0; i < scope->aliases.count; i++) { rt_alias_t *a = scope->aliases.items[i]; dump_one_signal(m, scope, a->signal, a->where); } for (int i = 0; i < scope->children.count; i++) { rt_scope_t *c = scope->children.items[i]; if (is_signal_scope(c)) dump_signals(m, c); } for (int i = 0; i < scope->children.count; i++) { rt_scope_t *c = scope->children.items[i]; if (!is_signal_scope(c)) dump_signals(m, c); } } #endif // TRACE_SIGNALS static text_buf_t *signal_full_name(rt_signal_t *s) { text_buf_t *tb = tb_new(); if (is_signal_scope(s->parent)) tb_printf(tb, "%s.", istr(s->parent->name)); tb_cat(tb, istr(tree_ident(s->where))); return tb; } static void check_undriven_std_logic(rt_nexus_t *n) { // Print a warning if any STD_LOGIC signal has multiple sources one // of which is an undriven port with initial value 'U'. The resolved // value will then always be 'U' which often confuses users. if (n->n_sources < 2 || !(n->signal->shared.flags & SIG_F_STD_LOGIC)) return; rt_signal_t *undriven = NULL; for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag == SOURCE_PORT && s->u.port.conv_func == NULL) { rt_nexus_t *input = s->u.port.input; if (input->n_sources == 0) { const unsigned char *init = nexus_effective(input), *p = init; for (; *p == 0 && p < init + input->width; p++); if (p == init + input->width) undriven = s->u.port.input->signal; } } } if (undriven == NULL) return; LOCAL_TEXT_BUF sig_name = signal_full_name(n->signal); LOCAL_TEXT_BUF port_name = signal_full_name(undriven); const loc_t *sig_loc = tree_loc(n->signal->where); rt_scope_t *sig_scope = n->signal->parent; for (; is_signal_scope(sig_scope); sig_scope = sig_scope->parent) sig_loc = tree_loc(sig_scope->where); const loc_t *port_loc = tree_loc(undriven->where); rt_scope_t *port_scope = undriven->parent; for (; is_signal_scope(port_scope); port_scope = port_scope->parent) port_loc = tree_loc(port_scope->where); diag_t *d = diag_new(DIAG_WARN, sig_loc); diag_printf(d, "%ssignal %s has %d sources including port %s which has " "initial value 'U' and no driver in instance %s", n->signal->n_nexus > 1 ? "sub-element of " : "", tb_get(sig_name), n->n_sources, tb_get(port_name), istr(tree_ident(port_scope->where))); diag_hint(d, sig_loc, "signal %s declared here", tb_get(sig_name)); diag_hint(d, port_loc, "sourced by port %s which always contributes 'U'", tb_get(port_name)); diag_hint(d, NULL, "the resolved value will always be 'U' which was almost " "certainly not intended"); diag_emit(d); // Prevent multiple warnings for the same signal n->signal->shared.flags &= ~SIG_F_STD_LOGIC; } static void create_processes(rt_model_t *m, rt_scope_t *s) { for (int i = 0; i < s->children.count; i++) { if (s->children.items[i]->kind == SCOPE_INSTANCE) create_processes(m, s->children.items[i]); } if (s->kind != SCOPE_INSTANCE) return; tree_t hier = tree_decl(s->where, 0); assert(tree_kind(hier) == T_HIER); LOCAL_TEXT_BUF tb = tb_new(); get_path_name(s, tb); ident_t path = ident_new(tb_get(tb)); ident_t sym_prefix = tree_ident2(hier); const int nstmts = tree_stmts(s->where); for (int i = 0; i < nstmts; i++) { tree_t t = tree_stmt(s->where, i); switch (tree_kind(t)) { case T_VERILOG: { ident_t name = tree_ident(t); ident_t sym = ident_prefix(sym_prefix, name, '.'); rt_proc_t *p = xcalloc(sizeof(rt_proc_t)); p->where = t; p->name = ident_prefix(path, ident_downcase(name), ':'); p->handle = jit_lazy_compile(m->jit, sym); p->scope = s; p->privdata = mptr_new(m->mspace, "process privdata"); p->wakeable.kind = W_PROC; p->wakeable.pending = false; p->wakeable.postponed = false; p->wakeable.delayed = false; APUSH(s->procs, p); } break; case T_PROCESS: { ident_t name = tree_ident(t); ident_t sym = ident_prefix(sym_prefix, name, '.'); rt_proc_t *p = xcalloc(sizeof(rt_proc_t)); p->where = t; p->name = ident_prefix(path, ident_downcase(name), ':'); p->handle = jit_lazy_compile(m->jit, sym); p->scope = s; p->privdata = mptr_new(m->mspace, "process privdata"); p->wakeable.kind = W_PROC; p->wakeable.pending = false; p->wakeable.postponed = !!(tree_flags(t) & TREE_F_POSTPONED); p->wakeable.delayed = false; APUSH(s->procs, p); } break; case T_PSL_DIRECT: { psl_node_t psl = tree_psl(t); const psl_kind_t kind = psl_kind(psl); if (kind != P_ASSERT && kind != P_COVER) continue; ident_t name = tree_ident(t); ident_t sym = ident_prefix(s->name, name, '.'); rt_prop_t *p = xcalloc(sizeof(rt_prop_t)); p->where = tree_psl(t); p->handle = jit_lazy_compile(m->jit, sym); p->scope = s; p->name = sym; p->privdata = mptr_new(m->mspace, "property privdata"); p->wakeable.kind = W_PROPERTY; p->wakeable.pending = false; p->wakeable.postponed = false; p->wakeable.delayed = false; APUSH(s->properties, p); } break; default: break; } } } void model_reset(rt_model_t *m) { MODEL_ENTRY(m); // Re-read options as these may have changed m->stop_delta = opt_get_int(OPT_STOP_DELTA); m->shuffle = opt_get_int(OPT_SHUFFLE_PROCS); __trace_on = opt_get_int(OPT_RT_TRACE); create_processes(m, m->root); nvc_rusage(&m->ready_rusage); // Initialisation is described in LRM 93 section 12.6.4 reset_scope(m, m->root); if (m->force_stop) return; // Error in intialisation #if TRACE_SIGNALS > 0 if (__trace_on) dump_signals(m, m->root); #endif TRACE("calculate initial signal values"); model_thread_t *thread = model_thread(m); thread->tlab = tlab_acquire(m->mspace); // The signals in the model are updated as follows in an order such // that if a given signal R depends upon the current value of another // signal S, then the current value of S is updated prior to the // updating of the current value of R. for (rt_nexus_t *n = m->nexuses; n != NULL; n = n->chain) { // The initial value of each driver is the default value of the signal if (n->n_sources > 0) { for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag == SOURCE_DRIVER) copy_value_ptr(n, &(s->u.driver.waveforms.value), nexus_effective(n)); } } const int rank = nexus_rank(n); if (rank > MAX_RANK) fatal_at(tree_loc(n->signal->where), "signal rank %d is greater " "than the maximum supported %d", rank, MAX_RANK); else if (rank > 0 || n->n_sources > 1) heap_insert(m->driving_heap, rank, n); else { calculate_initial_value(m, n); check_undriven_std_logic(n); } } while (heap_size(m->driving_heap) > 0) { rt_nexus_t *n = heap_extract_min(m->driving_heap); calculate_initial_value(m, n); check_undriven_std_logic(n); } // Update effective values after all initial driving values calculated while (heap_size(m->effective_heap) > 0) { rt_nexus_t *n = heap_extract_min(m->effective_heap); n->flags &= ~NET_F_PENDING; calculate_effective_value(m, n); } tlab_reset(thread->tlab); // No allocations can be live past here global_event(m, RT_END_OF_INITIALISATION); } static void update_property(rt_model_t *m, rt_prop_t *prop) { TRACE("update property %s state %s", istr(prop->name), trace_states(&prop->state)); rt_wakeable_t *obj = &(prop->wakeable); if (obj->trigger != NULL && !run_trigger(m, obj->trigger)) return; // Filtered model_thread_t *thread = model_thread(m); assert(thread->tlab != NULL); thread->active_obj = obj; thread->active_scope = prop->scope; jit_scalar_t args[] = { { .pointer = *mptr_get(prop->privdata) ?: (void *)-1 }, { .pointer = *mptr_get(prop->scope->privdata) }, { .integer = -1 }, }; mask_clearall(&prop->newstate); prop->strong = false; size_t bit = -1; while (mask_iter(&prop->state, &bit)) { args[2].integer = bit; if (!jit_vfastcall(m->jit, prop->handle, args, ARRAY_LEN(args), NULL, 0, thread->tlab)) m->force_stop = true; } tlab_reset(thread->tlab); // No allocations can be live past here thread->active_obj = NULL; thread->active_scope = NULL; TRACE("new state %s%s", trace_states(&prop->newstate), prop->strong ? " strong" : ""); mask_copy(&prop->state, &prop->newstate); m->liveness |= prop->strong; } static void sched_event(rt_model_t *m, rt_nexus_t *n, rt_wakeable_t *obj) { if (n->pending == NULL) n->pending = tag_pointer(obj, 1); else if (pointer_tag(n->pending) == 1) { rt_wakeable_t *cur = untag_pointer(n->pending, rt_wakeable_t); if (cur == obj) return; rt_pending_t *p = xmalloc_flex(sizeof(rt_pending_t), PENDING_MIN, sizeof(rt_wakeable_t *)); p->max = PENDING_MIN; p->count = 2; p->wake[0] = cur; p->wake[1] = obj; n->pending = tag_pointer(p, 0); } else { rt_pending_t *p = untag_pointer(n->pending, rt_pending_t); for (int i = 0; i < p->count; i++) { if (p->wake[i] == NULL || p->wake[i] == obj) { p->wake[i] = obj; return; } } if (p->count == p->max) { p->max = MAX(PENDING_MIN, p->max * 2); p = xrealloc_flex(p, sizeof(rt_pending_t), p->max, sizeof(rt_wakeable_t *)); n->pending = tag_pointer(p, 0); } p->wake[p->count++] = obj; } } static void clear_event(rt_model_t *m, rt_nexus_t *n, rt_wakeable_t *obj) { if (pointer_tag(n->pending) == 1) { rt_wakeable_t *wake = untag_pointer(n->pending, rt_wakeable_t); if (wake == obj) n->pending = NULL; } else if (n->pending != NULL) { rt_pending_t *p = untag_pointer(n->pending, rt_pending_t); for (int i = 0; i < p->count; i++) { if (p->wake[i] == obj) { p->wake[i] = NULL; return; } } } } static rt_source_t *find_driver(rt_nexus_t *nexus, rt_proc_t *proc) { // Try to find this process in the list of existing drivers for (rt_source_t *d = &(nexus->sources); d; d = d->chain_input) { if (d->tag == SOURCE_DRIVER && d->u.driver.proc == proc) return d; } return NULL; } static inline bool insert_transaction(rt_model_t *m, rt_nexus_t *nexus, rt_source_t *source, waveform_t *w, uint64_t when, uint64_t reject) { waveform_t *last = &(source->u.driver.waveforms); waveform_t *it = last->next; while (it != NULL && it->when < when) { // If the current transaction is within the pulse rejection interval // and the value is different to that of the new transaction then // delete the current transaction assert(it->when >= m->now); if (it->when >= when - reject && !cmp_values(nexus, it->value, w->value)) { waveform_t *next = it->next; last->next = next; free_value(nexus, it->value); free_waveform(m, it); it = next; } else { last = it; it = it->next; } } last->next = w; // Delete all transactions later than this // We could remove this transaction from the deltaq as well but the // overhead of doing so is probably higher than the cost of waking // up for the empty event bool already_scheduled = false; for (waveform_t *next; it != NULL; it = next) { next = it->next; already_scheduled |= (it->when == when); free_value(nexus, it->value); free_waveform(m, it); } return already_scheduled; } static void sched_driver(rt_model_t *m, rt_nexus_t *n, uint64_t after, uint64_t reject, const void *value, rt_proc_t *proc) { if (after == 0 && (n->flags & NET_F_FAST_DRIVER)) { rt_source_t *d = &(n->sources); assert(n->n_sources == 1); waveform_t *w = &d->u.driver.waveforms; w->when = m->now; assert(w->next == NULL); rt_signal_t *signal = n->signal; rt_source_t *d0 = &(signal->nexus.sources); if (d->fastqueued) assert(m->next_is_delta); else if ((signal->shared.flags & NET_F_FAST_DRIVER) && d0->sigqueued) { assert(m->next_is_delta); d->fastqueued = 1; } else if (cmp_bytes(value, value_ptr(n, &w->value), n->width * n->size)) { m->next_is_delta = true; d->was_active = (n->active_delta == m->iteration); n->active_delta = m->iteration + 1; return; } else if (signal->shared.flags & NET_F_FAST_DRIVER) { deferq_do(&m->delta_driverq, async_fast_all_drivers, signal); m->next_is_delta = true; d0->sigqueued = 1; d->fastqueued = 1; } else { deferq_do(&m->delta_driverq, async_fast_driver, d); m->next_is_delta = true; d->fastqueued = 1; } copy_value_ptr(n, &w->value, value); } else { rt_source_t *d = find_driver(n, proc); assert(d != NULL); if ((n->flags & NET_F_FAST_DRIVER) && d->fastqueued) { // A fast update to this driver is already scheduled waveform_t *w0 = alloc_waveform(m); w0->when = m->now; w0->next = NULL; w0->value = alloc_value(m, n); const uint8_t *prev = value_ptr(n, &(d->u.driver.waveforms.value)); copy_value_ptr(n, &w0->value, prev); assert(d->u.driver.waveforms.next == NULL); d->u.driver.waveforms.next = w0; } n->flags &= ~NET_F_FAST_DRIVER; waveform_t *w = alloc_waveform(m); w->when = m->now + after; w->next = NULL; w->value = alloc_value(m, n); copy_value_ptr(n, &w->value, value); if (!insert_transaction(m, n, d, w, w->when, reject)) deltaq_insert_driver(m, after, d); } } static void sched_disconnect(rt_model_t *m, rt_nexus_t *nexus, uint64_t after, uint64_t reject, rt_proc_t *proc) { rt_source_t *d = find_driver(nexus, proc); assert(d != NULL); const uint64_t when = m->now + after; // Need update_driver to clear disconnected flag nexus->flags &= ~NET_F_FAST_DRIVER; waveform_t *w = alloc_waveform(m); w->when = -when; // Use sign bit to represent null w->next = NULL; w->value.qword = 0; if (!insert_transaction(m, nexus, d, w, when, reject)) deltaq_insert_driver(m, after, d); } static void async_watch_callback(rt_model_t *m, void *arg) { rt_watch_t *w = arg; assert(w->wakeable.pending); w->wakeable.pending = false; if (w->wakeable.zombie) free(w); else (*w->fn)(m->now, w->signals[0], w, w->user_data); } static void async_timeout_callback(rt_model_t *m, void *arg) { rt_callback_t *cb = arg; (*cb->fn)(m, cb->user); free(cb); } static void async_update_implicit_signal(rt_model_t *m, void *arg) { rt_implicit_t *imp = arg; assert(imp->wakeable.pending); imp->wakeable.pending = false; update_implicit_signal(m, imp); } static void async_run_process(rt_model_t *m, void *arg) { rt_proc_t *proc = arg; assert(proc->wakeable.pending); proc->wakeable.pending = false; run_process(m, proc); } static void async_update_property(rt_model_t *m, void *arg) { rt_prop_t *prop = arg; assert(prop->wakeable.pending); prop->wakeable.pending = false; update_property(m, prop); } static bool heap_delete_proc_cb(uint64_t key, void *value, void *search) { if (pointer_tag(value) != EVENT_PROCESS) return false; return untag_pointer(value, rt_proc_t) == search; } static bool run_trigger(rt_model_t *m, rt_trigger_t *t) { if (t->when == m->now && t->iteration == m->iteration) return t->result.integer != 0; // Cached switch (t->kind) { case FUNC_TRIGGER: { tlab_t tlab = jit_null_tlab(m->jit); if (!jit_vfastcall(m->jit, t->handle, t->args, t->nargs, &t->result, 1, &tlab)) m->force_stop = true; TRACE("run trigger %p %s ==> %"PRIi64, t, istr(jit_get_name(m->jit, t->handle)), t->result.integer); } break; case OR_TRIGGER: { rt_trigger_t *left = t->args[0].pointer; rt_trigger_t *right = t->args[1].pointer; t->result.integer = run_trigger(m, left) || run_trigger(m, right); TRACE("or trigger %p ==> %"PRIi64, t, t->result.integer); } break; case CMP_TRIGGER: { rt_signal_t *s = t->args[0].pointer; uint32_t offset = t->args[1].integer; int64_t right = t->args[2].integer; #define COMPARE_SCALAR(type) do { \ const type *data = (type *)s->shared.data; \ t->result.integer = (data[offset] == right); \ } while (0) FOR_ALL_SIZES(s->nexus.size, COMPARE_SCALAR); TRACE("cmp trigger %p ==> %"PRIi64, t, t->result.integer); } break; } t->when = m->now; t->iteration = m->iteration; return t->result.integer != 0; } static void wakeup_one(rt_model_t *m, rt_wakeable_t *obj) { if (obj->pending) return; // Already scheduled deferq_t *dq = obj->postponed ? &m->postponedq : &m->procq; switch (obj->kind) { case W_PROC: { rt_proc_t *proc = container_of(obj, rt_proc_t, wakeable); TRACE("wakeup %sprocess %s", obj->postponed ? "postponed " : "", istr(proc->name)); deferq_do(dq, async_run_process, proc); if (proc->wakeable.delayed) { // This process was already scheduled to run at a later // time so we need to delete it from the simulation queue heap_delete(m->eventq_heap, heap_delete_proc_cb, proc); proc->wakeable.delayed = false; } } break; case W_PROPERTY: { rt_prop_t *prop = container_of(obj, rt_prop_t, wakeable); TRACE("wakeup property %s", istr(prop->name)); deferq_do(dq, async_update_property, prop); } break; case W_IMPLICIT: { rt_implicit_t *imp = container_of(obj, rt_implicit_t, wakeable); TRACE("wakeup implicit signal %s closure %s", istr(tree_ident(imp->signal.where)), istr(jit_get_name(m->jit, imp->closure.handle))); deferq_do(&m->implicitq, async_update_implicit_signal, imp); } break; case W_WATCH: { rt_watch_t *w = container_of(obj, rt_watch_t, wakeable); TRACE("wakeup %svalue change callback %p %s", obj->postponed ? "postponed " : "", w, debug_symbol_name(w->fn)); assert(!w->wakeable.zombie); deferq_do(dq, async_watch_callback, w); } break; case W_TRANSFER: { rt_transfer_t *t = container_of(obj, rt_transfer_t, wakeable); TRACE("wakeup signal transfer for %s", istr(tree_ident(t->target->signal->where))); deferq_do(dq, async_transfer_signal, t); } break; } set_pending(obj); } static void notify_event(rt_model_t *m, rt_nexus_t *n) { // Must only be called once per cycle assert(n->last_event != m->now || n->event_delta != m->iteration); n->last_event = m->now; n->event_delta = m->iteration; if (n->flags & NET_F_CACHE_EVENT) n->signal->shared.flags |= SIG_F_EVENT_FLAG; if (pointer_tag(n->pending) == 1) { rt_wakeable_t *wake = untag_pointer(n->pending, rt_wakeable_t); wakeup_one(m, wake); } else if (n->pending != NULL) { rt_pending_t *p = untag_pointer(n->pending, rt_pending_t); for (int i = 0; i < p->count; i++) { if (p->wake[i] != NULL) wakeup_one(m, p->wake[i]); } } } static void put_effective(rt_model_t *m, rt_nexus_t *n, const void *value) { TRACE("update %s effective value %s", trace_nexus(n), fmt_nexus(n, value)); unsigned char *eff = nexus_effective(n); unsigned char *last = nexus_last_value(n); const size_t valuesz = n->size * n->width; if (!cmp_bytes(eff, value, valuesz)) { copy2(last, eff, value, valuesz); notify_event(m, n); } } static void enqueue_effective(rt_model_t *m, rt_nexus_t *n) { if (n->flags & NET_F_PENDING) return; n->flags |= NET_F_PENDING; heap_insert(m->effective_heap, MAX_RANK - n->rank, n); } static void update_effective(rt_model_t *m, rt_nexus_t *n) { n->active_delta = m->iteration; n->flags &= ~NET_F_PENDING; calculate_effective_value(m, n); if (n->n_sources > 0) { for (rt_source_t *s = &(n->sources); s; s = s->chain_input) { if (s->tag != SOURCE_PORT) continue; else if (s->u.port.conv_func != NULL) { rt_conv_func_t *cf = s->u.port.conv_func; for (int i = 0; i < cf->ninputs; i++) { if (cf->inputs[i].nexus->flags & NET_F_INOUT) enqueue_effective(m, cf->inputs[i].nexus); } } else if (s->u.port.input->flags & NET_F_INOUT) enqueue_effective(m, s->u.port.input); } } } static void put_driving(rt_model_t *m, rt_nexus_t *n, const void *value) { if (n->flags & NET_F_EFFECTIVE) { TRACE("update %s driving value %s", trace_nexus(n), fmt_nexus(n, value)); memcpy(nexus_driving(n), value, n->size * n->width); assert(!(n->flags & NET_F_PENDING)); n->flags |= NET_F_PENDING; n->flags &= ~NET_F_HAS_INITIAL; heap_insert(m->effective_heap, MAX_RANK - n->rank, n); } else put_effective(m, n, value); } static void defer_driving_update(rt_model_t *m, rt_nexus_t *n) { if (n->flags & NET_F_PENDING) return; TRACE("defer %s driving value update", trace_nexus(n)); heap_insert(m->driving_heap, n->rank, n); n->flags |= NET_F_PENDING; } static void update_driving(rt_model_t *m, rt_nexus_t *n, bool safe) { if (n->n_sources == 1 || safe) { n->active_delta = m->iteration; n->flags &= ~NET_F_PENDING; calculate_driving_value(m, n); // Update outputs if the effective value must be calculated // separately or there was an event on this signal const bool update_outputs = !!(n->flags & NET_F_EFFECTIVE) || (n->event_delta == m->iteration && n->last_event == m->now); if (update_outputs) { for (rt_source_t *o = n->outputs; o; o = o->chain_output) { switch (o->tag) { case SOURCE_PORT: if (o->u.port.conv_func != NULL) defer_driving_update(m, o->u.port.output); else update_driving(m, o->u.port.output, false); break; case SOURCE_IMPLICIT: update_driving(m, o->u.pseudo.nexus , false); break; default: should_not_reach_here(); } } } } else defer_driving_update(m, n); } static void update_driver(rt_model_t *m, rt_nexus_t *n, rt_source_t *source) { waveform_t *w_now = &(source->u.driver.waveforms); waveform_t *w_next = w_now->next; if (likely(w_next != NULL && w_next->when == m->now)) { free_value(n, w_now->value); *w_now = *w_next; free_waveform(m, w_next); source->disconnected = 0; update_driving(m, n, false); } else if (unlikely(w_next != NULL && w_next->when == -m->now)) { // Disconnect source due to null transaction *w_now = *w_next; free_waveform(m, w_next); source->disconnected = 1; update_driving(m, n, false); } } static void fast_update_driver(rt_model_t *m, rt_nexus_t *nexus) { rt_source_t *src = &(nexus->sources); if (likely(nexus->flags & NET_F_FAST_DRIVER)) { // Preconditions for fast driver updates assert(nexus->n_sources == 1); assert(src->tag == SOURCE_DRIVER); assert(src->u.driver.waveforms.next == NULL); update_driving(m, nexus, false); } else update_driver(m, nexus, src); assert(src->fastqueued); src->fastqueued = 0; } static void fast_update_all_drivers(rt_model_t *m, rt_signal_t *signal) { assert(signal->shared.flags & NET_F_FAST_DRIVER); rt_nexus_t *n = &(signal->nexus); assert(n->sources.sigqueued); n->sources.sigqueued = 0; int count = 0; for (int i = 0; i < signal->n_nexus; i++, n = n->chain) { if (n->sources.fastqueued) { fast_update_driver(m, n); count++; } } if (count < signal->n_nexus >> 1) { // Unlikely to be worth the iteration cost signal->shared.flags &= ~NET_F_FAST_DRIVER; } } static void async_update_driver(rt_model_t *m, void *arg) { rt_source_t *src = arg; update_driver(m, src->u.driver.nexus, src); } static void async_fast_driver(rt_model_t *m, void *arg) { rt_source_t *src = arg; fast_update_driver(m, src->u.driver.nexus); } static void async_fast_all_drivers(rt_model_t *m, void *arg) { rt_signal_t *signal = arg; fast_update_all_drivers(m, signal); } static void async_pseudo_source(rt_model_t *m, void *arg) { rt_source_t *src = arg; assert(src->tag == SOURCE_FORCING || src->tag == SOURCE_DEPOSIT); update_driving(m, src->u.pseudo.nexus, false); assert(src->pseudoqueued); src->pseudoqueued = 0; } static void async_transfer_signal(rt_model_t *m, void *arg) { rt_transfer_t *t = arg; assert(t->wakeable.pending); t->wakeable.pending = false; rt_nexus_t *n = t->target; char *vptr = nexus_effective(t->source); for (int count = t->count; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); sched_driver(m, n, t->after, t->reject, vptr, t->proc); vptr += n->width * n->size; } } static void update_implicit_signal(rt_model_t *m, rt_implicit_t *imp) { model_thread_t *thread = model_thread(m); assert(thread->active_obj == NULL); thread->active_obj = &(imp->wakeable); jit_scalar_t result; if (!jit_try_call(m->jit, imp->closure.handle, &result, imp->closure.context, imp->signal.shared.data[0])) m->force_stop = true; thread->active_obj = NULL; TRACE("implicit signal %s new value %"PRIi64, istr(tree_ident(imp->signal.where)), result.integer); assert(imp->signal.n_nexus == 1); rt_nexus_t *n0 = &(imp->signal.nexus); n0->active_delta = m->iteration; if (n0->n_sources > 0 && n0->sources.tag == SOURCE_DRIVER) { if (!result.integer) { // Update driver for 'STABLE and 'QUIET // TODO: this should happen inside the callback waveform_t *w = alloc_waveform(m); w->when = m->now + imp->delay; w->next = NULL; w->value = alloc_value(m, n0); w->value.bytes[0] = 1; // Boolean TRUE if (!insert_transaction(m, n0, &(n0->sources), w, w->when, imp->delay)) deltaq_insert_driver(m, imp->delay, &(n0->sources)); put_effective(m, n0, &result.integer); } else if (n0->sources.u.driver.waveforms.next == NULL) put_effective(m, n0, &result.integer); } else put_effective(m, n0, &result.integer); } static void iteration_limit_proc_cb(void *fn, void *arg, void *extra) { diag_t *d = extra; rt_proc_t *proc = NULL; if (fn == async_run_process) proc = arg; else if (fn == async_transfer_signal) { rt_transfer_t *t = arg; proc = t->proc; } if (proc == NULL) return; const loc_t *loc = tree_loc(proc->where); diag_hint(d, loc, "process %s is active", istr(proc->name)); } static void iteration_limit_driver_cb(void *fn, void *arg, void *extra) { diag_t *d = extra; tree_t decl = NULL; if (fn == async_update_driver || fn == async_fast_driver) { rt_source_t *src = arg; if (src->tag == SOURCE_DRIVER) decl = src->u.driver.nexus->signal->where; } else if (fn == async_fast_all_drivers) { rt_signal_t *s = arg; decl = s->where; } if (decl == NULL) return; diag_hint(d, tree_loc(decl), "driver for %s %s is active", tree_kind(decl) == T_PORT_DECL ? "port" : "signal", istr(tree_ident(decl))); } static void reached_iteration_limit(rt_model_t *m) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "limit of %d delta cycles reached", m->stop_delta); deferq_scan(&m->delta_procq, iteration_limit_proc_cb, d); deferq_scan(&m->delta_driverq, iteration_limit_driver_cb, d); diag_hint(d, NULL, "you can increase this limit with $bold$--stop-delta$$"); diag_emit(d); m->force_stop = true; } static void sync_event_cache(rt_model_t *m) { for (int i = 0; i < m->eventsigs.count; i++) { rt_signal_t *s = m->eventsigs.items[i]; assert(s->shared.flags & SIG_F_CACHE_EVENT); const bool event = s->nexus.last_event == m->now && s->nexus.event_delta == m->iteration; TRACE("sync event flag %d for %s", event, istr(tree_ident(s->where))); if (event) assert(s->shared.flags & SIG_F_EVENT_FLAG); // Set by notify_event else s->shared.flags &= ~SIG_F_EVENT_FLAG; } } static void swap_deferq(deferq_t *a, deferq_t *b) { deferq_t tmp = *a; *a = *b; *b = tmp; } static void model_cycle(rt_model_t *m) { // Simulation cycle is described in LRM 93 section 12.6.4 const bool is_delta_cycle = m->next_is_delta; m->next_is_delta = false; if (is_delta_cycle) m->iteration = m->iteration + 1; else { m->now = heap_min_key(m->eventq_heap); m->iteration = 0; } TRACE("begin cycle"); #if TRACE_DELTAQ > 0 if (__trace_on) deltaq_dump(m); #endif swap_deferq(&m->procq, &m->delta_procq); swap_deferq(&m->driverq, &m->delta_driverq); if (m->iteration == 0) global_event(m, RT_NEXT_TIME_STEP); global_event(m, RT_NEXT_CYCLE); if (!is_delta_cycle) { for (;;) { void *e = heap_extract_min(m->eventq_heap); switch (pointer_tag(e)) { case EVENT_PROCESS: { rt_proc_t *proc = untag_pointer(e, rt_proc_t); assert(proc->wakeable.delayed); proc->wakeable.delayed = false; set_pending(&proc->wakeable); deferq_do(&m->procq, async_run_process, proc); } break; case EVENT_DRIVER: { rt_source_t *source = untag_pointer(e, rt_source_t); deferq_do(&m->driverq, async_update_driver, source); } break; case EVENT_TIMEOUT: { rt_callback_t *cb = untag_pointer(e, rt_callback_t); deferq_do(&m->driverq, async_timeout_callback, cb); } break; } if (heap_size(m->eventq_heap) == 0) break; else if (heap_min_key(m->eventq_heap) > m->now) break; } } deferq_run(m, &m->driverq); while (heap_size(m->driving_heap) > 0) { rt_nexus_t *n = heap_extract_min(m->driving_heap); update_driving(m, n, true); } while (heap_size(m->effective_heap) > 0) { rt_nexus_t *n = heap_extract_min(m->effective_heap); update_effective(m, n); } sync_event_cache(m); // Update implicit signals deferq_run(m, &m->implicitq); #if TRACE_SIGNALS > 0 if (__trace_on) dump_signals(m, m->root); #endif if (m->shuffle) deferq_shuffle(&m->procq); // Run all non-postponed processes and event callbacks deferq_run(m, &m->procq); global_event(m, RT_END_OF_PROCESSES); if (!m->next_is_delta) global_event(m, RT_LAST_KNOWN_DELTA_CYCLE); if (!m->next_is_delta) { m->can_create_delta = false; // Run all postponed processes and event callbacks deferq_run(m, &m->postponedq); global_event(m, RT_END_TIME_STEP); m->can_create_delta = true; } else if (m->stop_delta > 0 && m->iteration == m->stop_delta) reached_iteration_limit(m); } static bool should_stop_now(rt_model_t *m, uint64_t stop_time) { if (m->force_stop) { // Make sure we print the interrupted message if this was the // result of an interrupt jit_check_interrupt(m->jit); return true; } else if (m->next_is_delta) return false; else if (heap_size(m->eventq_heap) == 0) return true; else return heap_min_key(m->eventq_heap) > stop_time; } static void check_liveness_properties(rt_model_t *m, rt_scope_t *s) { model_thread_t *thread = model_thread(m); for (int i = 0; i < s->properties.count; i++) { rt_prop_t *p = s->properties.items[i]; if (p->strong) { TRACE("property %s in strong state", istr(p->name)); // Passing an invalid state triggers the assertion failure jit_scalar_t args[] = { { .pointer = *mptr_get(p->privdata) ?: (void *)-1 }, { .pointer = *mptr_get(p->scope->privdata) }, { .integer = INT_MAX }, }; jit_vfastcall(m->jit, p->handle, args, ARRAY_LEN(args), NULL, 0, thread->tlab); } } for (int i = 0; i < s->children.count; i++) check_liveness_properties(m, s->children.items[i]); } void model_run(rt_model_t *m, uint64_t stop_time) { MODEL_ENTRY(m); if (m->force_stop) return; // Was error during intialisation global_event(m, RT_START_OF_SIMULATION); while (!should_stop_now(m, stop_time)) model_cycle(m); global_event(m, RT_END_OF_SIMULATION); if (m->liveness) check_liveness_properties(m, m->root); } bool model_step(rt_model_t *m) { MODEL_ENTRY(m); if (!m->force_stop) model_cycle(m); return should_stop_now(m, TIME_HIGH); } static inline void check_postponed(int64_t after, rt_proc_t *proc) { if (unlikely(proc->wakeable.postponed && (after == 0))) fatal("postponed process %s cannot cause a delta cycle", istr(proc->name)); } static inline void check_reject_limit(rt_signal_t *s, uint64_t after, uint64_t reject) { if (unlikely(reject > after)) jit_msg(NULL, DIAG_FATAL, "signal %s pulse reject limit %s is greater " "than delay %s", istr(tree_ident(s->where)), trace_time(reject), trace_time(after)); } static inline void check_delay(int64_t delay) { if (unlikely(delay < 0)) { char buf[32]; fmt_time_r(buf, sizeof(buf), delay, " "); jit_msg(NULL, DIAG_FATAL, "illegal negative delay %s", buf); } } void force_signal(rt_model_t *m, rt_signal_t *s, const void *values, int offset, size_t count) { RT_LOCK(s->lock); TRACE("force signal %s+%d to %s", istr(tree_ident(s->where)), offset, fmt_values(values, count)); assert(m->can_create_delta); rt_nexus_t *n = split_nexus(m, s, offset, count); const char *vptr = values; for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); n->flags |= NET_F_FORCED; rt_source_t *src = get_pseudo_source(m, n, SOURCE_FORCING); copy_value_ptr(n, &(src->u.pseudo.value), vptr); src->disconnected = 0; if (!src->pseudoqueued) { deltaq_insert_pseudo_source(m, src); src->pseudoqueued = 1; } vptr += n->width * n->size; } } void release_signal(rt_model_t *m, rt_signal_t *s, int offset, size_t count) { RT_LOCK(s->lock); TRACE("release signal %s+%d", istr(tree_ident(s->where)), offset); assert(m->can_create_delta); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); n->flags &= ~NET_F_FORCED; rt_source_t *src = get_pseudo_source(m, n, SOURCE_FORCING); src->disconnected = 1; if (!src->pseudoqueued) { deltaq_insert_pseudo_source(m, src); src->pseudoqueued = 1; } } } void deposit_signal(rt_model_t *m, rt_signal_t *s, const void *values, int offset, size_t count) { RT_LOCK(s->lock); TRACE("deposit signal %s+%d to %s", istr(tree_ident(s->where)), offset, fmt_values(values, count)); assert(m->can_create_delta); rt_nexus_t *n = split_nexus(m, s, offset, count); const char *vptr = values; for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); rt_source_t *src = get_pseudo_source(m, n, SOURCE_DEPOSIT); copy_value_ptr(n, &(src->u.pseudo.value), vptr); src->disconnected = 0; if (!src->pseudoqueued) { deltaq_insert_pseudo_source(m, src); src->pseudoqueued = 1; } vptr += n->width * n->size; } } bool model_can_create_delta(rt_model_t *m) { return m->can_create_delta; } int64_t model_now(rt_model_t *m, unsigned *deltas) { if (deltas != NULL) *deltas = MAX(m->iteration, 0); return m->now; } int64_t model_next_time(rt_model_t *m) { if (heap_size(m->eventq_heap) == 0) return TIME_HIGH; else return heap_min_key(m->eventq_heap); } void model_stop(rt_model_t *m) { relaxed_store(&m->force_stop, true); } void model_set_global_cb(rt_model_t *m, rt_event_t event, rt_event_fn_t fn, void *user) { assert(event < RT_LAST_EVENT); // Add to end of list so callbacks are called in registration order rt_callback_t **p = &(m->global_cbs[event]); for (; *p; p = &(*p)->next); rt_callback_t *cb = xcalloc(sizeof(rt_callback_t)); cb->next = NULL; cb->fn = fn; cb->user = user; *p = cb; } void model_set_timeout_cb(rt_model_t *m, uint64_t when, rt_event_fn_t fn, void *user) { rt_callback_t *cb = xcalloc(sizeof(rt_callback_t)); cb->next = NULL; cb->fn = fn; cb->user = user; assert(when > m->now); // TODO: delta timeouts? void *e = tag_pointer(cb, EVENT_TIMEOUT); heap_insert(m->eventq_heap, when, e); } rt_watch_t *watch_new(rt_model_t *m, sig_event_fn_t fn, void *user, watch_kind_t kind, unsigned slots) { rt_watch_t *w = xcalloc_flex(sizeof(rt_watch_t), slots, sizeof(rt_signal_t *)); w->fn = fn; w->chain_all = m->watches; w->user_data = user; w->num_slots = slots; w->wakeable.kind = W_WATCH; w->wakeable.postponed = (kind == WATCH_POSTPONED); w->wakeable.pending = false; w->wakeable.delayed = false; m->watches = w; return w; } void watch_free(rt_model_t *m, rt_watch_t *w) { assert(!w->wakeable.zombie); for (int i = 0; i < w->next_slot; i++) { rt_nexus_t *n = &(w->signals[i]->nexus); for (int j = 0; j < w->signals[i]->n_nexus; j++, n = n->chain) clear_event(m, n, &(w->wakeable)); } rt_watch_t **last = &m->watches; for (rt_watch_t *it = *last; it; last = &(it->chain_all), it = it->chain_all) { if (it == w) { *last = it->chain_all; if (w->wakeable.pending) w->wakeable.zombie = true; // Will be freed in callback else free(w); return; } } should_not_reach_here(); } rt_watch_t *model_set_event_cb(rt_model_t *m, rt_signal_t *s, rt_watch_t *w) { assert(!w->wakeable.zombie); assert(w->next_slot < w->num_slots); w->signals[w->next_slot++] = s; rt_nexus_t *n = &(s->nexus); for (int i = 0; i < s->n_nexus; i++, n = n->chain) sched_event(m, n, &(w->wakeable)); return w; } static void handle_interrupt_cb(jit_t *j, void *ctx) { rt_proc_t *proc = get_active_proc(); if (proc != NULL) jit_msg(NULL, DIAG_FATAL, "interrupted in process %s", istr(proc->name)); else { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "interrupted"); diag_emit(d); } } void model_interrupt(rt_model_t *m) { model_stop(m); jit_interrupt(m->jit, handle_interrupt_cb, m); } int model_exit_status(rt_model_t *m) { int status; if (jit_exit_status(m->jit, &status)) return status; else if (m->stop_delta > 0 && m->iteration == m->stop_delta) return EXIT_FAILURE; else return get_vhdl_assert_exit_status(); } static bool nexus_active(rt_model_t *m, rt_nexus_t *nexus) { if (nexus->n_sources > 0) { for (rt_source_t *s = &(nexus->sources); s; s = s->chain_input) { if (s->tag == SOURCE_PORT) { rt_conv_func_t *cf = s->u.port.conv_func; if (cf == NULL) { RT_LOCK(s->u.port.input->signal->lock); if (nexus_active(m, s->u.port.input)) return true; } else { for (int i = 0; i < cf->ninputs; i++) { if (nexus_active(m, cf->inputs[i].nexus)) return true; } } } else if (s->tag == SOURCE_DRIVER && s->u.driver.waveforms.when == m->now) { if (nexus->active_delta == m->iteration) return true; else if (nexus->active_delta == m->iteration + 1 && s->was_active) return true; } } } return false; } static uint64_t nexus_last_active(rt_model_t *m, rt_nexus_t *nexus) { int64_t last = TIME_HIGH; if (nexus->n_sources > 0) { for (rt_source_t *s = &(nexus->sources); s; s = s->chain_input) { if (s->tag == SOURCE_PORT) { rt_conv_func_t *cf = s->u.port.conv_func; if (cf == NULL) { RT_LOCK(s->u.port.input->signal->lock); last = MIN(last, nexus_last_active(m, s->u.port.input)); } else { for (int i = 0; i < cf->ninputs; i++) { RT_LOCK(cf->inputs[i]->signal->lock); last = MIN(last, nexus_last_active(m, cf->inputs[i].nexus)); } } } else if (s->tag == SOURCE_DRIVER && s->u.driver.waveforms.when <= m->now) last = MIN(last, m->now - s->u.driver.waveforms.when); } } return last; } void get_forcing_value(rt_signal_t *s, uint8_t *value) { uint8_t *p = value; rt_nexus_t *n = &(s->nexus); for (int i = 0; i < s->n_nexus; i++) { assert(n->n_sources > 0); rt_source_t *s = NULL; for (s = &(n->sources); s; s = s->chain_input) { if (s->tag == SOURCE_FORCING) break; } assert(s != NULL); memcpy(p, s->u.pseudo.value.bytes, n->width * n->size); p += n->width * n->size; } assert(p == value + s->shared.size); } int32_t *get_cover_counter(rt_model_t *m, int32_t tag, int count) { assert(tag >= 0); assert(m->cover != NULL); return jit_get_cover_mem(m->jit, tag + count) + tag; } static rt_trigger_t *new_trigger(rt_model_t *m, trigger_kind_t kind, uint64_t hash, jit_handle_t handle, unsigned nargs, const jit_scalar_t *args) { rt_trigger_t **bucket = &(m->triggertab[hash % TRIGGER_TAB_SIZE]); for (rt_trigger_t *exist = *bucket; exist; exist = exist->chain) { bool hit = exist->handle == handle && exist->nargs == nargs && exist->kind == kind; for (int i = 0; hit && i < nargs; i++) hit &= (exist->args[i].integer == args[i].integer); if (hit) return exist; } const size_t argsz = nargs * sizeof(jit_scalar_t); rt_trigger_t *t = static_alloc(m, sizeof(rt_trigger_t) + argsz); t->handle = handle; t->nargs = nargs; t->when = TIME_HIGH; t->kind = kind; t->chain = *bucket; memcpy(t->args, args, argsz); return (*bucket = t); } void call_with_model(rt_model_t *m, void (*cb)(void *), void *arg) { MODEL_ENTRY(m); (*cb)(arg); } void get_instance_name(rt_scope_t *s, text_buf_t *tb) { if (s->kind == SCOPE_ROOT) return; tree_t hier = tree_decl(s->where, 0); assert(tree_kind(hier) == T_HIER); switch (tree_subkind(hier)) { case T_ARCH: { tree_t unit = tree_ref(hier); get_instance_name(s->parent, tb); if (s->parent->kind != SCOPE_ROOT) { tree_t hier2 = tree_decl(s->parent->where, 0); assert(tree_kind(hier2) == T_HIER); if (tree_subkind(hier2) != T_COMPONENT) { tb_append(tb, ':'); tb_istr(tb, tree_ident(s->where)); } tb_append(tb, '@'); } else tb_append(tb, ':'); const char *arch = strchr(istr(tree_ident(unit)), '-') + 1; tb_printf(tb, "%s(%s)", istr(tree_ident2(unit)), arch); } break; case T_BLOCK: case T_FOR_GENERATE: case T_IF_GENERATE: case T_CASE_GENERATE: get_instance_name(s->parent, tb); tb_append(tb, ':'); tb_printf(tb, "%s", istr(tree_ident(s->where))); break; case T_COMPONENT: get_instance_name(s->parent, tb); tb_printf(tb, ":%s", istr(tree_ident(s->where))); break; default: should_not_reach_here(); } tb_downcase(tb); } void get_path_name(rt_scope_t *s, text_buf_t *tb) { if (s->kind == SCOPE_ROOT) return; get_path_name(s->parent, tb); if (s->parent->kind != SCOPE_ROOT) { tree_t hier = tree_decl(s->parent->where, 0); assert(tree_kind(hier) == T_HIER); if (tree_subkind(hier) == T_COMPONENT) return; // Skip implicit block for components } tb_append(tb, ':'); tb_istr(tb, tree_ident(s->where)); tb_downcase(tb); } //////////////////////////////////////////////////////////////////////////////// // Entry points from compiled code sig_shared_t *x_init_signal(int64_t count, uint32_t size, jit_scalar_t value, bool scalar, sig_flags_t flags, tree_t where, int32_t offset) { TRACE("init signal %s count=%"PRIi64" size=%d value=%s flags=%x offset=%d", istr(tree_ident(where)), count, size, fmt_jit_value(value, scalar, size * count), flags, offset); rt_model_t *m = get_model(); if (count > INT32_MAX) jit_msg(tree_loc(where), DIAG_FATAL, "signal %s has %"PRIi64 " sub-elements which is greater than the maximum supported %d", istr(tree_ident(where)), count, INT32_MAX); const size_t datasz = MAX(3 * count * size, 8); rt_signal_t *s = static_alloc(m, sizeof(rt_signal_t) + datasz); setup_signal(m, s, where, count, size, flags, offset); // The driving value area is also used to save the default value void *driving = s->shared.data + 2*s->shared.size; if (scalar) { #define COPY_SCALAR(type) do { \ type *pi = (type *)s->shared.data; \ type *pd = (type *)driving; \ for (int i = 0; i < count; i++) \ pi[i] = pd[i] = value.integer; \ } while (0) FOR_ALL_SIZES(size, COPY_SCALAR); } else { memcpy(s->shared.data, value.pointer, s->shared.size); memcpy(driving, value.pointer, s->shared.size); } return &(s->shared); } void x_drive_signal(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("drive signal %s+%d count=%d", istr(tree_ident(s->where)), offset, count); rt_model_t *m = get_model(); rt_proc_t *proc = get_active_proc(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { rt_source_t *s; for (s = &(n->sources); s; s = s->chain_input) { if (s->tag == SOURCE_DRIVER && s->u.driver.proc == proc) break; } if (s == NULL) { s = add_source(m, n, SOURCE_DRIVER); s->u.driver.waveforms.value = alloc_value(m, n); s->u.driver.proc = proc; } count -= n->width; assert(count >= 0); } } void x_sched_process(int64_t delay) { rt_proc_t *proc = get_active_proc(); if (proc == NULL) return; // May be called during constant folding TRACE("schedule process %s delay=%s", istr(proc->name), trace_time(delay)); check_delay(delay); deltaq_insert_proc(get_model(), delay, proc); } void x_sched_waveform_s(sig_shared_t *ss, uint32_t offset, uint64_t scalar, int64_t after, int64_t reject) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_sched_waveform_s %s+%d value=%"PRIi64" after=%s reject=%s", istr(tree_ident(s->where)), offset, scalar, trace_time(after), trace_time(reject)); rt_proc_t *proc = get_active_proc(); check_delay(after); check_postponed(after, proc); check_reject_limit(s, after, reject); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, 1); sched_driver(m, n, after, reject, &scalar, proc); } void x_sched_waveform(sig_shared_t *ss, uint32_t offset, void *values, int32_t count, int64_t after, int64_t reject) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_sched_waveform %s+%d value=%s count=%d after=%s reject=%s", istr(tree_ident(s->where)), offset, fmt_values(values, count * s->nexus.size), count, trace_time(after), trace_time(reject)); rt_proc_t *proc = get_active_proc(); check_delay(after); check_postponed(after, proc); check_reject_limit(s, after, reject); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); char *vptr = values; for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); sched_driver(m, n, after, reject, vptr, proc); vptr += n->width * n->size; } } void x_transfer_signal(sig_shared_t *target_ss, uint32_t toffset, sig_shared_t *source_ss, uint32_t soffset, int32_t count, int64_t after, int64_t reject) { rt_signal_t *target = container_of(target_ss, rt_signal_t, shared); rt_signal_t *source = container_of(source_ss, rt_signal_t, shared); TRACE("transfer signal %s+%d to %s+%d count=%d", istr(tree_ident(source->where)), soffset, istr(tree_ident(target->where)), toffset, count); rt_proc_t *proc = get_active_proc(); check_delay(after); check_postponed(after, proc); check_reject_limit(target, after, reject); rt_model_t *m = get_model(); rt_transfer_t *t = static_alloc(m, sizeof(rt_transfer_t)); t->proc = proc; t->target = split_nexus(m, target, toffset, count); t->source = split_nexus(m, source, soffset, count); t->count = count; t->after = after; t->reject = reject; t->wakeable.kind = W_TRANSFER; t->wakeable.postponed = false; t->wakeable.pending = false; t->wakeable.delayed = false; for (rt_nexus_t *n = t->source; count > 0; n = n->chain) { sched_event(m, n, &(t->wakeable)); if (!t->wakeable.pending) { // Schedule initial update immediately deferq_do(&m->delta_procq, async_transfer_signal, t); t->wakeable.pending = true; } count -= n->width; assert(count >= 0); } } int32_t x_test_net_event(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_test_net_event %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); int32_t result = 0; rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { if (n->last_event == m->now && n->event_delta == m->iteration) { result = 1; break; } count -= n->width; assert(count >= 0); } if (ss->size == s->nexus.size) { assert(!(ss->flags & SIG_F_CACHE_EVENT)); // Should have taken fast-path ss->flags |= SIG_F_CACHE_EVENT | (result ? SIG_F_EVENT_FLAG : 0); s->nexus.flags |= NET_F_CACHE_EVENT; APUSH(m->eventsigs, s); } return result; } int32_t x_test_net_active(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_test_net_active %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { if (nexus_active(m, n)) return 1; count -= n->width; assert(count >= 0); } return 0; } void x_sched_event(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_sched_event %s+%d count=%d", istr(tree_ident(s->where)), offset, count); rt_wakeable_t *obj = get_active_wakeable(); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { sched_event(m, n, obj); count -= n->width; assert(count >= 0); } } void x_clear_event(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("clear event %s+%d count=%d", istr(tree_ident(s->where)), offset, count); rt_model_t *m = get_model(); rt_proc_t *proc = get_active_proc(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { clear_event(m, n, &(proc->wakeable)); count -= n->width; assert(count >= 0); } } void x_enter_state(int32_t state, bool strong) { rt_wakeable_t *obj = get_active_wakeable(); assert(obj->kind == W_PROPERTY); rt_prop_t *prop = container_of(obj, rt_prop_t, wakeable); mask_set(&prop->newstate, state); prop->strong |= strong; } void x_alias_signal(sig_shared_t *ss, tree_t where) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("alias signal %s to %s", istr(tree_ident(s->where)), istr(tree_ident(where))); rt_alias_t *a = xcalloc(sizeof(rt_alias_t)); a->where = where; a->signal = s; model_thread_t *thread = model_thread(get_model()); APUSH(thread->active_scope->aliases, a); } int64_t x_last_event(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_last_event %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); int64_t last = TIME_HIGH; rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { if (n->last_event <= m->now) last = MIN(last, m->now - n->last_event); count -= n->width; assert(count >= 0); } return last; } int64_t x_last_active(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_last_active %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); int64_t last = TIME_HIGH; rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { last = MIN(last, nexus_last_active(m, n)); count -= n->width; assert(count >= 0); } return last; } void x_map_signal(sig_shared_t *src_ss, uint32_t src_offset, sig_shared_t *dst_ss, uint32_t dst_offset, uint32_t count) { rt_signal_t *src_s = container_of(src_ss, rt_signal_t, shared); RT_LOCK(src_s->lock); rt_signal_t *dst_s = container_of(dst_ss, rt_signal_t, shared); RT_LOCK(dst_s->lock); TRACE("map signal %s+%d to %s+%d count %d", istr(tree_ident(src_s->where)), src_offset, istr(tree_ident(dst_s->where)), dst_offset, count); assert(src_s != dst_s); rt_model_t *m = get_model(); rt_nexus_t *src_n = split_nexus(m, src_s, src_offset, count); rt_nexus_t *dst_n = split_nexus(m, dst_s, dst_offset, count); while (count > 0) { if (src_n->width > dst_n->width) clone_nexus(m, src_n, dst_n->width); else if (src_n->width < dst_n->width) clone_nexus(m, dst_n, src_n->width); assert(src_n->width == dst_n->width); assert(src_n->size == dst_n->size); // Effective value updates must propagate through ports src_n->flags |= (dst_n->flags & NET_F_EFFECTIVE); dst_n->flags |= (src_n->flags & NET_F_EFFECTIVE); rt_source_t *port = add_source(m, dst_n, SOURCE_PORT); port->u.port.input = src_n; port->chain_output = src_n->outputs; src_n->outputs = port; count -= src_n->width; assert(count >= 0); src_n = src_n->chain; dst_n = dst_n->chain; } } void x_map_const(sig_shared_t *ss, uint32_t offset, const uint8_t *values, uint32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("map const %s to %s+%d count %d", fmt_values(values, count), istr(tree_ident(s->where)), offset, count); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { const size_t valuesz = n->size * n->width; memcpy(nexus_effective(n), values, valuesz); memcpy(nexus_initial(n), values, valuesz); n->flags |= NET_F_HAS_INITIAL; values += valuesz; count -= n->width; assert(count >= 0); } } void x_map_implicit(sig_shared_t *src_ss, uint32_t src_offset, sig_shared_t *dst_ss, uint32_t dst_offset, uint32_t count) { rt_signal_t *src_s = container_of(src_ss, rt_signal_t, shared); RT_LOCK(src_s->lock); rt_signal_t *dst_s = container_of(dst_ss, rt_signal_t, shared); RT_LOCK(dst_s->lock); TRACE("map implicit signal %s+%d to %s+%d count %d", istr(tree_ident(src_s->where)), src_offset, istr(tree_ident(dst_s->where)), dst_offset, count); assert(src_s != dst_s); assert(dst_offset == 0); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, src_s, src_offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); rt_source_t *src = add_source(m, &(dst_s->nexus), SOURCE_IMPLICIT); src->u.port.input = n; src->chain_output = n->outputs; n->outputs = src; n->flags |= NET_F_EFFECTIVE; // Update outputs when active n->flags &= ~NET_F_FAST_DRIVER; } } void x_push_scope(tree_t where, int32_t size, rt_scope_kind_t kind) { TRACE("push scope %s size=%d kind=%d", istr(tree_ident(where)), size, kind); rt_model_t *m = get_model(); model_thread_t *thread = model_thread(m); ident_t name; if (thread->active_scope && thread->active_scope->kind == SCOPE_ARRAY) name = ident_sprintf("%s(%d)", istr(thread->active_scope->name), thread->active_scope->children.count); else if (thread->active_scope && thread->active_scope->kind == SCOPE_RECORD) name = ident_prefix(thread->active_scope->name, tree_ident(where), '.'); else name = tree_ident(where); rt_scope_t *s = xcalloc(sizeof(rt_scope_t)); s->where = where; s->name = name; s->kind = kind; s->parent = thread->active_scope; s->size = size; s->privdata = MPTR_INVALID; if (kind != SCOPE_PACKAGE) { type_t type = tree_type(where); assert(type_is_composite(type)); if (type_kind(type) == T_SUBTYPE && type_has_resolution(type)) s->flags |= SCOPE_F_RESOLVED; } thread->active_scope = s; } void x_pop_scope(void) { rt_model_t *m = get_model(); model_thread_t *thread = model_thread(m); rt_scope_t *pop = thread->active_scope, *old = pop->parent; TRACE("pop scope %s", istr(tree_ident(pop->where))); int offset = INT_MAX; for (int i = 0; i < pop->children.count; i++) offset = MIN(offset, pop->children.items[i]->offset); for (int i = 0; i < pop->signals.count; i++) offset = MIN(offset, pop->signals.items[i]->offset); pop->offset = offset; thread->active_scope = old; if (pop->kind == SCOPE_PACKAGE) pop->parent = m->root; // Always attach packages to root scope APUSH(pop->parent->children, pop); } bool x_driving(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("_driving %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); int ntotal = 0, ndriving = 0; bool found = false; rt_model_t *m = get_model(); rt_proc_t *proc = get_active_proc(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { if (n->n_sources > 0) { rt_source_t *src = find_driver(n, proc); if (src != NULL) { if (!src->disconnected) ndriving++; found = true; } } ntotal++; count -= n->width; assert(count >= 0); } if (!found) jit_msg(NULL, DIAG_FATAL, "process %s does not contain a driver for %s", istr(proc->name), istr(tree_ident(s->where))); return ntotal == ndriving; } void *x_driving_value(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); RT_LOCK(s->lock); TRACE("driving value %s offset=%d count=%d", istr(tree_ident(s->where)), offset, count); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); rt_proc_t *proc = get_active_proc(); if (proc == NULL) { // Called in output conversion if (n->flags & NET_F_EFFECTIVE) return nexus_driving(n); else return nexus_effective(n); } void *result = tlab_alloc(model_thread(m)->tlab, s->shared.size); uint8_t *p = result; for (; count > 0; n = n->chain) { rt_source_t *src = find_driver(n, proc); if (src == NULL) jit_msg(NULL, DIAG_FATAL, "process %s does not contain a driver " "for %s", istr(proc->name), istr(tree_ident(s->where))); const uint8_t *driving; if (n->flags & NET_F_FAST_DRIVER) driving = nexus_effective(n); else driving = value_ptr(n, &(src->u.driver.waveforms.value)); memcpy(p, driving, n->width * n->size); p += n->width * n->size; count -= n->width; assert(count >= 0); } return result; } sig_shared_t *x_implicit_signal(uint32_t count, uint32_t size, tree_t where, implicit_kind_t kind, ffi_closure_t *closure, int64_t delay) { TRACE("implicit signal %s count=%d size=%d kind=%d", istr(tree_ident(where)), count, size, kind); rt_model_t *m = get_model(); const size_t datasz = MAX(2 * count * size, 8); rt_implicit_t *imp = static_alloc(m, sizeof(rt_implicit_t) + datasz); setup_signal(m, &(imp->signal), where, count, size, SIG_F_IMPLICIT, 0); imp->closure = *closure; imp->delay = delay; imp->wakeable.kind = W_IMPLICIT; deferq_do(&m->implicitq, async_update_implicit_signal, imp); set_pending(&(imp->wakeable)); if (kind == IMPLICIT_STABLE || kind == IMPLICIT_QUIET) { add_source(m, &(imp->signal.nexus), SOURCE_DRIVER); imp->signal.shared.data[0] = 1; // X'STABLE initally true } return &(imp->signal.shared); } void x_disconnect(sig_shared_t *ss, uint32_t offset, int32_t count, int64_t after, int64_t reject) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("_disconnect %s+%d len=%d after=%s reject=%s", istr(tree_ident(s->where)), offset, count, trace_time(after), trace_time(reject)); rt_proc_t *proc = get_active_proc(); check_postponed(after, proc); check_reject_limit(s, after, reject); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); sched_disconnect(m, n, after, reject, proc); } } void x_force(sig_shared_t *ss, uint32_t offset, int32_t count, void *values) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("force signal %s+%d value=%s count=%d", istr(tree_ident(s->where)), offset, fmt_values(values, count), count); rt_proc_t *proc = get_active_proc(); rt_model_t *m = get_model(); check_postponed(0, proc); force_signal(m, s, values, offset, count); } void x_release(sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("release signal %s+%d count=%d", istr(tree_ident(s->where)), offset, count); rt_proc_t *proc = get_active_proc(); rt_model_t *m = get_model(); check_postponed(0, proc); release_signal(m, s, offset, count); } void x_deposit_signal(sig_shared_t *ss, uint32_t offset, int32_t count, void *values) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("deposit signal %s+%d value=%s count=%d", istr(tree_ident(s->where)), offset, fmt_values(values, count * s->nexus.size), count); rt_proc_t *proc = get_active_proc(); rt_model_t *m = get_model(); check_postponed(0, proc); deposit_signal(m, s, values, offset, count); } void x_put_conversion(rt_conv_func_t *cf, sig_shared_t *ss, uint32_t offset, int32_t count, void *values) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("put conversion %s+%d value=%s count=%d", istr(tree_ident(s->where)), offset, fmt_values(values, count * s->nexus.size), count); rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); rt_source_t *s = &(n->sources); for (; s; s = s->chain_input) { if (s->tag == SOURCE_PORT && s->u.port.conv_func == cf) break; } rt_value_t *result; if (s != NULL) result = &(s->u.port.conv_result); else { assert(n->flags & NET_F_EFFECTIVE); result = find_conversion_input(cf, n); assert(result != NULL); } copy_value_ptr(n, result, values); values += n->width * n->size; } } void x_resolve_signal(sig_shared_t *ss, jit_handle_t handle, void *context, int32_t nlits, int32_t flags) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("resolve signal %s", istr(tree_ident(s->where))); ffi_closure_t closure = { .handle = handle, .context = context }; rt_model_t *m = get_model(); s->resolution = memo_resolution_fn(m, s, closure, nlits, flags); // Copy R_IDENT into the nexus flags to avoid rt_resolve_nexus_fast // having to dereference the resolution pointer in the common case if (s->resolution->flags & R_IDENT) { s->shared.flags |= NET_F_R_IDENT; rt_nexus_t *n = &(s->nexus); for (int i = 0; i < s->n_nexus; i++, n = n->chain) n->flags |= NET_F_R_IDENT; } } void x_process_init(jit_handle_t handle, tree_t where) { rt_model_t *m = get_model(); ident_t name = jit_get_name(m->jit, handle); TRACE("init process %s", istr(name)); rt_scope_t *s = model_thread(m)->active_scope; assert(s != NULL); assert(s->kind == SCOPE_INSTANCE); rt_proc_t *p = xcalloc(sizeof(rt_proc_t)); p->where = where; p->name = name; p->handle = handle; p->scope = s; p->privdata = mptr_new(m->mspace, "process privdata"); p->wakeable.kind = W_PROC; p->wakeable.pending = false; p->wakeable.postponed = false; p->wakeable.delayed = false; APUSH(s->procs, p); } void *x_function_trigger(jit_handle_t handle, unsigned nargs, const jit_scalar_t *args) { rt_model_t *m = get_model(); uint64_t hash = mix_bits_32(handle); for (int i = 0; i < nargs; i++) hash ^= mix_bits_64(args[i].integer); TRACE("function trigger %s nargs=%u hash=%"PRIx64, istr(jit_get_name(m->jit, handle)), nargs, hash); return new_trigger(m, FUNC_TRIGGER, hash, handle, nargs, args); } void *x_or_trigger(void *left, void *right) { rt_model_t *m = get_model(); uint64_t hash = mix_bits_64(left) ^ mix_bits_64(right); TRACE("or trigger %p %p hash=%"PRIx64, left, right, hash); const jit_scalar_t args[] = { { .pointer = left < right ? left : right }, { .pointer = left < right ? right : left } }; return new_trigger(m, OR_TRIGGER, hash, JIT_HANDLE_INVALID, 2, args); } void *x_cmp_trigger(sig_shared_t *ss, uint32_t offset, int64_t right) { rt_model_t *m = get_model(); rt_signal_t *s = container_of(ss, rt_signal_t, shared); uint64_t hash = mix_bits_64(s) ^ mix_bits_32(offset) ^ mix_bits_64(right); TRACE("cmp trigger %s+%d right=%"PRIi64" hash=%"PRIx64, istr(tree_ident(s->where)), offset, right, hash); const jit_scalar_t args[] = { { .pointer = s }, { .integer = offset }, { .integer = right } }; return new_trigger(m, CMP_TRIGGER, hash, JIT_HANDLE_INVALID, 3, args); } void x_add_trigger(void *ptr) { TRACE("add trigger %p", ptr); rt_wakeable_t *obj = get_active_wakeable(); assert(obj->trigger == NULL); obj->trigger = ptr; } void *x_port_conversion(const ffi_closure_t *driving, const ffi_closure_t *effective) { rt_model_t *m = get_model(); TRACE("port conversion %s context %p", istr(jit_get_name(m->jit, driving->handle)), driving->context); if (effective->handle != JIT_HANDLE_INVALID) TRACE("effective value conversion %s context %p", istr(jit_get_name(m->jit, effective->handle)), effective->context); const size_t tail_bytes = ALIGN_UP(sizeof(rt_conv_func_t), MEMBLOCK_ALIGN) - sizeof(rt_conv_func_t); const int tail_max_inputs = tail_bytes / sizeof(conv_input_t); assert(tail_max_inputs > 0); const size_t total_bytes = sizeof(rt_conv_func_t) + tail_max_inputs * sizeof(conv_input_t); rt_conv_func_t *cf = static_alloc(m, total_bytes); cf->driving = *driving; cf->effective = *effective; cf->ninputs = 0; cf->maxinputs = tail_max_inputs; cf->outputs = NULL; cf->inputs = cf->tail; cf->when = TIME_HIGH; cf->iteration = UINT_MAX; return cf; } void x_convert_in(void *ptr, sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("convert in %p %s+%d count=%d", ptr, istr(tree_ident(s->where)), offset, count); rt_conv_func_t *cf = ptr; rt_model_t *m = get_model(); rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); add_conversion_input(m, cf, n); rt_source_t **p = &(n->outputs); for (; *p != NULL && *p != cf->outputs; p = &((*p)->chain_output)); *p = cf->outputs; } } void x_convert_out(void *ptr, sig_shared_t *ss, uint32_t offset, int32_t count) { rt_signal_t *s = container_of(ss, rt_signal_t, shared); TRACE("convert out %p %s+%d count=%d", ptr, istr(tree_ident(s->where)), offset, count); rt_conv_func_t *cf = ptr; rt_model_t *m = get_model(); assert(cf->ninputs == 0); // Add outputs first rt_nexus_t *n = split_nexus(m, s, offset, count); for (; count > 0; n = n->chain) { count -= n->width; assert(count >= 0); rt_source_t *src = add_source(m, n, SOURCE_PORT); src->u.port.conv_func = cf; src->u.port.conv_result = alloc_value(m, n); src->chain_output = cf->outputs; cf->outputs = src; } } void x_instance_name(attr_kind_t kind, text_buf_t *tb) { rt_model_t *m = get_model(); rt_scope_t *s = get_active_scope(m); switch (kind) { case ATTR_INSTANCE_NAME: get_instance_name(s, tb); break; case ATTR_PATH_NAME: get_path_name(s, tb); break; default: should_not_reach_here(); } } nvc-r1.17.1/src/rt/model.h000066400000000000000000000064051504111170000152310ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_MODEL_H #define _RT_MODEL_H #include "prim.h" #include "rt/rt.h" typedef enum { WATCH_EVENT, WATCH_POSTPONED, } watch_kind_t; rt_model_t *model_new(jit_t *jit, cover_data_t *cover); void model_free(rt_model_t *m); void model_reset(rt_model_t *m); void model_run(rt_model_t *m, uint64_t stop_time); bool model_step(rt_model_t *m); bool model_can_create_delta(rt_model_t *m); int64_t model_now(rt_model_t *m, unsigned *deltas); int64_t model_next_time(rt_model_t *m); void model_stop(rt_model_t *m); void model_interrupt(rt_model_t *m); int model_exit_status(rt_model_t *m); rt_watch_t *watch_new(rt_model_t *m, sig_event_fn_t fn, void *user, watch_kind_t kind, unsigned slots); void watch_free(rt_model_t *m, rt_watch_t *w); void model_set_global_cb(rt_model_t *m, rt_event_t event, rt_event_fn_t fn, void *user); rt_watch_t *model_set_event_cb(rt_model_t *m, rt_signal_t *s, rt_watch_t *w); void model_set_timeout_cb(rt_model_t *m, uint64_t when, rt_event_fn_t fn, void *user); void call_with_model(rt_model_t *m, void (*cb)(void *), void *arg); rt_model_t *get_model(void); rt_model_t *get_model_or_null(void); rt_proc_t *get_active_proc(void); rt_scope_t *get_active_scope(rt_model_t *m); cover_data_t *get_coverage(rt_model_t *m); rt_scope_t *find_scope(rt_model_t *m, tree_t container); rt_scope_t *root_scope(rt_model_t *m); rt_scope_t *child_scope(rt_scope_t *scope, tree_t decl); rt_scope_t *child_scope_at(rt_scope_t *scope, int index); rt_signal_t *find_signal(rt_scope_t *scope, tree_t decl); rt_proc_t *find_proc(rt_scope_t *scope, tree_t proc); bool is_signal_scope(rt_scope_t *scope); rt_scope_t *create_scope(rt_model_t *m, tree_t block, rt_scope_t *parent); void get_instance_name(rt_scope_t *s, text_buf_t *tb); void get_path_name(rt_scope_t *s, text_buf_t *tb); const void *signal_value(rt_signal_t *s); const void *signal_last_value(rt_signal_t *s); uint8_t signal_size(rt_signal_t *s); uint32_t signal_width(rt_signal_t *s); size_t signal_expand(rt_signal_t *s, uint64_t *buf, size_t max); void force_signal(rt_model_t *m, rt_signal_t *s, const void *values, int offset, size_t count); void release_signal(rt_model_t *m, rt_signal_t *s, int offset, size_t count); void deposit_signal(rt_model_t *m, rt_signal_t *s, const void *values, int offset, size_t count); rt_watch_t *find_watch(rt_nexus_t *n, sig_event_fn_t fn); void get_forcing_value(rt_signal_t *s, uint8_t *value); int32_t *get_cover_counter(rt_model_t *m, int32_t tag, int count); #endif // _RT_MODEL_H nvc-r1.17.1/src/rt/mspace.c000066400000000000000000000356271504111170000154040ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "cpustate.h" #include "diag.h" #include "mask.h" #include "option.h" #include "rt/mspace.h" #include "thread.h" #include #include #include #include #include #define LINE_SIZE 32 #define LINE_WORDS (LINE_SIZE / sizeof(intptr_t)) #define MAX_HEAP (UINT64_C(0x100000000) * LINE_SIZE) // Extra padding at the end of heap regions to allow vectorised // intrinsics to read past the end of an array #define OVERRUN_MARGIN 32 // AVX2 has 32-byte vectors STATIC_ASSERT(OVERRUN_MARGIN % LINE_SIZE == 0); typedef A(uint64_t) work_list_t; typedef struct _linked_tlab linked_tlab_t; typedef struct _linked_tlab { linked_tlab_t *next; linked_tlab_t *prev; tlab_t tlab; } linked_tlab_t; struct _mptr { void *ptr; mptr_t prev; mptr_t next; #ifdef DEBUG const char *name; #endif }; typedef struct { bit_mask_t markmask; work_list_t worklist; struct cpu_state cpu[MAX_THREADS]; #if ASAN_ENABLED void *fake_stack[MAX_THREADS]; #endif } gc_state_t; typedef struct _free_list free_list_t; struct _free_list { free_list_t *next; char *ptr; size_t size; }; struct _mspace { nvc_lock_t lock; size_t maxsize; size_t maxlines; char *space; bit_mask_t headmask; mptr_t roots; mptr_t free_mptrs; mspace_oom_fn_t oomfn; free_list_t *free_list; uint64_t create_us; linked_tlab_t *live_tlabs; linked_tlab_t *free_tlabs; unsigned total_gc; unsigned num_cycles; #ifdef DEBUG bool stress; #endif }; static intptr_t *stack_limit[MAX_THREADS]; static void mspace_gc(mspace_t *m); static bool is_mspace_ptr(mspace_t *m, char *p); mspace_t *mspace_new(size_t size) { mspace_t *m = xcalloc(sizeof(mspace_t)); m->maxsize = ALIGN_UP(size, LINE_SIZE); m->maxlines = (m->maxsize - OVERRUN_MARGIN) / LINE_SIZE; if (m->maxsize > MAX_HEAP) fatal("the maximum supported heap size is %"PRIu64"g", MAX_HEAP / 1024 / 1024 / 1024); DEBUG_ONLY(m->stress = opt_get_int(OPT_GC_STRESS)); m->space = map_huge_pages(LINE_SIZE, m->maxsize); ASAN_POISON(m->space, m->maxsize); mask_init(&(m->headmask), m->maxlines); mask_setall(&(m->headmask)); free_list_t *f = xmalloc(sizeof(free_list_t)); f->next = NULL; f->ptr = m->space; f->size = m->maxsize - OVERRUN_MARGIN; m->free_list = f; m->create_us = get_timestamp_us(); return m; } void mspace_destroy(mspace_t *m) { #ifdef DEBUG if (m->roots != NULL) { LOCAL_TEXT_BUF tb = tb_new(); int n = 0; for (mptr_t p = m->roots; p; p = p->next) tb_printf(tb, "%s%s", n++ > 0 ? ", " : "", p->name); fatal_trace("destroying mspace with %d live mptrs: %s", n, tb_get(tb)); } #endif assert(m->live_tlabs == NULL); for (linked_tlab_t *lt = m->free_tlabs, *tmp; lt; lt = tmp) { tmp = lt->next; free(lt); } if (opt_get_verbose(OPT_GC_VERBOSE, NULL) && m->num_cycles > 0) { const uint64_t destroy_us = get_timestamp_us(); const double gc_frac = m->total_gc / (double)(destroy_us - m->create_us); debugf("GC: %d collection cycles; %d us total; %.1f%% of overall " "run time", m->num_cycles, m->total_gc, gc_frac * 100.0); } for (free_list_t *it = m->free_list, *tmp; it; it = tmp) { tmp = it->next; free(it); } for (mptr_t p = m->free_mptrs, tmp; p; p = tmp) { tmp = p->next; free(p); } mask_free(&(m->headmask)); nvc_munmap(m->space, m->maxsize); free(m); } void mspace_stack_limit(void *limit) { assert(limit != NULL); atomic_store(&(stack_limit[thread_id()]), limit); } static void *mspace_try_alloc(mspace_t *m, size_t size) { // Add one to size before rounding up to LINE_SIZE to allow a valid // pointer to point at one element past the end of an array const size_t nlines = (size + LINE_SIZE) / LINE_SIZE; const size_t asize = nlines * LINE_SIZE; SCOPED_LOCK(m->lock); for (free_list_t **it = &(m->free_list); *it; it = &((*it)->next)) { assert((*it)->size % LINE_SIZE == 0); if ((*it)->size >= asize) { char *base = (*it)->ptr; assert((uintptr_t)base % LINE_SIZE == 0); assert(base >= m->space); assert(base < m->space + m->maxsize); ASAN_UNPOISON(base, size); const ptrdiff_t line = (base - m->space) / LINE_SIZE; mask_set(&(m->headmask), line); if (nlines > 1) mask_clear_range(&(m->headmask), line + 1, nlines - 1); if ((*it)->size == asize) { free_list_t *next = (*it)->next; free(*it); *it = next; } else { (*it)->size -= asize; (*it)->ptr += asize; } // Make sure the first fault to the page is a write to // allocate THP on Linux *(volatile char *)base = 0; return base; } } return NULL; } void *mspace_alloc(mspace_t *m, size_t size) { if (size == 0) return NULL; #ifdef DEBUG if (stack_limit[thread_id()] == NULL) fatal_trace("cannot allocate without setting stack limit"); else if (m->stress) mspace_gc(m); #endif int retry = 1; do { void *ptr = mspace_try_alloc(m, size); if (ptr != NULL) return ptr; mspace_gc(m); } while (retry--); if (m->oomfn) { (*m->oomfn)(m, size); return NULL; } else fatal_trace("out of memory attempting to allocate %zu byte object", size); } void *mspace_alloc_array(mspace_t *m, int nelems, size_t size) { return mspace_alloc(m, nelems * size); } void *mspace_alloc_flex(mspace_t *m, size_t fixed, int nelems, size_t size) { return mspace_alloc(m, fixed + nelems * size); } void mspace_set_oom_handler(mspace_t *m, mspace_oom_fn_t fn) { m->oomfn = fn; } mptr_t mptr_new(mspace_t *m, const char *name) { SCOPED_LOCK(m->lock); mptr_t ptr; if (m->free_mptrs != NULL) { ptr = m->free_mptrs; m->free_mptrs = ptr->next; } else ptr = xmalloc(sizeof(struct _mptr)); if (m->roots != NULL) { assert(m->roots->prev == NULL); m->roots->prev = ptr; } ptr->ptr = NULL; ptr->next = m->roots; ptr->prev = NULL; DEBUG_ONLY(ptr->name = name); return (m->roots = ptr); } void mptr_free(mspace_t *m, mptr_t *ptr) { if (*ptr == MPTR_INVALID) return; SCOPED_LOCK(m->lock); if ((*ptr)->next != NULL) (*ptr)->next->prev = (*ptr)->prev; if ((*ptr)->prev != NULL) (*ptr)->prev->next = (*ptr)->next; else { assert(m->roots == *ptr); m->roots = (*ptr)->next; } (*ptr)->prev = NULL; (*ptr)->ptr = NULL; DEBUG_ONLY((*ptr)->name = NULL); (*ptr)->next = m->free_mptrs; m->free_mptrs = *ptr; *ptr = NULL; } void **mptr_get(mptr_t ptr) { assert(ptr != MPTR_INVALID); return &(ptr->ptr); } #ifdef DEBUG static bool tlab_on_list(linked_tlab_t *lt, linked_tlab_t *list) { for (linked_tlab_t *it = list; it; it = it->next) { if (it == lt) return true; } return false; } #endif tlab_t *tlab_acquire(mspace_t *m) { SCOPED_LOCK(m->lock); linked_tlab_t *lt = m->free_tlabs; if (lt == NULL) { lt = xmalloc(sizeof(linked_tlab_t) + TLAB_SIZE); lt->tlab.mspace = m; } else { assert(!tlab_on_list(lt, m->live_tlabs)); assert(lt->prev == NULL); m->free_tlabs = lt->next; } lt->next = m->live_tlabs; lt->prev = NULL; if (m->live_tlabs != NULL) { assert(m->live_tlabs->prev == NULL); m->live_tlabs->prev = lt; } m->live_tlabs = lt; // Ensure proper starting alignment on 32-bit systems const size_t data_off = offsetof(tlab_t, data); lt->tlab.alloc = ALIGN_UP(data_off, sizeof(double)) - data_off; lt->tlab.limit = TLAB_SIZE - OVERRUN_MARGIN; return &(lt->tlab); } void tlab_release(tlab_t *t) { if (t == NULL) return; SCOPED_LOCK(t->mspace->lock); linked_tlab_t *lt = container_of(t, linked_tlab_t, tlab); assert(t->alloc <= t->limit); assert(!tlab_on_list(lt, t->mspace->free_tlabs)); assert(tlab_on_list(lt, t->mspace->live_tlabs)); if (lt->prev == NULL) t->mspace->live_tlabs = lt->next; else { assert(lt->prev->next == lt); lt->prev->next = lt->next; } if (lt->next != NULL) lt->next->prev = lt->prev; assert(!tlab_on_list(lt, t->mspace->live_tlabs)); lt->prev = NULL; lt->next = t->mspace->free_tlabs; t->mspace->free_tlabs = lt; } void *tlab_alloc(tlab_t *t, size_t size) { assert(t->alloc <= t->limit); assert((t->alloc & (sizeof(double) - 1)) == 0); if (t->alloc + size <= t->limit) { void *p = t->data + t->alloc; t->alloc += ALIGN_UP(size, sizeof(double)); return p; } else return mspace_alloc(t->mspace, size); } __attribute__((always_inline)) static inline bool is_mspace_ptr(mspace_t *m, char *p) { return p >= m->space && p < m->space + m->maxsize; } static void mspace_mark_root(mspace_t *m, intptr_t p, gc_state_t *state) { if (is_mspace_ptr(m, (char *)p)) { ptrdiff_t line = ((char *)p - m->space) / LINE_SIZE; assert(line < UINT32_MAX); // Enforced by MAX_HEAP // Scan backwards to the start of the object line = mask_scan_backwards(&(m->headmask), line); assert(line != -1); size_t objlen = 1; if (line + 1 < m->maxlines) objlen += mask_count_clear(&(m->headmask), line + 1); assert(objlen < UINT32_MAX); if (!mask_test(&(state->markmask), line)) { mask_set_range(&(state->markmask), line, objlen); uint64_t enc = ((uint64_t)line << 32) | objlen; APUSH(state->worklist, enc); } } } static void mspace_suspend_cb(int thread_id, struct cpu_state *cpu, void *arg) { gc_state_t *state = arg; assert(thread_id < MAX_THREADS); state->cpu[thread_id] = *cpu; #if ASAN_ENABLED state->fake_stack[thread_id] = __asan_get_current_fake_stack(); #endif } __attribute__((no_sanitize_address, noinline)) static void mspace_gc(mspace_t *m) { const uint64_t start_ticks = get_timestamp_us(); #ifdef DEBUG if (stack_limit[thread_id()] == NULL) fatal_trace("GC requested without setting stack limit"); #endif #if defined __SANITIZE_THREAD__ && !defined __APPLE__ return; // Cannot reliably suspend threads with tsan #endif gc_state_t state = {}; mask_init(&(state.markmask), m->maxlines); SCOPED_LOCK(m->lock); stop_world(mspace_suspend_cb, &state); for (int i = 0; i < MAX_THREADS; i++) { if (get_thread(i) == NULL) continue; intptr_t *limit = atomic_load(&(stack_limit[i])); if (limit == NULL) continue; for (int j = 0; j < MAX_CPU_REGS; j++) mspace_mark_root(m, state.cpu[i].regs[j], &state); intptr_t *stack_top = (intptr_t *)state.cpu[i].sp; assert(stack_top <= limit); // Stack must grow down for (intptr_t *p = stack_top; p < limit; p++) { mspace_mark_root(m, *p, &state); #if ASAN_ENABLED // Address sanitiser relocates possibly-escaping stack // allocations to a "fake stack" on the heap which we also need // to scan to find roots if (state.fake_stack[i] != NULL) { void *beg, *end; if (__asan_addr_is_in_fake_stack(state.fake_stack[i], (void *)*p, &beg, &end)) { for (intptr_t *p2 = beg; p2 < (intptr_t *)end; p2++) mspace_mark_root(m, *p2, &state); } } #endif } } for (mptr_t p = m->roots; p; p = p->next) mspace_mark_root(m, (intptr_t)p->ptr, &state); for (linked_tlab_t *lt = m->live_tlabs; lt; lt = lt->next) { for (char *p = lt->tlab.data; p < lt->tlab.data + lt->tlab.alloc; p += sizeof(intptr_t)) mspace_mark_root(m, *(intptr_t *)p, &state); } while (state.worklist.count > 0) { const uint64_t enc = APOP(state.worklist); const uint32_t line = enc >> 32; const uint32_t objlen = enc & 0xffffffff; for (size_t i = 0; i < objlen; i++) { const ptrdiff_t off = (uintptr_t)(line + i) * LINE_SIZE; intptr_t *words = (intptr_t *)(m->space + off); for (int j = 0; j < LINE_WORDS; j++) mspace_mark_root(m, words[j], &state); } } #if ASAN_ENABLED for (int i = 0; i < m->maxlines; i++) { if (!mask_test(&(state.markmask), i)) ASAN_POISON(m->space + i * LINE_SIZE, LINE_SIZE); } #endif for (free_list_t *it = m->free_list, *tmp; it; it = tmp) { tmp = it->next; free(it); } m->free_list = NULL; int freefrags = 0, freelines = 0; free_list_t **tail = &(m->free_list); for (size_t line = 0; line < m->maxlines;) { const size_t clear = mask_count_clear(&(state.markmask), line); if (clear == 0) line++; else { free_list_t *f = xmalloc(sizeof(free_list_t)); f->next = NULL; f->ptr = m->space + line * LINE_SIZE; f->size = clear * LINE_SIZE; *tail = f; tail = &(f->next); mask_set_range(&(m->headmask), line, clear); freefrags++; freelines += clear; line += clear; } } start_world(); if (opt_get_verbose(OPT_GC_VERBOSE, NULL)) { const int ticks = get_timestamp_us() - start_ticks; debugf("GC: allocated %zd/%zu; fragmentation %.2g%% [%d us]", mask_popcount(&(state.markmask)) * LINE_SIZE, m->maxsize, ((double)(freefrags - 1) / (double)freelines) * 100.0, ticks); m->total_gc += ticks; m->num_cycles++; } mask_free(&(state.markmask)); assert(state.worklist.count == 0); ACLEAR(state.worklist); } void *mspace_find(mspace_t *m, void *ptr, size_t *size) { if (!is_mspace_ptr(m, ptr)) { *size = 0; return NULL; } ptrdiff_t line = ((char *)ptr - m->space) / LINE_SIZE; // Scan backwards to the start of the object line = mask_scan_backwards(&(m->headmask), line); assert(line != -1); size_t objlen = 1; if (line + 1 < m->maxlines) objlen += mask_count_clear(&(m->headmask), line + 1); *size = objlen * LINE_SIZE; return m->space + line * LINE_SIZE; } nvc-r1.17.1/src/rt/mspace.h000066400000000000000000000037141504111170000154010ustar00rootroot00000000000000// // Copyright (C) 2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_MSPACE_H #define _RT_MSPACE_H #include "prim.h" #define MPTR_INVALID NULL typedef struct _mptr *mptr_t; typedef void *UNSAFE_MPTR; typedef void (*mspace_oom_fn_t)(mspace_t *, size_t); #define TLAB_SIZE (64 * 1024) // The code generator knows the layout of this struct typedef struct _tlab { mspace_t *mspace; uint32_t alloc; uint32_t limit; char data[0]; } tlab_t; #define tlab_reset(t) do { \ assert((t)->alloc <= (t)->limit); \ (t)->alloc = 0; \ } while (0) mspace_t *mspace_new(size_t size); void mspace_destroy(mspace_t *m); void *mspace_alloc(mspace_t *m, size_t size); void *mspace_alloc_array(mspace_t *m, int nelems, size_t size); void *mspace_alloc_flex(mspace_t *m, size_t fixed, int nelems, size_t size); void mspace_set_oom_handler(mspace_t *m, mspace_oom_fn_t fn); void *mspace_find(mspace_t *m, void *ptr, size_t *size); tlab_t *tlab_acquire(mspace_t *m); void tlab_release(tlab_t *t); void *tlab_alloc(tlab_t *t, size_t size); mptr_t mptr_new(mspace_t *m, const char *name); void mptr_free(mspace_t *m, mptr_t *ptr); void **mptr_get(mptr_t ptr); #define MSPACE_CURRENT_FRAME __builtin_frame_address(0) void mspace_stack_limit(void *limit); #endif // _RT_MSPACE_H nvc-r1.17.1/src/rt/printer.c000066400000000000000000000214471504111170000156120ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "rt/printer.h" #include "rt/structs.h" #include "type.h" #include #include #include #include typedef void (*type_fn_t)(print_func_t *, const void *, size_t, print_flags_t); typedef struct _print_func { printer_t *printer; type_fn_t typefn; char *map; size_t stride; print_func_t *elem; } print_func_t; typedef struct _printer { hash_t *typemap; text_buf_t *buf; } printer_t; static const char std_logic_map[] = "UX01ZWLH-"; static void begin_quote(print_func_t *f, print_flags_t flags, char enc) { if (flags & PRINT_F_ENCODE) tb_append(f->printer->buf, enc); else tb_append(f->printer->buf, '"'); } static void end_quote(print_func_t *f, print_flags_t flags) { if (!(flags & PRINT_F_ENCODE)) tb_append(f->printer->buf, '"'); } static void int_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { assert(size <= 8); assert(is_power_of_2(size)); if (flags & PRINT_F_ENCODE) tb_append(f->printer->buf, 'i'); const int radix = flags & PRINT_F_RADIX; if (radix == PRINT_F_HEX || radix == PRINT_F_BIN) { uint64_t wide = 0; switch (size) { case 1: wide = *(uint8_t *)data; break; case 2: wide = *(uint16_t *)data; break; case 4: wide = *(uint32_t *)data; break; case 8: wide = *(uint64_t *)data; break; } if (radix == PRINT_F_BIN) { for (int i = (size * 8) - 1; i >= 0; i--) tb_append(f->printer->buf, (wide & (UINT64_C(1) << i)) ? '1' : '0'); } else tb_printf(f->printer->buf, "0x%"PRIx64, wide); } else { int64_t wide = 0; switch (size) { case 1: wide = *(int8_t *)data; break; case 2: wide = *(int16_t *)data; break; case 4: wide = *(int32_t *)data; break; case 8: wide = *(int64_t *)data; break; } tb_printf(f->printer->buf, "%"PRIi64, wide); } } static void std_logic_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { assert(size == 1); if (flags & PRINT_F_ENCODE) { tb_append(f->printer->buf, 'l'); tb_append(f->printer->buf, std_logic_map[*(uint8_t *)data]); } else { const char str[] = { '\'', std_logic_map[*(uint8_t *)data], '\'' }; tb_catn(f->printer->buf, str, ARRAY_LEN(str)); } } static void std_logic_vector_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { begin_quote(f, flags, 'L'); for (int i = 0; i < size; i++) { const uint8_t bit = *((uint8_t *)data + i); assert(bit < ARRAY_LEN(std_logic_map)); tb_append(f->printer->buf, std_logic_map[bit]); } end_quote(f, flags); } static void bit_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { assert(size == 1); if (flags & PRINT_F_ENCODE) { tb_append(f->printer->buf, 'b'); tb_append(f->printer->buf, *(uint8_t *)data ? '1' : '0'); } else tb_cat(f->printer->buf, *(uint8_t *)data ? "'1'" : "'0'"); } static void bit_vector_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { begin_quote(f, flags, 'B'); for (int i = 0; i < size; i++) tb_append(f->printer->buf, *((uint8_t *)data + i) ? '1' : '0'); end_quote(f, flags); } static void physical_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { if (flags & PRINT_F_ENCODE) tb_append(f->printer->buf, 'p'); int_printer(f, data, size, 0); tb_append(f->printer->buf, ' '); tb_cat(f->printer->buf, f->map); } static void enum_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { if (flags & PRINT_F_ENCODE) tb_append(f->printer->buf, 'e'); assert(size == 1); const int lit = *(uint8_t *)data; tb_cat(f->printer->buf, f->map + lit * f->stride); } static void make_enum_map(print_func_t *f, type_t type) { int stride = 0; const unsigned nlits = type_enum_literals(type); for (int i = 0; i < nlits; i++) stride = MAX(stride, ident_len(tree_ident(type_enum_literal(type, i)))); f->stride = stride + 1; f->map = xcalloc_array(nlits, f->stride); for (int i = 0; i < nlits; i++) { ident_t id = tree_ident(type_enum_literal(type, i)); memcpy(f->map + i*f->stride, istr(id), ident_len(id)); } } static void enum_vector_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { if (flags & PRINT_F_ENCODE) tb_append(f->printer->buf, 'E'); flags &= ~PRINT_F_ENCODE; tb_append(f->printer->buf, '('); for (int i = 0; i < size; i++) { if (i > 0) tb_cat(f->printer->buf, ", "); (*f->elem->typefn)(f->elem, data + i, 1, flags); } tb_append(f->printer->buf, ')'); } static void string_printer(print_func_t *f, const void *data, size_t size, print_flags_t flags) { bool allprint = true; for (int i = 0; i < size; i++) allprint &= isprint_iso88591(*((uint8_t *)data + i)); if (allprint) { begin_quote(f, flags, 'S'); for (int i = 0; i < size; i++) tb_append(f->printer->buf, *((uint8_t *)data + i)); end_quote(f, flags); } else enum_vector_printer(f, data, size, flags); } printer_t *printer_new(void) { printer_t *p = xcalloc(sizeof(printer_t)); p->typemap = hash_new(128); p->buf = tb_new(); return p; } void printer_free(printer_t *p) { hash_iter_t it = HASH_BEGIN; const void *key; void *value; while (hash_iter(p->typemap, &it, &key, &value)) { print_func_t *f = value; free(f->map); free(f); } hash_free(p->typemap); tb_free(p->buf); free(p); } print_func_t *printer_for(printer_t *p, type_t type) { print_func_t *f = hash_get(p->typemap, type); if (f != NULL) return f; type_t base = type_base_recur(type); if ((f = hash_get(p->typemap, base)) != NULL) { hash_put(p->typemap, type, f); return f; } f = xcalloc(sizeof(print_func_t)); f->printer = p; switch (type_kind(base)) { case T_INTEGER: f->typefn = int_printer; break; case T_ENUM: switch (is_well_known(type_ident(base))) { case W_IEEE_LOGIC: case W_IEEE_ULOGIC: f->typefn = std_logic_printer; break; case W_STD_BIT: f->typefn = bit_printer; break; default: f->typefn = enum_printer; make_enum_map(f, type); break; } break; case T_PHYSICAL: f->typefn = physical_printer; f->map = xstrdup(istr(tree_ident(type_unit(base, 0)))); break; case T_ARRAY: switch (is_well_known(type_ident(base))) { case W_IEEE_LOGIC_VECTOR: case W_IEEE_ULOGIC_VECTOR: case W_IEEE_UNSIGNED: case W_IEEE_SIGNED: f->typefn = std_logic_vector_printer; break; case W_STD_BIT_VECTOR: f->typefn = bit_vector_printer; break; case W_STD_STRING: f->typefn = string_printer; f->elem = printer_for(p, type_elem(base)); break; default: { type_t elem = type_elem(type); if (type_is_enum(elem)) { f->typefn = enum_vector_printer; f->elem = printer_for(p, type_elem(base)); break; } goto invalid; } } break; default: goto invalid; } hash_put(p->typemap, type, f); return f; invalid: free(f); return NULL; } const char *print_signal(print_func_t *fn, rt_signal_t *s, print_flags_t flags) { tb_rewind(fn->printer->buf); (*fn->typefn)(fn, s->shared.data, s->shared.size, flags); return tb_get(fn->printer->buf); } const char *print_raw(print_func_t *fn, const void *data, size_t size, print_flags_t flags) { tb_rewind(fn->printer->buf); (*fn->typefn)(fn, data, size, flags); return tb_get(fn->printer->buf); } nvc-r1.17.1/src/rt/printer.h000066400000000000000000000024361504111170000156140ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_PRINTER_H #define _RT_PRINTER_H #include "prim.h" typedef struct _print_func print_func_t; #define PRINT_F_RADIX 0x3 #define PRINT_F_BIN 1 #define PRINT_F_HEX 2 #define PRINT_F_DEC 3 #define PRINT_F_ENCODE 0x4 typedef uint32_t print_flags_t; printer_t *printer_new(void); void printer_free(printer_t *p); print_func_t *printer_for(printer_t *p, type_t type); const char *print_signal(print_func_t *fn, rt_signal_t *s, print_flags_t flags); const char *print_raw(print_func_t *fn, const void *data, size_t size, print_flags_t flags); #endif // _RT_PRINTER_H nvc-r1.17.1/src/rt/random.c000066400000000000000000000045141504111170000154030ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "jit/jit.h" #include "option.h" #include "thread.h" #include #define MT_N 624 #define MT_M 397 #define MATRIX_A 0x9908B0DFUL #define UPPER_MASK 0x80000000UL #define LOWER_MASK 0x7FFFFFFFUL static uint32_t mt[MT_N]; static int mti = MT_N + 1; static nvc_lock_t lock; static void mt19937_init(uint32_t seed) { mt[0] = seed; for (mti = 1; mti < MT_N; mti++) mt[mti] = 1812433253UL * (mt[mti - 1] ^ (mt[mti - 1] >> 30)) + mti; DEBUG_ONLY(debugf("initialised MT19937 with seed %08x", seed)); } static uint32_t mt19937_next(void) { static const uint32_t mag01[2] = { 0x0UL, MATRIX_A }; uint32_t y; if (mti == MT_N) { // Twist int kk; for (kk = 0; kk < MT_N - MT_M; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + MT_M] ^ (y >> 1) ^ mag01[y & 0x1UL]; } for (; kk < MT_N - 1; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (MT_M - MT_N)] ^ (y >> 1) ^ mag01[y & 0x1UL]; } y = (mt[MT_N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[MT_N - 1] = mt[MT_M - 1] ^ (y >> 1) ^ mag01[y & 0x1UL]; mti = 0; } else assert(mti < MT_N); y = mt[mti++]; // Tempering y ^= (y >> 11); y ^= (y << 7) & 0x9D2C5680UL; y ^= (y << 15) & 0xEFC60000UL; y ^= (y >> 18); return y; } uint32_t get_random(void) { SCOPED_LOCK(lock); if (mti > MT_N) mt19937_init(opt_get_int(OPT_RANDOM_SEED)); return mt19937_next(); } DLLEXPORT void _nvc_random_get_next(jit_scalar_t *args) { args[0].integer = get_random(); } nvc-r1.17.1/src/rt/random.h000066400000000000000000000014601504111170000154050ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_RANDOM_H #define _RT_RANDOM_H #include "prim.h" uint32_t get_random(void); #endif // _RT_RANDOM_H nvc-r1.17.1/src/rt/reflect.c000066400000000000000000000777411504111170000155630ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "jit/jit-exits.h" #include "jit/jit-layout.h" #include "jit/jit.h" #include "rt/fileio.h" #include "tree.h" #include "type.h" #include #include #include #include typedef enum { CLASS_ENUMERATION, CLASS_INTEGER, CLASS_FLOATING, CLASS_PHYSICAL, CLASS_RECORD, CLASS_ARRAY, CLASS_ACCESS, CLASS_FILE, CLASS_PROTECTED } reflect_class_t; typedef struct _value_mirror value_mirror; typedef struct _subtype_mirror subtype_mirror; typedef struct _integer_value_mirror integer_value_mirror; typedef struct _floating_value_mirror floating_value_mirror; typedef struct _enumeration_value_mirror enumeration_value_mirror; typedef struct _physical_value_mirror physical_value_mirror; typedef struct { type_t f_type; subtype_mirror *f_mirror; } cache_elem_t; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; int64_t f_canary1; cache_elem_t *f_subtype_cache; int64_t f_num_subtypes; int64_t f_max_subtypes; int64_t f_canary2; } internal_cache_pt; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; integer_value_mirror *f_left; integer_value_mirror *f_right; integer_value_mirror *f_low; integer_value_mirror *f_high; uint8_t f_ascending; } integer_subtype_mirror_pt; typedef struct { void *access; integer_subtype_mirror_pt pt; } integer_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; ffi_uarray_t *f_literals; } enumeration_subtype_mirror_pt; typedef struct { void *access; enumeration_subtype_mirror_pt pt; } enumeration_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; floating_value_mirror *f_left; floating_value_mirror *f_right; floating_value_mirror *f_low; floating_value_mirror *f_high; uint8_t f_ascending; } floating_subtype_mirror_pt; typedef struct { void *access; floating_subtype_mirror_pt pt; } floating_subtype_mirror; typedef struct { ffi_uarray_t *f_name; int64_t f_scale; } unit_rec; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; physical_value_mirror *f_left; physical_value_mirror *f_right; physical_value_mirror *f_low; physical_value_mirror *f_high; uint8_t f_ascending; ffi_uarray_t *f_units; } physical_subtype_mirror_pt; typedef struct { void *access; physical_subtype_mirror_pt pt; } physical_subtype_mirror; typedef struct { subtype_mirror *f_index_subtype; int64_t f_left; int64_t f_right; int64_t f_length; uint8_t f_ascending; } dimension_rec; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; uint64_t f_dimensions; subtype_mirror *f_element_subtype; ffi_uarray_t *f_dimension_data; } array_subtype_mirror_pt; typedef struct { void *access; array_subtype_mirror_pt pt; } array_subtype_mirror; typedef struct { ffi_uarray_t *f_name; subtype_mirror *f_subtype; } field_rec; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; ffi_uarray_t *f_fields; } record_subtype_mirror_pt; typedef struct { void *access; record_subtype_mirror_pt pt; } record_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; subtype_mirror *f_designated; } file_subtype_mirror_pt; typedef struct { void *access; file_subtype_mirror_pt pt; } file_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; subtype_mirror *f_designated; } access_subtype_mirror_pt; typedef struct { void *access; access_subtype_mirror_pt pt; } access_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; subtype_mirror *f_owner; } protected_subtype_mirror_pt; typedef struct { void *access; ffi_uarray_t path_name; ffi_uarray_t inst_name; protected_subtype_mirror_pt pt; } protected_subtype_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; integer_subtype_mirror *f_subtype; int64_t f_value; } integer_value_mirror_pt; typedef struct _integer_value_mirror { void *access; integer_value_mirror_pt pt; } integer_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; enumeration_subtype_mirror *f_subtype; int64_t f_pos; ffi_uarray_t *f_image; } enumeration_value_mirror_pt; typedef struct _enumeration_value_mirror { void *access; enumeration_value_mirror_pt pt; } enumeration_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; floating_subtype_mirror *f_subtype; double f_value; } floating_value_mirror_pt; typedef struct _floating_value_mirror { void *access; floating_value_mirror_pt pt; } floating_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; physical_subtype_mirror *f_subtype; int64_t f_value; } physical_value_mirror_pt; typedef struct _physical_value_mirror { void *access; physical_value_mirror_pt pt; } physical_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; array_subtype_mirror *f_subtype; ffi_uarray_t *f_elements; } array_value_mirror_pt; typedef struct { void *access; array_value_mirror_pt pt; } array_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; record_subtype_mirror *f_subtype; ffi_uarray_t *f_elements; } record_value_mirror_pt; typedef struct { void *access; record_value_mirror_pt pt; } record_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; file_subtype_mirror *f_subtype; ffi_uarray_t *f_logical_name; uint8_t f_open_kind; } file_value_mirror_pt; typedef struct { void *access; file_value_mirror_pt pt; } file_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; access_subtype_mirror *f_subtype; value_mirror *f_value; } access_value_mirror_pt; typedef struct { void *access; access_value_mirror_pt pt; } access_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; value_mirror *f_owner; protected_subtype_mirror *f_subtype; } protected_value_mirror_pt; typedef struct { void *access; protected_value_mirror_pt pt; } protected_value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; uint8_t f_class; subtype_mirror *f_subtype; integer_value_mirror *f_integer; enumeration_value_mirror *f_enumeration; floating_value_mirror *f_floating; array_value_mirror *f_array; record_value_mirror *f_record; file_value_mirror *f_file; access_value_mirror *f_access; physical_value_mirror *f_physical; protected_value_mirror *f_protected; } value_mirror_pt; typedef struct _value_mirror { void *access; value_mirror_pt pt; } value_mirror; typedef struct { void *context; ffi_uarray_t path_name; ffi_uarray_t inst_name; uint8_t f_class; ffi_uarray_t *f_name; integer_subtype_mirror *f_integer; enumeration_subtype_mirror *f_enumeration; floating_subtype_mirror *f_floating; array_subtype_mirror *f_array; record_subtype_mirror *f_record; file_subtype_mirror *f_file; access_subtype_mirror *f_access; physical_subtype_mirror *f_physical; protected_subtype_mirror *f_protected; } subtype_mirror_pt; typedef struct _subtype_mirror { void *access; subtype_mirror_pt pt; } subtype_mirror; static subtype_mirror *get_subtype_mirror(void *context, type_t type, const jit_scalar_t *bounds); static void *zero_alloc(size_t size) { void *ptr = jit_mspace_alloc(size); memset(ptr, '\0', size); return ptr; } static ffi_uarray_t *get_string(const char *str) { const size_t nchars = strlen(str); void *mem = jit_mspace_alloc(sizeof(ffi_uarray_t) + nchars); memcpy(mem + sizeof(ffi_uarray_t), str, nchars); ffi_uarray_t *u = mem; u->ptr = mem + sizeof(ffi_uarray_t); u->dims[0].left = 1; u->dims[0].length = nchars; return u; } static internal_cache_pt *get_cache(void *context) { // This will break if the package layout ever changes internal_cache_pt *pt = *(internal_cache_pt **)(context + 7*sizeof(void *)); assert(pt->f_canary1 == 0xdeadbeef); assert(pt->f_canary2 == 0xcafebabe); assert(pt->context == context); return pt; } static jit_scalar_t load_scalar(const void *base, size_t off, size_t size) { jit_scalar_t elt = { .integer = 0 }; #define UNPACK_ELEMENT(type) do { \ const type *p = base; \ elt.integer = p[off]; \ } while (0); FOR_ALL_SIZES(size, UNPACK_ELEMENT); return elt; } static jit_scalar_t *get_array_bounds(type_t type, void *ptr) { const int ndims = dimension_of(type); jit_scalar_t *fbounds = xmalloc_array(ndims*2 + 1, sizeof(jit_scalar_t)); if (type_is_unconstrained(type)) { ffi_uarray_t *u = ptr; fbounds[0].pointer = u->ptr; for (int i = 0; i < ndims; i++) { fbounds[i*2+1].integer = u->dims[i].left; fbounds[i*2+2].integer = u->dims[i].length; } } else { fbounds[0].pointer = ptr; for (int i = 0; i < ndims; i++) { tree_t r = range_of(type, i); int64_t left, length; if (!folded_int(tree_left(r), &left)) goto not_const; else if (!folded_length(r, &length)) goto not_const; const range_kind_t dir = tree_subkind(r); fbounds[i*2+1].integer = left; fbounds[i*2+2].integer = (dir == RANGE_DOWNTO ? ~length : length); } } return fbounds; not_const: jit_msg(NULL, DIAG_FATAL, "array %s bounds are not constant", type_pp(type)); return NULL; } static jit_scalar_t *get_null_array(type_t type) { const int ndims = dimension_of(type); jit_scalar_t *bounds = xmalloc_array(ndims*2 + 1, sizeof(jit_scalar_t)); bounds[0].pointer = NULL; for (int i = 0; i < ndims; i++) { bounds[i*2+1].integer = 0; bounds[i*2+2].integer = 0; } return bounds; } static value_mirror *get_value_mirror(void *context, jit_scalar_t value, type_t type, const jit_scalar_t *bounds) { value_mirror *vm = zero_alloc(sizeof(value_mirror)); vm->access = &(vm->pt); vm->pt.context = context; vm->pt.f_subtype = get_subtype_mirror(context, type, bounds); if (type_is_integer(type)) { integer_value_mirror *ivm = zero_alloc(sizeof(integer_value_mirror)); ivm->access = &(ivm->pt); ivm->pt.context = context; ivm->pt.f_value = value.integer; ivm->pt.f_owner = vm; ivm->pt.f_subtype = vm->pt.f_subtype->pt.f_integer; vm->pt.f_class = CLASS_INTEGER; vm->pt.f_integer = ivm; } else if (type_is_enum(type)) { enumeration_value_mirror *evm = zero_alloc(sizeof(enumeration_value_mirror)); evm->access = &(evm->pt); evm->pt.context = context; evm->pt.f_pos = value.integer; evm->pt.f_owner = vm; evm->pt.f_subtype = vm->pt.f_subtype->pt.f_enumeration; LOCAL_TEXT_BUF tb = tb_new(); type_t base = type_base_recur(type); tb_istr(tb, tree_ident(type_enum_literal(base, value.integer))); if (tb_get(tb)[0] != '\'') tb_downcase(tb); evm->pt.f_image = get_string(tb_get(tb)); vm->pt.f_class = CLASS_ENUMERATION; vm->pt.f_enumeration = evm; } else if (type_is_real(type)) { floating_value_mirror *fvm = zero_alloc(sizeof(floating_value_mirror)); fvm->access = &(fvm->pt); fvm->pt.context = context; fvm->pt.f_value = value.real; fvm->pt.f_owner = vm; fvm->pt.f_subtype = vm->pt.f_subtype->pt.f_floating; vm->pt.f_class = CLASS_FLOATING; vm->pt.f_floating = fvm; } else if (type_is_array(type)) { array_value_mirror *avm = zero_alloc(sizeof(array_value_mirror)); avm->access = &(avm->pt); avm->pt.context = context; avm->pt.f_owner = vm; avm->pt.f_subtype = vm->pt.f_subtype->pt.f_array; dimension_rec *dims = avm->pt.f_subtype->pt.f_dimension_data->ptr; size_t total = 1; for (int i = 0; i < avm->pt.f_subtype->pt.f_dimensions; i++) total *= dims[i].f_length; avm->pt.f_elements = zero_alloc(sizeof(ffi_uarray_t) + total * sizeof(value_mirror *)); avm->pt.f_elements->dims[0].left = 0; avm->pt.f_elements->dims[0].length = total; avm->pt.f_elements->ptr = avm->pt.f_elements + 1; type_t elem = type_elem(type); const int ebytes = type_byte_width(elem); value_mirror **elems = avm->pt.f_elements->ptr; for (int i = 0; i < total; i++) { jit_scalar_t elt = load_scalar(value.pointer, i, ebytes); elems[i] = get_value_mirror(context, elt, elem, NULL); } vm->pt.f_class = CLASS_ARRAY; vm->pt.f_array = avm; } else if (type_is_record(type)) { record_value_mirror *rvm = zero_alloc(sizeof(record_value_mirror)); rvm->access = &(rvm->pt); rvm->pt.context = context; rvm->pt.f_owner = vm; rvm->pt.f_subtype = vm->pt.f_subtype->pt.f_record; type_t base = type_base_recur(type); const int nfields = type_fields(base); rvm->pt.f_elements = zero_alloc(sizeof(ffi_uarray_t) + nfields * sizeof(value_mirror *)); rvm->pt.f_elements->dims[0].left = 0; rvm->pt.f_elements->dims[0].length = nfields; rvm->pt.f_elements->ptr = rvm->pt.f_elements + 1; const jit_layout_t *l = layout_of(type); assert(l->nparts == nfields); value_mirror **elements = rvm->pt.f_elements->ptr; for (int i = 0; i < l->nparts; i++) { type_t ft = tree_type(type_field(base, i)); void *ptr = value.pointer + l->parts[i].offset; if (type_is_scalar(ft)) { jit_scalar_t elt = load_scalar(ptr, 0, l->parts[i].size); elements[i] = get_value_mirror(context, elt, ft, NULL); } else if (type_is_array(ft)) { jit_scalar_t *fbounds LOCAL = get_array_bounds(ft, ptr); elements[i] = get_value_mirror(context, fbounds[0], ft, fbounds); } else { jit_scalar_t elt = { .pointer = ptr }; elements[i] = get_value_mirror(context, elt, ft, NULL); } } vm->pt.f_class = CLASS_RECORD; vm->pt.f_record = rvm; } else if (type_is_file(type)) { file_value_mirror *fvm = zero_alloc(sizeof(file_value_mirror)); fvm->access = &(fvm->pt); fvm->pt.context = context; fvm->pt.f_owner = vm; fvm->pt.f_subtype = vm->pt.f_subtype->pt.f_file; file_mode_t mode; if (file_mode(value.integer, &mode)) fvm->pt.f_open_kind = mode; else { jit_msg(NULL, DIAG_WARN, "cannot determine file mode"); fvm->pt.f_open_kind = 0; } const char *name; if (file_logical_name(value.integer, &name)) fvm->pt.f_logical_name = get_string(name); else { jit_msg(NULL, DIAG_WARN, "cannot determine file logical name"); fvm->pt.f_logical_name = NULL; } vm->pt.f_class = CLASS_FILE; vm->pt.f_file = fvm; } else if (type_is_access(type)) { access_value_mirror *avm = zero_alloc(sizeof(access_value_mirror)); avm->access = &(avm->pt); avm->pt.context = context; avm->pt.f_owner = vm; avm->pt.f_subtype = vm->pt.f_subtype->pt.f_access; if (value.pointer != NULL) { type_t designated = type_designated(type); if (type_is_array(designated)) { jit_scalar_t *bounds LOCAL = get_array_bounds(designated, value.pointer); avm->pt.f_value = get_value_mirror(context, bounds[0], designated, bounds); } else { jit_scalar_t access = { .pointer = value.pointer }; avm->pt.f_value = get_value_mirror(context, access, designated, NULL); } } vm->pt.f_class = CLASS_ACCESS; vm->pt.f_access = avm; } else if (type_is_physical(type)) { physical_value_mirror *pvm = zero_alloc(sizeof(physical_value_mirror)); pvm->access = &(pvm->pt); pvm->pt.context = context; pvm->pt.f_value = value.integer; pvm->pt.f_owner = vm; pvm->pt.f_subtype = vm->pt.f_subtype->pt.f_physical; vm->pt.f_class = CLASS_PHYSICAL; vm->pt.f_physical = pvm; } else if (type_is_protected(type)) { protected_value_mirror *pvm = zero_alloc(sizeof(protected_value_mirror)); pvm->access = &(pvm->pt); pvm->pt.context = context; pvm->pt.f_owner = vm; pvm->pt.f_subtype = vm->pt.f_subtype->pt.f_protected; vm->pt.f_class = CLASS_PROTECTED; vm->pt.f_protected = pvm; } else jit_msg(NULL, DIAG_FATAL, "unsupported type %s in prefix of REFLECT " "attribute", type_pp(type)); return vm; } static integer_value_mirror *get_integer_mirror(void *context, type_t type, int64_t value) { jit_scalar_t scalar = { .integer = value }; return get_value_mirror(context, scalar, type, NULL)->pt.f_integer; } static enumeration_value_mirror *get_enumeration_mirror(void *context, type_t type, int64_t value) { jit_scalar_t scalar = { .integer = value }; return get_value_mirror(context, scalar, type, NULL)->pt.f_enumeration; } static physical_value_mirror *get_physical_mirror(void *context, type_t type, int64_t value) { jit_scalar_t scalar = { .integer = value }; return get_value_mirror(context, scalar, type, NULL)->pt.f_physical; } static floating_value_mirror *get_floating_mirror(void *context, type_t type, double value) { jit_scalar_t scalar = { .real = value }; return get_value_mirror(context, scalar, type, NULL)->pt.f_floating; } static bool safe_to_cache(type_t type) { if (type_is_unconstrained(type)) return false; else if (type_is_array(type)) { const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { int64_t length; if (!folded_length(range_of(type, i), &length)) return false; } return true; } else if (type_is_record(type)) { const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { if (!safe_to_cache(tree_type(type_field(type, i)))) return false; } return true; } else return true; } static subtype_mirror *get_subtype_mirror(void *context, type_t type, const jit_scalar_t *bounds) { internal_cache_pt *cache = get_cache(context); for (int i = 0; i < cache->f_num_subtypes; i++) { cache_elem_t *e = &(cache->f_subtype_cache[i]); if (e->f_type == type) return e->f_mirror; } subtype_mirror *sm = zero_alloc(sizeof(subtype_mirror)); sm->access = &(sm->pt); sm->pt.context = context; if (safe_to_cache(type)) { if (cache->f_num_subtypes == cache->f_max_subtypes) { const size_t new_max = MAX(cache->f_max_subtypes * 2, 128); cache_elem_t *tmp = zero_alloc(new_max * sizeof(cache_elem_t)); if (cache->f_subtype_cache != NULL) memcpy(tmp, cache->f_subtype_cache, cache->f_max_subtypes * sizeof(cache_elem_t)); cache->f_subtype_cache = tmp; cache->f_max_subtypes = new_max; } cache_elem_t *e = &(cache->f_subtype_cache[cache->f_num_subtypes++]); e->f_type = type; e->f_mirror = sm; } const char *simple = strrchr(istr(type_ident(type)), '.') + 1; sm->pt.f_name = get_string(simple); if (type_is_integer(type)) { integer_subtype_mirror *ism = zero_alloc(sizeof(integer_subtype_mirror)); ism->access = &(ism->pt); range_kind_t rkind; int64_t low = INT64_MIN, high = INT64_MAX; for (;; type = type_base(type)) { tree_t r = range_of(type, 0); rkind = tree_subkind(r); if (rkind != RANGE_EXPR && folded_bounds(r, &low, &high)) break; else if (type_kind(type) != T_SUBTYPE) break; } ism->pt.context = context; ism->pt.f_owner = sm; ism->pt.f_ascending = (rkind == RANGE_TO); type_t index = index_type_of(type, 0); ism->pt.f_low = get_integer_mirror(context, index, low); ism->pt.f_high = get_integer_mirror(context, index, high); ism->pt.f_left = (rkind == RANGE_TO) ? ism->pt.f_low : ism->pt.f_high; ism->pt.f_right = (rkind == RANGE_TO) ? ism->pt.f_high : ism->pt.f_low; sm->pt.f_class = CLASS_INTEGER; sm->pt.f_integer = ism; } else if (type_is_enum(type)) { enumeration_subtype_mirror *esm = zero_alloc(sizeof(enumeration_subtype_mirror)); esm->access = &(esm->pt); range_kind_t rkind; int64_t low = INT64_MIN, high = INT64_MAX; for (;; type = type_base(type)) { tree_t r = range_of(type, 0); rkind = tree_subkind(r); if (rkind != RANGE_EXPR && folded_bounds(r, &low, &high)) break; else if (type_kind(type) != T_SUBTYPE) break; } esm->pt.context = context; esm->pt.f_owner = sm; type_t base = type_base_recur(type); const int nlits = type_enum_literals(base); const size_t size = sizeof(ffi_uarray_t) + nlits * sizeof(enumeration_value_mirror *); esm->pt.f_literals = zero_alloc(size); esm->pt.f_literals->dims[0].left = 0; esm->pt.f_literals->dims[0].length = nlits; esm->pt.f_literals->ptr = esm->pt.f_literals + 1; enumeration_value_mirror **lits = esm->pt.f_literals->ptr; for (int i = 0; i < nlits; i++) lits[i] = get_enumeration_mirror(context, base, i); sm->pt.f_class = CLASS_ENUMERATION; sm->pt.f_enumeration = esm; } else if (type_is_real(type)) { floating_subtype_mirror *fsm = zero_alloc(sizeof(floating_subtype_mirror)); fsm->access = &(fsm->pt); range_kind_t rkind; double low = DBL_MIN, high = DBL_MAX; tree_t r; for (;; type = type_base(type)) { r = range_of(type, 0); rkind = tree_subkind(r); if (rkind != RANGE_EXPR && folded_bounds_real(r, &low, &high)) break; else if (type_kind(type) != T_SUBTYPE) break; } fsm->pt.context = context; fsm->pt.f_owner = sm; fsm->pt.f_ascending = (rkind == RANGE_TO); type_t index = index_type_of(type, 0); fsm->pt.f_low = get_floating_mirror(context, index, low); fsm->pt.f_high = get_floating_mirror(context, index, high); fsm->pt.f_left = (rkind == RANGE_TO) ? fsm->pt.f_low : fsm->pt.f_high; fsm->pt.f_right = (rkind == RANGE_TO) ? fsm->pt.f_high : fsm->pt.f_low; sm->pt.f_class = CLASS_FLOATING; sm->pt.f_floating = fsm; } else if (type_is_array(type)) { array_subtype_mirror *astm = zero_alloc(sizeof(array_subtype_mirror)); astm->access = &(astm->pt); const int ndims = dimension_of(type); type_t elem = type_elem(type); astm->pt.context = context; astm->pt.f_owner = sm; astm->pt.f_dimensions = ndims; astm->pt.f_element_subtype = get_subtype_mirror(context, elem, NULL); astm->pt.f_dimension_data = zero_alloc(sizeof(ffi_uarray_t) + ndims * sizeof(dimension_rec)); astm->pt.f_dimension_data->dims[0].left = 1; astm->pt.f_dimension_data->dims[0].length = ndims; astm->pt.f_dimension_data->ptr = astm->pt.f_dimension_data + 1; dimension_rec *dims = astm->pt.f_dimension_data->ptr; for (int i = 0; i < ndims; i++) { type_t itype = index_type_of(type, i); dims[i].f_index_subtype = get_subtype_mirror(context, itype, NULL); const int64_t left = bounds[i*2 + 1].integer; const int64_t length = bounds[i*2 + 2].integer; dims[i].f_ascending = length >= 0; dims[i].f_left = left; dims[i].f_length = length ^ (length >> 63); if (length < 0) dims[i].f_right = left + length + 2; else dims[i].f_right = left + length - 1; } sm->pt.f_class = CLASS_ARRAY; sm->pt.f_array = astm; } else if (type_is_record(type)) { record_subtype_mirror *rsm = zero_alloc(sizeof(record_subtype_mirror)); rsm->access = &(rsm->pt); rsm->pt.context = context; rsm->pt.f_owner = sm; type_t base = type_base_recur(type); const int nfields = type_fields(base); rsm->pt.f_fields = zero_alloc(sizeof(ffi_uarray_t) + nfields * sizeof(field_rec)); rsm->pt.f_fields->dims[0].left = 0; rsm->pt.f_fields->dims[0].length = nfields; rsm->pt.f_fields->ptr = rsm->pt.f_fields + 1; const jit_layout_t *l = layout_of(type); assert(l->nparts == nfields); field_rec *fields = rsm->pt.f_fields->ptr; for (int i = 0; i < nfields; i++) { tree_t f = type_field(base, i); fields[i].f_name = get_string(istr(tree_ident(f))); type_t ft = tree_type(f); if (type_is_array(ft)) { void *ptr = bounds[0].pointer + l->parts[i].offset; jit_scalar_t *fbounds LOCAL = get_array_bounds(ft, ptr); fields[i].f_subtype = get_subtype_mirror(context, ft, fbounds); } else fields[i].f_subtype = get_subtype_mirror(context, ft, NULL); } sm->pt.f_class = CLASS_RECORD; sm->pt.f_record = rsm; } else if (type_is_file(type)) { file_subtype_mirror *fsm = zero_alloc(sizeof(file_subtype_mirror)); fsm->access = &(fsm->pt); fsm->pt.context = context; fsm->pt.f_owner = sm; type_t designated = type_designated(type); jit_scalar_t *dbounds LOCAL = NULL; if (type_is_array(designated)) dbounds = get_null_array(designated); fsm->pt.f_designated = get_subtype_mirror(context, designated, dbounds); sm->pt.f_class = CLASS_FILE; sm->pt.f_file = fsm; } else if (type_is_access(type)) { access_subtype_mirror *astm = zero_alloc(sizeof(access_subtype_mirror)); astm->access = &(astm->pt); astm->pt.context = context; astm->pt.f_owner = sm; type_t designated = type_designated(type); jit_scalar_t *dbounds LOCAL = NULL; if (type_is_array(designated)) dbounds = get_null_array(designated); astm->pt.f_designated = get_subtype_mirror(context, designated, dbounds); sm->pt.f_class = CLASS_ACCESS; sm->pt.f_access = astm; } else if (type_is_physical(type)) { physical_subtype_mirror *psm = zero_alloc(sizeof(physical_subtype_mirror)); psm->access = &(psm->pt); psm->pt.context = context; psm->pt.f_owner = sm; range_kind_t rkind; int64_t low = INT64_MIN, high = INT64_MAX; for (;; type = type_base(type)) { tree_t r = range_of(type, 0); rkind = tree_subkind(r); if (rkind != RANGE_EXPR && folded_bounds(r, &low, &high)) break; else if (type_kind(type) != T_SUBTYPE) break; } psm->pt.f_ascending = (rkind == RANGE_TO); type_t index = index_type_of(type, 0); psm->pt.f_low = get_physical_mirror(context, index, low); psm->pt.f_high = get_physical_mirror(context, index, high); psm->pt.f_left = (rkind == RANGE_TO) ? psm->pt.f_low : psm->pt.f_high; psm->pt.f_right = (rkind == RANGE_TO) ? psm->pt.f_high : psm->pt.f_low; type_t base = type_base_recur(type); const int nunits = type_units(base); psm->pt.f_units = zero_alloc(sizeof(ffi_uarray_t) + nunits * sizeof(unit_rec)); psm->pt.f_units->dims[0].left = 1; psm->pt.f_units->dims[0].length = nunits; psm->pt.f_units->ptr = psm->pt.f_units + 1; unit_rec *units = psm->pt.f_units->ptr; for (int i = 0; i < nunits; i++) { tree_t u = type_unit(base, i); units[i].f_name = get_string(istr(tree_ident(u))); units[i].f_scale = assume_int(tree_value(u)); } sm->pt.f_class = CLASS_PHYSICAL; sm->pt.f_physical = psm; } else if (type_is_protected(type)) { protected_subtype_mirror *psm = zero_alloc(sizeof(protected_subtype_mirror)); psm->access = &(psm->pt); psm->pt.context = context; psm->pt.f_owner = sm; sm->pt.f_class = CLASS_PROTECTED; sm->pt.f_protected = psm; } else jit_msg(NULL, DIAG_FATAL, "unsupported type %s in prefix of REFLECT " "attribute", type_pp(type)); return sm; } void *x_reflect_value(void *context, jit_scalar_t value, tree_t where, const jit_scalar_t *bounds) { return get_value_mirror(context, value, tree_type(where), bounds); } void *x_reflect_subtype(void *context, tree_t where, const jit_scalar_t *bounds) { type_t type = tree_type(where); assert(!type_is_unconstrained(type)); // Should be caught earlier return get_subtype_mirror(context, type, bounds); } void _std_reflection_init(void) { // Dummy function to force linking } nvc-r1.17.1/src/rt/rt.h000066400000000000000000000050241504111170000145520ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_H #define _RT_H #include "ident.h" #include "prim.h" #include #define RT_ABI_VERSION 31 #define RT_ALIGN_MASK 0x7 #define RT_MULTITHREADED 0 #define TIME_HIGH INT64_MAX // Value of TIME'HIGH #if RT_MULTITHREADED #define RT_LOCK(x) SCOPED_LOCK(x) #define MULTITHREADED_ONLY(x) x #else #define RT_LOCK(x) #define MULTITHREADED_ONLY(x) #endif typedef void (*sig_event_fn_t)(uint64_t now, rt_signal_t *signal, rt_watch_t *watch, void *user); typedef void (*rt_event_fn_t)(rt_model_t *m, void *user); typedef enum { R_MEMO = (1 << 0), R_IDENT = (1 << 1), R_COMPOSITE = (1 << 2), } res_flags_t; #define NET_F_FORCED (1 << 0) #define NET_F_INOUT (1 << 1) #define NET_F_CACHE_EVENT (1 << 2) #define NET_F_R_IDENT (1 << 3) #define NET_F_PENDING (1 << 4) #define NET_F_HAS_INITIAL (1 << 5) #define NET_F_FAST_DRIVER (1 << 6) #define NET_F_EFFECTIVE (1 << 7) typedef uint8_t net_flags_t; #define SIG_F_IMPLICIT (1 << 8) #define SIG_F_STD_LOGIC (1 << 9) #define SIG_F_CACHE_EVENT (1 << 10) #define SIG_F_EVENT_FLAG (1 << 11) #define SIG_F_REGISTER (1 << 12) typedef uint32_t sig_flags_t; typedef enum { SIGNAL_BUS, SIGNAL_REGISTER } rt_signal_kind_t; typedef enum { RT_END_OF_INITIALISATION, RT_START_OF_SIMULATION, RT_END_OF_SIMULATION, RT_END_OF_PROCESSES, RT_LAST_KNOWN_DELTA_CYCLE, RT_NEXT_TIME_STEP, RT_END_TIME_STEP, RT_NEXT_CYCLE, RT_LAST_EVENT } rt_event_t; typedef enum { SCOPE_ROOT, SCOPE_INSTANCE, SCOPE_PACKAGE, SCOPE_ARRAY, SCOPE_RECORD, } rt_scope_kind_t; typedef uint16_t delta_cycle_t; #define DELTA_CYCLE_MAX UINT16_MAX void _std_standard_init(void); void _std_env_init(void); void _std_reflection_init(void); void _file_io_init(void); void _nvc_sim_pkg_init(void); #endif // _RT_H nvc-r1.17.1/src/rt/shell.c000066400000000000000000001133211504111170000152270ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "hash.h" #include "printer.h" #include "rt/assert.h" #include "rt/model.h" #include "rt/structs.h" #include "shell.h" #include "tree.h" #include "type.h" #include #include #include #include #include #include #include #include #include #include #undef DLLEXPORT #include #define TIME_BUFSZ 32 #if TCL_MAJOR_VERSION < 9 typedef int Tcl_Size; #endif typedef struct { const char *name; Tcl_ObjCmdProc *fn; const char *help; } shell_cmd_t; typedef enum { SHELL_SIGNAL, SHELL_REGION, } object_kind_t; typedef struct { object_kind_t kind; ident_t name; ident_t path; } shell_object_t; typedef struct { shell_object_t obj; rt_signal_t *signal; print_func_t *printer; rt_watch_t *watch; tcl_shell_t *owner; } shell_signal_t; typedef struct { shell_object_t obj; rt_scope_t *scope; } shell_region_t; typedef char *(*get_line_fn_t)(tcl_shell_t *); typedef struct _tcl_shell { char *prompt; Tcl_Interp *interp; shell_cmd_t *cmds; size_t ncmds; size_t cmdalloc; rt_model_t *model; tree_t top; rt_scope_t *root; shell_signal_t *signals; unsigned nsignals; shell_region_t *regions; unsigned nregions; hash_t *namemap; jit_t *jit; int64_t now_var; unsigned deltas_var; printer_t *printer; get_line_fn_t getline; shell_handler_t handler; bool quit; char *datadir; } tcl_shell_t; static __thread tcl_shell_t *rl_shell = NULL; __attribute__((format(printf, 2, 3))) static int tcl_error(tcl_shell_t *sh, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *buf LOCAL = color_vasprintf(fmt, ap); va_end(ap); Tcl_SetObjResult(sh->interp, Tcl_NewStringObj(buf, -1)); return TCL_ERROR; } static void tcl_dict_put(tcl_shell_t *sh, Tcl_Obj *dict, const char *key, Tcl_Obj *value) { Tcl_DictObjPut(sh->interp, dict, Tcl_NewStringObj(key, -1), value); } static Tcl_Obj *tcl_ident_string(ident_t ident) { return Tcl_NewStringObj(istr(ident), ident_len(ident)); } static int syntax_error(tcl_shell_t *sh, Tcl_Obj *const objv[]) { return tcl_error(sh, "syntax error, enter $bold$help %s$$ for usage", Tcl_GetString(objv[0])); } __attribute__((format(printf, 2, 3))) static void shell_printf(tcl_shell_t *sh, const char *fmt, ...) { va_list ap; va_start(ap, fmt); if (sh->handler.stdout_write != NULL) { char *buf LOCAL = color_vasprintf(fmt, ap); (*sh->handler.stdout_write)(buf, strlen(buf), sh->handler.context); } else wrapped_vprintf(fmt, ap); va_end(ap); } static bool shell_has_model(tcl_shell_t *sh) { if (sh->model == NULL) { tcl_error(sh, "no simulation loaded, elaborate first with the " "$bold$-e$$ command or pass the top-level design unit " "as a command line argument"); return false; } return true; } static void shell_next_time_step(rt_model_t *m, void *user) { tcl_shell_t *sh = user; assert(sh->handler.next_time_step != NULL); uint64_t now = model_now(m, NULL); (*sh->handler.next_time_step)(now, sh->handler.context); model_set_global_cb(sh->model, RT_NEXT_TIME_STEP, shell_next_time_step, sh); } static void shell_create_model(tcl_shell_t *sh) { assert(sh->model == NULL); sh->model = model_new(sh->jit, NULL); create_scope(sh->model, sh->top, NULL); if (sh->handler.next_time_step != NULL) model_set_global_cb(sh->model, RT_NEXT_TIME_STEP, shell_next_time_step, sh); model_reset(sh->model); if ((sh->root = find_scope(sh->model, tree_stmt(sh->top, 0))) == NULL) fatal_trace("cannot find root scope"); } static void shell_update_now(tcl_shell_t *sh) { sh->now_var = model_now(sh->model, &sh->deltas_var); Tcl_UpdateLinkedVar(sh->interp, "now"); Tcl_UpdateLinkedVar(sh->interp, "deltas"); } static bool shell_get_printer(tcl_shell_t *sh, shell_signal_t *ss) { if (ss->printer == NULL) ss->printer = printer_for(sh->printer, tree_type(ss->signal->where)); if (ss->printer == NULL) { tcl_error(sh, "cannot display type %s", type_pp(tree_type(ss->signal->where))); return false; } return true; } static void shell_add_cmd(tcl_shell_t *sh, const char *name, Tcl_ObjCmdProc fn, const char *help) { shell_cmd_t cmd = { name, fn, help }; if (sh->cmdalloc == sh->ncmds) { sh->cmdalloc = MAX(sh->cmdalloc * 2, 16); sh->cmds = xrealloc_array(sh->cmds, sh->cmdalloc, sizeof(shell_cmd_t)); } sh->cmds[sh->ncmds++] = cmd; Tcl_CreateObjCommand(sh->interp, name, fn, sh, NULL); } static void shell_event_cb(uint64_t now, rt_signal_t *s, rt_watch_t *w, void *user) { shell_signal_t *ss = user; shell_handler_t *h = &(ss->owner->handler); if (h->signal_update != NULL) { const char *enc = print_signal(ss->printer, ss->signal, PRINT_F_ENCODE); (*h->signal_update)(ss->obj.path, now, s, enc, h->context); } } static void watch_signal(shell_signal_t *ss) { ss->watch = watch_new(ss->owner->model, shell_event_cb, ss, WATCH_POSTPONED, 1); model_set_event_cb(ss->owner->model, ss->signal, ss->watch); } static void recreate_objects(tcl_shell_t *sh, rt_scope_t *scope, shell_signal_t **sptr, shell_region_t **rptr) { shell_region_t *r = (*rptr)++; assert(r->obj.name == ident_downcase(tree_ident(scope->where))); r->scope = scope; for (int i = 0; i < scope->signals.count; i++) { shell_signal_t *ss = (*sptr)++; ss->signal = scope->signals.items[i]; assert(ss->obj.name == ident_downcase(tree_ident(ss->signal->where))); if (ss->watch != NULL) watch_signal(ss); } for (int i = 0; i < scope->aliases.count; i++) { rt_alias_t *a = scope->aliases.items[i]; shell_signal_t *ss = (*sptr)++; assert(ss->obj.name == ident_downcase(tree_ident(a->where))); ss->signal = a->signal; if (ss->watch != NULL) watch_signal(ss); } for (int i = 0; i < scope->children.count; i++) recreate_objects(sh, scope->children.items[i], sptr, rptr); } const char *next_option(int *pos, int objc, Tcl_Obj *const objv[]) { if (*pos >= objc) return NULL; const char *opt = Tcl_GetString(objv[*pos]); if (opt[0] != '-') return NULL; (*pos)++; return opt; } static shell_object_t *get_object(tcl_shell_t *sh, const char *name) { shell_object_t *obj = hash_get(sh->namemap, ident_new(name)); if (obj == NULL) tcl_error(sh, "cannot find name '%s'", name); return obj; } static shell_signal_t *get_signal(tcl_shell_t *sh, const char *name) { shell_object_t *obj = get_object(sh, name); if (obj == NULL) return NULL; else if (obj->kind != SHELL_SIGNAL) { tcl_error(sh, "'%s' is not a signal", name); return NULL; } return container_of(obj, shell_signal_t, obj); } static const char restart_help[] = "Restart the simulation"; static int shell_cmd_restart(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (!shell_has_model(sh)) return TCL_ERROR; model_free(sh->model); sh->model = NULL; jit_reset(sh->jit); clear_vhdl_assert(); for (vhdl_severity_t s = SEVERITY_NOTE; s <= SEVERITY_FAILURE; s++) set_vhdl_assert_enable(s, true); shell_create_model(sh); shell_signal_t *wptr = sh->signals; shell_region_t *rptr = sh->regions; recreate_objects(sh, sh->root, &wptr, &rptr); assert(wptr == sh->signals + sh->nsignals); assert(rptr == sh->regions + sh->nregions); shell_update_now(sh); if (sh->handler.restart_sim != NULL) (*sh->handler.restart_sim)(sh->handler.context); return TCL_OK; } static const char run_help[] = "Start or resume the simulation"; static int shell_cmd_run(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; static bool sim_running = false; if (!shell_has_model(sh)) return TCL_ERROR; else if (sim_running) return tcl_error(sh, "simulation already running"); uint64_t stop_time = UINT64_MAX; if (objc == 3) { Tcl_WideInt base; int error = Tcl_GetWideIntFromObj(interp, objv[1], &base); if (error != TCL_OK || base <= 0) return tcl_error(sh, "invalid time"); const char *unit = Tcl_GetString(objv[2]); uint64_t mult; if (strcmp(unit, "fs") == 0) mult = 1; else if (strcmp(unit, "ps") == 0) mult = 1000; else if (strcmp(unit, "ns") == 0) mult = 1000000; else if (strcmp(unit, "us") == 0) mult = 1000000000; else if (strcmp(unit, "ms") == 0) mult = 1000000000000; else return tcl_error(sh, "invalid time unit %s", unit); stop_time = model_now(sh->model, NULL) + (base * mult); } else if (objc != 1) return tcl_error(sh, "usage: $bold$run [time units]$$"); sim_running = true; model_run(sh->model, stop_time); sim_running = false; shell_update_now(sh); return TCL_OK; } static const char find_help[] = "Find signals and other objects in the design\n" "\n" "Syntax:\n" " find signals [options] \n" " find regions [options] \n" "\n" "Options:\n" " -r, -recursive\tInclude subregions in wildcard search.\n" "\n" "Examples:\n" " find signals -r /*\tList all signals in the design\n" " find signals /uut/x*\tAll signals in instance UUT that start with X\n" " find regions -r *\tList all regions in the design\n"; static int shell_cmd_find(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; enum { SIGNALS, REGIONS } what; if (!shell_has_model(sh)) return TCL_ERROR; else if (objc < 3) goto usage; else if (strcmp(Tcl_GetString(objv[1]), "signals") == 0) what = SIGNALS; else if (strcmp(Tcl_GetString(objv[1]), "regions") == 0) what = REGIONS; else goto usage; int pos = 2; for (const char *opt; (opt = next_option(&pos, objc, objv)); ) { if (strcmp(opt, "-recursive") == 0 || strcmp(opt, "-r") == 0) { // Always recursive for now... } else goto usage; } const char *glob = Tcl_GetString(objv[pos]); Tcl_Obj *result = Tcl_NewListObj(0, NULL); switch (what) { case SIGNALS: { for (int i = 0; i < sh->nsignals; i++) { if (!ident_glob(sh->signals[i].obj.path, glob, -1)) continue; Tcl_Obj *obj = tcl_ident_string(sh->signals[i].obj.path); Tcl_ListObjAppendElement(interp, result, obj); } } break; case REGIONS: { for (int i = 0; i < sh->nregions; i++) { if (!ident_glob(sh->regions[i].obj.path, glob, -1)) continue; Tcl_Obj *obj = tcl_ident_string(sh->regions[i].obj.path); Tcl_ListObjAppendElement(interp, result, obj); } break; } break; } Tcl_SetObjResult(interp, result); return TCL_OK; usage: return syntax_error(sh, objv); } static const char elaborate_help[] = "Obsolete command which does nothing.\n"; static int shell_cmd_elaborate(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; return tcl_error(sh, "the elaborate/vsim command has been removed, " "elaborate the design first with \"nvc -e top --do ...\" " "or \"nvc -e top -i\""); } static const char examine_help[] = "Display current value of one of more signals\n" "\n" "Syntax:\n" " examine [options] ...\n" "\n" "Note \"exa\" is an alias of this command.\n" "\n" "Options:\n" " -radix \tFormat as hexadecimal, decimal, or binary.\n" " -\tAlias of \"-radix \".\n" "\n" "Examples:\n" " examine /uut/foo\n" " exa -hex sig\n"; static bool parse_radix(const char *str, print_flags_t *flags) { if (strcmp(str, "binary") == 0 || strcmp(str, "bin") == 0 || strcmp(str, "b") == 0) { *flags &= ~PRINT_F_RADIX; *flags |= PRINT_F_BIN; return true; } else if (strcmp(str, "-hexadecimal") == 0 || strcmp(str, "hex") == 0 || strcmp(str, "h") == 0) { *flags &= ~PRINT_F_RADIX; *flags |= PRINT_F_HEX; return true; } else return false; } static int shell_cmd_examine(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (!shell_has_model(sh)) return TCL_ERROR; print_flags_t flags = 0; int pos = 1; for (const char *opt; (opt = next_option(&pos, objc, objv)); ) { if (parse_radix(opt + 1, &flags)) continue; else if (strcmp(opt, "-radix") == 0 && pos + 1 < objc) { const char *arg = Tcl_GetString(objv[pos++]); if (!parse_radix(arg, &flags)) goto usage; } else goto usage; } if (pos == objc) goto usage; const int count = objc - pos; Tcl_Obj *single[1], **result = single; if (count > 1) result = xmalloc_array(count, sizeof(Tcl_Obj *)); for (int i = 0; pos < objc; pos++, i++) { const char *name = Tcl_GetString(objv[pos]); shell_signal_t *ss = get_signal(sh, name); if (ss == NULL) return TCL_ERROR; if (!shell_get_printer(sh, ss)) return TCL_ERROR; const char *str = print_signal(ss->printer, ss->signal, flags); result[i] = Tcl_NewStringObj(str, -1); } if (count > 1) { Tcl_Obj *list = Tcl_NewListObj(count, result); Tcl_SetObjResult(interp, list); free(result); } else Tcl_SetObjResult(interp, result[0]); return TCL_OK; usage: return syntax_error(sh, objv); } static const char describe_help[] = "Return information about an object or region\n" "\n" "Syntax:\n" " describe ...\n" "\n" "Examples:\n" " describe /uut/foo\n" " describe /uut\n"; static int shell_cmd_describe(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (!shell_has_model(sh)) return TCL_ERROR; int pos = 1; for (const char *opt; (opt = next_option(&pos, objc, objv)); ) { goto usage; } if (pos == objc) goto usage; const int count = objc - pos; Tcl_Obj *single[1], **result = single; if (count > 1) result = xmalloc_array(count, sizeof(Tcl_Obj *)); for (int i = 0; pos < objc; pos++, i++) { const char *name = Tcl_GetString(objv[pos]); shell_object_t *obj = get_object(sh, name); if (obj == NULL) return TCL_ERROR; Tcl_Obj *d = result[i] = Tcl_NewDictObj(); tcl_dict_put(sh, d, "name", tcl_ident_string(obj->name)); tcl_dict_put(sh, d, "path", tcl_ident_string(obj->path)); switch (obj->kind) { case SHELL_SIGNAL: { tcl_dict_put(sh, d, "kind", Tcl_NewStringObj("signal", -1)); shell_signal_t *ss = container_of(obj, shell_signal_t, obj); type_t type = tree_type(ss->signal->where); tcl_dict_put(sh, d, "type", Tcl_NewStringObj(type_pp(type), -1)); } break; case SHELL_REGION: tcl_dict_put(sh, d, "kind", Tcl_NewStringObj("region", -1)); break; } } if (count > 1) { Tcl_Obj *list = Tcl_NewListObj(count, result); Tcl_SetObjResult(interp, list); free(result); } else Tcl_SetObjResult(interp, result[0]); return TCL_OK; usage: return syntax_error(sh, objv); } static const char force_help[] = "Force the value of a signal\n" "\n" "Syntax:\n" " force [ ]\n" "\n" "Value can be either an enumeration literal ('1', true), an integer " "(42, 0), or a bit string literal (\"10111\") and must be appropriate " "for the signal type. Without arguments lists all currently forced " "signals.\n" "\n" "Examples:\n" " force /uut/foo '1'\n" " force /bitvec \"10011\"\n"; static int shell_cmd_force(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (!shell_has_model(sh)) return TCL_ERROR; else if (objc != 3 && objc != 1) return syntax_error(sh, objv); if (objc == 1) { for (int i = 0; i < sh->nsignals; i++) { shell_signal_t *ss = &(sh->signals[i]); if (!(ss->signal->nexus.flags & NET_F_FORCED)) continue; if (!shell_get_printer(sh, ss)) return TCL_ERROR; const size_t nbytes = ss->signal->shared.size; uint8_t *value LOCAL = xmalloc(nbytes); get_forcing_value(ss->signal, value); shell_printf(sh, "force %s %s\n", istr(ss->obj.path), print_raw(ss->printer, value, nbytes, 0)); } return TCL_OK; } const char *signame = Tcl_GetString(objv[1]); const char *valstr = Tcl_GetString(objv[2]); shell_signal_t *ss = get_signal(sh, signame); if (ss == NULL) return TCL_ERROR; type_t type = tree_type(ss->signal->where); parsed_value_t value; if (!parse_value(type, valstr, &value)) return tcl_error(sh, "value '%s' is not valid for type %s", valstr, type_pp(type)); if (type_is_scalar(type)) force_signal(sh->model, ss->signal, &value.integer, 0, 1); else if (type_is_character_array(type)) { const int width = signal_width(ss->signal); if (value.enums->count != width) { tcl_error(sh, "expected %d elements for signal %s but have %d", width, signame, value.enums->count); free(value.enums); return TCL_ERROR; } force_signal(sh->model, ss->signal, value.enums->values, 0, width); free(value.enums); } else return tcl_error(sh, "cannot force signals of type %s", type_pp(type)); return TCL_OK; } static const char noforce_help[] = "Stop forcing the value of signals\n" "\n" "Syntax:\n" " noforce ...\n" " noforce *\n" "\n" "The second form stops forcing all currently forced signals.\n" "\n" "Examples:\n" " noforce /uut/foo /baz\n"; static int shell_cmd_noforce(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (!shell_has_model(sh)) return TCL_ERROR; else if (objc == 1) return syntax_error(sh, objv); for (int i = 1; i < objc; i++) { const char *signame = Tcl_GetString(objv[i]); if (strcmp(signame, "*") == 0) { for (int i = 0; i < sh->nsignals; i++) { shell_signal_t *ss = &(sh->signals[i]); if (ss->signal->nexus.flags & NET_F_FORCED) release_signal(sh->model, ss->signal, 0, signal_width(ss->signal)); } } else { shell_signal_t *ss = get_signal(sh, signame); if (ss == NULL) return TCL_ERROR; if (!(ss->signal->nexus.flags & NET_F_FORCED)) return tcl_error(sh, "signal %s is not forced", signame); release_signal(sh->model, ss->signal, 0, signal_width(ss->signal)); } } return TCL_OK; } static const char add_help[] = "Add signals and other objects to the display\n" "\n" "Syntax:\n" " add wave [options] ...\n" "\n" "Options:\n" " -r, -recursive\tInclude subregions in wildcard search.\n" "\n" "Examples:\n" " add wave /*\tAdd all signals to waveform\n"; static int shell_cmd_add(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; char **globs LOCAL = NULL; if (objc < 3 || strcmp(Tcl_GetString(objv[1]), "wave") != 0) goto usage; else if (!shell_has_model(sh)) return TCL_ERROR; int pos = 2; for (const char *opt; (opt = next_option(&pos, objc, objv)); ) { if (strcmp(opt, "-recursive") == 0 || strcmp(opt, "-r") == 0) { // Always recursive for now... } else goto usage; } const int nglobs = objc - pos; globs = xmalloc_array(nglobs, sizeof(char *)); for (int i = 0; i < nglobs; i++) globs[i] = Tcl_GetString(objv[pos++]); for (int i = 0; i < sh->nsignals; i++) { shell_signal_t *ss = &(sh->signals[i]); bool match = false; for (int j = 0; j < nglobs; j++) match |= ident_glob(ss->obj.path, globs[j], -1); if (!match || !shell_get_printer(sh, ss)) continue; if (sh->handler.add_wave != NULL) { const char *enc = print_signal(ss->printer, ss->signal, PRINT_F_ENCODE); (*sh->handler.add_wave)(ss->obj.path, enc, sh->handler.context); } if (ss->watch == NULL) watch_signal(ss); } return TCL_OK; usage: return syntax_error(sh, objv); } static const char quit_help[] = "Obsolete command which does nothing.\n"; static int shell_cmd_quit(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; return tcl_error(sh, "the quit command has been removed"); } static const char exit_help[] = "Exit the simulator and return a status code\n" "\n" "Syntax:\n" " exit [-code ]\n" "\n" "Options:\n" " -code \tStatus code to return to shell.\n"; static int shell_cmd_exit(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; int pos = 1, status = EXIT_SUCCESS; for (const char *opt; (opt = next_option(&pos, objc, objv)); ) { if (strcmp(opt, "-code") == 0 && pos < objc) status = atoi(Tcl_GetString(objv[pos++])); else goto usage; } if (pos != objc) goto usage; if (sh->handler.exit != NULL) (*sh->handler.exit)(status, sh->handler.context); Tcl_Exit(status); usage: return syntax_error(sh, objv); } static const char help_help[] = "Display list of commands or detailed help\n" "\n" "Use $bold$help $$ to display detailed usage of a particular\n" "command.\n"; static int shell_cmd_help(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { tcl_shell_t *sh = cd; if (objc == 2) { const char *which = Tcl_GetString(objv[1]); for (int i = 0; i < sh->ncmds; i++) { if (strcmp(sh->cmds[i].name, which) == 0) { shell_printf(sh, "%s", sh->cmds[i].help); return TCL_OK; } } return tcl_error(sh, "invalid command '%s'", which); } else if (objc != 1) return tcl_error(sh, "syntax error, try $bold$help$$"); shell_printf(sh, "List of supported commands:\n"); for (shell_cmd_t *c = sh->cmds; c < sh->cmds + sh->ncmds; c++) { const int linelen = strchrnul(c->help, '\n') - c->help; shell_printf(sh, " $bold$%-16s$$%.*s\n", c->name, linelen, c->help); } shell_printf(sh, "\n"); shell_printf(sh, "Use $bold$help $$ for detailed usage " "of a particular command. Standard TCL commands are " "also accepted.\n"); return TCL_OK; } static const char copyright_help[] = "Display copyright information"; static int shell_cmd_copyright(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { Tcl_Channel channel = Tcl_GetStdChannel(TCL_STDOUT); extern char copy_string[]; Tcl_WriteChars(channel, copy_string, -1); Tcl_WriteChars(channel, "\n", 1); Tcl_Flush(channel); return TCL_OK; } static const char echo_help[] = "Display value of arguments"; static int shell_cmd_echo(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { Tcl_Channel channel = Tcl_GetStdChannel(TCL_STDOUT); for (int i = 1; i < objc; i++) { if (i > 1) Tcl_WriteChars(channel, " ", 1); Tcl_WriteObj(channel, objv[i]); } Tcl_WriteChars(channel, "\n", 1); Tcl_Flush(channel); return TCL_OK; } static char *shell_list_generator(const char *script, const char *text, int state, int prefix) { static Tcl_Obj *list = NULL; static int index, len; static Tcl_Size max; if (!state) { if (Tcl_Eval(rl_shell->interp, script) != TCL_OK) return NULL; list = Tcl_GetObjResult(rl_shell->interp); if (Tcl_ListObjLength(rl_shell->interp, list, &max) != TCL_OK) return NULL; index = 0; len = strlen(text); } while (index < max) { Tcl_Obj *obj; if (Tcl_ListObjIndex(rl_shell->interp, list, index++, &obj) != TCL_OK) return NULL; const char *str = Tcl_GetString(obj); if (strncmp(str, text + prefix, len - prefix) == 0) { if (prefix == 0) return xstrdup(str); else { assert(len >= prefix); const size_t complen = strlen(str); char *buf = xmalloc(prefix + complen + 1); memcpy(buf, text, prefix); memcpy(buf + prefix, str, complen + 1); return buf; } } } return NULL; } static char *shell_command_generator(const char *text, int state) { return shell_list_generator("info commands", text, state, 0); } static char *shell_variable_generator(const char *text, int state) { return shell_list_generator("info vars", text, state, 1); } static char **shell_tab_completion(const char *text, int start, int end) { rl_attempted_completion_over = 0; if (text[0] == '$') return rl_completion_matches(text, shell_variable_generator); // Determine if we are completing a TCL command or not int pos = start - 1; for (; pos >= 0 && isspace_iso88591(rl_line_buffer[pos]); pos--); if (pos == -1 || rl_line_buffer[pos] == '[') return rl_completion_matches(text, shell_command_generator); return NULL; } static char *shell_completing_get_line(tcl_shell_t *sh) { rl_attempted_completion_function = shell_tab_completion; rl_completer_quote_characters = "\"'"; rl_completer_word_break_characters = " \t\r\n[]{}"; rl_special_prefixes = "$"; rl_shell = sh; char *buf = readline(sh->prompt); if ((buf != NULL) && (*buf != '\0')) add_history(buf); rl_shell = NULL; return buf; } static char *shell_raw_get_line(tcl_shell_t *sh) { fputs(sh->prompt, stdout); fflush(stdout); LOCAL_TEXT_BUF tb = tb_new(); size_t off = 0; for (;;) { int ch = fgetc(stdin); fputc(ch, stdout); switch (ch) { case EOF: return (off > 0) ? tb_claim(tb) : NULL; case '\n': return tb_claim(tb); default: tb_append(tb, ch); } } } void shell_print_banner(tcl_shell_t *sh) { extern const char version_string[]; shell_printf(sh, "\n"); if (sh->handler.stdout_write == NULL) print_centred(version_string); else shell_printf(sh, "\t%s", version_string); static const char blurb[] = "\n\nThis program comes with ABSOLUTELY NO WARRANTY. This is free " "software, and you are welcome to redistribute it under certain " "conditions; type $bold$copyright$$ for details.\n\n" "Type $bold$help$$ for a list of supported commands.\n\n"; shell_printf(sh, blurb); } static int compare_shell_cmd(const void *a, const void *b) { return strcmp(((shell_cmd_t *)a)->name, ((shell_cmd_t *)b)->name); } tcl_shell_t *shell_new(jit_t *jit) { tcl_shell_t *sh = xcalloc(sizeof(tcl_shell_t)); #ifdef RL_VERSION_MAJOR sh->prompt = color_asprintf("\001$+cyan$\002%%\001$$\002 "); #else sh->prompt = color_asprintf("$+cyan$%%$$ "); #endif sh->interp = Tcl_CreateInterp(); sh->jit = jit; sh->printer = printer_new(); if (isatty(fileno(stdin))) sh->getline = shell_completing_get_line; else sh->getline = shell_raw_get_line; if (Tcl_Init(sh->interp) != 0) fatal("%s", Tcl_GetStringResult(sh->interp)); Tcl_LinkVar(sh->interp, "now", (char *)&sh->now_var, TCL_LINK_WIDE_INT | TCL_LINK_READ_ONLY); Tcl_LinkVar(sh->interp, "deltas", (char *)&sh->deltas_var, TCL_LINK_UINT | TCL_LINK_READ_ONLY); { LOCAL_TEXT_BUF tb = tb_new(); get_data_dir(tb); sh->datadir = tb_claim(tb); } Tcl_LinkVar(sh->interp, "nvc_dataDir", (char *)&sh->datadir, TCL_LINK_READ_ONLY | TCL_LINK_STRING); atexit(Tcl_Finalize); Tcl_DeleteCommand(sh->interp, "exit"); shell_add_cmd(sh, "help", shell_cmd_help, help_help); shell_add_cmd(sh, "exit", shell_cmd_exit, exit_help); shell_add_cmd(sh, "copyright", shell_cmd_copyright, copyright_help); shell_add_cmd(sh, "find", shell_cmd_find, find_help); shell_add_cmd(sh, "run", shell_cmd_run, run_help); shell_add_cmd(sh, "restart", shell_cmd_restart, restart_help); shell_add_cmd(sh, "elaborate", shell_cmd_elaborate, elaborate_help); shell_add_cmd(sh, "vsim", shell_cmd_elaborate, elaborate_help); shell_add_cmd(sh, "examine", shell_cmd_examine, examine_help); shell_add_cmd(sh, "exa", shell_cmd_examine, examine_help); shell_add_cmd(sh, "add", shell_cmd_add, add_help); shell_add_cmd(sh, "quit", shell_cmd_quit, quit_help); shell_add_cmd(sh, "force", shell_cmd_force, force_help); shell_add_cmd(sh, "noforce", shell_cmd_noforce, noforce_help); shell_add_cmd(sh, "echo", shell_cmd_echo, echo_help); shell_add_cmd(sh, "describe", shell_cmd_describe, describe_help); qsort(sh->cmds, sh->ncmds, sizeof(shell_cmd_t), compare_shell_cmd); return sh; } void shell_free(tcl_shell_t *sh) { if (sh->model != NULL) { model_free(sh->model); hash_free(sh->namemap); free(sh->signals); free(sh->regions); } printer_free(sh->printer); Tcl_DeleteInterp(sh->interp); free(sh->datadir); free(sh->prompt); free(sh->cmds); free(sh); } bool shell_eval(tcl_shell_t *sh, const char *script, const char **result) { const int code = Tcl_Eval(sh->interp, script); switch (code) { case TCL_OK: if (result != NULL) *result = Tcl_GetStringResult(sh->interp); return true; case TCL_ERROR: { const char *info = Tcl_GetVar(sh->interp, "::errorInfo", 0); if (info != NULL && *info != '\n') errorf("%s", info); *result = Tcl_GetStringResult(sh->interp); if (info == NULL && *result != NULL && **result != '\0') errorf("%s", *result); } return false; default: warnf("Tcl_Eval returned unknown code %d", code); return false; } } static void count_objects(rt_scope_t *scope, unsigned *nsignals, unsigned *nregions) { *nsignals += scope->signals.count + scope->aliases.count; *nregions += 1; for (int i = 0; i < scope->children.count;i ++) count_objects(scope->children.items[i], nsignals, nregions); } static void recurse_objects(tcl_shell_t *sh, rt_scope_t *scope, text_buf_t *path, shell_signal_t **sptr, shell_region_t **rptr) { const int base = tb_len(path); shell_region_t *r = (*rptr)++; r->scope = scope; r->obj.kind = SHELL_REGION; r->obj.name = ident_downcase(tree_ident(scope->where)); r->obj.path = ident_new(tb_get(path)); hash_put(sh->namemap, r->obj.path, &(r->obj)); for (int i = 0; i < scope->signals.count; i++) { shell_signal_t *ss = (*sptr)++; ss->signal = scope->signals.items[i]; ss->obj.kind = SHELL_SIGNAL; ss->obj.name = ident_downcase(tree_ident(ss->signal->where)); ss->owner = sh; tb_istr(path, ss->obj.name); ss->obj.path = ident_new(tb_get(path)); tb_trim(path, base); hash_put(sh->namemap, ss->obj.path, &(ss->obj)); } for (int i = 0; i < scope->aliases.count; i++) { rt_alias_t *a = scope->aliases.items[i]; shell_signal_t *ss = (*sptr)++; ss->signal = a->signal; ss->obj.kind = SHELL_SIGNAL; ss->obj.name = ident_downcase(tree_ident(a->where)); ss->owner = sh; tb_istr(path, ss->obj.name); ss->obj.path = ident_new(tb_get(path)); tb_trim(path, base); hash_put(sh->namemap, ss->obj.path, &(ss->obj)); } for (int i = 0; i < scope->children.count; i++) { rt_scope_t *child = scope->children.items[i]; ident_t name = ident_downcase(tree_ident(child->where)); tb_istr(path, name); tb_append(path, '/'); recurse_objects(sh, child, path, sptr, rptr); tb_trim(path, base); } } void shell_reset(tcl_shell_t *sh, tree_t top) { jit_reset(sh->jit); sh->top = top; shell_create_model(sh); sh->nsignals = sh->nregions = 0; count_objects(sh->root, &sh->nsignals, &sh->nregions); sh->signals = xcalloc_array(sh->nsignals, sizeof(shell_signal_t)); sh->regions = xcalloc_array(sh->nregions, sizeof(shell_region_t)); sh->namemap = hash_new(1 + sh->nsignals * 2); text_buf_t *path = tb_new(); shell_signal_t *sptr = sh->signals; shell_region_t *rptr = sh->regions; tb_cat(path, "/"); recurse_objects(sh, sh->root, path, &sptr, &rptr); assert(sptr == sh->signals + sh->nsignals); assert(rptr == sh->regions + sh->nregions); tb_free(path); shell_update_now(sh); if (sh->handler.start_sim != NULL) (*sh->handler.start_sim)(tree_ident(top), sh->handler.context); } void shell_interact(tcl_shell_t *sh) { shell_print_banner(sh); char *line; while (!sh->quit && (line = (*sh->getline)(sh))) { const char *result = NULL; if (shell_eval(sh, line, &result) && *result != '\0') color_printf("$+black$%s$$\n", result); free(line); } } bool shell_do(tcl_shell_t *sh, const char *file) { const int code = Tcl_EvalFile(sh->interp, file); switch (code) { case TCL_OK: return true; case TCL_ERROR: { const char *info = Tcl_GetVar(sh->interp, "::errorInfo", 0); if (info != NULL && *info != '\n') errorf("%s", info); else { const char *str = Tcl_GetStringResult(sh->interp); if (str != NULL && *str != '\0') errorf("%s", str); } return false; } default: warnf("Tcl_Eval returned unknown code %d", code); return false; } } static int shell_redirect_close(ClientData cd, Tcl_Interp *interp) { return EINVAL; } #if TCL_MAJOR_VERSION >= 9 static int shell_redirect_close2(void *instanceData, Tcl_Interp *interp, int flags) { return EINVAL; } #endif static void shell_redirect_watch(ClientData cd, int mask) { } static int shell_redirect_output(ClientData cd, const char *buf, int nchars, int *error) { tcl_shell_t *sh = untag_pointer(cd, tcl_shell_t); switch (pointer_tag(cd)) { case 0: (*sh->handler.stdout_write)(buf, nchars, sh->handler.context); break; case 1: (*sh->handler.stderr_write)(buf, nchars, sh->handler.context); break; case 2: (*sh->handler.backchannel_write)(buf, nchars, sh->handler.context); break; default: fatal_trace("invalid channel number %"PRIiPTR, pointer_tag(cd)); } return nchars; } static const Tcl_ChannelType redirect_funcs = { .typeName = "redirect", .version = TCL_CHANNEL_VERSION_5, .closeProc = shell_redirect_close, #if TCL_MAJOR_VERSION >= 9 .close2Proc = shell_redirect_close2, #endif .watchProc = shell_redirect_watch, .outputProc = shell_redirect_output, }; void shell_set_handler(tcl_shell_t *sh, const shell_handler_t *h) { sh->handler = *h; if (h->stdout_write != NULL) { Tcl_Channel chan = Tcl_CreateChannel(&redirect_funcs, "redirect0", tag_pointer(sh, 0), TCL_WRITABLE); Tcl_SetChannelOption(NULL, chan, "-translation", "lf"); Tcl_SetChannelOption(NULL, chan, "-buffering", "line"); Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8"); Tcl_RegisterChannel(sh->interp, chan); Tcl_SetStdChannel(chan, TCL_STDOUT); } if (h->stderr_write != NULL) { Tcl_Channel chan = Tcl_CreateChannel(&redirect_funcs, "redirect1", tag_pointer(sh, 1), TCL_WRITABLE); Tcl_SetChannelOption(NULL, chan, "-translation", "lf"); Tcl_SetChannelOption(NULL, chan, "-buffering", "none"); Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8"); Tcl_RegisterChannel(sh->interp, chan); Tcl_SetStdChannel(chan, TCL_STDERR); } if (h->backchannel_write != NULL) { Tcl_Channel chan = Tcl_CreateChannel(&redirect_funcs, "backchannel", tag_pointer(sh, 2), TCL_WRITABLE); Tcl_SetChannelOption(NULL, chan, "-translation", "lf"); Tcl_SetChannelOption(NULL, chan, "-buffering", "full"); Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8"); Tcl_RegisterChannel(sh->interp, chan); } } nvc-r1.17.1/src/rt/shell.h000066400000000000000000000035141504111170000152360ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_SHELL_H #define _RT_SHELL_H #include "prim.h" typedef jit_t *(*jit_factory_t)(unit_registry_t *, mir_context_t *); typedef struct { void (*add_wave)(ident_t path, const char *enc, void *ctx); void (*signal_update)(ident_t path, uint64_t now, rt_signal_t *s, const char *enc, void *ctx); void (*stdout_write)(const char *buf, size_t nchars, void *ctx); void (*stderr_write)(const char *buf, size_t nchars, void *ctx); void (*backchannel_write)(const char *buf, size_t nchars, void *ctx); void (*start_sim)(ident_t top, void *ctx); void (*restart_sim)(void *ctx); void (*exit)(int status, void *ctx); void (*next_time_step)(uint64_t now, void *ctx); void *context; } shell_handler_t; tcl_shell_t *shell_new(jit_t *jit); void shell_free(tcl_shell_t *sh); bool shell_eval(tcl_shell_t *sh, const char *script, const char **result); bool shell_do(tcl_shell_t *sh, const char *file); void shell_interact(tcl_shell_t *sh); void shell_reset(tcl_shell_t *sh, tree_t top); void shell_set_handler(tcl_shell_t *sh, const shell_handler_t *h); void shell_print_banner(tcl_shell_t *sh); #endif // _RT_SHELL_H nvc-r1.17.1/src/rt/simpkg.c000066400000000000000000000024001504111170000154050ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "option.h" #include "jit/jit.h" #include "jit/jit-ffi.h" #include "rt/model.h" #include "rt/rt.h" DLLEXPORT void _nvc_ieee_warnings(jit_scalar_t *args) { args[0].integer = (opt_get_int(OPT_IEEE_WARNINGS) == IEEE_WARNINGS_ON); } DLLEXPORT void _nvc_current_delta(jit_scalar_t *args) { rt_model_t *m = get_model_or_null(); if (m == NULL) args[0].integer = 0; else { unsigned delta; model_now(m, &delta); args[0].integer = delta; } } void _nvc_sim_pkg_init(void) { // Dummy function to force linking } nvc-r1.17.1/src/rt/standard.c000066400000000000000000000112761504111170000157260ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "jit/jit.h" #include "jit/jit-exits.h" #include "jit/jit-ffi.h" #include "rt/model.h" #include "rt/mspace.h" #include "rt/rt.h" #include #include #include #include #include static void bit_vec_to_string(jit_scalar_t *args, tlab_t *tlab, int log_base) { const uint8_t *vec_ptr = args[1].pointer; int64_t vec_len = ffi_array_length(args[3].integer); const size_t result_len = (vec_len + log_base - 1) / log_base; const int left_pad = (log_base - (vec_len % log_base)) % log_base; char *buf = tlab_alloc(tlab, result_len); for (int i = 0; i < result_len; i++) { unsigned nibble = 0; for (int j = 0; j < log_base; j++) { if (i > 0 || j >= left_pad) { nibble <<= 1; nibble |= !!(vec_ptr[i*log_base + j - left_pad]); } } static const char map[16] = "0123456789ABCDEF"; buf[i] = map[nibble]; } args[0].pointer = buf; args[1].integer = 1; args[2].integer = result_len; } DLLEXPORT void _std_standard_now(jit_scalar_t *args) { rt_model_t *m = get_model_or_null(); args[0].integer = m ? model_now(m, NULL) : 0; } DLLEXPORT void _std_to_string_time(jit_scalar_t *args, tlab_t *tlab) { int64_t value = args[1].integer; int64_t unit = args[2].integer; const char *unit_str = ""; switch (unit) { case 1ll: unit_str = "fs"; break; case 1000ll: unit_str = "ps"; break; case 1000000ll: unit_str = "ns"; break; case 1000000000ll: unit_str = "us"; break; case 1000000000000ll: unit_str = "ms"; break; case 1000000000000000ll: unit_str = "sec"; break; case 60000000000000000ll: unit_str = "min"; break; case 3600000000000000000ll: unit_str = "hr"; break; default: jit_msg(NULL, DIAG_FATAL, "invalid UNIT argument %"PRIi64" in TO_STRING", unit); } static char buf[64]; if (value % unit == 0) checked_sprintf(buf, sizeof(buf), "%"PRIi64" %s", value / unit, unit_str); else checked_sprintf(buf, sizeof(buf), "%.*g %s", DBL_DIG, (double)value / (double)unit, unit_str); ffi_return_string(buf, args, tlab); } DLLEXPORT void _std_to_string_real_digits(jit_scalar_t *args, tlab_t *tlab) { double value = args[1].real; int32_t digits = args[2].integer; char buf[32]; if (digits == 0) checked_sprintf(buf, sizeof(buf), "%.17g", value); else checked_sprintf(buf, sizeof(buf), "%.*f", digits, value); ffi_return_string(buf, args, tlab); } DLLEXPORT void _std_to_string_real_format(jit_scalar_t *args, tlab_t *tlab) { double value = args[1].real; const void *fmt_ptr = args[2].pointer; size_t fmt_length = ffi_array_length(args[4].integer); char *fmt_cstr LOCAL = null_terminate(fmt_ptr, fmt_length); if (fmt_cstr[0] != '%') jit_msg(NULL, DIAG_FATAL, "conversion specification must " "start with '%%'"); for (const char *p = fmt_cstr + 1; *p; p++) { switch (*p) { case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A': continue; case '0'...'9': continue; case '.': case '-': continue; default: jit_msg(NULL, DIAG_FATAL, "illegal character '%c' in format \"%s\"", *p, fmt_cstr + 1); } } char buf[64]; checked_sprintf(buf, sizeof(buf), fmt_cstr, value); ffi_return_string(buf, args, tlab); } DLLEXPORT void _std_to_hstring_bit_vec(jit_scalar_t *args, tlab_t *tlab) { bit_vec_to_string(args, tlab, 4); } DLLEXPORT void _std_to_ostring_bit_vec(jit_scalar_t *args, tlab_t *tlab) { bit_vec_to_string(args, tlab, 3); } DLLEXPORT void _std_to_string_real(jit_scalar_t *args, tlab_t *tlab) { const size_t max = 32; char *buf = tlab_alloc(tlab, max); size_t len = checked_sprintf(buf, max, "%.*g", DBL_DIG, args[1].real); args[0].pointer = buf; args[1].integer = 1; args[2].integer = len; } void _std_standard_init(void) { // Dummy function to force linking } nvc-r1.17.1/src/rt/stdenv.c000066400000000000000000000413271504111170000154310ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "jit/jit.h" #include "jit/jit-ffi.h" #include "jit/jit-exits.h" #include "scan.h" #include "rt/assert.h" #include "rt/mspace.h" #include "rt/rt.h" #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __MINGW32__ #include #define gmtime_r(t, tm) gmtime_s(tm, t); #define localtime_r(t, tm) localtime_s(tm, t); #endif typedef struct { int64_t microsecond; int64_t second; int64_t minute; int64_t hour; int64_t day; int64_t month; int64_t year; int8_t weekday; int64_t dayofyear; } time_record_t; typedef struct { ffi_uarray_t *name; ffi_uarray_t *items; } directory_t; typedef enum { DIR_OPEN_STATUS_OK = 0, DIR_OPEN_STATUS_NOT_FOUND = 1, DIR_OPEN_STATUS_NO_DIRECTORY = 2, DIR_OPEN_STATUS_ACCESS_DENIED = 3, DIR_OPEN_STATUS_ERROR = 4 } dir_open_status_t; typedef enum { DIR_CREATE_STATUS_OK = 0, DIR_CREATE_STATUS_ITEM_EXISTS = 1, DIR_CREATE_STATUS_ACCESS_DENIED = 2, DIR_CREATE_STATUS_ERROR = 3 } dir_create_status_t; typedef enum { FILE_DELETE_STATUS_OK = 0, FILE_DELETE_STATUS_NO_FILE = 1, FILE_DELETE_STATUS_ACCESS_DENIED = 2, FILE_DELETE_STATUS_ERROR = 3 } file_delete_status_t; typedef enum { DIR_DELETE_STATUS_OK = 0, DIR_DELETE_STATUS_NO_DIRECTORY = 1, DIR_DELETE_STATUS_NOT_EMPTY = 2, DIR_DELETE_STATUS_ACCESS_DENIED = 3, DIR_DELETE_STATUS_ERROR = 4 } dir_delete_status_t; typedef struct { ffi_uarray_t *name; ffi_uarray_t *file_name; ffi_uarray_t *file_path; int64_t file_line; } call_path_element_t; static ffi_uarray_t *to_line_n(const char *str, size_t len) { char *buf = jit_mspace_alloc(len); memcpy(buf, str, len); ffi_uarray_t *u = jit_mspace_alloc(sizeof(ffi_uarray_t)); *u = ffi_wrap(buf, 1, len); return u; } static ffi_uarray_t *to_line(const char *str) { return to_line_n(str, strlen(str)); } static int8_t errno_to_dir_open_status(void) { switch (errno) { case 0: return DIR_OPEN_STATUS_OK; case ENOENT: return DIR_OPEN_STATUS_NOT_FOUND; case ENOTDIR: return DIR_OPEN_STATUS_NO_DIRECTORY; case EACCES: return DIR_OPEN_STATUS_ACCESS_DENIED; default: return DIR_OPEN_STATUS_ERROR; } } static int8_t errno_to_dir_create_status(void) { switch (errno) { case 0: return DIR_CREATE_STATUS_OK; case EEXIST: return DIR_CREATE_STATUS_ITEM_EXISTS; case EACCES: return DIR_CREATE_STATUS_ACCESS_DENIED; default: return DIR_CREATE_STATUS_ERROR; } } static int8_t errno_to_file_delete_status(void) { switch (errno) { case 0: return FILE_DELETE_STATUS_OK; case ENOENT: return FILE_DELETE_STATUS_NO_FILE; case EACCES: return FILE_DELETE_STATUS_ACCESS_DENIED; default: return FILE_DELETE_STATUS_ERROR; } } static int8_t errno_to_dir_delete_status(void) { switch (errno) { case 0: return DIR_DELETE_STATUS_OK; case ENOENT: case ENOTDIR: return DIR_DELETE_STATUS_NO_DIRECTORY; case ENOTEMPTY: return DIR_DELETE_STATUS_NOT_EMPTY; case EACCES: return DIR_DELETE_STATUS_ACCESS_DENIED; default: return DIR_DELETE_STATUS_ERROR; } } static char *find_dir_separator(const char *str) { // Forward slash is a valid separator even on Windows char *fwd = strrchr(str, '/'); if (fwd == NULL && DIR_SEP[0] != '/') return strrchr(str, DIR_SEP[0]); else return fwd; } static ffi_uarray_t *to_absolute_path(const char *input) { if (is_absolute_path(input)) return to_line(input); char buf[PATH_MAX]; if (realpath(input, buf) == NULL) return to_line(input); else return to_line(buf); } static void to_time_record(const struct tm *tm, int us, time_record_t *tr) { assert(us >= 0); assert(us < 1000000); tr->microsecond = us; tr->second = tm->tm_sec; tr->minute = tm->tm_min; tr->hour = tm->tm_hour; tr->day = tm->tm_mday; tr->month = tm->tm_mon; tr->year = 1900 + tm->tm_year; tr->weekday = tm->tm_wday; tr->dayofyear = tm->tm_yday; } static time_t to_time_t(const time_record_t *tr) { const int adj_year = tr->year - 1900; return tr->second + tr->minute*60 + tr->hour*3600 + tr->dayofyear*86400 + (adj_year - 70) * 31536000 + ((adj_year - 69) / 4) * 86400 - ((adj_year - 1) / 100)*86400 + ((adj_year + 299) / 400) * 86400; } DLLEXPORT void _std_env_stop(jit_scalar_t *args) { const int32_t finish = args[2].integer; const int32_t have_status = args[3].integer; const int32_t status = args[4].integer; if (have_status) { notef("%s called with status %d", finish ? "FINISH" : "STOP", status); jit_abort_with_status(status); } else { notef("%s called", finish ? "FINISH" : "STOP"); jit_abort(); } } DLLEXPORT void _std_env_getenv(jit_scalar_t *args, tlab_t *tlab) { char *LOCAL cstr = null_terminate(args[1].pointer, ffi_array_length(args[3].integer)); // LRM19 section 16.5.6: conditional analysis identifiers are part of // the queried environment and take precedence over possibly // inherited environment variables of identical names. const char *pp = pp_defines_get(cstr); if (pp != NULL) ffi_return_string(pp, args, tlab); else { const char *env = getenv(cstr); ffi_return_string(env ?: "", args, tlab); } } DLLEXPORT void _std_env_vhdl_version(jit_scalar_t *args, tlab_t *tlab) { const char *str = standard_text(standard()); ffi_return_string(str, args, tlab); } DLLEXPORT void _std_env_tool_version(jit_scalar_t *args, tlab_t *tlab) { ffi_return_string(PACKAGE_VERSION, args, tlab); } DLLEXPORT double _std_env_epoch(void) { const uint64_t nanos = get_real_time(); // Be careful to avoid loss of precision here double real = nanos / UINT64_C(1000000000); real += 1.0e9 / (nanos % UINT64_C(1000000000)); return real; } DLLEXPORT double _std_env_epoch_trec(const time_record_t *tr) { const time_t secs = to_time_t(tr); return (double)secs + (double)tr->microsecond / 1e6; } DLLEXPORT void _std_env_localtime(double time, time_record_t *tr) { double fsecs = floor(time); time_t secs = (time_t)fsecs; struct tm tm; localtime_r(&secs, &tm); to_time_record(&tm, (int)(1e6 * (time - fsecs)), tr); } DLLEXPORT void _std_env_localtime_trec(const time_record_t *tr, time_record_t *result) { time_t time = to_time_t(tr); struct tm tm = {}; localtime_r(&time, &tm); to_time_record(&tm, tr->microsecond, result); } DLLEXPORT void _std_env_gmtime(double time, time_record_t *tr) { double fsecs = floor(time); time_t secs = (int)fsecs; struct tm tm; gmtime_r(&secs, &tm); to_time_record(&tm, (int)(1e6 * (time - fsecs)), tr); } DLLEXPORT void _std_env_gmtime_trec(const time_record_t *tr, time_record_t *result) { struct tm tm = {}; time_t time = to_time_t(tr); #ifdef __MINGW32__ TIME_ZONE_INFORMATION tz; switch (GetTimeZoneInformation(&tz)) { case TIME_ZONE_ID_UNKNOWN: time += tz.Bias * 60; break; case TIME_ZONE_ID_STANDARD: time += (tz.Bias + tz.StandardBias) * 60; break; case TIME_ZONE_ID_DAYLIGHT: time += (tz.Bias + tz.DaylightBias) * 60; break; } #else // Call localtime to get GMT offset localtime_r(&time, &tm); time -= tm.tm_gmtoff; #endif gmtime_r(&time, &tm); to_time_record(&tm, tr->microsecond, result); } DLLEXPORT void _std_env_add_trec_real(const time_record_t *tr, double delta, time_record_t *result) { const int micro = (int)(fmod(delta, 1.0) * 1e6); const time_t secs = (time_t)trunc(delta); time_t newsecs = to_time_t(tr) + secs; int newmicro = tr->microsecond + micro; if (newmicro >= 1000000) { newmicro %= 1000000; newsecs++; } else if (newmicro < 0) { newmicro = 1000000 + newmicro % 100000; newsecs--; } struct tm tm = {}; gmtime_r(&newsecs, &tm); to_time_record(&tm, newmicro, result); } DLLEXPORT double _std_env_diff_trec(const time_record_t *tr1, const time_record_t *tr2) { const time_t diff = to_time_t(tr1) - to_time_t(tr2); const int microdiff = tr1->microsecond - tr2->microsecond; return (double)diff + (double)microdiff / 1e6; } DLLEXPORT void _std_env_get_workingdir(jit_scalar_t *args, tlab_t *tlab) { char buf[PATH_MAX]; if (getcwd(buf, sizeof(buf)) == NULL) jit_msg(NULL, DIAG_FATAL, "getcwd failed: %s", strerror(errno)); ffi_return_string(buf, args, tlab); } DLLEXPORT void _std_env_set_workingdir(const uint8_t *dir_ptr, int64_t dir_len, int8_t *status) { char *cstr LOCAL = null_terminate(dir_ptr, dir_len); if (chdir(cstr) == -1) *status = errno_to_dir_open_status(); else *status = DIR_OPEN_STATUS_OK; } DLLEXPORT void _std_env_createdir(const uint8_t *path_ptr, int64_t path_len, int8_t parents, int8_t *status) { char *cstr LOCAL = null_terminate(path_ptr, path_len); if (parents) jit_msg(NULL, DIAG_WARN, "PARENTS argument not supported"); #ifdef __MINGW32__ if (mkdir(cstr) == -1) #else if (mkdir(cstr, 0777) == -1) #endif *status = errno_to_dir_create_status(); else *status = DIR_CREATE_STATUS_OK; } DLLEXPORT bool _std_env_itemexists(const uint8_t *path_ptr, int64_t path_len) { char *path LOCAL = null_terminate(path_ptr, path_len); file_info_t info; return get_file_info(path, &info); } DLLEXPORT bool _std_env_itemisfile(const uint8_t *path_ptr, int64_t path_len) { char *path LOCAL = null_terminate(path_ptr, path_len); file_info_t info; if (!get_file_info(path, &info)) return false; return info.type == FILE_REGULAR; } DLLEXPORT bool _std_env_itemisdir(const uint8_t *path_ptr, int64_t path_len) { char *path LOCAL = null_terminate(path_ptr, path_len); file_info_t info; if (!get_file_info(path, &info)) return false; return info.type == FILE_DIR; } DLLEXPORT void _std_env_deletefile(const uint8_t *path_ptr, int64_t path_len, int8_t *status) { char *path LOCAL = null_terminate(path_ptr, path_len); if (remove(path) == -1) *status = errno_to_file_delete_status(); else *status = FILE_DELETE_STATUS_OK; } static int8_t delete_tree(const char *path) { DIR *d = opendir(path); if (d == NULL) return errno_to_dir_delete_status(); LOCAL_TEXT_BUF tb = tb_new(); int8_t status = DIR_DELETE_STATUS_OK; struct dirent *e; while (status == DIR_DELETE_STATUS_OK && (e = readdir(d))) { if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue; tb_rewind(tb); tb_cat(tb, path); tb_cat(tb, DIR_SEP); tb_cat(tb, e->d_name); #if defined __MINGW32__ || !defined DT_DIR file_info_t info; get_file_info(tb_get(tb), &info); const bool is_dir = (info.type == FILE_DIR); #else const bool is_dir = (e->d_type == DT_DIR); #endif if (is_dir) status = delete_tree(tb_get(tb)); else if (remove(tb_get(tb)) == -1) status = errno_to_dir_delete_status(); } closedir(d); if (status == DIR_DELETE_STATUS_OK && rmdir(path) == -1) return errno_to_dir_delete_status(); return status; } DLLEXPORT void _std_env_deletedir(const uint8_t *path_ptr, int64_t path_len, int8_t recursive, int8_t *status) { char *path LOCAL = null_terminate(path_ptr, path_len); if (recursive) *status = delete_tree(path); else if (rmdir(path) == -1) *status = errno_to_dir_delete_status(); else *status = DIR_DELETE_STATUS_OK; } DLLEXPORT void _std_env_dir_open(directory_t *dir, const uint8_t *path_ptr, int64_t path_len, int8_t *status) { char *path LOCAL = null_terminate(path_ptr, path_len); DIR *d = opendir(path); if (d == NULL) { *status = errno_to_dir_open_status(); return; } char resolved[PATH_MAX]; if (realpath(path, resolved) == NULL) { *status = errno_to_dir_open_status(); return; } const size_t resolvedsz = strlen(resolved); size_t memsz = sizeof(ffi_uarray_t)*2 + resolvedsz; struct dirent *e; int count = 0; while ((e = readdir(d))) { const size_t nchars = strlen(e->d_name); memsz += sizeof(ffi_uarray_t) + ALIGN_UP(nchars, 8); count++; } memsz += count * sizeof(ffi_uarray_t *); rewinddir(d); void *mem = jit_mspace_alloc(memsz), *next = mem; dir->items = next; dir->items->dims[0].left = 0; dir->items->dims[0].length = count; dir->items->ptr = dir->items + 1; next += sizeof(ffi_uarray_t) + count * sizeof(ffi_uarray_t *); for (int nth = 0; (e = readdir(d)); nth++) { const size_t nchars = strlen(e->d_name); ffi_uarray_t *u = next; u->ptr = u + 1; u->dims[0].left = 1; u->dims[0].length = nchars; memcpy(u->ptr, e->d_name, nchars); *((ffi_uarray_t **)dir->items->ptr + nth) = u; next += sizeof(ffi_uarray_t) + ALIGN_UP(nchars, 8); } closedir(d); dir->name = next; dir->name->ptr = dir->name + 1; dir->name->dims[0].left = 1; dir->name->dims[0].length = resolvedsz; memcpy(dir->name->ptr, resolved, resolvedsz); next += sizeof(ffi_uarray_t) + resolvedsz; assert(next == mem + memsz); *status = 0; } DLLEXPORT void _std_env_get_call_path(jit_scalar_t *args, tlab_t *tlab) { jit_stack_trace_t *stack LOCAL = jit_stack_trace(); call_path_element_t *array = jit_mspace_alloc(stack->count * sizeof(call_path_element_t)); for (int i = 0; i < stack->count; i++) { jit_frame_t *frame = &(stack->frames[i]); call_path_element_t *cpe = &(array[i]); tree_t decl = tree_from_object(frame->object); assert(decl != NULL); cpe->name = to_line(istr(tree_ident(decl))); cpe->file_line = frame->loc.first_line; char *file LOCAL = xstrdup(loc_file_str(&frame->loc)); char *sep = find_dir_separator(file); if (sep != NULL) { *sep = '\0'; cpe->file_name = to_line(sep + 1); cpe->file_path = to_absolute_path(file); } else { cpe->file_name = to_line(file); cpe->file_path = to_absolute_path("."); } } ffi_uarray_t *u = jit_mspace_alloc(sizeof(ffi_uarray_t)); *u = ffi_wrap(array, 0, stack->count - 1); args[0].pointer = u; } DLLEXPORT void _std_env_file_name(ffi_uarray_t **ptr) { jit_stack_trace_t *stack LOCAL = jit_stack_trace(); assert(stack->count > 1); const char *file = loc_file_str(&(stack->frames[1].loc)); const char *sep = find_dir_separator(file); *ptr = to_line(sep ? sep + 1 : file); } DLLEXPORT void _std_env_file_path(ffi_uarray_t **ptr) { jit_stack_trace_t *stack LOCAL = jit_stack_trace(); assert(stack->count > 1); char *file LOCAL = xstrdup(loc_file_str(&(stack->frames[1].loc))); char *sep = find_dir_separator(file); if (sep == NULL) *ptr = to_absolute_path("."); else { *sep = '\0'; *ptr = to_absolute_path(file); } } DLLEXPORT int32_t _std_env_file_line(void) { jit_stack_trace_t *stack LOCAL = jit_stack_trace(); assert(stack->count > 1); return stack->frames[1].loc.first_line; } DLLEXPORT int64_t _std_env_seconds_to_time(double real) { double whole, frac = modf(real, &whole); return (int64_t)whole * UINT64_C(1000000000000000) + (int64_t)(frac * 1e15); } DLLEXPORT void _std_env_get_vhdl_assert_count(jit_scalar_t *args) { vhdl_severity_t severity_level = args[1].integer; args[0].integer = get_vhdl_assert_count(severity_level); } DLLEXPORT void _std_env_clear_vhdl_assert(void) { clear_vhdl_assert(); } DLLEXPORT void _std_env_set_vhdl_assert_enable(jit_scalar_t *args) { vhdl_severity_t severity_level = args[2].integer; bool enable = !!args[3].integer; set_vhdl_assert_enable(severity_level, enable); } DLLEXPORT void _std_env_get_vhdl_assert_enable(jit_scalar_t *args) { vhdl_severity_t severity_level = args[1].integer; args[0].integer = get_vhdl_assert_enable(severity_level); } void _std_env_init(void) { // Dummy function to force linking } nvc-r1.17.1/src/rt/structs.h000066400000000000000000000145031504111170000156360ustar00rootroot00000000000000// // Copyright (C) 2011-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_STRUCTS_H #define _RT_STRUCTS_H #include "prim.h" #include "array.h" #include "mask.h" #include "jit/jit.h" #include "jit/jit-ffi.h" #include "rt/mspace.h" #include "rt/rt.h" #include "thread.h" typedef void *(*value_fn_t)(rt_nexus_t *); typedef A(rt_scope_t *) scope_list_t; typedef A(rt_prop_t *) prop_list_t; typedef A(rt_signal_t *) signal_list_t; typedef A(rt_proc_t *) proc_list_t; typedef A(rt_alias_t *) alias_list_t; typedef enum { W_PROC, W_WATCH, W_IMPLICIT, W_PROPERTY, W_TRANSFER, } wakeable_kind_t; typedef uint32_t wakeup_gen_t; typedef enum { FUNC_TRIGGER, OR_TRIGGER, CMP_TRIGGER } trigger_kind_t; typedef struct _rt_trigger { jit_handle_t handle; unsigned nargs; uint64_t when; unsigned iteration; trigger_kind_t kind; rt_trigger_t *chain; jit_scalar_t result; jit_scalar_t args[]; } rt_trigger_t; typedef struct { wakeable_kind_t kind : 8; unsigned pending : 1; unsigned postponed : 1; unsigned delayed : 1; unsigned zombie : 1; rt_trigger_t *trigger; } rt_wakeable_t; typedef struct _rt_proc { rt_wakeable_t wakeable; tree_t where; ident_t name; jit_handle_t handle; tlab_t *tlab; rt_scope_t *scope; mptr_t privdata; } rt_proc_t; STATIC_ASSERT(sizeof(rt_proc_t) <= 128); typedef struct _rt_prop { rt_wakeable_t wakeable; psl_node_t where; ident_t name; jit_handle_t handle; rt_scope_t *scope; bit_mask_t state; bit_mask_t newstate; mptr_t privdata; bool strong; } rt_prop_t; typedef union { uint8_t bytes[8]; uint64_t qword; void *ext; } rt_value_t; STATIC_ASSERT(sizeof(rt_value_t) == 8); struct waveform { uint64_t when; waveform_t *next; rt_value_t value; }; STATIC_ASSERT(sizeof(waveform_t) <= 24); typedef struct { unsigned count; unsigned max; rt_wakeable_t *wake[]; } rt_pending_t; typedef enum { SOURCE_DRIVER, SOURCE_PORT, SOURCE_FORCING, SOURCE_DEPOSIT, SOURCE_IMPLICIT, } source_kind_t; typedef struct { rt_proc_t *proc; rt_nexus_t *nexus; waveform_t waveforms; } rt_driver_t; typedef struct { rt_nexus_t *nexus; rt_value_t result; } conv_input_t; typedef struct _rt_conv_func { ffi_closure_t driving; ffi_closure_t effective; unsigned ninputs; unsigned maxinputs; conv_input_t *inputs; rt_source_t *outputs; uint64_t when; unsigned iteration; conv_input_t tail[]; } rt_conv_func_t; typedef struct { rt_nexus_t *output; rt_nexus_t *input; rt_conv_func_t *conv_func; rt_value_t conv_result; } rt_port_t; typedef struct { rt_nexus_t *nexus; rt_value_t value; } rt_pseudo_t; typedef struct _rt_source { rt_source_t *chain_input; rt_source_t *chain_output; source_kind_t tag; unsigned disconnected : 1; unsigned fastqueued : 1; unsigned sigqueued : 1; unsigned pseudoqueued : 1; unsigned was_active : 1; union { rt_port_t port; rt_driver_t driver; rt_pseudo_t pseudo; } u; } rt_source_t; STATIC_ASSERT(sizeof(rt_source_t) <= 64); typedef struct { ffi_closure_t closure; res_flags_t flags; int8_t tab2[16][16]; int8_t tab1[16]; } res_memo_t; typedef struct _rt_nexus { rt_nexus_t *chain; rt_signal_t *signal; uint32_t offset; delta_cycle_t active_delta; delta_cycle_t event_delta; uint32_t width; net_flags_t flags; uint8_t size; uint8_t n_sources; uint8_t rank; uint64_t last_event; void *pending; rt_source_t *outputs; void *free_value; rt_source_t sources; } rt_nexus_t; STATIC_ASSERT(sizeof(rt_nexus_t) <= 128); // The code generator knows the layout of this struct typedef struct _sig_shared { uint32_t size; sig_flags_t flags; uint8_t data[]; } sig_shared_t; typedef struct { int how; rt_nexus_t *nexus[]; } rt_index_t; typedef struct _rt_signal { tree_t where; rt_scope_t *parent; rt_index_t *index; res_memo_t *resolution; nvc_lock_t lock; uint32_t offset; uint32_t n_nexus; rt_nexus_t nexus; sig_shared_t shared; } rt_signal_t; STATIC_ASSERT(sizeof(rt_signal_t) + 8 <= 192); typedef struct _rt_implicit { rt_wakeable_t wakeable; ffi_closure_t closure; uint64_t delay; rt_signal_t signal; // Has a flexible member } rt_implicit_t; typedef struct { rt_wakeable_t wakeable; rt_proc_t *proc; rt_nexus_t *target; rt_nexus_t *source; int64_t after; int64_t reject; unsigned count; } rt_transfer_t; typedef struct _rt_alias { rt_alias_t *chain; tree_t where; rt_signal_t *signal; } rt_alias_t; typedef enum { SCOPE_F_RESOLVED = (1 << 0) } rt_scope_flags_t; typedef struct _rt_scope { signal_list_t signals; proc_list_t procs; alias_list_t aliases; prop_list_t properties; rt_scope_kind_t kind; rt_scope_flags_t flags; unsigned size; // For signal scopes unsigned offset; ident_t name; tree_t where; mptr_t privdata; rt_scope_t *parent; scope_list_t children; } rt_scope_t; typedef struct _rt_watch { rt_wakeable_t wakeable; sig_event_fn_t fn; rt_watch_t *chain_all; void *user_data; unsigned num_slots; unsigned next_slot; rt_signal_t *signals[]; } rt_watch_t; #endif // _RT_STRUCTS_H nvc-r1.17.1/src/rt/wave.c000066400000000000000000001043721504111170000150700ustar00rootroot00000000000000// // Copyright (C) 2013-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "fstapi.h" #include "hash.h" #include "jit/jit-layout.h" #include "option.h" #include "rt/model.h" #include "rt/rt.h" #include "rt/structs.h" #include "rt/wave.h" #include "tree.h" #include "type.h" #include #include #include #include #if !defined __CYGWIN__ && !defined __MINGW32__ #include #endif #define USE_FST_ENUMS 0 typedef struct { char *text; size_t len; } glob_t; typedef A(glob_t) glob_array_t; typedef struct _fst_data fst_data_t; typedef void (*fst_fmt_fn_t)(rt_watch_t *, fst_data_t *); typedef struct { int64_t mult; char *name; } fst_unit_t; typedef struct { unsigned count; unsigned size; char *strings; } fst_enum_t; typedef struct { fst_fmt_fn_t fn; enum fstVarType vartype; enum fstSupplementalDataType sdt; unsigned size; union { const char *map; fst_unit_t *units; fst_enum_t literals; fstEnumHandle enumh; } u; } fst_type_t; typedef struct _fst_data { wave_dumper_t *dumper; fst_type_t *type; rt_watch_t *watch; tree_t decl; rt_signal_t *signal; unsigned size; unsigned count; fstHandle handle[]; } fst_data_t; typedef A(fst_data_t *) data_array_t; typedef struct { int64_t length; int64_t msb; int64_t lsb; range_kind_t dir; } fst_dim_t; typedef struct { FILE *file; int colour; text_buf_t *hier; bool end_of_record; } gtkw_writer_t; typedef struct _wave_dumper { tree_t top; void *fst_ctx; rt_model_t *model; gtkw_writer_t *gtkw; FILE *vcdfile; char *tmpfst; uint64_t last_time; jit_t *jit; hash_t *typecache; data_array_t dumped; } wave_dumper_t; static glob_array_t incl; static glob_array_t excl; static void fst_process_signal(wave_dumper_t *wd, rt_scope_t *scope, tree_t d, type_t type, text_buf_t *tb); static bool wave_should_dump(rt_scope_t *scope, ident_t id); static bool should_dump_array(tree_t where, unsigned length) { const unsigned limit = opt_get_int(OPT_DUMP_ARRAYS); if (limit > 0 && length <= limit) return true; static bool warned = false; if (warned || limit > 0) return false; notef("arrays of composite types such as %s are not not dumped by default, " "pass $bold$--dump-arrays$$ to include these in the waveform dump", type_pp(tree_type(where))); warned = true; return false; } static void fst_close(rt_model_t *m, void *arg) { wave_dumper_t *wd = arg; fstWriterEmitTimeChange(wd->fst_ctx, model_now(m, NULL)); fstWriterClose(wd->fst_ctx); if (wd->vcdfile) { void *xc = fstReaderOpen(wd->tmpfst); if (xc == NULL) fatal("fstReaderOpen failed for temporary FST file"); fstReaderSetVcdExtensions(xc, 1); if (!fstReaderProcessHier(xc, wd->vcdfile)) fatal("fstReaderProcessHier failed"); fstReaderSetFacProcessMaskAll(xc); fstReaderIterBlocks(xc, NULL, NULL, wd->vcdfile); fstReaderClose(xc); fclose(wd->vcdfile); wd->vcdfile = NULL; if (unlink(wd->tmpfst) != 0) fatal_errno("unlink: %s", wd->tmpfst); #if !defined __CYGWIN__ && !defined __MINGW32__ char *tmpdir = dirname(wd->tmpfst); if (rmdir(tmpdir) != 0) fatal_errno("unlink: %s", tmpdir); #endif free(wd->tmpfst); wd->tmpfst = NULL; } wd->fst_ctx = NULL; wd->model = NULL; } static inline void fst_write_binary(uint64_t val, size_t size, char *buf) { for (size_t j = 0; j < size; j++) buf[size - 1 - j] = (val & (UINT64_C(1) << j)) ? '1' : '0'; buf[size] = '\0'; } static void fst_fmt_int(rt_watch_t *w, fst_data_t *data) { uint64_t val[data->count]; signal_expand(data->signal, val, data->count); for (int i = 0; i < data->count; i++) { char buf[data->type->size + 1]; fst_write_binary(val[i], data->type->size, buf); fstWriterEmitValueChange(data->dumper->fst_ctx, data->handle[i], buf); } } static void fst_fmt_real(rt_watch_t *w, fst_data_t *data) { const void *buf = signal_value(data->signal); fstWriterEmitValueChange(data->dumper->fst_ctx, data->handle[0], buf); } static void fst_fmt_physical(rt_watch_t *w, fst_data_t *data) { uint64_t val; signal_expand(data->signal, &val, 1); fst_unit_t *unit = data->type->u.units; while ((val % unit->mult) != 0) ++unit; char buf[128]; checked_sprintf(buf, sizeof(buf), "%"PRIi64" %s", val / unit->mult, unit->name); fstWriterEmitVariableLengthValueChange( data->dumper->fst_ctx, data->handle[0], buf, strlen(buf)); } static void fst_fmt_chars(rt_watch_t *w, fst_data_t *data) { const uint8_t *p = signal_value(data->signal); for (int i = 0; i < data->count; i++, p += data->size) { if (likely(data->type->u.map != NULL)) { char buf[data->size]; for (int j = 0; j < data->size; j++) buf[j] = data->type->u.map[p[j]]; fstWriterEmitValueChange(data->dumper->fst_ctx, data->handle[i], buf); } else fstWriterEmitVariableLengthValueChange( data->dumper->fst_ctx, data->handle[i], p, data->size); } } #if !USE_FST_ENUMS static void fst_fmt_enum(rt_watch_t *w, fst_data_t *data) { uint64_t val; signal_expand(data->signal, &val, 1); fst_enum_t *e = &(data->type->u.literals); assert(val < e->count); const char *literal = e->strings + val * e->size; fstWriterEmitVariableLengthValueChange(data->dumper->fst_ctx, data->handle[0], literal, strnlen(literal, e->size)); } #endif static void fst_event_cb(uint64_t now, rt_signal_t *s, rt_watch_t *w, void *user) { fst_data_t *data = user; if (now != data->dumper->last_time) { fstWriterEmitTimeChange(data->dumper->fst_ctx, now); data->dumper->last_time = now; } if (likely(data != NULL)) (*data->type->fn)(w, data); } static fst_unit_t *fst_make_unit_map(type_t type) { type_t base = type_base_recur(type); const int nunits = type_units(base); fst_unit_t *map = xmalloc(nunits * sizeof(fst_unit_t)); for (int i = 0; i < nunits; i++) { tree_t unit = type_unit(base, nunits - 1 - i); map[i].mult = assume_int(tree_value(unit)); map[i].name = strdup(istr(tree_ident(unit))); } return map; } static fst_type_t *fst_type_for(wave_dumper_t *wd, type_t type, const loc_t *loc) { if (is_anonymous_subtype(type)) { // Do not cache anonymous subtypes return fst_type_for(wd, type_base(type), loc); } fst_type_t *ft = hash_get(wd->typecache, type); if (ft == (void *)-1) return NULL; // Failed for this type earlier else if (ft != NULL) return ft; ft = xcalloc(sizeof(fst_type_t)); switch (type_kind(type)) { case T_SUBTYPE: { fst_type_t *baseft = fst_type_for(wd, type_base(type), loc); if (baseft == NULL) goto poison; *ft = *baseft; switch (is_well_known(type_ident(type))) { case W_STD_NATURAL: ft->sdt = FST_SDT_VHDL_NATURAL; break; case W_STD_POSITIVE: ft->sdt = FST_SDT_VHDL_POSITIVE; break; case W_IEEE_LOGIC: ft->sdt = FST_SDT_VHDL_STD_LOGIC; break; default: break; } } break; case T_INTEGER: { int64_t low, high; range_bounds(range_of(type, 0), &low, &high); ft->vartype = FST_VT_VCD_INTEGER; ft->fn = fst_fmt_int; ft->size = bits_for_range(low, high); ft->sdt = FST_SDT_VHDL_INTEGER; } break; case T_REAL: ft->vartype = FST_VT_VCD_REAL; ft->fn = fst_fmt_real; ft->sdt = FST_SDT_VHDL_REAL; break; case T_ENUM: { switch (is_well_known(type_ident(type))) { case W_IEEE_ULOGIC: ft->sdt = FST_SDT_VHDL_STD_ULOGIC; ft->vartype = FST_VT_SV_LOGIC; ft->fn = fst_fmt_chars; ft->u.map = "UX01ZWLH-"; ft->size = 1; break; case W_STD_BIT: ft->sdt = FST_SDT_VHDL_BIT; ft->vartype = FST_VT_SV_LOGIC; ft->fn = fst_fmt_chars; ft->u.map = "01"; ft->size = 1; break; case W_STD_CHAR: ft->sdt = FST_SDT_VHDL_CHARACTER; break; case W_STD_BOOL: ft->sdt = FST_SDT_VHDL_BOOLEAN; break; default: ft->sdt = FST_SDT_NONE; break; } } if (ft->fn == NULL) { const int nlits = type_enum_literals(type); int maxsize = 0; for (int i = 0; i < nlits; i++) { ident_t id = tree_ident(type_enum_literal(type, i)); maxsize = MAX(maxsize, ident_len(id) + 1); } #if USE_FST_ENUMS const int nbits = bits_for_range(0, nlits - 1); char *lit_mem LOCAL = xmalloc((nbits + 1) * nlits); char *name_mem LOCAL = xmalloc_array(maxsize, nlits); const char **lits LOCAL = xmalloc_array(nlits, sizeof(char *)); const char **names LOCAL = xmalloc_array(nlits, sizeof(char *)); char *namep = name_mem; for (int i = 0; i < nlits; i++) { ident_t id = tree_ident(type_enum_literal(type, i)); size_t len = ident_len(id) + 1; memcpy(namep, istr(id), len); names[i] = namep; namep += len; char *litp = lit_mem + i * (nbits + 1); fst_write_binary(i, nbits, litp); lits[i] = litp; } ft->vartype = FST_VT_SV_ENUM; ft->size = nbits; ft->fn = fst_fmt_int; ft->u.enumh = fstWriterCreateEnumTable(wd->fst_ctx, type_pp(type), nlits, nbits, names, lits); #else ft->vartype = FST_VT_GEN_STRING; ft->size = 0; ft->fn = fst_fmt_enum; ft->u.literals.count = nlits; ft->u.literals.size = maxsize; ft->u.literals.strings = xmalloc(maxsize * nlits); for (int i = 0; i < nlits; i++) { char *p = ft->u.literals.strings + i*maxsize; strncpy(p, istr(tree_ident(type_enum_literal(type, i))), maxsize); for (; *p; p++) *p = tolower_iso88591(*p); } #endif } break; case T_PHYSICAL: ft->sdt = FST_SDT_NONE; ft->vartype = FST_VT_GEN_STRING; ft->size = 0; ft->u.units = fst_make_unit_map(type); ft->fn = fst_fmt_physical; break; case T_ARRAY: { if (dimension_of(type) > 1) { warn_at(loc, "cannot represent multidimensional arrays " "in FST format"); goto poison; } type_t elem = type_elem(type); fst_type_t *elemft = fst_type_for(wd, elem, loc); if (elemft == NULL) { warn_at(loc, "cannot represent arrays of array of type %s " "in FST format", type_pp(elem)); goto poison; } *ft = *elemft; switch (is_well_known(type_ident(type))) { case W_IEEE_ULOGIC_VECTOR: ft->sdt = FST_SDT_VHDL_STD_ULOGIC_VECTOR; break; case W_IEEE_LOGIC_VECTOR: ft->sdt = FST_SDT_VHDL_STD_LOGIC_VECTOR; break; case W_IEEE_SIGNED: ft->sdt = FST_SDT_VHDL_SIGNED; break; case W_IEEE_UNSIGNED: ft->sdt = FST_SDT_VHDL_UNSIGNED; break; case W_STD_STRING: ft->sdt = FST_SDT_VHDL_STRING; ft->vartype = FST_VT_GEN_STRING; ft->fn = fst_fmt_chars; ft->u.map = NULL; ft->size = 1; break; default: break; } } break; default: warn_at(loc, "cannot represent type %s in FST format", type_pp(type)); goto poison; } hash_put(wd->typecache, type, ft); return ft; poison: hash_put(wd->typecache, type, (void *)-1); free(ft); return NULL; } static void *fst_get_ptr(wave_dumper_t *wd, rt_scope_t *scope, tree_t where) { if (scope->kind == SCOPE_RECORD) { type_t rtype = type_elem_recur(tree_type(scope->where)); assert(type_is_record(rtype)); assert(type_field(rtype, tree_pos(where)) == where); const jit_layout_t *l = signal_layout_of(rtype); assert(l->nparts == type_fields(rtype)); const ptrdiff_t offset = l->parts[tree_pos(where)].offset; return fst_get_ptr(wd, scope->parent, scope->where) + offset; } else if (scope->kind == SCOPE_ARRAY) { // Record nested inside array ffi_uarray_t *u = fst_get_ptr(wd, scope->parent, scope->where); return u->ptr; } else { assert(scope->kind == SCOPE_INSTANCE); jit_handle_t handle = jit_lazy_compile(wd->jit, scope->name); return jit_get_frame_var(wd->jit, handle, tree_ident(where)); } } static void fst_get_array_range(wave_dumper_t *wd, type_t type, rt_scope_t *scope, tree_t where, int dim, int64_t *left, int64_t *right, range_kind_t *dir, int64_t *length) { if (!type_is_unconstrained(type)) { tree_t r = range_of(type, 0); if (folded_length(r, length)) { *dir = tree_subkind(r); *left = assume_int(tree_left(r)); *right = assume_int(tree_right(r)); return; } } const jit_layout_t *l = signal_layout_of(type); assert(l->parts[l->nparts - 1].class == LC_BOUNDS); void *base = fst_get_ptr(wd, scope, where); ffi_dim_t *dims = base + l->parts[l->nparts - 1].offset; *left = dims[dim].left; *right = ffi_array_right(dims[dim].left, dims[dim].length); *dir = ffi_array_dir(dims[dim].length); *length = ffi_array_length(dims[dim].length); assert(*length >= 0 && *length < UINT32_MAX); } static fstHandle fst_create_handle(wave_dumper_t *wd, fst_data_t *data, const char *name, enum fstVarDir dir, type_t type, fstHandle alias) { if (data->type->vartype == FST_VT_SV_ENUM) fstWriterEmitEnumTableRef(wd->fst_ctx, data->type->u.enumh); return fstWriterCreateVar2( wd->fst_ctx, data->type->vartype, dir, data->size, name, alias, type_pp(type), FST_SVT_VHDL_SIGNAL, data->type->sdt); } static void fst_create_memory(wave_dumper_t *wd, fst_data_t *data, int *pos, const fst_dim_t *dims, int ndims, int curdim, enum fstVarDir vd, type_t type, text_buf_t *tb) { if (curdim == ndims - 1) { tb_printf(tb, "[%"PRIi64":%"PRIi64"]", dims[curdim].msb, dims[curdim].lsb); data->handle[(*pos)++] = fst_create_handle(wd, data, tb_get(tb), vd, type, 0); } else { const size_t pfxlen = tb_len(tb); type_t elem = type_elem(type); for (int i = 0; i < dims[curdim].length; i++) { tb_trim(tb, pfxlen); tb_printf(tb, "[%"PRIi64"]", dims[curdim].msb + (dims[curdim].dir == RANGE_TO ? i : -i)); fst_create_memory(wd, data, pos, dims, ndims, curdim + 1, vd, elem, tb); } } } static void fst_create_array_var(wave_dumper_t *wd, tree_t d, rt_signal_t *s, type_t type, text_buf_t *tb) { enum fstVarDir vd = FST_VD_IMPLICIT; if (tree_kind(d) == T_PORT_DECL) { switch (tree_subkind(d)) { case PORT_IN: vd = FST_VD_INPUT; break; case PORT_OUT: vd = FST_VD_OUTPUT; break; case PORT_INOUT: vd = FST_VD_INOUT; break; case PORT_BUFFER: vd = FST_VD_BUFFER; break; } } int64_t left, right, length; range_kind_t dir; fst_get_array_range(wd, type, s->parent, s->where, 0, &left, &right, &dir, &length); tb_rewind(tb); tb_istr(tb, tree_ident(d)); tb_printf(tb, "[%"PRIi64":%"PRIi64"]", left, right); tb_downcase(tb); fst_data_t *data; type_t elem = type_elem(type); if (type_is_enum(elem)) { fst_type_t *ft = fst_type_for(wd, type, tree_loc(d)); if (ft == NULL) return; data = xcalloc(sizeof(fst_data_t) + sizeof(fstHandle)); data->type = ft; data->size = length * ft->size; data->count = 1; data->handle[0] = fst_create_handle(wd, data, tb_get(tb), vd, type, 0); if (wd->gtkw != NULL) fprintf(wd->gtkw->file, "%s.%s\n", tb_get(wd->gtkw->hier), tb_get(tb)); } else if (!should_dump_array(d, length)) return; // Dumping memories and nested arrays can be slow else if (type_is_record(elem)) return; // Not yet supported else if (type_is_array(elem)) { fst_type_t *ft = fst_type_for(wd, elem, tree_loc(d)); if (ft == NULL) return; SCOPED_A(fst_dim_t) dims = AINIT; fst_dim_t dim0 = { length, left, right, dir }; APUSH(dims, dim0); int64_t e_length = 1; for (type_t e = elem; type_is_array(e); e = type_elem(e)) { if (dims.count > 1) length *= dims.items[dims.count - 1].length; fst_dim_t dim; assert(dimension_of(e) == 1); fst_get_array_range(wd, e, s->parent, s->where, dims.count, &dim.msb, &dim.lsb, &dim.dir, &dim.length); APUSH(dims, dim); e_length = dim.length; } data = xcalloc_flex(sizeof(fst_data_t), length, sizeof(fstHandle)); data->count = length; data->size = e_length * ft->size; data->type = ft; tb_rewind(tb); tb_istr(tb, tree_ident(d)); tb_downcase(tb); int pos = 0; fst_create_memory(wd, data, &pos, dims.items, dims.count, 0, vd, type, tb); fflush(stdout); assert(pos == length); fstWriterSetAttrEnd(wd->fst_ctx); } else { fst_type_t *ft = fst_type_for(wd, elem, tree_loc(d)); if (ft == NULL) return; data = xcalloc_flex(sizeof(fst_data_t), length, sizeof(fstHandle)); data->count = length; data->size = ft->size; data->type = ft; tb_rewind(tb); tb_istr(tb, tree_ident(d)); tb_downcase(tb); const size_t pfxlen = tb_len(tb); for (int i = 0; i < length; i++) { tb_trim(tb, pfxlen); tb_printf(tb, "[%"PRIi64"]", dir == RANGE_TO ? left + i : left - i); data->handle[i] = fst_create_handle(wd, data, tb_get(tb), vd, elem, 0); } fstWriterSetAttrEnd(wd->fst_ctx); } assert(find_watch(&(s->nexus), fst_event_cb) == NULL); data->decl = d; data->signal = s; data->dumper = wd; data->watch = watch_new(wd->model, fst_event_cb, data, WATCH_POSTPONED, 1); model_set_event_cb(wd->model, data->signal, data->watch); APUSH(wd->dumped, data); } static void fst_create_scalar_var(wave_dumper_t *wd, tree_t d, rt_signal_t *s, type_t type, text_buf_t *tb) { fst_type_t *ft = fst_type_for(wd, type, tree_loc(d)); if (ft == NULL) return; fst_data_t *data = xcalloc(sizeof(fst_data_t) + sizeof(fstHandle)); data->type = ft; data->count = 1; data->size = ft->size; data->dumper = wd; enum fstVarDir dir = FST_VD_IMPLICIT; if (tree_kind(d) == T_PORT_DECL) { switch (tree_subkind(d)) { case PORT_IN: dir = FST_VD_INPUT; break; case PORT_OUT: dir = FST_VD_OUTPUT; break; case PORT_INOUT: dir = FST_VD_INOUT; break; case PORT_BUFFER: dir = FST_VD_BUFFER; break; } } tb_rewind(tb); tb_istr(tb, tree_ident(d)); tb_downcase(tb); data->handle[0] = fst_create_handle(wd, data, tb_get(tb), dir, type, 0); assert(find_watch(&(s->nexus), fst_event_cb) == NULL); data->decl = d; data->signal = s; data->watch = watch_new(wd->model, fst_event_cb, data, WATCH_POSTPONED, 1); model_set_event_cb(wd->model, data->signal, data->watch); APUSH(wd->dumped, data); if (wd->gtkw != NULL) fprintf(wd->gtkw->file, "%s.%s\n", tb_get(wd->gtkw->hier), tb_get(tb)); } static void gtkw_print_scope_comment(gtkw_writer_t *gtkw, rt_scope_t *scope, rt_scope_kind_t kind, text_buf_t *tb, bool leaf) { if (scope->parent != NULL && scope->parent->kind == kind) { gtkw_print_scope_comment(gtkw, scope->parent, kind, tb, false); fputc(kind == SCOPE_INSTANCE ? '/' : '.', gtkw->file); } else fputc('-', gtkw->file); if (scope->kind == SCOPE_INSTANCE && scope->parent->kind == SCOPE_ROOT) { // Do not emit the root scope label } else if (scope->kind == kind) { tb_rewind(tb); tb_istr(tb, tree_ident(scope->where)); tb_downcase(tb); fputs(tb_get(tb), gtkw->file); } if (leaf) fprintf(gtkw->file, "%c\n", is_signal_scope(scope) ? ':' : '/'); gtkw->end_of_record = false; } static void fst_create_record_var(wave_dumper_t *wd, tree_t d, rt_scope_t *scope, type_t type, const char *suffix, text_buf_t *tb) { tb_rewind(tb); tb_istr(tb, tree_ident(d)); tb_cat(tb, suffix); tb_downcase(tb); fstWriterSetScope(wd->fst_ctx, FST_ST_VHDL_RECORD, tb_get(tb), NULL); size_t hlen = 0; if (wd->gtkw != NULL) { hlen = tb_len(wd->gtkw->hier); tb_printf(wd->gtkw->hier, ".%s", tb_get(tb)); gtkw_print_scope_comment(wd->gtkw, scope, scope->kind, tb, true); } const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { tree_t f = type_field(type, i); tree_t cons = type_constraint_for_field(type, f); fst_process_signal(wd, scope, f, tree_type(cons ?: f), tb); } fstWriterSetUpscope(wd->fst_ctx); if (wd->gtkw != NULL) { tb_trim(wd->gtkw->hier, hlen); wd->gtkw->end_of_record = true; } } static void fst_create_record_array_var(wave_dumper_t *wd, tree_t d, rt_scope_t *scope, type_t type, int dim, int start, int count, const char *prefix, text_buf_t *tb) { if (dimension_of(type) > 1) return; // Not supported int64_t left, right, length; range_kind_t dir; fst_get_array_range(wd, type, scope->parent, d, dim, &left, &right, &dir, &length); type_t elem = type_elem(type); const bool nested = type_is_array(elem); assert(count % length == 0); const int stride = count / length; for (int i = start, index = 0; i < start + count; i += stride, index++) { rt_scope_t *sub = AGET(scope->children, i); char suffix[64]; checked_sprintf(suffix, sizeof(suffix), "%s[%"PRIi64"]", prefix, dir == RANGE_TO ? left + index : left - index); if (nested) fst_create_record_array_var(wd, d, scope, elem, dim + 1, i, stride, suffix, tb); else fst_create_record_var(wd, d, sub, elem, suffix, tb); } } static void fst_alias_var(wave_dumper_t *wd, tree_t d, rt_scope_t *scope, rt_signal_t *s, text_buf_t *tb) { rt_watch_t *w = find_watch(&(s->nexus), fst_event_cb); if (w == NULL) return; // Did not dump the primary signal fst_data_t *data = w->user_data; if (data->count != 1) return; // Cannot handle for now type_t type = tree_type(d); tb_rewind(tb); tb_istr(tb, tree_ident(d)); if (type_is_array(type)) { int64_t left, right, length; range_kind_t dir; fst_get_array_range(wd, type, scope, d, 0, &left, &right, &dir, &length); tb_printf(tb, "[%"PRIi64":%"PRIi64"]", left, right); } tb_downcase(tb); fst_create_handle(wd, data, tb_get(tb), FST_VD_INPUT, type, data->handle[0]); if (wd->gtkw != NULL) fprintf(wd->gtkw->file, "%s.%s\n", tb_get(wd->gtkw->hier), tb_get(tb)); } static void fst_process_signal(wave_dumper_t *wd, rt_scope_t *scope, tree_t d, type_t type, text_buf_t *tb) { if (type_is_homogeneous(type)) { if (wd->gtkw != NULL) { if (wd->gtkw->end_of_record) { fputs("-\n", wd->gtkw->file); // Blank line after record wd->gtkw->end_of_record = false; } fprintf(wd->gtkw->file, "[color] %d\n", wd->gtkw->colour); } rt_signal_t *s = find_signal(scope, d); if (s == NULL) return; else if (s->where != d) fst_alias_var(wd, d, scope, s, tb); // Collapsed with another signal else if (type_is_array(type)) fst_create_array_var(wd, d, s, type, tb); else fst_create_scalar_var(wd, d, s, type, tb); } else if (type_is_record(type)) { rt_scope_t *sub = child_scope(scope, d); if (sub != NULL) // NULL means signal was optimised out fst_create_record_var(wd, d, sub, type, "", tb); } else { rt_scope_t *sub = child_scope(scope, d); if (sub != NULL && should_dump_array(d, sub->children.count)) fst_create_record_array_var(wd, d, sub, type, 0, 0, sub->children.count, "", tb); } } static void fst_enter_scope(wave_dumper_t *wd, tree_t unit, rt_scope_t *scope, text_buf_t *tb) { enum fstScopeType st; switch (tree_kind(unit)) { case T_ARCH: st = FST_ST_VHDL_ARCHITECTURE; break; case T_BLOCK: st = FST_ST_VHDL_BLOCK; break; case T_FOR_GENERATE: st = FST_ST_VHDL_FOR_GENERATE; break; case T_IF_GENERATE: st = FST_ST_VHDL_IF_GENERATE; break; case T_PACKAGE: st = FST_ST_VHDL_PACKAGE; break; case T_COMPONENT: st = FST_ST_VHDL_ARCHITECTURE; break; case T_VERILOG: st = FST_ST_VCD_MODULE; break; default: st = FST_ST_VHDL_ARCHITECTURE; warn_at(tree_loc(unit), "no FST scope type for %s", tree_kind_str(tree_kind(unit))); break; } const loc_t *loc = tree_loc(unit); fstWriterSetSourceStem(wd->fst_ctx, loc_file_str(loc), loc->first_line, 1); tb_rewind(tb); tb_istr(tb, tree_ident(scope->where)); tb_downcase(tb); // TODO: store the component name in T_HIER somehow? fstWriterSetScope(wd->fst_ctx, st, tb_get(tb), ""); if (wd->gtkw != NULL) { if (scope->kind == SCOPE_INSTANCE && tb_len(wd->gtkw->hier) > 0) tb_append(wd->gtkw->hier, '.'); tb_cat(wd->gtkw->hier, tb_get(tb)); gtkw_print_scope_comment(wd->gtkw, scope, scope->kind, tb, true); wd->gtkw->colour = (wd->gtkw->colour % 7) + 1; } } static void fst_leave_scope(wave_dumper_t *wd) { fstWriterSetUpscope(wd->fst_ctx); if (wd->gtkw != NULL) { const char *h = tb_get(wd->gtkw->hier); const char *prev = strrchr(h, '.'); if (prev != NULL) tb_trim(wd->gtkw->hier, prev - h); } } static void fst_walk_design(wave_dumper_t *wd, tree_t block) { tree_t h = tree_decl(block, 0); assert(tree_kind(h) == T_HIER); rt_scope_t *scope = find_scope(wd->model, block); if (scope == NULL) fatal_trace("missing scope for %s", istr(tree_ident(block))); LOCAL_TEXT_BUF tb = tb_new(); fst_enter_scope(wd, tree_ref(h), scope, tb); if (tree_subkind(h) == T_COMPONENT && tree_stmts(block) > 0) { // Skip over implicit block statement created for component // instantiation block = tree_stmt(block, 0); assert(tree_kind(block) == T_BLOCK); scope = find_scope(wd->model, block); } const int nports = tree_ports(block); for (int i = 0; i < nports; i++) { tree_t p = tree_port(block, i); if (wave_should_dump(scope, tree_ident(p))) fst_process_signal(wd, scope, p, tree_type(p), tb); } const int ndecls = tree_decls(block); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(block, i); if (tree_kind(d) == T_SIGNAL_DECL) { if (wave_should_dump(scope, tree_ident(d))) fst_process_signal(wd, scope, d, tree_type(d), tb); } } const int nstmts = tree_stmts(block); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(block, i); switch (tree_kind(s)) { case T_BLOCK: fst_walk_design(wd, s); break; case T_PROCESS: case T_VERILOG: break; case T_PSL_DIRECT: break; // TODO: consider emitting to FST default: fatal_trace("cannot handle tree kind %s in fst_walk_design", tree_kind_str(tree_kind(s))); } } fst_leave_scope(wd); } static void fst_walk_packages(wave_dumper_t *wd) { rt_scope_t *root = root_scope(wd->model); assert(root != NULL); assert(root->kind == SCOPE_ROOT); if (wd->gtkw != NULL) tb_rewind(wd->gtkw->hier); LOCAL_TEXT_BUF tb = tb_new(); for (int i = 0; i < root->children.count; i++) { rt_scope_t *s = root->children.items[i]; if (s->kind != SCOPE_PACKAGE) continue; fst_enter_scope(wd, s->where, s, tb); const int ndecls = tree_decls(s->where); for (int j = 0; j < ndecls; j++) { tree_t d = tree_decl(s->where, j); if (tree_kind(d) == T_SIGNAL_DECL) fst_process_signal(wd, s, d, tree_type(d), tb); } fst_leave_scope(wd); } } void wave_dumper_restart(wave_dumper_t *wd, rt_model_t *m, jit_t *jit) { wd->last_time = UINT64_MAX; wd->model = m; wd->jit = jit; fst_walk_design(wd, tree_stmt(wd->top, 0)); fst_walk_packages(wd); if (wd->gtkw != NULL) { fclose(wd->gtkw->file); tb_free(wd->gtkw->hier); free(wd->gtkw); wd->gtkw = NULL; } // Emitting the initial values must happen after all FST variables // are created to avoid expensive mmap/munmap calls for (int i = 0; i < wd->dumped.count; i++) { fst_data_t *data = wd->dumped.items[i]; fst_event_cb(0, data->signal, data->watch, data); } model_set_global_cb(m, RT_END_OF_SIMULATION, fst_close, wd); } wave_dumper_t *wave_dumper_new(const char *file, const char *gtkw_file, tree_t top, wave_format_t format) { wave_dumper_t *wd = xcalloc(sizeof(wave_dumper_t)); wd->top = top; wd->last_time = UINT64_MAX; wd->typecache = hash_new(128); if (format == WAVE_FORMAT_VCD) { #if defined __CYGWIN__ || defined __MINGW32__ const char *tmpdir = "."; #else char tmpdir[PATH_MAX] = "/tmp/vcdXXXXXX"; checked_sprintf(tmpdir, PATH_MAX, "%s/vcdXXXXXX", getenv("TMPDIR") ?: "/tmp"); if (mkdtemp(tmpdir) == NULL) fatal_errno("mkdtemp"); #endif wd->vcdfile = fopen(file, "wb"); if (wd->vcdfile == NULL) fatal_errno("%s", file); wd->tmpfst = xasprintf("%s" DIR_SEP "temp.fst", tmpdir); wd->fst_ctx = fstWriterCreate(wd->tmpfst, 1); } else { wd->vcdfile = NULL; wd->tmpfst = NULL; wd->fst_ctx = fstWriterCreate(file, 1); } if (wd->fst_ctx == NULL) fatal("fstWriterCreate failed"); fstWriterSetFileType(wd->fst_ctx, FST_FT_VHDL); fstWriterSetTimescale(wd->fst_ctx, -15); fstWriterSetVersion(wd->fst_ctx, PACKAGE_STRING); fstWriterSetPackType(wd->fst_ctx, 0); fstWriterSetRepackOnClose(wd->fst_ctx, 1); fstWriterSetParallelMode(wd->fst_ctx, 0); if (gtkw_file != NULL) { wd->gtkw = xcalloc(sizeof(gtkw_writer_t)); if ((wd->gtkw->file = fopen(gtkw_file, "w")) == NULL) fatal_errno("%s", gtkw_file); wd->gtkw->hier = tb_new(); wd->gtkw->colour = 3; } return wd; } void wave_dumper_free(wave_dumper_t *wd) { for (int i = 0; i < wd->dumped.count; i++) free(wd->dumped.items[i]); ACLEAR(wd->dumped); hash_free(wd->typecache); free(wd); } void wave_include_glob(const char *glob) { APUSH(incl, ((glob_t){ .text = strdup(glob), .len = strlen(glob) })); } void wave_exclude_glob(const char *glob) { APUSH(excl, ((glob_t){ .text = strdup(glob), .len = strlen(glob) })); } static void wave_process_file(const char *fname, bool include) { FILE *f = fopen(fname, "r"); if (f == NULL) return; notef("%s signals from %s", include ? "including" : "excluding", fname); char line[1024]; while (!feof(f) && (fgets(line, sizeof(line), f) != NULL)) { // Erase comments bool comment = false; for (char *p = line; *p != '\0'; p++) { if (*p == '#') comment = true; if (comment || (*p == '\r') || (*p == '\n')) *p = '\0'; } char glob[1024]; if (sscanf(line, " %1023s ", glob) == 1) { if (include) wave_include_glob(glob); else wave_exclude_glob(glob); } } fclose(f); } void wave_include_file(const char *base) { char *inclf LOCAL = xasprintf("%s.include", base); wave_process_file(inclf, true); char *exclf LOCAL = xasprintf("%s.exclude", base); wave_process_file(exclf, false); } static bool wave_should_dump(rt_scope_t *scope, ident_t id) { if (excl.count == 0 && incl.count == 0) return true; LOCAL_TEXT_BUF tb = tb_new(); get_path_name(scope, tb); tb_append(tb, ':'); tb_istr(tb, id); tb_downcase(tb); ident_t name = ident_new(tb_get(tb)); for (int i = 0; i < excl.count; i++) { if (ident_glob(name, excl.items[i].text, excl.items[i].len)) return false; } for (int i = 0; i < incl.count; i++) { if (ident_glob(name, incl.items[i].text, incl.items[i].len)) return true; } return (incl.count == 0); } nvc-r1.17.1/src/rt/wave.h000066400000000000000000000023271504111170000150720ustar00rootroot00000000000000// // Copyright (C) 2013-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _RT_WAVE_H #define _RT_WAVE_H #include "prim.h" typedef enum { WAVE_FORMAT_FST, WAVE_FORMAT_VCD } wave_format_t; wave_dumper_t *wave_dumper_new(const char *file, const char *gtkw_file, tree_t top, wave_format_t format); void wave_dumper_free(wave_dumper_t *wd); void wave_dumper_restart(wave_dumper_t *wd, rt_model_t *m, jit_t *jit); void wave_include_glob(const char *glob); void wave_exclude_glob(const char *glob); void wave_include_file(const char *base); #endif // _RT_WAVE_H nvc-r1.17.1/src/scan.c000066400000000000000000000471171504111170000144300ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "diag.h" #include "ident.h" #include "option.h" #include "scan.h" #include "hash.h" #include #include #include #include #include #include typedef struct { bool result; bool taken; loc_t loc; } cond_state_t; typedef A(cond_state_t) cond_stack_t; typedef struct { ident_t name; loc_t expandloc; } macro_expansion_t; typedef A(macro_expansion_t) macro_stack_t; static const char *file_start; static size_t file_sz; static const char *read_ptr; static hdl_kind_t src_kind; static file_ref_t file_ref = FILE_INVALID; static int colno; static int lineno; static int lookahead; static int pperrors; static cond_stack_t cond_stack; static shash_t *pp_defines; static macro_stack_t macro_stack; extern int yylex(void); extern void reset_scanner(void); static bool pp_cond_analysis_expr(void); static void pp_defines_init(); yylval_t yylval; loc_t yylloc; void input_from_buffer(const char *buf, size_t len, hdl_kind_t kind) { pp_defines_init(); reset_scanner(); yylloc = LOC_INVALID; file_start = buf; file_sz = len; src_kind = kind; read_ptr = buf; lineno = 1; colno = 0; lookahead = -1; pperrors = 0; switch (kind) { case SOURCE_VERILOG: reset_verilog_parser(); break; case SOURCE_VHDL: reset_vhdl_parser(); break; case SOURCE_SDF: reset_sdf_parser(); break; } } void input_from_file(const char *file) { // TODO: need a more sophisticated mechanism to determine HDL type hdl_kind_t kind = SOURCE_VHDL; size_t len = strlen(file); if (len > 2 && file[len - 2] == '.' && file[len - 1] == 'v') kind = SOURCE_VERILOG; else if (len > 3 && strcmp(file + len - 3, ".sv") == 0) kind = SOURCE_VERILOG; else if (len > 4 && !strcmp(&(file[len - 4]), ".sdf")) { kind = SOURCE_SDF; } int fd; if (strcmp(file, "-") == 0) fd = STDIN_FILENO; else { fd = open(file, O_RDONLY); if (fd < 0) fatal_errno("opening %s", file); } file_info_t info; if (!get_handle_info(fd, &info)) fatal_errno("%s: cannot get file info", file); if (info.type == FILE_FIFO) { // Read all the data from the pipe into a buffer size_t bufsz = 16384, total = 0; char *buf = xmalloc(bufsz); int nbytes; do { if (bufsz - 1 - file_sz == 0) buf = xrealloc(buf, bufsz *= 2); nbytes = read(fd, buf + total, bufsz - 1 - total); if (nbytes < 0) fatal_errno("read"); total += nbytes; buf[total] = '\0'; } while (nbytes > 0); input_from_buffer(buf, total, kind); } else if (info.type == FILE_REGULAR) { void *map = NULL; if (info.size > 0) map = map_file(fd, info.size); file_ref = loc_file_ref(file, map); input_from_buffer(map, info.size, kind); } else fatal("opening %s: not a regular file", file); close(fd); } hdl_kind_t source_kind(void) { return src_kind; } int get_next_char(char *b, int max_buffer) { const ptrdiff_t navail = (file_start - read_ptr) + file_sz; assert(navail >= 0); if (navail == 0) return 0; const int nchars = MIN(navail, max_buffer); memcpy(b, read_ptr, nchars); read_ptr += nchars; return nchars; } void begin_token(char *tok, int length) { // Newline must match as a single token for the logic below to work assert(strchr(tok, '\n') == NULL || length == 1); if (macro_stack.count == 0) { const int first_col = colno; if (*tok == '\n') { colno = 0; lineno += 1; } else colno += length; const int last_col = first_col + length - 1; extern loc_t yylloc; yylloc = get_loc(lineno, first_col, lineno, last_col, file_ref); } else yylloc = macro_stack.items[0].expandloc; } const char *token_str(token_t tok) { if (tok == tEOF) return "end of file"; else if (tok < 128) { static char buf[2]; buf[0] = tok; return buf; } else { static const char *token_strs[] = { "identifier", "entity", "is", "end", "generic", "port", "constant", "component", "configuration", "architecture", "of", "begin", "for", "type", "to", "all", "in", "out", "buffer", "bus", "unaffected", "signal", "downto", "process", "postponed", "wait", "report", ":=", "integer", "string", "error", "inout", "linkage", "variable", "if", "range", "subtype", "units", "package", "library", "use", "null", "function", "impure", "return", "pure", "array", "<>", "=>", "others", "assert", "severity", "on", "map", "then", "else", "elsif", "body", "while", "loop", "after", "alias", "attribute", "procedure", "exit", "next", "when", "case", "label", "group", "literal", "inertial", "transport", "reject", "bit string", "block", "with", "select", "generate", "access", "file", "open", "real", "until", "record", "new", "shared", "and", "or", "nand", "nor", "xor", "xnor", "/=", "<=", ">=", "**", "sll", "srl", "sla", "sra", "rol", "ror", "mod", "rem", "abs", "not", "guarded", "reverse_range", "protected", "context", "`if", "`else", "`elsif", "`end", "`error", "`warning", "translate_off", "translate_on", "?=", "?/=", "?<", "?<=", "?>", "?>=", "register", "disconnect", "??", "<<", ">>", "force", "release", "parameter", "coverage on", "coverage off", "PSL directive", "always", "->", "<->", "default", "clock", "next!", "never", "eventually!", "next_a", "next_a!", "next_e", "next_e!", "next_event", "next_event!", "module", "endmodule", "input", "output", "reg", "posedge", "negedge", "initial", "wire", "unsigned", "assume", "assume_guarantee", "restrict", "restrict_guarantee", "strong", "fairness", "cover", "property", "sequence", "const", "mutable", "hdltype", "boolean", "bit", "bitvector", "numeric", "string", "[*", "[+]", "[->", "[=", "&&", "within", "system task", "view", "private", "prev", "stable", "rose", "fell", "ended", "nondet", "nondetv", "union", "translate on", "translate off", "until!", "until_", "until!_", "`timescale", "supply0", "supply1", "pulldown", "pullup", "===", "!==", "==", "!=", "(*", "*)", "number", "forever", "[[", "]]", "specify", "endspecify", "primitive", "endprimitive", "table", "endtable", "assign", "level symbol", "edge symbol", "edge indicator", "buf", "||", "scalar constant (0)", "scalar constant (1)", "delay file", "sdf version", "design", "date", "vendor", "program", "version", "divider", "voltage", "temperature", "cell", "celltype", "instance", "delay", "timing check", "timing env", "path pulse", "path pulse percent", "IO path", "retain", "cond", "condelse", "interconnect", "net delay", "device", "setup", "hold", "setuphold", "recovery", "removal", "recrem", "skew", "bidirectional skew", "width", "period", "nochange", "cond", "scond", "ccond", "path constraint", "period constraint", "sum", "diff", "skew constraint", "exception", "name", "arrival", "departure", "slack", "waveform", "increment", "absolute", "~&", "~|", "~^", "struct", "packed", "void", "byte", "shortint", "longint", "int", "integer", "time", "typedef", "logic", "enum", "tagged", "abort", "sync_abort", "async_abort", "before", "before!", "before_", "before!_", "|->", "|=>", "next", "inf", "repeat", "do", "endpoint", "<<", ">>", "<<<", ">>>", "task", "endtask", "endfunction", "`begin_keywords", "`end_keywords", "real", "shortreal", "realtime", "`__nvc_push", "`__nvc_pop", "++", "--", "var", "`default_nettype", "tri", "tri0", "tri1", "wand", "triand", "wor", "trior", "trireg", "uwire", "none", "localparam", "always_comb", "always_ff", "always_latch", "(*)", "endcase", "casex", "casez", "ifnone", "edge", "*>", "$setup", "$hold", "$recovery", "$removal", "$setuphold", "$recrem", "$width", "+:", "-:", "endgenerate", "`resetall", "event", "&&&", "specparam", "fork", "join", "automatic", "genvar", "highz0", "highz1", "strong0", "strong1", "pull0", "pull1", "weak0", "weak1", "small", "medium", "large", "vectored", "scalared", }; if (tok >= 200 && tok - 200 < ARRAY_LEN(token_strs)) return token_strs[tok - 200]; } return "???"; } void free_token(token_t tok, yylval_t *lval) { if (tok == tSTRING || tok == tBITSTRING) free(lval->str); DEBUG_ONLY(lval->str = NULL); } static void pp_defines_init(void) { if (pp_defines != NULL) return; pp_defines = shash_new(16); pp_defines_add("VHDL_VERSION", standard_text(standard())); pp_defines_add("TOOL_TYPE", "SIMULATION"); pp_defines_add("TOOL_VENDOR", PACKAGE_URL); pp_defines_add("TOOL_NAME", PACKAGE_NAME); pp_defines_add("TOOL_EDITION", "GPL"); pp_defines_add("TOOL_VERSION", PACKAGE_VERSION); } void pp_defines_add(const char *name, const char *value) { pp_defines_init(); bool valid = isalpha_iso88591(name[0]) || name[0] == '_'; for (const char *p = name + 1; valid && *p; p++) valid &= isalnum_iso88591(*p) || *p == '_'; if (!valid) errorf("\"%s\" is not a valid conditional analysis identifier", name); char *existing_val = shash_get(pp_defines, name); if (existing_val) { warnf("conditional analysis identifier '%s' already defined (%s)", name, existing_val); free(existing_val); } shash_put(pp_defines, name, xstrdup(value)); } const char *pp_defines_get(const char *name) { pp_defines_init(); return shash_get(pp_defines, name); } void pp_defines_iter(pp_iter_t fn, void *ctx) { pp_defines_init(); const char *key; void *value; for (hash_iter_t it = HASH_BEGIN; shash_iter(pp_defines, &it, &key, &value); ) (*fn)(key, value, ctx); } static int pp_yylex(void) { const int tok = lookahead != -1 ? lookahead : yylex(); lookahead = -1; return tok; } static void pp_error(const char *fmt, ...) { va_list ap; va_start(ap, fmt); if (pperrors++ == 0 || opt_get_int(OPT_UNIT_TEST)) { diag_t *d = diag_new(DIAG_ERROR, &yylloc); diag_vprintf(d, fmt, ap); diag_emit(d); } va_end(ap); } static bool pp_expect(int expect) { const int got = pp_yylex(); if (got != expect) { pp_error("expected $yellow$%s$$ while parsing conditional " "directive but found $yellow$%s$$", token_str(expect), token_str(got)); return false; } return true; } static bool pp_cond_analysis_relation(void) { // ( conditional_analysis_expression ) // | not ( conditional_analysis_expression ) // | conditional_analysis_identifier = string_literal // | conditional_analysis_identifier /= string_literal // | conditional_analysis_identifier < string_literal // | conditional_analysis_identifier <= string_literal // | conditional_analysis_identifier > string_literal // | conditional_analysis_identifier >= string_literal bool result = false; token_t tok = pp_yylex(); switch (tok) { case tLPAREN: result = pp_cond_analysis_expr(); pp_expect(tRPAREN); break; case tNOT: pp_expect(tLPAREN); result = !pp_cond_analysis_expr(); pp_expect(tRPAREN); break; case tID: { const char *name = istr(yylval.ident); token_t rel = pp_yylex(); if (pp_expect(tSTRING)) { const char *value = shash_get(pp_defines, name); if (value == NULL) pp_error("undefined conditional analysis identifier %s", name); else { char *cmp = yylval.str + 1; cmp[strlen(cmp) - 1] = '\0'; switch (rel) { case tEQ: result = strcmp(value, cmp) == 0; break; case tNEQ: result = strcmp(value, cmp) != 0; break; case tLT: result = strcmp(value, cmp) < 0; break; case tLE: result = strcmp(value, cmp) <= 0; break; case tGT: result = strcmp(value, cmp) > 0; break; case tGE: result = strcmp(value, cmp) >= 0; break; default: pp_error("expected conditional analysis relation " "but found $yellow$%s$$", token_str(rel)); break; } } free(yylval.str); } } break; default: pp_error("unexpected $yellow$%s$$ while parsing conditional " "analysis relation", token_str(tok)); } return result; } static bool pp_cond_analysis_expr(void) { // conditional_analysis_relation // | conditional_analysis_relation { and conditional_analysis_relation } // | conditional_analysis_relation { or conditional_analysis_relation } // | conditional_analysis_relation { xor conditional_analysis_relation } // | conditional_analysis_relation { xnor conditional_analysis_relation } const bool lhs = pp_cond_analysis_relation(); switch ((lookahead = pp_yylex())) { case tAND: lookahead = -1; return pp_cond_analysis_relation() && lhs; case tOR: lookahead = -1; return pp_cond_analysis_relation() || lhs; case tXOR: lookahead = -1; return pp_cond_analysis_relation() ^ lhs; case tXNOR: lookahead = -1; return !(pp_cond_analysis_relation() ^ lhs); default: return lhs; } return lhs; } static void macro_hint_cb(diag_t *d, void *ctx) { assert(macro_stack.count > 0); for (int i = 0; i < macro_stack.count; i++) diag_hint(d, NULL, "while expanding macro %s", istr(macro_stack.items[i].name)); } static void pp_nvc_push(void) { token_t tok; macro_expansion_t exp = {}; unsigned first_line, first_column, column_delta; if ((tok = pp_yylex()) != tID) goto error; exp.name = ident_new(yylval.str); free(yylval.str); if ((tok = pp_yylex()) != tCOMMA) goto error; if ((tok = pp_yylex()) != tUNSIGNED) goto error; first_line = atoi(yylval.str); free(yylval.str); if ((tok = pp_yylex()) != tCOLON) goto error; if ((tok = pp_yylex()) != tUNSIGNED) goto error; first_column = atoi(yylval.str); free(yylval.str); if ((tok = pp_yylex()) != tCOMMA) goto error; if ((tok = pp_yylex()) != tUNSIGNED) goto error; column_delta = atoi(yylval.str); free(yylval.str); exp.expandloc = get_loc(first_line, first_column, first_line, first_column + column_delta, yylloc.file_ref); if (macro_stack.count == 0) diag_add_hint_fn(macro_hint_cb, NULL); APUSH(macro_stack, exp); return; error: pp_error("unexpected %s while parsing `__nvc_push directive", token_str(tok)); } static void pp_nvc_pop(void) { if (macro_stack.count == 0) return; const macro_expansion_t top = APOP(macro_stack); lineno = top.expandloc.first_line - 1; colno = top.expandloc.first_column + top.expandloc.column_delta; if (macro_stack.count == 0) diag_remove_hint_fn(macro_hint_cb); } token_t processed_yylex(void) { assert(lookahead == -1); for (;;) { token_t token = pp_yylex(); switch (token) { case tCONDIF: { cond_state_t new = { .loc = yylloc }; new.result = new.taken = pp_cond_analysis_expr(); if (cond_stack.count > 0 && !ATOP(cond_stack).result) { // Suppress nested conditionals in not-taken branches new.taken = true; new.result = false; } pp_expect(tTHEN); new.loc.column_delta = yylloc.first_column + yylloc.column_delta - new.loc.first_column; new.loc.line_delta = yylloc.first_line + yylloc.line_delta - new.loc.first_line; APUSH(cond_stack, new); } break; case tCONDELSIF: { if (cond_stack.count == 0) pp_error("unexpected $yellow$%s$$ outside conditional " "analysis block", token_str(token)); const bool result = pp_cond_analysis_expr(); if (cond_stack.count > 0) { if (!ATOP(cond_stack).taken) { ATOP(cond_stack).result = result; ATOP(cond_stack).taken = result; } else ATOP(cond_stack).result = false; } pp_expect(tTHEN); } break; case tCONDELSE: { if (cond_stack.count == 0) pp_error("unexpected $yellow$%s$$ outside conditional " "analysis block", token_str(token)); else { cond_state_t *cs = &(cond_stack.items[cond_stack.count - 1]); cs->result = !(cs->taken); } } break; case tCONDEND: { if (cond_stack.count == 0) pp_error("unexpected $yellow$%s$$ outside conditional " "analysis block", token_str(token)); else APOP(cond_stack); if ((lookahead = yylex()) == tIF) lookahead = -1; } break; case tCONDERROR: case tCONDWARN: { loc_t loc = yylloc; if (pp_expect(tSTRING)) { loc.column_delta = yylloc.first_column + yylloc.column_delta - loc.first_column; loc.line_delta = yylloc.first_line + yylloc.line_delta - loc.first_line; if (cond_stack.count == 0 || ATOP(cond_stack).result) { const diag_level_t level = token == tCONDWARN ? DIAG_WARN : DIAG_ERROR; diag_t *d = diag_new(level, &loc); diag_printf(d, "%s", yylval.str); diag_emit(d); } free(yylval.str); } } break; case tEOF: while (cond_stack.count > 0) { error_at(&(ATOP(cond_stack).loc), "unterminated conditional " "analysis block"); APOP(cond_stack); } return tEOF; case tNVCPUSH: pp_nvc_push(); break; case tNVCPOP: pp_nvc_pop(); break; default: if (cond_stack.count == 0 || ATOP(cond_stack).result) return token; else { free_token(token, &yylval); break; } } } } nvc-r1.17.1/src/scan.h000066400000000000000000000312251504111170000144260ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _SCAN_H #define _SCAN_H #include "prim.h" typedef struct { ident_t left, right; } ident_pair_t; typedef union { double real; char *str; int64_t i64; ident_t ident; } yylval_t; // Functions shared between VHDL and Verilog scanners typedef enum { SOURCE_VHDL, SOURCE_VERILOG, SOURCE_SDF } hdl_kind_t; typedef int token_t; void input_from_file(const char *file); void input_from_buffer(const char *buf, size_t len, hdl_kind_t hdl); hdl_kind_t source_kind(void); token_t processed_yylex(void); const char *token_str(token_t tok); void free_token(token_t tok, yylval_t *lval); typedef void (*pp_iter_t)(const char *, const char *, void *); void pp_defines_add(const char *name, const char *value); const char *pp_defines_get(const char *name); void pp_defines_iter(pp_iter_t fn, void *ctx); void scan_as_psl(void); void scan_as_vhdl(void); void scan_as_verilog(void); void scan_as_udp(void); void scan_as_sdf(void); void scan_as_sdf_expr(void); // Private interface to Flex scanners void begin_token(char *tok, int length); int get_next_char(char *b, int max_buffer); void reset_vhdl_parser(void); void reset_verilog_parser(void); void reset_sdf_parser(void); #define tEOF 0 #define tLPAREN '(' #define tRPAREN ')' #define tSEMI ';' #define tCOLON ':' #define tCOMMA ',' #define tAT '@' #define tLT '<' #define tGT '>' #define tPLUS '+' #define tMINUS '-' #define tTIMES '*' #define tDOT '.' #define tTICK '\'' #define tEQ '=' #define tAMP '&' #define tLBRACE '{' #define tRBRACE '}' #define tCARET '^' #define tQUESTION '?' #define tBAR '|' #define tLSQUARE '[' #define tRSQUARE ']' #define tOVER '/' #define tHASH '#' #define tTILDE '~' #define tBANG '!' #define tPERCENT '%' #define tID 200 #define tENTITY 201 #define tIS 202 #define tEND 203 #define tGENERIC 204 #define tPORT 205 #define tCONSTANT 206 #define tCOMPONENT 207 #define tCONFIGURATION 208 #define tARCHITECTURE 209 #define tOF 210 #define tBEGIN 211 #define tFOR 212 #define tTYPE 213 #define tTO 214 #define tALL 215 #define tIN 216 #define tOUT 217 #define tBUFFER 218 #define tBUS 219 #define tUNAFFECTED 220 #define tSIGNAL 221 #define tDOWNTO 222 #define tPROCESS 223 #define tPOSTPONED 224 #define tWAIT 225 #define tREPORT 226 #define tWALRUS 227 #define tINT 228 #define tSTRING 229 #define tERROR 230 #define tINOUT 231 #define tLINKAGE 232 #define tVARIABLE 233 #define tIF 234 #define tRANGE 235 #define tSUBTYPE 236 #define tUNITS 237 #define tPACKAGE 238 #define tLIBRARY 239 #define tUSE 240 #define tNULL 241 #define tFUNCTION 242 #define tIMPURE 243 #define tRETURN 244 #define tPURE 245 #define tARRAY 246 #define tBOX 247 #define tASSOC 248 #define tOTHERS 249 #define tASSERT 250 #define tSEVERITY 251 #define tON 252 #define tMAP 253 #define tTHEN 254 #define tELSE 255 #define tELSIF 256 #define tBODY 257 #define tWHILE 258 #define tLOOP 259 #define tAFTER 260 #define tALIAS 261 #define tATTRIBUTE 262 #define tPROCEDURE 263 #define tEXIT 264 #define tNEXT 265 #define tWHEN 266 #define tCASE 267 #define tLABEL 268 #define tGROUP 269 #define tLITERAL 270 #define tINERTIAL 271 #define tTRANSPORT 272 #define tREJECT 273 #define tBITSTRING 274 #define tBLOCK 275 #define tWITH 276 #define tSELECT 277 #define tGENERATE 278 #define tACCESS 279 #define tFILE 280 #define tOPEN 281 #define tREAL 282 #define tUNTIL 283 #define tRECORD 284 #define tNEW 285 #define tSHARED 286 #define tAND 287 #define tOR 288 #define tNAND 289 #define tNOR 290 #define tXOR 291 #define tXNOR 292 #define tNEQ 293 #define tLE 294 #define tGE 295 #define tPOWER 296 #define tSLL 297 #define tSRL 298 #define tSLA 299 #define tSRA 300 #define tROL 301 #define tROR 302 #define tMOD 303 #define tREM 304 #define tABS 305 #define tNOT 306 #define tGUARDED 307 #define tREVRANGE 308 #define tPROTECTED 309 #define tCONTEXT 310 #define tCONDIF 311 #define tCONDELSE 312 #define tCONDELSIF 313 #define tCONDEND 314 #define tCONDERROR 315 #define tCONDWARN 316 #define tSYNTHOFF 317 #define tSYNTHON 318 #define tMEQ 319 #define tMNEQ 320 #define tMLT 321 #define tMLE 322 #define tMGT 323 #define tMGE 324 #define tREGISTER 325 #define tDISCONNECT 326 #define tCCONV 327 #define tLTLT 328 #define tGTGT 329 #define tFORCE 330 #define tRELEASE 331 #define tPARAMETER 332 #define tCOVERAGEON 333 #define tCOVERAGEOFF 334 #define tSTARTPSL 335 #define tALWAYS 336 #define tIFIMPL 337 #define tIFFIMPL 338 #define tDEFAULT 339 #define tCLOCK 340 #define tNEXT1 341 #define tNEVER 342 #define tEVENTUALLY 343 #define tNEXTA 344 #define tNEXTA1 345 #define tNEXTE 346 #define tNEXTE1 347 #define tNEXTEVENT 348 #define tNEXTEVENT1 349 #define tMODULE 350 #define tENDMODULE 351 #define tINPUT 352 #define tOUTPUT 353 #define tREG 354 #define tPOSEDGE 355 #define tNEGEDGE 356 #define tINITIAL 357 #define tWIRE 358 #define tUNSIGNED 359 #define tASSUME 360 #define tASSUMEG 361 #define tRESTRICT 362 #define tRESTRICTG 363 #define tSTRONG 364 #define tFAIRNESS 365 #define tCOVER 366 #define tPROPERTY 367 #define tSEQUENCE 368 #define tCONST 369 #define tMUTABLE 370 #define tHDLTYPE 371 #define tBOOLEAN 372 #define tBIT 373 #define tBITVECTOR 374 #define tNUMERIC 375 #define tSTRINGK 376 #define tTIMESRPT 377 #define tPLUSRPT 378 #define tGOTORPT 379 #define tEQRPT 380 #define tDBLAMP 381 #define tWITHIN 382 #define tSYSTASK 383 #define tVIEW 384 #define tPRIVATE 385 #define tPREV 386 #define tSTABLE 387 #define tROSE 388 #define tFELL 389 #define tENDED 390 #define tNONDET 391 #define tNONDETV 392 #define tUNION 393 #define tTRANSLATEON 394 #define tTRANSLATEOFF 395 #define tUNTIL1 396 #define tUNTIL_ 397 #define tUNTIL1_ 398 #define tTIMESCALE 399 #define tSUPPLY0 400 #define tSUPPLY1 401 #define tPULLDOWN 402 #define tPULLUP 403 #define tCASEEQ 404 #define tCASENEQ 405 #define tLOGEQ 406 #define tLOGNEQ 407 #define tATTRBEGIN 408 #define tATTREND 409 #define tNUMBER 410 #define tFOREVER 411 #define t2LSQUARE 412 #define t2RSQUARE 413 #define tSPECIFY 414 #define tENDSPECIFY 415 #define tPRIMITIVE 416 #define tENDPRIMITIVE 417 #define tTABLE 418 #define tENDTABLE 419 #define tASSIGN 420 #define tUDPLEVEL 421 #define tUDPEDGE 422 #define tUDPIND 423 #define tBUF 424 #define tLOGOR 425 #define tSCALARZERO 426 #define tSCALARONE 427 #define tDELAYFILE 428 #define tSDFVERSION 429 #define tDESIGN 430 #define tDATE 431 #define tVENDOR 432 #define tPROGRAM 433 #define tVERSION 434 #define tDIVIDER 435 #define tVOLTAGE 436 #define tTEMPERATURE 437 #define tCELL 438 #define tCELLTYPE 439 #define tINSTANCE 440 #define tDELAY 441 #define tTIMINGCHECK 442 #define tTIMINGENV 443 #define tPATHPULSE 444 #define tPATHPULSEP 445 #define tIOPATH 446 #define tRETAIN 447 #define tSDFCOND 448 #define tSDFCONDELSE 449 #define tINTERCONNECT 450 #define tNETDELAY 451 #define tDEVICE 452 #define tSETUP 453 #define tHOLD 454 #define tSETUPHOLD 455 #define tRECOVERY 456 #define tREMOVAL 457 #define tRECREM 458 #define tSKEW 459 #define tBIDIRSKEW 460 #define tWIDTH 461 #define tPERIOD 462 #define tNOCHANGE 463 #define tCOND 464 #define tSCOND 465 #define tCCOND 466 #define tPATHCONSTR 467 #define tPERIODCONSTR 468 #define tSUM 469 #define tDIFF 470 #define tSKEWCONSTR 471 #define tEXCEPTION 472 #define tNAME 473 #define tARRIVAL 474 #define tDEPARTURE 475 #define tSLACK 476 #define tWAVEFORM 477 #define tINCREMENT 478 #define tABSOLUTE 479 #define tTILDEAMP 480 #define tTILDEBAR 481 #define tTILDECARET 482 #define tSTRUCT 483 #define tPACKED 484 #define tVOID 485 #define tBYTE 486 #define tSHORTINT 487 #define tLONGINT 488 #define tSVINT 489 #define tINTEGER 490 #define tTIME 491 #define tTYPEDEF 492 #define tLOGIC 493 #define tENUM 494 #define tTAGGED 495 #define tABORT 496 #define tSYNC_ABORT 497 #define tASYNC_ABORT 498 #define tBEFORE 499 #define tBEFORE1 500 #define tBEFORE_ 501 #define tBEFORE1_ 502 #define tSUFFIXOVR 503 #define tSUFFIXNON 504 #define tPSLNEXT 505 #define tINF 506 #define tREPEAT 507 #define tDO 508 #define tENDPOINT 509 #define tSHIFTLL 510 #define tSHIFTRL 511 #define tSHIFTLA 512 #define tSHIFTRA 513 #define tTASK 514 #define tENDTASK 515 #define tENDFUNCTION 516 #define tBEGINKEYWORDS 517 #define tENDKEYWORDS 518 #define tSVREAL 519 #define tSHORTREAL 520 #define tREALTIME 521 #define tNVCPUSH 522 #define tNVCPOP 523 #define tPLUSPLUS 524 #define tMINUSMINUS 525 #define tVAR 526 #define tDEFNETTYPE 527 #define tTRI 528 #define tTRI0 529 #define tTRI1 530 #define tWAND 531 #define tTRIAND 532 #define tWOR 533 #define tTRIOR 534 #define tTRIREG 535 #define tUWIRE 536 #define tNONE 537 #define tLOCALPARAM 538 #define tALWAYSCOMB 539 #define tALWAYSFF 540 #define tALWAYSLATCH 541 #define tPARENSTAR 542 #define tENDCASE 543 #define tCASEX 544 #define tCASEZ 545 #define tIFNONE 546 #define tEDGE 547 #define tTIMESGT 548 #define tDLRSETUP 549 #define tDLRHOLD 550 #define tDLRRECOVERY 551 #define tDLRREMOVAL 552 #define tDLRSETUPHOLD 553 #define tDLRRECREM 554 #define tDLRWIDTH 555 #define tINDEXPOS 556 #define tINDEXNEG 557 #define tENDGENERATE 558 #define tRESETALL 559 #define tEVENT 560 #define tTRPLAMP 561 #define tSPECPARAM 562 #define tFORK 563 #define tJOIN 564 #define tAUTOMATIC 565 #define tGENVAR 566 #define tHIGHZ0 567 #define tHIGHZ1 568 #define tSTRONG0 569 #define tSTRONG1 570 #define tPULL0 571 #define tPULL1 572 #define tWEAK0 573 #define tWEAK1 574 #define tSMALL 575 #define tMEDIUM 576 #define tLARGE 577 #define tVECTORED 578 #define tSCALARED 579 #endif // _SCAN_H nvc-r1.17.1/src/sdf/000077500000000000000000000000001504111170000141025ustar00rootroot00000000000000nvc-r1.17.1/src/sdf/Makemodule.am000066400000000000000000000001621504111170000165030ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/sdf/sdf-phase.h \ src/sdf/sdf-parse.c \ src/sdf/sdf-util.h \ src/sdf/sdf-util.c nvc-r1.17.1/src/sdf/sdf-parse.c000066400000000000000000001500301504111170000161310ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "ident.h" #include "scan.h" #include "sdf/sdf-phase.h" #include "sdf/sdf-util.h" #include #include #include #include #include // Lexer symbols extern yylval_t yylval; extern loc_t yylloc; // Global state, currently parsed file static sdf_file_t *sdf_file = NULL; /////////////////////////////////////////////////////////////////////////////// // TODO: The common parser functions and macros are copy-paste from VLOG parser. // This could be refactored for one universal parser type. /////////////////////////////////////////////////////////////////////////////// #define RECOVER_THRESH 5 #define TRACE_PARSE 0 #define TRACE_RECOVERY 0 #define TOKENQ_SIZE 8 typedef struct { token_t token; yylval_t lval; loc_t loc; } tokenq_t; typedef struct { loc_t start_loc; loc_t last_loc; const char *hint_str; int n_correct; tokenq_t tokenq[TOKENQ_SIZE]; int tokenq_head; int tokenq_tail; yylval_t last_lval; token_t opt_hist[8]; int nopt_hist; #if TRACE_PARSE int depth; #endif } parse_state_t; typedef struct { const char *old_hint; loc_t old_start_loc; } rule_state_t; static parse_state_t state; #define scan(...) _scan(1, __VA_ARGS__, -1) #define expect(...) _expect(1, __VA_ARGS__, -1) #define one_of(...) _one_of(1, __VA_ARGS__, -1) #define not_at_token(...) ((peek() != tEOF) && !_scan(1, __VA_ARGS__, -1)) #define peek() peek_nth(1) #define parse_error(loc, ...) do { \ if (state.n_correct >= RECOVER_THRESH) \ error_at((loc), __VA_ARGS__); \ } while (0) #if TRACE_PARSE static void _push_state(const rule_state_t *s); #else #define _push_state(s) #endif #define EXTEND(s) \ __attribute__((cleanup(_pop_state), unused)) \ const rule_state_t _state = { state.hint_str, state.start_loc }; \ state.hint_str = s; \ _push_state(&_state); #define BEGIN(s) \ EXTEND(s); \ state.start_loc = LOC_INVALID; \ static inline void _pop_state(const rule_state_t *r) { #if TRACE_PARSE printf("%*s<-- %s\n", state.depth--, "", state.hint_str); #endif state.hint_str = r->old_hint; if (r->old_start_loc.first_line != LINE_INVALID) state.start_loc = r->old_start_loc; } #if TRACE_PARSE static inline void _push_state(const rule_state_t *r) { printf("%*s--> %s\n", state.depth++, "", state.hint_str); } #endif static token_t peek_nth(int n) { while (((state.tokenq_head - state.tokenq_tail) & (TOKENQ_SIZE - 1)) < n) { const token_t token = processed_yylex(); int next = (state.tokenq_head + 1) & (TOKENQ_SIZE - 1); assert(next != state.tokenq_tail); extern yylval_t yylval; state.tokenq[state.tokenq_head].token = token; state.tokenq[state.tokenq_head].lval = yylval; state.tokenq[state.tokenq_head].loc = yylloc; state.tokenq_head = next; } const int pos = (state.tokenq_tail + n - 1) & (TOKENQ_SIZE - 1); return state.tokenq[pos].token; } static void drop_token(void) { assert(state.tokenq_head != state.tokenq_tail); if (state.start_loc.first_line == LINE_INVALID) state.start_loc = state.tokenq[state.tokenq_tail].loc; state.last_lval = state.tokenq[state.tokenq_tail].lval; state.last_loc = state.tokenq[state.tokenq_tail].loc; state.tokenq_tail = (state.tokenq_tail + 1) & (TOKENQ_SIZE - 1); state.nopt_hist = 0; } static void _vexpect(va_list ap) { if (state.n_correct >= RECOVER_THRESH) { diag_t *d = diag_new(DIAG_ERROR, &(state.tokenq[state.tokenq_tail].loc)); diag_printf(d, "unexpected $yellow$%s$$ while parsing %s, expecting ", token_str(peek()), state.hint_str); bool first = true; for (int i = 0; i < state.nopt_hist; i++) { diag_printf(d, "%s$yellow$%s$$", i == 0 ? "one of " : ", ", token_str(state.opt_hist[i])); first = false; } int tok = va_arg(ap, int); while (tok != -1) { const int tmp = tok; tok = va_arg(ap, int); if (first && (tok != -1)) diag_printf(d, "one of "); else if (!first) diag_printf(d, (tok == -1) ? " or " : ", "); diag_printf(d, "$yellow$%s$$", token_str(tmp)); first = false; } diag_hint(d, &(state.tokenq[state.tokenq_tail].loc), "this token was unexpected"); diag_emit(d); } state.n_correct = 0; drop_token(); } static void _expect(int dummy, ...) { va_list ap; va_start(ap, dummy); _vexpect(ap); va_end(ap); } static bool consume(token_t tok) { const token_t got = peek(); if (tok != got) { expect(tok); return false; } else { state.n_correct++; drop_token(); return true; } } static bool optional(token_t tok) { if (peek() == tok) { consume(tok); return true; } else { if (state.nopt_hist < ARRAY_LEN(state.opt_hist)) state.opt_hist[state.nopt_hist++] = tok; return false; } } static bool _scan(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); return found; } static int _one_of(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); if (found) { consume(p); return p; } else { va_start(ap, dummy); _vexpect(ap); va_end(ap); return -1; } } static ident_t error_marker(void) { return well_known(W_ERROR); } /////////////////////////////////////////////////////////////////////////////// // VLOG copy-paste ends here! /////////////////////////////////////////////////////////////////////////////// #define PARSE_MIN_DELAYS (!!(sdf_file->min_max_spec & S_F_MIN_VALUES)) #define PARSE_TYP_DELAYS (!!(sdf_file->min_max_spec & S_F_TYP_VALUES)) #define PARSE_MAX_DELAYS (!!(sdf_file->min_max_spec & S_F_MAX_VALUES)) static inline bool is_next_tok_signed_number(void) { return scan(tINT, tREAL, tPLUS, tMINUS); } #define EPSILON 0.0000000000001 static bool doubles_equal(double a, double b) { if (fabs(a - b) < EPSILON) return true; return false; } static ident_t p_identifier(void) { // identifier ::= // character { character } BEGIN("identifier"); ident_t id; if (consume(tID)) { id = ident_new(state.last_lval.str); free(state.last_lval.str); } else id = error_marker(); return id; } static ident_t p_qstring(void) { // qstring ::= // " { any_character } " BEGIN("qstring"); // qstring identifier is stored including the surrounding // apostrophes. consume(tSTRING); ident_t str = ident_new(state.last_lval.str); free(state.last_lval.str); return str; } static ident_t p_hierarchical_identifier(void) { // hierarchical_identifier ::= // identifier { hchar identifier } BEGIN("hierarchical identifier"); scan_as_sdf_expr(); ident_t id = p_identifier(); // Hierarchical identifier is purposefully converted to '.' separator. // This-way, "ident_walk_selected" can be used to walk the hierarchy. // To dump the identifier, dumper walks the ID and replaces '.' by // actual hierarchy separator to get to the original source! while (scan(tDOT, tOVER)) { int tok = peek(); consume(tok); if (tok != sdf_file->hchar) warn_at(&state.last_loc, "Used hierarchy separator: %c " "but hierarchy separator defined in SDF header is: %c", tok, sdf_file->hchar); id = ident_prefix(id, p_identifier(), '.'); } scan_as_sdf(); return id; } static int64_t p_integer(void) { // integer ::= // decimal_digit { decimal_digit } BEGIN("integer") consume(tINT); return yylval.i64; } static double p_real_number(void) { // real_number ::= // integer // | integer [ . integer ] // | integer [ . integer ] e [ sign ] integer BEGIN("real number"); switch (one_of(tINT, tREAL)) { case tINT: return (double)yylval.i64; case tREAL: return yylval.real; default: return 0.0; } } static double p_signed_real_number(void) { // signed_real_number ::= // [ sign ] real_number BEGIN("signed real number"); switch (peek()) { case tMINUS: consume(tMINUS); return -p_real_number(); case tPLUS: consume(tPLUS); // Fall-through default: return p_real_number(); } } static void p_scalar_constant(void) { // scalar_constant ::= // 0 // logical zero // | 'b0 // | 'B0 // | 1'b0 // | 1'B0 // | 1 // logical one // | 'b1 // | 'B1 // | 1'b1 // | 1'B1 BEGIN("scalar constant"); int64_t val = 0; switch (one_of(tINT, tSCALARZERO, tSCALARONE)) { case tINT: val = yylval.i64; if (val != 1 && val != 0) parse_error(&state.last_loc, "scalar_constant shall be one of: " "1'b0, 1'B0, 'b0, 'B0, 0, " "1'b1, 1'B1, 'b1, 'B1, 1"); break; case tSCALARONE: val = 1; break; case tSCALARZERO: val = 0; break; } } static void p_scalar_node(void) { // scalar_node ::= // scalar_port // | scalar_net // scalar_port ::= // hierarchical_identifier // | hierarchical_identifier [ integer ] // scalar_net ::= // hierarchical_identifier // | hierarchical_identifier [ integer ] BEGIN("scalar node"); p_hierarchical_identifier(); if (optional(tLSQUARE)) { p_integer(); consume(tRSQUARE); } } static void p_port_instance(void) { // port_instance ::= // port // | hierarchical_identifier hchar port // port ::= // scalar_port // | bus_port // scalar_port ::= // hierarchical_identifier // | hierarchical_identifier [ integer ] // bus_port ::= // hierarchical_identifier [ integer : integer ] // hierarchical_identifier ::= // identifier { hchar identifier } // // Note: // "port_instance" is equivalent to "port" because "hierarchical_identifier hchar port" // production can completeyl dervied from "port" by: // port -> scalar_port -> hierarchical_identifier -> identifier { hchar identifier } // // Therefore "hierarchical_identifier hchar port" is givan as: // <----hierarchical_identifier----> <--port--> // {identifier { hchar identifier }} hchar identifier BEGIN("port instance"); p_hierarchical_identifier(); if (optional(tLSQUARE)) { p_integer(); if (optional(tCOLON)) p_integer(); consume(tRSQUARE); } } static void p_port_or_scalar_constant(void) { if (scan(tINT, tSCALARONE, tSCALARZERO)) return p_scalar_constant(); return p_port_instance(); } static void p_port_edge(void) { // port_edge ::= // ( edge_identifier port_instance ) BEGIN("port edge"); consume(tLPAREN); // TODO: Implement other edge identifier types! one_of(tPOSEDGE, tNEGEDGE); p_port_instance(); consume(tRPAREN); } static void p_port_spec(void) { // port_spec ::= // port_instance // | port_edge BEGIN("port spec"); if (scan(tLPAREN)) return p_port_edge(); return p_port_instance(); } static inline sdf_binary_expr_kind_t p_binary_operator_optional(void) { // binary_operator ::= // + // arithmetic sum // | - // arithmetic difference // | * // arithmetic product // | / // arithmetic quotient // | % // modulus // | == // logical equality // | != // logical inequality // | === // case equality // | !== // case inequality // | && // logical AND // | || // logical OR // | < // relational // | <= // relational // | > // relational // | >= // relational // | & // bit-wise binary AND // | | // bit-wise binary inclusive OR // | ^ // bit-wise binary exclusive OR // | ^~ // bit-wise binary equivalence // | ~^ // bit-wise binary equivalence (alternative) // | >> // right shift // | << // left shift BEGIN("binary operator") sdf_binary_expr_kind_t rv = S_BINARY_EXPR_NONE; int tok = peek(); switch (tok) { case tPLUS: rv = S_BINARY_EXPR_PLUS; break; case tMINUS: rv = S_BINARY_EXPR_MINUS; break; case tTIMES: rv = S_BINARY_EXPR_MULT; break; case tOVER: rv = S_BINARY_EXPR_DIV; break; case tLOGEQ: rv = S_BINARY_EXPR_LOGEQ; break; case tLOGNEQ: rv = S_BINARY_EXPR_LOGNEQ; break; case tCASEEQ: rv = S_BINARY_EXPR_CASEEQ; break; case tCASENEQ: rv = S_BINARY_EXPR_CASENEQ; break; case tDBLAMP: rv = S_BINARY_EXPR_LOGAND; break; case tLOGOR: rv = S_BINARY_EXPR_LOGOR; break; case tLT: rv = S_BINARY_EXPR_LT; break; case tGT: rv = S_BINARY_EXPR_GT; break; case tLE: rv = S_BINARY_EXPR_LTEQ; break; case tGE: rv = S_BINARY_EXPR_GTEQ; break; case tAMP: rv = S_BINARY_EXPR_BITAND; break; case tBAR: rv = S_BINARY_EXPR_BITOR; break; case tCARET: rv = S_BINARY_EXPR_BITXOR; break; case tPERCENT: rv = S_BINARY_EXPR_MOD; break; case tTILDECARET: rv = S_BINARY_EXPR_BITXNOR; break; case tLTLT: rv = S_BINARY_EXPR_SHLEFT; break; case tGTGT: rv = S_BINARY_EXPR_SHRIGHT; break; } if (rv != S_BINARY_EXPR_NONE) consume(tok); return rv; } static sdf_unary_expr_kind_t p_unary_operator_optional(void) { // unary_operator ::= // + // arithmetic identity // | - // arithmetic negation // | ! // logical negation // | ~ // bit-wise unary negation // | & // reduction unary AND // | ~& // reduction unary NAND // | | // reduction unary OR // | ~| // reduction unary NOR // | ^ // reduction unary XOR // | ^~ // reduction unary XNOR // | ~^ // reduction unary XNOR (alternative) BEGIN("unary operator"); sdf_unary_expr_kind_t rv = S_UNARY_EXPR_NONE; int tok = peek(); switch (tok) { case tPLUS: rv = S_UNARY_EXPR_PLUS; break; case tMINUS: rv = S_UNARY_EXPR_MINUS; break; case tBANG: rv = S_UNARY_EXPR_LOGNOT; break; case tTILDE: rv = S_UNARY_EXPR_BITNOT; break; case tCARET: rv = S_UNARY_EXPR_XOR; break; case tBAR: rv = S_UNARY_EXPR_OR; break; case tAMP: rv = S_UNARY_EXPR_AND; break; case tTILDEAMP: rv = S_UNARY_EXPR_NAND; break; case tTILDEBAR: rv = S_UNARY_EXPR_NOR; break; case tTILDECARET: rv = S_UNARY_EXPR_XNOR; break; } if (rv != S_UNARY_EXPR_NONE) consume(tok); return rv; } static void p_simple_expression(void) { // simple_expression ::= // ( simple_expression ) // | unary_operator ( simple_expression ) // | port // | unary_operator port // | scalar_constant // | unary_operator scalar_constant // | simple_expression ? simple_expression : simple_expression // | { simple_expression [ concat_expression ] } // | { simple_expression { simple_expression [ concat_expression ] } } BEGIN("simple expression"); if (optional(tLPAREN)) { p_simple_expression(); consume(tRPAREN); return; } // unary_operator sdf_unary_expr_kind_t unary_kind = S_UNARY_EXPR_NONE; if ((unary_kind = p_unary_operator_optional()) != S_UNARY_EXPR_NONE) { if (optional(tLPAREN)) { p_simple_expression(); consume(tRPAREN); } else p_port_or_scalar_constant(); return; } // simple_expression if (optional(tLBRACE)) { p_simple_expression(); while (optional(tCOMMA)) p_simple_expression(); if (optional(tRBRACE)) { p_simple_expression(); while (optional(tCOMMA)) p_simple_expression(); consume(tRBRACE); } consume(tRBRACE); } p_port_or_scalar_constant(); // simple_expression ? simple_expression : simple_expression if (optional(tQUESTION)) { p_simple_expression(); consume(tCOLON); p_simple_expression(); } } static void p_conditional_port_expr(void) { // conditional_port_expr ::= // simple_expression // | ( conditional_port_expr ) // | unary_operator ( conditional_port_expr ) // | conditional_port_expr binary_operator conditional_port_expr BEGIN("conditional port expression"); sdf_unary_expr_kind_t unary_kind = S_UNARY_EXPR_NONE; if (optional(tLPAREN)) { p_conditional_port_expr(); consume(tRPAREN); } // unary_operator else if ((unary_kind = p_unary_operator_optional()) != S_UNARY_EXPR_NONE) { p_conditional_port_expr(); } // When we consume unary expression and open parenthesis, we get only to // "conditional_port_expr" and "simple_expression". // "conditional port_expr" is taken care-of by recursion, // only "simple_expression" remain else p_simple_expression(); // binary_operator sdf_binary_expr_kind_t binary_kind = S_BINARY_EXPR_NONE; if ((binary_kind = p_binary_operator_optional()) != S_BINARY_EXPR_NONE) { p_conditional_port_expr(); } } static void p_timing_check_condition(void) { // timing_check_condition ::= // scalar_node // | inversion_operator scalar_node // | scalar_node equality_operator scalar_constant BEGIN("timing check condition"); // inversion_operator if (scan(tBANG, tTILDE)) { int tok = peek(); consume(tok); p_scalar_node(); return; } p_scalar_node(); // equality_operator if (scan(tLOGEQ, tLOGNEQ, tCASEEQ, tCASENEQ)) { int tok = peek(); consume(tok); p_scalar_constant(); } } static void p_neg_pair(void) { // neg_pair ::= // ( negedge signed_real_number [ signed_real_number ] ) // ( posedge signed_real_number [ signed_real_number ] ) BEGIN("neg pair"); consume (tLPAREN); consume (tNEGEDGE); p_signed_real_number(); if (is_next_tok_signed_number()) p_signed_real_number(); consume (tRPAREN); consume (tLPAREN); consume (tPOSEDGE); p_signed_real_number(); if (is_next_tok_signed_number()) p_signed_real_number(); consume (tRPAREN); } static void p_pos_pair(void) { // pos_pair ::= // ( posedge signed_real_number [ signed_real_number ] ) // ( negedge signed_real_number [ signed_real_number ] ) BEGIN("pos pair"); consume (tLPAREN); consume (tPOSEDGE); p_signed_real_number(); if (is_next_tok_signed_number()) p_signed_real_number(); consume (tRPAREN); consume (tLPAREN); consume (tNEGEDGE); p_signed_real_number(); if (is_next_tok_signed_number()) p_signed_real_number(); consume (tRPAREN); } static void p_edge_list(void) { // edge_list ::= // pos_pair { pos_pair } // | neg_pair { neg_pair } BEGIN("edge list") p_pos_pair(); while (peek_nth(2) == tPOSEDGE) p_pos_pair(); p_neg_pair(); while (peek_nth(2) == tNEGEDGE) p_neg_pair(); } static ident_t p_cell_instance(void) { // cell_instance ::= // ( INSTANCE [ hierarchical_identifier ] ) // | ( INSTANCE * ) BEGIN("cell instance"); consume(tLPAREN); consume(tINSTANCE); ident_t hier = NULL; if (scan(tTIMES, tID)) { if (optional(tTIMES)) hier = ident_new("*"); else hier = p_hierarchical_identifier(); } consume(tRPAREN); return hier; } static void p_real_number_or_tripple(void) { // real_number ::= // integer // | integer [ . integer ] // | integer [ . integer ] e [ sign ] integer // triple ::= // real_number : [ real_number ] : [ real_number ] // | [ real_number ] : real_number : [ real_number ] // | [ real_number ] : [ real_number ] : real_number // If parsing tripple one following scenarios can occur: // : // (tINT|tREAL): // // Detect if parsing tripple or only real_number bool is_tripple = false; if (scan(tCOLON) || peek_nth(2) == tCOLON) is_tripple = true; if (is_tripple) { bool number_present = false; if (not_at_token(tCOLON)) { p_real_number(); number_present = true; } consume(tCOLON); if (not_at_token(tCOLON)) { p_real_number(); number_present = true; } consume(tCOLON); if (not_at_token(tRPAREN)) { p_real_number(); number_present = true; } if (!number_present) parse_error(&state.last_loc, "'tripple' shall have at least one number specified"); return; } p_real_number(); } static void p_value(void) { // value ::= // ( [ real_number ] ) // | ( [triple] ) BEGIN("value"); consume(tLPAREN); if (not_at_token(tRPAREN)) p_real_number_or_tripple(); consume(tRPAREN); } static void p_signed_real_number_or_rtripple(void) { // signed_real_number ::= // [ sign ] real_number // rtriple ::= // signed_real_number : [ signed_real_number ] : [ signed_real_number ] // | [ signed_real_number ] : signed_real_number : [ signed_real_number ] // | [ signed_real_number ] : [ signed_real_number ] : signed_real_number // If parsing rtripple one following scenarios can occur: // : // (tINT|tREAL): // (tPLUS|tMINUS)(tINT|tREAL): // // Detect if parsing rtripple or only signed_real_number bool is_rtripple = false; if (scan(tCOLON) || peek_nth(2) == tCOLON || peek_nth(3) == tCOLON) is_rtripple = true; if (is_rtripple) { bool number_present = false; if (not_at_token(tCOLON)) { p_signed_real_number(); number_present = true; } consume(tCOLON); if (not_at_token(tCOLON)) { p_signed_real_number(); number_present = true; } consume(tCOLON); if (not_at_token(tRPAREN)) { p_signed_real_number(); number_present = true; } if (!number_present) parse_error(&state.last_loc, "'rtripple' shall have at least one number specified"); return; } p_signed_real_number(); } static void p_rvalue(void) { // rvalue ::= // ( [ signed_real_number ] ) // | ( [ rtriple ] ) BEGIN("rvalue"); consume(tLPAREN); if (not_at_token(tRPAREN)) p_signed_real_number_or_rtripple(); consume(tRPAREN); } static void p_name(void) { // name ::= // ( NAME [ qstring ] ) BEGIN("name"); consume(tLPAREN); consume(tNAME); if (scan(tSTRING)) p_qstring(); consume(tRPAREN); } static void p_path_constraint(void) { // path_constraint ::= // ( PATHCONSTRAINT [ name ] port_instance port_instance { port_instance } // rvalue rvalue ) BEGIN("path constraint"); consume(tLPAREN); consume(tPATHCONSTR); if (peek_nth(2) == tNAME) p_name(); p_port_instance(); p_port_instance(); while (scan(tID)) p_port_instance(); p_rvalue(); p_rvalue(); consume(tRPAREN); } static void p_exception(void) { // exception ::= // ( EXCEPTION cell_instance { cell_instance } ) BEGIN("exception"); consume(tLPAREN); consume(tEXCEPTION); p_cell_instance(); while (peek_nth(2) == tINSTANCE) p_cell_instance(); consume(tRPAREN); } static void p_period_constraint(void) { // period_constraint ::= // ( PERIODCONSTRAINT port_instance value [ exception ] ) BEGIN("period constraint"); consume(tLPAREN); consume(tPERIODCONSTR); p_port_instance(); p_value(); if (peek_nth(2) == tEXCEPTION) p_exception(); consume(tRPAREN); } static void p_constraint_path(void) { // constraint_path ::= // ( port_instance port_instance ) BEGIN("constraint path"); consume(tLPAREN); p_port_instance(); p_port_instance(); consume(tRPAREN); } static void p_sum_constraint(void) { // sum_constraint ::= // ( SUM constraint_path constraint_path { constraint_path } rvalue [ rvalue ] ) BEGIN("sum constraint"); consume(tLPAREN); consume(tSUM); p_constraint_path(); p_constraint_path(); // Both next follow-up tokens start with tLPAREN. // Decide based on second next token while (peek_nth(2) == tID) p_constraint_path(); p_rvalue(); if (scan(tLPAREN)) p_rvalue(); consume(tRPAREN); } static void p_diff_constraint(void) { // diff_constraint ::= // ( DIFF constraint_path constraint_path value [ value ] ) BEGIN("diff constraint"); consume(tLPAREN); consume(tDIFF); p_constraint_path(); p_constraint_path(); p_value(); if (scan(tLPAREN)) p_value(); consume(tRPAREN); } static void p_skew_constraint(void) { // skew_constraint ::= // ( SKEWCONSTRAINT port_spec value ) BEGIN("skew constraint"); consume(tLPAREN); consume(tSKEWCONSTR); p_port_spec(); p_value(); consume(tRPAREN); } static void p_arrival_env(void) { // arrival_env ::= // ( ARRIVAL [ port_edge ] port_instance rvalue rvalue rvalue rvalue ) BEGIN("arrival env"); consume(tLPAREN); consume(tARRIVAL); if (scan(tLPAREN)) p_port_edge(); p_port_instance(); for (int i = 0; i < 4; i++) p_rvalue(); consume(tRPAREN); } static void p_departure_env(void) { // departure_env ::= // ( DEPARTURE [ port_edge ] port_instance rvalue rvalue rvalue rvalue ) BEGIN("departure env"); consume(tLPAREN); consume(tDEPARTURE); if (scan(tLPAREN)) p_port_edge(); p_port_instance(); for (int i = 0; i < 4; i++) p_rvalue(); consume(tRPAREN); } static void p_slack_env(void) { // slack_env ::= // ( SLACK port_instance rvalue rvalue rvalue rvalue [ real_number ] ) BEGIN("slack env"); consume(tLPAREN); consume(tSLACK); p_port_instance(); for (int i = 0; i < 4; i++) p_rvalue(); if (scan(tREAL, tINT)) p_real_number(); consume(tRPAREN); } static void p_waveform_env(void) { // waveform_env ::= // ( WAVEFORM port_instance real_number edge_list ) BEGIN("waveform env"); consume(tLPAREN); consume(tWAVEFORM); p_port_instance(); p_real_number(); // sdf_value of S_TENV_KIND_WAVEFORM // 0 - real_number // 1 - X - Edge pairs p_edge_list(); consume(tRPAREN); } static void p_te_spec(void) { // te_spec ::= // ( TIMINGENV te_def { te_def } ) BEGIN("te spec"); consume(tLPAREN); consume(tTIMINGENV); do { switch (peek_nth(2)) { case tPATHCONSTR: p_path_constraint(); break; case tPERIODCONSTR: p_period_constraint(); break; case tSUM: p_sum_constraint(); break; case tDIFF: p_diff_constraint(); break; case tSKEWCONSTR: p_skew_constraint(); break; case tARRIVAL: p_arrival_env(); break; case tDEPARTURE: p_departure_env(); break; case tSLACK: p_slack_env(); break; case tWAVEFORM: p_waveform_env(); break; default: consume(tLPAREN); one_of(tPATHCONSTR, tPERIODCONSTR, tSUM, tDIFF, tSKEWCONSTR, tARRIVAL, tDEPARTURE, tSLACK, tWAVEFORM); } } while (scan(tLPAREN)); consume(tRPAREN); } static void p_delval(void) { // delval ::= // rvalue // | ( rvalue rvalue ) // | ( rvalue rvalue rvalue ) BEGIN("delval"); // Multiple rvalues in delval if (peek_nth(2) == tLPAREN) { consume(tLPAREN); if (scan(tLPAREN)) p_rvalue(); if (scan(tLPAREN)) p_rvalue(); if (scan(tLPAREN)) p_rvalue(); consume(tRPAREN); } // Single rvalue in delval else p_rvalue(); } static void p_delval_list(void) { // delval_list ::= // delval // | delval delval // | delval delval delval // | delval delval delval delval [ delval ] [ delval ] // | delval delval delval delval delval delval delval // [ delval ] [ delval ] [ delval ] [ delval ] [ delval ] BEGIN("delval list"); while (scan(tLPAREN)) p_delval(); // if (sdf_values(delay) > 12) // parse_error(&state.last_loc, // "'delval_list' shall have at most 12 'delval' entries"); } static void p_lbl_def(sdf_flags_t flag) { // lbl_def ::= // ( identifier delval_list ) BEGIN("lbl def"); consume(tLPAREN); p_identifier(); // Reuse delay for current label. Delvals are both "value" for these p_delval_list(); consume(tRPAREN); } static void p_lbl_type(void) { // lbl_type ::= // ( INCREMENT lbl_def { lbl_def } ) // | ( ABSOLUTE lbl_def { lbl_def } ) BEGIN("lbl type"); consume(tLPAREN); sdf_flags_t flag; if (one_of(tABSOLUTE, tINCREMENT) == tABSOLUTE) flag = S_F_VALUE_ABSOLUTE; else flag = S_F_VALUE_INCREMENT; while (scan(tLPAREN)) p_lbl_def(flag); consume(tRPAREN); } static void p_lbl_spec(void) { // bl_spec ::= // ( LABEL lbl_type { lbl_type } ) BEGIN("lbl spec"); consume(tLPAREN); consume(tLABEL); do p_lbl_type(); while (scan(tLPAREN)); consume(tRPAREN); } static void p_port_tchk(void) { // port_tchk ::= // port_spec // | ( COND [ qstring ] timing_check_condition port_spec ) BEGIN("port tcheck"); if (peek_nth(2) == tSDFCOND) { consume(tLPAREN); consume(tSDFCOND); if (scan(tSTRING)) p_qstring(); p_timing_check_condition(); p_port_spec(); consume(tRPAREN); return; } return p_port_spec(); } static void p_nochange_timing_check(void) { // nochange_timing_check ::= // ( NOCHANGE port_tchk port_tchk rvalue rvalue ) BEGIN("nochange timing check"); consume(tLPAREN); consume(tNOCHANGE); p_port_tchk(); p_port_tchk(); p_rvalue(); p_rvalue(); consume(tRPAREN); } static void p_bidirectskew_timing_check(void) { // bidirectskew_timing_check ::= // ( BIDIRECTSKEW port_tchk port_tchk value value ) BEGIN("bidirectskew timing check"); consume(tLPAREN); consume(tBIDIRSKEW); p_port_tchk(); p_port_tchk(); p_value(); p_value(); consume(tRPAREN); } static void p_skew_timing_check(void) { // skew_timing_check ::= // ( SKEW port_tchk port_tchk rvalue ) BEGIN("skew timing check"); consume(tLPAREN); consume(tSKEW); p_port_tchk(); p_port_tchk(); p_rvalue(); consume(tRPAREN); } #define DEFINE_1P1V_TCHK(func_name, msg, tok, subkind) \ static void func_name(void) \ { \ /* width_timing_check ::= */ \ /* ( WIDTH port_tchk value ) */ \ /* period_timing_check ::= */ \ /* ( PERIOD port_tchk value ) */ \ \ BEGIN(msg); \ \ consume(tLPAREN); \ consume(tok); \ \ p_port_tchk(); \ p_value(); \ \ consume(tRPAREN); \ } DEFINE_1P1V_TCHK(p_width_timing_check, "width timing check", tWIDTH, S_TCHECK_WIDTH); DEFINE_1P1V_TCHK(p_period_timing_check, "period timing check", tPERIOD, S_TCHECK_PERIOD); static void p_scond_or_ccond(sdf_cond_kind_t kind) { // scond ::= // ( SCOND [ qstring ] timing_check_condition ) // ccond ::= // ( CCOND [ qstring ] timing_check_condition ) BEGIN("scond or ccond"); consume(tLPAREN); if (kind == S_COND_CCOND) consume(tCCOND); else consume(tSCOND); if (scan(tSTRING)) p_qstring(); p_timing_check_condition(); consume(tRPAREN); return; } #define DEFINE_2P2RV_TCHK(func_name, msg, tok, subkind) \ static void func_name(void) \ { \ /* setuphold_timing_check ::= */ \ /* ( SETUPHOLD port_tchk port_tchk rvalue rvalue ) */ \ /* | ( SETUPHOLD port_spec port_spec rvalue rvalue */ \ /* [ scond ] [ ccond ] ) */ \ \ BEGIN(msg); \ \ consume(tLPAREN); \ consume(tok); \ \ bool cond_seen = false; \ if (peek_nth(2) == tSDFCOND) \ cond_seen = true; \ p_port_tchk(); \ \ if (peek_nth(2) == tSDFCOND) \ cond_seen = true; \ p_port_tchk(); \ \ p_rvalue(); \ p_rvalue(); \ \ if (!cond_seen && (peek_nth(2) == tSCOND)) \ p_scond_or_ccond(S_COND_SCOND); \ if (!cond_seen && (peek_nth(2) == tCCOND)) \ p_scond_or_ccond(S_COND_CCOND); \ \ consume(tRPAREN); \ } DEFINE_2P2RV_TCHK(p_setuphold_timing_check, "setuphold timing check", tSETUPHOLD, S_TCHECK_SETUPHOLD); DEFINE_2P2RV_TCHK(p_recrem_timing_check, "recrem timing check", tRECREM, S_TCHECK_RECREM); #define DEFINE_2P1V_TCHK(func_name, msg, tok, subkind) \ static void func_name(void) \ { \ /* setup_timing_check ::= */ \ /* ( SETUP port_tchk port_tchk value ) */ \ /* hold_timing_check ::= */ \ /* ( HOLD port_tchk port_tchk value ) */ \ /* recovery_timing_check ::= */ \ /* ( RECOVERY port_tchk port_tchk value ) */ \ /* removal_timing_check ::= */ \ /* ( REMOVAL port_tchk port_tchk value ) */ \ \ BEGIN(msg); \ \ consume(tLPAREN); \ consume(tok); \ \ p_port_tchk(); \ p_port_tchk(); \ p_value(); \ \ consume(tRPAREN); \ } DEFINE_2P1V_TCHK(p_setup_timing_check, "setup timing check", tSETUP, S_TCHECK_SETUP); DEFINE_2P1V_TCHK(p_hold_timing_check, "hold timing check", tHOLD, S_TCHECK_HOLD); DEFINE_2P1V_TCHK(p_recovery_timing_check, "recovery timing check",tRECOVERY, S_TCHECK_RECOVERY); DEFINE_2P1V_TCHK(p_removal_timing_check, "removal timing check", tREMOVAL, S_TCHECK_REMOVAL); static void p_tc_spec(void) { // tc_spec ::= // ( TIMINGCHECK tchk_def { tchk_def } ) BEGIN("tc spec"); consume(tLPAREN); consume(tTIMINGCHECK); do { switch (peek_nth(2)) { case tSETUP: p_setup_timing_check(); break; case tHOLD: p_hold_timing_check(); break; case tRECOVERY: p_recovery_timing_check(); break; case tREMOVAL: p_removal_timing_check(); break; case tSETUPHOLD: p_setuphold_timing_check(); break; case tRECREM: p_recrem_timing_check(); break; case tWIDTH: p_width_timing_check(); break; case tPERIOD: p_period_timing_check(); break; case tSKEW: p_skew_timing_check(); break; case tBIDIRSKEW: p_bidirectskew_timing_check(); break; case tNOCHANGE: p_nochange_timing_check(); break; default: consume(tLPAREN); one_of(tSETUP, tHOLD, tSETUPHOLD, tRECREM, tWIDTH, tPERIOD, tSKEW, tBIDIRSKEW, tNOCHANGE); }; } while (scan(tLPAREN)); consume(tRPAREN); } static void p_pathpulsepercent_deltype(void) { // pathpulsepercent_deltype ::= // ( PATHPULSEPERCENT [ input_output_path ] value [ value ] ) BEGIN("pathpulsepercent deltype"); consume(tLPAREN); consume(tPATHPULSEP); if (scan(tID)) { p_port_instance(); p_port_instance(); } p_value(); if (scan(tLPAREN)) p_value(); consume(tRPAREN); } static void p_pathpulse_deltype(void) { // pathpulse_deltype ::= // ( PATHPULSE [ input_output_path ] value [ value ] ) BEGIN("pathpulse deltype"); consume(tLPAREN); consume(tPATHPULSE); if (scan(tID)) { p_port_instance(); p_port_instance(); } p_value(); if (scan(tLPAREN)) p_value(); consume(tRPAREN); } static void p_retain_def(void) { // retain_def ::= // ( RETAIN retval_list ) // retval_list ::= // delval // | delval delval // | delval delval delval BEGIN("retain def"); consume(tLPAREN); consume(tRETAIN); while (scan(tLPAREN)) p_delval(); // if (sdf_values(retain) > 3) // parse_error(&state.last_loc, // "'retval_list' shall have at most 3 'delval' entries"); consume(tRPAREN); return; } static void p_iopath_def(void) { // iopath_def ::= // ( IOPATH port_spec port_instance { retain_def } delval_list ) BEGIN("iopath def"); consume(tLPAREN); consume(tIOPATH); p_port_spec(); p_port_instance(); if (peek_nth(2) == tRETAIN) p_retain_def(); p_delval_list(); consume(tRPAREN); } static void p_condelse_def(void) { // condelse_def ::= // ( CONDELSE iopath_def ) BEGIN("condelse def"); consume(tLPAREN); consume(tSDFCONDELSE); p_iopath_def(); consume(tRPAREN); } static void p_cond_def(void) { // cond_def ::= // ( COND [ qstring ] conditional_port_expr iopath_def ) BEGIN("cond def"); consume(tLPAREN); consume(tSDFCOND); if (scan(tSTRING)) p_qstring(); p_conditional_port_expr(); p_iopath_def(); consume(tRPAREN); } static void p_port_def(void) { // port_def ::= // ( PORT port_instance delval_list ) BEGIN("port def"); consume(tLPAREN); consume(tPORT); p_port_instance(); p_delval_list(); consume(tRPAREN); } static void p_interconnect_def(void) { // interconnect_def ::= // ( INTERCONNECT port_instance port_instance delval_list ) BEGIN("interconnect def"); consume(tLPAREN); consume(tINTERCONNECT); p_port_instance(); p_port_instance(); p_delval_list(); consume(tRPAREN); } static void p_netdelay_def(void) { // netdelay_def ::= // ( NETDELAY net_spec delval_list ) BEGIN("netdelay def"); consume(tLPAREN); consume(tNETDELAY); p_port_spec(); p_delval_list(); consume(tRPAREN); } static void p_device_def(void) { // device_def ::= // ( DEVICE [ port_instance ] delval_list ) BEGIN("device def"); consume(tLPAREN); consume(tDEVICE); if (scan(tID)) p_port_instance(); p_delval_list(); consume(tRPAREN); } static void p_deldef_list(sdf_flags_t flag) { // del_def { del_def } BEGIN("deldef list"); int tok = peek_nth(2); while (tok == tIOPATH || tok == tSDFCOND || tok == tSDFCONDELSE || tok == tPORT || tok == tINTERCONNECT || tok == tNETDELAY || tok == tDEVICE) { switch (tok) { case tIOPATH: p_iopath_def(); break; case tSDFCOND: p_cond_def(); break; case tSDFCONDELSE: p_condelse_def(); break; case tPORT: p_port_def(); break; case tINTERCONNECT: p_interconnect_def(); break; case tNETDELAY: p_netdelay_def(); break; default: // tDEVICE p_device_def(); } tok = peek_nth(2); }; } static void p_increment_deltype(void) { // increment_deltype ::= // ( INCREMENT del_def { del_def } ) BEGIN("increment deltype") consume(tLPAREN); consume(tINCREMENT); p_deldef_list(S_F_VALUE_INCREMENT); consume(tRPAREN); } static void p_absolute_deltype(void) { // absolute_deltype ::= // ( ABSOLUTE del_def { del_def } ) BEGIN("absolute deltype"); consume(tLPAREN); consume(tABSOLUTE); p_deldef_list(S_F_VALUE_ABSOLUTE); consume(tRPAREN); } static void p_del_spec(void) { // del_spec ::= // ( DELAY deltype { deltype } ) BEGIN("del spec"); consume(tLPAREN); consume(tDELAY); do { switch (peek_nth(2)) { case tABSOLUTE: p_absolute_deltype(); break; case tINCREMENT: p_increment_deltype(); break; case tPATHPULSE: p_pathpulse_deltype(); break; case tPATHPULSEP: p_pathpulsepercent_deltype(); break; default: consume(tLPAREN); one_of(tABSOLUTE, tINCREMENT, tPATHPULSE, tPATHPULSEP); } } while (scan(tLPAREN)); consume(tRPAREN); } static void p_cell(void) { // cell ::= // ( CELL celltype cell_instance { timing_spec } ) // celltype ::= // ( CELLTYPE qstring ) // cell_instance ::= // ( INSTANCE [ hierarchical_identifier ] ) // | ( INSTANCE * ) BEGIN("cell"); consume(tLPAREN); consume(tCELL); // celltype consume(tLPAREN); consume(tCELLTYPE); p_qstring(); consume(tRPAREN); // cell_instance p_cell_instance(); // { timing_spec } int tok = peek_nth(2); while (tok == tDELAY || tok == tTIMINGCHECK || tok == tLABEL || tok == tTIMINGENV) { switch (tok) { case tDELAY: p_del_spec(); break; case tTIMINGCHECK: p_tc_spec(); break; case tLABEL: p_lbl_spec(); break; default: // tTIMINGENV p_te_spec(); } tok = peek_nth(2); } consume(tRPAREN); } static void p_timescale(void) { // time_scale ::= // ( TIMESCALE timescale_number timescale_unit ) // timescale_number ::= // 1 | 10 | 100 | 1.0 | 10.0 | 100.0 // timescale_unit ::= // s | ms | us | ns | ps | fs BEGIN("timescale"); consume(tLPAREN); consume(tTIMESCALE); double mult_fact = p_real_number(); // This accepts also timescale_number like 1.000000 if (!doubles_equal(mult_fact, 1.0) && !doubles_equal(mult_fact, 10.0) && !doubles_equal(mult_fact, 100.0)) parse_error(&state.last_loc, "Invalid timescale_number: %.1f. " "Allowed values are: 1, 10, 100, 1.0, 10.0, 100.0", mult_fact); ident_t timescale_unit = p_identifier(); const char *ustr = istr(timescale_unit); double unit_fact = 1; if (!strcmp(ustr, "s")) unit_fact = 1E15; else if (!strcmp(ustr, "ms")) unit_fact = 1E12; else if (!strcmp(ustr, "us")) unit_fact = 1E9; else if (!strcmp(ustr, "ns")) unit_fact = 1E6; else if (!strcmp(ustr, "ps")) unit_fact = 1E3; else if (strcmp(ustr, "fs")) parse_error(&state.last_loc, "Invalid timescale_unit: %s. " "Allowed values are: s, ms, us, ps, fs.", ustr); // Multiplication factor for real numbers in the SDF file // to convert to 1 fs sdf_file->unit_mult = mult_fact * unit_fact; consume(tRPAREN); } static void p_temperature(void) { // temperature ::= // ( TEMPERATURE rtriple ) // | ( TEMPERATURE signed_real_number ) BEGIN("temperature"); consume(tLPAREN); consume(tTEMPERATURE); p_signed_real_number_or_rtripple(); consume(tRPAREN); } static void p_voltage(void) { // voltage ::= // ( VOLTAGE rtriple ) // | ( VOLTAGE signed_real_number ) BEGIN("voltage"); consume(tLPAREN); consume(tVOLTAGE); p_signed_real_number_or_rtripple(); consume(tRPAREN); } static void p_hierarchy_divider(void) { // hierarchy_divider ::= // ( DIVIDER hchar ) BEGIN("hierarchy divider"); consume(tLPAREN); consume(tDIVIDER); char hchar = one_of(tDOT, tOVER); if (hchar == -1) parse_error(&state.last_loc, "Invalid SDF Hierarchy separator: %c. " "SDF hierarchy separator shall be one of: '/' , '.' ", hchar); sdf_file->hchar = hchar; if (hchar == tDOT) sdf_file->hchar_other = tOVER; else sdf_file->hchar_other = tDOT; consume(tRPAREN); } static void p_qstring_header_entry(int header_entry_token, sdf_header_item_kind_t header_item_kind, const char *info) { // design_name ::= // ( DESIGN qstring ) // date ::= // ( DATE qstring ) // vendor ::= // ( VENDOR qstring ) // program_name ::= // ( PROGRAM qstring ) // program_version ::= // ( VERSION qstring ) // process ::= // ( PROCESS qstring ) BEGIN(info); consume(tLPAREN); consume(header_entry_token); p_qstring(); consume(tRPAREN); } static void p_sdf_version(void) { // sdf_version ::= // ( SDFVERSION qstring ) BEGIN("sdf version"); consume(tLPAREN); consume(tSDFVERSION); ident_t id = p_qstring(); sdf_file->std = SDF_STD_4_0; if (ident_glob(id, "*1.0*", -1)) sdf_file->std = SDF_STD_1_0; else if (ident_glob(id, "*2.0*", -1)) sdf_file->std = SDF_STD_2_0; else if (ident_glob(id, "*2.1*", -1)) sdf_file->std = SDF_STD_2_1; else if (ident_glob(id, "*3.0*", -1)) sdf_file->std = SDF_STD_3_0; else if (ident_glob(id, "*4.0*", -1)) sdf_file->std = SDF_STD_4_0; else parse_error(&state.last_loc, "Invalid SDF version: %s. " "SDF version shall contain one of: " "\"1.0\", \"2.0\", \"2.1\", \"3.0\" or \"4.0\".", istr(id)); consume(tRPAREN); } static void p_sdf_header(void) { // sdf_header ::= // sdf_version [ design_name ] [ date ] [ vendor ] [ program_name ] // [ program_version ] [hierarchy_divider ] [ voltage ] // [ process ] [temperature ] [ time_scale ] BEGIN("sdf header"); p_sdf_version(); if (peek_nth(2) == tDESIGN) p_qstring_header_entry(tDESIGN, S_HEADER_DESIGN, "design_name"); if (peek_nth(2) == tDATE) p_qstring_header_entry(tDATE, S_HEADER_DATE, "date"); if (peek_nth(2) == tVENDOR) p_qstring_header_entry(tVENDOR, S_HEADER_VENDOR, "vendor"); if (peek_nth(2) == tPROGRAM) p_qstring_header_entry(tPROGRAM, S_HEADER_PROGRAM, "program"); if (peek_nth(2) == tVERSION) p_qstring_header_entry(tVERSION, S_HEADER_VERSION, "program_version"); if (peek_nth(2) == tDIVIDER) p_hierarchy_divider(); if (peek_nth(2) == tVOLTAGE) p_voltage(); if (peek_nth(2) == tPROCESS) p_qstring_header_entry(tPROCESS, S_HEADER_PROCESS, "process"); if (peek_nth(2) == tTEMPERATURE) p_temperature(); // Default time unit is 1 ns // See section 5.2.11 of IEEE 1497-2001 sdf_file->unit_mult = 1E6; if (peek_nth(2) == tTIMESCALE) p_timescale(); } static sdf_file_t *p_delay_file(const char *file, sdf_flags_t min_max_spec) { // delay_file ::= // ( DELAYFILE sdf_header cell { cell } ) BEGIN("delay file"); consume(tLPAREN); consume(tDELAYFILE); sdf_file = sdf_file_new(16384, 256); sdf_file->hchar = '.'; sdf_file->min_max_spec = min_max_spec; p_sdf_header(); while (peek_nth(2) == tCELL) p_cell(); consume(tRPAREN); return sdf_file; } /////////////////////////////////////////////////////////////////////////////// // Public API /////////////////////////////////////////////////////////////////////////////// sdf_file_t *sdf_parse(const char *file, sdf_flags_t min_max_spec) { scan_as_sdf(); reset_sdf_parser(); if (peek() == tEOF) return NULL; return p_delay_file(file, min_max_spec); } void reset_sdf_parser(void) { state.tokenq_head = state.tokenq_tail = 0; } nvc-r1.17.1/src/sdf/sdf-phase.h000066400000000000000000000015611504111170000161300ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _SDF_PHASE_H #define _SDF_PHASE_H #include "prim.h" #include "sdf/sdf-util.h" sdf_file_t* sdf_parse(const char *file, sdf_flags_t min_max_spec); #endif // _SDF_PHASE_H nvc-r1.17.1/src/sdf/sdf-util.c000066400000000000000000000022241504111170000157750ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "sdf/sdf-util.h" #include sdf_file_t *sdf_file_new(int exp_hier_cells, int exp_wild_cells) { sdf_file_t *sdf_file = xcalloc(sizeof(struct _sdf_file)); sdf_file->hier_map = hash_new(exp_hier_cells); sdf_file->name_map = hash_new(exp_wild_cells); return sdf_file; } void sdf_file_free(sdf_file_t *sdf_file) { hash_free(sdf_file->name_map); hash_free(sdf_file->hier_map); free(sdf_file); } nvc-r1.17.1/src/sdf/sdf-util.h000066400000000000000000000106501504111170000160040ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _SDF_UTIL_H #define _SDF_UTIL_H #include "prim.h" // // SDF standard revisions // typedef enum { SDF_STD_1_0, SDF_STD_2_0, SDF_STD_2_1, SDF_STD_3_0, SDF_STD_4_0 } sdf_std_t; typedef enum { S_F_POSEDGE = (1 << 0), S_F_NEGEDGE = (1 << 1), S_F_VALUE_ABSOLUTE = (1 << 2), S_F_VALUE_INCREMENT = (1 << 3), S_F_MIN_VALUES = (1 << 4), S_F_TYP_VALUES = (1 << 5), S_F_MAX_VALUES = (1 << 6) } sdf_flags_t; #define S_F_MIN_MAX_SPEC_ALL (S_F_MIN_VALUES | S_F_TYP_VALUES | S_F_MAX_VALUES) #define S_F_DELTYPE_ALL (S_F_DELTYPE_ABSOLUTE | S_F_DELTYPE_INCREMENT) typedef enum { S_HEADER_SDF_VERSION = (1 << 0), S_HEADER_DESIGN = (1 << 1), S_HEADER_DATE = (1 << 2), S_HEADER_VENDOR = (1 << 3), S_HEADER_PROGRAM = (1 << 4), S_HEADER_VERSION = (1 << 5), S_HEADER_DIVIDER = (1 << 6), S_HEADER_VOLTAGE = (1 << 7), S_HEADER_PROCESS = (1 << 8), S_HEADER_TEMPERATURE = (1 << 9), S_HEADER_TIMESCALE = (1 << 10), } sdf_header_item_kind_t; typedef enum { S_COND_COND, S_COND_CONDELSE, S_COND_SCOND, S_COND_CCOND } sdf_cond_kind_t; typedef enum { S_TCHECK_SETUP, S_TCHECK_HOLD, S_TCHECK_SETUPHOLD, S_TCHECK_RECOVERY, S_TCHECK_REMOVAL, S_TCHECK_RECREM, S_TCHECK_SKEW, S_TCHECK_BIDIRSKEW, S_TCHECK_WIDTH, S_TCHECK_PERIOD, S_TCHECK_NOCHANGE } sdf_tcheck_kind_t; typedef enum { S_UNARY_EXPR_PLUS, S_UNARY_EXPR_MINUS, S_UNARY_EXPR_LOGNOT, S_UNARY_EXPR_BITNOT, S_UNARY_EXPR_AND, S_UNARY_EXPR_NAND, S_UNARY_EXPR_OR, S_UNARY_EXPR_NOR, S_UNARY_EXPR_XOR, S_UNARY_EXPR_XNOR, S_UNARY_EXPR_NONE, } sdf_unary_expr_kind_t; typedef enum { S_BINARY_EXPR_PLUS, S_BINARY_EXPR_MINUS, S_BINARY_EXPR_MULT, S_BINARY_EXPR_DIV, S_BINARY_EXPR_MOD, S_BINARY_EXPR_LOGEQ, S_BINARY_EXPR_LOGNEQ, S_BINARY_EXPR_CASEEQ, S_BINARY_EXPR_CASENEQ, S_BINARY_EXPR_LOGAND, S_BINARY_EXPR_LOGOR, S_BINARY_EXPR_LT, S_BINARY_EXPR_LTEQ, S_BINARY_EXPR_GT, S_BINARY_EXPR_GTEQ, S_BINARY_EXPR_BITAND, S_BINARY_EXPR_BITOR, S_BINARY_EXPR_BITXOR, S_BINARY_EXPR_BITXNOR, S_BINARY_EXPR_SHRIGHT, S_BINARY_EXPR_SHLEFT, S_BINARY_EXPR_NONE } sdf_binary_expr_kind_t; struct _sdf_file { // SDF standard sdf_std_t std; // Multiplier for each time unit to convert into fs. double unit_mult; // Hierarchy separator char hchar; char hchar_other; // hier_map: Hierarchy -> Cell map // name_map: Cell name -> Cell map (for wildcards) // Each cell is placed in only one of these two hash tables. // Duplicities are prevented by looking up cells in the hash tables before // adding the cell. Thus cells with equal: // - hierarchy (INSTANCE [hierarchy]) // - cell name and wildcard (CELLNAME, INSTANCE *) // are merged into single S_CELL object. // TODO: Resolve location tracking. SDF standard says that information from // SDF file should be annotated in order it is present in the SDF file. // If there is a cell annotated due to cell_name and instance wildcard, // and also annotated by cell with hierarchy entry, then it is currently // not possible to figure out which one to apply earlier. This is because // loc_t is invalid since it counts only until 1M lines! Maybe somehow // tracking only line number ? hash_t *hier_map; hash_t *name_map; // Mask of delays that are parsed: // S_F_MIN_DELAYS, S_F_TYP_DELAYS, S_F_MAX_DELAYS sdf_flags_t min_max_spec; }; sdf_file_t *sdf_file_new(int exp_hier_cells, int exp_wild_cells); void sdf_file_free(sdf_file_t *sdf); #endif // _SDF_UTIL_H nvc-r1.17.1/src/sem.c000066400000000000000000007147551504111170000143010ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "hash.h" #include "lib.h" #include "mask.h" #include "names.h" #include "option.h" #include "phase.h" #include "psl/psl-phase.h" #include "type.h" #include #include #include typedef bool (*static_fn_t)(tree_t t); typedef enum { MAP_MISSING, MAP_OPEN, MAP_PARTIAL, MAP_FULL } map_state_t; typedef struct { tree_t decl; map_state_t state; } formal_map_t; static bool sem_check_array_ref(tree_t t, nametab_t *tab); static bool sem_locally_static(tree_t t); static bool sem_globally_static(tree_t t); static tree_t sem_check_lvalue(tree_t t); static bool sem_check_same_type(tree_t left, tree_t right); static bool sem_check_type(tree_t t, type_t expect, nametab_t *tab); static bool sem_static_name(tree_t t, static_fn_t check_fn); static bool sem_static_subtype(type_t type, static_fn_t fn); static bool sem_check_attr_ref(tree_t t, bool allow_range, nametab_t *tab); static bool sem_check_generic_map(tree_t t, tree_t unit, nametab_t *tab); static bool sem_check_port_map(tree_t t, tree_t unit, nametab_t *tab); static bool sem_check_subtype(tree_t decl, type_t type, nametab_t *tab); static bool sem_check_incomplete(tree_t t, type_t type); #define sem_error(t, ...) do { \ error_at(t ? tree_loc(t) : NULL , __VA_ARGS__); \ return false; \ } while (0) static bool sem_check_resolution(type_t type, tree_t res) { // Resolution functions are described in LRM 93 section 2.4 if (tree_kind(res) == T_ELEM_RESOLUTION) { // VHDL-2008 element resolution assert(standard() >= STD_08); if (type_is_array(type)) { tree_t sub = tree_value(tree_assoc(res, 0)); return sem_check_resolution(type_elem(type), sub); } else if (type_is_record(type)) sem_error(res, "sorry, record element resolution functions are not" "supported yet"); else { // Should have been caught during name resolution assert(error_count() > 0); return false; } } if (tree_kind(res) != T_REF) { // Should have been caught during name resolution assert(error_count() > 0); return false; } if (!tree_has_ref(res)) return false; tree_t fdecl = tree_ref(res); assert(is_subprogram(fdecl)); type_t ftype = tree_type(fdecl); if (type_kind(ftype) != T_SIGNATURE || !type_has_result(ftype)) sem_error(res, "resolution function name %s is not a function", istr(tree_ident(res))); // Must take a single parameter of array of base type if (type_params(ftype) != 1) sem_error(res, "resolution function must have a single argument"); type_t param = type_param(ftype, 0); if (type_kind(param) != T_ARRAY) sem_error(res, "parameter of resolution function must be " "an unconstrained array type"); if (!type_eq(type_elem(param), type)) sem_error(res, "parameter of resolution function must be " "an array of %s but found %s", type_pp(type), type_pp(type_elem(param))); // Return type must be the resolved type if (!type_eq(type_result(ftype), type)) sem_error(res, "result of resolution function must be %s but have %s", type_pp(type), type_pp(type_result(ftype))); return true; } static bool sem_check_range(tree_t r, type_t expect, nametab_t *tab) { if (expect != NULL && type_is_none(expect)) return false; // Prevent cascading errors switch (tree_subkind(r)) { case RANGE_EXPR: { tree_t expr = tree_value(r); type_t type = tree_type(expr); if (type_is_none(type)) return false; // Was earlier error if (tree_kind(expr) != T_ATTR_REF) sem_error(expr, "invalid expression in range constraint"); const attr_kind_t kind = tree_subkind(expr); if (kind != ATTR_RANGE && kind != ATTR_REVERSE_RANGE) sem_error(expr, "cannot use attribute %s as range", istr(tree_ident(expr))); if (!sem_check_attr_ref(expr, true, tab)) return false; if (expect && !sem_check_type(expr, expect, tab)) sem_error(expr, "expected type of range bound to be %s but is %s", type_pp(expect), type_pp(type)); } break; case RANGE_TO: case RANGE_DOWNTO: { tree_t left = tree_left(r); if (!sem_check(left, tab)) return false; tree_t right = tree_right(r); if (!sem_check(right, tab)) return false; if (expect != NULL) { if (!sem_check_same_type(left, right)) sem_error(right, "type mismatch in range: left is %s," " right is %s", type_pp(tree_type(left)), type_pp(tree_type(right))); if (!sem_check_type(left, expect, tab)) sem_error(r, "expected type of range bounds to be %s but" " have %s", type_pp(expect), type_pp(tree_type(left))); // This cannot fail because we know left and right have the // same type and left is equal to expect, but we still need // to call sem_check_type for the implicit conversion sem_check_type(right, expect, tab); sem_check_type(r, expect, tab); } } break; } return true; } static bool sem_check_discrete_range(tree_t r, type_t expect, nametab_t *tab) { if (!sem_check_range(r, expect ?: tree_type(r), tab)) return false; const range_kind_t kind = tree_subkind(r); type_t type = tree_type(r); if (type_is_none(type) || kind == RANGE_ERROR) return false; if (!type_is_discrete(type)) sem_error(r, "type of range bounds %s is not discrete", type_pp(type)); // See LRM 93 section 3.2.1.1: universal integer bound must be a // numeric literal or attribute. Later LRMs relax the wording here. if (standard() < STD_00 && !relaxed_rules() && kind != RANGE_EXPR) { tree_t left = tree_left(r); tree_t right = tree_right(r); type_t left_type = tree_type(left); type_t right_type = tree_type(right); if (type_is_universal(left_type) && type_is_universal(right_type)) { tree_kind_t lkind = tree_kind(left); tree_kind_t rkind = tree_kind(right); const bool invalid = lkind != T_LITERAL && lkind != T_ATTR_REF && rkind != T_LITERAL && rkind != T_ATTR_REF; if (invalid) sem_error(r, "universal integer bound must be numeric" " literal or attribute"); } } return true; } static bool sem_check_constraint(tree_t constraint, type_t base, nametab_t *tab) { const constraint_kind_t consk = tree_subkind(constraint); switch (consk) { case C_RANGE: if (!type_is_scalar(base)) sem_error(constraint, "range constraint cannot be used with " "non-scalar type %s", type_pp(base)); break; case C_INDEX: if (!type_is_array(base)) sem_error(constraint, "index constraint cannot be used with " "non-array type %s", type_pp(base)); break; case C_RECORD: { if (!type_is_record(base)) sem_error(constraint, "record element constraint cannot be used " "with non-record type %s", type_pp(base)); // Range list is overloaded to hold record element constraints const int nelem = tree_ranges(constraint); for (int i = 0; i < nelem; i++) { tree_t ei = tree_range(constraint, i); assert(tree_kind(ei) == T_ELEM_CONSTRAINT); if (!tree_has_ref(ei)) return false; // Was parse error tree_t decl = tree_ref(ei); assert(tree_kind(decl) == T_FIELD_DECL); // Checked by parser type_t ftype = tree_type(decl); if (!type_is_unconstrained(ftype)) sem_error(constraint, "field %s in record element constraint is " "already constrained", istr(tree_ident(decl))); type_t sub = tree_type(ei); if (!sem_check_subtype(decl, sub, tab)) return false; // Check for duplicate element constraints tree_t fi = tree_ref(ei); for (int j = 0; j < i; j++) { tree_t ej = tree_range(constraint, j); if (tree_pos(tree_ref(ej)) == tree_pos(fi)) sem_error(ei, "duplicate record element constraint for " "field %s", istr(tree_ident(fi))); } } // Code belows handles index and range constraints return true; } } if (type_is_array(base)) { if (type_kind(base) == T_SUBTYPE && !type_is_unconstrained(base)) sem_error(constraint, "cannot change constraints of constrained " "array type %s", type_pp(base)); } else if (type_is_record(base) && standard() < STD_08) sem_error(constraint, "record subtype may not have constraints " "in VHDL-%s", standard_text(standard())); const int ndims_base = type_is_array(base) ? dimension_of(base) : 1; const int ndims = tree_ranges(constraint); if (ndims != ndims_base) sem_error(constraint, "expected %d constraints for type %s but found %d", ndims_base, type_pp(base), ndims); for (int i = 0; i < ndims; i++) { tree_t r = tree_range(constraint, i); type_t index = index_type_of(base, i); switch (consk) { case C_INDEX: if (!sem_check_discrete_range(r, index, tab)) return false; break; case C_RANGE: if (!sem_check_range(r, index, tab)) return false; break; default: break; } } return true; } static bool sem_check_subtype_helper(tree_t decl, type_t type, nametab_t *tab) { // Shared code for checking subtype declarations and implicit subtypes type_t base = type_base(type); if (type_is_none(base)) return false; else if (type_is_access(base)) base = type_designated(base); assert(!is_anonymous_subtype(base)); if (type_is_protected(base)) sem_error(decl, "subtypes may not have protected base types"); else if (!sem_check_incomplete(decl, type)) return false; if (type_has_constraint(type)) { tree_t cons = type_constraint(type); if (!sem_check_constraint(cons, base, tab)) return false; // Check the subtype does not already have an index constraint in // this position for (type_t b = base; type_kind(b) == T_SUBTYPE; b = type_base(b)) { if (type_has_constraint(b)) { tree_t econs = type_constraint(b); if (tree_subkind(econs) == C_INDEX) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(cons)); diag_printf(d, "duplicate index constraint for type %s", type_pp(base)); diag_hint(d, tree_loc(econs), "already constrained here"); diag_emit(d); return false; } } } } if (type_is_array(type) && type_has_elem(type)) { type_t elem = type_elem(type); if (is_anonymous_subtype(elem)) { // Anonymous subtype created for array element constraint assert(standard() >= STD_08); if (!sem_check_subtype_helper(decl, elem, tab)) return false; } } if (type_has_resolution(type)) { if (!sem_check_resolution(type_base(type), type_resolution(type))) return false; } return true; } static bool sem_check_subtype(tree_t decl, type_t type, nametab_t *tab) { // Check an anonymous subtype at the point of use if (type_kind(type) != T_SUBTYPE) return true; else if (type_has_ident(type)) return true; // Explicitly declared subtype return sem_check_subtype_helper(decl, type, tab); } static bool sem_check_use_clause(tree_t c, nametab_t *tab) { if (standard() >= STD_08) { tree_t unit = find_enclosing(tab, S_DESIGN_UNIT); if (unit != NULL && tree_kind(unit) == T_CONTEXT) { // LRM 08 section 13.3 ident_t prefix = ident_until(tree_ident(c), '.'); if (prefix == well_known(W_WORK)) sem_error(c, "selected name in context declaration use clause " "may not have WORK as a prefix"); } } return true; } static bool sem_check_library_clause(tree_t t, nametab_t *tab) { if (standard() >= STD_08) { ident_t name = tree_ident(t); tree_t unit = find_enclosing(tab, S_DESIGN_UNIT); if (unit != NULL && tree_kind(unit) == T_CONTEXT) { // LRM 08 section 13.3 if (name == well_known(W_WORK)) sem_error(t, "library clause in a context declaration may not have " "logical library name WORK"); } } return true; } static bool sem_check_context_clause(tree_t t, nametab_t *tab) { // Ignore the implicit WORK and STD with context declarations const int ignore = tree_kind(t) == T_CONTEXT ? 2 : 0; bool ok = true; const int ncontexts = tree_contexts(t); for (int n = ignore; n < ncontexts; n++) ok = sem_check(tree_context(t, n), tab) && ok; return ok; } static bool sem_check_readable(tree_t t) { switch (tree_kind(t)) { case T_REF: { if (tree_flags(t) & TREE_F_FORMAL_NAME) return true; // Name appearing in formal tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_PORT_DECL: { const port_mode_t mode = tree_subkind(decl); if (mode == PORT_OUT && standard() < STD_08) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "cannot read output port %s", istr(tree_ident(t))); diag_hint(d, tree_loc(decl), "%s declared with mode OUT", istr(tree_ident(decl))); diag_hint(d, tree_loc(t), "read here"); diag_hint(d, NULL, "outputs can be read with " "$bold$--std=2008$$"); diag_emit(d); return false; } else if (mode == PORT_LINKAGE) sem_error(t, "linkage port %s may not be read except as " "an actual corresponding to an interface of mode " "linkage", istr(tree_ident(t))); } break; case T_PARAM_DECL: if (tree_subkind(decl) == PORT_OUT) { // LRM 08 section 6.5.2: The value of the interface // object is allowed to be updated and, provided it is // not a signal parameter, read. if (standard() < STD_08) sem_error(t, "cannot read OUT parameter %s", istr(tree_ident(t))); else if (tree_class(decl) == C_SIGNAL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "cannot read OUT signal parameter %s", istr(tree_ident(t))); diag_hint(d, NULL, "OUT parameters can be read provided they " "are not signal parameters"); diag_lrm(d, STD_08, "6.5.2"); diag_emit(d); return false; } } break; default: break; } return true; } case T_ARRAY_REF: case T_ARRAY_SLICE: return sem_check_readable(tree_value(t)); default: return true; } } static bool sem_check_array_dims(type_t type, type_t constraint, nametab_t *tab) { const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { tree_t r = range_of(type, i); type_t index_type = NULL; if (constraint != NULL && i < dimension_of(constraint)) index_type = index_type_of(constraint, i); if (!sem_check_discrete_range(r, index_type, tab)) return false; if (index_type == NULL) index_type = tree_type(r); if (!sem_check_type(r, index_type, tab)) sem_error(r, "type of bound %s does not match type of index %s", type_pp(tree_type(r)), type_pp(index_type)); } return true; } static bool sem_check_type(tree_t t, type_t expect, nametab_t *tab) { type_t actual = tree_type(t); if (type_eq_map(actual, expect, get_generic_map(tab))) return true; // Supress cascading errors if (type_is_none(actual) || type_is_none(expect)) return true; return false; } static bool sem_check_same_type(tree_t left, tree_t right) { type_t left_type = tree_type(left); type_t right_type = tree_type(right); if (type_eq(left_type, right_type)) return true; // Supress cascading errors if (type_is_none(left_type) || type_is_none(right_type)) return true; return false; } static bool sem_has_access(type_t t) { // returns true if the type is an access type or is a composite // type that contains a subelement of an access type type_t base = type_base_recur(t); if (type_is_access(base)) return true; if (type_is_array(base)) return sem_has_access(type_elem(base)); if (type_is_record(base)) { const int nfields = type_fields(base); for (int i = 0; i < nfields; i++) { if (sem_has_access(tree_type(type_field(base, i)))) return true; } } return false; } static bool sem_check_type_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); // Nothing more to do for incomplete types if (type_kind(type) == T_INCOMPLETE) return true; type_kind_t kind = type_kind(type); if (kind == T_SUBTYPE) { // Implicitly created subtype for a constrained array defintion if (!sem_check_subtype_helper(t, type, tab)) { // Prevent cascading errors // TODO: can we do this check in the parser and set T_NONE earlier? type_set_base(type, type_new(T_NONE)); return false; } type = type_base(type); kind = type_kind(type); assert(kind == T_ARRAY); } switch (kind) { case T_ARRAY: { type_t elem_type = type_elem(type); if (!sem_check_subtype(t, elem_type, tab)) return false; if (standard() < STD_08 && type_is_unconstrained(elem_type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "array %s cannot have unconstrained element type", istr(tree_ident(t))); diag_hint(d, NULL, "this would be allowed with $bold$--std=2008$$"); diag_emit(d); return false; } if (type_is_file(elem_type)) sem_error(t, "array %s cannot have element of file type", istr(tree_ident(t))); else if (type_is_protected(elem_type)) sem_error(t, "array %s cannot have element of protected type", istr(tree_ident(t))); else if (!sem_check_incomplete(t, elem_type)) return false; const int nindex = type_indexes(type); for (int i = 0; i < nindex; i++) { type_t index_type = type_index(type, i); if (type_is_none(index_type)) return false; else if (!type_is_discrete(index_type)) sem_error(t, "index type %s is not discrete", type_pp(index_type)); } return true; } case T_ENUM: return true; case T_PHYSICAL: { const int nunits = type_units(type); for (int i = 0; i < nunits; i++) { tree_t u = type_unit(type, i); tree_set_type(u, type); if (!sem_check(u, tab)) return false; tree_t value = tree_value(u); // LRM 08 section 5.2.4.1: the abstract literal portion // shall be an integer literal if (tree_ival(value) == 0 && tree_dval(value) != 0) sem_error(value, "the abstract literal portion of a secondary " "unit declaration must be an integer literal"); if (i > 0 && !sem_check_type(value, type, tab)) sem_error(value, "secondary unit %s must have type %s", istr(tree_ident(u)), type_pp(type)); } } // Fall-through case T_INTEGER: { tree_t r = type_dim(type, 0); if (!sem_check_range(r, NULL, tab)) return false; switch (tree_subkind(r)) { case RANGE_TO: case RANGE_DOWNTO: { // See LRM 93 section 3.1.2: Each bound of a range // constraint that must be of some integer type, but the // two bounds need not have the same integer type. tree_t left = tree_left(r), right = tree_right(r); if (!type_is_integer(tree_type(left))) sem_error(left, "type of left bound must be of some integer " "type but have %s", type_pp(tree_type(left))); else if (!type_is_integer(tree_type(right))) sem_error(right, "type of right bound must be of some " "integer type but have %s", type_pp(tree_type(right))); } break; case RANGE_EXPR: if (!type_is_integer(tree_type(r))) sem_error(r, "type of range bounds must be of some integer " "type but have %s", type_pp(tree_type(r))); break; } if (!sem_locally_static(r)) sem_error(r, "range constraint of type %s must be locally static", type_pp(type)); tree_set_type(r, type); return true; } case T_REAL: { tree_t r = type_dim(type, 0); if (!sem_check_range(r, NULL, tab)) return false; switch (tree_subkind(r)) { case RANGE_TO: case RANGE_DOWNTO: { // See LRM 93 section 3.1.4: Each bound of a range // constraint that must be of some floating-point type, but // the two bounds need not have the same floating-point type. tree_t left = tree_left(r), right = tree_right(r); if (!type_is_real(tree_type(left))) sem_error(left, "type of left bound must be of some " "floating-point type but have %s", type_pp(tree_type(left))); else if (!type_is_real(tree_type(right))) sem_error(right, "type of right bound must be of some " "floating-point type but have %s", type_pp(tree_type(right))); } break; case RANGE_EXPR: assert(type_is_real(tree_type(r))); // Unreachable break; } if (!sem_locally_static(r)) sem_error(r, "range constraint of type %s must be locally static", type_pp(type)); tree_set_type(r, type); return true; } case T_RECORD: { const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { tree_t f = type_field(type, i); if (!sem_check(f, tab)) return false; // Each field name must be distinct ident_t f_name = tree_ident(f); for (int j = 0; j < i; j++) { tree_t fj = type_field(type, j); if (ident_casecmp(f_name, tree_ident(fj))) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(f)); diag_printf(d, "duplicate field name %s", istr(f_name)); diag_hint(d, tree_loc(fj), "previously declared here"); diag_hint(d, tree_loc(f), "declared again here"); diag_emit(d); return false; } } type_t f_type = tree_type(f); if (!sem_check_subtype(f, f_type, tab)) return false; // Recursive record types are not allowed if (type_eq(type, f_type)) sem_error(f, "recursive record types are not allowed"); // Element types may not be unconstrained before VHDL-2008 if (standard() < STD_08 && type_is_unconstrained(f_type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(f)); diag_printf(d, "record field %s cannot have unconstrained " "array type in VHDL-%s", istr(f_name), standard_text(standard())); diag_hint(d, NULL, "pass $bold$--std=2008$$ to enable this " "feature"); diag_emit(d); return false; } else if (type_is_file(f_type)) sem_error(f, "record field %s cannot be of file type", istr(f_name)); else if (type_is_protected(f_type)) sem_error(f, "record field %s cannot be of protected type", istr(f_name)); } return true; } case T_FILE: // Rules for file types are in LRM 93 section 3.4 { type_t f = type_designated(type); switch (type_kind(f)) { case T_ACCESS: sem_error(t, "files may not be of access type"); break; case T_FILE: sem_error(t, "files may not be of file type"); break; case T_PROTECTED: sem_error(t, "files may not be of protected type"); break; default: break; } if (sem_has_access(f)) sem_error(t, "type %s has a subelement with an access type", type_pp(f)); type_t base_f = type_base_recur(f); if (type_is_array(base_f) && dimension_of(base_f) > 1) sem_error(t, "array type for file type must be one-dimensional"); return true; } case T_ACCESS: // Rules for access types are in LRM 93 section 3.3 { type_t designated = type_designated(type); if (!sem_check_subtype(t, designated, tab)) return false; if (standard() < STD_19) { if (type_is_file(designated)) sem_error(t, "access type %s cannot designate file type", istr(tree_ident(t))); if (type_is_protected(designated)) sem_error(t, "access type %s cannot designate protected type", istr(tree_ident(t))); } return true; } case T_PROTECTED: default: return true; } } static bool sem_check_subtype_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); assert(type_kind(type) == T_SUBTYPE); assert(type_has_ident(type)); return sem_check_subtype_helper(t, type, tab); } static bool sem_check_incomplete(tree_t t, type_t type) { if (type_is_incomplete(type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "invalid use of incomplete type %s", type_pp(type)); diag_hint(d, NULL, "prior to the end of the corresponding full type " "declaration, an incomplete type may only be used as the " "designated type of an access type declaration"); diag_lrm(d, STD_08, "5.4.2"); diag_emit(d); return false; } return true; } static bool sem_no_access_file_or_protected(tree_t t, type_t type, const char *what) { // constants, signals, attributes, generics, ports // may not be of an access, file, or protected type, or // of a composite type with a subelement of an access type if (type_is_access(type)) sem_error(t, "%s may not have access type", what); if (sem_has_access(type)) sem_error(t, "%s may not have a type with a subelement of access type", what); if (type_is_protected(type)) sem_error(t, "%s may not have protected type", what); if (type_is_file(type)) sem_error(t, "%s may not have file type", what); return true; } static void sem_unconstrained_decl_hint(diag_t *d, type_t type) { if (!type_is_record(type)) return; // Tell the user which field is unconstrained type_t base = type_base_recur(type); const int nfields = type_fields(base); for (int i = 0; i < nfields; i++) { tree_t f = type_field(base, i); if (!type_is_unconstrained(tree_type(f))) continue; else if (type_constraint_for_field(type, f) == NULL) diag_hint(d, NULL, "missing record element constraint for field %s", istr(tree_ident(f))); } } static void sem_propagate_constraints(tree_t decl, tree_t value) { // Propagate the constraints from an initial value to an object // declaration with unconstrained type but only if the object subtype // has no constraints of its own if (standard() < STD_19 && tree_kind(decl) != T_CONST_DECL) return; type_t type = tree_type(decl); if (!type_is_unconstrained(type)) return; for (type_t iter = type; type_kind(iter) == T_SUBTYPE; iter = type_base(iter)) { if (type_has_constraint(iter)) return; } tree_set_type(decl, tree_type(value)); } static bool sem_check_const_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (!sem_check_subtype(t, type, tab)) return false; else if (type_is_none(type)) return false; else if (!sem_check_incomplete(t, type)) return false; if (!sem_no_access_file_or_protected(t, type, "constants")) return false; tree_t fwd = find_forward_decl(tab, t); if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of initial value %s does not match type " "of declaration %s", type_pp2(tree_type(value), type), type_pp2(type, tree_type(value))); if (fwd == NULL) sem_propagate_constraints(t, value); // A constant with a globaly static value should be treated as // globally static regardless of where it is declared if (sem_globally_static(value)) { tree_set_flag(t, TREE_F_GLOBALLY_STATIC); // A reference to a constant with a locally static subype and // locally static value is locally static if (sem_locally_static(value) && sem_static_subtype(tree_type(t), sem_locally_static)) tree_set_flag(t, TREE_F_LOCALLY_STATIC); } } else if (tree_kind(find_enclosing(tab, S_DESIGN_UNIT)) != T_PACKAGE) sem_error(t, "deferred constant declarations are only permitted " "in packages"); if (fwd != NULL && !type_strict_eq(tree_type(fwd), type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "expected type %s for deferred constant %s but " "found %s", type_pp2(tree_type(fwd), type), istr(tree_ident(t)), type_pp2(type, tree_type(fwd))); diag_hint(d, tree_loc(fwd), "originally declared with type %s", type_pp2(tree_type(fwd), type)); diag_hint(d, tree_loc(t), "type here is %s", type_pp2(type, tree_type(fwd))); diag_emit(d); return false; } return true; } static bool sem_check_signal_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (!sem_check_subtype(t, type, tab)) return false; else if (type_is_none(type)) return false; if (type_is_unconstrained(type)) { if (standard() < STD_19) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "declaration of signal %s cannot have unconstrained " "type %s", istr(tree_ident(t)), type_pp(type)); sem_unconstrained_decl_hint(d, type); diag_emit(d); return false; } else if (!tree_has_value(t)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "declaration of signal %s without an initial value " "cannot have unconstrained type %s", istr(tree_ident(t)), type_pp(type)); sem_unconstrained_decl_hint(d, type); diag_emit(d); return false; } } else if (!sem_check_incomplete(t, type)) return false; if (!sem_no_access_file_or_protected(t, type, "signals")) return false; if (is_guarded_signal(t) && !type_is_resolved(type)) sem_error(t, "guarded signal must have resolved subtype"); if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of initial value %s does not match type " "of declaration %s", type_pp2(tree_type(value), type), type_pp2(type, tree_type(value))); if (standard() >= STD_19 && type_is_unconstrained(type)) tree_set_type(t, tree_type(value)); } return true; } static bool sem_check_var_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (!sem_check_subtype(t, type, tab)) return false; else if (type_is_none(type)) return false; if (type_is_unconstrained(type)) { if (standard() < STD_19) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "declaration of variable %s cannot have unconstrained " "type %s", istr(tree_ident(t)), type_pp(type)); sem_unconstrained_decl_hint(d, type); diag_emit(d); return false; } else if (!tree_has_value(t)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "declaration of variable %s without an initial value " "cannot have unconstrained type %s", istr(tree_ident(t)), type_pp(type)); sem_unconstrained_decl_hint(d, type); diag_emit(d); return false; } } else if (!sem_check_incomplete(t, type)) return false; if (tree_has_value(t)) { if (type_kind(type) == T_PROTECTED) sem_error(t, "variable %s with protected type may not have an " "initial value", istr(tree_ident(t))); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of initial value %s does not match type " "of declaration %s", type_pp2(tree_type(value), type), type_pp2(type, tree_type(value))); sem_propagate_constraints(t, value); } // From VHDL-2000 onwards shared variables must be protected types if (standard() >= STD_00) { if ((tree_flags(t) & TREE_F_SHARED) && !type_is_protected(type)) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "shared variable %s must have protected type", istr(tree_ident(t))); diag_emit(d); } } } if (type_is_protected(type)) { ident_t typeid = ident_rfrom(type_ident(type), '.'); tree_t pt = get_local_decl(tab, NULL, typeid, 0); if (pt != NULL && tree_kind(pt) == T_PROT_DECL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "cannot declare instance of protected type %s " "before its body has been elaborated", type_pp(type)); diag_hint(d, tree_loc(pt), "%s declared here", type_pp(type)); diag_lrm(d, STD_08, "14.4.2"); diag_emit(d); return false; } // The 2019 standard needs access to the instance and path name at // the point of declaration if (standard() >= STD_19) tree_set_global_flags(t, TREE_GF_INSTANCE_NAME | TREE_GF_PATH_NAME); } return true; } static bool sem_check_param_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (!sem_check_subtype(t, type, tab)) return false; else if (!sem_check_incomplete(t, type)) return false; // See LRM 93 section 3.3 for restrictions const type_kind_t kind = type_base_kind(type); const class_t class = tree_class(t); const port_mode_t mode = tree_subkind(t); switch (mode) { case PORT_BUFFER: sem_error(t, "subprogram formal parameters cannot have mode BUFFER"); break; case PORT_LINKAGE: sem_error(t, "subprogram formal parameters cannot have mode LINKAGE"); break; default: break; } if (kind == T_FILE && class != C_FILE) sem_error(t, "formal parameter %s with file type must have class FILE", istr(tree_ident(t))); if (kind != T_FILE && class == C_FILE) sem_error(t, "formal parameter %s with class FILE must have file type", istr(tree_ident(t))); if ((kind == T_ACCESS || kind == T_PROTECTED) && class != C_VARIABLE) sem_error(t, "formal parameter %s with %s type must have class VARIABLE", istr(tree_ident(t)), kind == T_ACCESS ? "access" : "protected"); if (sem_has_access(type) && class != C_VARIABLE) sem_error(t, "formal parameter %s with type containing an access type " "must have class VARIABLE", istr(tree_ident(t))); if (class == C_CONSTANT && mode != PORT_IN) sem_error(t, "parameter of class CONSTANT must have mode IN"); // LRM 08 section 4.2.2.3 if (class == C_SIGNAL && tree_flags(t) & TREE_F_BUS) sem_error(t, "formal signal parameter declaration may " "not include the reserved word BUS"); if (class == C_PACKAGE || class == C_TYPE) sem_error(t, "parameter interface list cannot contain %s " "interface declaration", class_str(class)); if (mode == PORT_RECORD_VIEW || mode == PORT_ARRAY_VIEW) { tree_t name = tree_value(t); type_t view_type = tree_type(name); if (type_is_none(view_type)) return false; if (type_kind(view_type) != T_VIEW) sem_error(name, "name in mode view indication of parameter %s does " "not denote a mode view", istr(tree_ident(t))); type_t elem_type = type; if (mode == PORT_ARRAY_VIEW) { if (!type_is_array(type)) sem_error(t, "parameter %s with array mode view indication has " "non-array type %s", istr(tree_ident(t)), type_pp(type)); elem_type = type_elem(type); } if (!type_eq(elem_type, type_designated(view_type))) sem_error(t, "subtype %s is not compatible with mode " "view %s", type_pp(elem_type), type_pp(view_type)); } else if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of default value %s does not match type " "of declaration %s", type_pp(tree_type(value)), type_pp(type)); switch (class) { case C_SIGNAL: sem_error(t, "parameter of class SIGNAL cannot have a " "default value"); break; case C_VARIABLE: if (mode == PORT_OUT || mode == PORT_INOUT) sem_error(t, "parameter of class VARIABLE with mode OUT or " "INOUT cannot have a default value"); break; default: break; } if (!sem_globally_static(value)) { diag_t *d = pedantic_diag(tree_loc(value)); if (d != NULL) { diag_printf(d, "default value must be a static expression"); diag_emit(d); } } if (kind == T_PROTECTED) sem_error(t, "parameter with protected type cannot have " "a default value"); } return true; } static bool sem_check_port_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (type_is_none(type)) return false; else if (!sem_check_subtype(t, type, tab)) return false; else if (!sem_check_incomplete(t, type)) return false; const class_t class = tree_class(t); const port_mode_t mode = tree_subkind(t); if (class == C_VARIABLE) { if (standard() < STD_19) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "ports may not have variable class in VHDL-%s", standard_text(standard())); diag_hint(d, NULL, "pass $bold$--std=2019$$ to enable this " "feature"); diag_emit(d); return false; } if (mode != PORT_INOUT) sem_error(t, "formal variable port %s must have mode INOUT", istr(tree_ident(t))); if (!type_is_protected(type)) sem_error(t, "formal variable port %s must have protected type", istr(tree_ident(t))); } else if (class != C_SIGNAL) sem_error(t, "invalid object class %s for port %s", class_str(class), istr(tree_ident(t))); if (type_is_access(type)) sem_error(t, "port %s cannot be declared with access type %s", istr(tree_ident(t)), type_pp(type)); if (sem_has_access(type)) sem_error(t, "port %s cannot be declared with type %s which has a " "subelement of access type", istr(tree_ident(t)), type_pp(type)); if (class != C_VARIABLE && type_is_protected(type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "port %s with class %s cannot be declared with " "protected type %s", istr(tree_ident(t)), class_str(class), type_pp(type)); diag_hint(d, NULL, "ports with variable class can be of protected " "type in VHDL-2019"); diag_hint(d, NULL, "pass $bold$--std=2019$$ to enable this " "feature"); diag_emit(d); return false; } if (type_is_file(type)) sem_error(t, "port %s cannot be declared with file type %s", istr(tree_ident(t)), type_pp(type)); if (mode == PORT_RECORD_VIEW || mode == PORT_ARRAY_VIEW) { tree_t name = tree_value(t); type_t view_type = tree_type(name); if (type_is_none(view_type)) return false; if (type_kind(view_type) != T_VIEW) sem_error(name, "name in mode view indication of port %s does not " "denote a mode view", istr(tree_ident(t))); type_t elem_type = type; if (mode == PORT_ARRAY_VIEW) { if (!type_is_array(type)) sem_error(t, "port %s with array mode view indication has " "non-array type %s", istr(tree_ident(t)), type_pp(type)); elem_type = type_elem(type); } if (!type_eq(elem_type, type_designated(view_type))) sem_error(t, "subtype %s is not compatible with mode " "view %s", type_pp(elem_type), type_pp(view_type)); } else if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (mode == PORT_LINKAGE) sem_error(t, "port with mode LINKAGE cannot have a default value"); if (!sem_check_type(value, type, tab)) sem_error(value, "type of default value %s does not match type " "of declaration %s", type_pp(tree_type(value)), type_pp(type)); } return true; } static bool sem_check_generic_decl(tree_t t, nametab_t *tab) { const class_t class = tree_class(t); switch (class) { case C_CONSTANT: case C_TYPE: case C_FUNCTION: case C_PROCEDURE: break; case C_PACKAGE: { tree_t map = tree_value(t); if (!tree_has_ref(map)) return false; // Was earlier error assert(tree_kind(map) == T_PACKAGE_MAP); tree_t pack = tree_ref(map); assert(is_uninstantiated_package(pack)); switch (tree_subkind(map)) { case PACKAGE_MAP_DEFAULT: { // Check each generic in the uninstantiated package has a // default value const int ngenerics = tree_generics(pack); for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(pack, i); if (!tree_has_value(g)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(map)); diag_printf(d, "generic %s in package %s does not have a " "default value", istr(tree_ident(g)), istr(tree_ident(pack))); diag_hint(d, tree_loc(g), "%s declared here", istr(tree_ident(g))); diag_lrm(d, STD_08, "6.5.5"); diag_emit(d); return false; } } } break; case PACKAGE_MAP_MATCHING: sem_check_generic_map(map, pack, tab); break; case PACKAGE_MAP_BOX: break; } return true; } default: sem_error(t, "invalid object class %s for generic %s", class_str(tree_class(t)), istr(tree_ident(t))); } type_t type = tree_type(t); if (!sem_check_subtype(t, type, tab)) return false; else if (type_is_none(type)) return false; else if (!sem_check_incomplete(t, type)) return false; if (class != C_TYPE) { if (type_is_access(type)) sem_error(t, "generic %s may not have access type", istr(tree_ident(t))); else if (sem_has_access(type)) sem_error(t, "generic %s may not have a type with a subelement of " "access type", istr(tree_ident(t))); else if (type_is_protected(type)) sem_error(t, "generic %s may not have protected type", istr(tree_ident(t))); else if (type_is_file(type)) sem_error(t, "generic %s may not have file type", istr(tree_ident(t))); } if (class == C_CONSTANT && tree_subkind(t) != PORT_IN) sem_error(t, "generic %s with class CONSTANT must have mode IN", istr(tree_ident(t))); if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of default value %s does not match type " "of declaration %s", type_pp(tree_type(value)), type_pp(type)); } if (tree_flags(t) & TREE_F_LOCALLY_STATIC) { // For a generic declaration in a pacakage or subprogram to be // locally static it must also have a locally static subtype if (!sem_static_subtype(type, sem_locally_static)) tree_clear_flag(t, TREE_F_LOCALLY_STATIC); } return true; } static bool sem_check_field_decl(tree_t t) { type_t type = tree_type(t); if (!sem_check_incomplete(t, type)) return false; return true; } static bool sem_check_unit_decl(tree_t t) { return true; } static bool sem_check_alias(tree_t t, nametab_t *tab) { // Rules for aliases are given in LRM 93 section 4.3.3 tree_t value = tree_value(t); type_t type = get_type_or_null(t); const tree_kind_t value_kind = tree_kind(value); if (type != NULL && type_is_subprogram(type)) { // Alias of subprogram or enumeration literal // Rules for matching signatures are in LRM 93 section 2.3.2 assert(tree_kind(value) == T_REF || tree_kind(value) == T_PROT_REF); return true; } else if (tree_flags(t) & TREE_F_NONOBJECT_ALIAS) { // TODO: cannot be label return true; } else if (value_kind == T_REF && tree_has_ref(value)) { tree_t decl = tree_ref(value); if (aliased_type_decl(decl) != NULL) return true; // Alias of type else if (tree_kind(decl) == T_VIEW_DECL) return true; // Alias of view declaration } else if (value_kind == T_ATTR_REF && is_type_attribute(tree_subkind(value))) return true; // Alias of type // Alias of object if (!sem_check(value, tab)) return false; if (value_kind == T_ATTR_REF && tree_subkind(value) == ATTR_CONVERSE) { // Special case handling for // https://gitlab.com/IEEE-P1076/VHDL-Issues/-/issues/293 return true; } else if (!sem_static_name(value, sem_globally_static)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "aliased name is not static"); diag_lrm(d, STD_93, "6.1"); diag_emit(d); return false; } if (type != NULL) { // Alias declaration had optional subtype indication if (!sem_check_subtype(t, type, tab)) return false; if (value_kind == T_EXTERNAL_NAME) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "an alias of an external name cannot have a " "subtype indication"); diag_lrm(d, STD_08, "6.6.2"); diag_emit(d); return false; } if (!sem_check_type(value, type, tab)) sem_error(t, "type of aliased object %s does not match expected " "type %s", type_pp2(tree_type(value), type), type_pp2(type, tree_type(value))); if (opt_get_int(OPT_RELAXED) && type_is_unconstrained(type)) { // If the type of the aliased object is unconstrained then // use its subtype instead of the subtype declared by the // alias. This is required for some UVVM sources. type_t obj_type = tree_type(value); if (!type_is_unconstrained(obj_type)) tree_set_type(t, obj_type); } } else type = tree_type(value); if (standard() < STD_08 && type_is_array(type) && dimension_of(type) > 1) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "object alias may not have multidimensional array type " "in VHDL-%s", standard_text(standard())); diag_lrm(d, STD_93, "4.3.3.1"); diag_emit(d); return false; } return true; } static void sem_missing_body_cb(tree_t t, tree_t parent, nametab_t *tab) { if (parent == NULL || !opt_get_int(OPT_MISSING_BODY)) return; else if (have_name_errors(tab)) return; // May be missing due to parse errors const tree_kind_t kind = tree_kind(parent); if (kind == T_PACKAGE || kind == T_PROT_DECL) return; // Should be in body type_t type = tree_type(t); tree_t body = NULL; int nth = 0; do { body = get_local_decl(tab, NULL, tree_ident(t), nth++); } while (body != NULL && !type_eq(tree_type(body), type)); if (body == NULL || !is_body(body)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "missing body for "); switch (tree_kind(t)) { case T_PROT_DECL: diag_printf(d, "protected type "); break; case T_PROC_DECL: diag_printf(d, "procedure "); break; case T_FUNC_DECL: diag_printf(d, "function "); break; default: break; } diag_printf(d, "%s", type_pp(type)); diag_suppress(d, type_has_error(type)); diag_hint(d, tree_loc(parent), "body not found in %s", istr(tree_ident(parent))); diag_hint(d, tree_loc(t), "%s declared here", type_pp(type)); diag_emit(d); } } static bool sem_check_func_ports(tree_t t, nametab_t *tab) { const vhdl_standard_t std = standard(); ident_t id = tree_ident(t); if (is_operator_symbol(id)) { const int nports = tree_ports(t); const well_known_t wk = is_well_known(id); if (wk >= W_OP_AND && wk <= W_OP_XNOR) { if (std >= STD_08 && (nports < 1 || nports > 2)) sem_error(t, "logical operator must have either one or two " "operands"); else if (std < STD_08 && nports != 2) sem_error(t, "logical operator must have two operands"); } else if (wk >= W_OP_ABS && wk <= W_OP_CCONV && nports != 1) sem_error(t, "unary operator must have one operand"); else if ((wk >= W_OP_EQUAL && wk <= W_OP_EXPONENT && nports != 2) || (wk >= W_OP_MATCH_EQUAL && wk <= W_OP_MATCH_GREATER_EQUAL && nports != 2) || (wk >= W_OP_ADD && wk <= W_OP_MINUS && (nports < 1 || nports > 2))) sem_error(t, "binary operator must have two operands"); } const bool pure = !(tree_flags(t) & TREE_F_IMPURE); if (!pure && std >= STD_19) return true; // LCS2016_002 relaxed rules for impure functions const int nports = tree_ports(t); for (int i = 0; i < nports; i++) { tree_t p = tree_port(t, i); if (tree_subkind(p) != PORT_IN) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(p)); diag_printf(d, "%sfunction parameters must have mode IN", std < STD_19 ? "" : "pure "); diag_hint(d, tree_loc(p), "parameter %s has mode %s", istr(tree_ident(p)), port_mode_str(tree_subkind(p))); diag_lrm(d, STD_08, "4.2.2.1"); diag_emit(d); } else if (tree_class(p) == C_VARIABLE) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(p)); diag_printf(d, "class of %sfunction parameters must be CONSTANT, " "SIGNAL, or FILE", std < STD_19 ? "" : "pure "); diag_hint(d, tree_loc(p), "parameter %s has class %s", istr(tree_ident(p)), class_str(tree_class(p))); diag_lrm(d, STD_08, "4.2.2.1"); diag_emit(d); } } return true; } static bool sem_check_protected_method(tree_t t, nametab_t *tab) { if (standard() >= STD_19) return true; // Relaxed in LCS2016_04 const int nports = tree_ports(t); for (int i = 0; i < nports; i++) { tree_t p = tree_port(t, i); type_t type = tree_type(p); if (sem_has_access(type)) { diag_t *d = pedantic_diag(tree_loc(p)); if (d != NULL) { diag_printf(d, "parameters of protected type methods cannot be of " "an access type or a composite type containing an " "access type"); if (type_is_access(type)) diag_hint(d, tree_loc(p), "type of %s is %s which is an " "access type", istr(tree_ident(p)), type_pp(type)); else diag_hint(d, tree_loc(p), "type of %s is %s which has an " "access type as a subelement", istr(tree_ident(p)), type_pp(type)); diag_lrm(d, STD_08, "5.6.2"); diag_emit(d); } } else if (type_is_file(type)) { diag_t *d = pedantic_diag(tree_loc(p)); if (d != NULL) { diag_printf(d, "parameters of protected type methods cannot be of " "a file type"); diag_hint(d, tree_loc(p), "type of %s is %s which is a file type", istr(tree_ident(p)), type_pp(type)); diag_lrm(d, STD_08, "5.6.2"); diag_emit(d); } } } if (tree_kind(t) == T_FUNC_DECL) { type_t result = type_result(tree_type(t)); if (sem_has_access(result) || type_is_file(result)) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "return type of a protected type method cannot be " "of a file type, access type, or a composite type with " "a subelement that is an access type"); diag_lrm(d, STD_08, "5.6.2"); diag_emit(d); } } } return true; } static bool sem_check_func_result(tree_t t) { type_t result = type_result(tree_type(t)); if (type_is_protected(result)) sem_error(t, "function result subtype may not denote a protected type"); else if (type_is_file(result)) sem_error(t, "function result subtype may not denote a file type"); else if (!sem_check_incomplete(t, result)) return false; return true; } static bool sem_check_func_decl(tree_t t, nametab_t *tab) { const tree_flags_t flags = tree_flags(t); if (flags & TREE_F_PREDEFINED) return true; if (!sem_check_func_ports(t, tab)) return false; if (!sem_check_func_result(t)) return false; if ((flags & TREE_F_PROTECTED) && !sem_check_protected_method(t, tab)) return false; defer_check(tab, sem_missing_body_cb, t); return true; } static bool sem_compare_interfaces(tree_t decl, tree_t body, int nth, tree_t (*getfn)(tree_t, unsigned), const char *what) { tree_t dport = (*getfn)(decl, nth); tree_t bport = (*getfn)(body, nth); tree_flags_t dflags = tree_flags(dport); tree_flags_t bflags = tree_flags(bport); ident_t dname = tree_ident(dport); ident_t bname = tree_ident(bport); if (dname != bname) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(bport)); diag_printf(d, "%s name %s in subprogram %s body does not match " "name %s in declaration", what, istr(bname), istr(tree_ident(body)), istr(dname)); diag_hint(d, tree_loc(dport), "%s %s has name %s in specification", ordinal_str(nth + 1), what, istr(dname)); diag_hint(d, tree_loc(bport), "%s %s has name %s in body", ordinal_str(nth + 1), what, istr(bname)); diag_emit(d); return false; } const bool dcont = !!(tree_flags(dport) & TREE_F_CONTINUATION); const bool bcont = !!(tree_flags(bport) & TREE_F_CONTINUATION); if (dcont != bcont) { diag_t *d = pedantic_diag(tree_loc(bport)); if (d != NULL) { diag_printf(d, "declaration of %s %s in subprogram body does not " "match specification", what, istr(bname)); int bseq = 1; for (tree_t it = bport; tree_flags(it) & TREE_F_CONTINUATION; it = (*getfn)(body, nth - bseq++)); diag_hint(d, tree_loc(bport), "%s appears %s in identifier list", istr(bname), ordinal_str(bseq)); int dseq = 1; for (tree_t it = dport; tree_flags(it) & TREE_F_CONTINUATION; it = (*getfn)(decl, nth - dseq++)); diag_hint(d, tree_loc(dport), "%s appears %s in identifier list", istr(dname), ordinal_str(dseq)); diag_lrm(d, STD_08, "4.10"); diag_emit(d); return false; } } else if (dcont && bcont) return true; // Already checked first declaration in list type_t dtype = tree_type(dport); type_t btype = tree_type(bport); // Do not use type_eq here as subtype must exactly match if (!type_strict_eq(btype, dtype)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(bport)); diag_printf(d, "subtype of %s %s does not match type %s in " "specification", what, istr(bname), type_pp(dtype)); diag_hint(d, tree_loc(dport), "%s %s declared with type %s", what, istr(dname), type_pp(dtype)); diag_hint(d, tree_loc(bport), "%s %s declared with type %s ", what, istr(bname), type_pp(btype)); diag_emit(d); return false; } const port_mode_t dmode = tree_subkind(dport); const port_mode_t bmode = tree_subkind(bport); if (dmode != bmode) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(bport)); diag_printf(d, "%s %s of subprogram body %s with mode %s does not " "match mode %s in specification", what, istr(dname), istr(tree_ident(body)), port_mode_str(bmode), port_mode_str(dmode)); diag_hint(d, tree_loc(dport), "%s %s declared with mode %s", what, istr(dname), port_mode_str(dmode)); diag_hint(d, tree_loc(bport), "%s %s declared with mode %s", what, istr(bname), port_mode_str(bmode)); diag_emit(d); return false; } const bool bmode_explicit = !!(bflags & TREE_F_EXPLICIT_MODE); const bool dmode_explicit = !!(dflags & TREE_F_EXPLICIT_MODE); if (bmode_explicit != dmode_explicit) { diag_t *d = pedantic_diag(tree_loc(bport)); if (d != NULL) { const char *dmode_str = dmode_explicit ? port_mode_str(dmode) : "default"; const char *bmode_str = bmode_explicit ? port_mode_str(bmode) : "default"; diag_printf(d, "mode indication of subprogram %s %s %s was %s in " "specification but %s in body", istr(tree_ident(body)), what, istr(dname), dmode_str, bmode_str); diag_hint(d, tree_loc(dport), "%s %s declared with %s mode in " "specification", what, istr(dname), dmode_str); diag_hint(d, tree_loc(bport), "%s %s declared with %s mode in body", what, istr(bname), bmode_str); diag_lrm(d, STD_08, "4.10"); diag_emit(d); return false; } } const class_t dclass = tree_class(dport); const class_t bclass = tree_class(bport); if (dclass != bclass) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(bport)); diag_printf(d, "class %s of subprogram body %s %s %s does not " "match class %s in specification", class_str(bclass), istr(tree_ident(body)), what, istr(dname), class_str(dclass)); diag_hint(d, tree_loc(dport), "%s %s declared with class %s in " "subprogram specification", what, istr(dname), class_str(dclass)); diag_hint(d, tree_loc(bport), "%s %s declared with class %s in " "subprogram body", what, istr(bname), class_str(bclass)); diag_emit(d); return false; } const bool bclass_explicit = !!(bflags & TREE_F_EXPLICIT_CLASS); const bool dclass_explicit = !!(dflags & TREE_F_EXPLICIT_CLASS); if (bclass_explicit != dclass_explicit) { diag_t *d = pedantic_diag(tree_loc(bport)); if (d != NULL) { const char *dclass_str = dclass_explicit ? class_str(dclass) : "default"; const char *bclass_str = bclass_explicit ? class_str(bclass) : "default"; diag_printf(d, "class of subprogram %s %s %s was %s in specification " "but %s in body", istr(tree_ident(body)), what, istr(dname), dclass_str, bclass_str); diag_hint(d, tree_loc(dport), "%s %s declared with %s class in " "specification", what, istr(dname), dclass_str); diag_hint(d, tree_loc(bport), "%s %s declared with %s class in body", what, istr(bname), bclass_str); diag_lrm(d, STD_08, "4.10"); diag_emit(d); return false; } } tree_t bdef = tree_has_value(bport) ? tree_value(bport) : NULL; tree_t ddef = tree_has_value(dport) ? tree_value(dport) : NULL; if (bdef == NULL && ddef == NULL) return true; const tree_kind_t bkind = bdef ? tree_kind(bdef) : T_LAST_TREE_KIND; const tree_kind_t dkind = ddef ? tree_kind(ddef) : T_LAST_TREE_KIND; // Work around some mismatches caused by folding if (bdef != NULL && ddef != NULL && bkind != dkind) return true; if (dkind == bkind) { // This only covers a few simple cases switch (dkind) { case T_LITERAL: { const literal_kind_t dsub = tree_subkind(ddef); const literal_kind_t bsub = tree_subkind(bdef); if (dsub == bsub) { switch (dsub) { case L_INT: if (tree_ival(ddef) == tree_ival(bdef)) return true; break; case L_REAL: if (tree_dval(ddef) == tree_dval(bdef)) return true; break; default: return true; } } } break; case T_REF: case T_FCALL: if (!tree_has_ref(bdef) || !tree_has_ref(ddef)) return true; // Was parse error, ignore it tree_t bref = tree_ref(bdef); tree_t dref = tree_ref(ddef); if (bref == dref) return true; // Work around mismatch introduced by folding const tree_kind_t brefkind = tree_kind(bref); if (brefkind == T_CONST_DECL || brefkind == T_GENERIC_DECL) return true; break; default: return true; } } diag_t *d = diag_new(DIAG_ERROR, tree_loc(bport)); diag_printf(d, "default value of %s %s in subprogram body %s does not " "match declaration", what, istr(dname), istr(tree_ident(body))); diag_hint(d, tree_loc(dport), "parameter was originally declared here"); diag_hint(d, tree_loc(bport), "body has different default value"); diag_emit(d); return false; } static bool sem_check_conforming(tree_t decl, tree_t body) { // Conformance rules are in LRM 08 section 4.10 // Note we don't implement strict lexical conformance here bool ok = true; const bool dimpure = !!(tree_flags(decl) & TREE_F_IMPURE); const bool bimpure = !!(tree_flags(body) & TREE_F_IMPURE); if (dimpure != bimpure) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(body)); diag_printf(d, "function %s declaration was %s but body is %s", istr(tree_ident(body)), dimpure ? "impure" : "pure", bimpure ? "impure" : "pure"); diag_hint(d, tree_loc(decl), "declaration was %s", dimpure ? "impure" : "pure"); diag_hint(d, tree_loc(body), "expecting keyword %s to match declaration", bimpure ? "IMPURE" : "PURE"); diag_emit(d); ok = false; } // This must be true or they would be considered different overloads assert(tree_ports(decl) == tree_ports(body)); const int nports = tree_ports(decl); for (int i = 0; i < nports; i++) ok &= sem_compare_interfaces(decl, body, i, tree_port, "parameter"); const int ngenerics = tree_generics(decl); if (ngenerics != tree_generics(body)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(body)); diag_printf(d, "subprogram %s declaration has %d generic%s but body " "has %d", istr(tree_ident(body)), ngenerics, ngenerics > 1 ? "s" : "", tree_generics(body)); diag_hint(d, tree_loc(decl), "declaration with %d generics", ngenerics); diag_hint(d, tree_loc(body), "body has %d generics", tree_generics(body)); diag_emit(d); ok = false; } else { for (int i = 0; i < ngenerics; i++) ok &= sem_compare_interfaces(decl, body, i, tree_generic, "generic"); } type_t dtype = tree_type(decl); type_t btype = tree_type(body); if (type_has_result(dtype) && type_has_result(btype)) { type_t dresult = type_result(dtype); type_t bresult = type_result(btype); if (!type_strict_eq(dresult, bresult)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(body)); diag_printf(d, "return type of function body %s does not match type " "%s in specification", istr(tree_ident(body)), type_pp(dresult)); diag_hint(d, tree_loc(decl), "specification has return type %s", type_pp(dresult)); diag_hint(d, tree_loc(body), "body has return type %s ", type_pp(bresult)); diag_emit(d); ok = false; } } return ok; } static bool sem_check_func_body(tree_t t, nametab_t *tab) { if (!sem_check_func_ports(t, tab)) return false; if (!sem_check_func_result(t)) return false; tree_t fwd = find_forward_decl(tab, t); if (fwd != NULL && !sem_check_conforming(fwd, t)) return false; return true; } static bool sem_check_proc_decl(tree_t t, nametab_t *tab) { if (is_operator_symbol(tree_ident(t))) sem_error(t, "procedure name must be an identifier"); const tree_flags_t flags = tree_flags(t); if (flags & TREE_F_PREDEFINED) return true; else if ((flags & TREE_F_PROTECTED) && !sem_check_protected_method(t, tab)) return false; defer_check(tab, sem_missing_body_cb, t); return true; } static bool sem_check_proc_body(tree_t t, nametab_t *tab) { tree_t fwd = find_forward_decl(tab, t); if (fwd != NULL && !sem_check_conforming(fwd, t)) return false; if (fwd == NULL && is_operator_symbol(tree_ident(t))) sem_error(t, "procedure name must be an identifier"); // Cleared by wait statement or pcall tree_set_flag(t, TREE_F_NEVER_WAITS); return true; } static bool sem_check_subprogram_inst(tree_t t, nametab_t *tab) { if (tree_generics(t) == 0) return false; // Was a parse error if (!sem_check_generic_map(t, t, tab)) return false; // Other declarations were checked on the uninstantiated subprogram return true; } static bool sem_check_sensitivity(tree_t t, nametab_t *tab) { const int ntriggers = tree_triggers(t); for (int i = 0; i < ntriggers; i++) { tree_t r = tree_trigger(t, i); if (tree_kind(r) == T_ALL) continue; else if (!sem_check(r, tab) || !sem_check_readable(r)) return false; if (!sem_static_name(r, sem_globally_static)) sem_error(r, "name in sensitivity list is not a static signal name"); if (class_of(r) != C_SIGNAL) { tree_t ref = name_to_ref(r); diag_t *d = diag_new(DIAG_ERROR, tree_loc(r)); if (ref != NULL) { tree_t decl = tree_ref(ref); diag_printf(d, "name %s in sensitivity list is not a signal", istr(tree_ident(decl))); diag_hint(d, tree_loc(r), "%s is a %s", istr(tree_ident(decl)), class_str(class_of(decl))); } else diag_printf(d, "name in sensitivity list is not a signal"); diag_emit(d); return false; } } return true; } static void sem_check_missing_wait(tree_t t, nametab_t *tab) { if (!opt_get_int(OPT_MISSING_WAIT)) return; const int ntriggers = tree_triggers(t); if (ntriggers > 0) return; const tree_flags_t flags = tree_flags(t); if (flags & TREE_F_HAS_WAIT) return; diag_t *d = diag_new(DIAG_WARN, tree_loc(t)); diag_printf(d, "potential infinite loop in process"); if (!(flags & TREE_F_SYNTHETIC_NAME)) diag_printf(d, " %s", istr(tree_ident(t))); diag_printf(d, " with no sensitivity list and no wait statements."); diag_emit(d); } static bool sem_check_process(tree_t t, nametab_t *tab) { if (!sem_check_sensitivity(t, tab)) return false; sem_check_missing_wait(t, tab); return true; } static bool sem_check_package(tree_t t, nametab_t *tab) { if (!sem_check_context_clause(t, tab)) return false; if (tree_genmaps(t) > 0 && !sem_check_generic_map(t, t, tab)) return false; // Subprogram bodies are not allowed in package specification const int ndecls = tree_decls(t); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(t, i); tree_kind_t kind = tree_kind(d); if ((kind == T_FUNC_BODY) || (kind == T_PROC_BODY)) sem_error(d, "subprogram body is not allowed in package specification"); } return true; } static bool sem_check_pack_inst(tree_t t, nametab_t *tab) { if (tree_generics(t) == 0) return false; // Was a parse error if (!sem_check_generic_map(t, t, tab)) return false; // Other declarations were checked on the uninstantiated package return true; } static bool sem_check_missing_bodies(tree_t secondary, nametab_t *tab) { // Check for any missing subprogram or protected type bodies, and // deferred constants which were not given values and tree_t primary = tree_primary(secondary); const int ndecls = tree_decls(primary); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(primary, i); switch (tree_kind(d)) { case T_FUNC_DECL: case T_PROC_DECL: if (tree_flags(d) & TREE_F_PREDEFINED) break; // Fall-through case T_PROT_DECL: sem_missing_body_cb(d, secondary, tab); break; case T_CONST_DECL: if (!tree_has_value(d)) { tree_t d2 = get_local_decl(tab, NULL, tree_ident(d), 0); if (d2 == NULL || !tree_has_value(d2)) sem_error(d, "deferred constant %s was not given a value in the " "package body", istr(tree_ident(d))); } default: break; } } return true; } static bool sem_check_pack_body(tree_t t, nametab_t *tab) { if (!tree_has_primary(t)) return false; if (!sem_check_context_clause(t, tab)) return false; if (!sem_check_missing_bodies(t, tab)) return false; return true; } static bool sem_check_component(tree_t t, nametab_t *tab) { return true; } static void sem_passive_cb(tree_t t, void *context) { tree_t s = context; diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "signal assignment statement not allowed inside passive " "process"); diag_hint(d, tree_loc(s), "process in entity statement part must " "be passive"); diag_hint(d, tree_loc(t), "signal assignment statement"); diag_lrm(d, STD_93, "1.1.3"); diag_lrm(d, STD_93, "9.2"); diag_emit(d); } static bool sem_check_entity(tree_t t, nametab_t *tab) { if (!sem_check_context_clause(t, tab)) return false; // All processes in entity statement part must be passive const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(t, i); tree_visit_only(s, sem_passive_cb, s, T_SIGNAL_ASSIGN); } return true; } static bool sem_check_arch(tree_t t, nametab_t *tab) { if (!tree_has_primary(t)) return false; if (!sem_check_context_clause(t, tab)) return false; return true; } static tree_t sem_check_lvalue(tree_t t) { switch (tree_kind(t)) { case T_REF: return sem_check_lvalue(tree_ref(t)); case T_ARRAY_SLICE: case T_ARRAY_REF: case T_ALIAS: case T_RECORD_REF: case T_ALL: return sem_check_lvalue(tree_value(t)); case T_VAR_DECL: case T_SIGNAL_DECL: case T_PORT_DECL: case T_CONST_DECL: case T_IMPLICIT_SIGNAL: case T_PARAM_DECL: case T_EXTERNAL_NAME: return t; default: return NULL; } } static bool sem_check_aggregate_target_element(tree_t target, int nth) { tree_t a = tree_assoc(target, nth); tree_t value = tree_value(a); if (tree_kind(value) != T_AGGREGATE) { if (!sem_static_name(value, sem_locally_static)) sem_error(value, "aggregate element must be locally static name"); } const assoc_kind_t kind = tree_subkind(a); switch (kind) { case A_RANGE: if (standard() >= STD_08) { // LRM 08 section 10.6.2.1: it is an error if the element // association contains a choice that is a discrete range and // an expression of a type other than the aggregate type. diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "range choice expression must have same type " "as aggregate"); diag_hint(d, tree_loc(value), "expression type is %s but " "aggregate is %s", type_pp(tree_type(value)), type_pp(tree_type(target))); diag_lrm(d, STD_08, "10.6.2"); diag_emit(d); return false; } // Fall-through case A_OTHERS: sem_error(a, "%s association not allowed in aggregate target", assoc_kind_str(kind)); case A_NAMED: case A_POS: case A_SLICE: case A_CONCAT: break; } const int nassocs = tree_assocs(target); for (int j = nth + 1; j < nassocs; j++) { tree_t cmp = tree_value(tree_assoc(target, j)); if (same_tree(value, cmp)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(cmp)); diag_printf(d, "%s %s is identifed more than once in " "aggregate target", class_str(class_of(cmp)), tree_kind(cmp) == T_REF ? istr(tree_ident(cmp)) : "subelement"); diag_hint(d, tree_loc(value), "first seen here"); diag_lrm(d, STD_08, "10.5.2"); diag_emit(d); return false; } } return true; } static bool sem_check_variable_target(tree_t target) { if (tree_kind(target) == T_AGGREGATE) { // Rules for aggregate variable targets in LRM 93 section 8.5 type_t type = tree_type(target); if (!type_is_composite(type)) sem_error(target, "aggregate target of variable assignment has " "non-composite type %s", type_pp(tree_type(target))); const int nassocs = tree_assocs(target); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(target, i); tree_t value = tree_value(a); if (!sem_check_variable_target(value)) return false; if (!sem_check_aggregate_target_element(target, i)) return false; } } else { tree_t decl = sem_check_lvalue(target); const tree_kind_t kind = decl ? tree_kind(decl) : T_LAST_TREE_KIND; const bool suitable = kind == T_VAR_DECL || (kind == T_PARAM_DECL && tree_class(decl) == C_VARIABLE) || (kind == T_EXTERNAL_NAME && tree_class(decl) == C_VARIABLE); if (!suitable) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "target of variable assignment must be a variable " "name or aggregate"); tree_t ref = name_to_ref(target); if (ref != NULL && tree_has_ref(ref)) diag_hint(d, tree_loc(target), "%s is a %s", istr(tree_ident(ref)), class_str(class_of(tree_ref(ref)))); diag_emit(d); return false; } else if (kind == T_PARAM_DECL && tree_subkind(decl) == PORT_IN) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "cannot assign to parameter %s with mode IN", istr(tree_ident(decl))); diag_hint(d, tree_loc(decl), "%s declared with mode IN", istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of variable assignment"); diag_emit(d); return false; } else if (type_is_protected(tree_type(target))) sem_error(target, "may not assign to variable of a protected type"); } return true; } static bool sem_check_var_assign(tree_t t, nametab_t *tab) { tree_t target = tree_target(t); tree_t value = tree_value(t); if (!sem_check(target, tab)) return false; if (!sem_check(value, tab)) return false; if (!sem_check_readable(value)) return false; if (!sem_check_variable_target(target)) return false; if (!sem_check_same_type(value, target)) { type_t target_type = tree_type(target); type_t value_type = tree_type(value); sem_error(t, "type of value %s does not match type of target %s", type_pp2(value_type, target_type), type_pp2(target_type, value_type)); } return true; } static bool sem_check_waveforms(tree_t t, tree_t target, nametab_t *tab) { type_t std_time = std_type(NULL, STD_TIME); type_t expect = tree_type(target); const int nwaves = tree_waveforms(t); for (int i = 0; i < nwaves; i++) { tree_t waveform = tree_waveform(t, i); if (tree_has_value(waveform)) { tree_t value = tree_value(waveform); if (!sem_check(value, tab)) return false; if (!sem_check_readable(value)) return false; if (!sem_check_type(value, expect, tab)) sem_error(t, "type of value %s does not match type of target %s", type_pp2(tree_type(value), expect), type_pp2(expect, tree_type(value))); } else { tree_t decl = sem_check_lvalue(target); if (decl != NULL && !is_guarded_signal(decl)) sem_error(waveform, "a null waveform element is only valid when " "the target is a guarded signal"); } if (tree_has_delay(waveform)) { tree_t delay = tree_delay(waveform); if (!sem_check(delay, tab)) return false; if (!sem_check_type(delay, std_time, tab)) sem_error(delay, "type of delay must be %s but have %s", type_pp(std_time), type_pp(tree_type(delay))); } } return true; } static tree_t sem_check_view_target(tree_t target) { switch (tree_kind(target)) { case T_REF: { tree_t decl = tree_ref(target); if (tree_kind(decl) == T_PORT_DECL) { const port_mode_t mode = tree_subkind(decl); if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) return tree_value(decl); } return NULL; } case T_ARRAY_REF: case T_ARRAY_SLICE: return sem_check_view_target(tree_value(target)); case T_RECORD_REF: { tree_t view = sem_check_view_target(tree_value(target)); if (view == NULL) return NULL; bool converse = false; tree_t f = tree_ref(target); tree_t e = find_element_mode_indication(view, f, &converse); if (e == NULL) return NULL; if (converse_mode(e, converse) == PORT_IN) { tree_t port = tree_ref(name_to_ref(target)); diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "cannot assign to element %s of port %s which has " "mode IN from mode view indication", istr(tree_ident(e)), istr(tree_ident(port))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(port), "sub-element %s of %s declared with " "mode IN due to mode view indication", istr(tree_ident(e)), istr(tree_ident(port))); diag_emit(d); return NULL; } return NULL; } default: return NULL; } } static bool sem_check_signal_target(tree_t target, nametab_t *tab, bool guarded) { if (tree_kind(target) == T_AGGREGATE) { // Rules for aggregate signal targets in LRM 93 section 8.4 type_t type = tree_type(target); if (!type_is_composite(type)) sem_error(target, "aggregate target of signal assignment has " "non-composite type %s", type_pp(type)); bool has_guarded = false, has_unguarded = false; const int nassocs = tree_assocs(target); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(target, i); tree_t value = tree_value(a); if (!sem_check_signal_target(value, tab, guarded)) return false; if (!sem_check_aggregate_target_element(target, i)) return false; tree_t ref = name_to_ref(value); if (ref != NULL && is_guarded_signal(tree_ref(ref))) has_guarded = true; else has_unguarded = true; } if (has_guarded && has_unguarded) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "aggregate target of signal assignment contains both " "guarded and unguarded signals"); diag_lrm(d, STD_08, "11.6"); diag_emit(d); return false; } return true; } else { tree_t decl = sem_check_lvalue(target); if (decl == NULL) sem_error(target, "target of signal assignment must be a signal " "name or aggregate"); if (is_guarded_signal(decl) && !guarded) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "guarded signal %s cannot be the target of an " "unguarded assignment", istr(tree_ident(decl))); diag_hint(d, tree_loc(decl), "%s declared here", istr(tree_ident(decl))); diag_lrm(d, STD_08, "11.6"); diag_emit(d); return false; } switch (tree_kind(decl)) { case T_SIGNAL_DECL: { tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL && find_enclosing(tab, S_PROCESS) == NULL) { // LRM 08 section 10.5.2.2: if a signal assignment appears // in a procedure not contained within a process then the // target must be a formal parameter diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "signal %s is not a formal parameter and " "subprogram %s is not contained within a process " "statement", istr(tree_ident(decl)), type_pp(tree_type(sub))); diag_lrm(d, STD_08, "10.5.2.2"); diag_emit(d); return false; } } break; case T_IMPLICIT_SIGNAL: sem_error(target, "implicit signal may not be assigned"); case T_PORT_DECL: case T_PARAM_DECL: { const port_mode_t mode = tree_subkind(decl); if (mode == PORT_IN) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "cannot assign to input %s %s", tree_kind(decl) == T_PORT_DECL ? "port" : "parameter", istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(decl), "%s declared with mode IN", istr(tree_ident(decl))); diag_emit(d); return false; } else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { tree_t view = sem_check_view_target(target); if (view != NULL) { tree_t inport = NULL; type_t view_type = tree_type(view); const int nelems = type_fields(view_type); for (int i = 0; i < nelems; i++) { tree_t e = type_field(view_type, i); const port_mode_t mode = tree_subkind(e); if (mode == PORT_IN || mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { // This is not correct for nested mode view // indications but seems like a very obscure // corner case inport = e; break; } } if (inport != NULL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "cannot assign to port %s with mode view " "indication as one or more sub-elements have " "mode IN", istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(inport), "element %s declared with mode IN", istr(tree_ident(inport))); diag_emit(d); return false; } } return true; } else if (mode == PORT_LINKAGE) sem_error(target, "linkage port %s may not be updated except as " "an actual corresponding to an interface of mode " "linkage", istr(tree_ident(decl))); else if (tree_class(decl) != C_SIGNAL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "%s is not a valid target of signal assignment", istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(decl), "declared with class %s", class_str(tree_class(decl))); diag_emit(d); return false; } } break; case T_EXTERNAL_NAME: { if (tree_class(decl) != C_SIGNAL) { tree_t tail = tree_part(decl, tree_parts(decl) - 1); diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "external name %s is not a valid target of " "signal assignment", istr(tree_ident(tail))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(decl), "declared with class %s", class_str(tree_class(decl))); diag_emit(d); return false; } tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL && find_enclosing(tab, S_PROCESS) == NULL) sem_error(target, "cannot create driver for external name as " "subprogram %s is not contained within a process " "statement", type_pp(tree_type(sub))); } break; case T_VAR_DECL: case T_CONST_DECL: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "%s %s is not a valid target of signal assignment", class_str(class_of(decl)), istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(decl), "declared as %s", class_str(class_of(decl))); diag_emit(d); return false; } default: sem_error(target, "invalid target of signal assignment"); } return true; } } static bool sem_check_reject(tree_t t, nametab_t *tab) { if (!sem_check(t, tab)) return false; if (!type_eq(tree_type(t), std_type(NULL, STD_TIME))) sem_error(t, "reject interval must have type TIME but have %s", type_pp(tree_type(t))); return true; } static bool sem_check_signal_assign(tree_t t, nametab_t *tab) { tree_t target = tree_target(t); if (!sem_check(target, tab)) return false; if (!sem_check_signal_target(target, tab, true)) return false; if (!sem_check_waveforms(t, target, tab)) return false; if (tree_has_reject(t) && !sem_check_reject(tree_reject(t), tab)) return false; return true; } static bool sem_check_guard(tree_t t, nametab_t *tab) { assert(tree_kind(t) == T_GUARD); if (!sem_check_type(t, std_type(NULL, STD_BOOLEAN), tab)) sem_error(t, "guard signal must have BOOLEAN type but found %s", type_pp(tree_type(t))); tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_SIGNAL_DECL: case T_IMPLICIT_SIGNAL: break; case T_PORT_DECL: if (tree_class(decl) == C_SIGNAL) break; // Fall-through default: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "assignment guard must be a signal"); diag_hint(d, tree_loc(decl), "%s is a %s", istr(tree_ident(decl)), class_str(class_of(decl))); diag_hint(d, tree_loc(t), "guarded statement"); diag_emit(d); return false; } } return true; } static bool sem_check_cond_assign(tree_t t, nametab_t *tab) { tree_t target = tree_target(t); if (!sem_check(target, tab)) return false; const bool has_guard = tree_has_guard(t); if (!sem_check_signal_target(target, tab, has_guard)) return false; if (has_guard && !sem_check_guard(tree_guard(t), tab)) return false; type_t std_bool = std_type(NULL, STD_BOOLEAN); const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(t, i); if (tree_has_value(c)) { tree_t test = tree_value(c); if (!sem_check(test, tab)) return false; if (!type_eq(tree_type(test), std_bool)) sem_error(test, "type of condition must be BOOLEAN"); } assert(tree_stmts(c) == 1); tree_t a = tree_stmt(c, 0); assert(tree_kind(a) == T_SIGNAL_ASSIGN); assert(tree_target(a) == target); if (tree_has_reject(a) && !sem_check_reject(tree_reject(a), tab)) return false; if (!sem_check_waveforms(a, target, tab)) return false; } return true; } static bool sem_check_closely_related(type_t from, type_t to, tree_t where) { if (type_eq(to, from)) return true; // Conversions are allowed between any abstract numeric types if (type_is_numeric(from) && type_is_numeric(to)) return true; // Suppress cascading errors if (type_is_none(from) || type_is_none(to)) return true; char *reason = NULL; if (type_is_array(from) && type_is_array(to)) { const int from_dims = dimension_of(from); const int to_dims = dimension_of(to); // Types must have same dimensionality if (from_dims != to_dims) { reason = xasprintf("%s has %d dimension%s but %s has %d", type_pp2(from, to), from_dims, from_dims == 1 ? "" : "s", type_pp2(to, from), to_dims); goto not_closely_related; } // Index types the same or closely related for (int i = 0; i < from_dims; i++) { type_t from_index = index_type_of(from, i); type_t to_index = index_type_of(to, i); if (!sem_check_closely_related(from_index, to_index, NULL)) { reason = xasprintf("%s index type of %s is %s which is not closely " "related to the %s index type of %s", ordinal_str(i + 1), type_pp2(from, to), type_pp(from_index), ordinal_str(i + 1), type_pp2(to, from)); goto not_closely_related; } } type_t from_e = type_elem(from); type_t to_e = type_elem(to); if (standard() >= STD_08) { // Element types must be closely related if (!sem_check_closely_related(from_e, to_e, NULL)) { reason = xasprintf("element type %s is not closely related to %s", type_pp2(from_e, to_e), type_pp2(to_e, from_e)); goto not_closely_related; } } else { // Element types must be the same if (!type_eq(from_e, to_e)) { reason = xasprintf("element type %s does not match %s", type_pp2(from_e, to_e), type_pp2(to_e, from_e)); goto not_closely_related; } } return true; } if (type_is_record(from) && type_is_record(to) && standard() >= STD_19) { // Each element of the target type must have a matching element in // the from type const int from_nf = type_fields(from); const int to_nf = type_fields(to); for (int i = 0; i < to_nf; i++) { tree_t to_f = type_field(to, i), from_f = NULL; type_t to_ftype = tree_type(to_f); ident_t name = tree_ident(to_f); for (int j = 0; j < from_nf && from_f == NULL; j++) { tree_t f = type_field(from, j); if (tree_ident(f) != name) continue; type_t from_ftype = tree_type(f); if (!sem_check_closely_related(from_ftype, to_ftype, NULL)) break; from_f = f; } if (from_f != NULL) continue; reason = xasprintf("field %s in record type %s has no matching " "element in type %s", istr(tree_ident(to_f)), type_pp2(to, from), type_pp2(from, to)); goto not_closely_related; } return true; } not_closely_related: if (where != NULL) { const loc_t *loc = tree_loc(where); diag_t *d = diag_new(DIAG_ERROR, loc); diag_printf(d, "conversion only allowed between closely related types"); if (reason != NULL) diag_hint(d, loc, "%s", reason); else diag_hint(d, loc, "%s and %s are not closely related", type_pp2(from, to), type_pp2(to, from)); diag_lrm(d, STD_93, "7.3.5"); diag_emit(d); free(reason); } return false; } static bool sem_check_conversion(tree_t t, nametab_t *tab) { // Type conversions are described in LRM 93 section 7.3.5 tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; return sem_check_closely_related(tree_type(value), tree_type(t), t); } static bool sem_check_compatible_view(tree_t formal, tree_t actual) { type_t type = tree_type(formal); type_t elem_type = type; if (tree_subkind(formal) == PORT_ARRAY_VIEW) elem_type = type_elem(type); tree_t formal_view = tree_value(formal); tree_t actual_view = sem_check_view_target(actual); if (actual_view != NULL) { // Associating an interface with another interface: check the // mode of each element is compatible const int nfields = type_fields(elem_type); for (int i = 0; i < nfields; i++) { tree_t f = type_field(elem_type, i); bool formal_converse = false; tree_t formal_elem = find_element_mode_indication(formal_view, f, &formal_converse); bool actual_converse = false; tree_t actual_elem = find_element_mode_indication(actual_view, f, &actual_converse); const port_mode_t formal_mode = converse_mode(formal_elem, formal_converse); const port_mode_t actual_mode = converse_mode(actual_elem, actual_converse); if (formal_mode != actual_mode) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(actual)); diag_printf(d, "mode view indication of formal %s %s " "element %s is not compatible with actual", tree_kind(formal) == T_PORT_DECL ? "port" : "parameter", istr(tree_ident(formal)), istr(tree_ident(f))); diag_hint(d, tree_loc(actual_view), "actual has mode %s from " "mode view indication on port %s", port_mode_str(actual_mode), istr(tree_ident(name_to_ref(actual)))); diag_hint(d, tree_loc(formal_view), "formal has mode %s", port_mode_str(formal_mode)); diag_emit(d); return false; } } } return true; } static bool sem_check_call_args(tree_t t, tree_t decl, nametab_t *tab) { const int nparams = tree_params(t); const int nports = tree_ports(decl); if (is_uninstantiated_subprogram(decl)) { // Allow recursive calls to the same subprogram tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != decl) sem_error(t, "cannot call uninstantiated %s %s", class_str(class_of(decl)), istr(tree_ident(decl))); } tree_t *map LOCAL = xcalloc_array(nports, sizeof(tree_t)); bool have_named = false; for (int i = 0; i < nparams; i++) { tree_t param = tree_param(t, i), port = NULL; type_t port_type = NULL; bool partial = false; int index = -1; switch (tree_subkind(param)) { case P_POS: if (have_named) sem_error(param, "positional parameters must precede named " "parameters"); else if ((index = tree_pos(param)) >= nports) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(param)); diag_printf(d, "too many positional parameters for subprogram %s", type_pp(tree_type(decl))); diag_hint(d, tree_loc(param), "%s positional parameter", ordinal_str(index + 1)); diag_hint(d, tree_loc(decl), "%s %s has %d formal parameter%s", class_str(class_of(decl)), istr(tree_ident(decl)), nports, nports > 1 ? "s" : ""); diag_emit(d); return false; } else { port = tree_port(decl, index); port_type = tree_type(port); } break; case P_NAMED: { have_named = true; tree_t name = tree_name(param); const tree_kind_t name_kind = tree_kind(name); if (name_kind == T_TYPE_CONV || name_kind == T_FCALL) sem_error(name, "sorry, conversions are not yet supported here"); else if (!sem_check(name, tab)) return false; if (tree_kind(name) == T_TYPE_CONV) { type_t to_type = tree_type(name); type_t from_type = tree_type(tree_value(name)); const bool missing_constraints = type_is_unconstrained(from_type) && type_is_unconstrained(to_type); if (missing_constraints) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(name)); diag_printf(d, "result of conversion for unconstrained " "formal %s must be a constrained array type", istr(tree_ident(decl))); diag_lrm(d, STD_93, "3.2.1.1"); diag_emit(d); return false; } } tree_t ref = name_to_ref(name); assert(ref != NULL); if ((partial = (ref != name))) { tree_t value = tree_value(name); if (tree_kind(value) != T_REF) sem_error(name, "sorry, this form of named parameter is " "not supported"); } ident_t id = tree_ident(ref); for (int j = 0; j < nports; j++) { tree_t p = tree_port(decl, j); if (tree_ident(p) == id) { index = j; port = p; break; } } if (index == -1) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(param)); diag_printf(d, "subprogram %s has no parameter named %s", type_pp(tree_type(decl)), istr(id)); diag_hint(d, tree_loc(decl), "subprogram defined here"); diag_emit(d); return false; } if (!tree_has_ref(ref)) { // Should have generated an error during overload // resolution assert(error_count() > 0); return false; } // Set the ref again here because solve_types may have set it // to the wrong overload if (tree_ref(ref) != port) tree_set_name(param, (name = change_ref(name, port))); port_type = tree_type(name); } } class_t class = tree_class(port); port_mode_t mode = tree_subkind(port); if (map[index] != NULL && (!partial || tree_kind(map[index]) == T_REF)) sem_error(param, "formal parameter %s already has an associated " "actual", istr(tree_ident(port))); map[index] = param; tree_t value = tree_value(param); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, port_type, tab)) sem_error(value, "type of actual %s does not match formal %s type %s", type_pp2(tree_type(value), port_type), istr(tree_ident(port)), type_pp2(port_type, tree_type(value))); // LRM 08 sections 4.2.2.2 and 4.2.2.3 if (class == C_VARIABLE || class == C_SIGNAL) { tree_t decl = sem_check_lvalue(value); if (decl == NULL || class_of(value) != class) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "actual for formal %s with class %s must be " "a name denoting a %s", istr(tree_ident(port)), class == C_VARIABLE ? "VARIABLE" : "SIGNAL", class_str(class)); if (decl == NULL) diag_hint(d, tree_loc(value), "actual designator is not a name"); else if (tree_kind(decl) == T_EXTERNAL_NAME) diag_hint(d, tree_loc(value), "external name has class %s", class_str(tree_class(decl))); else diag_hint(d, tree_loc(value), "object %s has class %s", istr(tree_ident(decl)), class_str(class_of(decl))); diag_lrm(d, STD_08, class == C_SIGNAL ? "4.2.2.3" : "4.2.2.2"); diag_emit(d); return false; } // Check OUT and INOUT parameters can be assigned to if (mode == PORT_OUT || mode == PORT_INOUT) { const tree_kind_t decl_kind = tree_kind(decl); if ((decl_kind == T_PARAM_DECL || decl_kind == T_PORT_DECL) && tree_subkind(decl) == PORT_IN) { const char *what = decl_kind == T_PARAM_DECL ? "parameter" : "port"; diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "cannot associate %s %s of mode IN with " "formal %s of mode %s", what, istr(tree_ident(decl)), istr(tree_ident(port)), port_mode_str(mode)); diag_hint(d, tree_loc(decl), "%s declared with mode %s", istr(tree_ident(decl)), port_mode_str(tree_subkind(decl))); diag_hint(d, tree_loc(value), "associated with %s %s %s here", port_mode_str(mode), what, istr(tree_ident(port))); diag_emit(d); return false; } else if (decl_kind == T_SIGNAL_DECL && class == C_SIGNAL) { tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL && find_enclosing(tab, S_PROCESS) == NULL) { // LRM 08 section 10.5.2.2: if a signal is associated // with an inout or out signal parameter in a subprogram // call within a procedure not contained within a process // then the target must be a formal parameter diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "signal %s is not a formal parameter and " "subprogram %s is not contained within a process " "statement", istr(tree_ident(decl)), type_pp(tree_type(sub))); diag_lrm(d, STD_08, "10.5.2.2"); diag_emit(d); return false; } } } else if ((mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) && !sem_check_compatible_view(port, value)) return false; } if (class == C_SIGNAL && !sem_static_name(value, sem_globally_static)) { diag_t *d = pedantic_diag(tree_loc(value)); if (d != NULL) { diag_printf(d, "actual associated with signal parameter %s must be " "denoted by a static signal name", istr(tree_ident(port))); diag_hint(d, tree_loc(value), "not a static signal name"); diag_lrm(d, STD_08, "4.2.2.3"); diag_lrm(d, STD_08, "8.1"); diag_emit(d); return false; } } // Check IN and INOUT parameters can be read if (tree_kind(t) != T_ATTR_REF) { const port_mode_t mode = tree_subkind(port); if (mode == PORT_IN || mode == PORT_INOUT) { if (!sem_check_readable(value)) return false; } } if (tree_kind(value) == T_OPEN && !tree_has_value(port)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(param)); diag_printf(d, "OPEN actual for formal parameter %s without " "default value", istr(tree_ident(port))); diag_hint(d, tree_loc(port), "%s declared here", istr(tree_ident(port))); diag_emit(d); return false; } } for (int i = 0; i < nports; i++) { if (map[i] == NULL) { tree_t port = tree_port(decl, i); if (!tree_has_value(port)) sem_error(t, "missing actual for formal parameter %s without " "default value", istr(tree_ident(port))); else { const port_mode_t mode = tree_subkind(port); if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) sem_error(t, "missing actual for formal parameter %s with " "mode view indication %s", istr(tree_ident(port)), type_pp(tree_type(tree_value(port)))); } } } return true; } static bool sem_check_fcall(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; if (tree_kind(t) == T_PROT_FCALL && tree_has_name(t)) { tree_t name = tree_name(t); if (!sem_check(name, tab)) return false; } tree_t decl = tree_ref(t), sub; const tree_flags_t flags = tree_flags(decl); if ((flags & TREE_F_IMPURE) && (sub = find_enclosing(tab, S_SUBPROGRAM))) { // Pure function may not call an impure function if (tree_kind(sub) == T_FUNC_BODY && !(tree_flags(sub) & TREE_F_IMPURE)) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "pure function %s cannot call impure function %s", istr(tree_ident(sub)), istr(tree_ident(decl))); diag_emit(d); } } // Propagate impurity flags tree_set_flag(sub, flags & (TREE_F_IMPURE_FILE | TREE_F_IMPURE_SHARED)); } else if (tree_kind(decl) == T_FUNC_DECL && !(flags & TREE_F_PREDEFINED) && is_same_region(tab, decl) && opt_get_int(OPT_MISSING_BODY)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "subprogram %s called before its body has been " "elaborated", type_pp(tree_type(decl))); diag_hint(d, tree_loc(decl), "%s declared here", type_pp(tree_type(decl))); diag_lrm(d, STD_08, "14.4.2"); diag_emit(d); return false; } if (!sem_check_call_args(t, decl, tab)) return false; if (sem_locally_static(t)) tree_set_flag(t, TREE_F_LOCALLY_STATIC | TREE_F_GLOBALLY_STATIC); else if (sem_globally_static(t)) tree_set_flag(t, TREE_F_GLOBALLY_STATIC); return true; } static bool sem_check_pcall(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; const bool is_protected = (tree_kind(t) == T_PROT_PCALL); if (is_protected && tree_has_name(t) && !sem_check(tree_name(t), tab)) return false; tree_t decl = tree_ref(t); switch (class_of(decl)) { case C_PROCEDURE: break; case C_FUNCTION: sem_error(t, "function %s cannot be called as a procedure", type_pp(tree_type(decl))); default: // All other errors should be caught at parsing stage assert(error_count() > 0); return false; } if (!sem_check_call_args(t, decl, tab)) return false; const tree_flags_t flags = tree_flags(decl); const bool never_waits = is_protected || !!(flags & TREE_F_NEVER_WAITS); const bool has_wait = !is_protected && !!(flags & TREE_F_HAS_WAIT); assert(!never_waits || !has_wait); tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL) { if (!never_waits) tree_clear_flag(sub, TREE_F_NEVER_WAITS); if (has_wait) tree_set_flag(sub, TREE_F_HAS_WAIT); if (flags & TREE_F_IMPURE_FILE) tree_set_flag(sub, TREE_F_IMPURE_FILE); if (flags & TREE_F_IMPURE_SHARED) tree_set_flag(sub, TREE_F_IMPURE_SHARED); const bool in_func = tree_kind(sub) == T_FUNC_BODY; const bool in_pure_func = in_func && !(tree_flags(sub) & TREE_F_IMPURE); if (has_wait && in_func) sem_error(t, "function %s cannot call procedure %s which contains " "a wait statement", istr(tree_ident(sub)), istr(tree_ident(decl))); else if ((flags & TREE_F_IMPURE_FILE) && in_pure_func) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "pure function %s cannot call procedure %s which " "references a file object", istr(tree_ident(sub)), istr(tree_ident(decl))); diag_emit(d); } } else if ((flags & TREE_F_IMPURE_SHARED) && in_pure_func) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "pure function %s cannot call procedure %s which " "references a shared variable", istr(tree_ident(sub)), istr(tree_ident(decl))); diag_emit(d); } } } if (!never_waits) { // Procedure may wait, suppress infinite loop warning tree_t proc = find_enclosing(tab, S_PROCESS); if (proc != NULL) tree_set_flag(proc, TREE_F_HAS_WAIT); } return true; } static bool sem_check_wait(tree_t t, nametab_t *tab) { if (tree_has_delay(t)) { type_t std_time = std_type(NULL, STD_TIME); tree_t delay = tree_delay(t); if (!sem_check(delay, tab)) return false; if (!sem_check_type(delay, std_time, tab)) sem_error(delay, "type of delay must be %s but have %s", type_pp(std_time), type_pp(tree_type(delay))); } if (tree_has_value(t)) { type_t std_bool = std_type(NULL, STD_BOOLEAN); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of condition must be BOOLEAN but have %s", type_pp(tree_type(value))); } if (find_enclosing(tab, S_PROTECTED)) sem_error(t, "wait statement not allowed in protected subprogram body"); tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL) { if (tree_kind(sub) == T_FUNC_BODY) sem_error(t, "wait statement not allowed in function body"); tree_clear_flag(sub, TREE_F_NEVER_WAITS); tree_set_flag(sub, TREE_F_HAS_WAIT); } tree_t proc = find_enclosing(tab, S_PROCESS); if (proc != NULL) { // No wait statements allowed in process with sensitivity list if (tree_triggers(proc) > 0) sem_error(t, "wait statement not allowed in process with " "sensitvity list"); tree_set_flag(proc, TREE_F_HAS_WAIT); } return sem_check_sensitivity(t, tab); } static bool sem_check_assert(tree_t t, nametab_t *tab) { // Rules for asserion statements are in LRM 93 section 8.2 tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t std_bool = std_type(NULL, STD_BOOLEAN); if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of assertion expression must be %s but " "is %s", type_pp(std_bool), type_pp(tree_type(value))); if (tree_has_message(t)) { tree_t message = tree_message(t); if (!sem_check(message, tab)) return false; type_t std_string = std_type(NULL, STD_STRING); if (!sem_check_type(message, std_string, tab)) sem_error(message, "type of message be %s but is %s", type_pp(std_string), type_pp(tree_type(message))); } if (tree_has_severity(t)) { tree_t severity = tree_severity(t); if (!sem_check(severity, tab)) return false; type_t std_severity = std_type(NULL, STD_SEVERITY_LEVEL); if (!sem_check_type(severity, std_severity, tab)) sem_error(severity, "type of severity must be %s but is %s", type_pp(std_severity), type_pp(tree_type(severity))); } return true; } static bool sem_check_report(tree_t t, nametab_t *tab) { tree_t message = tree_message(t); if (!sem_check(message, tab)) return false; type_t std_string = std_type(NULL, STD_STRING); if (!sem_check_type(message, std_string, tab)) sem_error(message, "type of message be %s but is %s", type_pp(std_string), type_pp(tree_type(message))); if (tree_has_severity(t)) { tree_t severity = tree_severity(t); if (!sem_check(severity, tab)) return false; type_t std_severity = std_type(NULL, STD_SEVERITY_LEVEL); if (!sem_check_type(severity, std_severity, tab)) sem_error(severity, "type of severity must be %s but is %s", type_pp(std_severity), type_pp(tree_type(severity))); } return true; } static bool sem_check_string_literal(tree_t t) { // String literals are in LRM 93 section 7.3.1 type_t type = tree_type(t); type_t elem = type_base_recur(type_elem(type)); if (type_is_none(elem)) return false; const int nlits = type_enum_literals(elem); const int nchars = tree_chars(t); for (int i = 0; i < nchars; i++) { tree_t ch = tree_char(t, i); ident_t ch_i = tree_ident(ch); bool valid = false; for (int j = 0; !valid && (j < nlits); j++) { tree_t lit = type_enum_literal(elem, j); if (ch_i == tree_ident(lit)) valid = true; } if (!valid) sem_error(t, "invalid character %s in string literal of type %s", istr(ch_i), type_pp(type)); } return true; } static bool sem_check_literal(tree_t t) { type_t type = tree_type(t); if (type_is_none(type)) return false; return true; } static bool sem_check_array_aggregate(tree_t t, nametab_t *tab) { type_t composite_type = tree_type(t); type_t base_type = type_base_recur(composite_type); type_t elem_type = NULL; const int ndims = dimension_of(composite_type); if (ndims == 1) elem_type = type_elem(base_type); else { // Higher dimensions must be specified with a sub-aggregate or // string literal tree_t a0 = tree_value(tree_assoc(t, 0)); const tree_kind_t a0_kind = tree_kind(a0); if (a0_kind != T_AGGREGATE && a0_kind != T_STRING) sem_error(a0, "second dimension of %d dimensional array type %s must " "be specified by a sub-aggregate, string, or bit-string " "literal", ndims, type_pp(composite_type)); // The parser will have constructed a type with ndims - 1 // dimensions. elem_type = tree_type(tree_value(tree_assoc(t, 0))); if (!type_is_unconstrained(elem_type)) { if (!sem_check_array_dims(elem_type, NULL, tab)) return false; } } type_t index_type = index_type_of(composite_type, 0); bool have_named = false; bool have_pos = false; const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); const assoc_kind_t akind = tree_subkind(a); switch (akind) { case A_RANGE: case A_SLICE: { tree_t r = tree_range(a, 0); if (!sem_check_discrete_range(r, index_type, tab)) return false; have_named = true; } break; case A_NAMED: { tree_t name = tree_name(a); if (!sem_check(name, tab)) return false; if (!sem_check_type(name, index_type, tab)) sem_error(name, "type of array aggregate choice %s does not " "match %s index type %s", type_pp(tree_type(name)), type_pp(composite_type), type_pp(index_type)); have_named = true; } break; case A_POS: case A_CONCAT: have_pos = true; break; case A_OTHERS: break; } tree_t value = tree_value(a); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, elem_type, tab)) { // LRM 08 section 9.3.3.3 allows the association to be of the // base aggregate type as well const bool allow_slice = (akind == A_CONCAT || akind == A_SLICE) || (ndims == 1 && standard() >= STD_08 && (akind == A_POS || akind == A_RANGE)); if (allow_slice && !sem_check_type(value, composite_type, tab)) sem_error(value, "type of %s association %s does not match " "aggregate element type %s or the aggregate type " "itself %s", assoc_kind_str(akind), type_pp(tree_type(value)), type_pp(elem_type), type_pp(composite_type)); else if (!allow_slice) sem_error(value, "type of %s association %s does not match " "aggregate element type %s", assoc_kind_str(akind), type_pp(tree_type(value)), type_pp(elem_type)); else assert(akind == A_CONCAT || akind == A_SLICE); } } // Named and positional associations cannot be mixed in array // aggregates if (have_named && have_pos) sem_error(t, "named and positional associations cannot be " "mixed in array aggregates"); // If a choice is not locally static then it must be the only element if (have_named && nassocs > 1) { for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); tree_t choice = NULL; switch (tree_subkind(a)) { case A_NAMED: choice = tree_name(a); break; case A_SLICE: case A_RANGE: choice = tree_range(a, 0); break; } if (choice && !sem_locally_static(choice)) sem_error(choice, "a choice that is not locally static is allowed" " only if the array aggregate contains a single element" " association"); } } return true; } static bool sem_check_record_aggregate(tree_t t, nametab_t *tab) { // Checks for record aggregates are given in LRM 93 section 7.3.2.1 type_t composite_type = tree_type(t); type_t base_type = type_base_recur(composite_type); const int nfields = type_fields(base_type); int pos = 0; LOCAL_BIT_MASK have; mask_init(&have, nfields); const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); int f = -1; switch (tree_subkind(a)) { case A_NAMED: { tree_t name = tree_name(a); if (tree_kind(name) != T_REF) sem_error(name, "association choice must be a field name"); else if (!tree_has_ref(name)) return false; // Was parse error tree_t fdecl = tree_ref(name); if (tree_kind(fdecl) != T_FIELD_DECL) return false; // Was parse error f = tree_pos(fdecl); } break; case A_POS: { if (pos >= nfields) sem_error(a, "%d positional associations given but record type" " %s only has %d fields", pos + 1, type_pp(composite_type), nfields); f = pos++; } break; case A_OTHERS: f = -1; break; case A_RANGE: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(tree_range(a, 0))); diag_printf(d, "an element association with a choice that is " "a discrete range is only allowed in an array " "aggregate"); diag_lrm(d, STD_08, "9.3.3"); diag_emit(d); return false; } case A_SLICE: case A_CONCAT: should_not_reach_here(); } int nmatched = 0; for (int j = 0; j < nfields; j++) { if ((f != -1) && (f != j)) continue; tree_t field = type_field(base_type, j); type_t field_type = tree_type(field); if (mask_test(&have, j)) { if (f == -1) continue; tree_t ak = NULL; for (int k = 0; k < i; k++) { ak = tree_assoc(t, k); if (tree_subkind(ak) == A_POS && tree_pos(ak) == j) break; else if (tree_pos(tree_ref(tree_name(ak))) == j) break; } assert(ak != NULL); diag_t *d = diag_new(DIAG_ERROR, tree_loc(a)); diag_printf(d, "field %s was already given a value by earlier " "%s choice", istr(tree_ident(field)), assoc_kind_str(tree_subkind(ak))); diag_hint(d, tree_loc(ak), "first choice associated with field %s", istr(tree_ident(field))); diag_hint(d, tree_loc(a), "duplicate choice here"); diag_emit(d); return false; } tree_t value = tree_value(a); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, field_type, tab)) sem_error(value, "type of value %s does not match type %s" " of field %s", type_pp2(tree_type(value), field_type), type_pp2(field_type, tree_type(value)), istr(tree_ident(field))); mask_set(&have, j); nmatched++; } if (f == -1 && nmatched == 0) sem_error(a, "others association must represent at least one element"); } for (int i = 0; i < nfields; i++) { if (!mask_test(&have, i)) { tree_t field = type_field(base_type, i); sem_error(t, "field %s does not have a value", istr(tree_ident(field))); } } return true; } static bool sem_check_aggregate(tree_t t, nametab_t *tab) { // Rules for aggregates are in LRM 93 section 7.3.2 type_t composite_type = tree_type(t); if (type_is_none(composite_type)) return false; assert(type_is_composite(composite_type)); // All positional associations must appear before named associations // and those must appear before any others association enum { POS, NAMED, OTHERS } state = POS; const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); switch (tree_subkind(a)) { case A_POS: case A_CONCAT: if (state > POS) sem_error(a, "positional associations must appear " "first in aggregate"); break; case A_NAMED: case A_RANGE: case A_SLICE: if (state > NAMED) sem_error(a, "named association must not follow " "others association in aggregate"); state = NAMED; break; case A_OTHERS: if (state == OTHERS) sem_error(a, "only a single others association " "allowed in aggregate"); state = OTHERS; break; } } if (type_is_array(composite_type)) return sem_check_array_aggregate(t, tab); else return sem_check_record_aggregate(t, tab); } static bool sem_check_ref(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; type_t type = get_type_or_null(t); if (type != NULL && type_is_none(type)) return false; tree_t decl = tree_ref(t); const tree_kind_t kind = tree_kind(decl); switch (kind) { case T_PORT_DECL: case T_VAR_DECL: case T_SIGNAL_DECL: case T_FILE_DECL: case T_ENUM_LIT: case T_UNIT_DECL: case T_FUNC_DECL: case T_FUNC_BODY: case T_FUNC_INST: case T_PROC_DECL: case T_PROC_BODY: case T_PROC_INST: case T_IMPLICIT_SIGNAL: case T_PARAM_DECL: break; case T_CONST_DECL: if (!tree_has_value(decl) && is_same_region(tab, decl)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "cannot reference deferred constant %s before the " "elaboration of the corresponding full declaration", istr(tree_ident(decl))); diag_hint(d, tree_loc(decl), "%s declared here", istr(tree_ident(decl))); diag_lrm(d, STD_08, "4.8"); diag_emit(d); return false; } break; case T_ALIAS: { switch (class_of(decl)) { case C_VARIABLE: case C_SIGNAL: case C_CONSTANT: case C_LITERAL: break; case C_DEFAULT: return false; // Must have been an earlier parse error default: sem_error(t, "invalid use of alias %s", istr(tree_ident(decl))); } } break; case T_GENERIC_DECL: if (tree_class(decl) == C_CONSTANT) break; // Fall-through default: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "invalid use of %s %s", class_str(class_of(decl)), istr(tree_ident(t))); diag_hint(d, tree_loc(decl), "%s declared here", istr(tree_ident(decl))); diag_emit(d); return false; } } tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub != NULL) { if (kind == T_FILE_DECL) tree_set_flag(sub, TREE_F_IMPURE_FILE); else if (kind == T_VAR_DECL && (tree_flags(decl) & TREE_F_SHARED)) tree_set_flag(sub, TREE_F_IMPURE_SHARED); const bool is_pure_func = tree_kind(sub) == T_FUNC_BODY && !(tree_flags(sub) & TREE_F_IMPURE); if (is_pure_func) { const class_t class = class_of(decl); if (class == C_VARIABLE || class == C_SIGNAL || class == C_FILE) { tree_t container = get_container(tab, decl); if (container != NULL && container != sub) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "cannot reference %s %s in pure function %s", class_str(class), istr(tree_ident(decl)), istr(tree_ident(sub))); diag_lrm(d, STD_08, "4.3"); diag_emit(d); return false; } } } } return true; } static bool sem_check_name_prefix(tree_t t, nametab_t *tab, const char *what) { // The prefix of a name may only be function call or another name switch (tree_kind(t)) { case T_FCALL: case T_PROT_FCALL: case T_REF: case T_ATTR_REF: case T_ALL: case T_ARRAY_REF: case T_ARRAY_SLICE: case T_RECORD_REF: case T_EXTERNAL_NAME: break; default: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "the prefix of %s must be a name or a " "function call", what); diag_lrm(d, STD_08, "8.1"); diag_emit(d); return false; } } return true; } static bool sem_check_record_ref(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!tree_has_ref(t)) return false; if (!sem_check_name_prefix(value, tab, "a selected name")) return false; return true; } static bool sem_check_array_ref(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_name_prefix(value, tab, "an indexed name")) return false; type_t type = tree_type(value); if (!type_is_array(type)) return false; // Checked earlier const int nindex = dimension_of(type); const int nparams = tree_params(t); if (nparams != nindex) sem_error(t, "prefix of indexed name has %d dimensions but %d " "indices given", nindex, nparams); bool ok = true; for (int i = 0; i < nparams; i++) { tree_t p = tree_param(t, i); assert(tree_subkind(p) == P_POS); type_t expect = index_type_of(type, i); tree_t value = tree_value(p); ok = sem_check(value, tab) && ok; if (ok && !sem_check_type(value, expect, tab)) sem_error(value, "type of index %s does not match type of " "array dimension %s", type_pp(tree_type(value)), type_pp(expect)); } return ok; } static bool sem_check_array_slice(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_name_prefix(value, tab, "a slice name")) return false; type_t array_type = tree_type(value); if (type_is_none(array_type)) return false; else if (!sem_check_incomplete(t, array_type)) return false; else if (!type_is_array(array_type)) sem_error(t, "type of slice prefix %s is not an array", type_pp(array_type)); tree_t r = tree_range(t, 0); if (!sem_check_discrete_range(r, index_type_of(array_type, 0), tab)) return false; const bool unconstrained = type_is_unconstrained(array_type); const range_kind_t prefix_dir = unconstrained ? RANGE_EXPR : direction_of(array_type, 0); const range_kind_t rkind = tree_subkind(r); const bool wrong_dir = !unconstrained && rkind != prefix_dir && (rkind == RANGE_TO || rkind == RANGE_DOWNTO) && (prefix_dir == RANGE_TO || prefix_dir == RANGE_DOWNTO); if (wrong_dir) { const char *text[] = { "TO", "DOWNTO", "?", "??", "???" }; sem_error(t, "range direction of slice %s does not match prefix %s", text[rkind], text[prefix_dir]); } return true; } static bool sem_check_signal_attr(tree_t t) { tree_t name = tree_name(t); if (tree_kind(name) == T_ATTR_REF) return sem_check_signal_attr(name); tree_t ref = name_to_ref(name); if (ref != NULL && class_of(ref) == C_SIGNAL) return true; sem_error(t, "prefix of attribute %s must denote a signal", istr(tree_ident(t))); } static bool sem_check_driving(tree_t t) { // See LRM 08 section 16.2.4 for special rules about 'DRIVING and // 'DRIVING_VALUE if (!sem_check_signal_attr(t)) return false; tree_t ref = name_to_ref(tree_name(t)); if (ref == NULL || !tree_has_ref(ref)) return false; tree_t decl = tree_ref(ref); if (tree_kind(decl) == T_PORT_DECL) { const port_mode_t mode = tree_subkind(decl); if (mode != PORT_OUT && mode != PORT_INOUT && mode != PORT_BUFFER) sem_error(t, "prefix of attribute %s must denote a signal or a port " "with mode IN, INOUT, or BUFFER", istr(tree_ident(t))); } // TODO: check within a process return true; } static bool sem_check_attr_param(tree_t t, type_t expect, int min, int max, nametab_t *tab) { const int nparams = tree_params(t); if (nparams == 0 && min > 0) sem_error(t, "attribute %s requires a parameter", istr(tree_ident(t))); else if (nparams > max) sem_error(t, "too many parameters for attribute %s", istr(tree_ident(t))); else if (nparams == 1) { tree_t dim = tree_value(tree_param(t, 0)); if (!sem_check(dim, tab)) return false; tree_t value = tree_value(tree_param(t, 0)); if (!sem_check_type(value, expect, tab)) sem_error(t, "expected type %s for attribute %s parameter but " "have %s", type_pp(expect), istr(tree_ident(t)), type_pp(tree_type(value))); } return true; } static bool sem_check_dimension_attr(tree_t t, nametab_t *tab) { const int nparams = tree_params(t); if (nparams == 0) return true; assert(nparams == 1); // Enforced by parser tree_t dim = tree_value(tree_param(t, 0)); if (!sem_check(dim, tab)) return false; // The parameter must be a locally static expression of type // universal_integer type_t uint = std_type(NULL, STD_UNIVERSAL_INTEGER); type_t dimtype = tree_type(dim); if (!type_eq(dimtype, uint)) { diag_t *d; if (type_is_integer(dimtype)) d = pedantic_diag(tree_loc(dim)); else d = diag_new(DIAG_ERROR, tree_loc(dim)); if (d != NULL) { diag_printf(d, "dimension parameter of attribute %s must be a locally " "static expression of type universal_integer", istr(tree_ident(t))); diag_hint(d, tree_loc(dim), "expression has type %s", type_pp(tree_type(dim))); diag_emit(d); return false; } } if (!sem_locally_static(dim)) sem_error(dim, "dimension parameter of attribute %s must be a locally " "static expression", istr(tree_ident(t))); if (!type_is_array(tree_type(tree_name(t)))) sem_error(t, "prefix of attribute %s with dimension is not an array", istr(tree_ident(t))); return true; } static bool sem_is_named_entity(tree_t t) { const tree_kind_t kind = tree_kind(t); if (kind != T_REF) return false; tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_SIGNAL_DECL: case T_VAR_DECL: case T_PORT_DECL: case T_ALIAS: case T_ENTITY: case T_ARCH: case T_PACKAGE: case T_PACK_BODY: case T_BLOCK: case T_FILE_DECL: case T_CONST_DECL: case T_FUNC_DECL: case T_FUNC_BODY: case T_PROC_DECL: case T_PROC_BODY: case T_PROCESS: case T_GENERIC_DECL: case T_PARAM_DECL: case T_INSTANCE: case T_PROT_DECL: case T_PROT_BODY: case T_TYPE_DECL: case T_SUBTYPE_DECL: case T_FOR_GENERATE: case T_IF_GENERATE: case T_CASE_GENERATE: return true; case T_IMPLICIT_SIGNAL: return tree_subkind(decl) == IMPLICIT_GUARD; // See LRM 93 section 4.3 default: return false; } } static bool sem_check_attr_prefix(tree_t t, bool allow_range, nametab_t *tab, type_t *named_type) { switch (tree_kind(t)) { case T_REF: { if (!tree_has_ref(t)) return false; tree_t decl = tree_ref(t), type_decl; if ((type_decl = aliased_type_decl(decl)) != NULL) *named_type = tree_type(type_decl); return true; } case T_ATTR_REF: { if (is_type_attribute(tree_subkind(t))) *named_type = tree_type(t); else { if (!sem_check_attr_ref(t, allow_range, tab)) return false; } return true; } case T_RECORD_REF: { if (!tree_has_ref(t)) return false; tree_t value = tree_value(t); if (!sem_check_attr_prefix(value, false, tab, named_type)) return false; if (!sem_check_name_prefix(t, tab, "a selected name")) return false; if (*named_type != NULL) *named_type = tree_type(tree_ref(t)); return true; } default: return sem_check(t, tab); } } static bool sem_check_attr_ref(tree_t t, bool allow_range, nametab_t *tab) { // Attribute names are in LRM 93 section 6.6 tree_t name = tree_name(t); type_t named_type = NULL; ident_t attr = tree_ident(t); const attr_kind_t predef = tree_subkind(t); const bool prefix_can_be_range = predef == ATTR_LOW || predef == ATTR_HIGH || predef == ATTR_LEFT || predef == ATTR_RIGHT || predef == ATTR_ASCENDING; if (!sem_check_attr_prefix(name, prefix_can_be_range, tab, &named_type)) return false; if (predef == ATTR_INSTANCE_NAME) tree_set_global_flags(t, TREE_GF_INSTANCE_NAME); else if (predef == ATTR_PATH_NAME) tree_set_global_flags(t, TREE_GF_PATH_NAME); switch (predef) { case ATTR_RANGE: case ATTR_REVERSE_RANGE: { type_t type = tree_type(name); if (type_is_none(type)) return false; else if (!allow_range) sem_error(t, "range expression not allowed here"); if (!sem_check_dimension_attr(t, tab)) return false; if (named_type != NULL) { // Range attribute of type if (named_type != NULL && type_is_unconstrained(type)) sem_error(t, "cannot use attribute %s with unconstrained array " "type %s", istr(attr), type_pp(type)); } else if (!type_is_array(type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(name)); diag_printf(d, "object prefix of attribute %s must be an array", istr(attr)); diag_hint(d, tree_loc(name), "prefix has type %s", type_pp(type)); diag_emit(d); return false; } return true; } case ATTR_LENGTH: { type_t type = get_type_or_null(name); if (type == NULL) sem_error(name, "prefix does not have LENGTH attribute"); else if (type_is_none(type)) return false; else if (!sem_check_incomplete(t, type)) return false; else if (!type_is_array(type) && !(standard() >= STD_19 && type_is_discrete(type))) sem_error(name, "prefix of attribute LENGTH must be an array%s " "but have type %s", standard() >= STD_19 ? " or a discrete type" : "", type_pp(type)); if (!sem_check_dimension_attr(t, tab)) return false; return true; } case ATTR_LEFT: case ATTR_RIGHT: case ATTR_LOW: case ATTR_HIGH: case ATTR_ASCENDING: { type_t type = tree_type(name); if (type_is_none(type)) return false; else if (!sem_check_incomplete(t, type)) return false; else if (!sem_check_dimension_attr(t, tab)) return false; if (!type_is_array(type) && !type_is_scalar(type)) sem_error(t, "prefix does not have attribute %s", istr(attr)); return true; } case ATTR_LAST_EVENT: case ATTR_LAST_ACTIVE: if (!sem_check_readable(name)) return false; else if (!sem_check_attr_param(t, NULL, 0, 0, tab)) return false; else if (!sem_check_signal_attr(t)) return false; return true; case ATTR_EVENT: case ATTR_ACTIVE: case ATTR_LAST_VALUE: if (!sem_check_readable(name)) return false; else if (!sem_check_signal_attr(t)) return false; return true; case ATTR_PATH_NAME: case ATTR_INSTANCE_NAME: case ATTR_SIMPLE_NAME: if (!sem_is_named_entity(name)) sem_error(t, "prefix of %s attribute must be a named entity", istr(attr)); tree_set_flag(name, TREE_F_ATTR_PREFIX); return true; case ATTR_QUIET: case ATTR_STABLE: case ATTR_DELAYED: { if (!sem_check_readable(name)) return false; else if (!sem_check_signal_attr(t)) return false; if (tree_params(t) > 0) { tree_t value = tree_value(tree_param(t, 0)); if (!sem_check(value, tab)) return false; type_t std_time = std_type(NULL, STD_TIME); if (!sem_check_type(value, std_time, tab)) sem_error(value, "parameter of attribute %s must have type %s", istr(attr), type_pp(std_time)); else if (!sem_globally_static(value)) sem_error(value, "parameter of attribute %s must be a static " "expression", istr(attr)); } return true; } case ATTR_TRANSACTION: if (!sem_check_readable(name)) return false; else if (!sem_check_signal_attr(t)) return false; return true; case ATTR_DRIVING_VALUE: case ATTR_DRIVING: return sem_check_driving(t); case ATTR_IMAGE: case ATTR_VALUE: { const bool std_2019 = standard() >= STD_19; if (named_type == NULL && std_2019 && tree_params(t) == 0) { // LCS2016-18 allows attribute with object prefix named_type = get_type_or_null(name); add_param(t, name, P_POS, NULL); } if (named_type == NULL) sem_error(t, "prefix of attribute %s must be a type", istr(attr)); if (!std_2019 && !type_is_scalar(named_type)) sem_error(t, "cannot use attribute %s with non-scalar type %s", istr(attr), type_pp(named_type)); else if (std_2019 && !type_is_representable(named_type)) sem_error(t, "cannot use attribute %s with non-representable " "type %s", istr(attr), type_pp(named_type)); type_t std_string = std_type(NULL, STD_STRING); type_t arg_type = predef == ATTR_IMAGE ? named_type : std_string; if (!sem_check_attr_param(t, arg_type, 1, 1, tab)) return false; return true; } case ATTR_LEFTOF: case ATTR_RIGHTOF: case ATTR_PRED: case ATTR_SUCC: case ATTR_POS: case ATTR_VAL: { if (named_type == NULL && standard() >= STD_19) named_type = get_type_or_null(name); // LCS2016-08 relaxation if (named_type == NULL) sem_error(t, "prefix of attribute %s must be a type", istr(attr)); type_t name_type = tree_type(name); if (!type_is_discrete(name_type) && !type_is_physical(name_type)) sem_error(t, "prefix of attribute %s must be a discrete or " "physical type", istr(attr)); if (predef == ATTR_VAL) { // Parameter may be any integer type if (tree_params(t) != 1) sem_error(t, "attribute VAL requires a parameter"); type_t ptype = tree_type(tree_value(tree_param(t, 0))); if (!type_is_integer(ptype)) sem_error(t, "parameter of attribute VAL must have an integer " "type but found %s", type_pp(ptype)); } else if (!sem_check_attr_param(t, name_type, 1, 1, tab)) return false; return true; } case ATTR_BASE: sem_error(t, "BASE attribute is allowed only as the prefix of the name " "of another attribute"); case ATTR_ELEMENT: case ATTR_SUBTYPE: case ATTR_INDEX: sem_error(t, "%s attribute is only allowed in a type mark", istr(attr)); case ATTR_CONVERSE: if (type_kind(tree_type(name)) != T_VIEW) sem_error(t, "prefix of 'CONVERSE attribute must be a named mode " "view or alias thereof"); return true; case ATTR_REFLECT: if (get_type_or_null(name) == NULL) sem_error(t, "prefix of attribute REFLECT is not a type mark or " "an object with a type"); else if (named_type != NULL && type_is_unconstrained(named_type)) sem_error(t, "prefix of 'REFLECT attribute must be a fully " "constrained subtype"); return true; case ATTR_USER: if (!tree_has_value(t)) return false; if (!sem_static_name(name, sem_globally_static)) { if (tree_kind(name) == T_REF) sem_error(name, "%s is not a static name", istr(tree_ident(name))); else sem_error(name, "invalid attribute reference"); } return true; default: fatal_trace("unhandled attribute kind %d", predef); } } static bool sem_check_qualified(tree_t t, nametab_t *tab) { if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; // LRM 08 section 9.3.5 qualified expressions: the operand shall have // the same type as the base type of the type mark type_t base = type_base_recur(tree_type(t)); if (!sem_check_type(value, base, tab)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "operand of qualified expression must have type %s", type_pp(base)); diag_hint(d, tree_loc(value), "operand has type %s", type_pp(tree_type(value))); diag_lrm(d, STD_08, "9.3.5"); diag_emit(d); return false; } } return true; } static bool sem_static_signal_name(tree_t t) { if (!sem_static_name(t, sem_globally_static)) return false; return class_of(t) == C_SIGNAL; } static bool sem_check_port_actual(formal_map_t *formals, int nformals, tree_t param, tree_t unit, nametab_t *tab) { tree_t value = tree_value(param), name = NULL, out_conv = NULL; tree_t decl = NULL; type_t type = NULL; switch (tree_subkind(param)) { case P_POS: { const int pos = tree_pos(param); if (pos >= nformals) sem_error(value, "found at least %d positional actuals but %s " "has only %d port%s", pos + 1, istr(tree_ident(unit)), nformals, nformals == 1 ? "" : "s"); if (formals[pos].state >= MAP_PARTIAL) sem_error(value, "formal port %s already has an actual", istr(tree_ident(formals[pos].decl))); formals[pos].state = MAP_FULL; decl = formals[pos].decl; type = tree_type(decl); } break; case P_NAMED: { tree_t ref = (name = tree_name(param)); switch (tree_kind(name)) { case T_FCALL: if (tree_params(name) != 1) sem_error(name, "output conversion function must have " "exactly one parameter"); // The parser would have replaced any other valid conversion // function with T_CONV_FUNC sem_error(name, "invalid output conversion %s", istr(tree_ident(name))); break; case T_CONV_FUNC: case T_TYPE_CONV: out_conv = name; name = ref = tree_value(name); break; default: break; } ref = name_to_ref(ref); assert(ref != NULL && tree_kind(ref) == T_REF); if (!tree_has_ref(ref)) return false; tree_t d = tree_ref(ref); for (int i = 0; i < nformals; i++) { if (formals[i].decl == d) { if (formals[i].state == MAP_FULL) sem_error(value, "formal port %s already has an actual", istr(tree_ident(formals[i].decl))); formals[i].state = ref == name ? MAP_FULL : MAP_PARTIAL; decl = formals[i].decl; tree_set_flag(ref, TREE_F_FORMAL_NAME); break; } } if (decl == NULL) sem_error(value, "%s has no port named %s", istr(tree_ident(unit)), istr(tree_ident(ref))); if (!sem_static_name(name, sem_locally_static)) sem_error(name, "formal name must be locally static"); if (out_conv != NULL) { port_mode_t mode = tree_subkind(decl); type = tree_type((mode == PORT_INOUT) ? name : out_conv); if (mode == PORT_IN) sem_error(name, "output conversion not allowed for formal " "%s with mode IN", istr(tree_ident(decl))); if (tree_kind(value) == T_OPEN) sem_error(name, "output conversion for formal %s must not " "have OPEN actual", istr(tree_ident(decl))); } else type = tree_type(name); break; } } assert(type != NULL); if (!sem_check(value, tab)) return false; const tree_kind_t kind = tree_kind(value); tree_t expr = kind == T_INERTIAL ? tree_value(value) : value; type_t value_type = tree_type(expr), atype; if (!sem_check_type(expr, type, tab)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "type of actual %s does not match type %s of formal " "port %s", type_pp2(value_type, type), type_pp2(type, value_type), istr(tree_ident(decl))); if (type_is_generic(type)) { hash_t *map = get_generic_map(tab); if (map != NULL && (atype = hash_get(map, type))) diag_hint(d, NULL, "generic type %s is mapped to %s", type_pp(type), type_pp(atype)); } diag_emit(d); return false; } const port_mode_t mode = tree_subkind(decl); if (kind == T_OPEN) { if ((mode == PORT_IN) && !tree_has_value(decl)) sem_error(value, "unconnected port %s with mode IN must have a " "default value", istr(tree_ident(decl))); if ((mode != PORT_IN) && type_is_unconstrained(tree_type(decl))) sem_error(value, "port %s of unconstrained type %s cannot " "be unconnected", istr(tree_ident(decl)), type_pp(type)); } // Check for type conversions and conversion functions // These only apply if the class of the formal is not constant tree_t actual; if (kind == T_TYPE_CONV || kind == T_CONV_FUNC) { // Conversion functions are in LRM 93 section 4.3.2.2 actual = tree_value(value); // LRM 93 section 3.2.1.1 result of a type conversion in an // association list cannot be an unconstrained array type if (type_is_unconstrained(value_type) && type_is_unconstrained(type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "result of conversion for unconstrained formal " "%s must be a constrained array type", istr(tree_ident(decl))); diag_lrm(d, STD_93, "3.2.1.1"); diag_emit(d); return false; } if (mode == PORT_OUT) sem_error(value, "conversion not allowed for formal %s with " "mode OUT", istr(tree_ident(decl))); else if (mode == PORT_INOUT && out_conv == NULL) sem_error(value, "INOUT port %s has output conversion but no " "corresponding input conversion", istr(tree_ident(decl))); } else actual = value; // No conversion tree_t ref = name_to_ref(actual); if (mode == PORT_IN && kind != T_INERTIAL) { bool is_static = true; if (ref != NULL && class_of(ref) == C_SIGNAL) is_static = sem_static_name(actual, sem_globally_static); else is_static = sem_globally_static(actual); // LRM 08 section 6.5.6.3 the actual is converted to a concurrent // signal assignment to an anonymous signal that is then // associated with the formal if (!is_static && standard() >= STD_08) { // The rules listed for unconstrained ports in 6.5.6.3 should // be covered by the check for a globally static subtype in // addition to the checks above if (type_is_unconstrained(type) && !sem_static_subtype(value_type, sem_globally_static)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "expression associated with unconstrained formal " "port %s must have a globally static subtype", istr(tree_ident(decl))); diag_lrm(d, STD_08, "6.5.6.3"); diag_emit(d); return false; } tree_t w = tree_new(T_INERTIAL); tree_set_loc(w, tree_loc(value)); tree_set_value(w, value); tree_set_target(w, name ?: make_ref(decl)); tree_set_value(param, w); } else if (!is_static) sem_error(value, "actual associated with port %s of mode IN must be " "a globally static expression or static signal name", istr(tree_ident(decl))); } else if (mode == PORT_INOUT && tree_class(decl) == C_VARIABLE) { // VHDL-2019 additions for shared variable ports if (ref == NULL || class_of(ref) != C_VARIABLE) sem_error(value, "actual associated with formal variable port %s " "must either be a shared variable or a formal variable port " "of another design entity", istr(tree_ident(decl))); } else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) { if (!sem_static_signal_name(actual)) sem_error(value, "actual associated with port %s with mode view " "indication must be a static signal name", istr(tree_ident(decl))); if (!sem_check_compatible_view(decl, actual)) return false; } else if (mode != PORT_IN && tree_kind(actual) != T_OPEN && !sem_static_signal_name(actual)) { sem_error(value, "actual associated with port %s of mode %s must be " "a static signal name or OPEN", istr(tree_ident(decl)), port_mode_str(tree_subkind(decl))); } else if (kind == T_INERTIAL) tree_set_target(value, name ?: make_ref(decl)); // Check connections between ports if (ref != NULL && tree_has_ref(ref)) { tree_t odecl = tree_ref(ref); if (tree_kind(odecl) == T_PORT_DECL) { const port_mode_t omode = tree_subkind(odecl); const bool error = (omode == PORT_BUFFER && (mode == PORT_OUT || mode == PORT_INOUT)) || (omode != PORT_BUFFER && mode == PORT_BUFFER) || (omode == PORT_IN && (mode == PORT_OUT || mode == PORT_INOUT)) || (omode == PORT_OUT && mode == PORT_IN && standard() < STD_08) || (omode == PORT_OUT && mode == PORT_INOUT) || (omode == PORT_LINKAGE && mode != PORT_LINKAGE); if (error) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "port %s with mode %s cannot be associated " "with formal port %s with mode %s", istr(tree_ident(odecl)), port_mode_str(omode), istr(tree_ident(decl)), port_mode_str(mode)); diag_hint(d, tree_loc(decl), "formal port %s declared here", istr(tree_ident(decl))); diag_hint(d, tree_loc(odecl), "port %s declared here", istr(tree_ident(odecl))); diag_emit(d); return false; } } } return true; } static bool sem_check_port_map(tree_t t, tree_t unit, nametab_t *tab) { // Check there is an actual for each formal port generic // Rules for maps are described in LRM 93 section 5.2.1.2 const int nformals = tree_ports(unit); const int nactuals = tree_params(t); bool ok = true; formal_map_t *formals LOCAL = xmalloc_array(nformals, sizeof(formal_map_t)); for (int i = 0; i < nformals; i++) { formals[i].decl = tree_port(unit, i); formals[i].state = MAP_MISSING; } for (int i = 0; i < nactuals; i++) { tree_t p = tree_param(t, i); if (tree_subkind(p) != P_NAMED) continue; tree_t name = tree_name(p); ok &= sem_check(name, tab); const tree_kind_t name_kind = tree_kind(name); if ((name_kind == T_ARRAY_REF || name_kind == T_ARRAY_SLICE) && tree_kind(tree_value(p)) == T_OPEN && standard() < STD_19) { diag_t *d = pedantic_diag(tree_loc(p)); if (d != NULL) { diag_printf(d, "sub-elements of composite port cannot be " "associated with OPEN"); diag_emit(d); } } } if (!ok) return false; for (int i = 0; i < nactuals; i++) { tree_t actual = tree_param(t, i); ok &= sem_check_port_actual(formals, nformals, actual, unit, tab); if (!ok && tree_subkind(actual) == P_POS && i >= nformals) break; // Prevent useless repeated errors } if (tree_kind(t) == T_BINDING) return ok; for (int i = 0; i < nformals; i++) { if (formals[i].state == MAP_MISSING) { port_mode_t mode = tree_subkind(formals[i].decl); if (mode == PORT_IN && !tree_has_value(formals[i].decl)) { error_at(tree_loc(t), "missing actual for port %s of " "mode IN without a default expression", istr(tree_ident(formals[i].decl))); } else if (mode == PORT_ARRAY_VIEW || mode == PORT_RECORD_VIEW) error_at(tree_loc(t), "missing actual for port %s with " "mode view indication %s", istr(tree_ident(formals[i].decl)), type_pp(tree_type(tree_value(formals[i].decl)))); type_t ftype = tree_type(formals[i].decl); if (mode != PORT_IN && type_is_unconstrained(ftype)) { error_at(tree_loc(t), "missing actual for port %s with " "unconstrained array type", istr(tree_ident(formals[i].decl))); } } } return ok; } static bool sem_check_generic_actual(formal_map_t *formals, int nformals, tree_t param, tree_t unit, nametab_t *tab) { tree_t name = NULL; int pos = -1; switch (tree_subkind(param)) { case P_POS: { pos = tree_pos(param); if (pos >= nformals) sem_error(param, "found at least %d positional actuals but %s " "has only %d generic%s", pos + 1, istr(tree_ident(unit)), nformals, nformals == 1 ? "" : "s"); else if (tree_flags(formals[pos].decl) & TREE_F_PREDEFINED) { diag_t *d = diag_new(DIAG_WARN, tree_loc(param)); diag_printf(d, "positional generic actual is associated with " "implicit generic subprogram %s for type %s", istr(tree_ident(formals[pos].decl)), type_pp(tree_type(tree_port(formals[pos].decl, 0)))); diag_hint(d, NULL, "use a named association if this was intended"); diag_emit(d); } } break; case P_NAMED: { name = tree_name(param); tree_t ref = name_to_ref(name); if (ref == NULL) sem_error(name, "invalid name in generic map"); else if (!tree_has_ref(ref)) return false; tree_t d = tree_ref(ref); for (pos = 0; pos < nformals; pos++) { if (formals[pos].decl == d) { tree_set_flag(ref, TREE_F_FORMAL_NAME); break; } } if (pos == nformals) sem_error(name, "%s is not a formal generic of %s", istr(tree_ident(ref)), istr(tree_ident(unit))); break; } } assert(pos >= 0 && pos < nformals); tree_t decl = formals[pos].decl, value = tree_value(param); type_t type = get_type_or_null(name ?: decl); const bool is_full = name == NULL || tree_kind(name) == T_REF; const bool is_open = tree_kind(value) == T_OPEN; if ((is_open && formals[pos].state == MAP_PARTIAL) || (!is_open && formals[pos].state == MAP_OPEN)) sem_error(param, "formal generic %s associated with OPEN cannot be " "individually associated", istr(tree_ident(formals[pos].decl))); if (formals[pos].state >= (is_full ? MAP_PARTIAL : MAP_FULL)) sem_error(param, "formal generic %s already has an actual", istr(tree_ident(formals[pos].decl))); if (is_open) formals[pos].state = MAP_OPEN; else if (is_full) formals[pos].state = MAP_FULL; else formals[pos].state = MAP_PARTIAL; if (is_open && !tree_has_value(decl)) sem_error(param, "generic %s without a default expression cannot " "be associated with OPEN", istr(tree_ident(decl))); else if (is_open) return true; // No further checking switch (tree_class(decl)) { case C_TYPE: // The parser already called map_generic_type assert(tree_kind(value) == T_TYPE_REF); assert(type_kind(type) == T_GENERIC); type_t map = tree_type(value); if (type_is_none(map)) return false; else if (!sem_check_incomplete(param, map)) return false; static const char *class_strings[] = { [GTYPE_SCALAR] = "a scalar", [GTYPE_DISCRETE] = "a discrete", [GTYPE_INTEGER] = "an integer", [GTYPE_FLOATING] = "a floating-point", [GTYPE_PHYSICAL] = "a physical", [GTYPE_ACCESS] = "an access", [GTYPE_ARRAY] = "an array", [GTYPE_FILE] = "a file", }; const gtype_class_t class = type_subkind(type); if (!type_matches_class(map, class)) sem_error(param, "cannot map type %s to generic interface type %s " "which requires %s type", type_pp(map), istr(tree_ident(decl)), class_strings[class]); else if (class == GTYPE_ACCESS || class == GTYPE_FILE) { type_t expect = type_designated(type); type_t actual = type_designated(map); if (type_is_generic(expect)) { const gtype_class_t expect_class = type_subkind(expect); if (!type_matches_class(actual, expect_class)) sem_error(param, "cannot map type %s to generic interface type " "%s as the designated type %s is not %s type", type_pp(map), istr(tree_ident(decl)), type_pp(actual), class_strings[expect_class]); } else if (!type_eq(actual, expect)) sem_error(param, "cannot map type %s to generic interface type " "%s as the designated type %s is not %s", type_pp(map), istr(tree_ident(decl)), type_pp(actual), type_pp(expect)); } else if (class == GTYPE_ARRAY) { const int nindex = type_indexes(type); if (nindex != dimension_of(map)) sem_error(param, "cannot map type %s to generic interface " "type %s as it has %d dimensions but the incomplete " "type definition has %d", type_pp(map), istr(tree_ident(decl)), dimension_of(map), nindex); for (int i = 0; i < nindex; i++) { type_t itype = type_index(type, i); type_t imap = index_type_of(map, i); if (type_is_generic(itype)) { const gtype_class_t expect_class = type_subkind(itype); if (!type_matches_class(imap, expect_class)) sem_error(param, "cannot map type %s to generic interface " "type %s as the index type %s of the %s dimension " "is not %s type", type_pp(map), istr(tree_ident(decl)), type_pp(imap), ordinal_str(i + 1), class_strings[expect_class]); } else if (!type_eq(imap, itype)) sem_error(param, "cannot map type %s to generic interface type " "%s as the index type %s of the %s dimension is not " "%s", type_pp(map), istr(tree_ident(decl)), type_pp(imap), ordinal_str(i + 1), type_pp(itype)); } type_t expect = type_elem(type); type_t actual = type_elem(map); if (type_is_generic(expect)) { const gtype_class_t expect_class = type_subkind(expect); if (!type_matches_class(actual, expect_class)) sem_error(param, "cannot map type %s to generic interface type " "%s as the element type %s is not %s type", type_pp(map), istr(tree_ident(decl)), type_pp(actual), class_strings[expect_class]); } else if (!type_eq(actual, expect)) sem_error(param, "cannot map type %s to generic interface type " "%s as the element type %s is not %s", type_pp(map), istr(tree_ident(decl)), type_pp(actual), type_pp(expect)); } break; case C_PACKAGE: { tree_t pack = NULL; if (tree_kind(value) == T_REF && tree_has_ref(value)) pack = tree_ref(value); if (pack == NULL || tree_kind(pack) != T_PACK_INST) sem_error(value, "actual for generic %s is not an " "instantiated package name", istr(tree_ident(decl))); else if (!tree_has_ref(pack)) return false; // Was parse error tree_t map = tree_value(decl); if (!tree_has_ref(map)) return false; // Was earlier error assert(tree_kind(map) == T_PACKAGE_MAP); tree_t base = tree_ref(pack); tree_t expect = tree_ref(map); if (tree_ident(base) != tree_ident(expect)) sem_error(value, "expected an instance of package %s but have " "instance of %s for generic %s", istr(tree_ident(expect)), istr(tree_ident(base)), istr(tree_ident(decl))); map_generic_package(tab, expect, pack); } break; case C_FUNCTION: case C_PROCEDURE: if (!sem_check(value, tab)) return false; if (!type_eq_map(tree_type(value), type, get_generic_map(tab))) sem_error(value, "type of actual %s does not match type %s of formal " "generic %s", type_pp(tree_type(value)), type_pp(type), istr(tree_ident(decl))); assert(tree_kind(value) == T_REF); if (!tree_has_ref(value)) return false; tree_t sub = tree_ref(value); assert(is_subprogram(sub)); const bool pure_formal = !(tree_flags(decl) & TREE_F_IMPURE); const bool pure_actual = !(tree_flags(sub) & TREE_F_IMPURE); if (pure_formal && !pure_actual) { diag_t *d = pedantic_diag(tree_loc(value)); if (d != NULL) { diag_printf(d, "cannot associate impure function %s with pure " "generic subprogram %s", type_pp(tree_type(value)), istr(tree_ident(decl))); diag_emit(d); } } map_generic_subprogram(tab, decl, sub); break; case C_CONSTANT: if (name != NULL) { if (!sem_check(name, tab)) return false; if (!sem_static_name(name, sem_locally_static)) sem_error(name, "formal generic name must be a locally " "static name"); } if (!sem_check(value, tab)) return false; if (!sem_check_type(value, type, tab)) sem_error(value, "type of actual %s does not match type %s of formal " "generic %s", type_pp(tree_type(value)), type_pp(type), istr(tree_ident(decl))); if (is_full) map_generic_const(tab, decl, value); break; default: // Was an earlier error break; } return true; } static bool sem_check_generic_map(tree_t t, tree_t unit, nametab_t *tab) { // Check there is an actual for each formal generic // Rules for maps are described in LRM 93 section 5.2.1.2 const int nformals = tree_generics(unit); const int nactuals = tree_genmaps(t); formal_map_t *formals LOCAL = xmalloc_array(nformals, sizeof(formal_map_t)); for (int i = 0; i < nformals; i++) { formals[i].decl = tree_generic(unit, i); formals[i].state = MAP_MISSING; } bool ok = true; for (int i = 0; i < nactuals; i++) { tree_t actual = tree_genmap(t, i); ok &= sem_check_generic_actual(formals, nformals, actual, unit, tab); if (!ok && tree_subkind(actual) == P_POS && i >= nformals) break; // Prevent useless repeated errors } for (int i = 0; i < nformals; i++) { if (formals[i].state >= MAP_PARTIAL) continue; const class_t class = tree_class(formals[i].decl); if (class == C_PACKAGE) error_at(tree_loc(t), "missing actual for generic package %s", istr(tree_ident(formals[i].decl))); else if (class == C_TYPE) { error_at(tree_loc(t), "missing actual for generic type %s", istr(tree_ident(formals[i].decl))); map_generic_type(tab, tree_type(formals[i].decl), type_new(T_NONE)); } else if (tree_has_value(formals[i].decl)) { tree_t value = tree_value(formals[i].decl); if (tree_kind(value) == T_BOX) { // Need to look up the matching subprogram now while we still // have the symbol table map_generic_box(tab, t, formals[i].decl, i); } } else if (formals[i].state == MAP_MISSING) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "missing actual for generic %s without a " "default expression", istr(tree_ident(formals[i].decl))); diag_hint(d, tree_loc(formals[i].decl), "generic %s declared here", istr(tree_ident(formals[i].decl))); diag_emit(d); } } return ok; } static bool sem_check_instance(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; tree_t unit = primary_unit_of(tree_ref(t)); if (tree_has_spec(t)) { tree_t spec = tree_spec(t); if (tree_class(t) != C_COMPONENT) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(spec)); diag_printf(d, "specification may only be used with component" " instances"); diag_hint(d, tree_loc(spec), "specification for %s", istr(tree_ident(t))); diag_hint(d, tree_loc(t), "%s instance", class_str(tree_class(t))); diag_emit(d); return false; } assert(tree_kind(unit) == T_COMPONENT); // Checked by parser if (tree_has_ref(spec) && tree_ref(spec) != unit) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(spec)); diag_printf(d, "component mismatch for instance %s: expected %s " "but specification has %s", istr(tree_ident(t)), istr(tree_ident(unit)), istr(tree_ident(tree_ref(spec)))); diag_hint(d, tree_loc(spec), "specification has component %s", istr(tree_ident(tree_ref(spec)))); diag_hint(d, tree_loc(t), "instance of component %s", istr(tree_ident(unit))); diag_emit(d); return false; } } if (!sem_check_generic_map(t, unit, tab)) return false; if (!sem_check_port_map(t, unit, tab)) return false; return true; } static bool sem_check_cond(tree_t t, nametab_t *tab) { if (tree_has_value(t)) { type_t std_bool = std_type(NULL, STD_BOOLEAN); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of condition must be %s but have %s", type_pp(std_bool), type_pp(tree_type(value))); if (!sem_check_readable(value)) return false; } return true; } static bool sem_check_if(tree_t t, nametab_t *tab) { bool ok = true; const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) ok &= sem_check_cond(tree_cond(t, i), tab); return ok; } static bool sem_static_subtype(type_t type, static_fn_t fn) { // Rules for locally static subtypes are in LRM 93 7.4.1 if (type_is_unconstrained(type)) return false; if (type_is_scalar(type)) return true; if (type_is_record(type)) { const int nfields = type_fields(type); for (int i = 0; i < nfields; i++) { if (!sem_static_subtype(tree_type(type_field(type, i)), fn)) return false; } return true; } switch (type_kind(type)) { case T_SUBTYPE: { const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { if (!(*fn)(range_of(type, i))) return false; } return true; } default: return true; } } static bool sem_ieee_locally_static(tree_t decl) { // Subprograms definined in certain IEEE packages are treated the // same as builtin operators in VHDL-2008 if (standard() < STD_08) return false; ident_t unit_name = tree_ident(tree_container(decl)); switch (is_well_known(unit_name)) { case W_NUMERIC_STD: case W_NUMERIC_BIT: case W_IEEE_1164: case W_NUMERIC_BIT_UNSIGNED: case W_NUMERIC_STD_UNSIGNED: return true; default: return false; } } static bool sem_locally_static(tree_t t) { // Rules for locally static expressions are in LRM 93 7.4.1 type_t type = tree_type(t); tree_kind_t kind = tree_kind(t); if (type_is_none(type)) return true; // Prevents further cascading errors // Any literal other than of type time if (kind == T_LITERAL) { if (tree_subkind(t) == L_PHYSICAL) return !type_eq(type, std_type(NULL, STD_TIME)); else return true; } else if (kind == T_STRING) return true; else if ((kind == T_REF) && (tree_kind(tree_ref(t)) == T_ENUM_LIT)) return true; else if (kind == T_OPEN) return true; if (kind == T_REF) { tree_t decl = tree_ref(t); const tree_kind_t dkind = tree_kind(decl); // A constant reference (other than a deferred constant) with a // locally static value if (dkind == T_CONST_DECL && (tree_flags(decl) & TREE_F_LOCALLY_STATIC)) return true; // An alias of a locally static name if (dkind == T_ALIAS) return sem_locally_static(tree_value(decl)); // [2008] A formal generic constant of a generic-mapped subprogram // or package with a locally static subtype if (dkind == T_GENERIC_DECL && (tree_flags(decl) & TREE_F_LOCALLY_STATIC)) return true; } // A locally static range if (kind == T_RANGE) { switch (tree_subkind(t)) { case RANGE_TO: case RANGE_DOWNTO: return sem_locally_static(tree_left(t)) && sem_locally_static(tree_right(t)); case RANGE_EXPR: return sem_locally_static(tree_value(t)); default: return false; } } // A function call of an implicit operator or [2008] an operation // defined in one of the packages STD_LOGIC_1164, NUMERIC_BIT, // NUMERIC_STD, NUMERIC_BIT_UNSIGNED, or NUMERIC_STD_UNSIGNED in // library IEEE whose actuals are locally static expressions. if (kind == T_FCALL) { if (!tree_has_ref(t)) return true; // Suppress further errors else if (tree_flags(t) & TREE_F_LOCALLY_STATIC) return true; tree_t decl = tree_ref(t); if (tree_kind(decl) == T_GENERIC_DECL) return false; // Not known at this point else if (tree_subkind(decl) == S_USER && !sem_ieee_locally_static(decl)) return false; const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!sem_locally_static(tree_value(tree_param(t, i)))) return false; } return true; } if (kind == T_ATTR_REF) { // A predefined attribute other than those listed below whose prefix // prefix is either a locally static subtype or is an object that is // of a locally static subtype const attr_kind_t predef = tree_subkind(t); if (predef == ATTR_EVENT || predef == ATTR_ACTIVE || predef == ATTR_LAST_EVENT || predef == ATTR_LAST_ACTIVE || predef == ATTR_LAST_VALUE || predef == ATTR_DRIVING || predef == ATTR_DRIVING_VALUE || predef == ATTR_PATH_NAME || predef == ATTR_INSTANCE_NAME || predef == ATTR_SIMPLE_NAME) return false; // Whose actual parameter (if any) is a locally static expression const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!sem_locally_static(tree_value(tree_param(t, i)))) return false; } if (tree_has_value(t)) { // A user-defined attribute whose value is a locally static expression return sem_locally_static(tree_value(t)); } type_t type = tree_type(tree_name(t)); return sem_static_subtype(type, sem_locally_static); } // A qualified expression whose operand is locally static if (kind == T_QUALIFIED) return sem_locally_static(tree_value(t)); // A type conversion whose expression is locally static if (kind == T_TYPE_CONV) return sem_locally_static(tree_value(t)); // Aggregates must have locally static range and all elements // must have locally static values if (kind == T_AGGREGATE) { if (type_is_unconstrained(type)) return false; if (type_is_array(type)) { if (!sem_locally_static(range_of(type, 0))) return false; } const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); if ((tree_subkind(a) == A_NAMED) && !sem_locally_static(tree_name(a))) return false; if (!sem_locally_static(tree_value(a))) return false; } return true; } // A record field name if ((kind == T_REF) && (tree_kind(tree_ref(t)) == T_FIELD_DECL)) return true; const bool std08_rules = standard() >= STD_08 || relaxed_rules(); // [2008] An indexed name whose prefix and index expressions are // locally static if (std08_rules && kind == T_ARRAY_REF) { const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!sem_locally_static(tree_value(tree_param(t, i)))) return false; } return sem_locally_static(tree_value(t)); } // [2008] A slice name whose prefix and range is locally static if (std08_rules && kind == T_ARRAY_SLICE) { if (!sem_locally_static(tree_range(t, 0))) return false; return sem_locally_static(tree_value(t)); } // [2008] A selected name whose prefix is locally static if (std08_rules && kind == T_RECORD_REF) return sem_locally_static(tree_value(t)); return false; } static bool sem_static_name(tree_t t, static_fn_t check_fn) { // Rules for static names are in LRM 93 6.1 switch (tree_kind(t)) { case T_REF: { tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_SIGNAL_DECL: case T_VAR_DECL: case T_CONST_DECL: case T_PORT_DECL: case T_TYPE_DECL: case T_SUBTYPE_DECL: case T_ENTITY: case T_ARCH: case T_PACK_BODY: case T_PACKAGE: case T_FUNC_BODY: case T_PROC_BODY: case T_FUNC_DECL: case T_PROC_DECL: case T_PROCESS: case T_BLOCK: case T_ENUM_LIT: case T_IMPLICIT_SIGNAL: case T_GENERIC_DECL: case T_PARAM_DECL: case T_CONCURRENT: case T_VIEW_DECL: case T_UNIT_DECL: return true; case T_ALIAS: return sem_static_name(tree_value(decl), check_fn); default: return false; } } case T_EXTERNAL_NAME: return true; case T_RECORD_REF: return sem_static_name(tree_value(t), check_fn); case T_ARRAY_REF: { if (!sem_static_name(tree_value(t), check_fn)) return false; const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!(*check_fn)(tree_value(tree_param(t, i)))) return false; } return true; } case T_ARRAY_SLICE: { if (!sem_static_name(tree_value(t), check_fn)) return false; return (*check_fn)(tree_range(t, 0)); } case T_ATTR_REF: { switch (tree_subkind(t)) { case ATTR_DELAYED: case ATTR_STABLE: case ATTR_QUIET: case ATTR_TRANSACTION: return sem_static_name(tree_name(t), check_fn); default: return false; } } default: return false; } } static bool sem_globally_static(tree_t t) { // Rules for globally static expressions are in LRM 93 7.4.2 type_t type = tree_type(t); tree_kind_t kind = tree_kind(t); if (type_is_none(type)) return true; // Prevents further cascading errors // A literal of type TIME if (type_eq(type, std_type(NULL, STD_TIME))) { if (kind == T_REF && tree_kind(tree_ref(t)) == T_UNIT_DECL) return true; else if (kind == T_LITERAL && tree_subkind(t) == L_PHYSICAL) return true; } // A locally static primary if (sem_locally_static(t)) return true; // A generic constant, generate parameter, or constant if (kind == T_REF) { tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_GENERIC_DECL: return true; case T_CONST_DECL: // Do not treat all constants as globally static, this is a // defect in the LRM return !!(tree_flags(decl) & TREE_F_GLOBALLY_STATIC); default: return false; } } else if (kind == T_EXTERNAL_NAME) return tree_class(t) == C_CONSTANT; // An alias whose aliased name is globally static if (kind == T_ALIAS) return sem_globally_static(tree_value(t)); if (kind == T_RANGE) { if (tree_subkind(t) == RANGE_EXPR) return sem_globally_static(tree_value(t)); if (!sem_globally_static(tree_left(t))) return false; if (!sem_globally_static(tree_right(t))) return false; return true; } // Aggregates must have globally static range and all elements // must have globally static values if (kind == T_AGGREGATE) { if (type_is_array(type) && !type_is_unconstrained(type) && !sem_globally_static(range_of(type, 0))) return false; const int nassocs = tree_assocs(t); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(t, i); if ((tree_subkind(a) == A_NAMED) && !sem_globally_static(tree_name(a))) return false; if (!sem_globally_static(tree_value(a))) return false; } return true; } // A function call of a pure function with globally static actuals if (kind == T_FCALL) { tree_t decl = tree_ref(t); if (tree_flags(decl) & TREE_F_IMPURE) return false; bool all_static = true; const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { tree_t p = tree_param(t, i); all_static = all_static && sem_globally_static(tree_value(p)); } return all_static; } if (kind == T_ATTR_REF) { const attr_kind_t predef = tree_subkind(t); // A predefined attribute that is one of 'SIMPLE_NAME, // 'INSTANCE_NAME, or 'PATH_NAME if (predef == ATTR_SIMPLE_NAME || predef == ATTR_INSTANCE_NAME || predef == ATTR_PATH_NAME) return true; // Clause j // A predefined attribute other than those listed below whose // prefix is either a globally static subtype or is an object or // function call that is of a globally static subtype, or in 2008, // a prefix which is a appropriate for a globally static attribute if (predef == ATTR_EVENT || predef == ATTR_ACTIVE || predef == ATTR_LAST_EVENT || predef == ATTR_LAST_ACTIVE || predef == ATTR_LAST_VALUE || predef == ATTR_DRIVING || predef == ATTR_DRIVING_VALUE) return false; // Clause k else if (predef == ATTR_USER) { // A user-defined attribute whose value is a globally static // expression return sem_globally_static(tree_value(t)); } const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!sem_globally_static(tree_value(tree_param(t, i)))) return false; } tree_t name = tree_name(t); if (standard() >= STD_08 || relaxed_rules()) { // LRM 08 section 9.4.3: A prefix is appropriate for a globally // static attribute if it denotes a signal, a constant, a type // or subtype, a globally static function call, a variable that // is not of an access type, or a variable of an access type // whose designated subtype is fully constrained. if (tree_kind(name) == T_FCALL) return sem_globally_static(name); tree_t ref = name_to_ref(name); if (ref == NULL) return false; tree_t decl = tree_ref(ref); const tree_kind_t dkind = tree_kind(decl); if (dkind == T_VAR_DECL && type_is_access(tree_type(name))) return false; return dkind == T_CONST_DECL || dkind == T_SIGNAL_DECL || dkind == T_TYPE_DECL || dkind == T_VAR_DECL || dkind == T_SUBTYPE_DECL || dkind == T_PORT_DECL || dkind == T_GENERIC_DECL; } type_t type = get_type_or_null(name); if (type == NULL) return false; return sem_static_subtype(type, sem_globally_static); } // A qualified expression whose operand is globally static if (kind == T_QUALIFIED) return sem_globally_static(tree_value(t)); // A type conversion whose operand is globally static if (kind == T_TYPE_CONV) return sem_globally_static(tree_value(t)); // TODO: clauses o, p // A sub-element or slice where indexes are globally static if (kind == T_ARRAY_REF) { if (!sem_globally_static(tree_value(t))) return false; const int nparams = tree_params(t); for (int i = 0; i < nparams; i++) { if (!sem_globally_static(tree_value(tree_param(t, i)))) return false; } return true; } else if (kind == T_ARRAY_SLICE) { if (!sem_globally_static(tree_value(t))) return false; if (!sem_globally_static(tree_range(t, 0))) return false; return true; } else if (kind == T_RECORD_REF) return sem_globally_static(tree_value(t)); return false; } static bool sem_check_case(tree_t t, nametab_t *tab) { tree_t test = tree_value(t); if (!sem_check(test, tab)) return false; type_t type = tree_type(test); // LRM 93 8.8 if the type of the expression is an array then it must be // a one dimensional character array type const bool is_1d_character_array = type_is_character_array(type); const bool valid = is_1d_character_array || type_is_discrete(type); if (!valid) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(test)); diag_printf(d, "case expression must have a discrete type or one " "dimensional character array type"); if (type_is_array(type) && dimension_of(type) != 1) diag_hint(d, tree_loc(test), "array has %d dimensions", dimension_of(type)); else if (type_is_array(type)) diag_hint(d, tree_loc(test), "type %s is not a character array", type_pp(type)); else diag_hint(d, tree_loc(test), "type is %s", type_pp(type)); diag_lrm(d, STD_08, "10.9"); diag_emit(d); return false; } if (is_1d_character_array && standard() < STD_08) { // VHDL-93 requires a locally static subtype, relaxed in later // revisions if (!sem_static_subtype(type, sem_locally_static)) sem_error(test, "case expression must have locally static subtype"); } static_fn_t static_fn = sem_locally_static; const char *static_str = "locally"; if (tree_kind(t) == T_CASE_GENERATE) { static_fn = sem_globally_static; static_str = "globally"; } const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(t, i); const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); switch (tree_subkind(a)) { case A_OTHERS: if (j != nassocs - 1 || i != nstmts - 1) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(a)); diag_printf(d, "others choice must appear last"); diag_hint(d, tree_loc(a), "others choice"); tree_t more = j + 1 < nassocs ? tree_assoc(alt, j + 1) : tree_assoc(tree_stmt(t, i + 1), 0); diag_hint(d, tree_loc(more), "further choices follow this"); diag_emit(d); return false; } break; case A_NAMED: { tree_t name = tree_name(a); if (!sem_check(name, tab)) return false; if (!sem_check_type(name, type, tab)) sem_error(name, "case choice must have type %s but found %s", type_pp(type), type_pp(tree_type(name))); else if (!(*static_fn)(name)) sem_error(name, "case choice must be %s static", static_str); } break; case A_RANGE: { tree_t r = tree_range(a, 0); if (!sem_check_discrete_range(r, type, tab)) return false; switch (tree_subkind(r)) { case RANGE_TO: case RANGE_DOWNTO: if (!(*static_fn)(tree_left(r))) sem_error(tree_left(r), "left index of case choice " "range is not %s static", static_str); else if (!(*static_fn)(tree_right(r))) sem_error(tree_right(r), "right index of case choice " "range is not %s static", static_str); break; case RANGE_EXPR: if (!(*static_fn)(tree_value(r))) sem_error(tree_value(r), "range expression is not %s " "static", static_str); break; default: return false; } } break; } } } return true; } static bool sem_check_match_case(tree_t t, nametab_t *tab) { // Matching case statement is in LRM 08 section 10.9 if (!sem_check_case(t, tab)) return false; tree_t value = tree_value(t); type_t type = tree_type(value); type_t std_bit = std_type(NULL, STD_BIT); type_t std_logic = ieee_type(IEEE_STD_ULOGIC); type_t elem = type; if (type_is_array(type) && dimension_of(type) == 1) elem = type_elem(type); if (!type_eq(elem, std_bit) && !type_eq(elem, std_logic)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "type of expression in a matching case statement must be " "BIT, STD_ULOGIC, or a one-dimensional array of these types"); diag_hint(d, tree_loc(value), "type is %s", type_pp(type)); diag_lrm(d, STD_08, "10.9"); diag_emit(d); return false; } return true; } static bool sem_check_return(tree_t t, nametab_t *tab) { tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub == NULL) sem_error(t, "return statement not allowed outside subprogram"); if (tree_has_value(t)) { if (tree_kind(sub) == T_PROC_BODY) sem_error(t, "cannot return a value from a procedure"); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t expect = tree_type(t); if (!sem_check_type(value, expect, tab)) sem_error(t, "expected return type %s but have %s", type_pp(expect), type_pp(tree_type(value))); } else if (tree_kind(sub) == T_FUNC_BODY) sem_error(t, "return in function must have an expression"); return true; } static bool sem_check_cond_return(tree_t t, nametab_t *tab) { tree_t sub = find_enclosing(tab, S_SUBPROGRAM); if (sub == NULL) sem_error(t, "return statement not allowed outside subprogram"); if (tree_kind(sub) != T_PROC_BODY) sem_error(t, "conditional return statement without value is only " "valid inside a procedure"); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t std_bool = std_type(NULL, STD_BOOLEAN); if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of condition must be %s but have %s", type_pp(std_bool), type_pp(tree_type(value))); return true; } static bool sem_check_while(tree_t t, nametab_t *tab) { type_t std_bool = std_type(NULL, STD_BOOLEAN); tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of loop condition must be %s but is %s", type_pp(std_bool), type_pp(tree_type(value))); return true; } static bool sem_check_for(tree_t t, nametab_t *tab) { if (!sem_check_discrete_range(tree_range(t, 0), NULL, tab)) return false; tree_t idecl = tree_decl(t, 0); if (!sem_check_subtype(idecl, tree_type(idecl), tab)) return false; return true; } static bool sem_check_block(tree_t t, nametab_t *tab) { if (!sem_check_generic_map(t, t, tab)) return false; if (!sem_check_port_map(t, t, tab)) return false; return true; } static bool sem_check_loop_control(tree_t t, nametab_t *tab) { if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t std_bool = std_type(NULL, STD_BOOLEAN); if (!type_eq(tree_type(value), std_bool)) sem_error(value, "type of %s condition must be %s but is %s", (tree_kind(t) == T_EXIT) ? "exit" : "next", type_pp(std_bool), type_pp(tree_type(value))); } return true; } static bool sem_check_attr_decl(tree_t t) { if (!sem_no_access_file_or_protected(t, tree_type(t), "attributes")) return false; return true; } static bool sem_check_attr_spec(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t type = tree_type(t); if (!sem_check_type(value, type, tab)) sem_error(t, "expected attribute specification for %s to have type %s " "but found %s", istr(tree_ident(t)), type_pp(type), type_pp(tree_type(value))); if (!tree_has_ref(t)) return false; tree_t decl = tree_ref(t); const class_t class = tree_class(t); if (class_of(decl) != class) sem_error(t, "class of object %s is %s not %s", istr(tree_ident(decl)), class_str(class_of(decl)), class_str(class)); switch (is_well_known(tree_ident(t))) { case W_NEVER_WAITS: { bool flag; if (!folded_bool(value, &flag)) sem_error(value, "expression must be a BOOLEAN literal"); else if (class != C_PROCEDURE) sem_error(t, "NEVER_WAITS attribute can only be applied to " "procedures"); else if (flag && !tree_frozen(decl)) tree_set_flag(decl, TREE_F_NEVER_WAITS); } break; case W_FOREIGN: if (!tree_frozen(decl)) tree_set_flag(decl, TREE_F_NEVER_WAITS); break; default: break; } return true; } static bool sem_check_if_generate(tree_t t, nametab_t *tab) { const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) { tree_t cond = tree_cond(t, i); if (!sem_check_cond(cond, tab)) return false; if (tree_has_value(cond)) { tree_t value = tree_value(cond); if (!sem_globally_static(value)) sem_error(value, "condition of generate statement must be static"); } } return true; } static bool sem_check_for_generate(tree_t t, nametab_t *tab) { tree_t r = tree_range(t, 0); if (!sem_check_discrete_range(r, NULL, tab)) return false; if (!sem_globally_static(r)) sem_error(r, "range of generate statement must be static"); tree_t idecl = tree_decl(t, 0); assert(tree_kind(idecl) == T_GENERIC_DECL); if (!sem_check_subtype(idecl, tree_type(idecl), tab)) return false; return true; } static bool sem_check_open(tree_t t) { return true; } static bool sem_check_file_decl(tree_t t, nametab_t *tab) { // Rules for file declarations are in LRM 93 section 4.3.1.4 if (!type_is_file(tree_type(t))) sem_error(t, "file declarations must have file type"); if (tree_has_value(t)) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, std_type(NULL, STD_STRING), tab)) sem_error(value, "file name must have type STRING"); tree_t mode = tree_file_mode(t); if (!sem_check(mode, tab)) return false; if (!sem_check_type(mode, std_type(NULL, STD_FILE_OPEN_KIND), tab)) sem_error(mode, "open mode must have type FILE_OPEN_KIND"); } tree_t sub = find_enclosing(tab, S_SUBPROGRAM); const bool in_pure_func = sub != NULL && tree_kind(sub) == T_FUNC_BODY && !(tree_flags(sub) & TREE_F_IMPURE); if (in_pure_func) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { diag_printf(d, "cannot declare a file object in a pure function"); diag_emit(d); } } return true; } static bool sem_check_new(tree_t t, nametab_t *tab) { // Rules for allocators are in LRM 93 section 7.3.6 tree_t value = tree_value(t); type_t access_type = tree_type(t); if (type_is_none(access_type)) return false; assert(type_is_access(access_type)); assert(tree_kind(value) == T_QUALIFIED); if (!sem_check(value, tab)) return false; type_t type = tree_type(value); if (type_is_none(type)) return false; if (!sem_check_subtype(value, type, tab)) return false; const bool has_initial = tree_has_value(value); if (!has_initial && type_is_unconstrained(type)) sem_error(t, "unconstrained array type %s not allowed in allocator " "expression", type_pp(type)); else if (!sem_check_incomplete(t, type)) return false; else if (type_is_protected(type)) { if (has_initial) sem_error(t, "protected type %s cannot have initial value", type_pp(type)); else if (standard() >= STD_19) tree_set_global_flags(t, TREE_GF_INSTANCE_NAME | TREE_GF_PATH_NAME); } type_t designated = type_designated(access_type); if (!type_eq(type, designated)) sem_error(value, "type of allocator expresion %s does not match " "access type %s", type_pp(type), type_pp(designated)); return true; } static bool sem_check_all(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; if (!sem_check_name_prefix(value, tab, "a selected name")) return false; type_t value_type = tree_type(value); if (type_is_none(value_type)) return false; if (!sem_check_readable(value)) return false; if (!type_is_access(value_type)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(value)); diag_printf(d, "prefix of a selected name with suffix ALL must " "have access type"); diag_hint(d, tree_loc(value), "prefix has type %s", type_pp(value_type)); diag_lrm(d, STD_08, "8.3"); diag_emit(d); return false; } return true; } static bool sem_check_binding(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; tree_t unit = primary_unit_of(tree_ref(t)); if (tree_kind(unit) == T_ENTITY) { if (tree_genmaps(t) > 0 && !sem_check_generic_map(t, unit, tab)) return false; if (tree_params(t) > 0 && !sem_check_port_map(t, unit, tab)) return false; } return true; } static bool sem_check_block_config(tree_t t, nametab_t *tab) { return true; } static bool sem_check_spec(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; tree_t comp = tree_ref(t); assert(tree_kind(comp) == T_COMPONENT); if (!tree_has_value(t)) return true; tree_t bind = tree_value(t); assert(tree_kind(bind) == T_BINDING); if (!sem_check(bind, tab)) return false; tree_t unit = tree_ref(bind); tree_t entity = primary_unit_of(unit); assert(tree_kind(entity) == T_ENTITY); bool ok = true; if (tree_genmaps(bind) == 0) { const int c_ngenerics = tree_generics(comp); const int e_ngenerics = tree_generics(entity); bit_mask_t have; mask_init(&have, e_ngenerics); bool have_named = false; for (int i = 0; i < c_ngenerics; i++) { tree_t cg = tree_generic(comp, i); int epos = 0; tree_t match = NULL; for (; epos < e_ngenerics; epos++) { tree_t eg = tree_generic(entity, epos); if (ident_casecmp(tree_ident(eg), tree_ident(cg))) { match = eg; mask_set(&have, epos); break; } } if (match == NULL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "generic %s in component %s has no corresponding " "generic in entity %s", istr(tree_ident(cg)), istr(tree_ident(comp)), istr(tree_ident(entity))); diag_hint(d, tree_loc(cg), "generic %s declared here", istr(tree_ident(cg))); diag_emit(d); ok = false; continue; } tree_t value; if (tree_class(cg) == C_PACKAGE) { tree_t pmap = tree_value(cg); assert(tree_kind(pmap) == T_PACKAGE_MAP); tree_t expect = tree_value(match); assert(tree_kind(expect) == T_PACKAGE_MAP); if (tree_ref(pmap) != tree_ref(expect)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "generic package %s in component %s does not " "match entity %s", istr(tree_ident(cg)), istr(tree_ident(comp)), istr(tree_ident(entity))); diag_hint(d, tree_loc(cg), "declaration of generic %s in " "component as instance of %s", istr(tree_ident(cg)), istr(tree_ident(pmap))); diag_hint(d, tree_loc(match), "declaration of generic %s in " "entity as instance of %s", istr(tree_ident(match)), istr(tree_ident(expect))); diag_emit(d); ok = false; continue; } value = tree_new(T_REF); tree_set_ident(value, tree_ident(cg)); tree_set_ref(value, cg); } else { type_t ctype = tree_type(cg); type_t etype = tree_type(match); if (!type_eq(ctype, etype)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "generic %s in component %s has type %s which " "is incompatible with type %s in entity %s", istr(tree_ident(cg)), istr(tree_ident(comp)), type_pp2(ctype, etype), type_pp2(etype, ctype), istr(tree_ident(entity))); diag_hint(d, tree_loc(cg), "declaration of generic %s in " "component", istr(tree_ident(cg))); diag_hint(d, tree_loc(match), "declaration of generic %s in " "entity", istr(tree_ident(match))); diag_emit(d); ok = false; continue; } value = make_ref(cg); } tree_t map = tree_new(T_PARAM); tree_set_loc(map, tree_loc(t)); tree_set_value(map, value); if (!have_named && epos == i) { tree_set_subkind(map, P_POS); tree_set_pos(map, epos); } else { tree_set_subkind(map, P_NAMED); tree_set_name(map, make_ref(match)); have_named = true; } tree_add_genmap(bind, map); } for (int i = 0; i < e_ngenerics; i++) { tree_t eg = tree_generic(entity, i); if (!mask_test(&have, i) && !tree_has_value(eg)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "generic %s in entity %s without a default value " "has no corresponding generic in component %s", istr(tree_ident(eg)), istr(tree_ident(entity)), istr(tree_ident(comp))); diag_hint(d, tree_loc(eg), "generic %s declared here", istr(tree_ident(eg))); diag_emit(d); ok = false; continue; } } mask_free(&have); } if (tree_params(bind) == 0) { const int c_nports = tree_ports(comp); const int e_nports = tree_ports(entity); bit_mask_t have; mask_init(&have, e_nports); bool have_named = false; for (int i = 0; i < c_nports; i++) { tree_t cp = tree_port(comp, i); int epos = 0; tree_t match = NULL; for (; match == NULL && epos < e_nports; epos++) { tree_t ep = tree_port(entity, epos); if (ident_casecmp(tree_ident(ep), tree_ident(cp))) { match = ep; mask_set(&have, epos); break; } } if (match == NULL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "port %s in component %s has no corresponding port " "in entity %s", istr(tree_ident(cp)), istr(tree_ident(comp)), istr(tree_ident(entity))); diag_hint(d, tree_loc(cp), "port %s declared here", istr(tree_ident(cp))); diag_emit(d); ok = false; continue; } type_t ctype = tree_type(cp); type_t etype = tree_type(match); if (!type_eq(ctype, etype)) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "port %s in component %s has type %s which is " "incompatible with type %s in entity %s", istr(tree_ident(cp)), istr(tree_ident(comp)), type_pp2(ctype, etype), type_pp2(etype, ctype), istr(tree_ident(entity))); diag_hint(d, tree_loc(cp), "declaration of port %s in component", istr(tree_ident(cp))); diag_hint(d, tree_loc(match), "declaration of port %s in entity", istr(tree_ident(match))); diag_emit(d); ok = false; continue; } if (!have_named && epos == i) add_param(bind, make_ref(cp), P_POS, NULL); else { add_param(bind, make_ref(cp), P_NAMED, make_ref(match)); have_named = true; } } for (int i = 0; i < e_nports; i++) { if (mask_test(&have, i)) continue; tree_t ep = tree_port(entity, i); const bool open_ok = tree_has_value(ep) || (tree_subkind(ep) == PORT_OUT && !type_is_unconstrained(tree_type(ep))); if (!open_ok) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "port %s in entity %s without a default value " "has no corresponding port in component %s", istr(tree_ident(ep)), istr(tree_ident(entity)), istr(tree_ident(comp))); diag_hint(d, tree_loc(ep), "port %s declared here", istr(tree_ident(ep))); diag_emit(d); ok = false; continue; } } } return ok; } static bool sem_check_configuration(tree_t t, nametab_t *tab) { if (!tree_has_primary(t)) return false; // Was parse error tree_t of = tree_primary(t); // LRM 08 section 3.4.1: for a configuration of a given design // entity, both the configuration declaration and the corresponding // entity declaration shall reside in the same library ident_t elib = ident_until(tree_ident(of), '.'); if (standard() < STD_19 && elib != lib_name(lib_work())) { diag_t *d = pedantic_diag(tree_loc(t)); if (d != NULL) { ident_t ename = ident_rfrom(tree_ident(of), '.'); diag_printf(d, "configuration declaration %s must reside in the " "same library as entity %s", istr(tree_ident(t)), istr(ename)); diag_hint(d, NULL, "entity %s is in library %s which is not the same " "as the current working library %s", istr(ename), istr(elib), istr(lib_name(lib_work()))); diag_lrm(d, STD_08, "3.4"); diag_emit(d); return false; } } return true; } static bool sem_check_prot_body(tree_t t, nametab_t *tab) { // Rules for protected type bodies are in LRM 00 section 3.5.2 type_t type = tree_type(t); if (type_is_none(type)) return false; if (!sem_check_missing_bodies(t, tab)) return false; return true; } static bool sem_check_implicit_signal(tree_t t, nametab_t *tab) { tree_t value = tree_value(t); type_t type = tree_type(t); if (!sem_check(value, tab)) return false; switch (tree_subkind(t)) { case IMPLICIT_GUARD: if (!sem_check_type(value, type, tab)) sem_error(value, "guard expression must have type %s but " "found %s", type_pp2(type, tree_type(value)), type_pp2(tree_type(value), type)); break; } return true; } static bool sem_check_context_decl(tree_t t, nametab_t *tab) { // Context declarations are in LRM 08 section 13.3 if (!sem_check_context_clause(t, tab)) return false; return true; } static bool sem_check_context_ref(tree_t t, nametab_t *tab) { if (standard() >= STD_08) { tree_t unit = find_enclosing(tab, S_DESIGN_UNIT); if (unit != NULL && tree_kind(unit) == T_CONTEXT) { // LRM 08 section 13.3 ident_t prefix = ident_until(tree_ident(t), '.'); if (prefix == well_known(W_WORK)) sem_error(t, "selected name in context declaration context " "reference may not have WORK as a prefix"); } } return true; } static bool sem_check_disconnect(tree_t t, nametab_t *tab) { if (!tree_has_ref(t)) return false; tree_t decl = tree_ref(t); if (class_of(decl) != C_SIGNAL || !is_guarded_signal(decl)) sem_error(t, "signal name %s in disconnection specification must denote " "a guarded signal", istr(tree_ident(t))); type_t type = tree_type(t); if (!type_eq(tree_type(decl), type)) sem_error(t, "type of declared signal %s does not match type %s in " "disconnection specification", type_pp(tree_type(decl)), type_pp(type)); tree_t delay = tree_delay(t); type_t std_time = std_type(NULL, STD_TIME); if (!sem_check_type(delay, std_time, tab)) sem_error(delay, "time expression in disconnection specification must " "have type %s but found %s", type_pp(std_time), type_pp(tree_type(delay))); if (!sem_globally_static(delay)) sem_error(delay, "time expression in disconnection specificiation " "must be static"); return true; } static bool sem_check_conv_func(tree_t t, nametab_t *tab) { if (type_is_none(tree_type(t))) return false; else if (!tree_has_ref(t)) return false; tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; tree_t decl = tree_ref(t); assert(tree_ports(decl) == 1); tree_t formal = tree_port(decl, 0); type_t ftype = tree_type(formal); if (!sem_check_type(value, ftype, tab)) sem_error(value, "type of conversion function actual %s does not match " "formal %s type %s", type_pp2(tree_type(value), ftype), istr(tree_ident(formal)), type_pp2(ftype, tree_type(value))); return true; } static bool sem_check_concurrent(tree_t t, nametab_t *tab) { if (tree_stmts(t) == 0) return false; // Was parse error return sem_check(tree_stmt(t, 0), tab); } static bool sem_check_external_name(tree_t t, nametab_t *tab) { const int nparts = tree_parts(t); for (int i = 0; i < nparts; i++) { tree_t pe = tree_part(t, i); switch (tree_subkind(pe)) { case PE_GENERATE: { tree_t value = tree_value(pe); if (!sem_globally_static(value)) sem_error(value, "generate index must be a static expression"); } break; case PE_RELATIVE: // Relative pathnames must have enclosing concurrent region if (find_enclosing(tab, S_CONCURRENT_BLOCK) == NULL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(t)); diag_printf(d, "relative pathname has no enclosing " "concurrent region"); diag_lrm(d, STD_08, "8.7"); diag_emit(d); return false; } } } const class_t class = tree_class(t); if (class != C_CONSTANT) { tree_t sub = find_enclosing(tab, S_SUBPROGRAM); const bool is_pure_func = sub != NULL && tree_kind(sub) == T_FUNC_BODY && !(tree_flags(sub) & TREE_F_IMPURE); if (is_pure_func) sem_error(t, "cannot reference external name with class %s in pure " "function %s", class_str(class), istr(tree_ident(sub))); } // Cannot do any more checking until elaboration return true; } static port_mode_t sem_default_force_mode(tree_t target) { // Rules for default force mode in LRM 08 section 10.5.2.1 tree_t ref = name_to_ref(target); if (ref == NULL || !tree_has_ref(ref)) return PORT_IN; tree_t decl = tree_ref(ref); const tree_kind_t dkind = tree_kind(decl); if (dkind == T_PORT_DECL || dkind == T_PARAM_DECL) { switch (tree_subkind(decl)) { case PORT_OUT: case PORT_INOUT: case PORT_BUFFER: return PORT_OUT; default: return PORT_IN; } } return PORT_IN; } static bool sem_check_force_target(tree_t target, port_mode_t mode, const char *what) { tree_t decl = sem_check_lvalue(target); if (decl == NULL) sem_error(target, "target of simple %s assignment must be a " "signal name", what); switch (tree_kind(decl)) { case T_SIGNAL_DECL: break; case T_PORT_DECL: case T_PARAM_DECL: if (tree_class(decl) != C_SIGNAL) { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "%s is not a valid target of simple %s assignment", what, istr(tree_ident(decl))); diag_hint(d, tree_loc(target), "target of simple %s assignment", what); diag_hint(d, tree_loc(decl), "declared with class %s", class_str(tree_class(decl))); diag_emit(d); return false; } else if (mode == PORT_OUT && tree_subkind(decl) == PORT_IN) sem_error(target, "force mode OUT may not be used with target " "of mode IN"); break; case T_EXTERNAL_NAME: if (tree_class(decl) != C_SIGNAL) { tree_t tail = tree_part(decl, tree_parts(decl) - 1); diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "external name %s is not a valid target of " "simple %s assignment", istr(tree_ident(tail)), what); diag_hint(d, tree_loc(target), "target of signal assignment"); diag_hint(d, tree_loc(decl), "declared with class %s", class_str(tree_class(decl))); diag_emit(d); return false; } break; case T_VAR_DECL: case T_CONST_DECL: { diag_t *d = diag_new(DIAG_ERROR, tree_loc(target)); diag_printf(d, "%s %s is not a valid target of simple %s assignment", class_str(class_of(decl)), istr(tree_ident(decl)), what); diag_hint(d, tree_loc(target), "target of simple %s assignment", what); diag_hint(d, tree_loc(decl), "declared as %s", class_str(class_of(decl))); diag_emit(d); return false; } default: sem_error(target, "invalid target of simple %s assignment", what); } return true; } static bool sem_check_force(tree_t t, nametab_t *tab) { tree_t target = tree_target(t); if (!sem_check(target, tab)) return false; port_mode_t mode = tree_subkind(t); if (mode == PORT_INVALID) tree_set_subkind(t, (mode = sem_default_force_mode(target))); if (!sem_check_force_target(target, mode, "force")) return false; tree_t value = tree_value(t); if (!sem_check(value, tab)) return false; type_t expect = tree_type(target); if (!sem_check_type(value, expect, tab)) sem_error(t, "type of force expression %s does not match type of " "target %s", type_pp2(tree_type(value), expect), type_pp2(expect, tree_type(value))); return true; } static bool sem_check_release(tree_t t, nametab_t *tab) { tree_t target = tree_target(t); if (!sem_check(target, tab)) return false; port_mode_t mode = tree_subkind(t); if (mode == PORT_INVALID) tree_set_subkind(t, (mode = sem_default_force_mode(target))); if (!sem_check_force_target(target, mode, "release")) return false; return true; } static bool sem_check_prot_ref(tree_t t, nametab_t *tab) { if (standard() >= STD_19) return true; // Alias of private variable method // There are no legal ways this can appear here and should always // have been converted to a call assert(error_count() > 0); return false; } static bool sem_check_view_decl(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (type_is_none(type)) return false; assert(type_kind(type) == T_VIEW); type_t rtype = type_designated(type); if (!type_is_record(rtype)) { assert(error_count() > 0); // Checked by parser return false; } else if (type_is_resolved(rtype)) sem_error(t, "subtype indication of a mode view declaration " "must denote an unresolved record type"); const int nfields = type_fields(rtype); LOCAL_BIT_MASK have; mask_init(&have, nfields); const int nelems = type_fields(type); for (int i = 0; i < nelems; i++) { tree_t e = type_field(type, i); assert(tree_kind(e) == T_VIEW_ELEMENT); if (!tree_has_ref(e)) return false; tree_t f = tree_ref(e); assert(tree_kind(f) == T_FIELD_DECL); const int pos = tree_pos(f); if (mask_test(&have, pos)) sem_error(e, "duplicate mode view element definition for field %s", istr(tree_ident(e))); mask_set(&have, pos); switch (tree_subkind(e)) { case PORT_LINKAGE: sem_error(e, "element mode indication cannot have mode LINKAGE"); case PORT_RECORD_VIEW: case PORT_ARRAY_VIEW: { tree_t name = tree_value(e); type_t type = tree_type(e); type_t view_type = tree_type(name); if (type_is_none(view_type)) return false; if (type_kind(view_type) != T_VIEW) sem_error(name, "name in element mode view indication of field " "%s does not denote a mode view", istr(tree_ident(f))); type_t elem_type = type; if (tree_subkind(e) == PORT_ARRAY_VIEW) { if (!type_is_array(type)) sem_error(e, "field %s with array mode view indication has " "non-array type %s", istr(tree_ident(f)), type_pp(type)); elem_type = type_elem(type); } if (!type_eq(elem_type, type_designated(view_type))) sem_error(e, "field %s subtype %s is not compatible with mode " "view %s", istr(tree_ident(f)), type_pp(elem_type), type_pp(view_type)); } break; } } if (mask_popcount(&have) != nfields) { LOCAL_TEXT_BUF tb = tb_new(); for (int i = 0, missing = 0; i < nfields; i++) { if (!mask_test(&have, i)) tb_printf(tb, "%s%s", missing++ > 0 ? ", " : "", istr(tree_ident(type_field(rtype, i)))); } sem_error(t, "missing mode view element defintion for %s", tb_get(tb)); } return true; } static bool sem_check_cond_value(tree_t t, nametab_t *tab) { type_t type = tree_type(t); if (type_is_none(type)) return false; type_t std_bool = std_type(NULL, STD_BOOLEAN); const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) { tree_t cond = tree_cond(t, i); assert(tree_kind(cond) == T_COND_EXPR); if (tree_has_value(cond)) { tree_t value = tree_value(cond); if (!sem_check(value, tab)) return false; if (!sem_check_type(value, std_bool, tab)) sem_error(value, "type of condition must be %s but have %s", type_pp(std_bool), type_pp(tree_type(value))); } else assert(i == nconds - 1); if (tree_has_result(cond)) { tree_t result = tree_result(cond); if (!sem_check(result, tab)) return false; if (!sem_check_type(result, type, tab)) sem_error(result, "expected type of conditional expression to be " "%s but is %s", type_pp(type), type_pp(tree_type(result))); } } return true; } static bool sem_check_prot_decl(tree_t t, nametab_t *tab) { const int ndecls = tree_decls(t); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(t, i); if (tree_kind(d) == T_ALIAS) { // LRM 19 section 5.6.2: it is an error if an alias declared // within a protected type declaration denotes anything other // than a method of a protected type tree_t value = tree_value(d); if (tree_kind(value) != T_PROT_REF) sem_error(d, "an alias declared within a protected type " "declaration must denote a protected type method"); } } defer_check(tab, sem_missing_body_cb, t); return true; } static bool sem_check_inertial(tree_t t, nametab_t *tab) { if (!sem_check(tree_value(t), tab)) return false; return true; } static bool sem_check_psl_union(tree_t t, nametab_t *tab) { psl_check(tree_psl(t), tab); return true; } bool sem_check(tree_t t, nametab_t *tab) { switch (tree_kind(t)) { case T_ARCH: return sem_check_arch(t, tab); case T_PACKAGE: return sem_check_package(t, tab); case T_ENTITY: return sem_check_entity(t, tab); case T_TYPE_DECL: return sem_check_type_decl(t, tab); case T_SUBTYPE_DECL: return sem_check_subtype_decl(t, tab); case T_PORT_DECL: return sem_check_port_decl(t, tab); case T_PARAM_DECL: return sem_check_param_decl(t, tab); case T_GENERIC_DECL: return sem_check_generic_decl(t, tab); case T_SIGNAL_DECL: return sem_check_signal_decl(t, tab); case T_VAR_DECL: return sem_check_var_decl(t, tab); case T_CONST_DECL: return sem_check_const_decl(t, tab); case T_PROCESS: return sem_check_process(t, tab); case T_VAR_ASSIGN: return sem_check_var_assign(t, tab); case T_SIGNAL_ASSIGN: return sem_check_signal_assign(t, tab); case T_FCALL: case T_PROT_FCALL: return sem_check_fcall(t, tab); case T_LITERAL: return sem_check_literal(t); case T_STRING: return sem_check_string_literal(t); case T_REF: return sem_check_ref(t, tab); case T_WAIT: return sem_check_wait(t, tab); case T_ASSERT: return sem_check_assert(t, tab); case T_REPORT: return sem_check_report(t, tab); case T_QUALIFIED: return sem_check_qualified(t, tab); case T_FUNC_DECL: return sem_check_func_decl(t, tab); case T_AGGREGATE: return sem_check_aggregate(t, tab); case T_ATTR_REF: return sem_check_attr_ref(t, false, tab); case T_ARRAY_REF: return sem_check_array_ref(t, tab); case T_ARRAY_SLICE: return sem_check_array_slice(t, tab); case T_INSTANCE: return sem_check_instance(t, tab); case T_IF: return sem_check_if(t, tab); case T_NULL: return true; case T_PACK_BODY: return sem_check_pack_body(t, tab); case T_FUNC_BODY: return sem_check_func_body(t, tab); case T_RETURN: return sem_check_return(t, tab); case T_COND_RETURN: return sem_check_cond_return(t, tab); case T_COND_ASSIGN: return sem_check_cond_assign(t, tab); case T_WHILE: return sem_check_while(t, tab); case T_ALIAS: return sem_check_alias(t, tab); case T_FOR: return sem_check_for(t, tab); case T_PROC_DECL: return sem_check_proc_decl(t, tab); case T_PROC_BODY: return sem_check_proc_body(t, tab); case T_BLOCK: return sem_check_block(t, tab); case T_CASE: case T_SELECT: return sem_check_case(t, tab); case T_EXIT: case T_NEXT: return sem_check_loop_control(t, tab); case T_PCALL: case T_PROT_PCALL: return sem_check_pcall(t, tab); case T_ATTR_SPEC: return sem_check_attr_spec(t, tab); case T_ATTR_DECL: return sem_check_attr_decl(t); case T_COMPONENT: return sem_check_component(t, tab); case T_IF_GENERATE: return sem_check_if_generate(t, tab); case T_FOR_GENERATE: return sem_check_for_generate(t, tab); case T_CASE_GENERATE: return sem_check_case(t, tab); case T_OPEN: return sem_check_open(t); case T_FIELD_DECL: return sem_check_field_decl(t); case T_FILE_DECL: return sem_check_file_decl(t, tab); case T_NEW: return sem_check_new(t, tab); case T_ALL: return sem_check_all(t, tab); case T_RECORD_REF: return sem_check_record_ref(t, tab); case T_UNIT_DECL: return sem_check_unit_decl(t); case T_USE: return sem_check_use_clause(t, tab); case T_TYPE_CONV: return sem_check_conversion(t, tab); case T_SPEC: return sem_check_spec(t, tab); case T_BINDING: return sem_check_binding(t, tab); case T_LIBRARY: return sem_check_library_clause(t, tab); case T_CONFIGURATION: return sem_check_configuration(t, tab); case T_PROT_BODY: return sem_check_prot_body(t, tab); case T_CONTEXT: return sem_check_context_decl(t, tab); case T_CONTEXT_REF: return sem_check_context_ref(t, tab); case T_BLOCK_CONFIG: return sem_check_block_config(t, tab); case T_IMPLICIT_SIGNAL: return sem_check_implicit_signal(t, tab); case T_DISCONNECT: return sem_check_disconnect(t, tab); case T_GROUP: case T_GROUP_TEMPLATE: case T_BOX: case T_PSL_DIRECT: case T_PSL_DECL: case T_PSL_FCALL: case T_LOOP: case T_SEQUENCE: return true; case T_PSL_UNION: return sem_check_psl_union(t, tab); case T_CONV_FUNC: return sem_check_conv_func(t, tab); case T_CONCURRENT: return sem_check_concurrent(t, tab); case T_PACK_INST: return sem_check_pack_inst(t, tab); case T_EXTERNAL_NAME: return sem_check_external_name(t, tab); case T_FORCE: return sem_check_force(t, tab); case T_RELEASE: return sem_check_release(t, tab); case T_PROT_REF: return sem_check_prot_ref(t, tab); case T_MATCH_CASE: case T_MATCH_SELECT: return sem_check_match_case(t, tab); case T_FUNC_INST: case T_PROC_INST: return sem_check_subprogram_inst(t, tab); case T_VIEW_DECL: return sem_check_view_decl(t, tab); case T_COND_VALUE: return sem_check_cond_value(t, tab); case T_PROT_DECL: return sem_check_prot_decl(t, tab); case T_INERTIAL: return sem_check_inertial(t, tab); default: sem_error(t, "cannot check %s", tree_kind_str(tree_kind(t))); } } nvc-r1.17.1/src/server.c000066400000000000000000001157551504111170000150160ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "jit/jit.h" #include "option.h" #include "phase.h" #include "rt/shell.h" #include "server.h" #include "sha1.h" #include "thread.h" #include #include #include #include #include #include #include #include #include #include #include #ifdef __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #else #include #include #include #endif #define WS_UPGRADE_VALUE "websocket" #define WS_WEBSOCKET_VERSION "13" #define WS_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" #define WS_GUID_LEN 36 #define WS_KEY_LEN 24 #define WS_KEY_GUID_LEN (WS_KEY_LEN + WS_GUID_LEN) #define HTTP_SWITCHING_PROTOCOLS 101 #define HTTP_OK 200 #define HTTP_BAD_REQUEST 400 #define HTTP_NOT_FOUND 404 #define HTTP_METHOD_NOT_ALLOWED 405 #define HTTP_UPGRADE_REQUIRED 426 #define HTTP_INTERNAL_SERVER_ERROR 500 #define WS_OPCODE_TEXT_FRAME 0x1 #define WS_OPCODE_BINARY_FRAME 0x2 #define WS_OPCODE_CLOSE_FRAME 0x8 #define WS_OPCODE_PING_FRAME 0x9 #define WS_OPCODE_PONG_FRAME 0xa #define MAX_HTTP_REQUEST 1024 #ifndef __MINGW32__ #define closesocket close #endif typedef struct _debug_server debug_server_t; typedef struct _web_socket { int sock; bool mask; bool closing; ws_handler_t handler; size_t tx_size; size_t tx_wptr; size_t tx_rptr; uint8_t *tx_buf; size_t rx_size; size_t rx_wptr; size_t rx_rptr; uint8_t *rx_buf; } web_socket_t; typedef struct _packet_buf { char *buf; size_t alloc; size_t wptr; size_t rptr; } packet_buf_t; typedef struct { debug_server_t *(*new_server)(void); void (*free_server)(debug_server_t *); void (*new_connection)(debug_server_t *, int); int (*fill_fd_set)(debug_server_t *, fd_set *, fd_set *); void (*poll_sockets)(debug_server_t *, fd_set *, fd_set *); void (*shutdown)(debug_server_t *); } server_proto_t; typedef struct _debug_server { const server_proto_t *proto; tcl_shell_t *shell; bool shutdown; bool banner; int sock; tree_t top; packet_buf_t *packetbuf; const char *init_cmd; } debug_server_t; typedef struct { debug_server_t server; web_socket_t *websocket; } http_server_t; typedef struct { debug_server_t server; int sock; size_t rx_size; size_t rx_wptr; size_t rx_rptr; char *rx_buf; size_t tx_size; size_t tx_wptr; size_t tx_rptr; uint8_t *tx_buf; } cxxrtl_server_t; //////////////////////////////////////////////////////////////////////////////// // WebSocket wrapper web_socket_t *ws_new(int sock, const ws_handler_t *handler, bool mask) { web_socket_t *ws = xcalloc(sizeof(web_socket_t)); ws->sock = sock; ws->mask = mask; ws->handler = *handler; return ws; } void ws_free(web_socket_t *ws) { free(ws->tx_buf); free(ws->rx_buf); free(ws); } static void ws_queue_buf(web_socket_t *ws, const void *data, size_t size) { if (ws->tx_wptr + size > ws->tx_size) { ws->tx_size = MAX(ws->tx_size + size, 1024); ws->tx_buf = xrealloc(ws->tx_buf, ws->tx_size); } memcpy(ws->tx_buf + ws->tx_wptr, data, size); ws->tx_wptr += size; } static void ws_send(web_socket_t *ws, int opcode, const void *data, size_t size) { const uint8_t size0 = (size < 126 ? size : (size <= UINT16_MAX ? 126 : 127)); const uint8_t header[2] = { 0x80 | opcode, (ws->mask ? 0x80 : 0x00) | (size0 & 0x7f), }; ws_queue_buf(ws, header, sizeof(header)); if (size0 == 126) { const uint8_t extlength[2] = { PACK_BE16(size) }; ws_queue_buf(ws, extlength, sizeof(extlength)); } else if (size0 == 127) { const uint8_t extlength[8] = { PACK_BE64(size) }; ws_queue_buf(ws, extlength, sizeof(extlength)); } if (ws->mask) { const int key = rand(); const uint8_t masks[4] = { PACK_BE32(key) }; ws_queue_buf(ws, masks, sizeof(masks)); char xord[128]; for (size_t i = 0; i < size; i += sizeof(xord)) { const size_t chunksz = MIN(sizeof(xord), size - i); for (int j = 0; j < chunksz; j++) xord[j] = ((const uint8_t *)data)[i + j] ^ masks[(i + j) % 4]; ws_queue_buf(ws, xord, chunksz); } } else if (size > 0) ws_queue_buf(ws, data, size); } void ws_send_binary(web_socket_t *ws, const void *data, size_t size) { ws_send(ws, WS_OPCODE_BINARY_FRAME, data, size); } void ws_send_packet(web_socket_t *ws, packet_buf_t *pb) { ws_send_binary(ws, pb->buf, pb->wptr); } void ws_send_text(web_socket_t *ws, const char *text) { ws_send(ws, WS_OPCODE_TEXT_FRAME, text, strlen(text)); } void ws_send_close(web_socket_t *ws) { ws_send(ws, WS_OPCODE_CLOSE_FRAME, NULL, 0); } void ws_send_ping(web_socket_t *ws, const void *data, size_t size) { ws_send(ws, WS_OPCODE_PING_FRAME, data, size); } void ws_flush(web_socket_t *ws) { while (ws->tx_wptr != ws->tx_rptr) { const size_t chunksz = ws->tx_wptr - ws->tx_rptr; const ssize_t nbytes = send(ws->sock, (char *)ws->tx_buf + ws->tx_rptr, chunksz, 0); if (nbytes == 0) break; else if (nbytes < 0) { ws->closing = true; break; } ws->tx_rptr += nbytes; } if (ws->tx_wptr == ws->tx_rptr) ws->tx_rptr = ws->tx_wptr = 0; } void ws_poll(web_socket_t *ws) { read_more: if (ws->rx_size - ws->rx_wptr < 1024) ws->rx_buf = xrealloc(ws->rx_buf, (ws->rx_size += 1024)); const ssize_t nbytes = recv(ws->sock, (char *)ws->rx_buf + ws->rx_wptr, ws->rx_size - ws->rx_wptr - 1, 0); if (nbytes == -1 && errno == EAGAIN) return; else if (nbytes <= 0) { ws->closing = true; return; } ws->rx_wptr += nbytes; assert(ws->rx_wptr <= ws->rx_size); assert(ws->rx_rptr < ws->rx_wptr); do { const size_t rbytes = ws->rx_wptr - ws->rx_rptr; if (rbytes < 2) goto read_more; // Not enough for WebSocket header uint8_t *frame = ws->rx_buf + ws->rx_rptr; // Frame format // // 0 1 2 3 4 5 6 7 8 9 A B C D E F // FIN RSV1 RSV2 RSV3 Opcode Mask Payload length // Extended payload length (optional) // Masking key (optional) // Payload data const bool fin = frame[0] & 0x80; const int opcode = frame[0] & 0xf; const bool mask = frame[1] & 0x80; const int size0 = frame[1] & 0x7f; size_t headersz = 2 + (mask ? 4 : 0); if (size0 == 126) headersz += 2; else if (size0 == 127) headersz += 8; if (rbytes < headersz) goto read_more; // Not enough for extended header int flength = size0; if (size0 == 127) flength = UNPACK_BE64(frame + 2); else if (size0 == 126) flength = UNPACK_BE16(frame + 2); if (rbytes < flength + headersz) goto read_more; // Not enough for full frame assert(fin); (void)fin; if (mask) { for (int i = 0; i < flength; i++) frame[headersz + i] ^= frame[headersz - 4 + (i % 4)]; } void *payload = frame + headersz; switch (opcode) { case WS_OPCODE_TEXT_FRAME: { char *text = payload; assert(text + flength < (char *)ws->rx_buf + ws->rx_size); text[flength] = '\0'; if (ws->handler.text_frame != NULL) (*ws->handler.text_frame)(ws, text, ws->handler.context); } break; case WS_OPCODE_BINARY_FRAME: if (ws->handler.binary_frame != NULL) (*ws->handler.binary_frame)(ws, payload, flength, ws->handler.context); break; case WS_OPCODE_CLOSE_FRAME: ws->closing = true; break; case WS_OPCODE_PING_FRAME: ws_send(ws, WS_OPCODE_PONG_FRAME, payload, flength); break; case WS_OPCODE_PONG_FRAME: if (ws->handler.pong_frame != NULL) (*ws->handler.pong_frame)(ws, payload, flength, ws->handler.context); break; default: DEBUG_ONLY(fatal_trace("unhandled WebSocket opcode %02x", opcode)); break; } ws->rx_rptr += flength + headersz; } while (ws->rx_rptr < ws->rx_wptr); ws->rx_rptr = ws->rx_wptr = 0; } bool ws_closing(web_socket_t *ws) { return ws->closing; } //////////////////////////////////////////////////////////////////////////////// // Packet buffers static packet_buf_t *pb_new(void) { packet_buf_t *pb = xcalloc(sizeof(packet_buf_t)); pb->alloc = 128; pb->buf = xmalloc(pb->alloc); return pb; } static void pb_free(packet_buf_t *pb) { free(pb->buf); free(pb); } static void pb_grow(packet_buf_t *pb, size_t need) { if (pb->wptr + need > pb->alloc) { pb->alloc = MAX(pb->wptr + need, pb->alloc * 2); pb->buf = xrealloc(pb->buf, pb->alloc); } } static void pb_pack_u8(packet_buf_t *pb, uint8_t value) { pb_grow(pb, 1); pb->buf[pb->wptr++] = value; } static void pb_pack_u16(packet_buf_t *pb, uint16_t value) { pb_grow(pb, 2); pb->buf[pb->wptr++] = value >> 8; pb->buf[pb->wptr++] = value & 0xff; } static void pb_pack_u32(packet_buf_t *pb, uint32_t value) { pb_grow(pb, 4); pb->buf[pb->wptr++] = (value >> 24) & 0xff; pb->buf[pb->wptr++] = (value >> 16) & 0xff; pb->buf[pb->wptr++] = (value >> 8) & 0xff; pb->buf[pb->wptr++] = value & 0xff; } static void pb_pack_u64(packet_buf_t *pb, uint64_t value) { pb_grow(pb, 8); pb->buf[pb->wptr++] = (value >> 56) & 0xff; pb->buf[pb->wptr++] = (value >> 48) & 0xff; pb->buf[pb->wptr++] = (value >> 40) & 0xff; pb->buf[pb->wptr++] = (value >> 32) & 0xff; pb->buf[pb->wptr++] = (value >> 24) & 0xff; pb->buf[pb->wptr++] = (value >> 16) & 0xff; pb->buf[pb->wptr++] = (value >> 8) & 0xff; pb->buf[pb->wptr++] = value & 0xff; } static void pb_pack_bytes(packet_buf_t *pb, const void *data, size_t len) { pb_grow(pb, len); memcpy(pb->buf + pb->wptr, data, len); pb->wptr += len; } static void pb_pack_str(packet_buf_t *pb, const char *str) { const size_t len = strlen(str); assert(len < UINT16_MAX); pb_pack_u16(pb, len); pb_pack_bytes(pb, str, len); } static void pb_pack_ident(packet_buf_t *pb, ident_t ident) { const size_t len = ident_len(ident); assert(len < UINT16_MAX); pb_pack_u16(pb, len); pb_pack_bytes(pb, istr(ident), len); } //////////////////////////////////////////////////////////////////////////////// // Generic networking utilities typedef enum { LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR } log_level_t; __attribute__((format(printf, 2, 3))) static void server_log(log_level_t level, const char *fmt, ...) { if (opt_get_int(OPT_UNIT_TEST)) return; else if (DEBUG_ONLY(false &&) level < LOG_INFO) return; va_list ap; va_start(ap, fmt); switch (level) { case LOG_DEBUG: color_printf("$#8$D: "); break; case LOG_INFO: printf("I: "); break; case LOG_WARN: color_printf("$yellow$W: "); break; case LOG_ERROR: color_printf("$red$E: "); break; } vprintf(fmt, ap); color_printf("$$\n"); fflush(stdout); va_end(ap); } static void send_fully(int fd, const void *data, size_t len) { while (len > 0) { ssize_t nbytes = send(fd, data, len, 0); if (nbytes <= 0) { server_log(LOG_ERROR, "send: %s", strerror(errno)); return; } data += nbytes; len -= nbytes; } } static void base64_encode(const void *in, size_t len, text_buf_t *tb) { static const char map[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; const unsigned char *data = in; for (size_t i = 0; i < len; i++) { int c0 = (data[i] >> 2) & 0x3F; tb_append(tb, map[c0]); c0 = (data[i] << 4) & 0x3F; if (++i < len) c0 |= (data[i] >> 4) & 0x0F; tb_append(tb, map[c0]); if (i < len) { int c1 = (data[i] << 2) & 0x3F; if (++i < len) c1 |= (data[i] >> 6) & 0x03; tb_append(tb, map[c1]); } else { ++i; tb_append(tb, '='); } if (i < len) { int c2 = data[i] & 0x3F; tb_append(tb, map[c2]); } else tb_append(tb, '='); } } static packet_buf_t *fresh_packet_buffer(debug_server_t *server) { server->packetbuf->wptr = 0; return server->packetbuf; } //////////////////////////////////////////////////////////////////////////////// // HTTP and WebSocket server static void send_http_headers(int fd, int status, const char *type, size_t len, const char *headers) { LOCAL_TEXT_BUF date = tb_new(); tb_strftime(date, "G%a, %d %b %Y %H:%M:%S %Z", time(NULL)); char buf[512]; const int nbytes = checked_sprintf(buf, sizeof(buf), "HTTP/1.1 %d\r\n" "Date: %s\r\n" "Content-Type: %s; charset=UTF-8\r\n" "Content-Length: %zu\r\n" "%s\r\n", status, tb_get(date), type, len, headers); send_fully(fd, buf, nbytes); } static void send_page(int fd, int status, const char *page) { const size_t len = strlen(page); send_http_headers(fd, status, "text/html", len, ""); send_fully(fd, page, len); } #ifdef ENABLE_GUI static void send_file(int fd, const char *file, const char *mime) { FILE *f = fopen(file, "rb"); if (f == NULL) { send_page(fd, HTTP_NOT_FOUND, "File not found"); return; } file_info_t info; if (!get_handle_info(fileno(f), &info)) { send_page(fd, HTTP_INTERNAL_SERVER_ERROR, "Cannot stat file"); goto out_close; } send_http_headers(fd, HTTP_OK, mime, info.size, ""); char buf[1024]; for (ssize_t remain = info.size, nbytes; remain > 0; remain -= nbytes) { memset(buf, '\0', sizeof(buf)); if ((nbytes = fread(buf, 1, MIN(remain, sizeof(buf)), f)) == 0) { server_log(LOG_ERROR, "fread: %s: %s", file, strerror(errno)); goto out_close; } send_fully(fd, buf, nbytes); } out_close: fclose(f); } #endif static void handle_text_frame(web_socket_t *ws, const char *text, void *context) { debug_server_t *server = context; const char *result = NULL; if (shell_eval(server->shell, text, &result) && *result != '\0') ws_send_text(ws, result); } static void handle_binary_frame(web_socket_t *ws, const void *data, size_t length, void *context) { debug_server_t *server = context; if (length == 0) { server_log(LOG_WARN, "ignoring zero-length binary frame"); return; } const c2s_opcode_t op = *(const uint8_t *)data; switch (op) { case C2S_SHUTDOWN: server->shutdown = true; break; default: server_log(LOG_ERROR, "unhandled client to server opcode %02x", op); break; } } static void kill_http_connection(http_server_t *http) { diag_set_consumer(NULL, NULL); closesocket(http->websocket->sock); ws_free(http->websocket); http->websocket = NULL; } static void tunnel_diag(diag_t *d, void *context) { http_server_t *http = container_of(context, http_server_t, server); if (http->websocket != NULL) { ws_send_text(http->websocket, diag_get_text(d)); } else server_log(LOG_INFO, "%s", diag_get_text(d)); } static void tunnel_output(const char *buf, size_t nchars, void *user) { http_server_t *http = container_of(user, http_server_t, server); ws_send(http->websocket, WS_OPCODE_TEXT_FRAME, buf, nchars); } static void tunnel_backchannel(const char *buf, size_t nchars, void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_BACKCHANNEL); pb_pack_u32(pb, nchars); pb_pack_bytes(pb, buf, nchars); ws_send_packet(http->websocket, pb); } static void add_wave_handler(ident_t path, const char *enc, void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_ADD_WAVE); pb_pack_ident(pb, path); pb_pack_str(pb, enc); ws_send_packet(http->websocket, pb); } static void signal_update_handler(ident_t path, uint64_t now, rt_signal_t *s, const char *enc, void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_SIGNAL_UPDATE); pb_pack_ident(pb, path); pb_pack_str(pb, enc); ws_send_packet(http->websocket, pb); } static void start_sim_handler(ident_t top, void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_START_SIM); pb_pack_ident(pb, top); ws_send_packet(http->websocket, pb); } static void restart_sim_handler(void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_RESTART_SIM); ws_send_packet(http->websocket, pb); } static void next_time_step_handler(uint64_t now, void *user) { http_server_t *http = container_of(user, http_server_t, server); packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_NEXT_TIME_STEP); pb_pack_u64(pb, now); ws_send_packet(http->websocket, pb); } static void open_websocket(http_server_t *http, int fd) { if (http->websocket != NULL) { ws_send_close(http->websocket); ws_flush(http->websocket); kill_http_connection(http); } const ws_handler_t handler = { .text_frame = handle_text_frame, .binary_frame = handle_binary_frame, .context = &(http->server) }; http->websocket = ws_new(fd, &handler, false); diag_set_consumer(tunnel_diag, &(http->server)); if (http->server.banner) shell_print_banner(http->server.shell); if (http->server.top != NULL) shell_reset(http->server.shell, http->server.top); if (http->server.init_cmd != NULL) { packet_buf_t *pb = fresh_packet_buffer(&(http->server)); pb_pack_u8(pb, S2C_INIT_CMD); pb_pack_str(pb, http->server.init_cmd); ws_send_packet(http->websocket, pb); } } static bool get_websocket_accept_value(const char *key, text_buf_t *tb) { if (key == NULL || strlen(key) != WS_KEY_LEN) return false; char *str LOCAL = xmalloc(WS_KEY_LEN + WS_GUID_LEN + 1); strncpy(str, key, (WS_KEY_LEN + 1)); strncpy(str + WS_KEY_LEN, WS_GUID, WS_GUID_LEN + 1); SHA1_CTX ctx; SHA1Init(&ctx); SHA1Update(&ctx, (unsigned char *)str, WS_KEY_GUID_LEN); unsigned char hash[SHA1_LEN]; SHA1Final(hash, &ctx); base64_encode(hash, SHA1_LEN, tb); return true; } static void websocket_upgrade(http_server_t *http, int fd, const char *method, const char *version, shash_t *headers) { LOCAL_TEXT_BUF tb = tb_new(); if (strcmp(method, "GET") != 0 || strcmp(version, "HTTP/1.1") != 0) { send_page(fd, HTTP_BAD_REQUEST, "Bad request"); goto out_close; } const char *ws_version_header = shash_get(headers, "sec-websocket-version"); if (ws_version_header == NULL || strcasecmp(ws_version_header, WS_WEBSOCKET_VERSION) != 0) { static const char page[] = "Upgrade required"; static const char header[] = "Sec-WebSocket-Version:" WS_WEBSOCKET_VERSION; send_http_headers(fd, HTTP_UPGRADE_REQUIRED, "text/html", sizeof(page), header); send_fully(fd, page, sizeof(page)); goto out_close; } const char *ws_key_header = shash_get(headers, "sec-websocket-key"); if (ws_key_header == NULL || strlen(ws_key_header) != WS_KEY_LEN) { send_page(fd, HTTP_BAD_REQUEST, "Bad request"); goto out_close; } tb_cat(tb, "Connection: upgrade\r\n" "Upgrade: websocket\r\n" "Sec-WebSocket-Accept: "); if (!get_websocket_accept_value(ws_key_header, tb)) goto out_close; tb_cat(tb, "\r\n"); send_http_headers(fd, HTTP_SWITCHING_PROTOCOLS, "text/html", 0, tb_get(tb)); open_websocket(http, fd); return; // Socket left open out_close: closesocket(fd); } static bool is_websocket_request(shash_t *headers) { const char *upg_header = shash_get(headers, "upgrade"); const char *con_header = shash_get(headers, "connection"); return (upg_header != NULL && con_header != NULL) && (strcasecmp(upg_header, WS_UPGRADE_VALUE) == 0) && (strcasestr(con_header, "Upgrade") != NULL); } #ifdef ENABLE_GUI static void serve_gui_static_files(int fd, const char *url) { LOCAL_TEXT_BUF tb = tb_new(); get_data_dir(tb); tb_cat(tb, "/gui"); if (strcmp(url, "/") == 0) { tb_cat(tb, "/index.html"); send_file(fd, tb_get(tb), "text/html"); return; } const char *mime = "application/octet-stream"; const char *dot = strrchr(url, '.'); if (dot != NULL) { static const char *mime_map[][2] = { { ".js", "text/javascript" }, { ".css", "text/css" }, { ".map", "application/json" }, }; for (int i = 0; i < ARRAY_LEN(mime_map); i++) { if (strcmp(dot, mime_map[i][0]) == 0) { mime = mime_map[i][1]; break; } } } tb_cat(tb, url); send_file(fd, tb_get(tb), mime); } #endif static void handle_http_request(http_server_t *http, int fd, const char *method, const char *url, const char *version, shash_t *headers) { server_log(LOG_DEBUG, "%s %s", method, url); if (is_websocket_request(headers)) { websocket_upgrade(http, fd, method, version, headers); return; // Socket left open } else if (strcmp(method, "GET") != 0) { send_page(fd, HTTP_METHOD_NOT_ALLOWED, "Method not allowed"); goto out_close; } #ifdef ENABLE_GUI serve_gui_static_files(fd, url); #else send_page(fd, HTTP_NOT_FOUND, "Not found"); #endif out_close: closesocket(fd); } static void http_new_connection(debug_server_t *server, int fd) { char buf[MAX_HTTP_REQUEST + 1]; size_t reqlen = 0; do { ssize_t n = recv(fd, buf + reqlen, MAX_HTTP_REQUEST - reqlen, 0); #ifdef __MINGW32__ const bool would_block = (n == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK); #else const bool would_block = (n == -1 && errno == EWOULDBLOCK); #endif if (would_block) { fd_set rfd; FD_ZERO(&rfd); FD_SET(fd, &rfd); struct timeval tv = { .tv_sec = 1, .tv_usec = 0 }; if (select(fd + 1, &rfd, NULL, NULL, &tv) == -1) { server_log(LOG_ERROR, "select: %s", last_os_error()); goto out_close; } if (FD_ISSET(fd, &rfd)) continue; server_log(LOG_ERROR, "timeout waiting for HTTP request"); goto out_close; } else if (n <= 0) { server_log(LOG_ERROR, "recv: %s", last_os_error()); goto out_close; } reqlen += n; assert(reqlen <= MAX_HTTP_REQUEST); if (reqlen == MAX_HTTP_REQUEST) { server_log(LOG_ERROR, "HTTP request too big"); goto out_close; } buf[reqlen] = '\0'; } while (strstr(buf, "\r\n\r\n") == NULL); const char *method = "GET"; const char *url = "/"; const char *version = ""; char *saveptr, *saveptr2; char *line = strtok_r(buf, "\r\n", &saveptr); if (line == NULL) { server_log(LOG_ERROR, "malformed HTTP request"); goto out_close; } method = strtok_r(line, " ", &saveptr2); if (method == NULL) goto malformed; url = strtok_r(NULL, " ", &saveptr2); if (url == NULL) goto malformed; version = strtok_r(NULL, " ", &saveptr2); if (version == NULL) goto malformed; shash_t *headers = shash_new(64); while ((line = strtok_r(NULL, "\r\n", &saveptr)) && line[0] != '\0') { char *colon = strchr(line, ':'); if (colon != NULL) { *colon = '\0'; char *value = colon + 1; while (*value == ' ') value++; for (char *p = line; *p; p++) *p = tolower_iso88591(*p); shash_put(headers, line, value); } } http_server_t *http = container_of(server, http_server_t, server); handle_http_request(http, fd, method, url, version, headers); shash_free(headers); return; malformed: server_log(LOG_ERROR, "malformed HTTP request"); out_close: closesocket(fd); } static int http_fill_fd_set(debug_server_t *server, fd_set *rfd, fd_set *wfd) { http_server_t *http = container_of(server, http_server_t, server); if (http->websocket == NULL) return -1; FD_SET(http->websocket->sock, rfd); if (http->websocket->tx_wptr != http->websocket->tx_rptr) FD_SET(http->websocket->sock, wfd); return http->websocket->sock; } static void http_poll_sockets(debug_server_t *server, fd_set *rfd, fd_set *wfd) { http_server_t *http = container_of(server, http_server_t, server); if (http->websocket == NULL) return; if (FD_ISSET(http->websocket->sock, rfd)) ws_poll(http->websocket); if (FD_ISSET(http->websocket->sock, wfd)) ws_flush(http->websocket); if (http->websocket->closing) kill_http_connection(http); } static void http_shutdown(debug_server_t *server) { http_server_t *http = container_of(server, http_server_t, server); if (http->websocket != NULL) ws_send_close(http->websocket); } static debug_server_t *http_server_new(void) { http_server_t *http = xcalloc(sizeof(http_server_t)); return &(http->server); } static void http_server_free(debug_server_t *server) { http_server_t *http = container_of(server, http_server_t, server); assert(http->websocket == NULL); free(http); } static const server_proto_t http_protocol = { .new_server = http_server_new, .free_server = http_server_free, .new_connection = http_new_connection, .fill_fd_set = http_fill_fd_set, .poll_sockets = http_poll_sockets, .shutdown = http_shutdown, }; //////////////////////////////////////////////////////////////////////////////// // CXXRTL debug protocol over TCP // // https://gist.github.com/whitequark/59520e2de0947da8747061bc2ea91639 static void kill_cxxrtl_connection(cxxrtl_server_t *cxxrtl) { diag_set_consumer(NULL, NULL); closesocket(cxxrtl->sock); cxxrtl->sock = -1; cxxrtl->rx_rptr = cxxrtl->rx_wptr = 0; } static void cxxrtl_send(cxxrtl_server_t *cxxrtl, json_t *json) { // TODO: use json_dumpb or json_dump_callback char *str LOCAL = json_dumps(json, JSON_COMPACT); server_log(LOG_DEBUG, "S->C: %s", str); const size_t size = strlen(str) + 1; if (cxxrtl->tx_wptr + size > cxxrtl->tx_size) { cxxrtl->tx_size = MAX(cxxrtl->tx_size + size, 1024); cxxrtl->tx_buf = xrealloc(cxxrtl->tx_buf, cxxrtl->tx_size); } memcpy(cxxrtl->tx_buf + cxxrtl->tx_wptr, str, size); cxxrtl->tx_wptr += size; } static void cxxrtl_error(cxxrtl_server_t *cxxrtl, json_t *json, const char *error, const char *message) { json_object_set_new(json, "type", json_string("error")); json_object_set_new(json, "error", json_string(error)); json_object_set_new(json, "message", json_string(message)); cxxrtl_send(cxxrtl, json); } static void handle_greeting(cxxrtl_server_t *cxxrtl, json_t *json) { json_t *version = json_object_get(json, "version"); if (version == NULL) return cxxrtl_error(cxxrtl, json, "parse_error", "Missing version"); else if (json_integer_value(version) != 0) return cxxrtl_error(cxxrtl, json, "version_error", "Epected version 0"); json_t *commands = json_array(); json_object_set_new(json, "commands", commands); static const char *supported_commands[] = { "list_scopes", "list_items", "reference_items", "query_interval", "get_simulation_status", "run_simulation", "pause_simulation", "nvc.quit_simulation", }; for (size_t i = 0; i < ARRAY_LEN(supported_commands); i++) json_array_append_new(commands, json_string(supported_commands[i])); json_t *events = json_array(); json_object_set_new(json, "events", events); static const char *supported_events[] = { "simulation_paused", "simulation_finished" }; for (size_t i = 0; i < ARRAY_LEN(supported_events); i++) json_array_append_new(events, json_string(supported_events[i])); json_t *features = json_object(); json_object_set_new(json, "features", features); json_t *encoding = json_array(); json_object_set_new(json, "item_values_encoding", encoding); json_array_append_new(encoding, json_string("base64(u32)")); json_object_set_new(features, "encoding", encoding); cxxrtl_send(cxxrtl, json); } static void handle_get_simulation_status(cxxrtl_server_t *cxxrtl, json_t *json) { json_object_set_new(json, "type", json_string("response")); json_object_set_new(json, "status", json_string("paused")); json_object_set_new(json, "latest_time", json_string("0.0")); json_object_set_new(json, "next_sample_time", json_string("0.0")); cxxrtl_send(cxxrtl, json); } static void handle_quit_simulation(cxxrtl_server_t *cxxrtl, json_t *json) { cxxrtl->server.shutdown = true; json_object_set_new(json, "type", json_string("response")); cxxrtl_send(cxxrtl, json); } static void handle_command(cxxrtl_server_t *cxxrtl, json_t *json) { json_t *command = json_object_get(json, "command"); if (command == NULL) return cxxrtl_error(cxxrtl, json, "parse_error", "Missing command"); const char *str = json_string_value(command); if (strcmp(str, "get_simulation_status") == 0) handle_get_simulation_status(cxxrtl, json); else if (strcmp(str, "nvc.quit_simulation") == 0) handle_quit_simulation(cxxrtl, json); else cxxrtl_error(cxxrtl, json, "bad_command", "Invalid command"); } static void cxxrtl_new_connection(debug_server_t *server, int fd) { cxxrtl_server_t *cxxrtl = container_of(server, cxxrtl_server_t, server); if (cxxrtl->sock != -1) { server_log(LOG_INFO, "closing old connection"); closesocket(cxxrtl->sock); } cxxrtl->sock = fd; } static int cxxrtl_fill_fd_set(debug_server_t *server, fd_set *rfd, fd_set *wfd) { cxxrtl_server_t *cxxrtl = container_of(server, cxxrtl_server_t, server); if (cxxrtl->sock != -1) FD_SET(cxxrtl->sock, rfd); if (cxxrtl->tx_wptr != cxxrtl->tx_rptr) FD_SET(cxxrtl->sock, wfd); return cxxrtl->sock; } static void cxxrtl_read_message(cxxrtl_server_t *cxxrtl) { if (cxxrtl->rx_size - cxxrtl->rx_wptr < 1024) cxxrtl->rx_buf = xrealloc(cxxrtl->rx_buf, (cxxrtl->rx_size += 1024)); const ssize_t nbytes = recv(cxxrtl->sock, cxxrtl->rx_buf + cxxrtl->rx_wptr, cxxrtl->rx_size - cxxrtl->rx_wptr, 0); if (nbytes == -1 && errno == EAGAIN) return; else if (nbytes == 0) { kill_cxxrtl_connection(cxxrtl); return; } else if (nbytes < 0) { server_log(LOG_ERROR, "connection closed: %s", last_os_error()); kill_cxxrtl_connection(cxxrtl); return; } cxxrtl->rx_wptr += nbytes; assert(cxxrtl->rx_wptr <= cxxrtl->rx_size); assert(cxxrtl->rx_rptr < cxxrtl->rx_wptr); do { char *endp = memchr(cxxrtl->rx_buf + cxxrtl->rx_rptr, '\0', cxxrtl->rx_wptr - cxxrtl->rx_rptr); if (endp == NULL) return; server_log(LOG_DEBUG, "C->S: %s", cxxrtl->rx_buf + cxxrtl->rx_rptr); json_error_t error; json_t *root = json_loads(cxxrtl->rx_buf + cxxrtl->rx_rptr, 0, &error); if (endp == cxxrtl->rx_buf + cxxrtl->rx_wptr - 1) cxxrtl->rx_wptr = cxxrtl->rx_rptr = 0; else cxxrtl->rx_rptr = endp - cxxrtl->rx_buf + 1; if (!json_is_object(root)) { cxxrtl_error(cxxrtl, root, "bad_json", "Nnot a JSON object"); json_decref(root); continue; } json_t *type = json_object_get(root, "type"); if (!json_is_string(type)) { cxxrtl_error(cxxrtl, root, "parse_error", "Missing type field"); json_decref(root); continue; } const char *typestr = json_string_value(type); if (strcmp(typestr, "greeting") == 0) handle_greeting(cxxrtl, root); else if (strcmp(typestr, "command") == 0) handle_command(cxxrtl, root); else server_log(LOG_ERROR, "unhandled message type '%s'", typestr); json_decref(root); } while (cxxrtl->rx_rptr != cxxrtl->rx_wptr); } static void cxxrtl_flush(cxxrtl_server_t *cxxrtl) { while (cxxrtl->tx_wptr != cxxrtl->tx_rptr) { const size_t chunksz = cxxrtl->tx_wptr - cxxrtl->tx_rptr; const ssize_t nbytes = send(cxxrtl->sock, cxxrtl->tx_buf + cxxrtl->tx_rptr, chunksz, 0); if (nbytes == 0) break; else if (nbytes < 0) { kill_cxxrtl_connection(cxxrtl); break; } cxxrtl->tx_rptr += nbytes; } if (cxxrtl->tx_wptr == cxxrtl->tx_rptr) cxxrtl->tx_rptr = cxxrtl->tx_wptr = 0; } static void cxxrtl_poll_sockets(debug_server_t *server, fd_set *rfd, fd_set *wfd) { cxxrtl_server_t *cxxrtl = container_of(server, cxxrtl_server_t, server); if (cxxrtl->sock == -1) return; if (FD_ISSET(cxxrtl->sock, rfd)) cxxrtl_read_message(cxxrtl); if (FD_ISSET(cxxrtl->sock, wfd)) cxxrtl_flush(cxxrtl); if (server->shutdown && cxxrtl->tx_wptr == cxxrtl->tx_rptr) { closesocket(cxxrtl->sock); cxxrtl->sock = -1; } } static void cxxrtl_shutdown(debug_server_t *server) { // TODO: send an event to the client? } static debug_server_t *cxxrtl_server_new(void) { cxxrtl_server_t *cxxrtl = xcalloc(sizeof(cxxrtl_server_t)); cxxrtl->sock = -1; return &(cxxrtl->server); } static void cxxrtl_server_free(debug_server_t *server) { cxxrtl_server_t *cxxrtl = container_of(server, cxxrtl_server_t, server); assert(cxxrtl->sock == -1); free(cxxrtl->rx_buf); free(cxxrtl->tx_buf); free(cxxrtl); } static const server_proto_t cxxrtl_protocol = { .new_server = cxxrtl_server_new, .free_server = cxxrtl_server_free, .new_connection = cxxrtl_new_connection, .fill_fd_set = cxxrtl_fill_fd_set, .poll_sockets = cxxrtl_poll_sockets, .shutdown = cxxrtl_shutdown, }; //////////////////////////////////////////////////////////////////////////////// // Server event loop static void handle_new_connection(debug_server_t *server) { int fd = accept(server->sock, NULL, NULL); if (fd < 0) { server_log(LOG_ERROR, "accept: %s", last_os_error()); return; } #ifdef __MINGW32__ if (ioctlsocket(fd, FIONBIO, &(unsigned long){1})) { server_log(LOG_ERROR, "ioctlsocket: %s", last_os_error()); closesocket(fd); return; } #else const int flags = fcntl(fd, F_GETFL, 0); if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) { server_log(LOG_ERROR, "fcntl: %s", last_os_error()); close(fd); return; } #endif if (server->proto->new_connection != NULL) (*server->proto->new_connection)(server, fd); } static int open_server_socket(void) { #ifdef __MINGW32__ WSADATA wsaData; if (WSAStartup(MAKEWORD(2, 2), &wsaData)) fatal_errno("WSAStartup failed"); #endif int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sock < 0) fatal_errno("socket"); if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&(int){1}, sizeof(int)) < 0) fatal_errno("setsockopt"); const uint16_t port = opt_get_int(OPT_SERVER_PORT); struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) fatal_errno("bind"); if (listen(sock, SOMAXCONN) < 0) fatal_errno("listen"); server_log(LOG_INFO, "listening on 127.0.0.1:%u", port); return sock; } void start_server(server_kind_t kind, jit_t *jit, tree_t top, server_ready_fn_t cb, void *arg, const char *init_cmd) { static const server_proto_t *map[] = { [SERVER_HTTP] = &http_protocol, [SERVER_CXXRTL] = &cxxrtl_protocol }; debug_server_t *server = (*map[kind]->new_server)(); server->shell = shell_new(jit); server->top = top; server->packetbuf = pb_new(); server->init_cmd = init_cmd; server->banner = !opt_get_int(OPT_UNIT_TEST); server->proto = map[kind]; shell_handler_t handler = { .add_wave = add_wave_handler, .signal_update = signal_update_handler, .stderr_write = tunnel_output, .stdout_write = tunnel_output, .backchannel_write = tunnel_backchannel, .start_sim = start_sim_handler, .restart_sim = restart_sim_handler, .next_time_step = next_time_step_handler, .context = server }; shell_set_handler(server->shell, &handler); server->sock = open_server_socket(); if (cb != NULL) (*cb)(arg); for (;;) { fd_set rfd, wfd, efd; FD_ZERO(&rfd); FD_ZERO(&wfd); FD_ZERO(&efd); int max_fd = -1; if (server->sock != -1) { FD_SET(server->sock, &rfd); max_fd = MAX(max_fd, server->sock); } const int proto_max = (*server->proto->fill_fd_set)(server, &rfd, &wfd); max_fd = MAX(max_fd, proto_max); if (max_fd == -1) break; struct timeval tv = { .tv_sec = 1, .tv_usec = 0 }; if (select(max_fd + 1, &rfd, &wfd, &efd, &tv) == -1) fatal_errno("select"); if (server->sock != -1 && FD_ISSET(server->sock, &rfd)) handle_new_connection(server); (*server->proto->poll_sockets)(server, &rfd, &wfd); if (server->shutdown && server->sock != -1) { server_log(LOG_INFO, "stopping server"); closesocket(server->sock); server->sock = -1; (*server->proto->shutdown)(server); } } assert(server->sock == -1); pb_free(server->packetbuf); shell_free(server->shell); (*server->proto->free_server)(server); } nvc-r1.17.1/src/server.h000066400000000000000000000037661504111170000150210ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _SERVER_H #define _SERVER_H #include "prim.h" #include "rt/shell.h" #include typedef struct _web_socket web_socket_t; typedef enum { C2S_SHUTDOWN = 0x00, } c2s_opcode_t; typedef enum { S2C_ADD_WAVE = 0x00, S2C_SIGNAL_UPDATE = 0x01, S2C_INIT_CMD = 0x02, S2C_START_SIM = 0x03, S2C_RESTART_SIM = 0x04, S2C_NEXT_TIME_STEP = 0x06, S2C_BACKCHANNEL = 0x07, } s2c_opcode_t; typedef struct { void (*text_frame)(web_socket_t *, const char *, void *); void (*binary_frame)(web_socket_t *, const void *, size_t, void *); void (*pong_frame)(web_socket_t *, const void *, size_t, void *); void *context; } ws_handler_t; web_socket_t *ws_new(int sock, const ws_handler_t *handler, bool mask); void ws_free(web_socket_t *ws); void ws_send_binary(web_socket_t *ws, const void *data, size_t size); void ws_send_text(web_socket_t *ws, const char *text); void ws_send_ping(web_socket_t *ws, const void *data, size_t size); void ws_flush(web_socket_t *ws); void ws_poll(web_socket_t *ws); bool ws_closing(web_socket_t *ws); typedef void (*server_ready_fn_t)(void *); typedef enum { SERVER_HTTP, SERVER_CXXRTL, } server_kind_t; void start_server(server_kind_t kind, jit_t *jit, tree_t top, server_ready_fn_t cb, void *arg, const char *init_cmd); #endif // _SERVER_H nvc-r1.17.1/src/simp.c000066400000000000000000001374161504111170000144560ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "eval.h" #include "hash.h" #include "option.h" #include "phase.h" #include "type.h" #include #include #include #include #include #include typedef struct { tree_t top; jit_t *jit; unit_registry_t *registry; mir_context_t *mir; hash_t *generics; } simp_ctx_t; typedef A(tree_t) tree_list_t; static tree_t simp_call_args(tree_t t) { tree_t decl = tree_ref(t); const int nparams = tree_params(t); const int nports = tree_ports(decl); // Replace named arguments with positional ones int last_pos = -1; for (int i = 0; i < nparams; i++) { if (tree_subkind(tree_param(t, i)) == P_POS) last_pos = i; } if (last_pos == nports - 1) return t; tree_t new = tree_new(tree_kind(t)); tree_set_loc(new, tree_loc(t)); if (tree_has_ident(t)) tree_set_ident(new, tree_ident(t)); tree_set_ref(new, tree_ref(t)); tree_kind_t kind = tree_kind(t); if (kind == T_FCALL || kind == T_PROT_FCALL) { tree_set_type(new, tree_type(t)); tree_set_flag(new, tree_flags(t)); } if ((kind == T_PROT_PCALL || kind == T_PROT_FCALL) && tree_has_name(t)) tree_set_name(new, tree_name(t)); for (int i = 0; i <= last_pos; i++) { tree_t param = tree_param(t, i); tree_t value = tree_value(param); add_param(new, value, P_POS, NULL); } for (int i = last_pos + 1; i < nports; i++) { tree_t port = tree_port(decl, i); tree_t agg = NULL; bool found = false; for (int j = last_pos + 1; j < nparams; j++) { tree_t p = tree_param(t, j); assert(tree_subkind(p) == P_NAMED); tree_t name = tree_name(p); const tree_kind_t name_kind = tree_kind(name); if (name_kind == T_REF) { if (tree_ref(name) == port) { add_param(new, tree_value(p), P_POS, NULL); found = true; break; } } else { // Must be a partial association tree_t ref = tree_value(name); assert(tree_kind(ref) == T_REF); // Checked by sem if (tree_ref(ref) == port) { if (agg == NULL) { agg = tree_new(T_AGGREGATE); tree_set_loc(agg, tree_loc(p)); tree_set_type(agg, tree_type(port)); add_param(new, agg, P_POS, NULL); } tree_t a = tree_new(T_ASSOC); tree_set_loc(a, tree_loc(p)); tree_set_subkind(a, A_NAMED); tree_set_value(a, tree_value(p)); if (name_kind == T_RECORD_REF) tree_set_name(a, make_ref(tree_ref(name))); else tree_set_name(a, tree_value(tree_param(name, 0))); tree_add_assoc(agg, a); found = true; } } } if (!found) { assert(tree_has_value(port)); // Checked by sem tree_t open = tree_new(T_OPEN); tree_set_loc(open, tree_loc(t)); tree_set_type(open, tree_type(port)); add_param(new, open, P_POS, NULL); } } return new; } static tree_t simp_concat(tree_t t) { assert(tree_params(t) == 2); tree_t p0 = tree_value(tree_param(t, 0)); tree_t p1 = tree_value(tree_param(t, 1)); tree_t p0_enum = NULL, p1_enum = NULL; const tree_kind_t p0_kind = tree_kind(p0); const tree_kind_t p1_kind = tree_kind(p1); type_t type = tree_type(t); bool is_string = true; // Only handle concatenations of string literals and enumeration // literals if (p0_kind == T_REF) { if (tree_kind((p0_enum = tree_ref(p0))) != T_ENUM_LIT) is_string = false; } else if (p0_kind != T_STRING) is_string = false; if (p1_kind == T_REF) { if (tree_kind((p1_enum = tree_ref(p1))) != T_ENUM_LIT) is_string = false; } else if (p1_kind != T_STRING) is_string = false; if (is_string) { tree_t new = tree_new(T_STRING); tree_set_loc(new, tree_loc(t)); if (p0_enum != NULL) tree_add_char(new, make_ref(p0_enum)); else { const int p0_chars = tree_chars(p0); for (int i = 0; i < p0_chars; i++) tree_add_char(new, tree_char(p0, i)); } if (p1_enum != NULL) tree_add_char(new, make_ref(p1_enum)); else { const int p1_chars = tree_chars(p1); for (int i = 0; i < p1_chars; i++) tree_add_char(new, tree_char(p1, i)); } tree_set_type(new, subtype_for_string(new, type)); return new; } // Convert all other concatenations to aggregates tree_t agg = tree_new(T_AGGREGATE); tree_set_type(agg, type); tree_set_loc(agg, tree_loc(t)); tree_t params[] = { tree_value(tree_param(t, 0)), tree_value(tree_param(t, 1)) }; for (int i = 0, pos = 0; i < ARRAY_LEN(params); i++) { if (tree_kind(params[i]) == T_AGGREGATE) { bool can_merge = true; const int nassocs = tree_assocs(params[i]); for (int j = 0; j < nassocs; j++) { const assoc_kind_t akind = tree_subkind(tree_assoc(params[i], j)); if (akind != A_POS && akind != A_CONCAT) { can_merge = false; break; } } if (can_merge) { for (int j = 0; j < nassocs; j++, pos++) tree_add_assoc(agg, tree_assoc(params[i], j)); continue; } } tree_t a = tree_new(T_ASSOC); tree_set_loc(a, tree_loc(t)); tree_set_value(a, params[i]); tree_set_pos(a, pos++); if (type_eq(tree_type(params[i]), type)) tree_set_subkind(a, A_CONCAT); else tree_set_subkind(a, A_POS); tree_add_assoc(agg, a); } return agg; } static tree_t simp_literal_expr(tree_t t, subprogram_kind_t kind) { // Simplify basic operations on literals without the overhead of // generating code int64_t p0, p1, result; switch (tree_params(t)) { case 2: if (!folded_int(tree_value(tree_param(t, 1)), &p1)) return t; // Fall-through case 1: if (!folded_int(tree_value(tree_param(t, 0)), &p0)) return t; break; default: return t; } switch (kind) { case S_NEGATE: if (p0 == INT64_MIN) return t; else return get_int_lit(t, NULL, -p0); case S_IDENTITY: return get_int_lit(t, NULL, p0); case S_SCALAR_NOT: return get_enum_lit(t, NULL, !p0); case S_SCALAR_EQ: return get_enum_lit(t, NULL, p0 == p1); case S_SCALAR_NEQ: return get_enum_lit(t, NULL, p0 != p1); case S_SCALAR_GT: return get_enum_lit(t, NULL, p0 > p1); case S_SCALAR_LT: return get_enum_lit(t, NULL, p0 < p1); case S_SCALAR_GE: return get_enum_lit(t, NULL, p0 >= p1); case S_SCALAR_LE: return get_enum_lit(t, NULL, p0 <= p1); case S_SCALAR_XOR: return get_enum_lit(t, NULL, p0 ^ p1); case S_SCALAR_XNOR: return get_enum_lit(t, NULL, !(p0 ^ p1)); case S_SCALAR_AND: return get_enum_lit(t, NULL, p0 & p1); case S_SCALAR_NAND: return get_enum_lit(t, NULL, !(p0 & p1)); case S_SCALAR_OR: return get_enum_lit(t, NULL, p0 | p1); case S_SCALAR_NOR: return get_enum_lit(t, NULL, !(p0 | p1)); case S_ADD: if (__builtin_add_overflow(p0, p1, &result)) return t; else return get_int_lit(t, NULL, result); case S_SUB: if (__builtin_sub_overflow(p0, p1, &result)) return t; else return get_int_lit(t, NULL, result); case S_MUL: if (__builtin_mul_overflow(p0, p1, &result)) return t; else return get_int_lit(t, NULL, result); case S_DIV: if ((p0 == INT64_MIN && p1 == -1) || p1 == 0) return t; else return get_int_lit(t, NULL, p0 / p1); case S_EXP: if (p1 >= 0 && ipow_safe(p0, p1, &result)) return get_int_lit(t, NULL, result); else return t; case S_ABS: if (p0 == INT64_MIN) return t; else return get_int_lit(t, NULL, llabs(p0)); default: return t; } } static tree_t simp_fcall_local(tree_t t, simp_ctx_t *ctx) { tree_t new = simp_call_args(t); if (new != t) return new; // Will be called again on new tree const subprogram_kind_t kind = tree_subkind(tree_ref(t)); if (kind == S_CONCAT) return simp_concat(t); else if (kind != S_USER) { tree_t new = simp_literal_expr(t, kind); if (new != t) return new; } if (!(tree_flags(t) & TREE_F_LOCALLY_STATIC)) return t; if (eval_possible(t, ctx->registry, ctx->mir)) return eval_try_fold(ctx->jit, t, ctx->registry, NULL, NULL); return t; } static tree_t simp_fcall_global(tree_t t, simp_ctx_t *ctx) { const subprogram_kind_t kind = tree_subkind(tree_ref(t)); assert(kind != S_CONCAT); if (kind != S_USER) { tree_t new = simp_literal_expr(t, kind); if (new != t) return new; } const tree_flags_t flags = tree_flags(t); if (flags & TREE_F_GLOBALLY_STATIC) { // Only evaluate non-scalar expressions if they are locally-static if (!(flags & TREE_F_LOCALLY_STATIC) && !type_is_scalar(tree_type(t))) return t; else if (!eval_possible(t, ctx->registry, ctx->mir)) return t; return eval_try_fold(ctx->jit, t, ctx->registry, NULL, NULL); } return t; } static tree_t simp_type_conv(tree_t t, simp_ctx_t *ctx) { type_t type = tree_type(t); if (type_is_array(type)) { type_t elem = type_elem(type); if (dimension_of(type) > 1 || !type_is_scalar(elem)) return t; // Not supported currently } if (eval_possible(t, ctx->registry, ctx->mir)) return eval_try_fold(ctx->jit, t, ctx->registry, NULL, NULL); return t; } static tree_t simp_pcall(tree_t t, simp_ctx_t *ctx) { tree_t new = simp_call_args(t); if (new != t) return new; return t; } static tree_t simp_record_ref(tree_t t, simp_ctx_t *ctx) { tree_t value = tree_value(t); if (tree_kind(value) == T_AGGREGATE) { ident_t field = tree_ident(t); type_t type = tree_type(value); const int nassocs = tree_assocs(value); for (int i = 0; i < nassocs; i++) { tree_t a = tree_assoc(value, i); switch (tree_subkind(a)) { case A_POS: if (tree_ident(type_field(type, tree_pos(a))) == field) return tree_value(a); break; case A_NAMED: if (tree_ident(tree_name(a)) == field) return tree_value(a); break; } } } return t; } static tree_t simp_ref(tree_t t, simp_ctx_t *ctx) { tree_t decl = tree_ref(t); switch (tree_kind(decl)) { case T_CONST_DECL: if (tree_flags(t) & (TREE_F_FORMAL_NAME | TREE_F_ATTR_PREFIX)) return t; else if (tree_has_value(decl)) { tree_t value = tree_value(decl); return is_literal(value) ? value : t; } else return t; case T_UNIT_DECL: return tree_value(decl); case T_GENERIC_DECL: if (ctx->generics != NULL) { tree_t map = hash_get(ctx->generics, decl); if (map != NULL) { switch (tree_kind(map)) { case T_LITERAL: case T_REF: // Do not rewrite references to non-references if they appear // as formal names or as prefixes of attribute names if (tree_flags(t) & (TREE_F_FORMAL_NAME | TREE_F_ATTR_PREFIX)) break; return map; default: fatal_trace("cannot rewrite generic %s to tree kind %s", istr(tree_ident(t)), tree_kind_str(tree_kind(map))); } } } return t; default: return t; } } static tree_t simp_attr_ref(tree_t t, simp_ctx_t *ctx) { if (tree_has_value(t)) return tree_value(t); const attr_kind_t predef = tree_subkind(t); switch (predef) { case ATTR_POS: { tree_t value = tree_value(tree_param(t, 0)); int64_t ipos; if (folded_int(value, &ipos)) return get_int_lit(t, NULL, ipos); } break; case ATTR_LENGTH: case ATTR_LEFT: case ATTR_LOW: case ATTR_HIGH: case ATTR_RIGHT: case ATTR_ASCENDING: { tree_t name = tree_name(t); if (tree_kind(name) == T_ATTR_REF) { // Try to rewrite expressions like X'RANGE(1)'LEFT to X'LEFT(1) switch (tree_subkind(name)) { case ATTR_RANGE: case ATTR_BASE: case ATTR_REVERSE_RANGE: { tree_t prefix = tree_name(name); tree_t new = tree_new(T_ATTR_REF); tree_set_loc(new, tree_loc(t)); tree_set_name(new, prefix); tree_set_ident(new, tree_ident(t)); tree_set_subkind(new, predef); tree_set_type(new, tree_type(t)); const int nparams = tree_params(name); if (nparams == 1) { // Avoid duplicated error messages if dimension is // out of range tree_t p0 = tree_param(name, 0); int64_t dim; if (!folded_int(tree_value(p0), &dim)) return t; else if (dim < 1 || dim > dimension_of(tree_type(prefix))) return t; tree_add_param(new, p0); } else assert(nparams == 0); return new; } } } type_t type = tree_type(name); int64_t dim_i = 1; if (type_kind(type) == T_ENUM) { // Enumeration subtypes are handled below const int nlits = type_enum_literals(type); switch (predef) { case ATTR_LEFT: case ATTR_LOW: return make_ref(type_enum_literal(type, 0)); case ATTR_RIGHT: case ATTR_HIGH: return make_ref(type_enum_literal(type, nlits - 1)); case ATTR_ASCENDING: return get_enum_lit(t, NULL, true); case ATTR_LENGTH: return get_int_lit(t, NULL, nlits); default: fatal_trace("invalid enumeration attribute %d", predef); } } else if (type_is_array(type)) { if (tree_params(t) > 0) { tree_t value = tree_value(tree_param(t, 0)); if (!folded_int(value, &dim_i)) fatal_at(tree_loc(value), "locally static dimension " "expression was not folded"); } if (tree_kind(name) == T_REF && tree_kind(tree_ref(name)) == T_TYPE_DECL && type_kind(type) == T_ARRAY) { // Get index type of unconstrained array if (dim_i < 1 || dim_i > type_indexes(type)) break; type = type_index(type, dim_i - 1); dim_i = 1; } else if (type_is_unconstrained(type)) break; else if (dim_i < 1 || dim_i > dimension_of(type)) break; } tree_t r = range_of(type, dim_i - 1); const range_kind_t rkind = tree_subkind(r); if (rkind != RANGE_TO && rkind != RANGE_DOWNTO) break; int64_t low, high; if (!folded_bounds(r, &low, &high)) break; switch (predef) { case ATTR_LENGTH: { int64_t length = 0; if (high < low) return get_int_lit(t, NULL, 0); else { bool overflow = false; overflow |= __builtin_sub_overflow(high, low, &length); overflow |= __builtin_add_overflow(length, 1, &length); if (overflow) error_at(tree_loc(t), "value of LENGTH attribute " "exceeds universal integer range"); return get_int_lit(t, NULL, length); } } case ATTR_LOW: return get_int_lit(t, NULL, low); case ATTR_HIGH: return get_int_lit(t, NULL, high); case ATTR_LEFT: return get_int_lit(t, NULL, rkind == RANGE_TO ? low : high); case ATTR_RIGHT: return get_int_lit(t, NULL, rkind == RANGE_TO ? high : low); case ATTR_ASCENDING: return get_enum_lit(t, NULL, (rkind == RANGE_TO)); default: break; } } break; default: break; } return t; } static void simp_build_wait_cb(tree_t expr, void *ctx) { tree_t wait = ctx; // Check for duplicates const int ntriggers = tree_triggers(wait); for (int i = 0; i < ntriggers; i++) { tree_t t = tree_trigger(wait, i); if (same_tree(t, expr)) return; } // Cannot use the static wait optimisation if the sensitivity list // contains an external name as it may change the elaboration order if (tree_kind(expr) == T_EXTERNAL_NAME) tree_clear_flag(wait, TREE_F_STATIC_WAIT); tree_add_trigger(wait, expr); } static void simp_all_sensitivity_cb(tree_t expr, void *ctx) { tree_t ref = name_to_ref(expr); assert(ref != NULL); tree_t decl = tree_ref(ref); if (tree_kind(decl) == T_PARAM_DECL) return; // Parameter of procedure declared within process simp_build_wait_cb(expr, ctx); } static void simp_synth_check_cb(tree_t expr, void *ctx) { tree_t prefix[8] = { expr }, proc = ctx; int nprefix = 1; for (tree_t ref = expr; nprefix < ARRAY_LEN(prefix) && tree_kind(ref) != T_REF; prefix[nprefix++] = ref = tree_value(ref)); const int ntriggers = tree_triggers(proc); for (int i = 0; i < ntriggers; i++) { tree_t trigger = tree_trigger(proc, i); for (int j = 0; j < nprefix; j++) { if (same_tree(prefix[j], trigger)) return; } } diag_t *d = diag_new(DIAG_WARN, tree_loc(expr)); diag_printf(d, "signal %s is read in ", istr(tree_ident(prefix[nprefix - 1]))); if (tree_flags(proc) & TREE_F_SYNTHETIC_NAME) diag_printf(d, "the process"); else diag_printf(d, "process %s", istr(tree_ident(proc))); diag_printf(d, " but is not in the sensitivity list"); diag_hint(d, tree_loc(proc), "missing from sensitivity list"); diag_hint(d, tree_loc(expr), "read here"); diag_emit(d); tree_add_trigger(proc, expr); // Suppress further warnings } static void simp_clock_edge_cb(tree_t t, void *ctx) { bool *clocked = ctx; // Simple heuristic to detect clock expressions switch (tree_kind(t)) { case T_ATTR_REF: if (tree_subkind(t) == ATTR_EVENT) *clocked = true; break; case T_FCALL: { switch (is_well_known(tree_ident2(tree_ref(t)))) { case W_IEEE_1164_RISING_EDGE: case W_IEEE_1164_FALLING_EDGE: *clocked = true; break; default: break; } } break; default: break; } } static void simp_synth_sensitivity(tree_t proc) { const int nstmts = tree_stmts(proc); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(proc, i); if (tree_kind(s) == T_IF) { const int nconds = tree_conds(s); for (int j = 0; j < nconds; j++) { tree_t c = tree_cond(s, j); if (tree_has_value(c)) { tree_t value = tree_value(c); bool clocked = false; tree_visit(value, simp_clock_edge_cb, &clocked); if (clocked) build_wait(value, simp_synth_check_cb, proc); else build_wait(c, simp_synth_check_cb, proc); } else build_wait(c, simp_synth_check_cb, proc); } } else build_wait(s, simp_synth_check_cb, proc); } } static tree_t simp_process(tree_t t) { // Replace sensitivity list with a "wait on" statement const int ntriggers = tree_triggers(t); if (ntriggers > 0) { const int nstmts = tree_stmts(t); if (nstmts == 0) return NULL; // Body was optimised away tree_t p = tree_new(T_PROCESS); tree_set_ident(p, tree_ident(t)); tree_set_loc(p, tree_loc(t)); tree_set_flag(p, tree_flags(t)); const int ndecls = tree_decls(t); for (int i = 0; i < ndecls; i++) tree_add_decl(p, tree_decl(t, i)); for (int i = 0; i < nstmts; i++) tree_add_stmt(p, tree_stmt(t, i)); tree_t w = tree_new(T_WAIT); tree_set_ident(w, tree_ident(p)); tree_set_flag(w, TREE_F_STATIC_WAIT); if (ntriggers == 1 && tree_kind(tree_trigger(t, 0)) == T_ALL) build_wait(t, simp_all_sensitivity_cb, w); else { if (opt_get_int(OPT_CHECK_SYNTHESIS)) simp_synth_sensitivity(t); // May add to list after ntriggers for (int i = 0; i < ntriggers; i++) tree_add_trigger(w, tree_trigger(t, i)); } tree_add_stmt(p, w); return p; } // Delete processes that contain just a single wait statement if (tree_stmts(t) == 1 && tree_kind(tree_stmt(t, 0)) == T_WAIT) return NULL; else return t; } static tree_t simp_wait(tree_t t) { // LRM 93 section 8.1 // If there is no sensitivity list supplied generate one from the // condition clause if (tree_has_value(t) && tree_triggers(t) == 0) build_wait(tree_value(t), simp_build_wait_cb, t); return t; } static bool simp_find_drivers(tree_t t, tree_list_t *list) { switch (tree_kind(t)) { case T_SIGNAL_ASSIGN: APUSH(*list, longest_static_prefix(tree_target(t))); return true; case T_DUMMY_DRIVER: APUSH(*list, tree_target(t)); return true; case T_VAR_ASSIGN: case T_WAIT: case T_NEXT: case T_EXIT: case T_FORCE: case T_RELEASE: case T_RETURN: case T_ASSERT: case T_REPORT: return true; case T_IF: { const int nconds = tree_conds(t); for (int i = 0; i < nconds; i++) { if (!simp_find_drivers(tree_cond(t, i), list)) return false; } return true; } case T_CASE: case T_MATCH_CASE: case T_WHILE: case T_LOOP: case T_FOR: case T_COND_STMT: case T_SEQUENCE: case T_ALTERNATIVE: { const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) { if (!simp_find_drivers(tree_stmt(t, i), list)) return false; } return true; } default: return false; // Conservative } } static void simp_make_dummy_drivers(tree_t container, tree_list_t *list) { for (int i = 0; i < list->count; i++) { tree_t d = tree_new(T_DUMMY_DRIVER); tree_set_loc(d, tree_loc(list->items[i])); tree_set_target(d, list->items[i]); tree_add_stmt(container, d); } ACLEAR(*list); } static bool simp_match_case_choice(tree_t alt, int64_t ival) { const int nassocs = tree_assocs(alt); for (int j = 0; j < nassocs; j++) { tree_t a = tree_assoc(alt, j); switch (tree_subkind(a)) { case A_NAMED: { int64_t aval; if (folded_int(tree_name(a), &aval) && ival == aval) return true; } break; case A_RANGE: { int64_t low, high; if (!folded_bounds(tree_range(a, 0), &low, &high)) continue; else if (ival >= low && ival <= high) return true; } case A_OTHERS: return true; } } return false; } static tree_t simp_case(tree_t t) { const int nstmts = tree_stmts(t); if (nstmts == 0) return NULL; // All choices are unreachable int64_t ival; if (!folded_int(tree_value(t), &ival)) return t; for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(t, i); if (!simp_match_case_choice(alt, ival)) continue; // This choice is always executed tree_list_t drivers = AINIT; for (int k = 0; k < nstmts; k++) { if (i != k && !simp_find_drivers(tree_stmt(t, k), &drivers)) { ACLEAR(drivers); return t; } } if (tree_stmts(alt) == 0 && drivers.count == 0) return NULL; tree_t seq = tree_new(T_SEQUENCE); tree_set_loc(seq, tree_loc(alt)); if (tree_has_ident(t)) tree_set_ident(seq, tree_ident(t)); const int nstmts = tree_stmts(alt); for (int i = 0; i < nstmts; i++) tree_add_stmt(seq, tree_stmt(alt, i)); simp_make_dummy_drivers(seq, &drivers); return seq; } return NULL; // No choices can be executed } static tree_t simp_case_generate(tree_t t) { const int nstmts = tree_stmts(t); if (nstmts == 0) return NULL; // All choices are unreachable int64_t ival; if (!folded_int(tree_value(t), &ival)) return t; for (int i = 0; i < nstmts; i++) { tree_t alt = tree_stmt(t, i); if (!simp_match_case_choice(alt, ival)) continue; // This choice is always executed if (tree_stmts(alt) == 0) return NULL; tree_t seq = tree_new(T_BLOCK); tree_set_loc(seq, tree_loc(alt)); if (tree_has_ident(alt)) tree_set_ident(seq, tree_ident(alt)); else if (tree_has_ident(t)) tree_set_ident(seq, tree_ident(t)); const int ndecls = tree_decls(alt); for (int i = 0; i < ndecls; i++) tree_add_decl(seq, tree_decl(alt, i)); const int nstmts = tree_stmts(alt); for (int i = 0; i < nstmts; i++) tree_add_stmt(seq, tree_stmt(alt, i)); return seq; } return NULL; // No choices can be executed } static tree_t simp_if(tree_t t) { const int nconds = tree_conds(t); bool any_folded = false, trivial_true = false; for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(t, i); bool bval; if (!tree_has_value(c)) continue; else if (folded_bool(tree_value(c), &bval)) { any_folded = true; trivial_true |= (i == 0 && bval); } } if (!any_folded) return t; tree_t new = NULL; if (!trivial_true) { new = tree_new(T_IF); tree_set_loc(new, tree_loc(t)); if (tree_has_ident(t)) tree_set_ident(new, tree_ident(t)); } tree_list_t drivers = AINIT; for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(t, i); bool bval = true; if (tree_has_value(c) && !folded_bool(tree_value(c), &bval)) { tree_add_cond(new, c); continue; } else if (bval) { for (int j = i + 1; j < nconds; j++) { if (!simp_find_drivers(tree_cond(t, j), &drivers)) { ACLEAR(drivers); return t; } } if (new != NULL && tree_conds(new) > 0) { tree_t c2 = tree_new(T_COND_STMT); tree_set_loc(c2, tree_loc(c)); const int nstmts = tree_stmts(c); for (int i = 0; i < nstmts; i++) tree_add_stmt(c2, tree_stmt(c, i)); tree_add_cond(new, c2); break; } else if (tree_stmts(c) == 1 && drivers.count == 0) return tree_stmt(c, 0); else { tree_t b = tree_new(T_SEQUENCE); tree_set_loc(b, tree_loc(t)); if (tree_has_ident(t)) tree_set_ident(b, tree_ident(t)); const int nstmts = tree_stmts(c); for (int i = 0; i < nstmts; i++) tree_add_stmt(b, tree_stmt(c, i)); simp_make_dummy_drivers(b, &drivers); return b; } } else simp_find_drivers(c, &drivers); } if (drivers.count > 0) { tree_t b = tree_new(T_SEQUENCE); tree_set_loc(b, tree_loc(t)); if (tree_conds(new) > 0) tree_add_stmt(b, new); else if (tree_has_ident(new)) tree_set_ident(b, tree_ident(new)); simp_make_dummy_drivers(b, &drivers); return b; } else if (tree_conds(new) > 0) return new; else return NULL; } static tree_t simp_while(tree_t t) { bool value_b; if (folded_bool(tree_value(t), &value_b) && !value_b) { // Condition is false so loop never executes tree_list_t drivers = AINIT; if (!simp_find_drivers(t, &drivers)) { ACLEAR(drivers); return t; } if (drivers.count == 0) return NULL; tree_t seq = tree_new(T_SEQUENCE); tree_set_loc(seq, tree_loc(t)); if (tree_has_ident(t)) tree_set_ident(seq, tree_ident(t)); simp_make_dummy_drivers(seq, &drivers); return seq; } return t; } static void simp_guard_target_cb(tree_t t, void *ctx) { bool *guarded_target = ctx; if (is_guarded_signal(tree_ref(t))) *guarded_target = true; } static tree_t simp_guard(tree_t t, tree_t s0, tree_t target) { // See LRM 93 section 9.3 tree_t g_if = tree_new(T_IF); tree_set_ident(g_if, ident_new("guard_if")); tree_set_loc(g_if, tree_loc(t)); tree_t c0 = tree_new(T_COND_STMT); tree_add_cond(g_if, c0); tree_t guard = tree_guard(t); assert(tree_kind(guard) == T_GUARD); tree_t guard_ref = make_ref(tree_ref(guard)); tree_set_value(c0, guard_ref); tree_add_stmt(c0, s0); bool guarded_target = false; tree_visit_only(target, simp_guard_target_cb, &guarded_target, T_REF); if (guarded_target) { tree_t d = tree_new(T_SIGNAL_ASSIGN); tree_set_loc(d, tree_loc(t)); tree_set_target(d, target); tree_t w0 = tree_new(T_WAVEFORM); tree_set_loc(w0, tree_loc(t)); if (tree_has_spec(guard)) { tree_t spec = tree_spec(guard); assert(tree_kind(spec) == T_DISCONNECT); tree_set_delay(w0, tree_delay(spec)); } tree_add_waveform(d, w0); tree_t c1 = tree_new(T_COND_STMT); tree_add_cond(g_if, c1); tree_add_stmt(c1, d); } return g_if; } static tree_t simp_concurrent(tree_t t) { if (tree_stmts(t) == 0) return NULL; // Body was optimised out // Replace concurrent statements with a process tree_t p = tree_new(T_PROCESS); tree_set_ident(p, tree_ident(t)); tree_set_loc(p, tree_loc(t)); tree_set_flag(p, tree_flags(t)); tree_t s0 = tree_stmt(t, 0); tree_t w = tree_new(T_WAIT); if (tree_kind(s0) == T_PCALL) { // Concurrent procedure calls may have internal waits tree_t decl = tree_ref(s0); if (tree_flags(decl) & TREE_F_NEVER_WAITS) tree_set_flag(w, TREE_F_STATIC_WAIT); } else tree_set_flag(w, TREE_F_STATIC_WAIT); tree_add_stmt(p, s0); build_wait(s0, simp_build_wait_cb, w); tree_add_stmt(p, w); return p; } static tree_t simp_cond_assign(tree_t t) { const int nconds = tree_conds(t); tree_t c0 = tree_cond(t, 0), s0; if (nconds == 1 && !tree_has_value(c0)) s0 = tree_stmt(c0, 0); else { s0 = tree_new(T_IF); tree_set_loc(s0, tree_loc(t)); for (int i = 0; i < nconds; i++) tree_add_cond(s0, tree_cond(t, i)); } if (tree_has_guard(t)) return simp_guard(t, s0, tree_target(t)); return s0; } static tree_t simp_select(tree_t t) { // Replace a select statement with a case statement const tree_kind_t kind = tree_kind(t) == T_MATCH_SELECT ? T_MATCH_CASE : T_CASE; tree_t c = tree_new(kind); tree_set_loc(c, tree_loc(t)); tree_set_value(c, tree_value(t)); const int nstmts = tree_stmts(t); for (int i = 0; i < nstmts; i++) tree_add_stmt(c, tree_stmt(t, i)); if (tree_has_guard(t)) { tree_t s0 = tree_stmt(tree_stmt(t, 0), 0); assert(tree_kind(s0) == T_SIGNAL_ASSIGN); return simp_guard(t, c, tree_target(s0)); } return c; } static tree_t simp_context_ref(tree_t t, simp_ctx_t *ctx) { tree_t decl = tree_ref(t); const int nctx = tree_contexts(decl); for (int i = 2; i < nctx; i++) tree_add_context(ctx->top, tree_context(decl, i)); return NULL; } static tree_t simp_assert(tree_t t) { bool value_b; if (tree_has_value(t) && folded_bool(tree_value(t), &value_b) && value_b) { // Assertion always passes return NULL; } return t; } static tree_t simp_if_generate(tree_t t) { const int nconds = tree_conds(t); bool any_folded = false, trivial_true = false; for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(t, i); bool bval; if (!tree_has_value(c)) continue; else if (folded_bool(tree_value(c), &bval)) { any_folded = true; trivial_true |= (i == 0 && bval); } } if (!any_folded) return t; tree_t new = NULL; if (!trivial_true) { new = tree_new(T_IF_GENERATE); tree_set_loc(new, tree_loc(t)); tree_set_ident(new, tree_ident(t)); } for (int i = 0; i < nconds; i++) { tree_t c = tree_cond(t, i); bool bval = true; if (tree_has_value(c) && !folded_bool(tree_value(c), &bval)) { tree_add_cond(new, c); continue; } else if (bval) { if (new != NULL && tree_conds(new) > 0) { tree_set_value(c, NULL); tree_add_cond(new, c); break; } else { tree_t b = tree_new(T_BLOCK); tree_set_loc(b, tree_loc(t)); if (tree_has_ident(c)) tree_set_ident(b, tree_ident(c)); else if (tree_has_ident(t)) tree_set_ident(b, tree_ident(t)); const int ndecls = tree_decls(c); for (int i = 0; i < ndecls; i++) tree_add_decl(b, tree_decl(c, i)); const int nstmts = tree_stmts(c); for (int i = 0; i < nstmts; i++) tree_add_stmt(b, tree_stmt(c, i)); return b; } } } return tree_conds(new) > 0 ? new : NULL; } static tree_t simp_signal_assign(tree_t t) { tree_t target = tree_target(t); if (tree_kind(target) == T_OPEN) return NULL; // Delete it return t; } static tree_t simp_var_assign(tree_t t) { tree_t value = tree_value(t); if (tree_kind(value) == T_COND_VALUE) { // Replace with an if statement tree_t new = tree_new(T_IF); tree_set_loc(new, tree_loc(t)); const int nconds = tree_conds(value); for (int i = 0; i < nconds; i++) { tree_t e = tree_cond(value, i); tree_t c = tree_new(T_COND_STMT); tree_set_loc(c, tree_loc(e)); if (tree_has_value(e)) tree_set_value(c, tree_value(e)); else assert(i == nconds - 1); tree_t s = tree_new(T_VAR_ASSIGN); tree_set_loc(s, tree_loc(t)); tree_set_target(s, tree_target(t)); tree_set_value(s, tree_result(e)); tree_add_stmt(c, s); tree_add_cond(new, c); } return new; } return t; } static tree_t simp_return(tree_t t) { if (tree_has_value(t)) { tree_t value = tree_value(t); if (tree_kind(value) == T_COND_VALUE) { // Replace with an if statement tree_t new = tree_new(T_IF); tree_set_loc(new, tree_loc(t)); const int nconds = tree_conds(value); for (int i = 0; i < nconds; i++) { tree_t e = tree_cond(value, i); tree_t c = tree_new(T_COND_STMT); tree_set_loc(c, tree_loc(e)); if (tree_has_value(e)) tree_set_value(c, tree_value(e)); else assert(i == nconds - 1); tree_t s = tree_new(T_RETURN); tree_set_loc(s, tree_loc(tree_result(e))); tree_set_value(s, tree_result(e)); tree_set_type(s, tree_type(t)); tree_add_stmt(c, s); tree_add_cond(new, c); } return new; } } return t; } static tree_t simp_cond_return(tree_t t) { tree_t value = tree_value(t); bool folded; if (folded_bool(tree_value(t), &folded)) { if (folded) { tree_t new = tree_new(T_RETURN); tree_set_loc(new, tree_loc(t)); return new; } else return NULL; } // Replace with an if statement tree_t new = tree_new(T_IF); tree_set_loc(new, tree_loc(t)); tree_t c = tree_new(T_COND_STMT); tree_set_loc(c, tree_loc(t)); tree_set_value(c, value); tree_t s = tree_new(T_RETURN); tree_set_loc(s, tree_loc(t)); tree_add_stmt(c, s); tree_add_cond(new, c); return new; } static tree_t simp_literal(tree_t t) { switch (tree_subkind(t)) { case L_PHYSICAL: // Rewrite in terms of the base unit if (tree_has_ref(t)) { tree_t decl = tree_ref(t); int64_t base = assume_int(tree_value(decl)); type_t type = tree_type(t); const double dval = tree_dval(t); if (dval != 0) { const double result = round(dval * base); if (result < (double)INT64_MIN || result > (double)INT64_MAX) error_at(tree_loc(t), "physical literal %g %s exceeds " "range of type %s", dval, istr(tree_ident(decl)), type_pp(type)); else tree_set_ival(t, (int64_t)result); } else { int64_t ival = tree_ival(t), result; if (__builtin_mul_overflow(ival, base, &result)) error_at(tree_loc(t), "physical literal %"PRIi64" %s exceeds " "range of type %s", ival, istr(tree_ident(decl)), type_pp(type)); else tree_set_ival(t, result); } tree_set_ref(t, NULL); tree_set_ident(t, tree_ident(type_unit(type, 0))); } return t; default: return t; } } static tree_t simp_range(tree_t t) { if (tree_subkind(t) != RANGE_EXPR) return t; tree_t value = tree_value(t); assert(tree_kind(value) == T_ATTR_REF); const attr_kind_t attr = tree_subkind(value); assert(attr == ATTR_RANGE || attr == ATTR_REVERSE_RANGE); tree_t name = tree_name(value); type_t type = tree_type(name); if (!type_const_bounds(type)) return t; int dim = 0; if (tree_params(value) > 0) { int64_t ival; if (!folded_int(tree_value(tree_param(value, 0)), &ival)) return t; dim = ival - 1; } if (attr == ATTR_REVERSE_RANGE) { tree_t base_r = range_of(type, dim); const range_kind_t base_kind = tree_subkind(base_r); tree_t rev = tree_new(T_RANGE); tree_set_subkind(rev, base_kind ^ 1); tree_set_loc(rev, tree_loc(t)); tree_set_type(rev, tree_type(t)); tree_set_left(rev, tree_right(base_r)); tree_set_right(rev, tree_left(base_r)); return rev; } else return range_of(type, dim); } static tree_t simp_sequence(tree_t t) { if (tree_stmts(t) == 1 && tree_decls(t) == 0) return tree_stmt(t, 0); else return t; } static tree_t simp_cond_expr(tree_t t) { if (!tree_has_result(t)) return NULL; // "unaffected" expression is redundant else if (tree_has_value(t)) { bool value_b; if (folded_bool(tree_value(t), &value_b)) { if (value_b) { // Always true, remove the test tree_set_value(t, NULL); return t; } else { // Always false, delete the condition return NULL; } } } return t; } static tree_t simp_cond_value(tree_t t) { tree_t c0 = tree_cond(t, 0); if (!tree_has_value(c0)) { // Always evaluates to "else" condition return tree_result(c0); } return t; } static tree_t simp_aggregate(tree_t t) { type_t type = tree_type(t); if (type_is_array(type) && type_is_unconstrained(type)) { type_t sub = calculate_aggregate_subtype(t); if (sub != NULL) tree_set_type(t, sub); } return t; } static void simp_generic_map(tree_t t, tree_t unit) { switch (tree_kind(unit)) { case T_CONFIGURATION: case T_ARCH: unit = tree_primary(unit); break; default: break; } const int ngenmaps = tree_genmaps(t); const int ngenerics = tree_generics(unit); int last_pos = 0; for (; last_pos < ngenmaps; last_pos++) { if (tree_subkind(tree_genmap(t, last_pos)) != P_POS) break; } if (last_pos == ngenmaps && ngenmaps == ngenerics) return; const tree_kind_t kind = tree_kind(t); SCOPED_A(tree_t) values = AINIT; for (int i = last_pos; i < ngenerics; i++) { tree_t g = tree_generic(unit, i), value = NULL; for (int j = last_pos; j < ngenmaps; j++) { tree_t mj = tree_genmap(t, j); if (tree_subkind(mj) == P_POS) { // This was added by the parser or checker if (tree_pos(mj) == i) value = tree_value(mj); continue; } tree_t name = tree_name(mj); tree_t ref = name_to_ref(name); if (ref == NULL || tree_ref(ref) != g) continue; switch (tree_kind(name)) { case T_REF: assert(value == NULL); value = tree_value(mj); break; case T_ARRAY_REF: case T_RECORD_REF: { tree_t a = tree_new(T_ASSOC); tree_set_loc(a, tree_loc(mj)); tree_set_subkind(a, A_NAMED); tree_set_value(a, tree_value(mj)); if (tree_kind(name) == T_ARRAY_REF) tree_set_name(a, tree_value(tree_param(name, 0))); else tree_set_name(a, make_ref(tree_ref(name))); if (value == NULL) { value = tree_new(T_AGGREGATE); tree_set_loc(value, tree_loc(mj)); tree_set_type(value, tree_type(g)); } else assert(tree_kind(value) == T_AGGREGATE); tree_add_assoc(value, a); } break; default: fatal_at(tree_loc(name), "sorry, this form of generic map is not " "yet supported"); break; } } if (value == NULL && kind != T_BINDING && tree_has_value(g)) { // If the default value is a non-literal expression we may get // the wrong result during elaboration of a recursive instantiation tree_t def = tree_value(g); if (is_literal(def)) value = def; } if (value == NULL) { value = tree_new(T_OPEN); tree_set_loc(value, tree_loc(t)); tree_set_type(value, tree_type(g)); } APUSH(values, value); } for (int i = 0; i < values.count; i++) { tree_t m; if (last_pos + i < ngenmaps) m = tree_genmap(t, last_pos + i); else { m = tree_new(T_PARAM); tree_add_genmap(t, m); } tree_set_subkind(m, P_POS); tree_set_pos(m, last_pos + i); tree_set_value(m, values.items[i]); tree_set_loc(m, tree_loc(values.items[i])); } if (last_pos + values.count < ngenmaps) tree_trim_genmaps(t, last_pos + values.count); } static tree_t simp_tree_local(tree_t t, void *_ctx) { simp_ctx_t *ctx = _ctx; switch (tree_kind(t)) { case T_PROCESS: return simp_process(t); case T_ATTR_REF: return simp_attr_ref(t, ctx); case T_FCALL: case T_PROT_FCALL: return simp_fcall_local(t, ctx); case T_PCALL: case T_PROT_PCALL: return simp_pcall(t, ctx); case T_REF: return simp_ref(t, ctx); case T_IF: return simp_if(t); case T_CASE: return simp_case(t); case T_CASE_GENERATE: return simp_case_generate(t); case T_WHILE: return simp_while(t); case T_CONCURRENT: return simp_concurrent(t); case T_COND_ASSIGN: return simp_cond_assign(t); case T_SELECT: case T_MATCH_SELECT: return simp_select(t); case T_WAIT: return simp_wait(t); case T_NULL: return NULL; // Delete it case T_RECORD_REF: return simp_record_ref(t, ctx); case T_CONTEXT_REF: return simp_context_ref(t, ctx); case T_ASSERT: return simp_assert(t); case T_IF_GENERATE: return simp_if_generate(t); case T_SIGNAL_ASSIGN: return simp_signal_assign(t); case T_VAR_ASSIGN: return simp_var_assign(t); case T_RETURN: return simp_return(t); case T_COND_RETURN: return simp_cond_return(t); case T_TYPE_CONV: return simp_type_conv(t, ctx); case T_LITERAL: return simp_literal(t); case T_RANGE: return simp_range(t); case T_SEQUENCE: return simp_sequence(t); case T_PACKAGE_MAP: if (tree_subkind(t) != PACKAGE_MAP_MATCHING) return t; // Fall-through case T_INSTANCE: case T_BINDING: simp_generic_map(t, tree_ref(t)); return t; case T_BLOCK: simp_generic_map(t, t); return t; case T_COND_EXPR: return simp_cond_expr(t); case T_COND_VALUE: return simp_cond_value(t); case T_PACK_INST: case T_FUNC_INST: case T_PROC_INST: simp_generic_map(t, t); return t; case T_PACKAGE: if (!is_uninstantiated_package(t)) simp_generic_map(t, t); return t; case T_AGGREGATE: return simp_aggregate(t); default: return t; } } void simplify_local(tree_t top, jit_t *jit, unit_registry_t *ur, mir_context_t *mc) { simp_ctx_t ctx = { .top = top, .jit = jit, .registry = ur, .mir = mc, }; tree_rewrite(top, NULL, simp_tree_local, NULL, &ctx); } static tree_t simp_tree_global(tree_t t, void *_ctx) { simp_ctx_t *ctx = _ctx; switch (tree_kind(t)) { case T_PROCESS: return simp_process(t); case T_ATTR_REF: return simp_attr_ref(t, ctx); case T_FCALL: case T_PROT_FCALL: return simp_fcall_global(t, ctx); case T_REF: return simp_ref(t, ctx); case T_IF: return simp_if(t); case T_CASE: return simp_case(t); case T_CASE_GENERATE: return simp_case_generate(t); case T_WHILE: return simp_while(t); case T_RECORD_REF: return simp_record_ref(t, ctx); case T_ASSERT: return simp_assert(t); case T_IF_GENERATE: return simp_if_generate(t); case T_TYPE_CONV: return simp_type_conv(t, ctx); case T_RANGE: return simp_range(t); case T_SEQUENCE: return simp_sequence(t); case T_COND_EXPR: return simp_cond_expr(t); case T_COND_VALUE: return simp_cond_value(t); case T_AGGREGATE: return simp_aggregate(t); // TODO: remove this case T_CONCURRENT: case T_COND_ASSIGN: case T_SELECT: case T_MATCH_SELECT: case T_NULL: case T_COND_RETURN: case T_CONTEXT_REF: should_not_reach_here(); // Should already have been rewritten default: return t; } } void simplify_global(tree_t top, hash_t *generics, jit_t *jit, unit_registry_t *ur, mir_context_t *mc) { simp_ctx_t ctx = { .top = top, .jit = jit, .registry = ur, .mir = mc, .generics = generics, }; tree_rewrite(top, NULL, simp_tree_global, NULL, &ctx); } nvc-r1.17.1/src/symbols.txt000066400000000000000000000050571504111170000155660ustar00rootroot00000000000000# # List of symbols exported from the nvc binary # { # Exported from src/rt/standard.c _std_standard_now; _std_to_hstring_bit_vec; _std_to_ostring_bit_vec; _std_to_string_real; _std_to_string_real_digits; _std_to_string_real_format; _std_to_string_time; # Exported from src/rt/stdenv.c _std_env_add_trec_real; _std_env_createdir; _std_env_deletedir; _std_env_deletefile; _std_env_diff_trec; _std_env_dir_open; _std_env_epoch; _std_env_epoch_trec; _std_env_file_line; _std_env_file_name; _std_env_file_path; _std_env_get_call_path; _std_env_get_workingdir; _std_env_getenv; _std_env_gmtime; _std_env_gmtime_trec; _std_env_itemexists; _std_env_itemisdir; _std_env_itemisfile; _std_env_localtime; _std_env_localtime_trec; _std_env_seconds_to_time; _std_env_set_workingdir; _std_env_stop; _std_env_tool_version; _std_env_vhdl_version; _std_env_get_vhdl_assert_count; _std_env_clear_vhdl_assert; _std_env_set_vhdl_assert_enable; _std_env_get_vhdl_assert_enable; # Exported from src/rt/assert.c _std_env_get_assert_format; _std_env_set_assert_format; _std_env_set_assert_format_valid; # Exported from src/rt/cover.c _nvc_create_cover_scope; _nvc_add_cover_item; _nvc_increment_cover_item; _nvc_set_cover_scope_name; # Exported from src/rt/simpkg.c _nvc_current_delta; _nvc_ieee_warnings; # Exported from src/rt/random.c _nvc_random_get_next; # Exported from src/rt/fileio.c __nvc_endfile; __nvc_file_canseek; __nvc_file_close; __nvc_file_mode; __nvc_file_position; __nvc_file_size; __nvc_file_state; __nvc_flush; __nvc_rewind; __nvc_seek; __nvc_truncate; # Exported from src/jit/jit-exits.c __nvc_do_exit; __nvc_get_object; __nvc_last_event; __nvc_mspace_alloc; __nvc_putpriv; __nvc_sched_waveform; __nvc_sched_process; __nvc_test_event; __nvc_pack; __nvc_unpack; _debug_dump; _debug_out; # Exported by VHPI vhpiFS; vhpiHR; vhpiMN; vhpiMS; vhpiNS; vhpiPS; vhpiS; vhpiUS; vhpi_assert; vhpi_check_error; vhpi_compare_handles; vhpi_control; vhpi_disable_cb; vhpi_enable_cb; vhpi_get; vhpi_get_cb_info; vhpi_get_foreignf_info; vhpi_get_next_time; vhpi_get_next_time; vhpi_get_phys; vhpi_get_real; vhpi_get_str; vhpi_get_time; vhpi_get_value; vhpi_handle; vhpi_handle_by_index; vhpi_handle_by_name; vhpi_iterator; vhpi_printf; vhpi_put_value; vhpi_register_cb; vhpi_register_foreignf; vhpi_release_handle; vhpi_remove_cb; vhpi_scan; vhpi_vprintf; # Unit test global_func; }; nvc-r1.17.1/src/thread.c000066400000000000000000001112711504111170000147440ustar00rootroot00000000000000// // Copyright (C) 2021-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "cpustate.h" #include "rt/mspace.h" #include "thread.h" #include #include #include #include #include #include #include #include #include #ifdef HAVE_PTHREAD #include #elif !defined __MINGW32__ #error missing pthread support #endif #ifdef __SANITIZE_THREAD__ #include #endif #if defined __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #elif defined __APPLE__ #define task_t __task_t #include #include #undef task_t #endif #define LOCK_SPINS 64 #define YIELD_SPINS 32 #define MIN_TAKE 8 #define PARKING_BAYS 64 #define SUSPEND_TIMEOUT 1 #if !defined __MINGW32__ && !defined __APPLE__ #define POSIX_SUSPEND 1 #define SIGSUSPEND SIGRTMIN #define SIGRESUME (SIGRTMIN + 1) #endif typedef struct { int64_t locks; int64_t spins; int64_t contended; int64_t parks; int64_t spurious; int64_t retries; } __attribute__((aligned(64))) lock_stats_t; STATIC_ASSERT(sizeof(lock_stats_t) == 64) #ifdef DEBUG #define LOCK_EVENT(what, n) do { \ if (likely(my_thread != NULL)) \ lock_stats[my_thread->id].what += (n); \ } while (0) #define WORKQ_EVENT(what, n) do { \ if (likely(my_thread != NULL)) \ workq_stats[my_thread->id].what += (n); \ } while (0) #else #define LOCK_EVENT(what, n) (void)(n) #define WORKQ_EVENT(what, n) (void)(n) #endif #ifdef __SANITIZE_THREAD__ #define TSAN_PRE_LOCK(addr) \ __tsan_mutex_pre_lock(addr, __tsan_mutex_linker_init); #define TSAN_POST_LOCK(addr) \ __tsan_mutex_post_lock(addr, __tsan_mutex_linker_init, 0); #define TSAN_PRE_UNLOCK(addr) \ __tsan_mutex_pre_unlock(addr, __tsan_mutex_linker_init); #define TSAN_POST_UNLOCK(addr) \ __tsan_mutex_post_unlock(addr, __tsan_mutex_linker_init); #else #define TSAN_PRE_LOCK(addr) #define TSAN_POST_LOCK(addr) #define TSAN_PRE_UNLOCK(addr) #define TSAN_POST_UNLOCK(addr) #endif #ifndef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP #define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP PTHREAD_MUTEX_INITIALIZER #endif #define PTHREAD_CHECK(op, ...) do { \ if (unlikely(op(__VA_ARGS__) != 0)) \ fatal_errno(#op); \ } while (0) // Lock implementation based on WTF::Lock in WebKit // https://webkit.org/blog/6161/locking-in-webkit/ typedef enum { IS_LOCKED = (1 << 0), HAS_PARKED = (1 << 1) } lock_bits_t; typedef struct { #ifdef __MINGW32__ CRITICAL_SECTION mutex; CONDITION_VARIABLE cond; #else pthread_mutex_t mutex; pthread_cond_t cond; #endif int parked; } __attribute__((aligned(64))) parking_bay_t; typedef bool (*park_fn_t)(parking_bay_t *, void *); typedef void (*unpark_fn_t)(parking_bay_t *, void *); typedef struct { task_fn_t fn; void *context; void *arg; workq_t *workq; } task_t; // Work sealing task queue is based on: // Arora, N. S., Blumofe, R. D., and Plaxton, C. G. // Thread scheduling for multiprogrammed multiprocessors. // Theory of Computing Systems 34, 2 (2001), 115-144. typedef uint32_t abp_idx_t; typedef uint32_t abp_tag_t; typedef union { struct { abp_idx_t top; abp_tag_t tag; }; uint64_t bits; } abp_age_t; STATIC_ASSERT(sizeof(abp_age_t) <= 8); #define THREADQ_SIZE 256 typedef struct { task_t deque[THREADQ_SIZE]; abp_age_t age; abp_idx_t bot; } __attribute__((aligned(64))) threadq_t; typedef enum { IDLE, START } workq_state_t; typedef union { struct { uint32_t count; uint32_t epoch; }; uint64_t bits; } entryq_ptr_t; STATIC_ASSERT(sizeof(entryq_ptr_t) <= 8); typedef struct { task_t *tasks; unsigned queuesz; entryq_ptr_t wptr; entryq_ptr_t comp; } __attribute__((aligned(64))) entryq_t; STATIC_ASSERT(sizeof(entryq_t) == 64); struct _workq { void *context; workq_state_t state; unsigned epoch; unsigned maxthread; bool parallel; entryq_t entryqs[MAX_THREADS]; }; typedef struct { int64_t comp; int64_t steals; int64_t wakes; } __attribute__((aligned(64))) workq_stats_t; STATIC_ASSERT(sizeof(workq_stats_t) == 64); typedef enum { MAIN_THREAD, USER_THREAD, WORKER_THREAD, } thread_kind_t; struct _nvc_thread { unsigned id; thread_kind_t kind; unsigned spins; threadq_t queue; char *name; thread_fn_t fn; void *arg; int victim; uint32_t rngstate; #ifdef __MINGW32__ HANDLE handle; void *retval; #else pthread_t handle; #endif #ifdef __APPLE__ thread_port_t port; #endif }; typedef struct { nvc_lock_t lock; task_t *tasks; unsigned wptr; unsigned rptr; unsigned max; } globalq_t; typedef struct _barrier { unsigned count; unsigned reached; unsigned passed; } __attribute__((aligned(64))) barrier_t; static parking_bay_t parking_bays[PARKING_BAYS] = { #ifndef __MINGW32__ [0 ... PARKING_BAYS - 1] = { PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP, PTHREAD_COND_INITIALIZER } #endif }; static nvc_thread_t *threads[MAX_THREADS]; static unsigned max_workers = 0; static int running_threads = 0; static unsigned max_thread_id = 0; static bool should_stop = false; static globalq_t globalq __attribute__((aligned(64))); static int async_pending __attribute__((aligned(64))) = 0; static nvc_lock_t stop_lock = 0; static stop_world_fn_t stop_callback = NULL; static void *stop_arg = NULL; #ifdef __MINGW32__ static CONDITION_VARIABLE wake_workers = CONDITION_VARIABLE_INIT; static CRITICAL_SECTION wakelock; #else static pthread_cond_t wake_workers = PTHREAD_COND_INITIALIZER; static pthread_mutex_t wakelock = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP; #endif #ifdef POSIX_SUSPEND static sem_t stop_sem; #endif #ifdef DEBUG static lock_stats_t lock_stats[MAX_THREADS]; static workq_stats_t workq_stats[MAX_THREADS]; #endif static __thread nvc_thread_t *my_thread = NULL; static parking_bay_t *parking_bay_for(void *cookie); #ifdef POSIX_SUSPEND static void suspend_handler(int sig, siginfo_t *info, void *context); #endif #ifdef DEBUG static void print_lock_stats(void) { lock_stats_t s = {}; workq_stats_t t = {}; for (int i = 0; i < MAX_THREADS; i++) { s.locks += relaxed_load(&(lock_stats[i].locks)); s.contended += relaxed_load(&(lock_stats[i].contended)); s.parks += relaxed_load(&(lock_stats[i].parks)); s.spins += relaxed_load(&(lock_stats[i].spins)); s.spurious += relaxed_load(&(lock_stats[i].spurious)); s.retries += relaxed_load(&(lock_stats[i].retries)); t.comp += relaxed_load(&(workq_stats[i].comp)); t.steals += relaxed_load(&(workq_stats[i].steals)); t.wakes += relaxed_load(&(workq_stats[i].wakes)); } printf("\nLock statistics:\n"); printf("\tTotal locks : %"PRIi64"\n", s.locks); printf("\tContended : %"PRIi64" (%.1f%%)\n", s.contended, 100.0 * ((double)s.contended / (double)s.locks)); printf("\tParked : %"PRIi64" (%.1f%%)\n", s.parks, 100.0 * ((double)s.parks / (double)s.locks)); printf("\tAverage spins : %.1f\n", (double)s.spins / (double)s.retries); printf("\tSpurious wakeups : %"PRIi64"\n", s.spurious); printf("\nWork queue statistics:\n"); printf("\tCompleted tasks : %"PRIi64"\n", t.comp); printf("\tSteals : %"PRIi64"\n", t.steals); printf("\tWakeups : %"PRIi64"\n", t.wakes); } #endif #ifdef __MINGW32__ static inline void platform_mutex_lock(LPCRITICAL_SECTION lpcs) { EnterCriticalSection(lpcs); } static inline void platform_mutex_unlock(LPCRITICAL_SECTION lpcs) { LeaveCriticalSection(lpcs); } static inline void platform_cond_broadcast(PCONDITION_VARIABLE pcv) { WakeAllConditionVariable(pcv); } static inline void platform_cond_wait(PCONDITION_VARIABLE pcv, LPCRITICAL_SECTION lpcs) { SleepConditionVariableCS(pcv, lpcs, INFINITE); } #else static inline void platform_mutex_lock(pthread_mutex_t *mtx) { PTHREAD_CHECK(pthread_mutex_lock, mtx); } static inline void platform_mutex_unlock(pthread_mutex_t *mtx) { PTHREAD_CHECK(pthread_mutex_unlock, mtx); } static inline void platform_cond_broadcast(pthread_cond_t *cond) { PTHREAD_CHECK(pthread_cond_broadcast, cond); } static inline void platform_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mtx) { PTHREAD_CHECK(pthread_cond_wait, cond, mtx); } #endif static void join_worker_threads(void) { SCOPED_A(nvc_thread_t *) join_list = AINIT; for (int i = 1; i < MAX_THREADS; i++) { nvc_thread_t *t = atomic_load(&threads[i]); if (t != NULL) APUSH(join_list, t); } // Lock the wake mutex here to avoid races with workers sleeping platform_mutex_lock(&wakelock); { atomic_store(&should_stop, true); platform_cond_broadcast(&wake_workers); } platform_mutex_unlock(&wakelock); for (int i = 0; i < join_list.count; i++) { nvc_thread_t *t = join_list.items[i]; switch (relaxed_load(&t->kind)) { case WORKER_THREAD: thread_join(t); continue; // Freed thread struct case USER_THREAD: case MAIN_THREAD: fatal_trace("leaked a user thread: %s", t->name); } } assert(atomic_load(&running_threads) == 1); #ifdef DEBUG for (int i = 0; i < PARKING_BAYS; i++) assert(parking_bays[i].parked == 0); #endif } static nvc_thread_t *thread_new(thread_fn_t fn, void *arg, thread_kind_t kind, char *name) { nvc_thread_t *thread = xcalloc(sizeof(nvc_thread_t)); thread->name = name; thread->fn = fn; thread->arg = arg; thread->kind = kind; thread->rngstate = rand(); atomic_store(&thread->queue.age.bits, 0); atomic_store(&thread->queue.bot, 0); int id = 0; for (; id < MAX_THREADS; id++) { if (relaxed_load(&(threads[id])) != NULL) continue; else if (atomic_cas(&(threads[id]), NULL, thread)) break; } if (id == MAX_THREADS) fatal_trace("cannot create more than %d threads", MAX_THREADS); thread->id = id; unsigned max = relaxed_load(&max_thread_id); while (max < id) { if (__atomic_cas(&max_thread_id, &max, id)) break; } atomic_add(&running_threads, 1); return thread; } #ifdef POSIX_SUSPEND static void unmask_fatal_signals(sigset_t *mask) { sigdelset(mask, SIGQUIT); sigdelset(mask, SIGABRT); sigdelset(mask, SIGTERM); } #endif #ifdef __APPLE__ static void reset_mach_ports(void) { for (int i = 0; i < MAX_THREADS; i++) { nvc_thread_t *t = atomic_load(&(threads[i])); if (t == NULL) continue; // Mach ports are not valid after fork t->port = pthread_mach_thread_np(t->handle); } } #endif void thread_init(void) { assert(my_thread == NULL); my_thread = thread_new(NULL, NULL, MAIN_THREAD, xstrdup("main thread")); #ifdef __MINGW32__ my_thread->handle = GetCurrentThread(); #else my_thread->handle = pthread_self(); #endif #ifdef __APPLE__ my_thread->port = pthread_mach_thread_np(my_thread->handle); pthread_atfork(NULL, NULL, reset_mach_ports); #endif #ifdef __MINGW32__ InitializeCriticalSectionAndSpinCount(&wakelock, LOCK_SPINS); InitializeConditionVariable(&wake_workers); for (int i = 0; i < PARKING_BAYS; i++) { parking_bay_t *bay = &(parking_bays[i]); InitializeCriticalSectionAndSpinCount(&(bay->mutex), LOCK_SPINS); InitializeConditionVariable(&(bay->cond)); } #endif assert(my_thread->id == 0); const char *max_env = getenv("NVC_MAX_THREADS"); if (max_env != NULL) max_workers = MAX(1, MIN(atoi(max_env), MAX_THREADS)); else max_workers = DEFAULT_THREADS; const int num_cpus = nvc_nprocs(); max_workers = MIN(num_cpus, max_workers); const char *jobs_env = getenv("NVC_CONCURRENT_JOBS"); if (jobs_env != NULL) { const int num_jobs = MAX(1, atoi(jobs_env)); const int limit = (int)round((double)num_cpus / (double)num_jobs); max_workers = MAX(1, MIN(max_workers, limit)); } assert(max_workers > 0); #ifdef DEBUG if (getenv("NVC_THREAD_VERBOSE") != NULL) atexit(print_lock_stats); #endif atexit(join_worker_threads); #ifdef POSIX_SUSPEND sem_init(&stop_sem, 0, 0); struct sigaction sa = { .sa_sigaction = suspend_handler, .sa_flags = SA_RESTART | SA_SIGINFO }; sigfillset(&sa.sa_mask); unmask_fatal_signals(&sa.sa_mask); sigaction(SIGSUSPEND, &sa, NULL); sigaction(SIGRESUME, &sa, NULL); sigset_t mask; PTHREAD_CHECK(pthread_sigmask, SIG_SETMASK, NULL, &mask); sigdelset(&mask, SIGSUSPEND); sigaddset(&mask, SIGRESUME); PTHREAD_CHECK(pthread_sigmask, SIG_SETMASK, &mask, NULL); #endif } int thread_id(void) { assert(my_thread != NULL); return my_thread->id; } bool thread_attached(void) { return my_thread != NULL; } void thread_sleep(int usec) { usleep(usec); } static void *thread_wrapper(void *arg) { assert(my_thread == NULL); my_thread = arg; void *result = (*my_thread->fn)(my_thread->arg); // Avoid races with stop_world SCOPED_LOCK(stop_lock); assert(threads[my_thread->id] == my_thread); atomic_store(&(threads[my_thread->id]), NULL); atomic_add(&running_threads, -1); return result; } #ifdef __MINGW32__ static DWORD win32_thread_wrapper(LPVOID param) { void *ret = thread_wrapper(param); atomic_store(&(my_thread->retval), ret); return 0; } #endif static void thread_start(nvc_thread_t *thread) { assert_lock_held(&stop_lock); #ifdef __MINGW32__ if ((thread->handle = CreateThread(NULL, 0, win32_thread_wrapper, thread, 0, NULL)) == NULL) fatal_errno("CreateThread"); #else PTHREAD_CHECK(pthread_create, &(thread->handle), NULL, thread_wrapper, thread); #endif #ifdef __APPLE__ thread->port = pthread_mach_thread_np(thread->handle); #endif } nvc_thread_t *thread_create(thread_fn_t fn, void *arg, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *name = xvasprintf(fmt, ap); va_end(ap); // Avoid races with stop_world SCOPED_LOCK(stop_lock); nvc_thread_t *thread = thread_new(fn, arg, USER_THREAD, name); thread_start(thread); return thread; } void *thread_join(nvc_thread_t *thread) { if (thread == my_thread || thread->kind == MAIN_THREAD) fatal_trace("cannot join self or main thread"); void *retval = NULL; #ifdef __MINGW32__ if (WaitForSingleObject(thread->handle, INFINITE) == WAIT_FAILED) fatal_errno("WaitForSingleObject failed for thread %s", thread->name); retval = atomic_load(&(thread->retval)); #else PTHREAD_CHECK(pthread_join, thread->handle, &retval); #endif async_free(thread->name); async_free(thread); return retval; } nvc_thread_t *get_thread(int id) { assert(id >= 0 && id < MAX_THREADS); return atomic_load(&threads[id]); } static inline parking_bay_t *parking_bay_for(void *cookie) { return &(parking_bays[mix_bits_64(cookie) % PARKING_BAYS]); } static void thread_park(void *cookie, park_fn_t fn) { parking_bay_t *bay = parking_bay_for(cookie); platform_mutex_lock(&(bay->mutex)); { if ((*fn)(bay, cookie)) { bay->parked++; platform_cond_wait(&(bay->cond), &(bay->mutex)); assert(bay->parked > 0); bay->parked--; } } platform_mutex_unlock(&(bay->mutex)); } static void thread_unpark(void *cookie, unpark_fn_t fn) { parking_bay_t *bay = parking_bay_for(cookie); if (fn != NULL) { platform_mutex_lock(&(bay->mutex)); { (*fn)(bay, cookie); } platform_mutex_unlock(&(bay->mutex)); } // Do not use pthread_cond_signal here as multiple threads parked in // this bay may be waiting on different cookies platform_cond_broadcast(&(bay->cond)); } void spin_wait(void) { #if defined ARCH_X86_64 __asm__ volatile ("pause"); #elif defined ARCH_ARM64 // YIELD is a no-op on most AArch64 cores so also do an ISB to stall // the pipeline for a bit __asm__ volatile ("yield; isb"); #endif } static bool lock_park_cb(parking_bay_t *bay, void *cookie) { nvc_lock_t *lock = cookie; // This is called with the park mutex held: check the lock is still // owned by someone and the park bit is still set return relaxed_load(lock) == (IS_LOCKED | HAS_PARKED); } static void lock_unpark_cb(parking_bay_t *bay, void *cookie) { nvc_lock_t *lock = cookie; assert(relaxed_load(lock) == (IS_LOCKED | HAS_PARKED)); // Unlock must have release semantics atomic_store(lock, (bay->parked > 0 ? HAS_PARKED : 0)); } void nvc_lock(nvc_lock_t *lock) { LOCK_EVENT(locks, 1); TSAN_PRE_LOCK(lock); int8_t state = 0; if (likely(__atomic_cas(lock, &state, state | IS_LOCKED))) goto locked; // Fast path: acquired the lock without contention LOCK_EVENT(contended, 1); for (;;) { LOCK_EVENT(retries, 1); // Spin a few times waiting for the owner to release the lock // before parking int spins = 0; for (; (state & IS_LOCKED) && spins < LOCK_SPINS; spins++, state = relaxed_load(lock)) spin_wait(); if (state & IS_LOCKED) { // Ignore failures here as we will check the lock state again // in the callback with the park mutex held atomic_cas(lock, IS_LOCKED, IS_LOCKED | HAS_PARKED); LOCK_EVENT(parks, 1); thread_park(lock, lock_park_cb); if ((state = relaxed_load(lock)) & IS_LOCKED) { // Someone else grabbed the lock before our thread was unparked LOCK_EVENT(spurious, 1); continue; } } else LOCK_EVENT(spins, spins); assert(!(state & IS_LOCKED)); // If we get here then we've seen the lock in an unowned state: // attempt to grab it with a CAS if (__atomic_cas(lock, &state, state | IS_LOCKED)) goto locked; } locked: TSAN_POST_LOCK(lock); } void nvc_unlock(nvc_lock_t *lock) { TSAN_PRE_UNLOCK(lock); // Fast path: unlock assuming no parked waiters if (likely(atomic_cas(lock, IS_LOCKED, 0))) goto unlocked; // If we get here then we must own the lock with at least one parked // waiting thread assert(relaxed_load(lock) == (IS_LOCKED | HAS_PARKED)); // Lock released in callback thread_unpark(lock, lock_unpark_cb); unlocked: TSAN_POST_UNLOCK(lock); } #ifdef DEBUG void assert_lock_held(nvc_lock_t *lock) { int8_t state = relaxed_load(lock); if (unlikely(!(state & IS_LOCKED))) fatal_trace("expected lock at %p to be held", lock); } #endif void __scoped_unlock(nvc_lock_t **plock) { nvc_unlock(*plock); } static void push_bot(threadq_t *tq, const task_t *tasks, size_t count) { const abp_idx_t bot = relaxed_load(&tq->bot); assert(bot + count <= THREADQ_SIZE); memcpy(tq->deque + bot, tasks, count * sizeof(task_t)); store_release(&tq->bot, bot + count); } static bool pop_bot(threadq_t *tq, task_t *task) { const abp_idx_t old_bot = relaxed_load(&tq->bot); if (old_bot == 0) return false; const abp_idx_t new_bot = old_bot - 1; atomic_store(&tq->bot, new_bot); *task = tq->deque[new_bot]; const abp_age_t old_age = { .bits = atomic_load(&tq->age.bits) }; if (new_bot > old_age.top) return true; atomic_store(&tq->bot, 0); const abp_age_t new_age = { .top = 0, .tag = old_age.tag + 1 }; if (new_bot == old_age.top) { if (atomic_cas(&tq->age.bits, old_age.bits, new_age.bits)) return true; } atomic_store(&tq->age.bits, new_age.bits); return false; } __attribute__((no_sanitize("thread"))) static bool pop_top(threadq_t *tq, task_t *task) { const abp_age_t old_age = { .bits = atomic_load(&tq->age.bits) }; const abp_idx_t bot = atomic_load(&tq->bot); if (bot <= old_age.top) return false; // This triggers a TSAN false-positive: we will never read from *task // if the CAS fails below, so it's safe to ignore *task = tq->deque[old_age.top]; const abp_age_t new_age = { .tag = old_age.tag, .top = old_age.top + 1 }; return atomic_cas(&tq->age.bits, old_age.bits, new_age.bits); } static void globalq_put(globalq_t *gq, const task_t *tasks, size_t count) { assert_lock_held(&gq->lock); if (gq->wptr == gq->rptr) gq->wptr = gq->rptr = 0; if (gq->wptr + count > gq->max) { gq->max = next_power_of_2(gq->wptr + count); gq->tasks = xrealloc_array(gq->tasks, gq->max, sizeof(task_t)); } memcpy(gq->tasks + gq->wptr, tasks, count * sizeof(task_t)); gq->wptr += count; } __attribute__((no_sanitize("thread"))) static bool globalq_unlocked_empty(globalq_t *gq) { return relaxed_load(&gq->wptr) == relaxed_load(&gq->rptr); } static size_t globalq_take(globalq_t *gq, threadq_t *tq) { if (globalq_unlocked_empty(gq)) return 0; const int nthreads = relaxed_load(&running_threads); SCOPED_LOCK(gq->lock); if (gq->wptr == gq->rptr) return 0; const int remain = gq->wptr - gq->rptr; const int share = gq->wptr / nthreads; const int take = MIN(remain, MAX(MIN_TAKE, MIN(THREADQ_SIZE, share))); const int from = gq->rptr; gq->rptr += take; push_bot(tq, gq->tasks + from, take); return take; } static void execute_task(task_t *task) { (*task->fn)(task->context, task->arg); if (task->workq != NULL) { entryq_t *eq = &(task->workq->entryqs[my_thread->id]); const entryq_ptr_t cur = { .bits = relaxed_load(&eq->comp.bits) }; const int epoch = atomic_load(&task->workq->epoch); const int count = cur.epoch == epoch ? cur.count : 0; const entryq_ptr_t next = { .count = count + 1, .epoch = epoch }; store_release(&eq->comp.bits, next.bits); } else atomic_add(&async_pending, -1); } static bool globalq_poll(globalq_t *gq, threadq_t *tq) { int ntasks; if ((ntasks = globalq_take(gq, tq))) { task_t task; int comp = 0; for (; pop_bot(tq, &task); comp++) execute_task(&task); WORKQ_EVENT(comp, comp); return true; } else return false; } workq_t *workq_new(void *context) { if (my_thread->kind != MAIN_THREAD) fatal_trace("work queues can only be created by the main thread"); workq_t *wq = xcalloc(sizeof(workq_t)); wq->state = IDLE; wq->context = context; wq->parallel = max_workers > 1; wq->epoch = 1; return wq; } void workq_not_thread_safe(workq_t *wq) { wq->parallel = false; } void workq_free(workq_t *wq) { if (my_thread->kind != MAIN_THREAD) fatal_trace("work queues can only be freed by the main thread"); assert(wq->state == IDLE); for (int i = 0; i < MAX_THREADS; i++) free(wq->entryqs[i].tasks); free(wq); } void workq_do(workq_t *wq, task_fn_t fn, void *arg) { assert(wq->state == IDLE); entryq_t *eq = &(wq->entryqs[my_thread->id]); const entryq_ptr_t cur = { .bits = relaxed_load(&eq->wptr.bits) }; const int epoch = atomic_load(&wq->epoch); const int wptr = cur.epoch == epoch ? cur.count : 0; if (wptr == eq->queuesz) { eq->queuesz = MAX(eq->queuesz * 2, 64); eq->tasks = xrealloc_array(eq->tasks, eq->queuesz, sizeof(task_t)); } eq->tasks[wptr] = (task_t){ fn, wq->context, arg, wq }; const entryq_ptr_t next = { .count = wptr + 1, .epoch = epoch }; store_release(&eq->wptr.bits, next.bits); unsigned maxthread = relaxed_load(&wq->maxthread); while (maxthread < my_thread->id) { if (__atomic_cas(&wq->maxthread, &maxthread, my_thread->id)) break; } } void workq_scan(workq_t *wq, scan_fn_t fn, void *arg) { const int maxthread = relaxed_load(&wq->maxthread); for (int i = 0; i <= maxthread; i++) { entryq_t *eq = &(wq->entryqs[my_thread->id]); const entryq_ptr_t wptr = { .bits = load_acquire(&eq->wptr.bits) }; for (int j = 0; j < wptr.count; j++) (*fn)(wq->context, eq->tasks[j].arg, arg); } } static int estimate_depth(threadq_t *tq) { const abp_age_t age = { .bits = relaxed_load(&tq->age.bits) }; const abp_idx_t bot = relaxed_load(&tq->bot); return bot <= age.top ? 0 : bot - age.top; } static threadq_t *get_thread_queue(int id) { assert(id < MAX_THREADS); nvc_thread_t *t = atomic_load(&(threads[id])); if (t == NULL) return NULL; return &(t->queue); } static uint32_t fast_rand(void) { uint32_t state = my_thread->rngstate; state ^= (state << 13); state ^= (state >> 17); state ^= (state << 5); return (my_thread->rngstate = state); } static threadq_t *find_victim(void) { threadq_t *last = get_thread_queue(my_thread->victim); if (last != NULL && estimate_depth(last) > 0) return last; const int maxthread = relaxed_load(&max_thread_id); const int start = fast_rand() % (maxthread + 1); int idx = start; do { if (idx != my_thread->id) { threadq_t *q = get_thread_queue(idx); if (q != NULL && estimate_depth(q) > 0) { my_thread->victim = idx; return q; } } } while ((idx = (idx + 1) % (maxthread + 1)) != start); return NULL; } static bool steal_task(void) { threadq_t *tq = find_victim(); if (tq == NULL) return false; task_t task; if (pop_top(tq, &task)) { WORKQ_EVENT(steals, 1); execute_task(&task); WORKQ_EVENT(comp, 1); return true; } return false; } static void progressive_backoff(void) { if (my_thread->spins++ < YIELD_SPINS) spin_wait(); else { #ifdef __MINGW32__ SwitchToThread(); #else sched_yield(); #endif my_thread->spins = 0; } } static void *worker_thread(void *arg) { mspace_stack_limit(MSPACE_CURRENT_FRAME); do { if (globalq_poll(&globalq, &(my_thread->queue)) || steal_task()) my_thread->spins = 0; // Did work else if (my_thread->spins++ < 2) spin_wait(); else { platform_mutex_lock(&wakelock); { if (!relaxed_load(&should_stop)) platform_cond_wait(&wake_workers, &wakelock); } platform_mutex_unlock(&wakelock); } } while (likely(!relaxed_load(&should_stop))); return NULL; } static void create_workers(int needed) { assert(my_thread->kind == MAIN_THREAD); if (relaxed_load(&should_stop)) return; while (relaxed_load(&running_threads) < MIN(max_workers, needed)) { static int counter = 0; char *name = xasprintf("worker thread %d", atomic_add(&counter, 1)); SCOPED_LOCK(stop_lock); // Avoid races with stop_world nvc_thread_t *thread = thread_new(worker_thread, NULL, WORKER_THREAD, name); thread_start(thread); } platform_cond_broadcast(&wake_workers); } void workq_start(workq_t *wq) { assert(my_thread->kind == MAIN_THREAD); const int epoch = relaxed_load(&wq->epoch); const int maxthread = relaxed_load(&wq->maxthread); assert(wq->state == IDLE); wq->state = START; int nserial = 0, nparallel = 0; for (int i = 0; i <= maxthread; i++) { entryq_t *eq = &wq->entryqs[i]; const entryq_ptr_t wptr = { .bits = load_acquire(&eq->wptr.bits) }; if (wptr.epoch == epoch) { // Only bump epoch if there are tasks to run if (nserial + nparallel == 0) atomic_add(&wq->epoch, 1); assert(wptr.count > 0); if (i == maxthread && nserial + nparallel == 0 && wptr.count == 1) { execute_task(&(eq->tasks[0])); // Only one task in total nserial++; } else if (wq->parallel) { if (nparallel == 0) nvc_lock(&globalq.lock); // Lazily acquire lock globalq_put(&globalq, eq->tasks, wptr.count); nparallel += wptr.count; } else { for (int j = 0; j < wptr.count; j++) execute_task(&(eq->tasks[j])); nserial += wptr.count; } } } if (wq->parallel && nparallel > 0) { nvc_unlock(&globalq.lock); create_workers(nparallel); } } static int workq_outstanding(workq_t *wq) { assert(wq->state == START); const int epoch = atomic_load(&wq->epoch); const int maxthread = relaxed_load(&max_thread_id); int pending = 0; for (int i = 0; i <= maxthread; i++) { entryq_t *eq = &(wq->entryqs[i]); const entryq_ptr_t wptr = { .bits = load_acquire(&eq->wptr.bits) }; if (wptr.epoch == epoch - 1) pending += wptr.count; const entryq_ptr_t comp = { .bits = load_acquire(&eq->comp.bits) }; if (comp.epoch == epoch) pending -= comp.count; } assert(pending >= 0); return pending; } static void workq_parallel_drain(workq_t *wq) { if (workq_outstanding(wq) > 0) { while (globalq_poll(&globalq, &(my_thread->queue))); while (steal_task()); while (workq_outstanding(wq) > 0) progressive_backoff(); } wq->state = IDLE; } void workq_drain(workq_t *wq) { if (my_thread->kind != MAIN_THREAD) fatal_trace("workq_drain can only be called from the main thread"); if (wq->parallel) workq_parallel_drain(wq); else { assert(wq->state == START); wq->state = IDLE; } } void async_do(task_fn_t fn, void *context, void *arg) { if (max_workers == 1) (*fn)(context, arg); // Single CPU else { const int npending = atomic_add(&async_pending, 1); create_workers(npending + 1 /* Do not count main thread */); task_t tasks[1] = { { fn, context, arg, NULL } }; SCOPED_LOCK(globalq.lock); globalq_put(&globalq, tasks, 1); } } void async_barrier(void) { while (atomic_load(&async_pending) > 0) { if (!globalq_poll(&globalq, &(my_thread->queue))) progressive_backoff(); } } void async_free(void *ptr) { if (ptr == NULL) return; // TODO: free when all threads in quiescent state } #ifdef POSIX_SUSPEND static void suspend_handler(int sig, siginfo_t *info, void *context) { if (info->si_pid != getpid()) return; // Not sent by us, ignore it else if (sig == SIGRESUME) return; const int olderrno = errno; if (my_thread != NULL) { struct cpu_state cpu; fill_cpu_state(&cpu, (ucontext_t *)context); stop_world_fn_t callback = atomic_load(&stop_callback); void *arg = atomic_load(&stop_arg); (*callback)(my_thread->id, &cpu, arg); } sem_post(&stop_sem); sigset_t mask; sigfillset(&mask); unmask_fatal_signals(&mask); sigdelset(&mask, SIGRESUME); sigsuspend(&mask); sem_post(&stop_sem); errno = olderrno; } #endif void stop_world(stop_world_fn_t callback, void *arg) { nvc_lock(&stop_lock); atomic_store(&stop_callback, callback); atomic_store(&stop_arg, arg); #ifdef __MINGW32__ const int maxthread = relaxed_load(&max_thread_id); for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; if (SuspendThread(thread->handle) != 0) fatal_errno("SuspendThread"); CONTEXT context; context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL; if (!GetThreadContext(thread->handle, &context)) fatal_errno("GetThreadContext"); struct cpu_state cpu; fill_cpu_state(&cpu, &context); (*callback)(thread->id, &cpu, arg); } #elif defined __APPLE__ const int maxthread = relaxed_load(&max_thread_id); for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; assert(thread->port != MACH_PORT_NULL); kern_return_t kern_result; do { kern_result = thread_suspend(thread->port); } while (kern_result == KERN_ABORTED); if (kern_result != KERN_SUCCESS) fatal_trace("failed to suspend thread %d (%d)", i, kern_result); #ifdef ARCH_ARM64 arm_thread_state64_t state; mach_msg_type_number_t count = ARM_THREAD_STATE64_COUNT; thread_state_flavor_t flavor = ARM_THREAD_STATE64; #else x86_thread_state64_t state; mach_msg_type_number_t count = x86_THREAD_STATE64_COUNT; thread_state_flavor_t flavor = x86_THREAD_STATE64; #endif kern_result = thread_get_state(thread->port, flavor, (natural_t *)&state, &count); if (kern_result != KERN_SUCCESS) fatal_trace("failed to get thread %d state (%d)", i, kern_result); // Fake a ucontext_t that we can pass to fill_cpu_state ucontext_t uc; typeof(*uc.uc_mcontext) mc; uc.uc_mcontext = &mc; mc.__ss = state; struct cpu_state cpu; fill_cpu_state(&cpu, &uc); (*callback)(thread->id, &cpu, arg); } #elif defined __SANITIZE_THREAD__ // https://github.com/google/sanitizers/issues/1179 fatal_trace("stop_world is not supported with tsan"); #else assert(sem_trywait(&stop_sem) == -1 && errno == EAGAIN); int signalled = 0; const int maxthread = relaxed_load(&max_thread_id); for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; PTHREAD_CHECK(pthread_kill, thread->handle, SIGSUSPEND); signalled++; } struct timespec ts; if (clock_gettime(CLOCK_REALTIME, &ts) != 0) fatal_errno("clock_gettime"); ts.tv_sec += SUSPEND_TIMEOUT; for (; signalled > 0; signalled--) { if (sem_timedwait(&stop_sem, &ts) != 0) fatal_trace("timeout waiting for %d threads to suspend", signalled); } assert(sem_trywait(&stop_sem) == -1 && errno == EAGAIN); #endif struct cpu_state cpu; capture_registers(&cpu); (*callback)(my_thread->id, &cpu, arg); } void start_world(void) { assert_lock_held(&stop_lock); const int maxthread = relaxed_load(&max_thread_id); #ifdef __MINGW32__ for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; if (ResumeThread(thread->handle) != 1) fatal_errno("ResumeThread"); } #elif defined __APPLE__ for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; kern_return_t kern_result; do { kern_result = thread_resume(thread->port); } while (kern_result == KERN_ABORTED); if (kern_result != KERN_SUCCESS) fatal_trace("failed to resume thread %d (%d)", i, kern_result); } #else assert(sem_trywait(&stop_sem) == -1 && errno == EAGAIN); int signalled = 0; for (int i = 0; i <= maxthread; i++) { nvc_thread_t *thread = atomic_load(&threads[i]); if (thread == NULL || thread == my_thread) continue; PTHREAD_CHECK(pthread_kill, thread->handle, SIGRESUME); signalled++; } struct timespec ts; if (clock_gettime(CLOCK_REALTIME, &ts) != 0) fatal_errno("clock_gettime"); ts.tv_sec += SUSPEND_TIMEOUT; for (; signalled > 0; signalled--) { if (sem_timedwait(&stop_sem, &ts) != 0) fatal_trace("timeout waiting for %d threads to resume", signalled); } assert(sem_trywait(&stop_sem) == -1 && errno == EAGAIN); #endif nvc_unlock(&stop_lock); } void thread_wx_mode(wx_mode_t mode) { #ifdef __APPLE__ pthread_jit_write_protect_np(mode == WX_EXECUTE); #else // Could use Intel memory protection keys here #endif } barrier_t *barrier_new(int count) { barrier_t *b = xcalloc(sizeof(barrier_t)); b->count = count; return b; } void barrier_free(barrier_t *b) { free(b); } void barrier_wait(barrier_t *b) { const int count = relaxed_load(&b->count); const int passed = relaxed_load(&b->passed); if (atomic_fetch_add(&b->reached, 1) == count - 1) { // Last thread to pass barrier relaxed_store(&b->reached, 0); store_release(&b->passed, passed + 1); } else { while (load_acquire(&b->passed) == passed) progressive_backoff(); } } nvc-r1.17.1/src/thread.h000066400000000000000000000075701504111170000147570ustar00rootroot00000000000000// // Copyright (C) 2021-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _THREAD_H #define _THREAD_H #include "util.h" #include #include #define atomic_add(p, n) __atomic_add_fetch((p), (n), __ATOMIC_SEQ_CST) #define atomic_fetch_add(p, n) __atomic_fetch_add((p), (n), __ATOMIC_SEQ_CST) #define atomic_load(p) __atomic_load_n((p), __ATOMIC_SEQ_CST) #define atomic_store(p, v) __atomic_store_n((p), (v), __ATOMIC_SEQ_CST) #define atomic_xchg(p, v) __atomic_exchange_n((p), (v), __ATOMIC_SEQ_CST) #define __atomic_cas(p, old, new) \ __atomic_compare_exchange_n((p), (old), (new), false, \ __ATOMIC_SEQ_CST, __ATOMIC_RELAXED) #define atomic_cas(p, old, new) ({ \ typeof(*p) __cmp = (old); \ __atomic_cas((p), &__cmp, (new)); \ }) #define relaxed_add(p, n) __atomic_add_fetch((p), (n), __ATOMIC_RELAXED) #define relaxed_fetch_add(p, n) __atomic_fetch_add((p), (n), __ATOMIC_RELAXED) #define relaxed_load(p) __atomic_load_n((p), __ATOMIC_RELAXED) #define relaxed_store(p, v) __atomic_store_n((p), (v), __ATOMIC_RELAXED) #define store_release(p, v) __atomic_store_n((p), (v), __ATOMIC_RELEASE) #define load_acquire(p) __atomic_load_n((p), __ATOMIC_ACQUIRE) #define full_barrier() __atomic_thread_fence(__ATOMIC_SEQ_CST) #define MAX_THREADS 64 #define DEFAULT_THREADS 8 STATIC_ASSERT(DEFAULT_THREADS <= MAX_THREADS); typedef struct _nvc_thread nvc_thread_t; void thread_init(void); int thread_id(void); bool thread_attached(void); void thread_sleep(int usec); typedef void *(*thread_fn_t)(void *); nvc_thread_t *thread_create(thread_fn_t fn, void *arg, const char *fmt, ...) __attribute__((format(printf, 3, 4))); void *thread_join(nvc_thread_t *thread); nvc_thread_t *get_thread(int id); void spin_wait(void); typedef int8_t nvc_lock_t; void nvc_lock(nvc_lock_t *lock); void nvc_unlock(nvc_lock_t *lock); #ifdef DEBUG void assert_lock_held(nvc_lock_t *lock); #else #define assert_lock_held(lock) #endif void __scoped_unlock(nvc_lock_t **plock); #define SCOPED_LOCK(lock) \ __attribute__((cleanup(__scoped_unlock), unused)) \ nvc_lock_t *UNIQUE(__lock) = &(lock); \ nvc_lock(&(lock)); typedef struct _workq workq_t; typedef void (*task_fn_t)(void *, void *); typedef void (*scan_fn_t)(void *, void *, void *); workq_t *workq_new(void *context); void workq_free(workq_t *wq); void workq_start(workq_t *wq); void workq_do(workq_t *wq, task_fn_t fn, void *arg); void workq_drain(workq_t *wq); void workq_scan(workq_t *wq, scan_fn_t fn, void *arg); void workq_not_thread_safe(workq_t *wq); void async_do(task_fn_t fn, void *context, void *arg); void async_barrier(void); void async_free(void *ptr); struct cpu_state; typedef void (*stop_world_fn_t)(int, struct cpu_state *, void *); void stop_world(stop_world_fn_t callback, void *arg); void start_world(void); typedef enum { WX_WRITE, WX_EXECUTE } wx_mode_t; void thread_wx_mode(wx_mode_t mode); typedef struct _barrier barrier_t; barrier_t *barrier_new(int count); void barrier_free(barrier_t *b); void barrier_wait(barrier_t *b); #endif // _THREAD_H nvc-r1.17.1/src/tree.c000066400000000000000000001047111504111170000144350ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "tree.h" #include "util.h" #include "object.h" #include "common.h" #include #include #include #include static const imask_t has_map[T_LAST_TREE_KIND] = { // T_ENTITY (I_IDENT | I_PORTS | I_GENERICS | I_CONTEXT | I_DECLS | I_STMTS | I_PRAGMAS), // T_ARCH (I_IDENT | I_IDENT2 | I_DECLS | I_STMTS | I_CONTEXT | I_PRIMARY | I_PRAGMAS), // T_PORT_DECL (I_IDENT | I_VALUE | I_TYPE | I_SUBKIND | I_CLASS | I_FLAGS), // T_FCALL (I_IDENT | I_PARAMS | I_TYPE | I_REF | I_FLAGS), // T_LITERAL (I_SUBKIND | I_TYPE | I_IVAL | I_DVAL | I_IDENT | I_REF), // T_SIGNAL_DECL (I_IDENT | I_VALUE | I_TYPE | I_FLAGS), // T_VAR_DECL (I_IDENT | I_VALUE | I_TYPE | I_FLAGS), // T_PROCESS (I_IDENT | I_DECLS | I_STMTS | I_TRIGGERS | I_FLAGS), // T_REF (I_IDENT | I_TYPE | I_REF | I_FLAGS), // T_WAIT (I_IDENT | I_VALUE | I_DELAY | I_TRIGGERS | I_FLAGS), // T_TYPE_DECL (I_IDENT | I_TYPE), // T_VAR_ASSIGN (I_IDENT | I_VALUE | I_TARGET), // T_PACKAGE (I_IDENT | I_DECLS | I_CONTEXT | I_GENERICS | I_GENMAPS | I_PRAGMAS), // T_SIGNAL_ASSIGN (I_IDENT | I_TARGET | I_WAVES | I_REJECT), // T_QUALIFIED (I_IDENT | I_VALUE | I_TYPE), // T_ENUM_LIT (I_IDENT | I_TYPE | I_POS), // T_CONST_DECL (I_IDENT | I_VALUE | I_TYPE | I_FLAGS), // T_FUNC_DECL (I_IDENT | I_PORTS | I_TYPE | I_FLAGS | I_IDENT2 | I_SUBKIND | I_GENERICS), // T_ELAB (I_IDENT | I_DECLS | I_STMTS | I_CONTEXT), // T_AGGREGATE (I_TYPE | I_ASSOCS | I_FLAGS), // T_ASSERT (I_IDENT | I_VALUE | I_SEVERITY | I_MESSAGE), // T_ATTR_REF (I_NAME | I_VALUE | I_IDENT | I_PARAMS | I_TYPE | I_SUBKIND), // T_ARRAY_REF (I_VALUE | I_PARAMS | I_TYPE | I_FLAGS), // T_ARRAY_SLICE (I_VALUE | I_TYPE | I_RANGES), // T_INSTANCE (I_IDENT | I_IDENT2 | I_PARAMS | I_GENMAPS | I_REF | I_CLASS | I_SPEC), // T_IF (I_IDENT | I_CONDS), // T_NULL (I_IDENT), // T_PACK_BODY (I_IDENT | I_DECLS | I_CONTEXT | I_PRIMARY | I_PRAGMAS), // T_FUNC_BODY (I_IDENT | I_DECLS | I_STMTS | I_PORTS | I_TYPE | I_FLAGS | I_GENERICS | I_IDENT2 | I_SUBKIND), // T_RETURN (I_IDENT | I_TYPE | I_VALUE), // T_COND_ASSIGN (I_IDENT | I_TARGET | I_CONDS | I_GUARD), // T_WHILE (I_IDENT | I_VALUE | I_STMTS), // T_WAVEFORM (I_VALUE | I_DELAY), // T_ALIAS (I_IDENT | I_VALUE | I_TYPE | I_FLAGS), // T_FOR (I_IDENT | I_STMTS | I_RANGES | I_DECLS), // T_ATTR_DECL (I_IDENT | I_TYPE), // T_ATTR_SPEC (I_IDENT | I_VALUE | I_IDENT2 | I_CLASS | I_REF | I_TYPE | I_SUBKIND), // T_PROC_DECL (I_IDENT | I_PORTS | I_TYPE | I_FLAGS | I_IDENT2 | I_SUBKIND | I_GENERICS), // T_PROC_BODY (I_IDENT | I_DECLS | I_STMTS | I_PORTS | I_TYPE | I_FLAGS | I_GENERICS | I_IDENT2 | I_SUBKIND), // T_EXIT (I_IDENT | I_VALUE | I_IDENT2), // T_PCALL (I_IDENT | I_IDENT2 | I_PARAMS | I_REF), // T_CASE (I_IDENT | I_VALUE | I_STMTS), // T_BLOCK (I_IDENT | I_DECLS | I_STMTS | I_PORTS | I_GENERICS | I_PARAMS | I_GENMAPS), // T_COND_STMT (I_IDENT | I_VALUE | I_DECLS | I_STMTS), // T_TYPE_CONV (I_VALUE | I_TYPE | I_FLAGS), // T_SELECT (I_IDENT | I_VALUE | I_STMTS | I_GUARD), // T_COMPONENT (I_IDENT | I_PORTS | I_GENERICS), // T_IF_GENERATE (I_IDENT | I_CONDS), // T_FOR_GENERATE (I_IDENT | I_DECLS | I_STMTS | I_RANGES), // T_FILE_DECL (I_IDENT | I_VALUE | I_TYPE | I_FILE_MODE), // T_OPEN (I_TYPE), // T_FIELD_DECL (I_IDENT | I_TYPE | I_POS), // T_RECORD_REF (I_IDENT | I_VALUE | I_TYPE | I_REF), // T_ALL (I_VALUE | I_TYPE), // T_NEW (I_VALUE | I_TYPE), // T_UNIT_DECL (I_IDENT | I_VALUE | I_TYPE), // T_NEXT (I_IDENT | I_VALUE | I_IDENT2), // T_PARAM (I_VALUE | I_POS | I_SUBKIND | I_NAME), // T_ASSOC (I_VALUE | I_POS | I_NAME | I_RANGES | I_SUBKIND), // T_USE (I_IDENT | I_IDENT2 | I_REF), // T_HIER (I_IDENT | I_SUBKIND | I_IDENT2 | I_REF), // T_SPEC (I_IDENT | I_IDENT2 | I_VALUE | I_REF | I_DECLS), // T_BINDING (I_PARAMS | I_GENMAPS | I_IDENT | I_IDENT2 | I_CLASS | I_REF), // T_LIBRARY (I_IDENT | I_IDENT2), // T_DESIGN_UNIT (I_CONTEXT), // T_CONFIGURATION (I_IDENT | I_IDENT2 | I_DECLS | I_PRIMARY | I_PRAGMAS), // T_PROT_BODY (I_IDENT | I_TYPE | I_DECLS | I_PRIMARY), // T_CONTEXT (I_CONTEXT | I_IDENT | I_PRAGMAS), // T_CONTEXT_REF (I_IDENT | I_REF), // T_CONSTRAINT (I_SUBKIND | I_RANGES | I_REF), // T_BLOCK_CONFIG (I_DECLS | I_IDENT | I_VALUE | I_RANGES | I_REF), // T_PROT_FCALL (I_IDENT | I_PARAMS | I_TYPE | I_REF | I_FLAGS | I_NAME), // T_PROT_PCALL (I_IDENT | I_IDENT2 | I_PARAMS | I_REF | I_NAME), // T_RANGE (I_SUBKIND | I_VALUE | I_LEFT | I_RIGHT | I_TYPE), // T_IMPLICIT_SIGNAL (I_IDENT | I_TYPE | I_SUBKIND | I_VALUE | I_FLAGS), // T_DISCONNECT (I_IDENT | I_REF | I_TYPE | I_DELAY), // T_GROUP_TEMPLATE (I_IDENT), // T_GROUP (I_IDENT | I_REF), // T_SUBTYPE_DECL (I_IDENT | I_TYPE), // T_CONV_FUNC (I_IDENT | I_REF | I_VALUE | I_TYPE), // T_CONCURRENT (I_IDENT | I_STMTS | I_FLAGS), // T_SEQUENCE (I_IDENT | I_STMTS | I_DECLS), // T_PACK_INST (I_IDENT | I_REF | I_DECLS | I_CONTEXT | I_GENERICS | I_GENMAPS | I_PRAGMAS), // T_GENERIC_DECL (I_IDENT | I_VALUE | I_TYPE | I_CLASS | I_SUBKIND | I_FLAGS | I_PORTS), // T_TYPE_REF (I_IDENT | I_TYPE), // T_BOX (I_IDENT | I_TYPE | I_REF), // T_PARAM_DECL (I_IDENT | I_VALUE | I_TYPE | I_SUBKIND | I_CLASS | I_FLAGS), // T_EXTERNAL_NAME (I_PARTS | I_CLASS | I_TYPE | I_REF), // T_FORCE (I_IDENT | I_TARGET | I_VALUE | I_SUBKIND), // T_RELEASE (I_IDENT | I_TARGET | I_SUBKIND), // T_PROT_REF (I_IDENT | I_VALUE | I_TYPE | I_REF), // T_MATCH_CASE (I_IDENT | I_VALUE | I_STMTS), // T_FUNC_INST (I_IDENT | I_DECLS | I_STMTS | I_PORTS | I_TYPE | I_FLAGS | I_GENERICS | I_IDENT2 | I_SUBKIND | I_GENMAPS | I_REF), // T_PROC_INST (I_IDENT | I_DECLS | I_STMTS | I_PORTS | I_TYPE | I_FLAGS | I_GENERICS | I_IDENT2 | I_SUBKIND | I_GENMAPS | I_REF), // T_ELEM_CONSTRAINT (I_IDENT | I_REF | I_TYPE), // T_STRING (I_CHARS | I_TYPE), // T_PATH_ELT (I_SUBKIND | I_IDENT | I_VALUE), // T_PRAGMA (I_SUBKIND), // T_CASE_GENERATE (I_IDENT | I_VALUE | I_STMTS), // T_ALTERNATIVE (I_IDENT | I_ASSOCS | I_STMTS | I_DECLS), // T_PSL_DECL (I_IDENT | I_FOREIGN), // T_VERILOG (I_IDENT | I_FOREIGN | I_PARAMS | I_GENMAPS), // T_VIEW_DECL (I_IDENT | I_TYPE), // T_PACKAGE_MAP (I_IDENT | I_SUBKIND | I_GENMAPS | I_REF), // T_COND_EXPR (I_VALUE | I_RESULT), // T_COND_VALUE (I_CONDS | I_TYPE), // T_COND_RETURN (I_IDENT | I_VALUE), // T_VIEW_ELEMENT (I_IDENT | I_REF | I_SUBKIND | I_TYPE | I_VALUE), // T_MATCH_SELECT (I_IDENT | I_VALUE | I_STMTS | I_GUARD), // T_PROT_DECL (I_IDENT | I_DECLS | I_TYPE), // T_DUMMY_DRIVER (I_TARGET | I_IDENT), // T_GUARD (I_REF | I_SPEC | I_TYPE), // T_INERTIAL (I_VALUE | I_TYPE | I_TARGET), // T_ELEM_RESOLUTION (I_ASSOCS), // T_LOOP (I_IDENT | I_STMTS), // T_REPORT (I_IDENT | I_SEVERITY | I_MESSAGE), // T_PSL_DIRECT (I_IDENT | I_FOREIGN), // T_PSL_FCALL (I_FOREIGN | I_TYPE), // T_PSL_UNION (I_FOREIGN | I_TYPE) }; static const char *kind_text_map[T_LAST_TREE_KIND] = { "T_ENTITY", "T_ARCH", "T_PORT_DECL", "T_FCALL", "T_LITERAL", "T_SIGNAL_DECL", "T_VAR_DECL", "T_PROCESS", "T_REF", "T_WAIT", "T_TYPE_DECL", "T_VAR_ASSIGN", "T_PACKAGE", "T_SIGNAL_ASSIGN", "T_QUALIFIED", "T_ENUM_LIT", "T_CONST_DECL", "T_FUNC_DECL", "T_ELAB", "T_AGGREGATE", "T_ASSERT", "T_ATTR_REF", "T_ARRAY_REF", "T_ARRAY_SLICE", "T_INSTANCE", "T_IF", "T_NULL", "T_PACK_BODY", "T_FUNC_BODY", "T_RETURN", "T_COND_ASSIGN", "T_WHILE", "T_WAVEFORM", "T_ALIAS", "T_FOR", "T_ATTR_DECL", "T_ATTR_SPEC", "T_PROC_DECL", "T_PROC_BODY", "T_EXIT", "T_PCALL", "T_CASE", "T_BLOCK", "T_COND_STMT", "T_TYPE_CONV", "T_SELECT", "T_COMPONENT", "T_IF_GENERATE", "T_FOR_GENERATE", "T_FILE_DECL", "T_OPEN", "T_FIELD_DECL", "T_RECORD_REF", "T_ALL", "T_NEW", "T_UNIT_DECL", "T_NEXT", "T_PARAM", "T_ASSOC", "T_USE", "T_HIER", "T_SPEC", "T_BINDING", "T_LIBRARY", "T_DESIGN_UNIT", "T_CONFIGURATION", "T_PROT_BODY", "T_CONTEXT", "T_CONTEXT_REF", "T_CONSTRAINT", "T_BLOCK_CONFIG", "T_PROT_FCALL", "T_PROT_PCALL", "T_RANGE", "T_IMPLICIT_SIGNAL", "T_DISCONNECT", "T_GROUP_TEMPLATE", "T_GROUP", "T_SUBTYPE_DECL", "T_CONV_FUNC", "T_CONCURRENT", "T_SEQUENCE", "T_PACK_INST", "T_GENERIC_DECL", "T_TYPE_REF", "T_BOX", "T_PARAM_DECL", "T_EXTERNAL_NAME", "T_FORCE", "T_RELEASE", "T_PROT_REF", "T_MATCH_CASE", "T_FUNC_INST", "T_PROC_INST", "T_ELEM_CONSTRAINT", "T_STRING", "T_PATH_ELT", "T_PRAGMA", "T_CASE_GENERATE", "T_ALTERNATIVE", "T_PSL_DECL", "T_VERILOG", "T_VIEW_DECL", "T_PACKAGE_MAP", "T_COND_EXPR", "T_COND_VALUE", "T_COND_RETURN", "T_VIEW_ELEMENT", "T_MATCH_SELECT", "T_PROT_DECL", "T_DUMMY_DRIVER", "T_GUARD", "T_INERTIAL", "T_ELEM_RESOLUTION", "T_LOOP", "T_REPORT", "T_PSL_DIRECT", "T_PSL_FCALL", "T_PSL_UNION", }; static const change_allowed_t change_allowed[] = { { T_REF, T_FCALL }, { T_REF, T_PCALL }, { T_ARRAY_REF, T_FCALL }, { T_FCALL, T_ARRAY_REF }, { T_PROT_FCALL, T_ARRAY_REF }, { T_DESIGN_UNIT, T_ENTITY }, { T_DESIGN_UNIT, T_PACKAGE }, { T_DESIGN_UNIT, T_PACK_BODY }, { T_DESIGN_UNIT, T_ARCH }, { T_DESIGN_UNIT, T_CONFIGURATION }, { T_DESIGN_UNIT, T_CONTEXT }, { T_DESIGN_UNIT, T_PACK_INST }, { T_FUNC_DECL, T_FUNC_BODY }, { T_PROC_DECL, T_PROC_BODY }, { T_FCALL, T_PROT_FCALL }, { T_PCALL, T_PROT_PCALL }, { -1, -1 } }; struct _tree { object_t object; }; struct _type { object_t object; }; struct _psl_node { object_t object; }; struct _vlog_node { object_t object; }; object_class_t tree_object = { .name = "tree", .change_allowed = change_allowed, .has_map = has_map, .kind_text_map = kind_text_map, .tag = OBJECT_TAG_TREE, .last_kind = T_LAST_TREE_KIND, .has_loc = true, .gc_roots = { T_ARCH, T_ENTITY, T_PACKAGE, T_ELAB, T_PACK_BODY, T_CONTEXT, T_CONFIGURATION, T_DESIGN_UNIT, T_PACK_INST }, .gc_num_roots = 9 }; #ifdef DEBUG static tree_kind_t expr_kinds[] = { T_FCALL, T_LITERAL, T_REF, T_QUALIFIED, T_AGGREGATE, T_ATTR_REF, T_ARRAY_REF, T_ARRAY_SLICE, T_TYPE_CONV, T_OPEN, T_RECORD_REF, T_ALL, T_NEW, T_PROT_FCALL, T_CONV_FUNC, T_TYPE_REF, T_BOX, T_EXTERNAL_NAME, T_PROT_REF, T_STRING, }; static tree_kind_t decl_kinds[] = { T_PORT_DECL, T_SIGNAL_DECL, T_VAR_DECL, T_TYPE_DECL, T_CONST_DECL, T_FUNC_DECL, T_FUNC_BODY, T_ALIAS, T_ATTR_DECL, T_ATTR_SPEC, T_PROC_DECL, T_PROC_BODY, T_COMPONENT, T_FILE_DECL, T_FIELD_DECL, T_UNIT_DECL, T_HIER, T_SPEC, T_BINDING, T_USE, T_PROT_BODY, T_BLOCK_CONFIG, T_IMPLICIT_SIGNAL, T_DISCONNECT, T_GROUP_TEMPLATE, T_GROUP, T_SUBTYPE_DECL, T_PACKAGE, T_PACK_BODY, T_PACK_INST, T_GENERIC_DECL, T_PARAM_DECL, T_PROC_INST, T_FUNC_INST, T_PSL_DECL, T_VIEW_DECL, T_PROT_DECL, T_VERILOG, }; static void tree_assert_kind(tree_t t, const tree_kind_t *list, size_t len, const char *what) { for (size_t i = 0; i < len; i++) { if (t->object.kind == list[i]) return; } fatal_trace("tree kind %s is not %s", tree_kind_str(t->object.kind), what); } #else #define tree_assert_kind(t, list, len, what) #endif static inline void tree_assert_expr(tree_t t) { tree_assert_kind(t, expr_kinds, ARRAY_LEN(expr_kinds), "an expression"); } static inline void tree_assert_decl(tree_t t) { tree_assert_kind(t, decl_kinds, ARRAY_LEN(decl_kinds), "a declaration"); } static inline tree_t tree_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _tree, object); } static inline void tree_array_add(item_t *item, tree_t t) { obj_array_add(&(item->obj_array), &(t->object)); } tree_t tree_new(tree_kind_t kind) { object_t *o = object_new(NULL, &tree_object, kind); return container_of(o, struct _tree, object); } const loc_t *tree_loc(tree_t t) { assert(t != NULL); return &t->object.loc; } void tree_set_loc(tree_t t, const loc_t *loc) { assert(t != NULL); assert(loc != NULL); t->object.loc = *loc; } ident_t tree_ident(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_IDENT); assert(item->ident != NULL); return item->ident; } bool tree_has_ident(tree_t t) { return lookup_item(&tree_object, t, I_IDENT)->ident != NULL; } void tree_set_ident(tree_t t, ident_t i) { lookup_item(&tree_object, t, I_IDENT)->ident = i; } ident_t tree_ident2(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_IDENT2); assert(item->ident != NULL); return item->ident; } void tree_set_ident2(tree_t t, ident_t i) { lookup_item(&tree_object, t, I_IDENT2)->ident = i; } bool tree_has_ident2(tree_t t) { return lookup_item(&tree_object, t, I_IDENT2)->ident != NULL; } tree_kind_t tree_kind(tree_t t) { assert(t != NULL); return t->object.kind; } void tree_change_kind(tree_t t, tree_kind_t kind) { object_change_kind(&tree_object, &(t->object), kind); } unsigned tree_ports(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_PORTS); return obj_array_count(item->obj_array); } tree_t tree_port(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_PORTS); return tree_array_nth(item, n); } void tree_add_port(tree_t t, tree_t d) { tree_assert_decl(d); tree_array_add(lookup_item(&tree_object, t, I_PORTS), d); object_write_barrier(&(t->object), &(d->object)); } unsigned tree_subkind(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_SUBKIND); return item->ival; } void tree_set_subkind(tree_t t, unsigned sub) { lookup_item(&tree_object, t, I_SUBKIND)->ival = sub; } unsigned tree_generics(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_GENERICS); return obj_array_count(item->obj_array); } tree_t tree_generic(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_GENERICS); return tree_array_nth(item, n); } void tree_add_generic(tree_t t, tree_t d) { assert(d->object.kind == T_GENERIC_DECL); tree_array_add(lookup_item(&tree_object, t, I_GENERICS), d); object_write_barrier(&(t->object), &(d->object)); } type_t tree_type(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_TYPE); assert(item->object != NULL); return container_of(item->object, struct _type, object); } void tree_set_type(tree_t t, type_t ty) { object_t *obj = ty ? &(ty->object) : NULL; lookup_item(&tree_object, t, I_TYPE)->object = obj; object_write_barrier(&(t->object), obj); } bool tree_has_type(tree_t t) { return lookup_item(&tree_object, t, I_TYPE)->object != NULL; } unsigned tree_params(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_PARAMS); return obj_array_count(item->obj_array); } tree_t tree_param(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_PARAMS); return tree_array_nth(item, n); } void tree_add_param(tree_t t, tree_t e) { assert(e->object.kind == T_PARAM); tree_array_add(lookup_item(&tree_object, t, I_PARAMS), e); object_write_barrier(&(t->object), &(e->object)); } unsigned tree_genmaps(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_GENMAPS); return obj_array_count(item->obj_array); } tree_t tree_genmap(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_GENMAPS); return tree_array_nth(item, n); } void tree_add_genmap(tree_t t, tree_t e) { tree_array_add(lookup_item(&tree_object, t, I_GENMAPS), e); } void tree_trim_genmaps(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_GENMAPS); assert(n < obj_array_count(item->obj_array)); assert(n > 0); item->obj_array->count = n; } int64_t tree_ival(tree_t t) { return lookup_item(&tree_object, t, I_IVAL)->ival; } void tree_set_ival(tree_t t, int64_t i) { lookup_item(&tree_object, t, I_IVAL)->ival = i; } double tree_dval(tree_t t) { return lookup_item(&tree_object, t, I_DVAL)->dval; } void tree_set_dval(tree_t t, double d) { lookup_item(&tree_object, t, I_DVAL)->dval = d; } tree_flags_t tree_flags(tree_t t) { return lookup_item(&tree_object, t, I_FLAGS)->ival; } void tree_set_flag(tree_t t, tree_flags_t mask) { lookup_item(&tree_object, t, I_FLAGS)->ival |= mask; } void tree_clear_flag(tree_t t, tree_flags_t mask) { lookup_item(&tree_object, t, I_FLAGS)->ival &= ~mask; } tree_t tree_primary(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_PRIMARY); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool tree_has_primary(tree_t t) { return lookup_item(&tree_object, t, I_PRIMARY)->object != NULL; } void tree_set_primary(tree_t t, tree_t unit) { lookup_item(&tree_object, t, I_PRIMARY)->object = &(unit->object); object_write_barrier(&(t->object), &(unit->object)); } psl_node_t tree_psl(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_FOREIGN); assert(item->object != NULL); return container_of(item->object, struct _psl_node, object); } void tree_set_psl(tree_t t, psl_node_t p) { assert(p != NULL); lookup_item(&tree_object, t, I_FOREIGN)->object = &(p->object); object_write_barrier(&(t->object), &(p->object)); } bool tree_has_psl(tree_t t) { return lookup_item(&tree_object, t, I_FOREIGN)->object != NULL; } vlog_node_t tree_vlog(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_FOREIGN); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } void tree_set_vlog(tree_t t, vlog_node_t v) { assert(v != NULL); lookup_item(&tree_object, t, I_FOREIGN)->object = &(v->object); object_write_barrier(&(t->object), &(v->object)); } unsigned tree_chars(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_CHARS); return obj_array_count(item->obj_array); } tree_t tree_char(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_CHARS); return tree_array_nth(item, n); } void tree_add_char(tree_t t, tree_t ref) { tree_array_add(lookup_item(&tree_object, t, I_CHARS), ref); object_write_barrier(&(t->object), &(ref->object)); } unsigned tree_parts(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_PARTS); return obj_array_count(item->obj_array); } tree_t tree_part(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_PARTS); return tree_array_nth(item, n); } void tree_add_part(tree_t t, tree_t ref) { tree_array_add(lookup_item(&tree_object, t, I_PARTS), ref); object_write_barrier(&(t->object), &(ref->object)); } bool tree_has_value(tree_t t) { return lookup_item(&tree_object, t, I_VALUE)->object != NULL; } tree_t tree_value(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_VALUE); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_value(tree_t t, tree_t v) { object_t *obj = v ? &(v->object) : NULL; lookup_item(&tree_object, t, I_VALUE)->object = obj; object_write_barrier(&(t->object), obj); } bool tree_has_result(tree_t t) { return lookup_item(&tree_object, t, I_RESULT)->object != NULL; } tree_t tree_result(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_RESULT); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_result(tree_t t, tree_t v) { object_t *obj = v ? &(v->object) : NULL; lookup_item(&tree_object, t, I_RESULT)->object = obj; object_write_barrier(&(t->object), obj); } unsigned tree_decls(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_DECLS); return obj_array_count(item->obj_array); } tree_t tree_decl(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_DECLS); return tree_array_nth(item, n); } void tree_add_decl(tree_t t, tree_t d) { tree_assert_decl(d); tree_array_add(lookup_item(&tree_object, t, I_DECLS), d); object_write_barrier(&(t->object), &(d->object)); } unsigned tree_stmts(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_STMTS); return obj_array_count(item->obj_array); } tree_t tree_stmt(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_STMTS); return tree_array_nth(item, n); } void tree_add_stmt(tree_t t, tree_t s) { assert(s != NULL); tree_array_add(lookup_item(&tree_object, t, I_STMTS), s); object_write_barrier(&(t->object), &(s->object)); } unsigned tree_waveforms(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_WAVES); return obj_array_count(item->obj_array); } tree_t tree_waveform(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_WAVES); return tree_array_nth(item, n); } void tree_add_waveform(tree_t t, tree_t w) { assert(w->object.kind == T_WAVEFORM); tree_array_add(lookup_item(&tree_object, t, I_WAVES), w); object_write_barrier(&(t->object), &(w->object)); } unsigned tree_conds(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_CONDS); return obj_array_count(item->obj_array); } tree_t tree_cond(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_CONDS); return tree_array_nth(item, n); } void tree_add_cond(tree_t t, tree_t c) { assert(c->object.kind == T_COND_STMT || c->object.kind == T_COND_EXPR); tree_array_add(lookup_item(&tree_object, t, I_CONDS), c); object_write_barrier(&(t->object), &(c->object)); } bool tree_has_delay(tree_t t) { return lookup_item(&tree_object, t, I_DELAY)->object != NULL; } tree_t tree_delay(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_DELAY); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_delay(tree_t t, tree_t d) { tree_assert_expr(d); lookup_item(&tree_object, t, I_DELAY)->object = &(d->object); object_write_barrier(&(t->object), &(d->object)); } unsigned tree_triggers(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_TRIGGERS); return obj_array_count(item->obj_array); } tree_t tree_trigger(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_TRIGGERS); return tree_array_nth(item, n); } void tree_add_trigger(tree_t t, tree_t s) { tree_assert_expr(s); tree_array_add(lookup_item(&tree_object, t, I_TRIGGERS), s); object_write_barrier(&(t->object), &(s->object)); } tree_t tree_target(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_TARGET); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_target(tree_t t, tree_t lhs) { lookup_item(&tree_object, t, I_TARGET)->object = &(lhs->object); object_write_barrier(&(t->object), &(lhs->object)); } tree_t tree_ref(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_REF); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool tree_has_ref(tree_t t) { return lookup_item(&tree_object, t, I_REF)->object != NULL; } void tree_set_ref(tree_t t, tree_t decl) { object_t *obj = decl ? &(decl->object) : NULL; lookup_item(&tree_object, t, I_REF)->object = obj; object_write_barrier(&(t->object), obj); } tree_t tree_spec(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_SPEC); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool tree_has_spec(tree_t t) { return lookup_item(&tree_object, t, I_SPEC)->object != NULL; } void tree_set_spec(tree_t t, tree_t s) { assert(s != NULL); lookup_item(&tree_object, t, I_SPEC)->object = &(s->object); object_write_barrier(&(t->object), &(s->object)); } unsigned tree_contexts(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_CONTEXT); return obj_array_count(item->obj_array); } tree_t tree_context(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_CONTEXT); return tree_array_nth(item, n); } void tree_add_context(tree_t t, tree_t ctx) { assert(ctx->object.kind == T_USE || ctx->object.kind == T_LIBRARY || ctx->object.kind == T_CONTEXT_REF); tree_array_add(lookup_item(&tree_object, t, I_CONTEXT), ctx); object_write_barrier(&(t->object), &(ctx->object)); } unsigned tree_pragmas(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_PRAGMAS); return obj_array_count(item->obj_array); } tree_t tree_pragma(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_PRAGMAS); return tree_array_nth(item, n); } void tree_add_pragma(tree_t t, tree_t p) { assert(p->object.kind == T_PRAGMA); tree_array_add(lookup_item(&tree_object, t, I_PRAGMAS), p); object_write_barrier(&(t->object), &(p->object)); } unsigned tree_assocs(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_ASSOCS); return obj_array_count(item->obj_array); } tree_t tree_assoc(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_ASSOCS); return tree_array_nth(item, n); } void tree_add_assoc(tree_t t, tree_t a) { assert(a->object.kind == T_ASSOC); tree_array_add(lookup_item(&tree_object, t, I_ASSOCS), a); object_write_barrier(&(t->object), &(a->object)); } tree_t tree_severity(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_SEVERITY); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_severity(tree_t t, tree_t s) { tree_assert_expr(s); lookup_item(&tree_object, t, I_SEVERITY)->object = &(s->object); object_write_barrier(&(t->object), &(s->object)); } bool tree_has_severity(tree_t t) { return lookup_item(&tree_object, t, I_SEVERITY)->object != NULL; } tree_t tree_message(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_MESSAGE); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool tree_has_message(tree_t t) { return lookup_item(&tree_object, t, I_MESSAGE)->object != NULL; } void tree_set_message(tree_t t, tree_t m) { tree_assert_expr(m); lookup_item(&tree_object, t, I_MESSAGE)->object = &(m->object); object_write_barrier(&(t->object), &(m->object)); } void tree_add_range(tree_t t, tree_t r) { tree_array_add(lookup_item(&tree_object, t, I_RANGES), r); object_write_barrier(&(t->object), &(r->object)); } tree_t tree_range(tree_t t, unsigned n) { item_t *item = lookup_item(&tree_object, t, I_RANGES); return tree_array_nth(item, n); } unsigned tree_ranges(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_RANGES); return obj_array_count(item->obj_array); } unsigned tree_pos(tree_t t) { return lookup_item(&tree_object, t, I_POS)->ival; } void tree_set_pos(tree_t t, unsigned pos) { lookup_item(&tree_object, t, I_POS)->ival = pos; } tree_t tree_left(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_LEFT); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_left(tree_t t, tree_t left) { tree_assert_expr(left); lookup_item(&tree_object, t, I_LEFT)->object = &(left->object); object_write_barrier(&(t->object), &(left->object)); } tree_t tree_right(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_RIGHT); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_right(tree_t t, tree_t right) { tree_assert_expr(right); lookup_item(&tree_object, t, I_RIGHT)->object = &(right->object); object_write_barrier(&(t->object), &(right->object)); } class_t tree_class(tree_t t) { return lookup_item(&tree_object, t, I_CLASS)->ival; } void tree_set_class(tree_t t, class_t c) { lookup_item(&tree_object, t, I_CLASS)->ival = c; } tree_t tree_reject(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_REJECT); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_reject(tree_t t, tree_t r) { tree_assert_expr(r); lookup_item(&tree_object, t, I_REJECT)->object = &(r->object); object_write_barrier(&(t->object), &(r->object)); } bool tree_has_reject(tree_t t) { return lookup_item(&tree_object, t, I_REJECT)->object != NULL; } tree_t tree_guard(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_GUARD); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_guard(tree_t t, tree_t g) { assert(g->object.kind == T_GUARD); lookup_item(&tree_object, t, I_GUARD)->object = &(g->object); object_write_barrier(&(t->object), &(g->object)); } bool tree_has_guard(tree_t t) { return lookup_item(&tree_object, t, I_GUARD)->object != NULL; } tree_t tree_name(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_NAME); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } void tree_set_name(tree_t t, tree_t n) { tree_assert_expr(n); lookup_item(&tree_object, t, I_NAME)->object = &(n->object); object_write_barrier(&(t->object), &(n->object)); } bool tree_has_name(tree_t t) { return lookup_item(&tree_object, t, I_NAME)->object != NULL; } tree_t tree_file_mode(tree_t t) { item_t *item = lookup_item(&tree_object, t, I_FILE_MODE); return container_of(item->object, struct _tree, object); } void tree_set_file_mode(tree_t t, tree_t m) { lookup_item(&tree_object, t, I_FILE_MODE)->object = &(m->object); object_write_barrier(&(t->object), &(m->object)); } unsigned tree_visit(tree_t t, tree_visit_fn_t fn, void *context) { return tree_visit_only(t, fn, context, T_LAST_TREE_KIND); } unsigned tree_visit_only(tree_t t, tree_visit_fn_t fn, void *context, tree_kind_t kind) { assert(t != NULL); object_visit_ctx_t ctx = { .count = 0, .postorder = (object_visit_fn_t)fn, .preorder = NULL, .context = context, .kind = kind, .tag = OBJECT_TAG_TREE, .generation = object_next_generation(), .deep = false }; object_visit(&(t->object), &ctx); return ctx.count; } tree_t tree_rewrite(tree_t t, tree_rewrite_pre_fn_t pre_fn, tree_rewrite_post_fn_t tree_post_fn, type_rewrite_post_fn_t type_post_fn, void *context) { object_arena_t *arena = object_arena(&(t->object)); if (arena_frozen(arena)) return t; object_rewrite_ctx_t ctx = { .generation = object_next_generation(), .context = context, .arena = arena, }; ctx.pre_fn[OBJECT_TAG_TREE] = (object_rewrite_pre_fn_t)pre_fn; ctx.post_fn[OBJECT_TAG_TREE] = (object_rewrite_post_fn_t)tree_post_fn; ctx.post_fn[OBJECT_TAG_TYPE] = (object_rewrite_post_fn_t)type_post_fn; object_t *result = object_rewrite(&(t->object), &ctx); free(ctx.cache); return container_of(result, struct _tree, object); } void tree_copy(tree_t *roots, unsigned nroots, tree_copy_pred_t tree_pred, type_copy_pred_t type_pred, void *pred_context, tree_copy_fn_t tree_callback, type_copy_fn_t type_callback, void *callback_context) { object_copy_ctx_t *ctx LOCAL = xcalloc_flex(sizeof(object_copy_ctx_t), nroots, sizeof(object_t *)); ctx->generation = object_next_generation(); ctx->pred_context = pred_context; ctx->callback_context = callback_context; ctx->nroots = nroots; for (unsigned i = 0; i < nroots; i++) ctx->roots[i] = &(roots[i]->object); ctx->should_copy[OBJECT_TAG_TREE] = (object_copy_pred_t)tree_pred; ctx->should_copy[OBJECT_TAG_TYPE] = (object_copy_pred_t)type_pred; ctx->callback[OBJECT_TAG_TREE] = (object_copy_fn_t)tree_callback; ctx->callback[OBJECT_TAG_TYPE] = (object_copy_fn_t)type_callback; object_copy(ctx); for (unsigned i = 0; i < nroots; i++) roots[i] = container_of(ctx->roots[i], struct _tree, object); } const char *tree_kind_str(tree_kind_t t) { return kind_text_map[t]; } object_arena_t *tree_arena(tree_t t) { return object_arena(&(t->object)); } bool tree_frozen(tree_t t) { return arena_frozen(object_arena(&(t->object))); } tree_t tree_container(tree_t t) { object_t *o = arena_root(object_arena(&(t->object))); assert(o->tag == OBJECT_TAG_TREE); return container_of(o, struct _tree, object); } void tree_walk_deps(tree_t t, tree_deps_fn_t fn, void *ctx) { arena_walk_deps(object_arena(&(t->object)), fn, ctx); } object_t *tree_to_object(tree_t t) { return t ? &(t->object) : NULL; } tree_t tree_from_object(object_t *obj) { if (obj != NULL && obj->tag == OBJECT_TAG_TREE) return container_of(obj, struct _tree, object); else return NULL; } tree_global_flags_t tree_global_flags(tree_t t) { return arena_flags(object_arena(&(t->object))); } void tree_set_global_flags(tree_t t, tree_global_flags_t flags) { arena_set_flags(object_arena(&(t->object)), flags); } nvc-r1.17.1/src/tree.h000066400000000000000000000330471504111170000144450ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _TREE_H #define _TREE_H #include "prim.h" #include #include typedef enum port_mode { PORT_INVALID, PORT_IN, PORT_OUT, PORT_INOUT, PORT_BUFFER, PORT_LINKAGE, PORT_RECORD_VIEW, PORT_ARRAY_VIEW, } port_mode_t; typedef enum { C_DEFAULT, C_SIGNAL, C_VARIABLE, C_CONSTANT, C_FILE, C_ENTITY, C_COMPONENT, C_CONFIGURATION, C_ARCHITECTURE, C_FUNCTION, C_PACKAGE, C_TYPE, C_SUBTYPE, C_LABEL, C_PROCEDURE, C_LITERAL, C_UNITS, C_LIBRARY, C_CONTEXT, C_VIEW, } class_t; typedef enum param_kind { P_POS, P_NAMED } param_kind_t; typedef enum assoc_kind { A_POS, A_NAMED, A_RANGE, A_OTHERS, A_SLICE, A_CONCAT, } assoc_kind_t; typedef enum literal_kind { L_INT, L_REAL, L_NULL, L_PHYSICAL } literal_kind_t; typedef enum constraint_kind { C_RANGE, C_INDEX, C_RECORD, } constraint_kind_t; typedef enum { RANGE_TO, RANGE_DOWNTO, RANGE_EXPR, RANGE_ERROR } range_kind_t; typedef enum { SPEC_EXACT, SPEC_ALL, SPEC_OTHERS, } spec_kind_t; typedef enum { PE_CARET, PE_SIMPLE, PE_LIBRARY, PE_RELATIVE, PE_ABSOLUTE, PE_GENERATE, } path_elt_t; typedef enum { S_USER, S_ARRAY_EQ, S_ARRAY_NEQ, S_ARRAY_LT, S_ARRAY_LE, S_ARRAY_GT, S_ARRAY_GE, S_CONCAT, S_RECORD_EQ, S_RECORD_NEQ, S_MUL, S_MUL_PR, S_MUL_RP, S_MUL_PI, S_MUL_IP, S_DIV, S_DIV_PR, S_DIV_PP, S_DIV_PI, S_ADD, S_SUB, S_IDENTITY, S_NEGATE, S_SCALAR_LT, S_SCALAR_LE, S_SCALAR_GT, S_SCALAR_GE, S_SCALAR_EQ, S_SCALAR_NEQ, S_ABS, S_MOD, S_REM, S_EXP, S_MUL_RI, S_MUL_IR, S_DIV_RI, S_SCALAR_AND, S_SCALAR_OR, S_SCALAR_XOR, S_SCALAR_NAND, S_SCALAR_NOR, S_SCALAR_XNOR, S_SCALAR_NOT, S_ARRAY_AND, S_ARRAY_OR, S_ARRAY_XOR, S_ARRAY_NAND, S_ARRAY_NOR, S_ARRAY_XNOR, S_ARRAY_NOT, S_MIXED_AND, S_MIXED_OR, S_MIXED_XOR, S_MIXED_NAND, S_MIXED_NOR, S_MIXED_XNOR, S_SLL, S_SRL, S_SLA, S_SRA, S_ROL, S_ROR, S_FILE_OPEN1, S_FILE_OPEN2, S_FILE_CLOSE, S_FILE_READ, S_FILE_WRITE, S_ENDFILE, S_DEALLOCATE, S_MINIMUM, S_MAXIMUM, S_TO_STRING, S_RISING_EDGE, S_FALLING_EDGE, S_REDUCE_AND, S_REDUCE_OR, S_REDUCE_NAND, S_REDUCE_NOR, S_REDUCE_XOR, S_REDUCE_XNOR, S_MATCH_LT, S_MATCH_LE, S_MATCH_GT, S_MATCH_GE, S_MATCH_EQ, S_MATCH_NEQ, S_FILE_FLUSH, S_FILE_OPEN3, S_FILE_MODE, S_FILE_CANSEEK, S_FILE_SIZE, S_FILE_REWIND, S_FILE_SEEK, S_FILE_TRUNCATE, S_FILE_STATE, S_FILE_POSITION, S_TO_STRING_TIME, S_TO_STRING_REAL_DIGITS, S_TO_STRING_REAL_FORMAT, S_TO_HSTRING_BITVEC, S_TO_OSTRING_BITVEC, } subprogram_kind_t; typedef enum { ATTR_USER, ATTR_LAST_EVENT, ATTR_EVENT, ATTR_ACTIVE, ATTR_LAST_VALUE, ATTR_PATH_NAME, ATTR_INSTANCE_NAME, ATTR_DELAYED, ATTR_STABLE, ATTR_QUIET, ATTR_TRANSACTION, ATTR_LENGTH, ATTR_LEFT, ATTR_LOW, ATTR_HIGH, ATTR_RIGHT, ATTR_ASCENDING, ATTR_IMAGE, ATTR_LAST_ACTIVE, ATTR_DRIVING, ATTR_DRIVING_VALUE, ATTR_VALUE, ATTR_SUCC, ATTR_PRED, ATTR_LEFTOF, ATTR_RIGHTOF, ATTR_POS, ATTR_VAL, ATTR_RANGE, ATTR_REVERSE_RANGE, ATTR_BASE, ATTR_SIMPLE_NAME, ATTR_SUBTYPE, ATTR_ELEMENT, ATTR_CONVERSE, ATTR_DESIGNATED_SUBTYPE, ATTR_INDEX, ATTR_REFLECT, } attr_kind_t; typedef enum { IMPLICIT_GUARD, IMPLICIT_DELAYED, IMPLICIT_TRANSACTION, IMPLICIT_STABLE, IMPLICIT_QUIET, } implicit_kind_t; typedef enum { PRAGMA_COVERAGE_ON, PRAGMA_COVERAGE_OFF, PRAGMA_SYNTHESIS_ON, PRAGMA_SYNTHESIS_OFF, PRAGMA_TRANSLATE_ON, PRAGMA_TRANSLATE_OFF, } pragma_kind_t; typedef enum { PACKAGE_MAP_BOX, PACKAGE_MAP_MATCHING, PACKAGE_MAP_DEFAULT, } package_map_kind_t; typedef enum tree_kind { T_ENTITY, T_ARCH, T_PORT_DECL, T_FCALL, T_LITERAL, T_SIGNAL_DECL, T_VAR_DECL, T_PROCESS, T_REF, T_WAIT, T_TYPE_DECL, T_VAR_ASSIGN, T_PACKAGE, T_SIGNAL_ASSIGN, T_QUALIFIED, T_ENUM_LIT, T_CONST_DECL, T_FUNC_DECL, T_ELAB, T_AGGREGATE, T_ASSERT, T_ATTR_REF, T_ARRAY_REF, T_ARRAY_SLICE, T_INSTANCE, T_IF, T_NULL, T_PACK_BODY, T_FUNC_BODY, T_RETURN, T_COND_ASSIGN, T_WHILE, T_WAVEFORM, T_ALIAS, T_FOR, T_ATTR_DECL, T_ATTR_SPEC, T_PROC_DECL, T_PROC_BODY, T_EXIT, T_PCALL, T_CASE, T_BLOCK, T_COND_STMT, T_TYPE_CONV, T_SELECT, T_COMPONENT, T_IF_GENERATE, T_FOR_GENERATE, T_FILE_DECL, T_OPEN, T_FIELD_DECL, T_RECORD_REF, T_ALL, T_NEW, T_UNIT_DECL, T_NEXT, T_PARAM, T_ASSOC, T_USE, T_HIER, T_SPEC, T_BINDING, T_LIBRARY, T_DESIGN_UNIT, T_CONFIGURATION, T_PROT_BODY, T_CONTEXT, T_CONTEXT_REF, T_CONSTRAINT, T_BLOCK_CONFIG, T_PROT_FCALL, T_PROT_PCALL, T_RANGE, T_IMPLICIT_SIGNAL, T_DISCONNECT, T_GROUP_TEMPLATE, T_GROUP, T_SUBTYPE_DECL, T_CONV_FUNC, T_CONCURRENT, T_SEQUENCE, T_PACK_INST, T_GENERIC_DECL, T_TYPE_REF, T_BOX, T_PARAM_DECL, T_EXTERNAL_NAME, T_FORCE, T_RELEASE, T_PROT_REF, T_MATCH_CASE, T_FUNC_INST, T_PROC_INST, T_ELEM_CONSTRAINT, T_STRING, T_PATH_ELT, T_PRAGMA, T_CASE_GENERATE, T_ALTERNATIVE, T_PSL_DECL, T_VERILOG, T_VIEW_DECL, T_PACKAGE_MAP, T_COND_EXPR, T_COND_VALUE, T_COND_RETURN, T_VIEW_ELEMENT, T_MATCH_SELECT, T_PROT_DECL, T_DUMMY_DRIVER, T_GUARD, T_INERTIAL, T_ELEM_RESOLUTION, T_LOOP, T_REPORT, T_PSL_DIRECT, T_PSL_FCALL, T_PSL_UNION, T_LAST_TREE_KIND } tree_kind_t; typedef enum { TREE_F_LOCALLY_STATIC = (1 << 0), TREE_F_GLOBALLY_STATIC = (1 << 1), TREE_F_CONTINUATION = (1 << 2), TREE_F_IMPURE = (1 << 3), TREE_F_CONVERSION = (1 << 4), TREE_F_POSTPONED = (1 << 5), TREE_F_SHARED = (1 << 6), TREE_F_BUS = (1 << 7), TREE_F_REGISTER = (1 << 8), TREE_F_ELIDE_BOUNDS = (1 << 9), TREE_F_KNOWS_SUBTYPE = (1 << 10), TREE_F_FORMAL_NAME = (1 << 11), TREE_F_SYNTHETIC_NAME = (1 << 12), TREE_F_PREDEFINED = (1 << 13), TREE_F_ATTR_PREFIX = (1 << 14), TREE_F_EXPLICIT_CLASS = (1 << 15), TREE_F_EXPLICIT_MODE = (1 << 16), TREE_F_PROTECTED = (1 << 17), TREE_F_STATIC_WAIT = (1 << 18), TREE_F_NONOBJECT_ALIAS = (1 << 19), TREE_F_NEVER_WAITS = (1 << 20), TREE_F_HAS_WAIT = (1 << 21), TREE_F_IMPURE_FILE = (1 << 22), TREE_F_IMPURE_SHARED = (1 << 23), TREE_F_CALL_NO_ARGS = (1 << 24), } tree_flags_t; typedef enum { TREE_GF_INSTANCE_NAME = (1 << 0), TREE_GF_PATH_NAME = (1 << 1), TREE_GF_DEFERRED_INST = (1 << 2), TREE_GF_EXTERNAL_NAME = (1 << 3), } tree_global_flags_t; tree_t tree_new(tree_kind_t kind); tree_kind_t tree_kind(tree_t t); void tree_change_kind(tree_t t, tree_kind_t kind); const char *tree_kind_str(tree_kind_t t); const loc_t *tree_loc(tree_t t); void tree_set_loc(tree_t t, const loc_t *loc); // See `has_map' in tree.c for definition of which fields each tree // kind contains type_t tree_type(tree_t t); void tree_set_type(tree_t t, type_t ty); bool tree_has_type(tree_t t); ident_t tree_ident(tree_t t); void tree_set_ident(tree_t t, ident_t i); bool tree_has_ident(tree_t t); ident_t tree_ident2(tree_t t); void tree_set_ident2(tree_t t, ident_t i); bool tree_has_ident2(tree_t t); unsigned tree_ports(tree_t t); tree_t tree_port(tree_t t, unsigned n); void tree_add_port(tree_t t, tree_t d); tree_t tree_file_mode(tree_t t); void tree_set_file_mode(tree_t t, tree_t m); unsigned tree_generics(tree_t t); tree_t tree_generic(tree_t t, unsigned n); void tree_add_generic(tree_t t, tree_t d); unsigned tree_genmaps(tree_t t); tree_t tree_genmap(tree_t t, unsigned n); void tree_add_genmap(tree_t t, tree_t e); void tree_trim_genmaps(tree_t t, unsigned n); unsigned tree_params(tree_t t); tree_t tree_param(tree_t t, unsigned n); void tree_add_param(tree_t t, tree_t e); int64_t tree_ival(tree_t t); void tree_set_ival(tree_t t, int64_t i); double tree_dval(tree_t t); void tree_set_dval(tree_t t, double d); bool tree_has_value(tree_t t); tree_t tree_value(tree_t t); void tree_set_value(tree_t t, tree_t v); bool tree_has_result(tree_t t); tree_t tree_result(tree_t t); void tree_set_result(tree_t t, tree_t v); unsigned tree_waveforms(tree_t t); tree_t tree_waveform(tree_t t, unsigned n); void tree_add_waveform(tree_t t, tree_t w); unsigned tree_decls(tree_t t); tree_t tree_decl(tree_t t, unsigned n); void tree_add_decl(tree_t t, tree_t d); unsigned tree_stmts(tree_t t); tree_t tree_stmt(tree_t t, unsigned n); void tree_add_stmt(tree_t t, tree_t d); unsigned tree_conds(tree_t t); tree_t tree_cond(tree_t t, unsigned n); void tree_add_cond(tree_t t, tree_t d); bool tree_has_delay(tree_t t); tree_t tree_delay(tree_t t); void tree_set_delay(tree_t t, tree_t d); unsigned tree_triggers(tree_t t); tree_t tree_trigger(tree_t t, unsigned n); void tree_add_trigger(tree_t t, tree_t s); tree_t tree_target(tree_t t); void tree_set_target(tree_t t, tree_t lhs); tree_t tree_ref(tree_t t); bool tree_has_ref(tree_t t); void tree_set_ref(tree_t t, tree_t decl); unsigned tree_contexts(tree_t t); tree_t tree_context(tree_t t, unsigned n); void tree_add_context(tree_t t, tree_t ctx); unsigned tree_pragmas(tree_t t); tree_t tree_pragma(tree_t t, unsigned n); void tree_add_pragma(tree_t t, tree_t p); unsigned tree_assocs(tree_t t); tree_t tree_assoc(tree_t t, unsigned n); void tree_add_assoc(tree_t t, tree_t a); tree_t tree_severity(tree_t t); bool tree_has_severity(tree_t t); void tree_set_severity(tree_t t, tree_t s); tree_t tree_message(tree_t t); bool tree_has_message(tree_t t); void tree_set_message(tree_t t, tree_t m); unsigned tree_pos(tree_t t); void tree_set_pos(tree_t t, unsigned pos); tree_t tree_left(tree_t t); void tree_set_left(tree_t t, tree_t left); tree_t tree_right(tree_t t); void tree_set_right(tree_t t, tree_t right); unsigned tree_subkind(tree_t t); void tree_set_subkind(tree_t t, unsigned sub); void tree_add_range(tree_t t, tree_t r); tree_t tree_range(tree_t t, unsigned n); unsigned tree_ranges(tree_t t); class_t tree_class(tree_t t); void tree_set_class(tree_t t, class_t c); tree_t tree_reject(tree_t t); void tree_set_reject(tree_t t, tree_t r); bool tree_has_reject(tree_t t); tree_t tree_guard(tree_t t); void tree_set_guard(tree_t t, tree_t g); bool tree_has_guard(tree_t t); tree_t tree_name(tree_t t); void tree_set_name(tree_t t, tree_t n); bool tree_has_name(tree_t t); tree_t tree_spec(tree_t t); bool tree_has_spec(tree_t t); void tree_set_spec(tree_t t, tree_t s); unsigned tree_chars(tree_t t); tree_t tree_char(tree_t t, unsigned n); void tree_add_char(tree_t t, tree_t ref); unsigned tree_parts(tree_t t); tree_t tree_part(tree_t t, unsigned n); void tree_add_part(tree_t t, tree_t ref); tree_flags_t tree_flags(tree_t t); void tree_set_flag(tree_t t, tree_flags_t mask); void tree_clear_flag(tree_t t, tree_flags_t mask); tree_t tree_primary(tree_t t); bool tree_has_primary(tree_t t); void tree_set_primary(tree_t t, tree_t unit); psl_node_t tree_psl(tree_t t); bool tree_has_psl(tree_t t); void tree_set_psl(tree_t t, psl_node_t p); vlog_node_t tree_vlog(tree_t t); void tree_set_vlog(tree_t t, vlog_node_t v); typedef void (*tree_visit_fn_t)(tree_t t, void *context); unsigned tree_visit(tree_t t, tree_visit_fn_t fn, void *context); unsigned tree_visit_only(tree_t t, tree_visit_fn_t fn, void *context, tree_kind_t kind); typedef void (*tree_rewrite_pre_fn_t)(tree_t t, void *context); typedef tree_t (*tree_rewrite_post_fn_t)(tree_t t, void *context); typedef type_t (*type_rewrite_post_fn_t)(type_t t, void *context); tree_t tree_rewrite(tree_t t, tree_rewrite_pre_fn_t pre_fn, tree_rewrite_post_fn_t tree_post_fn, type_rewrite_post_fn_t type_post_fn, void *context); typedef bool (*tree_copy_pred_t)(tree_t, void *); typedef bool (*type_copy_pred_t)(type_t, void *); typedef void (*tree_copy_fn_t)(tree_t, void *); typedef void (*type_copy_fn_t)(type_t, void *); void tree_copy(tree_t *roots, unsigned nroots, tree_copy_pred_t tree_pred, type_copy_pred_t type_pred, void *pred_context, tree_copy_fn_t tree_callback, type_copy_fn_t type_callback, void *callback_context); typedef tree_t (*tree_load_fn_t)(ident_t); typedef void (*tree_deps_fn_t)(ident_t, void *); object_arena_t *tree_arena(tree_t t); tree_t tree_container(tree_t t); bool tree_frozen(tree_t t); void tree_walk_deps(tree_t t, tree_deps_fn_t fn, void *ctx); object_t *tree_to_object(tree_t t); tree_t tree_from_object(object_t *obj); tree_global_flags_t tree_global_flags(tree_t t); void tree_set_global_flags(tree_t t, tree_global_flags_t flags); #endif // _TREE_H nvc-r1.17.1/src/type.c000066400000000000000000000630661504111170000144660ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "type.h" #include "tree.h" #include "util.h" #include "common.h" #include "object.h" #include "hash.h" #include #include #include #include #include #include static const imask_t has_map[T_LAST_TYPE_KIND] = { // T_SUBTYPE (I_IDENT | I_BASE | I_RESOLUTION | I_CONSTRAINT | I_ELEM), // T_INTEGER (I_IDENT | I_DIMS), // T_REAL (I_IDENT | I_DIMS), // T_ENUM (I_IDENT | I_LITERALS | I_DIMS), // T_PHYSICAL (I_IDENT | I_UNITS | I_DIMS), // T_ARRAY (I_IDENT | I_INDEXES | I_ELEM), // T_RECORD (I_IDENT | I_FIELDS), // T_FILE (I_IDENT | I_DESIGNATED), // T_ACCESS (I_IDENT | I_DESIGNATED), // T_INCOMPLETE (I_IDENT), // T_NONE (I_IDENT), // T_PROTECTED (I_IDENT | I_FIELDS), // T_GENERIC (I_IDENT | I_SUBKIND | I_DESIGNATED | I_INDEXES | I_ELEM), // T_VIEW (I_IDENT | I_DESIGNATED | I_FIELDS), // T_SIGNATURE (I_IDENT | I_PARAMS | I_RESULT), }; static const char *kind_text_map[T_LAST_TYPE_KIND] = { "T_SUBTYPE", "T_INTEGER", "T_REAL", "T_ENUM", "T_PHYSICAL", "T_ARRAY", "T_RECORD", "T_FILE", "T_ACCESS", "T_INCOMPLETE", "T_NONE", "T_PROTECTED", "T_GENERIC", "T_VIEW", "T_SIGNATURE", }; static const change_allowed_t change_allowed[] = { { -1, -1 } }; struct _type { object_t object; }; struct _tree { object_t object; }; object_class_t type_object = { .name = "type", .change_allowed = change_allowed, .has_map = has_map, .kind_text_map = kind_text_map, .tag = OBJECT_TAG_TYPE, .last_kind = T_LAST_TYPE_KIND }; extern object_arena_t *global_arena; static inline tree_t tree_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _tree, object); } static inline void tree_array_add(item_t *item, tree_t t) { obj_array_add(&(item->obj_array), &(t->object)); } static inline type_t type_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _type, object); } static inline void type_array_add(item_t *item, type_t t) { obj_array_add(&(item->obj_array), &(t->object)); } type_t type_new(type_kind_t kind) { object_t *o = object_new(NULL, &type_object, kind); return container_of(o, struct _type, object); } type_kind_t type_kind(type_t t) { assert(t != NULL); return t->object.kind; } static inline type_t type_base_map(type_t t, hash_t *map) { assert(t->object.kind == T_SUBTYPE); type_t base = type_base(t); if (map != NULL) return hash_get(map, base) ?: base; else return base; } static inline type_t type_result_or_null(type_t t) { item_t *item = lookup_item(&type_object, t, I_RESULT); if (item->object == NULL) return NULL; else return container_of(item->object, struct _type, object); } static bool _type_eq(type_t a, type_t b, bool strict, hash_t *map) { assert(a != NULL); assert(b != NULL); if (a == b) return true; type_kind_t kind_a = a->object.kind; type_kind_t kind_b = b->object.kind; if (map != NULL) { a = hash_get(map, a) ?: a; kind_a = a->object.kind; b = hash_get(map, b) ?: b; kind_b = b->object.kind; if (a == b) return true; } if (!strict) { // Subtypes are convertible to the base type while ((kind_a = a->object.kind) == T_SUBTYPE) a = type_base_map(a, map); while ((kind_b = b->object.kind) == T_SUBTYPE) b = type_base_map(b, map); if (a == b) return true; } const imask_t has = has_map[a->object.kind]; if (!(has & I_PARAMS)) { ident_t ai = lookup_item(&type_object, a, I_IDENT)->ident; ident_t bi = lookup_item(&type_object, b, I_IDENT)->ident; if (ai != bi) return false; else if (ai == NULL && kind_a == T_GENERIC) return false; // Anonymous generic types are distinct } if (kind_a == T_INCOMPLETE || kind_b == T_INCOMPLETE) return true; if (kind_a != kind_b) return false; if (kind_a == T_ARRAY) return _type_eq(type_elem(a), type_elem(b), strict, map); if (kind_a == T_ACCESS) return _type_eq(type_designated(a), type_designated(b), strict, map); if ((has & I_DIMS) && (type_dims(a) != type_dims(b))) return false; if (kind_a == T_SIGNATURE) { type_t ra = type_result_or_null(a); type_t rb = type_result_or_null(b); if (ra != NULL && rb != NULL) { if (!_type_eq(ra, rb, strict, map)) return false; } else if (ra != NULL || rb != NULL) return false; } if (has & I_PARAMS) { item_t *ap = lookup_item(&type_object, a, I_PARAMS); item_t *bp = lookup_item(&type_object, b, I_PARAMS); const int acount = obj_array_count(ap->obj_array); const int bcount = obj_array_count(bp->obj_array); if (acount != bcount) return false; for (int i = 0; i < acount; i++) { type_t ai = type_array_nth(ap, i); type_t bi = type_array_nth(bp, i); if (ai != bi && !_type_eq(ai, bi, strict, map)) return false; } } return true; } bool type_strict_eq(type_t a, type_t b) { return _type_eq(a, b, true, NULL); } bool type_eq(type_t a, type_t b) { return _type_eq(a, b, false, NULL); } bool type_eq_map(type_t a, type_t b, hash_t *map) { return _type_eq(a, b, false, map); } ident_t type_ident(type_t t) { assert(t != NULL); item_t *item = lookup_item(&type_object, t, I_IDENT); if (item->ident == NULL) { switch (t->object.kind) { case T_SUBTYPE: return type_ident(type_base(t)); case T_NONE: return ident_new("none"); case T_GENERIC: return ident_new("anonymous"); default: fatal_trace("type kind %s has no ident", type_kind_str(t->object.kind)); } } else return item->ident; } bool type_has_ident(type_t t) { assert(t != NULL); return (lookup_item(&type_object, t, I_IDENT)->ident != NULL); } void type_set_ident(type_t t, ident_t id) { assert(t != NULL); lookup_item(&type_object, t, I_IDENT)->ident = id; } unsigned type_dims(type_t t) { item_t *item = lookup_item(&type_object, t, I_DIMS); return obj_array_count(item->obj_array); } tree_t type_dim(type_t t, unsigned n) { item_t *item = lookup_item(&type_object, t, I_DIMS); return tree_array_nth(item, n); } void type_add_dim(type_t t, tree_t r) { tree_array_add(lookup_item(&type_object, t, I_DIMS), r); object_write_barrier(&(t->object), &(r->object)); } type_t type_base(type_t t) { item_t *item = lookup_item(&type_object, t, I_BASE); assert(item->object != NULL); return container_of(item->object, struct _type, object); } void type_set_base(type_t t, type_t b) { lookup_item(&type_object, t, I_BASE)->object = &(b->object); object_write_barrier(&(t->object), &(b->object)); } type_t type_elem(type_t t) { assert(t != NULL); if (t->object.kind == T_NONE) return t; else { item_t *item = lookup_item(&type_object, t, I_ELEM); if (t->object.kind == T_SUBTYPE && item->object == NULL) return type_elem(type_base(t)); else { assert(item->object != NULL); return container_of(item->object, struct _type, object); } } } void type_set_elem(type_t t, type_t e) { lookup_item(&type_object, t, I_ELEM)->object = &(e->object); object_write_barrier(&(t->object), &(e->object)); } bool type_has_elem(type_t t) { return lookup_item(&type_object, t, I_ELEM)->object != NULL; } unsigned type_subkind(type_t t) { item_t *item = lookup_item(&type_object, t, I_SUBKIND); return item->ival; } void type_set_subkind(type_t t, unsigned sub) { lookup_item(&type_object, t, I_SUBKIND)->ival = sub; } bool type_is_universal(type_t t) { assert(t != NULL); switch (t->object.kind) { case T_INTEGER: return t == std_type(NULL, STD_UNIVERSAL_INTEGER); case T_REAL: return t == std_type(NULL, STD_UNIVERSAL_REAL); default: return false; } } unsigned type_units(type_t t) { item_t *item = lookup_item(&type_object, t, I_UNITS); return obj_array_count(item->obj_array); } tree_t type_unit(type_t t, unsigned n) { item_t *item = lookup_item(&type_object, t, I_UNITS); return tree_array_nth(item, n); } void type_add_unit(type_t t, tree_t u) { tree_array_add(lookup_item(&type_object, t, I_UNITS), u); object_write_barrier(&(t->object), &(u->object)); } unsigned type_enum_literals(type_t t) { item_t *item = lookup_item(&type_object, t, I_LITERALS); return obj_array_count(item->obj_array); } tree_t type_enum_literal(type_t t, unsigned n) { item_t *item = lookup_item(&type_object, t, I_LITERALS); return tree_array_nth(item, n); } void type_enum_add_literal(type_t t, tree_t lit) { assert(tree_kind(lit) == T_ENUM_LIT); tree_array_add(lookup_item(&type_object, t, I_LITERALS), lit); object_write_barrier(&(t->object), &(lit->object)); } unsigned type_params(type_t t) { item_t *item = lookup_item(&type_object, t, I_PARAMS); return obj_array_count(item->obj_array); } type_t type_param(type_t t, unsigned n) { item_t *item = lookup_item(&type_object, t, I_PARAMS); return type_array_nth(item, n); } void type_add_param(type_t t, type_t p) { type_array_add(lookup_item(&type_object, t, I_PARAMS), p); object_write_barrier(&(t->object), &(p->object)); } unsigned type_fields(type_t t) { if (t->object.kind == T_SUBTYPE) return type_fields(type_base(t)); else { item_t *item = lookup_item(&type_object, t, I_FIELDS); return obj_array_count(item->obj_array); } } tree_t type_field(type_t t, unsigned n) { if (t->object.kind == T_SUBTYPE) return type_field(type_base(t), n); else { item_t *item = lookup_item(&type_object, t, I_FIELDS); return tree_array_nth(item, n); } } void type_add_field(type_t t, tree_t p) { tree_array_add(lookup_item(&type_object, t, I_FIELDS), p); object_write_barrier(&(t->object), &(p->object)); } type_t type_result(type_t t) { item_t *item = lookup_item(&type_object, t, I_RESULT); assert(item->object != NULL); return container_of(item->object, struct _type, object); } bool type_has_result(type_t t) { return lookup_item(&type_object, t, I_RESULT)->object != NULL; } void type_set_result(type_t t, type_t r) { lookup_item(&type_object, t, I_RESULT)->object = &(r->object); object_write_barrier(&(t->object), &(r->object)); } unsigned type_indexes(type_t t) { item_t *item = lookup_item(&type_object, t, I_INDEXES); return obj_array_count(item->obj_array); } void type_add_index(type_t t, type_t sub) { type_array_add(lookup_item(&type_object, t, I_INDEXES), sub); object_write_barrier(&(t->object), &(sub->object)); } type_t type_index(type_t t, unsigned n) { item_t *item = lookup_item(&type_object, t, I_INDEXES); return type_array_nth(item, n); } tree_t type_constraint(type_t t) { item_t *item = lookup_item(&type_object, t, I_CONSTRAINT); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } bool type_has_constraint(type_t t) { item_t *item = lookup_item(&type_object, t, I_CONSTRAINT); return item->object != NULL; } void type_set_constraint(type_t t, tree_t c) { assert(c->object.kind == T_CONSTRAINT); lookup_item(&type_object, t, I_CONSTRAINT)->object = &(c->object); object_write_barrier(&(t->object), &(c->object)); } void type_set_resolution(type_t t, tree_t r) { lookup_item(&type_object, t, I_RESOLUTION)->object = &(r->object); object_write_barrier(&(t->object), &(r->object)); } bool type_has_resolution(type_t t) { return lookup_item(&type_object, t, I_RESOLUTION)->object != NULL; } tree_t type_resolution(type_t t) { item_t *item = lookup_item(&type_object, t, I_RESOLUTION); assert(item->object != NULL); return container_of(item->object, struct _tree, object); } type_t type_designated(type_t t) { if (t->object.kind == T_SUBTYPE) return type_designated(type_base(t)); else { item_t *item = lookup_item(&type_object, t, I_DESIGNATED); assert(item->object != NULL); return container_of(item->object, struct _type, object); } } void type_set_designated(type_t t, type_t d) { lookup_item(&type_object, t, I_DESIGNATED)->object = &(d->object); object_write_barrier(&(t->object), &(d->object)); } void type_signature(type_t t, text_buf_t *tb) { assert(t->object.kind == T_SIGNATURE); tb_printf(tb, "["); const int nparams = type_params(t); for (int i = 0; i < nparams; i++) tb_printf(tb, "%s%s", (i == 0 ? "" : ", "), type_pp(type_param(t, i))); type_t r = type_result_or_null(t); if (r != NULL) tb_printf(tb, "%sreturn %s", nparams > 0 ? " " : "", type_pp(r)); tb_printf(tb, "]"); } const char *type_pp2(type_t t, type_t other) { assert(t != NULL); switch (type_kind(t)) { case T_SIGNATURE: { static hash_t *cache = NULL; if (cache == NULL) cache = hash_new(64); text_buf_t *tb = hash_get(cache, t); if (tb == NULL) { tb = tb_new(); hash_put(cache, t, tb); if (type_has_ident(t)) { tb_istr(tb, type_ident(t)); tb_append(tb, ' '); } type_signature(t, tb); } return tb_get(tb); } case T_GENERIC: if (!type_has_ident(t)) return "(an anonymous type)"; // Fall-through default: { const char *full1 = istr(type_ident(t)); const char *dot1 = strrchr(full1, '.'); const char *tail1 = dot1 ? dot1 + 1 : full1; if (other != NULL) { const char *full2 = istr(type_ident(other)); const char *dot2 = strrchr(full2, '.'); const char *tail2 = dot2 ? dot2 + 1 : full2; return strcmp(tail1, tail2) ? tail1 : full1; } else return tail1; } } } const char *type_pp(type_t t) { return type_pp2(t, NULL); } type_kind_t type_base_kind(type_t t) { assert(t != NULL); if (t->object.kind == T_SUBTYPE) return type_base_kind(type_base(t)); else return t->object.kind; } bool type_is_array(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_ARRAY; else return base == T_ARRAY; } bool type_is_record(type_t t) { return type_base_kind(t) == T_RECORD; } bool type_is_protected(type_t t) { return type_base_kind(t) == T_PROTECTED; } bool type_is_file(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_FILE; else return base == T_FILE; } bool type_is_access(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_ACCESS; else return base == T_ACCESS; } bool type_is_incomplete(type_t t) { return type_base_kind(t) == T_INCOMPLETE; } bool type_is_none(type_t t) { return type_base_kind(t) == T_NONE; } bool type_is_valid(type_t t) { return type_base_kind(t) != T_NONE; } bool type_has_error(type_t t) { switch (t->object.kind) { case T_NONE: return true; case T_SIGNATURE: { type_t r = type_result_or_null(t); if (r != NULL && type_is_none(r)) return true; const int nparams = type_params(t); for (int i = 0; i < nparams; i++) { if (type_is_none(type_param(t, i))) return true; } return false; } case T_SUBTYPE: return type_is_none(type_base(t)); default: return false; } } tree_t type_constraint_for_field(type_t t, tree_t f) { if (t->object.kind != T_SUBTYPE) return NULL; else if (!type_has_constraint(t)) return NULL; tree_t c = type_constraint(t); if (tree_subkind(c) != C_RECORD) return NULL; const int nelem = tree_ranges(c); for (int i = 0; i < nelem; i++) { tree_t ei = tree_range(c, i); assert(tree_kind(ei) == T_ELEM_CONSTRAINT); if (tree_has_ref(ei) && tree_ref(ei) == f) return ei; } return type_constraint_for_field(type_base(t), f); } bool type_is_unconstrained(type_t t) { assert(t != NULL); if (t->object.kind == T_SUBTYPE) { if (type_is_record(t)) { if (standard() >= STD_08) { const int nfields = type_fields(t); for (int i = 0; i < nfields; i++) { tree_t f = type_field(t, i); if (!type_is_unconstrained(tree_type(f))) continue; tree_t ec = type_constraint_for_field(t, f); if (ec == NULL || type_is_unconstrained(tree_type(ec))) return true; } } return false; } else if (type_is_array(t)) { if (standard() >= STD_08) { if (type_is_array(t)) { type_t elem = type_elem(t); if (type_is_unconstrained(elem)) return true; } } for (; t->object.kind == T_SUBTYPE; t = type_base(t)) { if (type_has_constraint(t)) { tree_t c = type_constraint(t); if (tree_subkind(c) == C_INDEX) return false; } } assert(t->object.kind == T_ARRAY); return true; } else return false; } else if (t->object.kind == T_ARRAY) return true; else if (t->object.kind == T_GENERIC && type_subkind(t) == GTYPE_ARRAY) return true; else if (t->object.kind == T_RECORD && standard() >= STD_08) { const int nfields = type_fields(t); for (int i = 0; i < nfields; i++) { if (type_is_unconstrained(tree_type(type_field(t, i)))) return true; } return false; } else return false; } bool type_is_enum(type_t t) { return type_base_kind(t) == T_ENUM; } bool type_is_discrete(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) { const gtype_class_t class = type_subkind(type_base_recur(t)); return class == GTYPE_INTEGER || class == GTYPE_DISCRETE; } else return base == T_INTEGER || base == T_ENUM; } bool type_is_numeric(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) { const gtype_class_t class = type_subkind(type_base_recur(t)); return class == GTYPE_INTEGER || class == GTYPE_FLOATING; } else return base == T_INTEGER || base == T_REAL; } bool type_is_subprogram(type_t t) { return t->object.kind == T_SIGNATURE; } bool type_is_physical(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_PHYSICAL; else return base == T_PHYSICAL; } bool type_is_integer(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_INTEGER; else return base == T_INTEGER; } bool type_is_real(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) return type_subkind(type_base_recur(t)) == GTYPE_FLOATING; else return base == T_REAL; } bool type_is_generic(type_t t) { return type_base_kind(t) == T_GENERIC; } bool type_is_scalar(type_t t) { const type_kind_t base = type_base_kind(t); if (base == T_GENERIC) { const gtype_class_t class = type_subkind(type_base_recur(t)); return class == GTYPE_SCALAR || class == GTYPE_DISCRETE || class == GTYPE_FLOATING || class == GTYPE_INTEGER; } else return base == T_INTEGER || base == T_REAL || base == T_ENUM || base == T_PHYSICAL || base == T_NONE; } bool type_is_representable(type_t t) { if (type_is_scalar(t)) return true; else if (standard() < STD_19) { if (type_is_array(t) && dimension_of(t) == 1) { type_t elem = type_elem(t); return type_is_enum(elem) && all_character_literals(elem); } else return false; } else if (type_is_record(t)) { const int nfields = type_fields(t); for (int i = 0; i < nfields; i++) { if (!type_is_representable(tree_type(type_field(t, i)))) return false; } return true; } else if (type_is_array(t)) return type_is_representable(type_elem(t)); else return false; } bool type_const_bounds(type_t t) { if (type_is_unconstrained(t)) return false; else if (type_is_record(t)) { const int nfields = type_fields(t); for (int i = 0; i < nfields; i++) { type_t ftype = tree_type(type_field(t, i)); if (!type_const_bounds(ftype)) return false; } return true; } else if (type_is_array(t)) { const int ndims = dimension_of(t); for (int i = 0; i < ndims; i++) { int64_t low, high; if (!folded_bounds(range_of(t, i), &low, &high)) return false; } return type_const_bounds(type_elem(t)); } else if (type_is_integer(t)) { int64_t low, high; return folded_bounds(range_of(t, 0), &low, &high); } else return true; } type_t type_base_recur(type_t t) { assert(t != NULL); while (t->object.kind == T_SUBTYPE) t = type_base(t); return t; } type_t type_elem_recur(type_t type) { while (type_is_array(type)) type = type_elem(type); return type; } const char *type_kind_str(type_kind_t t) { assert(t < T_LAST_TYPE_KIND); return kind_text_map[t]; } unsigned type_width(type_t type) { if (type_is_array(type)) { const unsigned elem_w = type_width(type_elem(type)); unsigned w = 1; const int ndims = dimension_of(type); for (int i = 0; i < ndims; i++) { int64_t low, high; range_bounds(range_of(type, i), &low, &high); w *= MAX(high - low + 1, 0); } return w * elem_w; } else { type_is_scalar(type); return 1; } } bool type_is_composite(type_t t) { const type_kind_t base = type_base_kind(t); return base == T_ARRAY || base == T_RECORD; } bool type_is_homogeneous(type_t t) { if (type_is_scalar(t)) return true; else if (type_is_array(t)) return type_is_homogeneous(type_elem(t)); else return false; } bool type_is_resolved(type_t t) { if (t->object.kind == T_SUBTYPE) return type_has_resolution(t) || type_is_resolved(type_base(t)); else return false; } bool type_frozen(type_t t) { return arena_frozen(object_arena(&(t->object))); } tree_t type_container(type_t t) { object_t *o = arena_root(object_arena(&(t->object))); assert(o->tag == OBJECT_TAG_TREE); return container_of(o, struct _tree, object); } object_t *type_to_object(type_t t) { return t ? &(t->object) : NULL; } type_t type_from_object(object_t *obj) { assert(obj->tag == OBJECT_TAG_TYPE); return container_of(obj, struct _type, object); } int type_bit_width(type_t type) { switch (type_kind(type)) { case T_INTEGER: case T_PHYSICAL: { tree_t r = range_of(type, 0); return bits_for_range(assume_int(tree_left(r)), assume_int(tree_right(r))); } case T_REAL: // All real types are doubles at the moment return 64; case T_SUBTYPE: return type_bit_width(type_base(type)); case T_ENUM: return bits_for_range(0, type_enum_literals(type) - 1); case T_ARRAY: return type_bit_width(type_elem(type)); default: fatal_trace("unhandled type %s in type_bit_width", type_pp(type)); } } int type_byte_width(type_t type) { return (type_bit_width(type) + 7) / 8; } bool type_is_character_array(type_t t) { // LRM 93 section 3.1.1 an enumeration type is a character type if at // least one of its enumeration literals is a character literal if (!type_is_array(t)) return false; if (dimension_of(t) != 1) return false; type_t elem = type_base_recur(type_elem(t)); if (!type_is_enum(elem)) return false; const int nlits = type_enum_literals(elem); for (int i = 0; i < nlits; i++) { tree_t lit = type_enum_literal(elem, i); if (ident_char(tree_ident(lit), 0) == '\'') return true; } return false; } bool type_matches_class(type_t t, gtype_class_t class) { switch (class) { case GTYPE_PRIVATE: return true; case GTYPE_SCALAR: return type_is_scalar(t); case GTYPE_DISCRETE: return type_is_discrete(t); case GTYPE_INTEGER: return type_is_integer(t); case GTYPE_FLOATING: return type_is_real(t); case GTYPE_PHYSICAL: return type_is_physical(t); case GTYPE_ACCESS: return type_is_access(t); case GTYPE_ARRAY: return type_is_array(t); case GTYPE_FILE: return type_is_file(t); default: return false; } } nvc-r1.17.1/src/type.h000066400000000000000000000111411504111170000144560ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _TYPE_H #define _TYPE_H #include #include "ident.h" #include "prim.h" typedef enum { T_SUBTYPE, T_INTEGER, T_REAL, T_ENUM, T_PHYSICAL, T_ARRAY, T_RECORD, T_FILE, T_ACCESS, T_INCOMPLETE, T_NONE, T_PROTECTED, T_GENERIC, T_VIEW, T_SIGNATURE, T_LAST_TYPE_KIND } type_kind_t; typedef enum { GTYPE_PRIVATE, GTYPE_SCALAR, GTYPE_DISCRETE, GTYPE_INTEGER, GTYPE_PHYSICAL, GTYPE_FLOATING, GTYPE_ARRAY, GTYPE_ACCESS, GTYPE_FILE, } gtype_class_t; type_t type_new(type_kind_t kind); type_kind_t type_kind(type_t t); const char *type_kind_str(type_kind_t t); bool type_eq(type_t a, type_t b); bool type_strict_eq(type_t a, type_t b); bool type_eq_map(type_t a, type_t b, hash_t *map); // See `has_map' in type.c for definition of which fields each type // kind contains ident_t type_ident(type_t t); void type_set_ident(type_t t, ident_t id); bool type_has_ident(type_t t); type_t type_base(type_t t); void type_set_base(type_t t, type_t b); type_t type_elem(type_t t); void type_set_elem(type_t t, type_t e); bool type_has_elem(type_t t); unsigned type_subkind(type_t t); void type_set_subkind(type_t t, unsigned subkind); unsigned type_dims(type_t t); tree_t type_dim(type_t t, unsigned n); void type_add_dim(type_t t, tree_t r); unsigned type_enum_literals(type_t t); tree_t type_enum_literal(type_t t, unsigned n); void type_enum_add_literal(type_t t, tree_t lit); unsigned type_units(type_t t); tree_t type_unit(type_t t, unsigned n); void type_add_unit(type_t t, tree_t u); unsigned type_params(type_t t); type_t type_param(type_t t, unsigned n); void type_add_param(type_t t, type_t p); type_t type_result(type_t t); bool type_has_result(type_t t); void type_set_result(type_t t, type_t r); type_t type_designated(type_t t); void type_set_designated(type_t t, type_t a); unsigned type_indexes(type_t t); void type_add_index(type_t t, type_t sub); type_t type_index(type_t t, unsigned n); tree_t type_constraint(type_t t); bool type_has_constraint(type_t t); void type_set_constraint(type_t t, tree_t c); unsigned type_fields(type_t t); tree_t type_field(type_t t, unsigned n); void type_add_field(type_t t, tree_t e); void type_set_resolution(type_t t, tree_t r); bool type_has_resolution(type_t t); tree_t type_resolution(type_t t); // Pretty printing const char *type_pp(type_t t); const char *type_pp2(type_t t, type_t other); void type_signature(type_t t, text_buf_t *tb); // Type predicates that recurse to base of subtypes bool type_is_array(type_t t); bool type_is_record(type_t t); bool type_is_unconstrained(type_t t); bool type_is_enum(type_t t); bool type_is_integer(type_t t); bool type_is_real(type_t t); bool type_is_generic(type_t t); bool type_is_scalar(type_t t); bool type_is_representable(type_t t); bool type_is_file(type_t t); bool type_is_protected(type_t t); bool type_is_access(type_t t); bool type_is_incomplete(type_t t); bool type_is_none(type_t t); bool type_is_valid(type_t t); bool type_is_physical(type_t t); bool type_is_discrete(type_t t); bool type_is_subprogram(type_t t); bool type_is_universal(type_t t); bool type_is_composite(type_t t); bool type_is_homogeneous(type_t t); bool type_is_resolved(type_t t); bool type_is_character_array(type_t t); bool type_is_numeric(type_t t); bool type_has_error(type_t t); bool type_const_bounds(type_t t); bool type_matches_class(type_t t, gtype_class_t class); // Helper to find ultimate base type type_t type_base_recur(type_t t); type_kind_t type_base_kind(type_t t); type_t type_elem_recur(type_t t); // Helper function to find number of sub-elemets unsigned type_width(type_t type); // Helpers for element constraints tree_t type_constraint_for_field(type_t t, tree_t f); int type_bit_width(type_t type); int type_byte_width(type_t type); bool type_frozen(type_t t); tree_t type_container(type_t t); object_t *type_to_object(type_t t); type_t type_from_object(object_t *obj); #endif // _TYPE_H nvc-r1.17.1/src/util.c000066400000000000000000001547341504111170000144650ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #if defined(__MINGW32__) #define WINVER 0x0A00 #define _WIN32_WINNT 0x0A00 #include #include #include #include #endif #include "util.h" #include "array.h" #include "cpustate.h" #include "debug.h" #include "diag.h" #include "option.h" #include "thread.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_SYS_PTRACE_H #include #endif #ifdef __APPLE__ #include #include #endif #ifdef __FreeBSD__ #include #endif #ifndef __MINGW32__ #include #include #include #include #include #include #endif #ifdef HAVE_PTHREAD #include #endif #ifdef HAVE_SYS_PRCTL_H #include #endif #ifdef __CYGWIN__ #include #endif #if defined(HAVE_UCONTEXT_H) #include #elif defined(HAVE_SYS_UCONTEXT_H) #include #endif #define N_TRACE_DEPTH 16 #define ERROR_SZ 1024 #define PAGINATE_RIGHT 72 #define TRACE_MAX_LINE 256 #define ANSI_RESET 0 #define ANSI_BOLD 1 #define ANSI_FG_BLACK 30 #define ANSI_FG_RED 31 #define ANSI_FG_GREEN 32 #define ANSI_FG_YELLOW 33 #define ANSI_FG_BLUE 34 #define ANSI_FG_MAGENTA 35 #define ANSI_FG_CYAN 36 #define ANSI_FG_WHITE 37 #define MAX_FMT_BUFS 32 #define MAX_PRINTF_BUFS 8 #define HUGE_PAGE_SIZE 0x200000 #define POOL_MIN_ALIGN sizeof(double) #define POOL_PAGE_4K 12 #define POOL_PAGE_1M 20 #define POOL_PAGE_MIN POOL_PAGE_4K #define POOL_PAGE_MAX POOL_PAGE_1M #if ASAN_ENABLED #define POOL_REDZONE 16 #else #define POOL_REDZONE 0 #endif typedef void (*print_fn_t)(const char *fmt, ...); static char *ansi_vasprintf(const char *fmt, va_list ap, bool force_plain); static void show_bug_report(void); typedef struct _fault_handler fault_handler_t; typedef struct _pool_page pool_page_t; struct color_escape { const char *name; int value; }; struct text_buf { char *buf; size_t alloc; size_t len; }; struct _fault_handler { fault_handler_t *next; fault_fn_t fn; void *context; }; typedef struct _pool_page { pool_page_t *next; size_t alloc; size_t size; uint8_t data[0]; } page_header_t; typedef struct _mem_pool { pool_page_t *pages; size_t pageshift; } mem_pool_t; static bool want_color = false; static bool want_links = false; static bool want_utf8 = false; static message_style_t message_style = MESSAGE_FULL; static sig_atomic_t crashing = SIG_ATOMIC_MAX; static int term_width = 0; static void *ctrl_c_arg = NULL; static fault_handler_t *fault_handlers = NULL; #ifdef __MINGW32__ static UINT win32_codepage = 0; #endif static void (*ctrl_c_fn)(void *) = NULL; static const struct color_escape escapes[] = { { "", ANSI_RESET }, { "bold", ANSI_BOLD }, { "black", ANSI_FG_BLACK }, { "red", ANSI_FG_RED }, { "green", ANSI_FG_GREEN }, { "yellow", ANSI_FG_YELLOW }, { "blue", ANSI_FG_BLUE }, { "magenta", ANSI_FG_MAGENTA }, { "cyan", ANSI_FG_CYAN }, { "white", ANSI_FG_WHITE }, }; void *xmalloc(size_t size) { void *p = malloc(size); if (p == NULL) fatal("memory exhausted (malloc %lu)", (long unsigned)size); return p; } void *xmalloc_flex(size_t fixed, size_t nelems, size_t size) { size_t bytes; if (__builtin_mul_overflow(nelems, size, &bytes)) fatal_trace("array size overflow: requested %zd * %zd bytes", nelems, size); return xmalloc(fixed + bytes); } void *xmalloc_array(size_t nelems, size_t size) { return xmalloc_flex(0, nelems, size); } void *xcalloc(size_t size) { void *p = calloc(1, size); if (p == NULL) fatal("memory exhausted (calloc %lu)", (long unsigned)size); return p; } void *xcalloc_flex(size_t fixed, size_t nelems, size_t size) { size_t bytes; if (__builtin_mul_overflow(nelems, size, &bytes)) fatal_trace("array size overflow: requested %zd * %zd bytes", nelems, size); return xcalloc(fixed + bytes); } void *xcalloc_array(size_t nelems, size_t size) { return xcalloc_flex(0, nelems, size); } void *xrealloc(void *ptr, size_t size) { ptr = realloc(ptr, size); if (ptr == NULL) fatal("memory exhausted (realloc %lu)", (long unsigned)size); return ptr; } void *xrealloc_array(void *ptr, size_t nelems, size_t size) { size_t bytes; if (__builtin_mul_overflow(nelems, size, &bytes)) fatal_trace("array size overflow: requested %zd * %zd bytes", nelems, size); return xrealloc(ptr, bytes); } void *xrealloc_flex(void *ptr, size_t fixed, size_t nelems, size_t size) { size_t bytes; if (__builtin_mul_overflow(nelems, size, &bytes)) fatal_trace("array size overflow: requested %zd * %zd bytes", nelems, size); return xrealloc(ptr, bytes + fixed); } char *xstrdup(const char *str) { char *copy = strdup(str); if (copy == NULL) fatal("memory exhausted (strdup)"); return copy; } char *xstrndup(const char *str, size_t n) { char *copy = strndup(str, n); if (copy == NULL) fatal("memory exhausted (strndup)"); return copy; } char *xvasprintf(const char *fmt, va_list ap) { char *strp = NULL; if (vasprintf(&strp, fmt, ap) < 0) fatal("memory exhausted (vasprintf)"); return strp; } char *xasprintf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *strp = xvasprintf(fmt, ap); va_end(ap); return strp; } void errorf(const char *fmt, ...) { diag_t *d = diag_new(DIAG_ERROR, NULL); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void warnf(const char *fmt, ...) { diag_t *d = diag_new(DIAG_WARN, NULL); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void notef(const char *fmt, ...) { diag_t *d = diag_new(DIAG_NOTE, NULL); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void debugf(const char *fmt, ...) { diag_t *d = diag_new(DIAG_DEBUG, NULL); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } static char *ansi_vasprintf(const char *fmt, va_list ap, bool force_plain) { // Replace color strings like "$red$foo$$bar" with ANSI escaped // strings like "\033[31mfoo\033[0mbar" static int override = 0; if (strchr(fmt, '$') == NULL) return xvasprintf(fmt, ap); LOCAL_TEXT_BUF tb = tb_new(); const char *escape_start = NULL; while (*fmt != '\0') { if (*fmt == '$') { if (escape_start == NULL) escape_start = fmt; else { const char *e = escape_start + 1; size_t len = fmt - e; bool bold; if ((bold = (*e == '!'))) ++e, --len; bool bright; if ((bright = (*e == '+'))) ++e, --len; if ((*e == '<' || *e == '>') && *(e + 1) == '$') { override += *e == '<' ? -1 : 1; escape_start = NULL; } else if (strncmp(e, "link:", 5) == 0) { if (want_links && !force_plain) { tb_cat(tb, "\033]8;;"); tb_catn(tb, e + 5, len - 5); tb_cat(tb, "\033]8;;\07"); } else { const char *bel = strchr(e, '\07'); if (bel && bel < e + len) tb_catn(tb, bel + 1, e + len - bel - 1); } escape_start = NULL; } else if (want_color && !force_plain && override >= 0) { bool found = false; if (*e == '#') { char *eptr; int code = strtoul(e + 1, &eptr, 10); if (eptr == e + len) { if (bold) tb_printf(tb, "\033[1;38;5;%dm", code); else tb_printf(tb, "\033[38;5;%dm", code); found = true; } } else if (strncmp(e, "link:", 5) == 0) { tb_cat(tb, "\033]8;;"); tb_catn(tb, e + 5, len - 5); tb_cat(tb, "\033]8;;\07"); found = true; } for (int i = 0; !found && i < ARRAY_LEN(escapes); i++) { if (strncmp(e, escapes[i].name, len) == 0) { int code = escapes[i].value + (bright ? 60 : 0); if (bold) tb_printf(tb, "\033[1;%dm", code); else tb_printf(tb, "\033[%dm", code); found = true; break; } } if (!found) { tb_catn(tb, escape_start, len + 1 + bold); escape_start = fmt; } else escape_start = NULL; } else escape_start = NULL; } } else if (escape_start == NULL) tb_append(tb, *fmt); ++fmt; } if (escape_start != NULL) tb_cat(tb, escape_start); return xvasprintf(tb_get(tb), ap); } static int color_vfprintf(FILE *f, const char *fmt, va_list ap) { char *strp LOCAL = ansi_vasprintf(fmt, ap, false); bool escape = false; int len = 0; for (const char *p = strp; *p != '\0'; p++) { if (*p == '\033') escape = true; if (escape) escape = (*p != 'm'); else len += 1; } fputs(strp, f); return len; } char *color_vasprintf(const char *fmt, va_list ap) { return ansi_vasprintf(fmt, ap, false); } char *strip_color(const char *fmt, va_list ap) { return ansi_vasprintf(fmt, ap, true); } int color_fprintf(FILE *f, const char *fmt, ...) { va_list ap; va_start(ap, fmt); const int len = color_vfprintf(f, fmt, ap); va_end(ap); return len; } int color_printf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); int rc = color_vprintf(fmt, ap); va_end(ap); return rc; } int color_vprintf(const char *fmt, va_list ap) { return color_vfprintf(stdout, fmt, ap); } char *color_asprintf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *str = ansi_vasprintf(fmt, ap, false); va_end(ap); return str; } bool color_terminal(void) { return want_color; } bool utf8_terminal(void) { return want_utf8; } void print_centred(const char *text) { if (term_width == 0) fputs(text, stdout); else { const int pad = (term_width - strlen(text)) / 2; printf("%*s%s", pad, "", text); } } void fatal_exit(int status) { async_barrier(); if (atomic_load(&crashing) != SIG_ATOMIC_MAX) _exit(status); // Exit during crash else if (!thread_attached() || thread_id() != 0) _exit(status); else exit(status); } void error_at(const loc_t *loc, const char *fmt, ...) { diag_t *d = diag_new(DIAG_ERROR, loc); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void warn_at(const loc_t *loc, const char *fmt, ...) { diag_t *d = diag_new(DIAG_WARN, loc); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void note_at(const loc_t *loc, const char *fmt, ...) { diag_t *d = diag_new(DIAG_NOTE, loc); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_emit(d); } void fatal_at(const loc_t *loc, const char *fmt, ...) { diag_t *d = diag_new(DIAG_FATAL, loc); diag_suppress(d, false); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_set_consumer(NULL, NULL); diag_emit(d); fatal_exit(EXIT_FAILURE); } void fatal(const char *fmt, ...) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_set_consumer(NULL, NULL); diag_emit(d); fatal_exit(EXIT_FAILURE); } void fatal_trace(const char *fmt, ...) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); va_end(ap); diag_set_consumer(NULL, NULL); diag_emit(d); show_stacktrace(); show_bug_report(); fatal_exit(EXIT_FAILURE); } void fatal_errno(const char *fmt, ...) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_suppress(d, false); va_list ap; va_start(ap, fmt); diag_vprintf(d, fmt, ap); diag_printf(d, ": %s", last_os_error()); va_end(ap); diag_set_consumer(NULL, NULL); diag_emit(d); fatal_exit(EXIT_FAILURE); } const char *last_os_error(void) { #ifdef __MINGW32__ static __thread LPSTR mbuf = NULL; if (mbuf != NULL) LocalFree(mbuf); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&mbuf, 0, NULL); return mbuf; #else return strerror(errno); #endif } static void trace_one_frame(uintptr_t pc, const char *module, const char *srcfile, const char *symbol, unsigned lineno, unsigned colno, ptrdiff_t disp, frame_kind_t kind) { color_fprintf(stderr, "[$green$%p$$] ", (void *)pc); if (kind == FRAME_LIB) color_fprintf(stderr, "($red$%s$$) ", module); if (srcfile != NULL) color_fprintf(stderr, "%s:%d ", srcfile, lineno); if (symbol != NULL) { color_fprintf(stderr, "$yellow$%s$$", symbol); if (srcfile == NULL && disp != 0) color_fprintf(stderr, "$yellow$+0x%"PRIxPTR"$$", disp); } if (kind == FRAME_VHDL) color_fprintf(stderr, " $magenta$[VHDL]$$"); fprintf(stderr, "\n"); #ifndef __MINGW32__ if (srcfile != NULL) { FILE *f = fopen(srcfile, "r"); if (f != NULL) { char *line LOCAL = NULL; size_t linesz = 0; for (int i = 0, len; i < lineno + 1 && (len = getline(&line, &linesz, f)) != -1; i++) { if (i < lineno - 2) continue; if (len <= 1) continue; else if (line[len - 1] == '\n') line[len - 1] = '\0'; if (i == lineno - 1) color_fprintf(stderr, "$cyan$$bold$-->$$ $cyan$%s$$\n", line); else color_fprintf(stderr, " $cyan$%s$$\n", line); } fclose(f); } } #endif } __attribute__((noinline)) void show_stacktrace(void) { debug_info_t *di = debug_capture(); const int nframes = debug_count_frames(di); for (int n = 1; n < nframes; n++) { const debug_frame_t *f = debug_get_frame(di, n); for (debug_inline_t *inl = f->inlined; inl != NULL; inl = inl->next) trace_one_frame(f->pc, f->module, inl->srcfile, inl->symbol, inl->lineno, inl->colno, f->disp, f->kind); trace_one_frame(f->pc, f->module, f->srcfile, f->symbol, f->lineno, f->colno, f->disp, f->kind); } debug_free(di); #if defined __linux__ && !defined HAVE_LIBDW && !defined HAVE_LIBDWARF color_fprintf(stderr, "\n$cyan$Hint: you can get better stack traces by " "installing the libdw-dev package and reconfiguring$$\n"); #endif fflush(stderr); } static void show_bug_report(void) { #ifndef DEBUG extern const char version_string[]; color_fprintf(stderr, "\n$!red$%s ["TARGET_SYSTEM"]\n\n" "Please report this bug at "PACKAGE_BUGREPORT"$$\n\n", version_string); fflush(stderr); #endif } #ifdef __MINGW32__ static const char *exception_name(DWORD code) { switch (code) { case EXCEPTION_ACCESS_VIOLATION: return "EXCEPTION_ACCESS_VIOLATION"; case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED"; case EXCEPTION_BREAKPOINT: return "EXCEPTION_BREAKPOINT"; case EXCEPTION_DATATYPE_MISALIGNMENT: return "EXCEPTION_DATATYPE_MISALIGNMENT"; case EXCEPTION_ILLEGAL_INSTRUCTION: return "EXCEPTION_ILLEGAL_INSTRUCTION"; case EXCEPTION_IN_PAGE_ERROR: return "EXCEPTION_IN_PAGE_ERROR"; case EXCEPTION_INT_DIVIDE_BY_ZERO: return "EXCEPTION_INT_DIVIDE_BY_ZERO"; case EXCEPTION_INT_OVERFLOW: return "EXCEPTION_INT_OVERFLOW"; case EXCEPTION_PRIV_INSTRUCTION: return "EXCEPTION_PRIV_INSTRUCTION"; case EXCEPTION_STACK_OVERFLOW: return "EXCEPTION_STACK_OVERFLOW"; } return "???"; } WINAPI static LONG win32_exception_handler(EXCEPTION_POINTERS *ExceptionInfo) { DWORD code = ExceptionInfo->ExceptionRecord->ExceptionCode; PVOID addr = ExceptionInfo->ExceptionRecord->ExceptionAddress; #if defined ARCH_ARM64 DWORD64 ip = ExceptionInfo->ContextRecord->Pc; #elif defined ARCH_X86_64 DWORD64 ip = ExceptionInfo->ContextRecord->Rip; #else DWORD ip = ExceptionInfo->ContextRecord->Eip; #endif if (code == EXCEPTION_ACCESS_VIOLATION) addr = (PVOID)ExceptionInfo->ExceptionRecord->ExceptionInformation[1]; color_fprintf(stderr, "\n$red$$bold$*** Caught exception %x (%s)", (int)code, exception_name(code)); switch (code) { case EXCEPTION_ACCESS_VIOLATION: case EXCEPTION_ILLEGAL_INSTRUCTION: fprintf(stderr, " [address=%p, ip=%p]", (void *)addr, (void*)ip); break; } color_fprintf(stderr, " ***$$\n\n"); fflush(stderr); #ifdef __WIN64 if (code != EXCEPTION_STACK_OVERFLOW) show_stacktrace(); #endif return EXCEPTION_EXECUTE_HANDLER; } #else #ifndef __SANITIZE_THREAD__ static const char *signame(int sig, siginfo_t *info) { switch (sig) { case SIGSEGV: #ifdef __linux__ switch (info->si_code) { case SEGV_MAPERR: return "SEGV_MAPERR"; case SEGV_ACCERR: return "SEGV_ACCERR"; default: return "SIGSEGV"; } #else return "SIGSEGV"; #endif case SIGABRT: return "SIGABRT"; case SIGILL: return "SIGILL"; case SIGFPE: return "SIGFPE"; case SIGUSR1: return "SIGUSR1"; case SIGUSR2: return "SIGUSR2"; case SIGBUS: return "SIGBUS"; case SIGINT: return "SIGINT"; case SIGTRAP: return "SIGTRAP"; default: return "???"; } } static void print_fatal_signal(int sig, siginfo_t *info, struct cpu_state *cpu) { static volatile __thread sig_atomic_t recurse = 0; if (recurse++ > 1) { signal(SIGABRT, SIG_DFL); abort(); } char buf[512], *p = buf, *s = buf, *end = buf + ARRAY_LEN(buf); p += checked_sprintf(p, end - p, "\n%s*** Caught signal %d (%s)%s", want_color ? "\033[31m\033[1m" : "", sig, signame(sig, info), recurse > 1 ? " inside signal handler" : ""); switch (sig) { case SIGSEGV: case SIGILL: case SIGFPE: case SIGBUS: p += checked_sprintf(p, end - p, " [address=%p, ip=%p]", info->si_addr, (void*)cpu->pc); break; } p += checked_sprintf(p, end - p, " ***%s\n\n", want_color ? "\033[0m" : ""); for (int n; s < p && (n = write(STDERR_FILENO, s, p - s)) > 0; s += n); if (sig != SIGUSR1 && !atomic_cas(&crashing, SIG_ATOMIC_MAX, thread_id())) { sleep(60); _exit(EXIT_FAILURE); } } #endif // !__SANITIZE_THREAD__ static __thread struct cpu_state *thread_regs = NULL; static void signal_handler(int sig, siginfo_t *info, void *context) { ucontext_t *uc = (ucontext_t*)context; struct cpu_state cpu; fill_cpu_state(&cpu, uc); struct cpu_state *req; if (sig == SIGUSR2 && (req = atomic_load(&thread_regs)) != NULL) { // Fill in registers for capture_registers *req = cpu; atomic_store(&thread_regs, NULL); return; } else if (sig == SIGINT) { void (*fn)(void *) = atomic_load(&ctrl_c_fn); if (fn != NULL) { (*fn)(ctrl_c_arg); return; } } #ifdef __SANITIZE_THREAD__ abort(); #else for (fault_handler_t *f = fault_handlers; f; f = f->next) (*f->fn)(sig, info->si_addr, &cpu, f->context); print_fatal_signal(sig, info, &cpu); show_stacktrace(); show_bug_report(); if (sig != SIGUSR1) _exit(2); #endif // !__SANITIZE_THREAD__ } #endif // ! __MINGW32__ void register_signal_handlers(void) { #ifdef __MINGW32__ SetUnhandledExceptionFilter(win32_exception_handler); #else struct sigaction sa = { .sa_sigaction = signal_handler, .sa_flags = SA_RESTART | SA_SIGINFO }; sigemptyset(&sa.sa_mask); #ifndef __SANITIZE_THREAD__ sigaction(SIGSEGV, &sa, NULL); sigaction(SIGUSR1, &sa, NULL); sigaction(SIGFPE, &sa, NULL); sigaction(SIGBUS, &sa, NULL); sigaction(SIGILL, &sa, NULL); sigaction(SIGABRT, &sa, NULL); sigaction(SIGTRAP, &sa, NULL); #endif // !__SANITIZE_THREAD__ sigaction(SIGUSR2, &sa, NULL); #endif // !__MINGW32__ } #ifdef __MINGW32__ static BOOL win32_ctrl_c_handler(DWORD fdwCtrlType) { switch (fdwCtrlType) { case CTRL_C_EVENT: { void (*fn)(void *) = atomic_load(&ctrl_c_fn); if (fn != NULL) (*fn)(ctrl_c_arg); return TRUE; } default: return FALSE; } } #endif void set_ctrl_c_handler(void (*fn)(void *), void *arg) { ctrl_c_arg = arg; atomic_store(&ctrl_c_fn, fn); if (fn != NULL) { #ifndef __MINGW32__ struct sigaction sa = {}; sa.sa_sigaction = signal_handler; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART | SA_SIGINFO; sigaction(SIGINT, &sa, NULL); #else if (!SetConsoleCtrlHandler(win32_ctrl_c_handler, TRUE)) fatal_trace("SetConsoleCtrlHandler"); #endif } else { #ifndef __MINGW32__ struct sigaction sa = {}; sa.sa_handler = SIG_DFL; sigaction(SIGINT, &sa, NULL); #else if (!SetConsoleCtrlHandler(win32_ctrl_c_handler, FALSE)) fatal_trace("SetConsoleCtrlHandler"); #endif } } #ifdef __MINGW32__ static void restore_win32_codepage(void) { assert(win32_codepage != 0); SetConsoleOutputCP(win32_codepage); } #endif void term_init(void) { const char *nvc_colors = getenv("NVC_COLORS"); const char *term = getenv("TERM") ?: ""; static const char *term_blacklist[] = { "dumb" }; spin_wait(); // Dummy, to force linking thread.c bool is_tty = isatty(STDERR_FILENO); #ifdef __MINGW32__ if (!is_tty) { // Handle running under MinTty HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); const size_t size = sizeof(FILE_NAME_INFO) + sizeof(WCHAR) * MAX_PATH; FILE_NAME_INFO *nameinfo = malloc(size); if (!GetFileInformationByHandleEx(hStdOut, FileNameInfo, nameinfo, size)) fatal_errno("GetFileInformationByHandle"); if ((wcsncmp(nameinfo->FileName, L"\\msys-", 6) == 0 || wcsncmp(nameinfo->FileName, L"\\cygwin-", 8) == 0) && wcsstr(nameinfo->FileName, L"pty") != NULL) is_tty = true; free(nameinfo); } #endif if (nvc_colors && strcmp(nvc_colors, "always") == 0) want_color = true; else if (nvc_colors && strcmp(nvc_colors, "never") == 0) want_color = false; else { want_color = is_tty; if (want_color && (term != NULL)) { for (size_t i = 0; i < ARRAY_LEN(term_blacklist); i++) { if (strcmp(term, term_blacklist[i]) == 0) { want_color = false; break; } } } } #ifdef __MINGW32__ HANDLE hConsole = GetStdHandle(STD_ERROR_HANDLE); DWORD mode; if (GetConsoleMode(hConsole, &mode)) { mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT; if (!SetConsoleMode(hConsole, mode)) want_color = false; CONSOLE_SCREEN_BUFFER_INFO info; if (GetConsoleScreenBufferInfo(hConsole, &info)) term_width = info.dwSize.X; else term_width = 80; } #else if (is_tty) { // Try to find the terminal size with tcgetwinsize or TIOCGWINSZ term_width = 80; #if defined HAVE_TCGETWINSIZE struct winsize ws; if (tcgetwinsize(STDIN_FILENO, &ws) == 0) term_width = ws.ws_col; #elif defined TIOCGWINSZ struct winsize ws; if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == 0) term_width = ws.ws_col; #endif } #endif #ifndef __MINGW32__ // Only print link escape codes if this is really a terminal want_links = want_color && is_tty; #else want_links = false; // Winpty doesn't recognise these #endif #ifndef __MINGW32__ // Assume the terminal is expecting UTF-8 by default want_utf8 = true; const char *lang = getenv("LANG"); if (lang != NULL && *lang != '\0' && strcasestr(lang, "utf-8") == NULL) want_utf8 = false; #else win32_codepage = GetConsoleOutputCP(); if (win32_codepage == 65001) want_utf8 = true; else if (win32_codepage != 28591) { SetConsoleOutputCP(28591); atexit(restore_win32_codepage); } #endif // Diagnostics are printed to stderr and explicitly flushed setvbuf(stderr, NULL, _IOLBF, BUFSIZ); } int terminal_width(void) { return term_width; } const char *ordinal_str(int n) { switch (n) { case 1: return "first"; case 2: return "second"; case 3: return "third"; default: { static char buf[16]; if (n > 20 && n % 10 == 1) checked_sprintf(buf, sizeof(buf), "%dst", n); else if (n > 20 && n % 10 == 2) checked_sprintf(buf, sizeof(buf), "%dnd", n); else if (n > 20 && n % 10 == 2) checked_sprintf(buf, sizeof(buf), "%drd", n); else checked_sprintf(buf, sizeof(buf), "%dth", n); return buf; } } } char *null_terminate(const uint8_t *data, size_t len) { char *cstr = xmalloc(len + 1); if (data != NULL) memcpy(cstr, data, len); else assert(len == 0); cstr[len] = '\0'; return cstr; } char toupper_iso88591(unsigned char ch) { if (ch >= 'a' && ch <= 'z') return ch - 'a' + 'A'; else if ((ch >= 0xe0 && ch <= 0xf6) || (ch >= 0xf8 && ch <= 0xfe)) return ch - 0x20; else return ch; } char tolower_iso88591(unsigned char ch) { if (ch >= 'A' && ch <= 'Z') return ch + 'a' - 'A'; else if ((ch >= 0xc0 && ch <= 0xd6) || (ch >= 0xd8 && ch <= 0xde)) return ch + 0x20; else return ch; } bool isprint_iso88591(unsigned char ch) { return (ch >= 0x20 && ch <= 0x7e) || (ch >= 0xa0 && ch <= 0xff); } bool isspace_iso88591(unsigned char ch) { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\v' || ch == '\f' || ch == '\r' || ch == 0xa0; } bool isdigit_iso88591(unsigned char ch) { return ch >= '0' && ch <= '9'; } bool isupper_iso88591(unsigned char ch) { return (ch >= 'A' && ch <= 'Z') || (ch >= 0xc0 && ch <= 0xd6) || (ch >= 0xd8 && ch <= 0xde); } bool isalpha_iso88591(unsigned char ch) { return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= 0xc0 && ch <= 0xd6) || (ch >= 0xd8 && ch <= 0xde) || (ch >= 0xe0 && ch <= 0xf6) || (ch >= 0xf8 && ch <= 0xfe); } bool isalnum_iso88591(unsigned char ch) { return isalpha_iso88591(ch) || (ch >= '0' && ch <= '9'); } int next_power_of_2(int n) { n--; n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; n++; return n; } int ilog2(int64_t n) { if (n <= 1) return 0; else { int r = 0; int64_t c = 1; while (c < n) { r += 1; c <<= 1; } return r; } } bool ipow_safe(int64_t x, int64_t y, int64_t *result) { assert(y >= 0); int overflow = 0, xo = 0; int64_t r = 1; while (y) { if (y & 1) overflow |= xo || __builtin_mul_overflow(r, x, &r); y >>= 1; xo |= __builtin_mul_overflow(x, x, &x); } *result = r; return !overflow; } int64_t ipow(int64_t x, int64_t y) { int64_t result; if (!ipow_safe(x, y, &result)) DEBUG_ONLY(fatal_trace("integer overflow in ipow")); return result; } #if !ASAN_ENABLED static long nvc_page_size(void) { #ifdef __MINGW32__ SYSTEM_INFO si; GetSystemInfo(&si); return si.dwPageSize; #else return sysconf(_SC_PAGESIZE); #endif } #endif void nvc_munmap(void *ptr, size_t length) { #if ASAN_ENABLED free(ptr); #elif !defined __MINGW32__ if (munmap(ptr, length) != 0) fatal_errno("munmap"); #else if (!VirtualFree(ptr, length, MEM_DECOMMIT)) fatal_errno("VirtualFree"); #endif } void *nvc_memalign(size_t align, size_t sz) { #if ASAN_ENABLED void *ptr; if (posix_memalign(&ptr, align, sz) != 0) fatal_errno("posix_memalign"); memset(ptr, '\0', sz); return ptr; #else assert(is_power_of_2(align)); const size_t mapalign = MAX(align, nvc_page_size()); const size_t mapsz = ALIGN_UP(sz + mapalign - 1, mapalign); #if defined __MINGW32__ void *ptr = VirtualAlloc(NULL, mapsz, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); if (ptr == NULL) fatal_errno("VirtualAlloc"); #else void *ptr = mmap(NULL, mapsz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); if (ptr == MAP_FAILED) fatal_errno("mmap failed to allocate %zu bytes", sz); #endif void *aligned = ALIGN_UP(ptr, align); void *limit = aligned + sz; if (align > nvc_page_size()) { const size_t low_waste = aligned - ptr; const size_t high_waste = ptr + mapsz - limit; assert(low_waste + high_waste == align); if (low_waste > 0) nvc_munmap(ptr, low_waste); if (high_waste > 0) nvc_munmap(limit, high_waste); } return aligned; #endif } void nvc_memprotect(void *ptr, size_t length, mem_access_t prot) { #if defined __MINGW32__ static const int map[] = { PAGE_NOACCESS, PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE }; DWORD old_prot; if (length > 0 && !VirtualProtect(ptr, length, map[prot], &old_prot)) fatal_errno("VirtualProtect"); #else #if ASAN_ENABLED // LeakSanitizer will not detect leaks in regions mapped read-only if (prot == MEM_RO || prot == MEM_NONE) return; #endif static const int map[] = { PROT_NONE, PROT_READ, PROT_READ | PROT_WRITE, PROT_READ | PROT_EXEC, PROT_READ | PROT_WRITE | PROT_EXEC }; if (mprotect(ptr, length, map[prot]) < 0) fatal_errno("mprotect"); #endif } void nvc_decommit(void *ptr, size_t length) { #if defined __MINGW32__ if (length > 0 && !VirtualFree(ptr, length, MEM_DECOMMIT)) fatal_errno("VirtualFree"); #elif defined __linux__ if (madvise(ptr, length, MADV_DONTNEED) != 0) fatal_errno("madvise: MADV_DONTNEED"); #endif } void *map_huge_pages(size_t align, size_t sz) { #ifdef __linux__ if (sz >= HUGE_PAGE_SIZE) { const size_t mapsz = ALIGN_UP(sz, HUGE_PAGE_SIZE); void *mem = nvc_memalign(MAX(HUGE_PAGE_SIZE, align), mapsz); if (madvise(mem, mapsz, MADV_HUGEPAGE) < 0) warnf("madvise: MADV_HUGEPAGE: %s", last_os_error()); return mem; } #endif return nvc_memalign(align, sz); } void *map_jit_pages(size_t align, size_t sz) { #ifdef __APPLE__ void *ptr = mmap(NULL, sz, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON | MAP_JIT, -1, 0); if (ptr == MAP_FAILED) fatal_errno("mmap failed to allocate %zu bytes for executable code", sz); #else void *ptr = map_huge_pages(align, sz); nvc_memprotect(ptr, sz, MEM_RWX); #endif return ptr; } int checked_sprintf(char *buf, int len, const char *fmt, ...) { assert(len > 0); va_list ap; va_start(ap, fmt); const int nbytes = vsnprintf(buf, len, fmt, ap); if (nbytes >= len) fatal_trace("checked_sprintf requires %d bytes but have %d", nbytes + 1, len); va_end(ap); return nbytes; } text_buf_t *tb_new(void) { text_buf_t *tb = xmalloc(sizeof(text_buf_t)); tb->alloc = 256; tb->len = 0; tb->buf = xmalloc(tb->alloc); tb->buf[0] = '\0'; return tb; } void tb_free(text_buf_t *tb) { free(tb->buf); free(tb); } void _tb_cleanup(text_buf_t **tb) { if (*tb != NULL) tb_free(*tb); } void tb_vprintf(text_buf_t *tb, const char *fmt, va_list ap) { int nchars, avail; for (;;) { va_list aq; va_copy(aq, ap); avail = tb->alloc - tb->len; nchars = vsnprintf(tb->buf + tb->len, avail, fmt, aq); va_end(aq); if (nchars + 1 < avail) break; tb->alloc *= 2; tb->buf = xrealloc(tb->buf, tb->alloc); } tb->len += nchars; } void tb_printf(text_buf_t *tb, const char *fmt, ...) { va_list ap; va_start(ap, fmt); tb_vprintf(tb, fmt, ap); va_end(ap); } void tb_istr(text_buf_t *tb, ident_t ident) { // TODO: this function seems useless now tb_cat(tb, istr(ident)); } void tb_append(text_buf_t *tb, char ch) { if (tb->len + 2 >= tb->alloc) { tb->alloc *= 2; tb->buf = xrealloc(tb->buf, tb->alloc); } tb->buf[(tb->len)++] = ch; tb->buf[tb->len] = '\0'; } void tb_catn(text_buf_t *tb, const char *str, size_t nchars) { if (tb->len + nchars + 1 >= tb->alloc) { tb->alloc = next_power_of_2(tb->alloc + nchars); tb->buf = xrealloc(tb->buf, tb->alloc); } memcpy(tb->buf + tb->len, str, nchars); tb->len += nchars; tb->buf[tb->len] = '\0'; } void tb_cat(text_buf_t *tb, const char *str) { tb_catn(tb, str, strlen(str)); } void tb_repeat(text_buf_t *tb, char ch, size_t count) { if (tb->len + count + 1 >= tb->alloc) { tb->alloc = next_power_of_2(tb->alloc + count + 1); tb->buf = xrealloc(tb->buf, tb->alloc); } memset(tb->buf + tb->len, ch, count); tb->len += count; tb->buf[tb->len] = '\0'; } char *tb_reserve(text_buf_t *tb, size_t size) { if (tb->len + size + 1 >= tb->alloc) { tb->alloc = next_power_of_2(tb->alloc + size + 1); tb->buf = xrealloc(tb->buf, tb->alloc); } char *start = tb->buf + tb->len; tb->len += size; tb->buf[tb->len] = '\0'; return start; } size_t tb_len(text_buf_t *tb) { return tb->len; } char *tb_claim(text_buf_t *tb) { char *buf = tb->buf; tb->buf = NULL; return buf; } const char *tb_get(text_buf_t *tb) { return tb->buf; } void tb_rewind(text_buf_t *tb) { tb->len = 0; tb->buf[0] = '\0'; } void tb_trim(text_buf_t *tb, size_t newlen) { assert(newlen <= tb->len); tb->len = newlen; tb->buf[tb->len] = '\0'; } void tb_strip(text_buf_t *tb) { while (tb->len > 0 && isspace_iso88591(tb->buf[tb->len - 1])) tb->buf[--(tb->len)] = '\0'; } void tb_downcase(text_buf_t *tb) { for (size_t i = 0; i < tb->len; i++) tb->buf[i] = tolower_iso88591(tb->buf[i]); } void tb_upcase(text_buf_t *tb) { for (size_t i = 0; i < tb->len; i++) tb->buf[i] = toupper_iso88591(tb->buf[i]); } void tb_replace(text_buf_t *tb, char old, char rep) { for (size_t i = 0; i < tb->len; i++) { if (tb->buf[i] == old) tb->buf[i] = rep; } } void tb_strftime(text_buf_t *tb, const char *fmt, time_t time) { struct tm tm; switch (fmt[0]) { case 'L': #ifdef __MINGW32__ localtime_s(&tm, &time); #else localtime_r(&time, &tm); #endif break; case 'G': #ifdef __MINGW32__ gmtime_s(&tm, &time); #else gmtime_r(&time, &tm); #endif break; default: fatal_trace("invalid timezone specifier '%c'", fmt[0]); } const size_t max = 64; char *p = tb_reserve(tb, max); if (strftime(p, max, fmt + 1, &tm) == 0) fatal_trace("time format buffer too small"); } void _local_free(void *ptr) { free(*(void **)ptr); } void set_message_style(message_style_t style) { message_style = style; if (style == MESSAGE_COMPACT) want_color = false; } message_style_t get_message_style(void) { return message_style; } #ifndef __MINGW32__ static uint64_t timeval_us(struct timeval *tv) { return (tv->tv_sec * UINT64_C(1000000)) + tv->tv_usec; } #endif void nvc_rusage(nvc_rusage_t *ru) { #ifndef __MINGW32__ static uint64_t last_user, last_sys; struct rusage buf; if (getrusage(RUSAGE_SELF, &buf) < 0) fatal_errno("getrusage"); const uint64_t user = timeval_us(&(buf.ru_utime)); const uint64_t sys = timeval_us(&(buf.ru_stime)); ru->user = (user - last_user) / 1000; ru->sys = (sys - last_sys) / 1000; last_sys = sys; last_user = user; #ifdef __APPLE__ const int rss_units = 1024; #else const int rss_units = 1; #endif ru->rss = buf.ru_maxrss / rss_units; #else static ULARGE_INTEGER last_kernel, last_user; ULARGE_INTEGER lv_Tkernel, lv_Tuser; HANDLE hProcess = GetCurrentProcess(); FILETIME ftCreation, ftExit, ftKernel, ftUser; if (!GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser)) fatal_errno("GetProcessTimes"); lv_Tkernel.LowPart = ftKernel.dwLowDateTime; lv_Tkernel.HighPart = ftKernel.dwHighDateTime; lv_Tuser.LowPart = ftUser.dwLowDateTime; lv_Tuser.HighPart = ftUser.dwHighDateTime; ru->user = (lv_Tuser.QuadPart - last_user.QuadPart) / 10000; ru->sys = (lv_Tkernel.QuadPart - last_kernel.QuadPart) / 10000; last_user = lv_Tuser; last_kernel = lv_Tkernel; PROCESS_MEMORY_COUNTERS counters; if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) fatal_errno("GetProcessMemoryInfo"); ru->rss = counters.PeakWorkingSetSize / 1024; #endif static uint64_t last_ts; const uint64_t ts = get_timestamp_us(); ru->ms = last_ts == 0 ? ru->user + ru->sys : (ts - last_ts) / 1000; last_ts = ts; } #ifdef __MINGW32__ static uint64_t file_time_to_nanos(LPFILETIME ft) { uint64_t nanos = (uint64_t)ft->dwHighDateTime << 32; nanos |= ft->dwLowDateTime; // Windows file timestamps are in units of 100 nanoseconds since // 1601-01-01T00:00:00Z: convert that to nanoseconds since the Unix // epoch 1970-01-01T00:00:00Z nanos -= UINT64_C(116444736000000000); nanos *= 100; return nanos; } static bool fill_file_info(file_info_t *info, HANDLE handle) { memset(info, '\0', sizeof(file_info_t)); BY_HANDLE_FILE_INFORMATION hinfo; if (!GetFileInformationByHandle(handle, &hinfo)) fatal_errno("GetFileInformationByHandle"); info->size = (uint64_t)hinfo.nFileSizeHigh << 32; info->size |= hinfo.nFileSizeLow; if (hinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) info->type = FILE_DIR; else info->type = FILE_REGULAR; info->mtime = file_time_to_nanos(&(hinfo.ftLastWriteTime)); return true; } #else // !__MINGW32__ static void fill_file_info(file_info_t *info, const struct stat *st) { memset(info, '\0', sizeof(file_info_t)); info->size = st->st_size; if (S_ISDIR(st->st_mode)) info->type = FILE_DIR; else if (!S_ISREG(st->st_mode)) info->type = FILE_FIFO; else info->type = FILE_REGULAR; info->mtime = st->st_mtime * UINT64_C(1000000000); #if defined HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC info->mtime += st->st_mtimespec.tv_nsec; #elif defined HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC info->mtime += st->st_mtim.tv_nsec; #endif } #endif // !__MINGW32__ bool get_file_info(const char *path, file_info_t *info) { #ifdef __MINGW32__ HANDLE handle = CreateFile( path, FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if (handle == INVALID_HANDLE_VALUE) return false; fill_file_info(info, handle); if (!CloseHandle(handle)) fatal_errno("CloseHandle"); return true; #else struct stat st; if (stat(path, &st) == 0) { fill_file_info(info, &st); return true; } else return false; #endif } bool get_handle_info(int fd, file_info_t *info) { #ifdef __MINGW32__ HANDLE handle = (HANDLE)_get_osfhandle(fd); fill_file_info(info, handle); return true; #else struct stat st; if (fstat(fd, &st) == 0) { fill_file_info(info, &st); return true; } else return false; #endif } void run_program(const char *const *args) { #if defined __CYGWIN__ || defined __MINGW32__ int status = spawnvp(_P_WAIT, args[0], (char *const *)args); #else // __CYGWIN__ pid_t pid = fork(); int status = 0; if (pid == 0) { execvp(args[0], (char *const *)args); fatal_errno("execv"); } else if (pid > 0) { if (waitpid(pid, &status, 0) != pid) fatal_errno("waitpid"); status = WEXITSTATUS(status); } else fatal_errno("fork"); #endif // __CYGWIN__ if (status != 0) { LOCAL_TEXT_BUF tb = tb_new(); for (size_t i = 0; args[i] != NULL; i++) tb_printf(tb, "%s%s", i > 0 ? " " : "", args[i]); fatal("$bold$%s$$ failed with status %d", tb_get(tb), status); } } char *nvc_temp_file(void) { static const char *try[] = { "TMPDIR", "TEMP", "TMP" }; const char *tmpdir = NULL; for (int i = 0; tmpdir == NULL && i < ARRAY_LEN(try); i++) tmpdir = getenv(try[i]); #ifdef __MINGW32__ char *buf = xasprintf("%s\\nvc-XXXXXX", tmpdir ?: "."); return _mktemp(buf); #else char *buf = xasprintf("%s/nvc-XXXXXX", tmpdir ?: "/tmp"); int fd = mkstemp(buf); if (fd < 0) fatal_errno("mkstemp"); close(fd); return buf; #endif } void file_read_lock(int fd) { #ifdef __MINGW32__ HANDLE hf = (HANDLE)_get_osfhandle(fd); LARGE_INTEGER li; li.QuadPart = _filelengthi64(fd); OVERLAPPED ovlp; memset(&ovlp, 0, sizeof ovlp); if (!LockFileEx(hf, 0, 0, li.LowPart, li.HighPart, &ovlp)) fatal_errno("LockFileEx"); #else if (flock(fd, LOCK_SH) < 0) fatal_errno("flock"); #endif } void file_write_lock(int fd) { #ifdef __MINGW32__ HANDLE hf = (HANDLE)_get_osfhandle(fd); LARGE_INTEGER li; li.QuadPart = _filelengthi64(fd); OVERLAPPED ovlp; memset(&ovlp, 0, sizeof ovlp); if (!LockFileEx(hf, LOCKFILE_EXCLUSIVE_LOCK, 0, li.LowPart, li.HighPart, &ovlp)) fatal_errno("LockFileEx"); #else if (flock(fd, LOCK_EX) < 0) fatal_errno("flock"); #endif } void file_unlock(int fd) { #ifdef __MINGW32__ HANDLE hf = (HANDLE)_get_osfhandle(fd); LARGE_INTEGER li; li.QuadPart = _filelengthi64 (fd); UnlockFile(hf, 0, 0, li.LowPart, li.HighPart); #else if (flock(fd, LOCK_UN) < 0) fatal_errno("flock"); #endif } void *map_file(int fd, size_t size) { #ifdef __MINGW32__ HANDLE handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL, PAGE_READONLY, 0, size, NULL); if (!handle) fatal_errno("CreateFileMapping"); void *ptr = MapViewOfFileEx(handle, FILE_MAP_READ, 0, 0, (SIZE_T) size, (LPVOID) NULL); CloseHandle(handle); if (ptr == NULL) fatal_errno("MapViewOfFileEx"); #else void *ptr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); if (ptr == MAP_FAILED) fatal_trace("mmap failed to map %zu byte file", size); #endif return ptr; } void unmap_file(void *ptr, size_t size) { #ifdef __MINGW32__ if (!UnmapViewOfFile((LPCVOID) ptr)) fatal_errno("UnmapViewOfFile"); #else munmap(ptr, size); #endif } void make_dir(const char *path) { #ifdef __MINGW32__ if (!CreateDirectory(path, NULL) && (GetLastError() != ERROR_ALREADY_EXISTS)) fatal_errno("mkdir: %s", path); #else if (mkdir(path, 0777) != 0 && errno != EEXIST) fatal_errno("mkdir: %s", path); #endif } uint64_t get_timestamp_ns(void) { #if defined __MINGW32__ static volatile uint64_t freq; if (load_acquire(&freq) == 0) { LARGE_INTEGER tmp; if (!QueryPerformanceFrequency(&tmp)) fatal_errno("QueryPerformanceFrequency"); store_release(&freq, tmp.QuadPart); } LARGE_INTEGER ticks; if (!QueryPerformanceCounter(&ticks)) fatal_errno("QueryPerformanceCounter"); return (double)ticks.QuadPart * (1e9 / (double)freq); #else struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) fatal_errno("clock_gettime"); return ts.tv_nsec + (ts.tv_sec * UINT64_C(1000000000)); #endif } uint64_t get_timestamp_us(void) { return get_timestamp_ns() / 1000; } timestamp_t get_real_time(void) { #if defined __MINGW32__ FILETIME ft; GetSystemTimeAsFileTime(&ft); return file_time_to_nanos(&ft); #else struct timespec ts; if (clock_gettime(CLOCK_REALTIME, &ts) != 0) fatal_errno("clock_gettime"); return (uint64_t)ts.tv_nsec + ((uint64_t)ts.tv_sec * UINT64_C(1000000000)); #endif } void open_pipe(int *rfd, int *wfd) { int fds[2]; #ifdef __MINGW32__ const int rc = _pipe(fds, 4096, _O_BINARY); #else const int rc = pipe(fds) < 0; #endif if (rc < 0) fatal_errno("failed to create pipe"); *rfd = fds[0]; *wfd = fds[1]; } #if defined _WIN32 || defined __CYGWIN__ static struct { char illegal; const char *rep; } symbol_replacements[] = { { '(', "_lp_" }, { ')', "_rp_" }, { '"', "_q_" }, { '[', "_ls_" }, { ']', "_rs_" }, { '*', "_mult_" }, { '+', "_plus_" }, { '=', "_eq_" }, { '\\', "_bs_" }, }; static text_buf_t *safe_symbol_win32(const char *text) { text_buf_t *tb = tb_new(); for (const char *p = text; *p != '\0'; p++) { bool replaced = false; for (size_t j = 0; j < ARRAY_LEN(symbol_replacements); j++) { if (*p == symbol_replacements[j].illegal) { tb_cat(tb, symbol_replacements[j].rep); replaced = true; break; } } if (!replaced) tb_append(tb, *p); } return tb; } #endif text_buf_t *safe_symbol(ident_t id) { // Return a string that is safe to use as a symbol name on this platform text_buf_t *tb = tb_new(); tb_istr(tb, id); #if defined _WIN32 || defined __CYGWIN__ if (strpbrk(tb_get(tb), "()\"[]*+=\\") == NULL) return tb; else { text_buf_t *new = safe_symbol_win32(tb_get(tb)); tb_free(tb); return new; } #else return tb; #endif } void __cleanup_array(void *ptr) { A(void *) *a = ptr; ACLEAR(*a); } void __array_resize_slow(void **ptr, uint32_t *limit, uint32_t count, size_t size) { if (count == 0) { free(*ptr); *ptr = NULL; *limit = 0; } else { if (*limit == 0) *limit = count; // Setting the initial size of the array else *limit = next_power_of_2(count); *ptr = xrealloc_array(*ptr, *limit, size); } } char *search_path(const char *name) { const char *path = getenv("PATH"); if (path == NULL) return xstrdup(name); char LOCAL *tmp = xstrdup(path); for (char *p = strtok(tmp, ":"); p; p = strtok(NULL, ":")) { char *full = xasprintf("%s"DIR_SEP"%s", p, name); struct stat sb; if (stat(full, &sb) == 0) return full; free(full); } return xstrdup(name); } bool get_exe_path(text_buf_t *tb) { #if defined __linux__ char buf[PATH_MAX]; ssize_t nchars = readlink("/proc/self/exe", buf, sizeof(buf)); if (nchars > 0) { // Does not append '\0' tb_catn(tb, buf, nchars); return true; } #elif defined __APPLE__ char buf[PATH_MAX]; if (proc_pidpath(getpid(), buf, sizeof(buf)) > 0) { tb_cat(tb, buf); return true; } #elif defined __FreeBSD__ char buf[PATH_MAX]; size_t size = sizeof(buf); const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 }; if (sysctl(name, ARRAY_LEN(name), buf, &size, NULL, 0) == 0) { tb_catn(tb, buf, size); return true; } #elif defined __MINGW32__ HANDLE hProc = GetCurrentProcess(); char buf[PATH_MAX]; DWORD size = sizeof(buf); if (QueryFullProcessImageNameA(hProc, 0, buf, &size)) { tb_cat(tb, buf); return true; } #endif return false; } #if defined __MINGW32__ static void get_relative_prefix(text_buf_t *tb) { if (get_exe_path(tb)) { int len = tb_len(tb); const char *str = tb_get(tb); for (int i = 0; i < 2; i++) { do { len--; } while (str[len] != DIR_SEP[0]); } tb_trim(tb, len); } else fatal("failed to read executable path"); } #endif void get_libexec_dir(text_buf_t *tb) { #if defined __MINGW32__ get_relative_prefix(tb); tb_cat(tb, DIR_SEP "libexec" DIR_SEP "nvc"); #else tb_cat(tb, LIBEXECDIR); #endif } void get_lib_dir(text_buf_t *tb) { #if defined __MINGW32__ get_relative_prefix(tb); tb_cat(tb, DIR_SEP "lib" DIR_SEP "nvc"); #else tb_cat(tb, LIBDIR); #endif } void get_data_dir(text_buf_t *tb) { #if defined __MINGW32__ get_relative_prefix(tb); tb_cat(tb, DIR_SEP "share" DIR_SEP "nvc"); #else tb_cat(tb, DATADIR); #endif } bool is_absolute_path(const char *path) { if (path[0] == DIR_SEP[0] || path[0] == '/') return true; #ifdef __MINGW32__ if (isalpha((int)path[0]) && path[1] == ':') return true; #endif return false; } void progress(const char *fmt, ...) { if (opt_get_int(OPT_VERBOSE)) { va_list ap; va_start(ap, fmt); char *msg LOCAL = xvasprintf(fmt, ap); va_end(ap); static nvc_rusage_t last_ru; nvc_rusage_t ru; nvc_rusage(&ru); const double conc = (double)(ru.user + ru.sys) / ru.ms; if (!isinf(conc) && conc > 1.1) notef("%s [%ums %.1fx %+dkB]", msg, ru.ms, conc, ru.rss - last_ru.rss); else notef("%s [%ums %+dkB]", msg, ru.ms, ru.rss - last_ru.rss); last_ru = ru; } } unsigned nvc_nprocs(void) { #if defined _WIN32 SYSTEM_INFO sysinfo; GetSystemInfo(&sysinfo); return sysinfo.dwNumberOfProcessors; #elif defined _SC_NPROCESSORS_ONLN long count = sysconf(_SC_NPROCESSORS_ONLN); if (count == -1) fatal_errno("sysconf(_SC_NPROCESSORS_ONLN)"); #if defined __linux__ && defined HAVE_GETTID // Restrict to the number of CPUs we are allowed to run on cpu_set_t s; if (sched_getaffinity(gettid(), sizeof(cpu_set_t), &s) == 0) return MAX(1, MIN(count, CPU_COUNT(&s))); #endif return count; #else #warning Cannot detect number of processors on this platform return 1; #endif } void capture_registers(struct cpu_state *cpu) { #if defined HAVE_GETCONTEXT ucontext_t uc; if (getcontext(&uc) != 0) fatal_errno("getcontext"); fill_cpu_state(cpu, &uc); #elif defined __MINGW32__ CONTEXT context; RtlCaptureContext(&context); fill_cpu_state(cpu, &context); #elif defined HAVE_PTHREAD assert(atomic_load(&thread_regs) == NULL); atomic_store(&thread_regs, cpu); if (pthread_kill(pthread_self(), SIGUSR2) != 0) fatal_errno("pthread_kill"); // Registers filled in by signal_handler if (atomic_load(&thread_regs) != NULL) fatal_trace("signal handler did not capture thread registers"); #else #error cannot capture registers on this platform #endif } void add_fault_handler(fault_fn_t fn, void *context) { fault_handler_t *h = xmalloc(sizeof(fault_handler_t)); h->next = fault_handlers; h->fn = fn; h->context = context; fault_handlers = h; } void remove_fault_handler(fault_fn_t fn, void *context) { for (fault_handler_t **p = &fault_handlers; *p; p = &((*p)->next)) { if ((*p)->fn == fn && (*p)->context == context) { fault_handler_t *tmp = (*p)->next; free(*p); *p = tmp; return; } } fatal_trace("no fault handler for %p with context %p", fn, context); } void check_cpu_features(void) { #ifdef HAVE_POPCNT if (!__builtin_cpu_supports("popcnt")) fatal("CPU is missing support for POPCNT instruction"); #endif } #ifdef DEBUG void should_not_reach_here(void) { fatal_trace("should not reach here"); } #endif mem_pool_t *pool_new(void) { mem_pool_t *mp = xcalloc(sizeof(mem_pool_t)); mp->pageshift = POOL_PAGE_MIN; return mp; } void pool_free(mem_pool_t *mp) { if (mp == NULL) return; for (pool_page_t *p = mp->pages, *tmp; p != NULL; p = tmp) { tmp = p->next; free(p); } free(mp); } static pool_page_t *pool_page_new(mem_pool_t *mp, size_t reqsz, size_t align) { const size_t hdrsz = ALIGN_UP(sizeof(page_header_t), align); const size_t minsz = next_power_of_2(reqsz + hdrsz); const size_t allocsz = MAX(1 << mp->pageshift, minsz); page_header_t *p = xmalloc(allocsz); p->next = mp->pages; p->alloc = hdrsz; p->size = allocsz; ASAN_POISON(p + hdrsz, allocsz - hdrsz); if (mp->pageshift < POOL_PAGE_MAX) mp->pageshift++; return (mp->pages = p); } static void *pool_aligned_malloc(mem_pool_t *mp, size_t size, size_t align) { assert(is_power_of_2(align)); pool_page_t *page; if (mp->pages == NULL) page = pool_page_new(mp, size, align); else { const size_t base = ALIGN_UP(mp->pages->alloc + POOL_REDZONE, align); if (base + size > mp->pages->size) page = pool_page_new(mp, size, align); else { page = mp->pages; page->alloc = base; } } assert((mp->pages->alloc & (align - 1)) == 0); assert(mp->pages->alloc + size <= mp->pages->size); assert(mp->pages->alloc >= sizeof(page_header_t)); void *ptr = (void *)mp->pages + mp->pages->alloc; mp->pages->alloc += size; ASAN_UNPOISON(ptr, size); return ptr; } void *pool_malloc(mem_pool_t *mp, size_t size) { return pool_aligned_malloc(mp, size, POOL_MIN_ALIGN); } void *pool_malloc_flex(mem_pool_t *mp, size_t fixed, size_t nelems, size_t size) { size_t bytes; if (__builtin_mul_overflow(nelems, size, &bytes)) fatal_trace("array size overflow: requested %zd * %zd bytes", nelems, size); return pool_malloc(mp, fixed + bytes); } void *pool_malloc_array(mem_pool_t *mp, size_t nelems, size_t size) { return pool_malloc_flex(mp, 0, nelems, size); } void *pool_calloc(mem_pool_t *mp, size_t size) { void *ptr = pool_aligned_malloc(mp, size, POOL_MIN_ALIGN); memset(ptr, '\0', size); return ptr; } void pool_stats(mem_pool_t *mp, size_t *alloc, size_t *npages) { *npages = 0; *alloc = 0; for (pool_page_t *p = mp->pages; p != NULL; p = p->next) { *npages += 1; *alloc += p->alloc - sizeof(pool_page_t); } } nvc-r1.17.1/src/util.h000066400000000000000000000360011504111170000144540ustar00rootroot00000000000000// // Copyright (C) 2011-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _UTIL_H #define _UTIL_H #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include #include #include #include #include #include #include "prim.h" #ifdef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL #define RETURNS_NONNULL __attribute__((returns_nonnull)) #else #define RETURNS_NONNULL #endif #ifdef __GNUC__ #define GCC_VERSION (__GNUC__ * 10000 \ + __GNUC_MINOR__ * 100 \ + __GNUC_PATCHLEVEL__) #else #define GCC_VERSION 0 #endif #define STATIC_ASSERT(x) _Static_assert((x), "Static assertion failed"); #if defined __has_feature // Clang #define ASAN_ENABLED __has_feature(address_sanitizer) #elif defined __SANITIZE_ADDRESS__ // GCC #define ASAN_ENABLED 1 #endif #if ASAN_ENABLED #include #define ASAN_POISON(addr, size) ASAN_POISON_MEMORY_REGION(addr, size) #define ASAN_UNPOISON(addr, size) ASAN_UNPOISON_MEMORY_REGION(addr, size) #else #define ASAN_POISON(addr, size) #define ASAN_UNPOISON(addr, size) #endif #if defined __x86_64__ #define ARCH_X86_64 1 #elif defined __i386__ #define ARCH_I386 1 #elif defined __aarch64__ #define ARCH_ARM64 1 #endif #ifdef __MINGW32__ #define realpath(N, R) _fullpath((R), (N), _MAX_PATH) #define setenv(x, y, z) _putenv_s((x), (y)) #define sigjmp_buf jmp_buf #define sigsetjmp(x, y) setjmp((x)) #define siglongjmp(x, y) longjmp((x), (y)) #endif #define is_power_of_2(x) (((x) & (x - 1)) == 0) #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0])) #define ALIGN_UP(p, a) (typeof(p))({ \ assert(is_power_of_2(a)); \ const typeof(a) __a = (a); \ (((uintptr_t)(p) + (__a) - 1) & ~((__a) - 1)); }) #define MAX(x, y) \ ({ typeof(x) __x = (x); typeof(y) __y = (y); \ ((__x) > (__y) ? (__x) : (__y)); }) #define MIN(x, y) \ ({ typeof(x) __x = (x); typeof(y) __y = (y); \ ((__x) < (__y) ? (__x) : (__y)); }) #define FLOAT_BITS(f) \ (((union { double __d; int64_t __i; }){.__d = (f)}).__i) #ifdef NDEBUG #undef DEBUG #define DEBUG_ONLY(x) #else #define DEBUG 1 #define DEBUG_ONLY(x) x #endif #ifdef ENABLE_LLVM #define LLVM_ONLY(x) x #define NOT_LLVM_ONLY(x) #else #define LLVM_ONLY(x) #define NOT_LLVM_ONLY(x) x #endif #define UNUSED __attribute__((unused)) #define PASTE(x, y) x ## y #define JOIN(x, y) PASTE(x, y) #define UNIQUE(name) JOIN(name, __COUNTER__) #define LCOV_EXCL_LINE #define LCOV_EXCL_START #define LCOV_EXCL_STOP #define LCOV_EXCL_BR_LINE #define LCOV_EXCL_BR_START #define LCOV_EXCL_BR_STOP #ifndef HAVE_MEMMEM void *memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen); #endif #ifndef HAVE_STRCASESTR char *strcasestr(const char *haystack_start, const char *needle_start); #endif #ifndef HAVE_GETLINE ssize_t getline(char **lineptr, size_t *n, FILE *stream); #endif #ifndef HAVE_FTELLO #define ftello(f) (off_t)ftell(f) #endif #ifndef HAVE_FSEEKO #define fseeko(f, o, w) (off_t)fseek(f, o, w) #endif #ifndef HAVE_STRCHRNUL char *strchrnul(const char *s, int c_in); #endif #ifndef HAVE_STRNDUP char *strndup(char const *s, size_t n); #endif #define container_of(ptr, type, member) ({ \ const typeof(((type *)0)->member) * __mptr = (ptr); \ (type *)((char *)__mptr - offsetof(type, member)); }) #define tag_pointer(p, tag) ({ \ typeof((p)) __p = (p); \ assert(((uintptr_t)__p & 7) == 0); \ assert((unsigned)(tag) < 8u); \ (void *)((uintptr_t)__p | (uintptr_t)(tag)); \ }) #define untag_pointer(p, type) (type *)((uintptr_t)(p) & ~7) #define pointer_tag(p) ((uintptr_t)(p) & 7) #define prefetch_read(ptr) __builtin_prefetch(ptr, 0) #define prefetch_write(ptr) __builtin_prefetch(ptr, 1, 1) // Scrambling functions from MurmurHash3 #define mix_bits_32(n) ({ \ uint32_t __n = (uint32_t)(n); \ __n *= 0xcc9e2d51; \ __n = (__n << 15) | (__n >> 17); \ __n *= 0x1b873593; \ }) #define mix_bits_64(n) ({ \ uint64_t __n = (uint64_t)(n); \ __n ^= (__n >> 33); \ __n *= UINT64_C(0xff51afd7ed558ccd); \ __n ^= (__n >> 33); \ __n *= UINT64_C(0xc4ceb9fe1a85ec53); \ __n ^= (__n >> 33); \ }) // Knuth's multiplicative hash #define knuth_hash(n) ((uint32_t)(n)) * UINT32_C(2654435761) void *xmalloc(size_t size) RETURNS_NONNULL; void *xmalloc_array(size_t nelems, size_t size) RETURNS_NONNULL; void *xmalloc_flex(size_t fixed, size_t nelems, size_t size) RETURNS_NONNULL; void *xcalloc(size_t size) RETURNS_NONNULL; void *xcalloc_array(size_t nelems, size_t size) RETURNS_NONNULL; void *xcalloc_flex(size_t fixed, size_t nelems, size_t size) RETURNS_NONNULL; void *xrealloc(void *ptr, size_t size) RETURNS_NONNULL; void *xrealloc_array(void *ptr, size_t nelems, size_t size) RETURNS_NONNULL; void *xrealloc_flex(void *ptr, size_t fixed, size_t nelems, size_t size) RETURNS_NONNULL; char *xstrdup(const char *str) RETURNS_NONNULL; char *xstrndup(const char *str, size_t n) RETURNS_NONNULL; char *xvasprintf(const char *fmt, va_list ap) RETURNS_NONNULL; char *xasprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2))) RETURNS_NONNULL; int color_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); int color_fprintf(FILE *file, const char *fmt, ...) __attribute__((format(printf, 2, 3))); int color_vprintf(const char *fmt, va_list ap); char *color_vasprintf(const char *fmt, va_list ap); char *color_asprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); char *strip_color(const char *fmt, va_list ap); void print_centred(const char *text); void errorf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); void warnf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); void notef(const char *fmt, ...) __attribute__((format(printf, 1, 2))); void debugf(const char *fmt, ...) __attribute__((format(printf, 1, 2))); void fatal(const char *fmt, ...) __attribute__((format(printf, 1, 2), noreturn, cold, noinline)); void fatal_trace(const char *fmt, ...) __attribute__((format(printf, 1, 2), noreturn, cold, noinline)); void fatal_errno(const char *fmt, ...) __attribute__((format(printf, 1, 2), noreturn, cold, noinline)); const char *last_os_error(void); #define likely(x) __builtin_expect(x, 1) #define unlikely(x) __builtin_expect(x, 0) #ifdef DEBUG void should_not_reach_here(void) __attribute__((noreturn, cold)); #else #define should_not_reach_here() __builtin_unreachable() #endif void error_at(const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 2, 3))); void warn_at(const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 2, 3))); void note_at(const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 2, 3))); void fatal_at(const loc_t *loc, const char *fmt, ...) __attribute__((format(printf, 2, 3), noreturn)); void fatal_exit(int status) __attribute__((noreturn)); void show_stacktrace(void); void register_signal_handlers(void); void set_ctrl_c_handler(void (*fn)(void *), void *arg); void term_init(void); bool color_terminal(void); bool utf8_terminal(void); int terminal_width(void); const char *ordinal_str(int n); char *null_terminate(const uint8_t *data, size_t len); char toupper_iso88591(unsigned char ch); char tolower_iso88591(unsigned char ch); bool isprint_iso88591(unsigned char ch); bool isspace_iso88591(unsigned char ch); bool isdigit_iso88591(unsigned char ch); bool isupper_iso88591(unsigned char ch); bool isalpha_iso88591(unsigned char ch); bool isalnum_iso88591(unsigned char ch); int checked_sprintf(char *buf, int len, const char *fmt, ...) __attribute__((format(printf, 3, 4))); int next_power_of_2(int n) __attribute__((pure)); int ilog2(int64_t n) __attribute__((pure)); int64_t ipow(int64_t x, int64_t y) __attribute__((pure)); bool ipow_safe(int64_t x, int64_t y, int64_t *result); typedef enum { MEM_NONE, MEM_RO, MEM_RW, MEM_RX, MEM_RWX } mem_access_t; void *nvc_memalign(size_t align, size_t sz); void nvc_munmap(void *ptr, size_t length); void nvc_memprotect(void *ptr, size_t length, mem_access_t prot); void nvc_decommit(void *ptr, size_t length); void *map_huge_pages(size_t align, size_t sz); void *map_jit_pages(size_t align, size_t sz); void run_program(const char *const *args); char *nvc_temp_file(void); text_buf_t *safe_symbol(ident_t id); #define LOCAL_TEXT_BUF __attribute__((cleanup(_tb_cleanup))) text_buf_t * text_buf_t *tb_new(void); void tb_free(text_buf_t *tb); void _tb_cleanup(text_buf_t **tb); void tb_printf(text_buf_t *tb, const char *fmt, ...) __attribute__((format(printf, 2, 3))); void tb_vprintf(text_buf_t *tb, const char *fmt, va_list ap); void tb_append(text_buf_t *tb, char ch); void tb_istr(text_buf_t *tb, ident_t ident); void tb_cat(text_buf_t *tb, const char *str); void tb_catn(text_buf_t *tb, const char *str, size_t nchars); void tb_repeat(text_buf_t *tb, char ch, size_t count); const char *tb_get(text_buf_t *tb); char *tb_claim(text_buf_t *tb); char *tb_reserve(text_buf_t *tb, size_t size); void tb_rewind(text_buf_t *tb); void tb_trim(text_buf_t *tb, size_t newlen); void tb_strip(text_buf_t *tb); size_t tb_len(text_buf_t *tb); void tb_downcase(text_buf_t *tb); void tb_upcase(text_buf_t *tb); void tb_replace(text_buf_t *tb, char old, char rep); void tb_strftime(text_buf_t *tb, const char *fmt, time_t time); #define LOCAL __attribute__((cleanup(_local_free))) void _local_free(void *ptr); #ifdef __MINGW32__ #define DLLEXPORT __declspec(dllexport) #else #define DLLEXPORT __attribute__((used)) #endif typedef enum { MESSAGE_FULL, MESSAGE_COMPACT } message_style_t; void set_message_style(message_style_t style); message_style_t get_message_style(void); typedef struct { unsigned rss; unsigned ms; unsigned user; unsigned sys; } nvc_rusage_t; void nvc_rusage(nvc_rusage_t *ru); typedef uint64_t timestamp_t; // Nanoseconds uint64_t get_timestamp_ns(void); uint64_t get_timestamp_us(void); timestamp_t get_real_time(void); unsigned nvc_nprocs(void); typedef enum { FILE_REGULAR, FILE_DIR, FILE_FIFO, } file_type_t; typedef struct { file_type_t type; size_t size; timestamp_t mtime; } file_info_t; bool get_file_info(const char *path, file_info_t *info); bool get_handle_info(int fd, file_info_t *info); void progress(const char *fmt, ...) __attribute__((format(printf, 1, 2))); void file_read_lock(int fd); void file_write_lock(int fd); void file_unlock(int fd); void *map_file(int fd, size_t size); void unmap_file(void *ptr, size_t size); void make_dir(const char *path); char *search_path(const char *name); void get_libexec_dir(text_buf_t *tb); void get_lib_dir(text_buf_t *tb); void get_data_dir(text_buf_t *tb); bool get_exe_path(text_buf_t *tb); void open_pipe(int *rfd, int *wfd); bool is_absolute_path(const char *path); void check_cpu_features(void); struct cpu_state; typedef void (*fault_fn_t)(int, void *, struct cpu_state *, void *); void add_fault_handler(fault_fn_t fn, void *context); void remove_fault_handler(fault_fn_t fn, void *context); struct cpu_state; void capture_registers(struct cpu_state *cpu); mem_pool_t *pool_new(void); void pool_free(mem_pool_t *mp); void *pool_malloc(mem_pool_t *mp, size_t size); void *pool_calloc(mem_pool_t *mp, size_t size); void *pool_malloc_array(mem_pool_t *mp, size_t nelems, size_t size); void *pool_malloc_flex(mem_pool_t *mp, size_t fixed, size_t nelems, size_t size); void pool_stats(mem_pool_t *mp, size_t *alloc, size_t *npages); #define INIT_ONCE(body) do { \ static volatile int __done = 0; \ if (!load_acquire(&__done)) { \ static nvc_lock_t __lock; \ SCOPED_LOCK(__lock); \ body; \ store_release(&__done, 1); \ } \ } while (0) #define FOR_ALL_SIZES(size, macro) do { \ switch (size) { \ case 1: \ macro(uint8_t); break; \ case 2: \ macro(uint16_t); break; \ case 4: \ macro(uint32_t); break; \ case 8: \ macro(uint64_t); break; \ } \ } while (0) #define UNPACK_BE16(b) ((b)[0] << 8 | (b)[1]) #define UNPACK_BE32(b) \ ((uint32_t)UNPACK_BE16(b) << 16 | UNPACK_BE16(b + 2)) #define UNPACK_BE64(b) \ ((uint64_t)UNPACK_BE32(b) << 32 | UNPACK_BE32(b + 4)) #define PACK_BE16(u) \ ((u) >> 8) & 0xff, (u) & 0xff #define PACK_BE32(u) \ PACK_BE16(u >> 16), PACK_BE16(u) #define PACK_BE64(u) \ PACK_BE32(u >> 32), PACK_BE32(u) #define unaligned_load(ptr, type) ({ \ const void *__ptr = (ptr); \ const struct { type value; } \ __attribute__((packed)) *__s = __ptr; \ __s->value; \ }) #define TYPE_MAX(x) \ _Generic((x), \ uint64_t: UINT64_MAX, \ int64_t: INT64_MAX, \ uint32_t: UINT32_MAX, \ int32_t: INT32_MAX, \ uint16_t: UINT16_MAX, \ int16_t: INT16_MAX, \ uint8_t: UINT8_MAX, \ int8_t: INT8_MAX) #define saturate_add(a, b) ({ \ typeof((typeof(a))(a)) __tmp; \ if (__builtin_add_overflow((a), (b), &__tmp)) \ __tmp = TYPE_MAX(__tmp); \ __tmp; \ }) #endif // _UTIL_H nvc-r1.17.1/src/vcode.c000066400000000000000000005702431504111170000146050ustar00rootroot00000000000000// // Copyright (C) 2014-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "lib.h" #include "object.h" #include "tree.h" #include "vcode.h" #include #include #include #include #include #include DECLARE_AND_DEFINE_ARRAY(vcode_reg); DECLARE_AND_DEFINE_ARRAY(vcode_block); DECLARE_AND_DEFINE_ARRAY(vcode_type); #define OP_HAS_TYPE(x) \ (x == VCODE_OP_ALLOC || x == VCODE_OP_COPY \ || x == VCODE_OP_CONST || x == VCODE_OP_CAST \ || x == VCODE_OP_CONST_RECORD \ || x == VCODE_OP_BIND_EXTERNAL || x == VCODE_OP_ARRAY_SCOPE \ || x == VCODE_OP_RECORD_SCOPE || x == VCODE_OP_SYSCALL) #define OP_HAS_ADDRESS(x) \ (x == VCODE_OP_LOAD || x == VCODE_OP_STORE || x == VCODE_OP_INDEX \ || x == VCODE_OP_VAR_UPREF) #define OP_HAS_FUNC(x) \ (x == VCODE_OP_FCALL || x == VCODE_OP_PCALL || x == VCODE_OP_RESUME \ || x == VCODE_OP_CLOSURE || x == VCODE_OP_PROTECTED_INIT \ || x == VCODE_OP_PACKAGE_INIT || x == VCODE_OP_PROCESS_INIT \ || x == VCODE_OP_FUNCTION_TRIGGER || x == VCODE_OP_SYSCALL) #define OP_HAS_IDENT(x) \ (x == VCODE_OP_LINK_VAR || x == VCODE_OP_LINK_PACKAGE \ || x == VCODE_OP_DEBUG_LOCUS || x == VCODE_OP_BIND_EXTERNAL) #define OP_HAS_OBJECT(x) \ (x == VCODE_OP_DEBUG_LOCUS) #define OP_HAS_REAL(x) \ (x == VCODE_OP_CONST_REAL) #define OP_HAS_VALUE(x) \ (x == VCODE_OP_CONST || x == VCODE_OP_CONST_REP) #define OP_HAS_DIM(x) \ (x == VCODE_OP_UARRAY_LEFT || x == VCODE_OP_UARRAY_RIGHT \ || x == VCODE_OP_UARRAY_DIR || x == VCODE_OP_UARRAY_LEN) #define OP_HAS_HOPS(x) \ (x == VCODE_OP_VAR_UPREF || x == VCODE_OP_CONTEXT_UPREF) #define OP_HAS_FIELD(x) \ (x == VCODE_OP_RECORD_REF) #define OP_HAS_CMP(x) \ (x == VCODE_OP_CMP) #define OP_HAS_TAG(x) \ (x == VCODE_OP_COVER_STMT || x == VCODE_OP_COVER_BRANCH \ || x == VCODE_OP_COVER_TOGGLE || x == VCODE_OP_COVER_EXPR \ || x == VCODE_OP_COVER_STATE) #define OP_HAS_COMMENT(x) \ (x == VCODE_OP_COMMENT) #define OP_HAS_TARGET(x) \ (x == VCODE_OP_WAIT || x == VCODE_OP_JUMP || x == VCODE_OP_COND \ || x == VCODE_OP_PCALL || x == VCODE_OP_CASE) typedef struct { vcode_op_t kind; vcode_reg_t result; vcode_reg_array_t args; loc_t loc; vcode_type_t type; // OP_HAS_TYPE union { ident_t func; // OP_HAS_FUNC ident_t ident; // OP_HAS_IDENT object_t *object; // OP_HAS_OBJECT vcode_var_t address; // OP_HAS_ADDRESS }; union { vcode_cmp_t cmp; // OP_HAS_CMP int64_t value; // OP_HAS_VALUE double real; // OP_HAS_REAL char *comment; // OP_HAS_COMMENT unsigned dim; // OP_HAS_DIM unsigned hops; // OP_HAS_HOPS unsigned field; // OP_HAS_FIELD uint32_t tag; // OP_HAS_TAG vcode_block_array_t targets; // OP_HAS_TARGET }; } op_t; DECLARE_AND_DEFINE_ARRAY(op); typedef struct { op_array_t ops; loc_t last_loc; } block_t; typedef struct { vcode_type_t type; vcode_type_t bounds; } reg_t; typedef struct { vtype_kind_t kind; vtype_repr_t repr; union { struct { int64_t low; int64_t high; }; struct { double rlow; double rhigh; }; struct { unsigned dims; unsigned size; vcode_type_t elem; vcode_type_t bounds; }; vcode_type_t pointed; vcode_type_t base; struct { ident_t name; vcode_type_array_t fields; }; }; } vtype_t; typedef struct { vcode_type_t type; vcode_type_t bounds; ident_t name; vcode_var_flags_t flags; } var_t; typedef struct { vcode_type_t type; vcode_type_t bounds; ident_t name; vcode_reg_t reg; } param_t; DECLARE_AND_DEFINE_ARRAY(param); DECLARE_AND_DEFINE_ARRAY(var); DECLARE_AND_DEFINE_ARRAY(reg); DECLARE_AND_DEFINE_ARRAY(block); DECLARE_AND_DEFINE_ARRAY(vtype); typedef enum { UNIT_UNDEFINED = (1 << 1), } unit_flags_t; struct _vcode_unit { vunit_kind_t kind; vcode_unit_t context; ident_t name; vcode_type_t result; block_array_t blocks; reg_array_t regs; vtype_array_t types; var_array_t vars; param_array_t params; unsigned depth; unit_flags_t flags; vcode_unit_t children; vcode_unit_t next; object_t *object; }; #define MASK_CONTEXT(x) ((x) >> 24) #define MASK_INDEX(x) ((x) & 0xffffff) #define MAKE_HANDLE(c, i) (((c) & 0xff) << 24 | ((i) & 0xffffff)) #define VCODE_ASSERT(expr, ...) do \ if (unlikely(!(expr))) { \ vcode_dump_with_mark(vcode_block_data()->ops.count - 1, \ NULL, NULL); \ fatal_trace(__VA_ARGS__); \ } while (0) #define VCODE_FOR_EACH_OP(name) \ block_t *_b = vcode_block_data(); \ op_t *name; int _i; \ if (_b->ops.count > 0) \ for (_i = _b->ops.count - 1, name = &(_b->ops.items[_i]); \ _i >= 0; name = &(_b->ops.items[--_i])) #define VCODE_FOR_EACH_MATCHING_OP(name, k) \ block_t *_b = vcode_block_data(); \ op_t *name; int _i; \ if (_b->ops.count > 0) \ for (_i = 0, name = &(_b->ops.items[_i]); \ _i < _b->ops.count; name = &(_b->ops.items[++_i])) \ if (name->kind == (k)) #define VCODE_CHECK_UNIONS 0 static __thread vcode_unit_t active_unit = NULL; static __thread vcode_block_t active_block = VCODE_INVALID_BLOCK; static inline int64_t sadd64(int64_t a, int64_t b) { int64_t result; if (__builtin_add_overflow(a, b, &result)) return b < 0 ? INT64_MIN : INT64_MAX; return result; } static inline int64_t ssub64(int64_t a, int64_t b) { int64_t result; if (__builtin_sub_overflow(a, b, &result)) return b > 0 ? INT64_MIN : INT64_MAX; return result; } static inline int64_t smul64(int64_t a, int64_t b) { int64_t result; if (__builtin_mul_overflow(a, b, &result)) return (a > 0 && b > 0) || (a < 0 && b < 0) ? INT64_MAX : INT64_MIN; return result; } static vcode_reg_t vcode_add_reg(vcode_type_t type) { assert(active_unit != NULL); vcode_reg_t reg = active_unit->regs.count; reg_t *r = reg_array_alloc(&(active_unit->regs)); memset(r, '\0', sizeof(reg_t)); r->type = type; r->bounds = type; return reg; } static block_t *vcode_block_data(void) { assert(active_unit != NULL); assert(active_block != -1); return &(active_unit->blocks.items[active_block]); } static op_t *vcode_add_op(vcode_op_t kind) { assert(active_unit != NULL); assert(active_block != VCODE_INVALID_BLOCK); VCODE_ASSERT( !vcode_block_finished(), "attempt to add to already finished block %d", active_block); block_t *block = vcode_block_data(); op_t *op = op_array_alloc(&(block->ops)); memset(op, '\0', sizeof(op_t)); op->kind = kind; op->result = VCODE_INVALID_REG; op->loc = block->last_loc; return op; } static void vcode_add_arg(op_t *op, vcode_reg_t arg) { vcode_reg_array_add(&(op->args), arg); } static void vcode_add_target(op_t *op, vcode_block_t block) { vcode_block_array_add(&(op->targets), block); } static op_t *vcode_op_data(int op) { assert(active_unit != NULL); assert(active_block != VCODE_INVALID_BLOCK); block_t *b = &(active_unit->blocks.items[active_block]); return op_array_nth_ptr(&(b->ops), op); } static op_t *vcode_find_definition(vcode_reg_t reg) { for (int i = active_block; i >= 0; i--) { block_t *b = &(active_unit->blocks.items[i]); for (int j = b->ops.count - 1; j >= 0; j--) { if (b->ops.items[j].result == reg) return &(b->ops.items[j]); } } return NULL; } #ifdef DEBUG static void vcode_assert_const(vcode_reg_t reg, const char *what) { op_t *defn = vcode_find_definition(reg); VCODE_ASSERT(defn != NULL, "constant %s uses parameter r%d", what, reg); VCODE_ASSERT(defn->kind == VCODE_OP_CONST || defn->kind == VCODE_OP_CONST_REAL || defn->kind == VCODE_OP_CONST_RECORD || defn->kind == VCODE_OP_CONST_ARRAY || defn->kind == VCODE_OP_CONST_REP || defn->kind == VCODE_OP_NULL || defn->kind == VCODE_OP_UNDEFINED, "constant %s argument r%d is not constant", what, reg); } #endif static reg_t *vcode_reg_data(vcode_reg_t reg) { assert(active_unit != NULL); assert(reg != VCODE_INVALID_REG); return reg_array_nth_ptr(&(active_unit->regs), reg); } static vtype_t *vcode_type_data(vcode_type_t type) { assert(type != VCODE_INVALID_TYPE); assert(active_unit != NULL); vcode_unit_t unit = active_unit; int depth = MASK_CONTEXT(type); assert(depth <= unit->depth); while (depth != unit->depth) unit = unit->context; return vtype_array_nth_ptr(&(unit->types), MASK_INDEX(type)); } static var_t *vcode_var_data(vcode_var_t var) { assert(active_unit != NULL); assert(var != VCODE_INVALID_VAR); return var_array_nth_ptr(&(active_unit->vars), var); } void vcode_heap_allocate(vcode_reg_t reg) { op_t *defn = vcode_find_definition(reg); if (defn == NULL) { // It is always safe to return a pointer to an argument return; } switch (defn->kind) { case VCODE_OP_CONST: case VCODE_OP_CONST_REAL: case VCODE_OP_CONST_ARRAY: case VCODE_OP_CONST_REP: case VCODE_OP_NULL: case VCODE_OP_UNDEFINED: case VCODE_OP_ADDRESS_OF: case VCODE_OP_LINK_VAR: case VCODE_OP_LINK_PACKAGE: case VCODE_OP_CONTEXT_UPREF: case VCODE_OP_PACKAGE_INIT: case VCODE_OP_BIND_EXTERNAL: break; case VCODE_OP_ALLOC: case VCODE_OP_REFLECT_SUBTYPE: case VCODE_OP_REFLECT_VALUE: // Always allocated in mspace break; case VCODE_OP_INDEX: vcode_var_data(defn->address)->flags |= VAR_HEAP; break; case VCODE_OP_VAR_UPREF: { vcode_unit_t vu = vcode_active_unit(); for (int i = 0; i < defn->hops; i++) vu = vcode_unit_context(vu); vcode_state_t state; vcode_state_save(&state); vcode_select_unit(vu); vcode_var_data(defn->address)->flags |= VAR_HEAP; vcode_state_restore(&state); } break; case VCODE_OP_ARRAY_REF: vcode_heap_allocate(defn->args.items[0]); break; case VCODE_OP_WRAP: case VCODE_OP_UNWRAP: case VCODE_OP_RESOLVED: vcode_heap_allocate(defn->args.items[0]); break; case VCODE_OP_LAST_VALUE: // Returns a pointer into the C heap break; case VCODE_OP_LOAD: { if (vcode_reg_kind(reg) != VCODE_TYPE_UARRAY) return; // Any store to this variable must be heap allocated for (int i = 0; i < active_unit->blocks.count; i++) { block_t *b = &(active_unit->blocks.items[i]); for (int j = 0; j < b->ops.count; j++) { op_t *op = &(b->ops.items[j]); if (op->kind == VCODE_OP_STORE && op->address == defn->address) vcode_heap_allocate(op->args.items[0]); VCODE_ASSERT( op->kind != VCODE_OP_INDEX || op->address != defn->address, "cannot heap allocate aliased pointer r%d", reg); } } } break; case VCODE_OP_FCALL: for (int i = 0; i < defn->args.count; i++) { const vtype_kind_t rkind = vcode_reg_kind(reg); if (rkind == VCODE_TYPE_POINTER || rkind == VCODE_TYPE_UARRAY) { // Function may return a pointer to its argument vcode_heap_allocate(defn->args.items[i]); } } break; case VCODE_OP_RECORD_REF: vcode_heap_allocate(defn->args.items[0]); break; case VCODE_OP_SELECT: vcode_heap_allocate(defn->args.items[1]); vcode_heap_allocate(defn->args.items[2]); break; case VCODE_OP_LOAD_INDIRECT: { // Always OK if scalar otherwise check the pointer source const vtype_kind_t vtkind = vcode_reg_kind(reg); if (vtkind != VCODE_TYPE_INT && vtkind != VCODE_TYPE_REAL) vcode_heap_allocate(defn->args.items[0]); } break; case VCODE_OP_ALL: // Must have been allocated on the heap break; case VCODE_OP_NEW: // On the heap by definition break; case VCODE_OP_SUB: case VCODE_OP_MUL: case VCODE_OP_DIV: case VCODE_OP_CAST: case VCODE_OP_CMP: case VCODE_OP_OR: case VCODE_OP_NOT: case VCODE_OP_AND: case VCODE_OP_NOR: case VCODE_OP_NAND: case VCODE_OP_XOR: case VCODE_OP_XNOR: case VCODE_OP_EVENT: case VCODE_OP_ACTIVE: case VCODE_OP_UARRAY_LEN: case VCODE_OP_UARRAY_LEFT: case VCODE_OP_UARRAY_RIGHT: case VCODE_OP_UARRAY_DIR: case VCODE_OP_LAST_EVENT: case VCODE_OP_NEG: case VCODE_OP_EXP: case VCODE_OP_ABS: case VCODE_OP_MOD: case VCODE_OP_REM: case VCODE_OP_ADD: case VCODE_OP_TRAP_ADD: case VCODE_OP_TRAP_SUB: case VCODE_OP_TRAP_MUL: case VCODE_OP_TRAP_NEG: case VCODE_OP_TRAP_EXP: // Result cannot reference pointer break; default: VCODE_ASSERT(false, "cannot heap allocate r%d", reg); } } void vcode_state_save(vcode_state_t *state) { state->unit = active_unit; state->block = active_block; } void vcode_state_restore(const vcode_state_t *state) { active_unit = state->unit; active_block = state->block; } void vcode_unit_unref(vcode_unit_t unit) { assert(unit != NULL); if (unit == active_unit) vcode_close(); for (vcode_unit_t it = unit->children; it != NULL; it = it->next) { assert(it->context == unit); it->context = NULL; } unit->children = NULL; if (unit->context != NULL) { vcode_unit_t *it = &(unit->context->children); for (; *it != NULL && *it != unit; it = &((*it)->next)) ; assert(*it != NULL); *it = (*it)->next; } for (unsigned i = 0; i < unit->blocks.count; i++) { block_t *b = &(unit->blocks.items[i]); for (unsigned j = 0; j < b->ops.count; j++) { op_t *o = &(b->ops.items[j]); if (OP_HAS_COMMENT(o->kind)) free(o->comment); if (OP_HAS_TARGET(o->kind)) free(o->targets.items); free(o->args.items); } free(b->ops.items); } free(unit->blocks.items); for (unsigned i = 0; i < unit->types.count; i++) { vtype_t *vt = &(unit->types.items[i]); if (vt->kind == VCODE_TYPE_RECORD) free(vt->fields.items); } free(unit->types.items); free(unit->regs.items); free(unit->vars.items); free(unit->params.items); free(unit); } vcode_unit_t vcode_unit_next(vcode_unit_t unit) { return unit->next; } vcode_unit_t vcode_unit_child(vcode_unit_t unit) { return unit->children; } int vcode_count_regs(void) { assert(active_unit != NULL); return active_unit->regs.count; } vcode_type_t vcode_reg_type(vcode_reg_t reg) { return vcode_reg_data(reg)->type; } vtype_kind_t vcode_reg_kind(vcode_reg_t reg) { return vtype_kind(vcode_reg_type(reg)); } vcode_type_t vcode_reg_bounds(vcode_reg_t reg) { return vcode_reg_data(reg)->bounds; } bool vcode_reg_const(vcode_reg_t reg, int64_t *value) { reg_t *r = vcode_reg_data(reg); vtype_kind_t kind = vtype_kind(r->type); if (kind != VCODE_TYPE_INT && kind != VCODE_TYPE_OFFSET) return false; vtype_t *bounds = vcode_type_data(r->bounds); VCODE_ASSERT( bounds->kind == VCODE_TYPE_INT || bounds->kind == VCODE_TYPE_OFFSET, "integer register r%d has non-integer bounds", reg); if (bounds->low == bounds->high) { if (value) *value = bounds->low; return true; } else return false; } void vcode_opt(void) { // Prune assignments to unused registers int *uses LOCAL = xmalloc_array(active_unit->regs.count, sizeof(int)); int pruned = 0; do { memset(uses, '\0', active_unit->regs.count * sizeof(int)); pruned = 0; for (int i = active_unit->blocks.count - 1; i >= 0; i--) { block_t *b = &(active_unit->blocks.items[i]); for (int j = b->ops.count - 1; j >= 0; j--) { op_t *o = &(b->ops.items[j]); switch (o->kind) { case VCODE_OP_FCALL: if (o->result == VCODE_INVALID_REG) break; case VCODE_OP_CONST: case VCODE_OP_CONST_REAL: case VCODE_OP_CONST_ARRAY: case VCODE_OP_CONST_RECORD: case VCODE_OP_CONST_REP: case VCODE_OP_LOAD: case VCODE_OP_LOAD_INDIRECT: case VCODE_OP_VAR_UPREF: case VCODE_OP_ADD: case VCODE_OP_ARRAY_REF: case VCODE_OP_SUB: case VCODE_OP_MUL: case VCODE_OP_CMP: case VCODE_OP_INDEX: case VCODE_OP_WRAP: case VCODE_OP_EXP: case VCODE_OP_UNDEFINED: case VCODE_OP_UARRAY_LEN: case VCODE_OP_UARRAY_DIR: case VCODE_OP_UARRAY_LEFT: case VCODE_OP_UARRAY_RIGHT: case VCODE_OP_UNWRAP: case VCODE_OP_NULL: case VCODE_OP_ADDRESS_OF: case VCODE_OP_RANGE_NULL: case VCODE_OP_RANGE_LENGTH: case VCODE_OP_DEBUG_LOCUS: case VCODE_OP_SELECT: case VCODE_OP_CAST: case VCODE_OP_RESOLVED: case VCODE_OP_TRAP_ADD: case VCODE_OP_TRAP_SUB: case VCODE_OP_TRAP_MUL: case VCODE_OP_TRAP_EXP: case VCODE_OP_ALLOC: case VCODE_OP_FUNCTION_TRIGGER: case VCODE_OP_CMP_TRIGGER: case VCODE_OP_OR_TRIGGER: if (uses[o->result] == -1) { vcode_dump_with_mark(j, NULL, NULL); fatal_trace("definition of r%d does not dominate all uses", o->result); } else if (uses[o->result] == 0) { if (false DEBUG_ONLY(|| o->kind != VCODE_OP_CONST)) { o->comment = xasprintf("Dead %s definition of r%d", vcode_op_string(o->kind), o->result); o->kind = VCODE_OP_COMMENT; } else o->kind = (vcode_op_t)-1; vcode_reg_array_resize(&(o->args), 0, VCODE_INVALID_REG); pruned++; } uses[o->result] = -1; break; default: break; } for (int k = 0; k < o->args.count; k++) { if (o->args.items[k] != VCODE_INVALID_REG) uses[o->args.items[k]]++; } } } } while (pruned > 0); for (int i = active_unit->blocks.count - 1; i >= 0; i--) { block_t *b = &(active_unit->blocks.items[i]); op_t *dst = &(b->ops.items[0]); size_t copied = 0; for (int j = 0; j < b->ops.count; j++) { const op_t *src = &(b->ops.items[j]); if (src->kind != (vcode_op_t)-1) { if (src != dst) { assert(dst < src); *dst = *src; } dst++; copied++; } } assert(copied <= b->ops.count); b->ops.count = copied; } } void vcode_close(void) { active_unit = NULL; active_block = -1; } int vcode_count_blocks(void) { assert(active_unit != NULL); return active_unit->blocks.count; } int vcode_count_ops(void) { assert(active_unit != NULL); assert(active_block != VCODE_INVALID_BLOCK); return active_unit->blocks.items[active_block].ops.count; } int vcode_count_vars(void) { assert(active_unit != NULL); return active_unit->vars.count; } vcode_var_t vcode_find_var(ident_t name) { assert(active_unit != NULL); for (int i = 0; i < active_unit->vars.count; i++) { if (active_unit->vars.items[i].name == name) return i; } return VCODE_INVALID_VAR; } ident_t vcode_var_name(vcode_var_t var) { return vcode_var_data(var)->name; } vcode_type_t vcode_var_type(vcode_var_t var) { return vcode_var_data(var)->type; } vcode_type_t vcode_var_bounds(vcode_var_t var) { return vcode_var_data(var)->bounds; } vcode_var_flags_t vcode_var_flags(vcode_var_t var) { return vcode_var_data(var)->flags; } vcode_op_t vcode_get_op(int op) { return vcode_op_data(op)->kind; } ident_t vcode_get_func(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_FUNC(o->kind)); return o->func; } ident_t vcode_get_ident(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_IDENT(o->kind)); return o->ident; } object_t *vcode_get_object(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_IDENT(o->kind)); return o->object; } int64_t vcode_get_value(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_VALUE(o->kind)); return o->value; } double vcode_get_real(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_REAL(o->kind)); return o->real; } vcode_var_t vcode_get_address(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_ADDRESS(o->kind)); return o->address; } unsigned vcode_get_dim(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_DIM(o->kind)); return o->dim; } int vcode_get_hops(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_HOPS(o->kind)); return o->hops; } int vcode_get_field(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_FIELD(o->kind)); return o->field; } vcode_var_t vcode_get_type(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_TYPE(o->kind)); return o->type; } int vcode_count_args(int op) { return vcode_op_data(op)->args.count; } vcode_reg_t vcode_get_arg(int op, int arg) { op_t *o = vcode_op_data(op); return vcode_reg_array_nth(&(o->args), arg); } vcode_reg_t vcode_get_result(int op) { op_t *o = vcode_op_data(op); return o->result; } vcode_cmp_t vcode_get_cmp(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_CMP(o->kind)); return o->cmp; } uint32_t vcode_get_tag(int op) { op_t *o = vcode_op_data(op); assert(OP_HAS_TAG(o->kind)); return o->tag; } const loc_t *vcode_get_loc(int op) { op_t *o = vcode_op_data(op); return &(o->loc); } vcode_block_t vcode_get_target(int op, int nth) { op_t *o = vcode_op_data(op); assert(OP_HAS_TARGET(o->kind)); return vcode_block_array_nth(&(o->targets), nth); } bool vcode_block_empty(void) { assert(active_unit != NULL); assert(active_block != VCODE_INVALID_BLOCK); return active_unit->blocks.items[active_block].ops.count == 0; } bool vcode_block_finished(void) { assert(active_unit != NULL); assert(active_block != VCODE_INVALID_BLOCK); const block_t *b = &(active_unit->blocks.items[active_block]); if (b->ops.count == 0) return false; else { vcode_op_t kind = b->ops.items[b->ops.count - 1].kind; return kind == VCODE_OP_WAIT || kind == VCODE_OP_JUMP || kind == VCODE_OP_COND || kind == VCODE_OP_PCALL || kind == VCODE_OP_RETURN || kind == VCODE_OP_CASE || kind == VCODE_OP_UNREACHABLE; } } const char *vcode_op_string(vcode_op_t op) { static const char *strs[] = { "cmp", "fcall", "wait", "const", "assert", "jump", "load", "store", "mul", "add", "comment", "const array", "index", "sub", "cast", "load indirect", "store indirect", "return", "sched waveform", "cond", "report", "div", "neg", "exp", "abs", "mod", "rem", "alloc", "select", "or", "wrap", "uarray left", "uarray right", "uarray dir", "unwrap", "not", "and", "event", "active", "const record", "record ref", "copy", "sched event", "pcall", "resume", "xor", "xnor", "nand", "nor", "memset", "case", "file open", "file write", "file read", "null", "new", "null check", "deallocate", "all", "const real", "last event", "debug out", "cover stmt", "cover branch", "cover toggle", "cover expr", "cover state", "uarray len", "undefined", "range null", "var upref", "resolved", "last value", "init signal", "map signal", "drive signal", "link var", "resolution wrapper", "last active", "driving", "driving value", "address of", "closure", "protected init", "context upref", "const rep", "protected free", "implicit signal", "disconnect", "link package", "index check", "debug locus", "length check", "range check", "array ref", "range length", "exponent check", "zero check", "map const", "resolve signal", "package scope", "pop scope", "alias signal", "trap add", "trap sub", "trap mul", "force", "release", "unreachable", "package init", "trap neg", "process init", "clear event", "trap exp", "enter state", "reflect value", "reflect subtype", "function trigger", "add trigger", "transfer signal", "port conversion", "convert in", "convert out", "bind foreign", "or trigger", "cmp trigger", "instance name", "deposit signal", "map implicit", "bind external", "array scope", "record scope", "syscall", "put conversion", "dir check", }; if ((unsigned)op >= ARRAY_LEN(strs)) return "???"; else return strs[op]; } LCOV_EXCL_START static int vcode_dump_reg(vcode_reg_t reg) { if (reg == VCODE_INVALID_REG) return color_printf("$red$invalid$$"); else return color_printf("$green$r%d$$", reg); } static int vcode_pretty_print_int(int64_t n) { if (n == INT64_MAX) return printf("2^63-1"); else if (n == INT64_MIN) return printf("-2^63"); else if (n == INT32_MAX) return printf("2^31-1"); else if (n == INT32_MIN) return printf("-2^31"); else return printf("%"PRIi64, n); } static int vcode_dump_one_type(vcode_type_t type) { int col = 0; vtype_t *vt = vcode_type_data(type); switch (vt->kind) { case VCODE_TYPE_INT: if (vt->low != vt->high) { col += vcode_pretty_print_int(vt->low); col += printf(".."); col += vcode_pretty_print_int(vt->high); } else col += vcode_pretty_print_int(vt->low); break; case VCODE_TYPE_REAL: if (vt->rlow == -DBL_MAX && vt->rhigh == DBL_MAX) col += printf("%%"); else if (vt->rlow == vt->rhigh) col += printf("%f", vt->rlow); else col += printf("%f..%f", vt->rlow, vt->rhigh); break; case VCODE_TYPE_CARRAY: { col += printf("[%u] : ", vt->size); col += vcode_dump_one_type(vt->elem); if (!vtype_eq(vt->elem, vt->bounds)) { col += printf(" => "); col += vcode_dump_one_type(vt->bounds); } } break; case VCODE_TYPE_UARRAY: { col += printf("["); for (unsigned i = 0; i < vt->dims; i++) col += printf("%s*", i > 0 ? ", " : ""); col += printf("] : "); col += vcode_dump_one_type(vt->elem); if (!vtype_eq(vt->elem, vt->bounds)) { col += printf(" => "); col += vcode_dump_one_type(vt->bounds); } } break; case VCODE_TYPE_POINTER: col += printf("@<"); col += vcode_dump_one_type(vt->pointed); col += printf(">"); break; case VCODE_TYPE_ACCESS: col += printf("A<"); col += vcode_dump_one_type(vt->pointed); col += printf(">"); break; case VCODE_TYPE_SIGNAL: col += printf("$<"); col += vcode_dump_one_type(vt->base); col += printf(">"); break; case VCODE_TYPE_OFFSET: col += printf("#"); break; case VCODE_TYPE_RECORD: col += printf("%s{}", istr(vt->name)); break; case VCODE_TYPE_FILE: col += printf("F<"); col += vcode_dump_one_type(vt->base); col += printf(">"); break; case VCODE_TYPE_OPAQUE: col += printf("?"); break; case VCODE_TYPE_RESOLUTION: col += printf("R<"); col += vcode_dump_one_type(vt->base); col += printf(">"); break; case VCODE_TYPE_CLOSURE: col += printf("C<"); col += vcode_dump_one_type(vt->base); col += printf(">"); break; case VCODE_TYPE_CONTEXT: col += printf("P<%s>", istr(vt->name)); break; case VCODE_TYPE_DEBUG_LOCUS: col += printf("D<>"); break; case VCODE_TYPE_TRIGGER: col += printf("T<>"); break; case VCODE_TYPE_CONVERSION: col += printf("X<>"); break; } return col; } static void vcode_dump_tab(int col, int to_col) { if (col >= to_col) printf(" "); else { while (col < to_col) col += printf(" "); } } static void vcode_dump_comment(int col) { vcode_dump_tab(col, 40); color_printf("$cyan$// "); } static void vcode_dump_type(int col, vcode_type_t type, vcode_type_t bounds) { vcode_dump_comment(col); vcode_dump_one_type(type); if (!vtype_eq(type, bounds)) { printf(" => "); vcode_dump_one_type(bounds); } } static void vcode_dump_result_type(int col, const op_t *op) { if (op->result != VCODE_INVALID_REG) { reg_t *r = vcode_reg_data(op->result); vcode_dump_type(col, r->type, r->bounds); } } static int vcode_dump_var(vcode_var_t var, int hops) { vcode_unit_t owner = active_unit; while (owner && hops--) owner = owner->context; if (owner == NULL || var >= owner->vars.count) return color_printf("$red$invalid$$"); else { var_t *v = var_array_nth_ptr(&(owner->vars), var); return color_printf("$magenta$%s$$", istr(v->name)); } } void vcode_dump_with_mark(int mark_op, vcode_dump_fn_t callback, void *arg) { assert(active_unit != NULL); const vcode_unit_t vu = active_unit; vcode_block_t old_block = active_block; printf("\n"); if (vu->name != NULL) color_printf("Name $cyan$%s$$\n", istr(vu->name)); color_printf("Kind $cyan$"); switch (vu->kind) { case VCODE_UNIT_PROCESS: printf("process"); break; case VCODE_UNIT_FUNCTION: printf("function"); break; case VCODE_UNIT_PROCEDURE: printf("procedure"); break; case VCODE_UNIT_INSTANCE: printf("instance"); break; case VCODE_UNIT_THUNK: printf("thunk"); break; case VCODE_UNIT_PACKAGE: printf("package"); break; case VCODE_UNIT_PROTECTED: printf("protected"); break; case VCODE_UNIT_PROPERTY: printf("property"); break; } color_printf("$$\n"); if (vu->context != NULL) color_printf("Context $cyan$%s$$\n", istr(vu->context->name)); printf("Blocks %d\n", vu->blocks.count); printf("Registers %d\n", vu->regs.count); printf("Types %d\n", vu->types.count); for (int i = 0; i < vu->types.count; i++) { const vtype_t *t = &(vu->types.items[i]); if (t->kind == VCODE_TYPE_RECORD) { int col = 0; col += color_printf(" $magenta$%s$$", istr(t->name)); vcode_dump_tab(col, 40); color_printf("$cyan${"); for (unsigned i = 0; i < t->fields.count; i++) { if (i > 0) printf(", "); vcode_dump_one_type(t->fields.items[i]); } color_printf("}$$\n"); } } printf("Variables %d\n", vu->vars.count); for (int i = 0; i < vu->vars.count; i++) { const var_t *v = &(vu->vars.items[i]); int col = printf(" "); col += color_printf("$magenta$%s$$", istr(v->name)); vcode_dump_type(col, v->type, v->bounds); if (v->flags & VAR_SIGNAL) col += printf(", signal"); if (v->flags & VAR_HEAP) col += printf(", heap"); if (v->flags & VAR_CONST) col += printf(", constant"); if (v->flags & VAR_TEMP) col += printf(", temp"); color_printf("$$\n"); } if (vu->result != VCODE_INVALID_TYPE) { color_printf("Result $cyan$"); vcode_dump_one_type(vu->result); color_printf("$$\n"); } if (vu->kind == VCODE_UNIT_FUNCTION || vu->kind == VCODE_UNIT_PROCEDURE || vu->kind == VCODE_UNIT_PROPERTY || (vu->kind == VCODE_UNIT_PROTECTED && vu->params.count > 0)) { printf("Parameters %d\n", vu->params.count); for (size_t i = 0; i < vu->params.count; i++) { const param_t *p = &(vu->params.items[i]); int col = printf(" "); col += vcode_dump_reg(p->reg); while (col < 8) col += printf(" "); col += color_printf("$magenta$%s$$", istr(p->name)); vcode_dump_type(col, p->type, p->bounds); color_printf("$$\n"); } } printf("Begin\n"); for (int i = 0; i < vu->blocks.count; i++) { active_block = i; const block_t *b = &(vu->blocks.items[i]); for (int j = 0; j < b->ops.count; j++) { int col = 0; if (j == 0) col += color_printf(" $yellow$%2d:$$ ", i); else col += printf(" "); const op_t *op = &(b->ops.items[j]); switch (op->kind) { case VCODE_OP_CMP: { vcode_dump_reg(op->result); printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); switch (op->cmp) { case VCODE_CMP_EQ: printf(" == "); break; case VCODE_CMP_NEQ: printf(" != "); break; case VCODE_CMP_LT: printf(" < "); break; case VCODE_CMP_GT: printf(" > "); break; case VCODE_CMP_LEQ: printf(" <= "); break; case VCODE_CMP_GEQ: printf(" >= "); break; } vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_CONST: { col += vcode_dump_reg(op->result); col += printf(" := %s %"PRIi64"", vcode_op_string(op->kind), op->value); vcode_dump_result_type(col, op); } break; case VCODE_OP_CONST_REAL: { col += vcode_dump_reg(op->result); col += printf(" := %s %g", vcode_op_string(op->kind), op->real); vcode_dump_result_type(col, op); } break; case VCODE_OP_ALLOC: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_FCALL: { if (op->result != VCODE_INVALID_REG) { col += vcode_dump_reg(op->result); col += printf(" := "); } col += color_printf("%s $magenta$%s$$ ", vcode_op_string(op->kind), istr(op->func)); for (int i = 0; i < op->args.count; i++) { if (i > 0) col += printf(", "); col += vcode_dump_reg(op->args.items[i]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_SYSCALL: { if (op->result != VCODE_INVALID_REG) { col += vcode_dump_reg(op->result); col += printf(" := "); } col += color_printf("%s $magenta$%s$$ ", vcode_op_string(op->kind), istr(op->func)); for (int i = 1; i < op->args.count; i++) { if (i > 1) col += printf(", "); col += vcode_dump_reg(op->args.items[i]); } if (op->args.count > 1) col += printf(" "); col += color_printf("locus "); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_MAP_CONST: case VCODE_OP_MAP_SIGNAL: case VCODE_OP_MAP_IMPLICIT: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" to "); vcode_dump_reg(op->args.items[1]); printf(" count "); vcode_dump_reg(op->args.items[2]); } break; case VCODE_OP_DRIVE_SIGNAL: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" count "); vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_TRANSFER_SIGNAL: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" to "); vcode_dump_reg(op->args.items[1]); printf(" count "); vcode_dump_reg(op->args.items[2]); printf(" reject "); vcode_dump_reg(op->args.items[3]); printf(" after "); vcode_dump_reg(op->args.items[4]); } break; case VCODE_OP_RESOLVE_SIGNAL: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" resolution "); vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_PACKAGE_SCOPE: case VCODE_OP_ARRAY_SCOPE: case VCODE_OP_RECORD_SCOPE: { col += printf("%s locus ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_type(col, op->type, op->type); } break; case VCODE_OP_POP_SCOPE: { printf("%s", vcode_op_string(op->kind)); } break; case VCODE_OP_INIT_SIGNAL: { col += vcode_dump_reg(op->result); col += printf(" := "); col += printf("%s count ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" size "); col += vcode_dump_reg(op->args.items[1]); col += printf(" value "); col += vcode_dump_reg(op->args.items[2]); col += printf(" flags "); col += vcode_dump_reg(op->args.items[3]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[4]); if (op->args.count > 5) { col += printf(" offset "); col += vcode_dump_reg(op->args.items[5]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_IMPLICIT_SIGNAL: { col += vcode_dump_reg(op->result); col += printf(" := %s count ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" size "); col += vcode_dump_reg(op->args.items[1]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[2]); col += printf(" kind "); col += vcode_dump_reg(op->args.items[3]); col += printf(" closure "); col += vcode_dump_reg(op->args.items[4]); } break; case VCODE_OP_RESOLUTION_WRAPPER: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" nlits "); col += vcode_dump_reg(op->args.items[1]); vcode_dump_result_type(col, op); } break; case VCODE_OP_CLOSURE: case VCODE_OP_PROTECTED_INIT: { col += vcode_dump_reg(op->result); col += color_printf(" := %s $magenta$%s$$ context ", vcode_op_string(op->kind), istr(op->func)); col += vcode_dump_reg(op->args.items[0]); if (op->args.count >= 3) { col += printf(" path " ); col += vcode_dump_reg(op->args.items[1]); col += printf(" instance " ); col += vcode_dump_reg(op->args.items[2]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_PACKAGE_INIT: { col += vcode_dump_reg(op->result); col += color_printf(" := %s $magenta$%s$$", vcode_op_string(op->kind), istr(op->func)); if (op->args.count > 0) { col += printf(" context " ); col += vcode_dump_reg(op->args.items[0]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_PROCESS_INIT: { color_printf("%s $magenta$%s$$ locus ", vcode_op_string(op->kind), istr(op->func)); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_PROTECTED_FREE: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_WAIT: { color_printf("%s $yellow$%d$$", vcode_op_string(op->kind), op->targets.items[0]); if (op->args.items[0] != VCODE_INVALID_REG) { printf(" for "); vcode_dump_reg(op->args.items[0]); } } break; case VCODE_OP_JUMP: { color_printf("%s $yellow$%d$$", vcode_op_string(op->kind), op->targets.items[0]); } break; case VCODE_OP_COND: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); color_printf(" then $yellow$%d$$ else $yellow$%d$$", op->targets.items[0], op->targets.items[1]); } break; case VCODE_OP_ASSERT: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); if (op->args.items[2] != VCODE_INVALID_REG) { printf(" report "); vcode_dump_reg(op->args.items[2]); printf(" length "); vcode_dump_reg(op->args.items[3]); } printf(" severity "); vcode_dump_reg(op->args.items[1]); printf(" locus "); vcode_dump_reg(op->args.items[4]); if (op->args.count > 5) { printf(" hint "); vcode_dump_reg(op->args.items[5]); printf(" "); vcode_dump_reg(op->args.items[6]); } } break; case VCODE_OP_REPORT: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[1]); printf(" length "); vcode_dump_reg(op->args.items[2]); printf(" severity "); vcode_dump_reg(op->args.items[0]); printf(" locus "); vcode_dump_reg(op->args.items[3]); } break; case VCODE_OP_LOAD: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_var(op->address, 0); vcode_dump_result_type(col, op); } break; case VCODE_OP_LOAD_INDIRECT: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_STORE: { vcode_dump_var(op->address, 0); printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_STORE_INDIRECT: { vcode_dump_reg(op->args.items[1]); printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_INDEX: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_var(op->address, 0); if (op->args.count > 0) { col += printf(" + "); col += vcode_dump_reg(op->args.items[0]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_MUL: case VCODE_OP_ADD: case VCODE_OP_SUB: case VCODE_OP_DIV: case VCODE_OP_EXP: case VCODE_OP_MOD: case VCODE_OP_REM: case VCODE_OP_OR: case VCODE_OP_AND: case VCODE_OP_XOR: case VCODE_OP_XNOR: case VCODE_OP_NAND: case VCODE_OP_NOR: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); switch (op->kind) { case VCODE_OP_MUL: col += printf(" * "); break; case VCODE_OP_ADD: col += printf(" + "); break; case VCODE_OP_SUB: col += printf(" - "); break; case VCODE_OP_DIV: col += printf(" / "); break; case VCODE_OP_EXP: col += printf(" ** "); break; case VCODE_OP_MOD: col += printf(" %% "); break; case VCODE_OP_REM: col += printf(" %% "); break; case VCODE_OP_OR: col += printf(" || "); break; case VCODE_OP_AND: col += printf(" && "); break; case VCODE_OP_XOR: col += printf(" ^ "); break; case VCODE_OP_XNOR: col += printf(" !^ "); break; case VCODE_OP_NAND: col += printf(" !& "); break; case VCODE_OP_NOR: col += printf(" !| "); break; default: break; } col += vcode_dump_reg(op->args.items[1]); vcode_dump_result_type(col, op); } break; case VCODE_OP_TRAP_ADD: case VCODE_OP_TRAP_SUB: case VCODE_OP_TRAP_MUL: case VCODE_OP_TRAP_EXP: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); switch (op->kind) { case VCODE_OP_TRAP_ADD: col += printf(" + "); break; case VCODE_OP_TRAP_SUB: col += printf(" - "); break; case VCODE_OP_TRAP_MUL: col += printf(" * "); break; case VCODE_OP_TRAP_EXP: col += printf(" ** "); break; default: break; } col += vcode_dump_reg(op->args.items[1]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[2]); vcode_dump_result_type(col, op); } break; case VCODE_OP_NOT: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_COMMENT: { color_printf("$cyan$// %s$$ ", op->comment); } break; case VCODE_OP_CONST_ARRAY: case VCODE_OP_CONST_RECORD: { col += vcode_dump_reg(op->result); col += printf(" := const %c", op->kind == VCODE_OP_CONST_ARRAY ? '[' : '{'); for (int k = 0; k < op->args.count; k++) { if (k > 0) col += printf(","); col += vcode_dump_reg(op->args.items[k]); } putchar(op->kind == VCODE_OP_CONST_ARRAY ? ']' : '}'); vcode_dump_result_type(col + 1, op); } break; case VCODE_OP_CONST_REP: { col += vcode_dump_reg(op->result); col += printf(" := const ["); col += vcode_dump_reg(op->args.items[0]); col += printf("]*%"PRIi64, op->value); vcode_dump_result_type(col, op); } break; case VCODE_OP_ADDRESS_OF: case VCODE_OP_CAST: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_RETURN: { printf("%s ", vcode_op_string(op->kind)); if (op->args.count > 0) vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_SCHED_WAVEFORM: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" count "); vcode_dump_reg(op->args.items[1]); printf(" values "); vcode_dump_reg(op->args.items[2]); printf(" reject "); vcode_dump_reg(op->args.items[3]); printf(" after "); vcode_dump_reg(op->args.items[4]); } break; case VCODE_OP_FORCE: case VCODE_OP_RELEASE: case VCODE_OP_DEPOSIT_SIGNAL: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" count "); vcode_dump_reg(op->args.items[1]); if (op->args.count > 2) { printf(" values "); vcode_dump_reg(op->args.items[2]); } } break; case VCODE_OP_DISCONNECT: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" count "); vcode_dump_reg(op->args.items[1]); printf(" reject "); vcode_dump_reg(op->args.items[2]); printf(" after "); vcode_dump_reg(op->args.items[3]); } break; case VCODE_OP_NEG: case VCODE_OP_TRAP_NEG: case VCODE_OP_ABS: case VCODE_OP_RESOLVED: case VCODE_OP_LAST_VALUE: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); if (op->args.count > 1) { col += printf(" locus "); col += vcode_dump_reg(op->args.items[1]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_SELECT: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" then "); col += vcode_dump_reg(op->args.items[1]); col += printf(" else "); col += vcode_dump_reg(op->args.items[2]); vcode_dump_result_type(col, op); } break; case VCODE_OP_WRAP: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" ["); for (int i = 1; i < op->args.count; i += 3) { if (i > 1) col += printf(", "); col += vcode_dump_reg(op->args.items[i + 0]); col += printf(" "); col += vcode_dump_reg(op->args.items[i + 1]); col += printf(" "); col += vcode_dump_reg(op->args.items[i + 2]); } col += printf("]"); vcode_dump_result_type(col, op); } break; case VCODE_OP_UARRAY_LEFT: case VCODE_OP_UARRAY_RIGHT: case VCODE_OP_UARRAY_DIR: case VCODE_OP_UARRAY_LEN: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" dim %d", op->dim); vcode_dump_result_type(col, op); } break; case VCODE_OP_UNWRAP: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_VAR_UPREF: { col += vcode_dump_reg(op->result); col += printf(" := %s %d, ", vcode_op_string(op->kind), op->hops); col += vcode_dump_var(op->address, op->hops); vcode_dump_result_type(col, op); } break; case VCODE_OP_CONTEXT_UPREF: { col += vcode_dump_reg(op->result); col += printf(" := %s %d", vcode_op_string(op->kind), op->hops); vcode_dump_result_type(col, op); } break; case VCODE_OP_ACTIVE: case VCODE_OP_EVENT: case VCODE_OP_DRIVING: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" length "); col += vcode_dump_reg(op->args.items[1]); vcode_dump_result_type(col, op); } break; case VCODE_OP_RECORD_REF: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" field %d", op->field); vcode_dump_result_type(col, op); } break; case VCODE_OP_ARRAY_REF: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" offset "); col += vcode_dump_reg(op->args.items[1]); vcode_dump_result_type(col, op); } break; case VCODE_OP_COPY: { vcode_dump_reg(op->args.items[0]); printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[1]); if (op->args.count > 2) { printf(" count " ); vcode_dump_reg(op->args.items[2]); } } break; case VCODE_OP_SCHED_EVENT: case VCODE_OP_CLEAR_EVENT: { printf("%s on ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" count "); vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_PCALL: { color_printf("%s $magenta$%s$$", vcode_op_string(op->kind), istr(op->func)); for (int i = 0; i < op->args.count; i++) { printf("%s", i > 0 ? ", " : " "); vcode_dump_reg(op->args.items[i]); } if (op->targets.count > 0) color_printf(" resume $yellow$%d$$", op->targets.items[0]); } break; case VCODE_OP_RESUME: { color_printf("%s $magenta$%s$$", vcode_op_string(op->kind), istr(op->func)); } break; case VCODE_OP_MEMSET: { vcode_dump_reg(op->args.items[0]); printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[1]); printf(" length "); vcode_dump_reg(op->args.items[2]); } break; case VCODE_OP_CASE: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); color_printf(" default $yellow$%d$$", op->targets.items[0]); for (int i = 1; i < op->args.count; i++) { printf(" ["); vcode_dump_reg(op->args.items[i]); color_printf(" $yellow$%d$$]", op->targets.items[i]); } } break; case VCODE_OP_FILE_OPEN: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" name "); vcode_dump_reg(op->args.items[1]); printf(" length "); vcode_dump_reg(op->args.items[2]); printf(" kind "); vcode_dump_reg(op->args.items[3]); if (op->args.count == 5) { printf(" status "); vcode_dump_reg(op->args.items[4]); } } break; case VCODE_OP_FILE_WRITE: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" value "); vcode_dump_reg(op->args.items[1]); if (op->args.count == 3) { printf(" length "); vcode_dump_reg(op->args.items[2]); } } break; case VCODE_OP_FILE_READ: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" ptr "); vcode_dump_reg(op->args.items[1]); if (op->args.count >= 3) { printf(" inlen "); vcode_dump_reg(op->args.items[2]); if (op->args.count >= 4) { printf(" outlen "); vcode_dump_reg(op->args.items[3]); } } } break; case VCODE_OP_NULL: case VCODE_OP_NEW: { col += vcode_dump_reg(op->result); col += printf(" := %s", vcode_op_string(op->kind)); if (op->args.count == 1) { col += printf(" length "); col += vcode_dump_reg(op->args.items[0]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_NULL_CHECK: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_DEALLOCATE: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_ALL: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); vcode_dump_result_type(col, op); } break; case VCODE_OP_LAST_EVENT: case VCODE_OP_LAST_ACTIVE: case VCODE_OP_DRIVING_VALUE: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); if (op->args.count > 1) { col += printf(" length "); col += vcode_dump_reg(op->args.items[1]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_ALIAS_SIGNAL: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" locus "); vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_LENGTH_CHECK: { col += printf("%s left ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" == right "); col += vcode_dump_reg(op->args.items[1]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[2]); if (op->args.count > 3) { col += printf(" dim "); col += vcode_dump_reg(op->args.items[3]); } } break; case VCODE_OP_EXPONENT_CHECK: case VCODE_OP_ZERO_CHECK: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[1]); } break; case VCODE_OP_INDEX_CHECK: case VCODE_OP_RANGE_CHECK: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" left "); col += vcode_dump_reg(op->args.items[1]); col += printf(" right "); col += vcode_dump_reg(op->args.items[2]); col += printf(" dir "); col += vcode_dump_reg(op->args.items[3]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[4]); if (op->args.items[5] != op->args.items[4]) { col += printf(" hint "); col += vcode_dump_reg(op->args.items[5]); } } break; case VCODE_OP_DIR_CHECK: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += printf(" == "); col += vcode_dump_reg(op->args.items[1]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[2]); } break; case VCODE_OP_DEBUG_OUT: { col += printf("%s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_COVER_STMT: case VCODE_OP_COVER_BRANCH: case VCODE_OP_COVER_EXPR: { printf("%s %u ", vcode_op_string(op->kind), op->tag); } break; case VCODE_OP_COVER_TOGGLE: case VCODE_OP_COVER_STATE: { printf("%s %u ", vcode_op_string(op->kind), op->tag); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_UNDEFINED: { col += vcode_dump_reg(op->result); col += printf(" := %s", vcode_op_string(op->kind)); vcode_dump_result_type(col, op); } break; case VCODE_OP_RANGE_LENGTH: case VCODE_OP_RANGE_NULL: { col += vcode_dump_reg(op->result); col += printf(" := %s left ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); col += printf(" right "); vcode_dump_reg(op->args.items[1]); col += printf(" dir "); col += vcode_dump_reg(op->args.items[2]); vcode_dump_result_type(col, op); } break; case VCODE_OP_LINK_PACKAGE: { col += vcode_dump_reg(op->result); col += color_printf(" := %s $magenta$%s$$", vcode_op_string(op->kind), istr(op->ident)); if (op->args.count > 0) { col += printf(" locus "); col += vcode_dump_reg(op->args.items[0]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_LINK_VAR: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += color_printf(" $magenta$%s$$", istr(op->ident)); vcode_dump_result_type(col, op); } break; case VCODE_OP_UNREACHABLE: { printf("%s", vcode_op_string(op->kind)); if (op->args.count > 0) { printf(" "); vcode_dump_reg(op->args.items[0]); } } break; case VCODE_OP_DEBUG_LOCUS: { col += vcode_dump_reg(op->result); col += color_printf(" := %s $magenta$", vcode_op_string(op->kind)); tree_t t = tree_from_object(op->object); if (t != NULL) col += printf("%s@", tree_kind_str(tree_kind(t))); col += color_printf("%p$$", op->object); vcode_dump_result_type(col, op); } break; case VCODE_OP_ENTER_STATE: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); if (op->args.count > 1) { printf(" strong "); vcode_dump_reg(op->args.items[1]); } } break; case VCODE_OP_REFLECT_VALUE: { col += vcode_dump_reg(op->result); col += printf(" := %s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); col += printf(" context "); vcode_dump_reg(op->args.items[1]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[2]); if (op->args.count > 3) { col += printf(" bounds "); col += vcode_dump_reg(op->args.items[3]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_REFLECT_SUBTYPE: { col += vcode_dump_reg(op->result); col += printf(" := %s context ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); col += printf(" locus "); col += vcode_dump_reg(op->args.items[1]); if (op->args.count > 2) { col += printf(" bounds "); col += vcode_dump_reg(op->args.items[2]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_FUNCTION_TRIGGER: { col += vcode_dump_reg(op->result); col += color_printf(" := %s $magenta$%s$$ ", vcode_op_string(op->kind), istr(op->func)); for (int i = 0; i < op->args.count; i++) { if (i > 0) col += printf(", "); col += vcode_dump_reg(op->args.items[i]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_OR_TRIGGER: case VCODE_OP_CMP_TRIGGER: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); if (op->kind == VCODE_OP_OR_TRIGGER) col += printf(" || "); else col += printf(" == "); col += vcode_dump_reg(op->args.items[1]); vcode_dump_result_type(col, op); } break; case VCODE_OP_ADD_TRIGGER: { printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); } break; case VCODE_OP_PUT_CONVERSION: { color_printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" signal "); vcode_dump_reg(op->args.items[1]); printf(" count "); vcode_dump_reg(op->args.items[2]); printf(" values "); vcode_dump_reg(op->args.items[3]); } break; case VCODE_OP_PORT_CONVERSION: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); if (op->args.count > 1) { col += printf(" effective "); col += vcode_dump_reg(op->args.items[1]); } vcode_dump_result_type(col, op); } break; case VCODE_OP_CONVERT_IN: case VCODE_OP_CONVERT_OUT: { color_printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" signal "); vcode_dump_reg(op->args.items[1]); printf(" count "); vcode_dump_reg(op->args.items[2]); } break; case VCODE_OP_BIND_FOREIGN: { color_printf("%s ", vcode_op_string(op->kind)); vcode_dump_reg(op->args.items[0]); printf(" length "); vcode_dump_reg(op->args.items[1]); if (op->args.count > 2) { printf(" locus "); vcode_dump_reg(op->args.items[1]); } } break; case VCODE_OP_INSTANCE_NAME: case VCODE_OP_BIND_EXTERNAL: { col += vcode_dump_reg(op->result); col += color_printf(" := %s ", vcode_op_string(op->kind)); col += vcode_dump_reg(op->args.items[0]); col += color_printf(" scope $magenta$%s$$", istr(op->ident)); vcode_dump_result_type(col, op); } break; } if (j == mark_op && i == old_block) color_printf("\t $red$<----$$"); color_printf("$$\n"); if (callback != NULL) (*callback)(j, arg); } if (b->ops.count == 0) color_printf(" $yellow$%2d:$$ $red$Empty basic block$$\n", i); } printf("\n"); fflush(stdout); active_block = old_block; } LCOV_EXCL_STOP bool vtype_eq(vcode_type_t a, vcode_type_t b) { assert(active_unit != NULL); if (a == b) return true; else { const vtype_t *at = vcode_type_data(a); const vtype_t *bt = vcode_type_data(b); if (at->kind != bt->kind) return false; switch (at->kind) { case VCODE_TYPE_INT: return (at->low == bt->low) && (at->high == bt->high); case VCODE_TYPE_REAL: return (at->rlow == bt->rlow) && (at->rhigh == bt->rhigh); case VCODE_TYPE_CARRAY: return at->size == bt->size && vtype_eq(at->elem, bt->elem); case VCODE_TYPE_UARRAY: return at->dims == bt->dims && vtype_eq(at->elem, bt->elem); case VCODE_TYPE_POINTER: case VCODE_TYPE_ACCESS: return vtype_eq(at->pointed, bt->pointed); case VCODE_TYPE_OFFSET: case VCODE_TYPE_OPAQUE: case VCODE_TYPE_DEBUG_LOCUS: case VCODE_TYPE_TRIGGER: case VCODE_TYPE_CONVERSION: return true; case VCODE_TYPE_RESOLUTION: case VCODE_TYPE_CLOSURE: case VCODE_TYPE_SIGNAL: case VCODE_TYPE_FILE: return vtype_eq(at->base, bt->base); case VCODE_TYPE_RECORD: case VCODE_TYPE_CONTEXT: return at->name == bt->name; } return false; } } void vcode_dump(void) { vcode_dump_with_mark(-1, NULL, NULL); } static vcode_type_t vtype_new(vtype_t *new) { int index = active_unit->types.count - 1; vcode_type_t type = MAKE_HANDLE(active_unit->depth, index); for (int i = 0; i < index; i++) { vcode_type_t this = MAKE_HANDLE(active_unit->depth, i); if (vtype_eq(this, type)) { active_unit->types.count--; return this; } } return type; } vcode_type_t vtype_int(int64_t low, int64_t high) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_INT; n->low = low; n->high = high; switch (bits_for_range(low, high)) { case 64: n->repr = low < 0 ? VCODE_REPR_I64 : VCODE_REPR_U64; break; case 32: n->repr = low < 0 ? VCODE_REPR_I32 : VCODE_REPR_U32; break; case 16: n->repr = low < 0 ? VCODE_REPR_I16 : VCODE_REPR_U16; break; case 8: n->repr = low < 0 ? VCODE_REPR_I8 : VCODE_REPR_U8; break; case 1: n->repr = VCODE_REPR_U1; break; case 0: n->repr = VCODE_REPR_I64; // Null range break; default: fatal_trace("cannot represent %"PRIi64"..%"PRIi64, low, high); } return vtype_new(n); } vcode_type_t vtype_bool(void) { return vtype_int(0, 1); } vcode_type_t vtype_carray(int size, vcode_type_t elem, vcode_type_t bounds) { assert(active_unit != NULL); const vtype_kind_t ekind = vtype_kind(elem); VCODE_ASSERT(ekind != VCODE_TYPE_CARRAY && ekind != VCODE_TYPE_UARRAY, "array types may not be nested"); vtype_t *n = vtype_array_alloc(&(active_unit->types)); memset(n, '\0', sizeof(vtype_t)); n->kind = VCODE_TYPE_CARRAY; n->elem = elem; n->bounds = bounds; n->size = MAX(size, 0); return vtype_new(n); } vcode_type_t vtype_find_named_record(ident_t name) { assert(active_unit != NULL); for (int i = 0; i < active_unit->types.count; i++) { vtype_t *other = &(active_unit->types.items[i]); if (other->kind == VCODE_TYPE_RECORD && other->name == name) return MAKE_HANDLE(active_unit->depth, i); } return VCODE_INVALID_TYPE; } vcode_type_t vtype_named_record(ident_t name, const vcode_type_t *field_types, int nfields) { assert(active_unit != NULL); vtype_t *data = NULL; vcode_type_t handle = vtype_find_named_record(name); if (handle == VCODE_INVALID_TYPE) { data = vtype_array_alloc(&(active_unit->types)); memset(data, '\0', sizeof(vtype_t)); data->kind = VCODE_TYPE_RECORD; data->name = name; handle = vtype_new(data); } else { data = vcode_type_data(handle); VCODE_ASSERT(data->fields.count == 0, "record type %s already defined", istr(name)); } vcode_type_array_resize(&(data->fields), 0, VCODE_INVALID_TYPE); for (int i = 0; i < nfields; i++) vcode_type_array_add(&(data->fields), field_types[i]); return handle; } vcode_type_t vtype_uarray(int ndim, vcode_type_t elem, vcode_type_t bounds) { assert(active_unit != NULL); const vtype_kind_t ekind = vtype_kind(elem); VCODE_ASSERT(ekind != VCODE_TYPE_CARRAY && ekind != VCODE_TYPE_UARRAY, "array types may not be nested"); VCODE_ASSERT(ndim > 0, "uarray must have at least one dimension"); vtype_t *n = vtype_array_alloc(&(active_unit->types)); memset(n, '\0', sizeof(vtype_t)); n->kind = VCODE_TYPE_UARRAY; n->elem = elem; n->bounds = bounds; n->dims = ndim; return vtype_new(n); } vcode_type_t vtype_pointer(vcode_type_t to) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_POINTER; n->pointed = to; VCODE_ASSERT(vtype_kind(to) != VCODE_TYPE_CARRAY, "cannot get pointer to carray type"); return vtype_new(n); } vcode_type_t vtype_access(vcode_type_t to) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_ACCESS; n->pointed = to; return vtype_new(n); } vcode_type_t vtype_signal(vcode_type_t base) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_SIGNAL; n->base = base; VCODE_ASSERT(vtype_is_scalar(base), "signal base type must be scalar"); return vtype_new(n); } vcode_type_t vtype_resolution(vcode_type_t base) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_RESOLUTION; n->base = base; return vtype_new(n); } vcode_type_t vtype_closure(vcode_type_t result) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_CLOSURE; n->base = result; return vtype_new(n); } vcode_type_t vtype_context(ident_t name) { assert(active_unit != NULL); assert(name != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_CONTEXT; n->name = name; return vtype_new(n); } vcode_type_t vtype_file(vcode_type_t base) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_FILE; n->base = base; return vtype_new(n); } vcode_type_t vtype_offset(void) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_OFFSET; n->low = INT64_MIN; n->high = INT64_MAX; n->repr = VCODE_REPR_I64; return vtype_new(n); } vcode_type_t vtype_time(void) { return vtype_int(INT64_MIN, INT64_MAX); } vcode_type_t vtype_char(void) { return vtype_int(0, 255); } vcode_type_t vtype_opaque(void) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_OPAQUE; return vtype_new(n); } vcode_type_t vtype_debug_locus(void) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_DEBUG_LOCUS; return vtype_new(n); } vcode_type_t vtype_trigger(void) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_TRIGGER; return vtype_new(n); } vcode_type_t vtype_conversion(void) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_CONVERSION; return vtype_new(n); } vcode_type_t vtype_real(double low, double high) { assert(active_unit != NULL); vtype_t *n = vtype_array_alloc(&(active_unit->types)); n->kind = VCODE_TYPE_REAL; n->rlow = low; n->rhigh = high; return vtype_new(n); } vtype_kind_t vtype_kind(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); return vt->kind; } vtype_repr_t vtype_repr(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_INT || vt->kind == VCODE_TYPE_OFFSET); return vt->repr; } vcode_type_t vtype_elem(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_CARRAY || vt->kind == VCODE_TYPE_UARRAY); return vt->elem; } vcode_type_t vtype_base(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_SIGNAL || vt->kind == VCODE_TYPE_FILE || vt->kind == VCODE_TYPE_RESOLUTION || vt->kind == VCODE_TYPE_CLOSURE); return vt->base; } vcode_type_t vtype_bounds(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_CARRAY || vt->kind == VCODE_TYPE_UARRAY); return vt->bounds; } unsigned vtype_dims(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_UARRAY); return vt->dims; } unsigned vtype_size(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_CARRAY); return vt->size; } int vtype_fields(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_RECORD); return vt->fields.count; } vcode_type_t vtype_field(vcode_type_t type, int field) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_RECORD); return vcode_type_array_nth(&(vt->fields), field); } ident_t vtype_name(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_RECORD || vt->kind == VCODE_TYPE_CONTEXT); return vt->name; } vcode_type_t vtype_pointed(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_POINTER || vt->kind == VCODE_TYPE_ACCESS); return vt->pointed; } int64_t vtype_low(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_INT || vt->kind == VCODE_TYPE_OFFSET); return vt->low; } int64_t vtype_high(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); assert(vt->kind == VCODE_TYPE_INT || vt->kind == VCODE_TYPE_OFFSET); return vt->high; } static bool vtype_is_pointer(vcode_type_t type, vtype_kind_t to) { return vtype_kind(type) == VCODE_TYPE_POINTER && vtype_kind(vtype_pointed(type)) == to; } bool vtype_is_scalar(vcode_type_t type) { const vtype_kind_t kind = vtype_kind(type); return kind == VCODE_TYPE_INT || kind == VCODE_TYPE_OFFSET || kind == VCODE_TYPE_UARRAY || kind == VCODE_TYPE_POINTER || kind == VCODE_TYPE_FILE || kind == VCODE_TYPE_ACCESS || kind == VCODE_TYPE_REAL || kind == VCODE_TYPE_SIGNAL || kind == VCODE_TYPE_CONTEXT || kind == VCODE_TYPE_TRIGGER || kind == VCODE_TYPE_RESOLUTION; } bool vtype_is_composite(vcode_type_t type) { const vtype_kind_t kind = vtype_kind(type); return kind == VCODE_TYPE_RECORD || kind == VCODE_TYPE_CARRAY; } bool vtype_is_signal(vcode_type_t type) { vtype_t *vt = vcode_type_data(type); switch (vt->kind) { case VCODE_TYPE_SIGNAL: return true; case VCODE_TYPE_POINTER: return vtype_is_signal(vt->pointed); case VCODE_TYPE_RECORD: for (int i = 0; i < vt->fields.count; i++) { if (vtype_is_signal(vt->fields.items[i])) return true; } return false; case VCODE_TYPE_UARRAY: case VCODE_TYPE_CARRAY: return vtype_is_signal(vt->elem); default: return false; } } int vtype_repr_bits(vtype_repr_t repr) { switch (repr) { case VCODE_REPR_U1: return 1; case VCODE_REPR_U8: case VCODE_REPR_I8: return 8; case VCODE_REPR_U16: case VCODE_REPR_I16: return 16; case VCODE_REPR_U32: case VCODE_REPR_I32: return 32; case VCODE_REPR_U64: case VCODE_REPR_I64: return 64; default: return -1; } } bool vtype_repr_signed(vtype_repr_t repr) { return repr == VCODE_REPR_I8 || repr == VCODE_REPR_I16 || repr == VCODE_REPR_I32 || repr == VCODE_REPR_I64; } static int64_t vtype_repr_low(vtype_repr_t repr) { switch (repr) { case VCODE_REPR_U1: case VCODE_REPR_U8: case VCODE_REPR_U16: case VCODE_REPR_U32: case VCODE_REPR_U64: return 0; case VCODE_REPR_I8: return INT8_MIN; case VCODE_REPR_I16: return INT16_MIN; case VCODE_REPR_I32: return INT32_MIN; case VCODE_REPR_I64: return INT64_MIN; default: return 0; } } static uint64_t vtype_repr_high(vtype_repr_t repr) { switch (repr) { case VCODE_REPR_U1: return 1; case VCODE_REPR_U8: return UINT8_MAX; case VCODE_REPR_U16: return UINT16_MAX; case VCODE_REPR_U32: return UINT32_MAX; case VCODE_REPR_U64: return UINT64_MAX; case VCODE_REPR_I8: return INT8_MAX; case VCODE_REPR_I16: return INT16_MAX; case VCODE_REPR_I32: return INT32_MAX; case VCODE_REPR_I64: return INT64_MAX; default: return 0; } } static bool vtype_clamp_to_repr(vtype_repr_t repr, int64_t *low, int64_t *high) { int64_t clamp_low = vtype_repr_low(repr); uint64_t clamp_high = vtype_repr_high(repr); if (*low >= clamp_low && *high <= clamp_high) return true; else { *low = MAX(clamp_low, *low); *high = MIN(clamp_high, *high); return false; } } int vcode_count_params(void) { assert(active_unit != NULL); assert(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_PROCEDURE || active_unit->kind == VCODE_UNIT_PROPERTY || active_unit->kind == VCODE_UNIT_PROTECTED); return active_unit->params.count; } vcode_type_t vcode_param_type(int param) { assert(active_unit != NULL); assert(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_PROCEDURE || active_unit->kind == VCODE_UNIT_PROPERTY || active_unit->kind == VCODE_UNIT_PROTECTED); assert(param < active_unit->params.count); return active_unit->params.items[param].type; } ident_t vcode_param_name(int param) { assert(active_unit != NULL); assert(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_PROCEDURE || active_unit->kind == VCODE_UNIT_PROPERTY || active_unit->kind == VCODE_UNIT_PROTECTED); assert(param < active_unit->params.count); return active_unit->params.items[param].name; } vcode_reg_t vcode_param_reg(int param) { assert(active_unit != NULL); assert(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_PROCEDURE || active_unit->kind == VCODE_UNIT_PROPERTY || active_unit->kind == VCODE_UNIT_PROTECTED); assert(param < active_unit->params.count); return active_unit->params.items[param].reg; } vcode_block_t emit_block(void) { assert(active_unit != NULL); vcode_block_t bnum = active_unit->blocks.count; block_t *bptr = block_array_alloc(&(active_unit->blocks)); memset(bptr, '\0', sizeof(block_t)); if (active_block != VCODE_INVALID_BLOCK) bptr->last_loc = active_unit->blocks.items[active_block].last_loc; else bptr->last_loc = LOC_INVALID; return bnum; } void vcode_select_unit(vcode_unit_t unit) { active_unit = unit; active_block = VCODE_INVALID_BLOCK; } void vcode_select_block(vcode_block_t block) { assert(active_unit != NULL); active_block = block; } vcode_block_t vcode_active_block(void) { assert(active_unit != NULL); assert(active_block != -1); return active_block; } const loc_t *vcode_last_loc(void) { return &(vcode_block_data()->last_loc); } vcode_unit_t vcode_active_unit(void) { assert(active_unit != NULL); return active_unit; } ident_t vcode_unit_name(vcode_unit_t vu) { assert(vu != NULL); return vu->name; } bool vcode_unit_has_undefined(vcode_unit_t vu) { assert(vu != NULL); return !!(vu->flags & UNIT_UNDEFINED); } int vcode_unit_depth(vcode_unit_t vu) { assert(vu != NULL); return vu->depth; } void vcode_set_result(vcode_type_t type) { assert(active_unit != NULL); assert(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_THUNK); active_unit->result = type; } vcode_type_t vcode_unit_result(vcode_unit_t vu) { assert(vu != NULL); assert(vu->kind == VCODE_UNIT_FUNCTION || vu->kind == VCODE_UNIT_THUNK); return vu->result; } vunit_kind_t vcode_unit_kind(vcode_unit_t vu) { assert(vu != NULL); return vu->kind; } vcode_unit_t vcode_unit_context(vcode_unit_t vu) { assert(vu != NULL); return vu->context; } object_t *vcode_unit_object(vcode_unit_t vu) { assert(vu != NULL); return vu->object; } static unsigned vcode_unit_calc_depth(vcode_unit_t unit) { int hops = 0; for (; (unit = unit->context); hops++) ; return hops; } static void vcode_add_child(vcode_unit_t context, vcode_unit_t child) { assert(context->kind != VCODE_UNIT_THUNK); child->next = NULL; if (context->children == NULL) context->children = child; else { vcode_unit_t it; for (it = context->children; it->next != NULL; it = it->next) ; it->next = child; } } vcode_unit_t emit_function(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_FUNCTION; vu->name = name; vu->context = context; vu->result = VCODE_INVALID_TYPE; vu->depth = vcode_unit_calc_depth(vu); vu->object = obj; vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_procedure(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_PROCEDURE; vu->name = name; vu->context = context; vu->result = VCODE_INVALID_TYPE; vu->depth = vcode_unit_calc_depth(vu); vu->object = obj; vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_process(ident_t name, object_t *obj, vcode_unit_t context) { assert(context->kind == VCODE_UNIT_INSTANCE); vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_PROCESS; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->object = obj; vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_instance(ident_t name, object_t *obj, vcode_unit_t context) { assert(context == NULL || context->kind == VCODE_UNIT_INSTANCE); vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_INSTANCE; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->object = obj; if (context != NULL) vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_package(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_PACKAGE; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->object = obj; if (context != NULL) vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_protected(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_PROTECTED; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->object = obj; if (context != NULL) vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_property(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_PROPERTY; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->object = obj; if (context != NULL) vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); emit_debug_info(&(obj->loc)); return vu; } vcode_unit_t emit_thunk(ident_t name, object_t *obj, vcode_unit_t context) { vcode_unit_t vu = xcalloc(sizeof(struct _vcode_unit)); vu->kind = VCODE_UNIT_THUNK; vu->name = name; vu->context = context; vu->depth = vcode_unit_calc_depth(vu); vu->result = VCODE_INVALID_TYPE; vu->depth = vcode_unit_calc_depth(vu); vu->object = obj; if (context != NULL) vcode_add_child(context, vu); vcode_select_unit(vu); vcode_select_block(emit_block()); return vu; } void emit_assert(vcode_reg_t value, vcode_reg_t message, vcode_reg_t length, vcode_reg_t severity, vcode_reg_t locus, vcode_reg_t hint_left, vcode_reg_t hint_right) { int64_t value_const; if (vcode_reg_const(value, &value_const) && value_const != 0) { emit_comment("Always true assertion on r%d", value); return; } op_t *op = vcode_add_op(VCODE_OP_ASSERT); vcode_add_arg(op, value); vcode_add_arg(op, severity); vcode_add_arg(op, message); vcode_add_arg(op, length); vcode_add_arg(op, locus); if (hint_left != VCODE_INVALID_REG) { vcode_add_arg(op, hint_left); vcode_add_arg(op, hint_right); VCODE_ASSERT(vtype_is_scalar(vcode_reg_type(hint_left)), "left hint must be scalar"); VCODE_ASSERT(vtype_is_scalar(vcode_reg_type(hint_right)), "right hint must be scalar"); } VCODE_ASSERT(vtype_eq(vcode_reg_type(value), vtype_bool()), "value parameter to assert is not bool"); VCODE_ASSERT(message == VCODE_INVALID_REG || vcode_reg_kind(message) == VCODE_TYPE_POINTER, "message parameter to assert is not a pointer"); VCODE_ASSERT(vtype_eq(vcode_reg_type(value), vtype_bool()), "value parameter to assert is not bool"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to report must be a debug locus"); } void emit_report(vcode_reg_t message, vcode_reg_t length, vcode_reg_t severity, vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_REPORT); vcode_add_arg(op, severity); vcode_add_arg(op, message); vcode_add_arg(op, length); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(message) == VCODE_TYPE_POINTER, "message parameter to report is not a pointer"); VCODE_ASSERT(vtype_eq(vtype_pointed(vcode_reg_type(message)), vtype_char()), "message parameter to report is not a character pointer"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to report must be a debug locus"); } vcode_reg_t emit_cmp(vcode_cmp_t cmp, vcode_reg_t lhs, vcode_reg_t rhs) { if (lhs == rhs) { if (cmp == VCODE_CMP_EQ) return emit_const(vtype_bool(), 1); else if (cmp == VCODE_CMP_NEQ) return emit_const(vtype_bool(), 0); else if (cmp == VCODE_CMP_LEQ || cmp == VCODE_CMP_GEQ) return emit_const(vtype_bool(), 1); else if (cmp == VCODE_CMP_LT || cmp == VCODE_CMP_GT) return emit_const(vtype_bool(), 0); } int64_t lconst, rconst; if (vcode_reg_const(lhs, &lconst) && vcode_reg_const(rhs, &rconst)) { switch (cmp) { case VCODE_CMP_EQ: return emit_const(vtype_bool(), lconst == rconst); case VCODE_CMP_NEQ: return emit_const(vtype_bool(), lconst != rconst); case VCODE_CMP_LT: return emit_const(vtype_bool(), lconst < rconst); case VCODE_CMP_GT: return emit_const(vtype_bool(), lconst > rconst); case VCODE_CMP_LEQ: return emit_const(vtype_bool(), lconst <= rconst); case VCODE_CMP_GEQ: return emit_const(vtype_bool(), lconst >= rconst); default: fatal_trace("cannot fold comparison %d", cmp); } } // Reuse any previous operation in this block with the same arguments VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CMP) { if (other->args.count == 2 && other->args.items[0] == lhs && other->args.items[1] == rhs && other->cmp == cmp) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CMP); vcode_add_arg(op, lhs); vcode_add_arg(op, rhs); op->cmp = cmp; op->result = vcode_add_reg(vtype_bool()); VCODE_ASSERT(vtype_eq(vcode_reg_type(lhs), vcode_reg_type(rhs)), "arguments to cmp are not the same type"); return op->result; } vcode_reg_t emit_fcall(ident_t func, vcode_type_t type, vcode_type_t bounds, const vcode_reg_t *args, int nargs) { op_t *o = vcode_add_op(VCODE_OP_FCALL); o->func = func; o->type = type; for (int i = 0; i < nargs; i++) vcode_add_arg(o, args[i]); for (int i = 0; i < nargs; i++) VCODE_ASSERT(args[i] != VCODE_INVALID_REG, "invalid argument to function"); VCODE_ASSERT(nargs > 0 && vcode_reg_kind(args[0]) == VCODE_TYPE_CONTEXT, "first argument to VHDL function must be context pointer"); if (type == VCODE_INVALID_TYPE) return (o->result = VCODE_INVALID_REG); else { o->result = vcode_add_reg(type); reg_t *rr = vcode_reg_data(o->result); rr->bounds = bounds; return o->result; } } void emit_pcall(ident_t func, const vcode_reg_t *args, int nargs, vcode_block_t resume_bb) { op_t *o = vcode_add_op(VCODE_OP_PCALL); o->func = func; for (int i = 0; i < nargs; i++) vcode_add_arg(o, args[i]); vcode_block_array_add(&(o->targets), resume_bb); for (int i = 0; i < nargs; i++) VCODE_ASSERT(args[i] != VCODE_INVALID_REG, "invalid argument to procedure"); VCODE_ASSERT(nargs > 0 && vcode_reg_kind(args[0]) == VCODE_TYPE_CONTEXT, "first argument to VHDL procedure must be context pointer"); } vcode_reg_t emit_syscall(ident_t func, vcode_type_t type, vcode_type_t bounds, vcode_reg_t locus, const vcode_reg_t *args, int nargs) { op_t *o = vcode_add_op(VCODE_OP_SYSCALL); o->func = func; o->type = type; vcode_add_arg(o, locus); for (int i = 0; i < nargs; i++) vcode_add_arg(o, args[i]); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to syscall must be a debug locus"); for (int i = 0; i < nargs; i++) VCODE_ASSERT(args[i] != VCODE_INVALID_REG, "invalid argument to syscall"); if (type == VCODE_INVALID_TYPE) return (o->result = VCODE_INVALID_REG); else { o->result = vcode_add_reg(type); reg_t *rr = vcode_reg_data(o->result); rr->bounds = bounds; return o->result; } } vcode_reg_t emit_alloc(vcode_type_t type, vcode_type_t bounds, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_ALLOC); op->type = type; op->result = vcode_add_reg(vtype_pointer(type)); vcode_add_arg(op, count); const vtype_kind_t tkind = vtype_kind(type); VCODE_ASSERT(tkind != VCODE_TYPE_CARRAY && tkind != VCODE_TYPE_UARRAY, "alloca element type cannot be array"); VCODE_ASSERT(count != VCODE_INVALID_REG, "alloca must have valid count argument"); reg_t *r = vcode_reg_data(op->result); r->bounds = bounds; return op->result; } vcode_reg_t emit_const(vcode_type_t type, int64_t value) { // Reuse any previous constant in this block with the same type and value VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONST) { if (other->value == value && vtype_eq(type, other->type)) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CONST); op->value = value; op->type = type; op->result = vcode_add_reg(type); vtype_kind_t type_kind = vtype_kind(type); VCODE_ASSERT(type_kind == VCODE_TYPE_INT || type_kind == VCODE_TYPE_OFFSET, "constant must have integer or offset type"); reg_t *r = vcode_reg_data(op->result); r->bounds = vtype_int(value, value); return op->result; } vcode_reg_t emit_const_real(vcode_type_t type, double value) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONST_REAL) { if (other->real == value && other->type == type) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CONST_REAL); op->real = value; op->type = type; op->result = vcode_add_reg(op->type); reg_t *r = vcode_reg_data(op->result); r->bounds = vtype_real(value, value); return op->result; } vcode_reg_t emit_const_array(vcode_type_t type, vcode_reg_t *values, int num) { vtype_kind_t kind = vtype_kind(type); // Reuse any previous operation in this block with the same arguments VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONST_ARRAY) { if (other->args.count != num) continue; else if (!vtype_eq(vcode_reg_type(other->result), type)) continue; bool match = true; for (int i = 0; match && i < num; i++) { if (other->args.items[i] != values[i]) match = false; } if (match) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CONST_ARRAY); op->result = vcode_add_reg(type); for (int i = 0; i < num; i++) vcode_add_arg(op, values[i]); VCODE_ASSERT(kind == VCODE_TYPE_CARRAY, "constant array must have constrained array type"); VCODE_ASSERT(vtype_size(type) == num, "expected %d elements but have %d", vtype_size(type), num); #ifdef DEBUG vcode_type_t elem = vtype_elem(type); for (int i = 0; i < num; i++) { VCODE_ASSERT(vtype_eq(vcode_reg_type(values[i]), elem), "wrong element type for item %d", i); vcode_assert_const(values[i], "array"); } #endif reg_t *r = vcode_reg_data(op->result); r->bounds = vtype_elem(type); return op->result; } vcode_reg_t emit_const_rep(vcode_type_t type, vcode_reg_t value, int rep) { // Reuse any previous operation in this block with the same arguments VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONST_REP) { if (other->args.items[0] == value && other->value == rep) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CONST_REP); op->value = rep; vcode_add_arg(op, value); VCODE_ASSERT(vtype_kind(type) == VCODE_TYPE_CARRAY, "constant array must have constrained array type"); VCODE_ASSERT(rep >= 0, "repeat count must be non-negative"); DEBUG_ONLY(vcode_assert_const(value, "repeat")); op->result = vcode_add_reg(type); reg_t *r = vcode_reg_data(op->result); r->bounds = vtype_bounds(type); return op->result; } vcode_reg_t emit_const_record(vcode_type_t type, vcode_reg_t *values, int num) { // Reuse any previous constant in this block with the same type and value VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONST_RECORD) { if (other->args.count == num && vtype_eq(type, other->type)) { bool same_regs = true; for (int i = 0; same_regs && i < num; i++) same_regs = other->args.items[i] == values[i]; if (same_regs) return other->result; } } op_t *op = vcode_add_op(VCODE_OP_CONST_RECORD); op->type = type; op->result = vcode_add_reg(type); for (int i = 0; i < num; i++) vcode_add_arg(op, values[i]); VCODE_ASSERT(vtype_kind(type) == VCODE_TYPE_RECORD, "constant record must have record type"); VCODE_ASSERT(vtype_fields(type) == num, "expected %d fields but have %d", vtype_fields(type), num); #ifdef DEBUG for (int i = 0; i < num; i++) { VCODE_ASSERT(vtype_eq(vtype_field(type, i), vcode_reg_type(values[i])), "wrong type for field %d", i); vcode_assert_const(values[i], "record"); } #endif return op->result; } vcode_reg_t emit_address_of(vcode_reg_t value) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_ADDRESS_OF) { if (other->args.items[0] == value) return other->result; } op_t *op = vcode_add_op(VCODE_OP_ADDRESS_OF); vcode_add_arg(op, value); vcode_type_t type = vcode_reg_type(value); VCODE_ASSERT(vtype_is_composite(type), "address of argument must be record or array"); if (vtype_kind(type) == VCODE_TYPE_CARRAY) { vcode_type_t elem = vtype_elem(type); op->result = vcode_add_reg(vtype_pointer(elem)); reg_t *rr = vcode_reg_data(op->result); rr->bounds = elem; return op->result; } else return (op->result = vcode_add_reg(vtype_pointer(type))); } void emit_wait(vcode_block_t target, vcode_reg_t time) { op_t *op = vcode_add_op(VCODE_OP_WAIT); vcode_add_target(op, target); vcode_add_arg(op, time); VCODE_ASSERT(time == VCODE_INVALID_REG || vcode_reg_kind(time) == VCODE_TYPE_INT, "wait time must have integer type"); VCODE_ASSERT(active_unit->kind == VCODE_UNIT_PROCEDURE || active_unit->kind == VCODE_UNIT_PROCESS, "wait only allowed in process or procedure"); } void emit_jump(vcode_block_t target) { op_t *op = vcode_add_op(VCODE_OP_JUMP); vcode_add_target(op, target); VCODE_ASSERT(target != VCODE_INVALID_BLOCK, "invalid jump target"); } vcode_var_t emit_var(vcode_type_t type, vcode_type_t bounds, ident_t name, vcode_var_flags_t flags) { assert(active_unit != NULL); vcode_var_t var = active_unit->vars.count; var_t *v = var_array_alloc(&(active_unit->vars)); memset(v, '\0', sizeof(var_t)); v->type = type; v->bounds = bounds; v->name = name; v->flags = flags; return var; } vcode_reg_t emit_param(vcode_type_t type, vcode_type_t bounds, ident_t name) { assert(active_unit != NULL); param_t *p = param_array_alloc(&(active_unit->params)); memset(p, '\0', sizeof(param_t)); p->type = type; p->bounds = bounds; p->name = name; p->reg = vcode_add_reg(type); reg_t *rr = vcode_reg_data(p->reg); rr->bounds = bounds; return p->reg; } vcode_reg_t emit_load(vcode_var_t var) { // Try scanning backwards through the block for another load or store to // this variable enum { EAGER, CONSERVATIVE, UNSAFE } state = EAGER; vcode_reg_t fold = VCODE_INVALID_REG; VCODE_FOR_EACH_OP(other) { switch (state) { case EAGER: if (other->kind == VCODE_OP_LOAD && other->address == var) return other->result; else if (other->kind == VCODE_OP_STORE && other->address == var) return other->args.items[0]; else if (other->kind == VCODE_OP_FCALL || other->kind == VCODE_OP_PCALL || other->kind == VCODE_OP_FILE_READ || other->kind == VCODE_OP_FILE_OPEN || other->kind == VCODE_OP_STORE_INDIRECT || other->kind == VCODE_OP_DEALLOCATE) state = CONSERVATIVE; // May write to variable break; case CONSERVATIVE: if (other->kind == VCODE_OP_LOAD && other->address == var && fold == VCODE_INVALID_REG) fold = other->result; else if (other->kind == VCODE_OP_STORE && other->address == var && fold == VCODE_INVALID_REG) fold = other->args.items[0]; else if (other->kind == VCODE_OP_INDEX && other->address == var) state = UNSAFE; else if (other->kind == VCODE_OP_CONTEXT_UPREF && other->hops == 0) state = UNSAFE; // Nested call captures variables break; case UNSAFE: break; } } if (fold != VCODE_INVALID_REG && state != UNSAFE) return fold; var_t *v = vcode_var_data(var); op_t *op = vcode_add_op(VCODE_OP_LOAD); op->address = var; op->result = vcode_add_reg(v->type); VCODE_ASSERT(vtype_is_scalar(v->type), "cannot load non-scalar type"); reg_t *r = vcode_reg_data(op->result); r->bounds = v->bounds; return op->result; } vcode_reg_t emit_load_indirect(vcode_reg_t reg) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_LOAD_INDIRECT && other->args.items[0] == reg) { return other->result; } else if (other->kind == VCODE_OP_FCALL || other->kind == VCODE_OP_PCALL || other->kind == VCODE_OP_STORE || other->kind == VCODE_OP_STORE_INDIRECT || other->kind == VCODE_OP_MEMSET || other->kind == VCODE_OP_COPY || other->kind == VCODE_OP_FILE_READ) break; // May write to this pointer } op_t *op = vcode_add_op(VCODE_OP_LOAD_INDIRECT); vcode_add_arg(op, reg); vcode_type_t rtype = vcode_reg_type(reg); VCODE_ASSERT(vtype_kind(rtype) == VCODE_TYPE_POINTER, "load indirect with non-pointer argument"); vcode_type_t deref = vtype_pointed(rtype); op->result = vcode_add_reg(deref); VCODE_ASSERT(vtype_is_scalar(deref), "cannot load non-scalar type"); vcode_reg_data(op->result)->bounds = vcode_reg_data(reg)->bounds; return op->result; } void emit_store(vcode_reg_t reg, vcode_var_t var) { // Any previous store to this variable in this block is dead VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_STORE && other->address == var) { other->kind = VCODE_OP_COMMENT; other->comment = xasprintf("Dead store to %s", istr(vcode_var_name(var))); vcode_reg_array_resize(&(other->args), 0, VCODE_INVALID_REG); } else if (other->kind == VCODE_OP_FCALL || other->kind == VCODE_OP_PCALL) break; // Needs to get variable for display else if ((other->kind == VCODE_OP_INDEX || other->kind == VCODE_OP_LOAD) && other->address == var) break; // Previous value may be used } var_t *v = vcode_var_data(var); reg_t *r = vcode_reg_data(reg); op_t *op = vcode_add_op(VCODE_OP_STORE); vcode_add_arg(op, reg); op->address = var; VCODE_ASSERT(vtype_eq(v->type, r->type), "variable and stored value do not have same type"); VCODE_ASSERT(vtype_is_scalar(v->type), "cannot store non-scalar type"); } void emit_store_indirect(vcode_reg_t reg, vcode_reg_t ptr) { reg_t *p = vcode_reg_data(ptr); reg_t *r = vcode_reg_data(reg); op_t *op = vcode_add_op(VCODE_OP_STORE_INDIRECT); vcode_add_arg(op, reg); vcode_add_arg(op, ptr); VCODE_ASSERT(vtype_kind(p->type) == VCODE_TYPE_POINTER, "store indirect target is not a pointer"); VCODE_ASSERT(vtype_eq(vtype_pointed(p->type), r->type), "pointer and stored value do not have same type"); VCODE_ASSERT(vtype_is_scalar(r->type), "cannot store non-scalar type"); } static vcode_reg_t emit_arith(vcode_op_t kind, vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { // Reuse any previous operation in this block with the same arguments VCODE_FOR_EACH_MATCHING_OP(other, kind) { if (other->args.items[0] == lhs && other->args.items[1] == rhs) return other->result; } op_t *op = vcode_add_op(kind); vcode_add_arg(op, lhs); vcode_add_arg(op, rhs); if (locus != VCODE_INVALID_REG) vcode_add_arg(op, locus); op->result = vcode_add_reg(vcode_reg_type(lhs)); vcode_type_t lhs_type = vcode_reg_type(lhs); vcode_type_t rhs_type = vcode_reg_type(rhs); VCODE_ASSERT(vtype_eq(lhs_type, rhs_type), "arguments to %s are not the same type", vcode_op_string(kind)); return op->result; } static vcode_reg_t emit_mul_op(vcode_op_t op, vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { int64_t lconst, rconst; const bool l_is_const = vcode_reg_const(lhs, &lconst); const bool r_is_const = vcode_reg_const(rhs, &rconst); if (l_is_const && r_is_const) return emit_const(vcode_reg_type(lhs), lconst * rconst); else if (r_is_const && rconst == 1) return lhs; else if (l_is_const && lconst == 1) return rhs; else if ((r_is_const && rconst == 0) || (l_is_const && lconst == 0)) return emit_const(vcode_reg_type(lhs), 0); reg_t *lhs_r = vcode_reg_data(lhs); reg_t *rhs_r = vcode_reg_data(rhs); vtype_t *bl = vcode_type_data(lhs_r->bounds); vtype_t *br = vcode_type_data(rhs_r->bounds); vcode_type_t vbounds; if (vcode_reg_kind(lhs) == VCODE_TYPE_REAL) { const double ll = bl->rlow * br->rlow; const double lh = bl->rlow * br->rhigh; const double hl = bl->rhigh * br->rlow; const double hh = bl->rhigh * br->rhigh; double min = MIN(MIN(ll, lh), MIN(hl, hh)); double max = MAX(MAX(ll, lh), MAX(hl, hh)); vbounds = vtype_real(min, max); } else { const int64_t ll = smul64(bl->low, br->low); const int64_t lh = smul64(bl->low, br->high); const int64_t hl = smul64(bl->high, br->low); const int64_t hh = smul64(bl->high, br->high); int64_t min = MIN(MIN(ll, lh), MIN(hl, hh)); int64_t max = MAX(MAX(ll, lh), MAX(hl, hh)); vtype_repr_t repr = vtype_repr(lhs_r->type); if (op == VCODE_OP_TRAP_MUL && vtype_clamp_to_repr(repr, &min, &max)) { op = VCODE_OP_MUL; // Cannot overflow locus = VCODE_INVALID_REG; } vbounds = vtype_int(min, max); } vcode_reg_t reg = emit_arith(op, lhs, rhs, locus); if (vbounds != VCODE_INVALID_TYPE) vcode_reg_data(reg)->bounds = vbounds; return reg; } vcode_reg_t emit_mul(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_mul_op(VCODE_OP_MUL, lhs, rhs, VCODE_INVALID_REG); } vcode_reg_t emit_trap_mul(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { vcode_reg_t result = emit_mul_op(VCODE_OP_TRAP_MUL, lhs, rhs, locus); VCODE_ASSERT(vcode_reg_kind(result) == VCODE_TYPE_INT, "trapping add may only be used with integer types"); return result; } vcode_reg_t emit_div(vcode_reg_t lhs, vcode_reg_t rhs) { int64_t lconst, rconst; const bool l_is_const = vcode_reg_const(lhs, &lconst); const bool r_is_const = vcode_reg_const(rhs, &rconst); if (l_is_const && r_is_const && rconst != 0) return emit_const(vcode_reg_type(lhs), lconst / rconst); else if (r_is_const && rconst == 1) return lhs; vcode_reg_t reg = emit_arith(VCODE_OP_DIV, lhs, rhs, VCODE_INVALID_REG); vtype_t *bl = vcode_type_data(vcode_reg_data(lhs)->bounds); if (bl->kind == VCODE_TYPE_INT && r_is_const && rconst != 0) { reg_t *rr = vcode_reg_data(reg); rr->bounds = vtype_int(bl->low / rconst, bl->high / rconst); } else if (bl->kind == VCODE_TYPE_REAL) { reg_t *rr = vcode_reg_data(reg); rr->bounds = vtype_real(-INFINITY, INFINITY); } return reg; } vcode_reg_t emit_exp(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_arith(VCODE_OP_EXP, lhs, rhs, VCODE_INVALID_REG); } vcode_reg_t emit_trap_exp(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { int64_t rconst; if (vcode_reg_const(rhs, &rconst)) { if (rconst == 0) return emit_const(vcode_reg_type(lhs), 1); else if (rconst == 1) return lhs; } vcode_reg_t result = emit_arith(VCODE_OP_TRAP_EXP, lhs, rhs, locus); VCODE_ASSERT(vcode_reg_kind(result) == VCODE_TYPE_INT, "trapping exp may only be used with integer types"); return result; } vcode_reg_t emit_mod(vcode_reg_t lhs, vcode_reg_t rhs) { int64_t lconst, rconst; if (vcode_reg_const(lhs, &lconst) && vcode_reg_const(rhs, &rconst) && lconst > 0 && rconst > 0) return emit_const(vcode_reg_type(lhs), lconst % rconst); vtype_t *bl = vcode_type_data(vcode_reg_data(lhs)->bounds); vtype_t *br = vcode_type_data(vcode_reg_data(rhs)->bounds); if (bl->low >= 0 && br->low >= 0) { // If both arguments are non-negative then rem is equivalent and // cheaper to compute vcode_reg_t reg = emit_arith(VCODE_OP_REM, lhs, rhs, VCODE_INVALID_REG); reg_t *rr = vcode_reg_data(reg); rr->bounds = vtype_int(0, MAX(0, br->high - 1)); return reg; } else return emit_arith(VCODE_OP_MOD, lhs, rhs, VCODE_INVALID_REG); } vcode_reg_t emit_rem(vcode_reg_t lhs, vcode_reg_t rhs) { int64_t lconst, rconst; if (vcode_reg_const(lhs, &lconst) && vcode_reg_const(rhs, &rconst) && lconst > 0 && rconst > 0) return emit_const(vcode_reg_type(lhs), lconst % rconst); vcode_reg_t reg = emit_arith(VCODE_OP_REM, lhs, rhs, VCODE_INVALID_REG); vtype_t *bl = vcode_type_data(vcode_reg_data(lhs)->bounds); vtype_t *br = vcode_type_data(vcode_reg_data(rhs)->bounds); if (bl->low >= 0 && br->low >= 0) { reg_t *rr = vcode_reg_data(reg); rr->bounds = vtype_int(0, br->high - 1); } return reg; } static vcode_reg_t emit_add_op(vcode_op_t op, vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { int64_t lconst, rconst; const bool l_is_const = vcode_reg_const(lhs, &lconst); const bool r_is_const = vcode_reg_const(rhs, &rconst); if (l_is_const && r_is_const) return emit_const(vcode_reg_type(lhs), lconst + rconst); else if (r_is_const && rconst == 0) return lhs; else if (l_is_const && lconst == 0) return rhs; vcode_type_t vbounds = VCODE_INVALID_TYPE; if (vcode_reg_kind(lhs) != VCODE_TYPE_REAL) { reg_t *lhs_r = vcode_reg_data(lhs); reg_t *rhs_r = vcode_reg_data(rhs); vtype_t *bl = vcode_type_data(lhs_r->bounds); vtype_t *br = vcode_type_data(rhs_r->bounds); int64_t rbl = sadd64(bl->low, br->low); int64_t rbh = sadd64(bl->high, br->high); vtype_repr_t repr = vtype_repr(lhs_r->type); if (op == VCODE_OP_TRAP_ADD && vtype_clamp_to_repr(repr, &rbl, &rbh)) { op = VCODE_OP_ADD; // Cannot overflow locus = VCODE_INVALID_REG; } vbounds = vtype_int(rbl, rbh); } vcode_reg_t reg = emit_arith(op, lhs, rhs, locus); if (vbounds != VCODE_INVALID_TYPE) vcode_reg_data(reg)->bounds = vbounds; return reg; } vcode_reg_t emit_add(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_add_op(VCODE_OP_ADD, lhs, rhs, VCODE_INVALID_REG); } vcode_reg_t emit_trap_add(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { vcode_reg_t result = emit_add_op(VCODE_OP_TRAP_ADD, lhs, rhs, locus); VCODE_ASSERT(vcode_reg_kind(result) == VCODE_TYPE_INT, "trapping add may only be used with integer types"); return result; } static vcode_reg_t emit_sub_op(vcode_op_t op, vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { int64_t lconst, rconst; const bool l_is_const = vcode_reg_const(lhs, &lconst); const bool r_is_const = vcode_reg_const(rhs, &rconst); if (l_is_const && r_is_const) return emit_const(vcode_reg_type(lhs), lconst - rconst); else if (r_is_const && rconst == 0) return lhs; else if (l_is_const && lconst == 0) return emit_neg(rhs); vcode_type_t vbounds = VCODE_INVALID_TYPE; if (vcode_reg_kind(lhs) != VCODE_TYPE_REAL) { reg_t *lhs_r = vcode_reg_data(lhs); reg_t *rhs_r = vcode_reg_data(rhs); vtype_t *bl = vcode_type_data(lhs_r->bounds); vtype_t *br = vcode_type_data(rhs_r->bounds); int64_t rbl = ssub64(bl->low, br->high); int64_t rbh = ssub64(bl->high, br->low); vtype_repr_t repr = vtype_repr(lhs_r->type); if (op == VCODE_OP_TRAP_SUB && vtype_clamp_to_repr(repr, &rbl, &rbh)) { op = VCODE_OP_SUB; // Cannot overflow locus = VCODE_INVALID_REG; } vbounds = vtype_int(rbl, rbh); } vcode_reg_t reg = emit_arith(op, lhs, rhs, locus); if (vbounds != VCODE_INVALID_TYPE) vcode_reg_data(reg)->bounds = vbounds; return reg; } vcode_reg_t emit_sub(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_sub_op(VCODE_OP_SUB, lhs, rhs, VCODE_INVALID_REG); } vcode_reg_t emit_trap_sub(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus) { vcode_reg_t result = emit_sub_op(VCODE_OP_TRAP_SUB, lhs, rhs, locus); VCODE_ASSERT(vcode_reg_kind(result) == VCODE_TYPE_INT, "trapping sub may only be used with integer types"); return result; } static void vcode_calculate_var_index_type(op_t *op, var_t *var) { switch (vtype_kind(var->type)) { case VCODE_TYPE_CARRAY: op->type = vtype_pointer(vtype_elem(var->type)); op->result = vcode_add_reg(op->type); vcode_reg_data(op->result)->bounds = vtype_bounds(var->type); break; case VCODE_TYPE_RECORD: op->type = vtype_pointer(var->type); op->result = vcode_add_reg(op->type); break; case VCODE_TYPE_INT: case VCODE_TYPE_FILE: case VCODE_TYPE_ACCESS: case VCODE_TYPE_REAL: case VCODE_TYPE_UARRAY: case VCODE_TYPE_POINTER: case VCODE_TYPE_SIGNAL: case VCODE_TYPE_CONTEXT: case VCODE_TYPE_OFFSET: case VCODE_TYPE_TRIGGER: case VCODE_TYPE_RESOLUTION: op->type = vtype_pointer(var->type); op->result = vcode_add_reg(op->type); vcode_reg_data(op->result)->bounds = var->bounds; break; default: VCODE_ASSERT(false, "variable %s cannot be indexed", istr(var->name)); } } vcode_reg_t emit_index(vcode_var_t var, vcode_reg_t offset) { // Try to find a previous index of this var by this offset VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_INDEX) { if (other->address == var && ((offset == VCODE_INVALID_REG && other->args.count == 0) || (offset != VCODE_INVALID_REG && other->args.items[0] == offset))) return other->result; } op_t *op = vcode_add_op(VCODE_OP_INDEX); op->address = var; if (offset != VCODE_INVALID_REG) vcode_add_arg(op, offset); vcode_calculate_var_index_type(op, vcode_var_data(var)); if (offset != VCODE_INVALID_REG) VCODE_ASSERT(vtype_kind(vcode_reg_type(offset)) == VCODE_TYPE_OFFSET, "index offset r%d does not have offset type", offset); return op->result; } vcode_reg_t emit_cast(vcode_type_t type, vcode_type_t bounds, vcode_reg_t reg) { if (vtype_eq(vcode_reg_type(reg), type)) return reg; vtype_kind_t from = vtype_kind(vcode_reg_type(reg)); vtype_kind_t to = vtype_kind(type); const bool integral = (from == VCODE_TYPE_OFFSET || from == VCODE_TYPE_INT) && (to == VCODE_TYPE_OFFSET || to == VCODE_TYPE_INT); int64_t value; if (integral && vcode_reg_const(reg, &value)) return emit_const(type, value); // Try to find a previous cast of this register to this type VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CAST) { if (vtype_eq(other->type, type) && other->args.items[0] == reg) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CAST); vcode_add_arg(op, reg); op->type = type; op->result = vcode_add_reg(type); static const vcode_type_t allowed[][2] = { { VCODE_TYPE_INT, VCODE_TYPE_OFFSET }, { VCODE_TYPE_OFFSET, VCODE_TYPE_INT }, { VCODE_TYPE_INT, VCODE_TYPE_INT }, { VCODE_TYPE_INT, VCODE_TYPE_REAL }, { VCODE_TYPE_REAL, VCODE_TYPE_INT }, { VCODE_TYPE_REAL, VCODE_TYPE_REAL }, { VCODE_TYPE_ACCESS, VCODE_TYPE_ACCESS }, }; if (integral) { vtype_t *vt = vcode_type_data(type); int64_t low = vt->low, high = vt->high; vtype_t *rt = vcode_type_data(vcode_reg_bounds(reg)); low = MAX(low, rt->low); high = MIN(high, rt->high); if (bounds != VCODE_INVALID_REG) { vtype_t *bt = vcode_type_data(bounds); low = MAX(low, bt->low); high = MIN(high, bt->high); } reg_t *rr = vcode_reg_data(op->result); rr->bounds = vtype_int(low, high); } else if (bounds != VCODE_INVALID_REG) vcode_reg_data(op->result)->bounds = bounds; for (size_t i = 0; i < ARRAY_LEN(allowed); i++) { if (from == allowed[i][0] && to == allowed[i][1]) return op->result; } VCODE_ASSERT(false, "invalid type conversion in cast"); } void emit_return(vcode_reg_t reg) { op_t *op = vcode_add_op(VCODE_OP_RETURN); if (reg != VCODE_INVALID_REG) { vcode_add_arg(op, reg); const vtype_kind_t rkind = vcode_reg_kind(reg); if (rkind == VCODE_TYPE_POINTER || rkind == VCODE_TYPE_UARRAY) vcode_heap_allocate(reg); VCODE_ASSERT(active_unit->kind == VCODE_UNIT_FUNCTION || active_unit->kind == VCODE_UNIT_THUNK || active_unit->kind == VCODE_UNIT_PROPERTY, "returning value fron non-function unit"); VCODE_ASSERT((active_unit->kind == VCODE_UNIT_PROPERTY && rkind == VCODE_TYPE_INT) || vtype_eq(active_unit->result, vcode_reg_type(reg)) || (vtype_kind(active_unit->result) == VCODE_TYPE_ACCESS && rkind == VCODE_TYPE_ACCESS), "return value incorrect type"); } } void emit_sched_waveform(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t values, vcode_reg_t reject, vcode_reg_t after) { int64_t nconst; if (vcode_reg_const(nnets, &nconst) && nconst == 0) { emit_comment("Skip empty waveform"); return; } op_t *op = vcode_add_op(VCODE_OP_SCHED_WAVEFORM); vcode_add_arg(op, nets); vcode_add_arg(op, nnets); vcode_add_arg(op, values); vcode_add_arg(op, reject); vcode_add_arg(op, after); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "sched_waveform target is not signal"); VCODE_ASSERT(vcode_reg_kind(nnets) == VCODE_TYPE_OFFSET, "sched_waveform net count is not offset type"); VCODE_ASSERT(vcode_reg_kind(values) != VCODE_TYPE_SIGNAL, "signal cannot be values argument for sched_waveform"); } void emit_force(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t values) { op_t *op = vcode_add_op(VCODE_OP_FORCE); vcode_add_arg(op, nets); vcode_add_arg(op, nnets); vcode_add_arg(op, values); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "force target is not signal"); VCODE_ASSERT(vcode_reg_kind(nnets) == VCODE_TYPE_OFFSET, "force net count is not offset type"); } void emit_release(vcode_reg_t nets, vcode_reg_t nnets) { op_t *op = vcode_add_op(VCODE_OP_RELEASE); vcode_add_arg(op, nets); vcode_add_arg(op, nnets); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "release target is not signal"); VCODE_ASSERT(vcode_reg_kind(nnets) == VCODE_TYPE_OFFSET, "release net count is not offset type"); } void emit_disconnect(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t reject, vcode_reg_t after) { op_t *op = vcode_add_op(VCODE_OP_DISCONNECT); vcode_add_arg(op, nets); vcode_add_arg(op, nnets); vcode_add_arg(op, reject); vcode_add_arg(op, after); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "disconnect target is not signal"); VCODE_ASSERT(vcode_reg_kind(nnets) == VCODE_TYPE_OFFSET, "disconnect net count is not offset type"); } void emit_cond(vcode_reg_t test, vcode_block_t btrue, vcode_block_t bfalse) { int64_t tconst; if (vcode_reg_const(test, &tconst)) { emit_jump(!!tconst ? btrue : bfalse); return; } op_t *op = vcode_add_op(VCODE_OP_COND); vcode_add_arg(op, test); vcode_add_target(op, btrue); vcode_add_target(op, bfalse); VCODE_ASSERT(vtype_eq(vcode_reg_type(test), vtype_bool()), "cond test is not a bool"); VCODE_ASSERT(btrue != VCODE_INVALID_BLOCK && bfalse != VCODE_INVALID_BLOCK, "invalid cond targets"); } vcode_reg_t emit_neg(vcode_reg_t lhs) { int64_t lconst; if (vcode_reg_const(lhs, &lconst)) return emit_const(vcode_reg_type(lhs), -lconst); op_t *op = vcode_add_op(VCODE_OP_NEG); vcode_add_arg(op, lhs); op->result = vcode_add_reg(vcode_reg_type(lhs)); return op->result; } vcode_reg_t emit_trap_neg(vcode_reg_t lhs, vcode_reg_t locus) { int64_t lconst; if (vcode_reg_const(lhs, &lconst) && lconst >= 0) return emit_const(vcode_reg_type(lhs), -lconst); else if (vcode_type_data(vcode_reg_data(lhs)->bounds)->low >= 0) return emit_neg(lhs); // Cannot overflow op_t *op = vcode_add_op(VCODE_OP_TRAP_NEG); vcode_add_arg(op, lhs); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to trap neg must be a debug locus"); VCODE_ASSERT(vcode_reg_kind(lhs) == VCODE_TYPE_INT, "trapping neg may only be used with integer types"); return (op->result = vcode_add_reg(vcode_reg_type(lhs))); } vcode_reg_t emit_abs(vcode_reg_t lhs) { int64_t lconst; if (vcode_reg_const(lhs, &lconst)) return emit_const(vcode_reg_type(lhs), llabs(lconst)); op_t *op = vcode_add_op(VCODE_OP_ABS); vcode_add_arg(op, lhs); op->result = vcode_add_reg(vcode_reg_type(lhs)); return op->result; } void emit_comment(const char *fmt, ...) { #ifndef NDEBUG va_list ap; va_start(ap, fmt); char *buf = xvasprintf(fmt, ap); for (char *p = buf + strlen(buf) - 1; p >= buf && isspace_iso88591(*p); p--) *p = '\0'; vcode_add_op(VCODE_OP_COMMENT)->comment = buf; va_end(ap); #endif } vcode_reg_t emit_select(vcode_reg_t test, vcode_reg_t rtrue, vcode_reg_t rfalse) { int64_t tconst; if (vcode_reg_const(test, &tconst)) return !!tconst ? rtrue : rfalse; else if (rtrue == rfalse) return rtrue; // Find a previous identical select VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_SELECT) { if (other->args.items[0] == test && other->args.items[1] == rtrue && other->args.items[2] == rfalse) return other->result; } op_t *op = vcode_add_op(VCODE_OP_SELECT); vcode_add_arg(op, test); vcode_add_arg(op, rtrue); vcode_add_arg(op, rfalse); op->result = vcode_add_reg(vcode_reg_type(rtrue)); VCODE_ASSERT(vtype_eq(vcode_reg_type(test), vtype_bool()), "select test must have bool type"); VCODE_ASSERT(vtype_eq(vcode_reg_type(rtrue), vcode_reg_type(rfalse)), "select arguments are not the same type"); return op->result; } static vcode_reg_t emit_logical_identity(vcode_op_t op, vcode_reg_t reg, bool b) { switch (op) { case VCODE_OP_AND: return b ? reg : emit_const(vtype_bool(), 0); case VCODE_OP_OR: return b ? emit_const(vtype_bool(), 1) : reg; case VCODE_OP_XOR: return b ? emit_not(reg) : reg; case VCODE_OP_XNOR: return b ? reg : emit_not(reg); case VCODE_OP_NAND: return b ? emit_not(reg) : emit_const(vtype_bool(), 1); case VCODE_OP_NOR: return b ? emit_const(vtype_bool(), 0) : emit_not(reg); default: fatal_trace("missing logicial identity for %s", vcode_op_string(op)); } } static vcode_reg_t emit_logical(vcode_op_t op, vcode_reg_t lhs, vcode_reg_t rhs) { vcode_type_t vtbool = vtype_bool(); int64_t lconst, rconst; const bool l_is_const = vcode_reg_const(lhs, &lconst); const bool r_is_const = vcode_reg_const(rhs, &rconst); if (l_is_const && r_is_const) { switch (op) { case VCODE_OP_AND: return emit_const(vtbool, lconst && rconst); case VCODE_OP_OR: return emit_const(vtbool, lconst || rconst); case VCODE_OP_XOR: return emit_const(vtbool, lconst ^ rconst); case VCODE_OP_XNOR: return emit_const(vtbool, !(lconst ^ rconst)); case VCODE_OP_NAND: return emit_const(vtbool, !(lconst && rconst)); case VCODE_OP_NOR: return emit_const(vtbool, !(lconst || rconst)); default: fatal_trace("cannot constant fold logical %s", vcode_op_string(op)); } } else if (l_is_const) return emit_logical_identity(op, rhs, !!lconst); else if (r_is_const) return emit_logical_identity(op, lhs, !!rconst); else if (lhs == rhs) { switch (op) { case VCODE_OP_AND: case VCODE_OP_OR: return lhs; case VCODE_OP_NAND: case VCODE_OP_NOR: return emit_not(lhs); case VCODE_OP_XOR: return emit_const(vtbool, 0); case VCODE_OP_XNOR: return emit_const(vtbool, 1); default: fatal_trace("cannot constant fold logical %s", vcode_op_string(op)); } } vcode_reg_t result = emit_arith(op, lhs, rhs, VCODE_INVALID_REG); VCODE_ASSERT(vtype_eq(vcode_reg_type(lhs), vtbool) && vtype_eq(vcode_reg_type(rhs), vtbool), "arguments to %s are not boolean", vcode_op_string(op)); return result; } vcode_reg_t emit_or(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_OR, lhs, rhs); } vcode_reg_t emit_and(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_AND, lhs, rhs); } vcode_reg_t emit_nand(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_NAND, lhs, rhs); } vcode_reg_t emit_nor(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_NOR, lhs, rhs); } vcode_reg_t emit_xor(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_XOR, lhs, rhs); } vcode_reg_t emit_xnor(vcode_reg_t lhs, vcode_reg_t rhs) { return emit_logical(VCODE_OP_XNOR, lhs, rhs); } vcode_reg_t emit_not(vcode_reg_t arg) { int64_t cval; if (vcode_reg_const(arg, &cval)) return emit_const(vtype_bool(), !cval); op_t *op = vcode_add_op(VCODE_OP_NOT); vcode_add_arg(op, arg); vcode_type_t vtbool = vtype_bool(); VCODE_ASSERT(vtype_eq(vcode_reg_type(arg), vtbool), "argument to not is not boolean"); return (op->result = vcode_add_reg(vtbool)); } vcode_reg_t emit_wrap(vcode_reg_t data, const vcode_dim_t *dims, int ndims) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_WRAP) { if (other->args.count == ndims*3 + 1 && other->args.items[0] == data) { bool match = true; for (int i = 0; match && i < ndims; i++) { match = other->args.items[i*3 + 1] == dims[i].left && other->args.items[i*3 + 2] == dims[i].right && other->args.items[i*3 + 3] == dims[i].dir; } if (match) return other->result; } } op_t *op = vcode_add_op(VCODE_OP_WRAP); vcode_add_arg(op, data); for (int i = 0; i < ndims; i++) { vcode_add_arg(op, dims[i].left); vcode_add_arg(op, dims[i].right); vcode_add_arg(op, dims[i].dir); } vcode_type_t ptr_type = vcode_reg_type(data); const vtype_kind_t ptrkind = vtype_kind(ptr_type); VCODE_ASSERT(ptrkind == VCODE_TYPE_POINTER || ptrkind == VCODE_TYPE_SIGNAL, "wrapped data is not pointer or signal"); #ifdef DEBUG for (int i = 0; i < ndims; i++) { VCODE_ASSERT(vtype_is_scalar(vcode_reg_type(dims[i].left)), "dimension %d left bound must be scalar", i + 1); VCODE_ASSERT(vtype_is_scalar(vcode_reg_type(dims[i].right)), "dimension %d right bound must be scalar", i + 1); VCODE_ASSERT(vtype_eq(vtype_bool(), vcode_reg_type(dims[i].dir)), "dimension %d direction must be bool", i + 1); } #endif vcode_type_t elem = (ptrkind == VCODE_TYPE_POINTER) ? vtype_pointed(ptr_type) : ptr_type; op->result = vcode_add_reg( vtype_uarray(ndims, elem, vcode_reg_bounds(data))); return op->result; } static vcode_reg_t emit_uarray_op(vcode_op_t o, vcode_type_t rtype, vcode_reg_t array, unsigned dim, unsigned arg_index) { // Reuse any previous operation in this block with the same arguments VCODE_FOR_EACH_OP(other) { if (other->kind == o && other->args.items[0] == array && other->dim == dim && (rtype == VCODE_INVALID_TYPE || vtype_eq(rtype, vcode_reg_type(other->result)))) return other->result; else if (other->kind == VCODE_OP_WRAP && other->result == array) return other->args.items[1 + (dim * 3) + arg_index]; } op_t *op = vcode_add_op(o); vcode_add_arg(op, array); op->dim = dim; vcode_type_t atype = vcode_reg_type(array); VCODE_ASSERT(vtype_kind(atype) == VCODE_TYPE_UARRAY, "cannot use %s with non-uarray type", vcode_op_string(o)); vtype_t *vt = vcode_type_data(atype); VCODE_ASSERT(dim < vt->dims, "invalid dimension %d", dim); if (rtype == VCODE_INVALID_TYPE) rtype = vtype_offset(); return (op->result = vcode_add_reg(rtype)); } vcode_reg_t emit_uarray_left(vcode_reg_t array, unsigned dim) { return emit_uarray_op(VCODE_OP_UARRAY_LEFT, VCODE_INVALID_TYPE, array, dim, 0); } vcode_reg_t emit_uarray_right(vcode_reg_t array, unsigned dim) { return emit_uarray_op(VCODE_OP_UARRAY_RIGHT, VCODE_INVALID_TYPE, array, dim, 1); } vcode_reg_t emit_uarray_dir(vcode_reg_t array, unsigned dim) { return emit_uarray_op(VCODE_OP_UARRAY_DIR, vtype_bool(), array, dim, 2); } vcode_reg_t emit_uarray_len(vcode_reg_t array, unsigned dim) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_UARRAY_LEN) { if (other->args.items[0] == array && other->dim == dim) return other->result; } else if (other->kind == VCODE_OP_WRAP && other->result == array) { VCODE_ASSERT(dim < (other->args.count - 1) / 3, "array dimension %d out of bounds", dim); vcode_reg_t left_reg = other->args.items[dim * 3 + 1]; vcode_reg_t right_reg = other->args.items[dim * 3 + 2]; vcode_reg_t dir_reg = other->args.items[dim * 3 + 3]; return emit_range_length(left_reg, right_reg, dir_reg); } } op_t *op = vcode_add_op(VCODE_OP_UARRAY_LEN); vcode_add_arg(op, array); op->dim = dim; vcode_type_t atype = vcode_reg_type(array); VCODE_ASSERT(vtype_kind(atype) == VCODE_TYPE_UARRAY, "cannot use uarray len with non-uarray type"); vtype_t *vt = vcode_type_data(atype); VCODE_ASSERT(dim < vt->dims, "invalid dimension %d", dim); op->result = vcode_add_reg(vtype_offset()); reg_t *rr = vcode_reg_data(op->result); rr->bounds = vtype_int(0, INT64_MAX); return op->result; } vcode_reg_t emit_unwrap(vcode_reg_t array) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_WRAP && other->result == array) return other->args.items[0]; else if (other->kind == VCODE_OP_UNWRAP && other->args.items[0] == array) return other->result; } op_t *op = vcode_add_op(VCODE_OP_UNWRAP); vcode_add_arg(op, array); vtype_t *vt = vcode_type_data(vcode_reg_type(array)); VCODE_ASSERT(vt->kind == VCODE_TYPE_UARRAY, "unwrap can only only be used with uarray types"); vcode_type_t elem = vt->elem; vcode_type_t rtype = (vtype_kind(elem) == VCODE_TYPE_SIGNAL) ? elem : vtype_pointer(elem); op->result = vcode_add_reg(rtype); reg_t *rr = vcode_reg_data(op->result); rr->bounds = elem; return op->result; } vcode_reg_t emit_range_null(vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_RANGE_NULL) { if (other->args.items[0] == left && other->args.items[1] == right && other->args.items[2] == dir) return other->result; } int64_t dir_const; if (vcode_reg_const(dir, &dir_const)) { vtype_t *lbounds = vcode_type_data(vcode_reg_bounds(left)); vtype_t *rbounds = vcode_type_data(vcode_reg_bounds(right)); if (dir_const == RANGE_TO && lbounds->low > rbounds->high) return emit_const(vtype_bool(), 1); else if (dir_const == RANGE_TO && lbounds->high <= rbounds->low) return emit_const(vtype_bool(), 0); else if (dir_const == RANGE_DOWNTO && rbounds->low > lbounds->high) return emit_const(vtype_bool(), 1); else if (dir_const == RANGE_DOWNTO && rbounds->high <= lbounds->low) return emit_const(vtype_bool(), 0); else if (dir_const == RANGE_TO) return emit_cmp(VCODE_CMP_GT, left, right); else return emit_cmp(VCODE_CMP_GT, right, left); } op_t *op = vcode_add_op(VCODE_OP_RANGE_NULL); vcode_add_arg(op, left); vcode_add_arg(op, right); vcode_add_arg(op, dir); VCODE_ASSERT(vtype_eq(vcode_reg_type(left), vcode_reg_type(right)), "range left and right have different types"); VCODE_ASSERT(vcode_reg_kind(dir) == VCODE_TYPE_INT, "dir argument to range length is not int"); return (op->result = vcode_add_reg(vtype_bool())); } vcode_reg_t emit_range_length(vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir) { vcode_reg_t left_array = VCODE_INVALID_REG, right_array = VCODE_INVALID_REG, dir_array = VCODE_INVALID_REG; int left_dim = -1, right_dim = -1, dir_dim = -1; VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_RANGE_LENGTH && other->args.items[0] == left && other->args.items[1] == right && other->args.items[2] == dir) return other->result; else if (other->kind == VCODE_OP_UARRAY_LEFT && other->result == left) { left_array = other->args.items[0]; left_dim = other->dim; } else if (other->kind == VCODE_OP_UARRAY_RIGHT && other->result == right) { right_array = other->args.items[0]; right_dim = other->dim; } else if (other->kind == VCODE_OP_UARRAY_DIR && other->result == dir) { dir_array = other->args.items[0]; dir_dim = other->dim; } } if (left_array != VCODE_INVALID_REG && left_array == right_array && right_array == dir_array && left_dim == right_dim && right_dim == dir_dim) return emit_uarray_len(left_array, left_dim); int64_t lconst, rconst, dconst; if (vcode_reg_const(dir, &dconst) && vcode_reg_const(left, &lconst) && vcode_reg_const(right, &rconst)) { int64_t diff; if (dconst == RANGE_TO) diff = rconst - lconst; else diff = lconst - rconst; return emit_const(vtype_offset(), diff < 0 ? 0 : diff + 1); } op_t *op = vcode_add_op(VCODE_OP_RANGE_LENGTH); vcode_add_arg(op, left); vcode_add_arg(op, right); vcode_add_arg(op, dir); VCODE_ASSERT(vtype_eq(vcode_reg_type(left), vcode_reg_type(right)), "range left and right have different types"); VCODE_ASSERT(vcode_reg_kind(dir) == VCODE_TYPE_INT, "dir argument to range length is not int"); op->result = vcode_add_reg(vtype_offset()); reg_t *rr = vcode_reg_data(op->result); rr->bounds = vtype_int(0, INT64_MAX); return op->result; } vcode_reg_t emit_var_upref(int hops, vcode_var_t var) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_VAR_UPREF) { if (other->hops == hops && other->address == var) return other->result; } op_t *op = vcode_add_op(VCODE_OP_VAR_UPREF); op->hops = hops; op->address = var; VCODE_ASSERT(hops > 0, "invalid hop count"); vcode_unit_t vu = active_unit; for (int i = 0; i < hops; i++) { vu = vu->context; VCODE_ASSERT(vu, "hop count is greater than depth"); } VCODE_ASSERT(var < vu->vars.count, "upref %d is not a variable", var); vcode_calculate_var_index_type(op, &(vu->vars.items[var])); return op->result; } vcode_reg_t emit_init_signal(vcode_type_t type, vcode_reg_t count, vcode_reg_t size, vcode_reg_t value, vcode_reg_t flags, vcode_reg_t locus, vcode_reg_t offset) { op_t *op = vcode_add_op(VCODE_OP_INIT_SIGNAL); vcode_add_arg(op, count); vcode_add_arg(op, size); vcode_add_arg(op, value); vcode_add_arg(op, flags); vcode_add_arg(op, locus); if (offset != VCODE_INVALID_REG) vcode_add_arg(op, offset); vcode_type_t vtype = vcode_reg_type(value); VCODE_ASSERT(vtype_is_scalar(type), "signal type must be scalar"); VCODE_ASSERT(vtype_eq(vtype, type) || vtype_kind(vtype) == VCODE_TYPE_POINTER, "init signal value type does not match signal type"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to init signal must be a debug locus"); VCODE_ASSERT(offset == VCODE_INVALID_REG || vcode_reg_kind(offset) == VCODE_TYPE_POINTER, "init signal offset argument must have pointer type"); return (op->result = vcode_add_reg(vtype_signal(type))); } void emit_resolve_signal(vcode_reg_t signal, vcode_reg_t resolution) { op_t *op = vcode_add_op(VCODE_OP_RESOLVE_SIGNAL); vcode_add_arg(op, signal); vcode_add_arg(op, resolution); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "signal argument has wrong type"); vcode_type_t rtype = vcode_reg_type(resolution); VCODE_ASSERT(vtype_kind(rtype) == VCODE_TYPE_POINTER, "resolution wrapper argument must be pointer"); VCODE_ASSERT(vtype_kind(vtype_pointed(rtype)) == VCODE_TYPE_RESOLUTION, "resolution wrapper argument has wrong type"); } vcode_reg_t emit_implicit_signal(vcode_type_t type, vcode_reg_t count, vcode_reg_t size, vcode_reg_t locus, vcode_reg_t kind, vcode_reg_t closure, vcode_reg_t delay) { op_t *op = vcode_add_op(VCODE_OP_IMPLICIT_SIGNAL); vcode_add_arg(op, count); vcode_add_arg(op, size); vcode_add_arg(op, locus); vcode_add_arg(op, kind); vcode_add_arg(op, closure); vcode_add_arg(op, delay); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument to implicit signal is not offset"); VCODE_ASSERT(vcode_reg_kind(kind) == VCODE_TYPE_OFFSET, "kind argument to implicit signal is not offset"); VCODE_ASSERT(vcode_reg_kind(closure) == VCODE_TYPE_CLOSURE, "closure argument to implicit signal is not a closure"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to implicit signal must be a debug locus"); VCODE_ASSERT(vcode_reg_kind(delay) == VCODE_TYPE_INT, "delay argument to implicit signal must be time"); return (op->result = vcode_add_reg(vtype_signal(type))); } void emit_map_signal(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_MAP_SIGNAL); vcode_add_arg(op, src); vcode_add_arg(op, dst); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(src) == VCODE_TYPE_SIGNAL, "src argument to map signal is not a signal"); VCODE_ASSERT(vcode_reg_kind(dst) == VCODE_TYPE_SIGNAL, "dst argument to map signal is not a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument type to map signal is not offset"); } void emit_map_const(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_MAP_CONST); vcode_add_arg(op, src); vcode_add_arg(op, dst); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(dst) == VCODE_TYPE_SIGNAL, "dst argument to map const is not a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument type to map const is not offset"); } void emit_map_implicit(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_MAP_IMPLICIT); vcode_add_arg(op, src); vcode_add_arg(op, dst); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(src) == VCODE_TYPE_SIGNAL, "src argument to map implicit is not a signal"); VCODE_ASSERT(vcode_reg_kind(dst) == VCODE_TYPE_SIGNAL, "dst argument to map implicit is not a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument type to map implicit is not offset"); } void emit_drive_signal(vcode_reg_t target, vcode_reg_t count) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_DRIVE_SIGNAL) { if (other->args.items[0] == target && other->args.items[1] == count) return; } op_t *op = vcode_add_op(VCODE_OP_DRIVE_SIGNAL); vcode_add_arg(op, target); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(target) == VCODE_TYPE_SIGNAL, "target argument to drive signal is not a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument type to drive signal is not offset"); } void emit_transfer_signal(vcode_reg_t target, vcode_reg_t source, vcode_reg_t count, vcode_reg_t reject, vcode_reg_t after) { op_t *op = vcode_add_op(VCODE_OP_TRANSFER_SIGNAL); vcode_add_arg(op, target); vcode_add_arg(op, source); vcode_add_arg(op, count); vcode_add_arg(op, reject); vcode_add_arg(op, after); VCODE_ASSERT(vcode_reg_kind(target) == VCODE_TYPE_SIGNAL, "target argument to transfer signal is not a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument type to transfer signal is not offset"); VCODE_ASSERT(vcode_reg_kind(source) == VCODE_TYPE_SIGNAL, "source argument to transfer signal is not a signal"); } vcode_reg_t emit_resolution_wrapper(vcode_type_t type, vcode_reg_t closure, vcode_reg_t nlits) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_RESOLUTION_WRAPPER) { if (other->args.items[0] == closure && other->args.items[1] == nlits) return other->result; } VCODE_ASSERT(vcode_reg_kind(closure) == VCODE_TYPE_CLOSURE, "first argument to resolution wrapper must be closure"); op_t *op = vcode_add_op(VCODE_OP_RESOLUTION_WRAPPER); vcode_add_arg(op, closure); vcode_add_arg(op, nlits); return (op->result = vcode_add_reg(vtype_resolution(type))); } vcode_reg_t emit_closure(ident_t func, vcode_reg_t context, vcode_type_t rtype) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CLOSURE) { if (other->func == func && other->args.items[0] == context) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CLOSURE); vcode_add_arg(op, context); op->func = func; VCODE_ASSERT(vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "invalid closure context argument"); return (op->result = vcode_add_reg(vtype_closure(rtype))); } vcode_reg_t emit_package_init(ident_t name, vcode_reg_t context) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_PACKAGE_INIT) { if (other->func == name) return other->result; } op_t *op = vcode_add_op(VCODE_OP_PACKAGE_INIT); op->func = name; if (context != VCODE_INVALID_REG) vcode_add_arg(op, context); VCODE_ASSERT(context == VCODE_INVALID_REG || vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "invalid protected init context argument"); VCODE_ASSERT(active_unit->kind == VCODE_UNIT_INSTANCE || active_unit->kind == VCODE_UNIT_PACKAGE || active_unit->kind == VCODE_UNIT_THUNK, "cannot use package init here"); VCODE_ASSERT(name != active_unit->name, "cyclic package init"); return (op->result = vcode_add_reg(vtype_context(name))); } vcode_reg_t emit_protected_init(vcode_type_t type, vcode_reg_t context, vcode_reg_t path_name, vcode_reg_t inst_name) { op_t *op = vcode_add_op(VCODE_OP_PROTECTED_INIT); vcode_add_arg(op, context); op->func = vtype_name(type); if (path_name != VCODE_INVALID_REG && inst_name != VCODE_INVALID_REG) { vcode_add_arg(op, path_name); vcode_add_arg(op, inst_name); VCODE_ASSERT(vcode_reg_kind(path_name) == VCODE_TYPE_UARRAY, "path name argument must be uarray"); VCODE_ASSERT(vcode_reg_kind(inst_name) == VCODE_TYPE_UARRAY, "inst name argument must be uarray"); } VCODE_ASSERT(vtype_kind(type) == VCODE_TYPE_CONTEXT, "protected init type must be context"); VCODE_ASSERT(vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "invalid protected init context argument"); return (op->result = vcode_add_reg(type)); } void emit_process_init(ident_t name, vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_PROCESS_INIT); vcode_add_arg(op, locus); op->func = name; VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to process init must be a debug locus"); } void emit_protected_free(vcode_reg_t obj) { op_t *op = vcode_add_op(VCODE_OP_PROTECTED_FREE); vcode_add_arg(op, obj); VCODE_ASSERT(vcode_reg_kind(obj) == VCODE_TYPE_CONTEXT, "protected object type must be context"); } vcode_reg_t emit_context_upref(int hops) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_CONTEXT_UPREF) { if (other->hops == hops) return other->result; } op_t *op = vcode_add_op(VCODE_OP_CONTEXT_UPREF); op->hops = hops; VCODE_ASSERT(hops >= 0, "invalid hop count"); vcode_unit_t vu = active_unit; for (int i = 0; i < hops; i++) { vu = vu->context; VCODE_ASSERT(vu, "hop count is greater than depth"); } return (op->result = vcode_add_reg(vtype_context(vu->name))); } static vcode_reg_t emit_signal_flag(vcode_op_t opkind, vcode_reg_t nets, vcode_reg_t len) { op_t *op = vcode_add_op(opkind); vcode_add_arg(op, nets); vcode_add_arg(op, len); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "argument to %s is not a signal", vcode_op_string(opkind)); return (op->result = vcode_add_reg(vtype_bool())); } vcode_reg_t emit_event_flag(vcode_reg_t nets, vcode_reg_t len) { return emit_signal_flag(VCODE_OP_EVENT, nets, len); } vcode_reg_t emit_active_flag(vcode_reg_t nets, vcode_reg_t len) { return emit_signal_flag(VCODE_OP_ACTIVE, nets, len); } vcode_reg_t emit_record_ref(vcode_reg_t record, unsigned field) { // Try scanning backwards through the block for another record ref VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_RECORD_REF) { if (other->args.items[0] == record && other->field == field) return other->result; } op_t *op = vcode_add_op(VCODE_OP_RECORD_REF); op->field = field; vcode_add_arg(op, record); vtype_t *rptype = vcode_type_data(vcode_reg_type(record)); VCODE_ASSERT(rptype->kind == VCODE_TYPE_POINTER, "argument to record ref must be a pointer"); vtype_t *rtype = vcode_type_data(rptype->pointed); VCODE_ASSERT(rtype->kind == VCODE_TYPE_RECORD, "argument must be pointer to record or record signal"); VCODE_ASSERT(field < rtype->fields.count, "invalid field %d", field); vcode_type_t field_type = rtype->fields.items[field]; vcode_type_t bounds_type = field_type; vcode_type_t result_type = field_type; const vtype_kind_t fkind = vtype_kind(field_type); if (fkind == VCODE_TYPE_CARRAY) result_type = bounds_type = vtype_elem(field_type); else if (fkind == VCODE_TYPE_UARRAY) { bounds_type = vtype_elem(field_type); result_type = field_type; } op->result = vcode_add_reg(vtype_pointer(result_type)); reg_t *rr = vcode_reg_data(op->result); rr->bounds = bounds_type; return op->result; } vcode_reg_t emit_array_ref(vcode_reg_t array, vcode_reg_t offset) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_ARRAY_REF) { if (other->args.items[0] == array && other->args.items[1] == offset) return other->result; } op_t *op = vcode_add_op(VCODE_OP_ARRAY_REF); vcode_add_arg(op, array); vcode_add_arg(op, offset); vcode_type_t rtype = vcode_reg_type(array); VCODE_ASSERT((vtype_kind(rtype) == VCODE_TYPE_POINTER && vtype_kind(vtype_pointed(rtype)) != VCODE_TYPE_UARRAY) || vtype_kind(rtype) == VCODE_TYPE_SIGNAL, "argument to array ref must be a pointer or signal"); VCODE_ASSERT(vcode_reg_kind(offset) == VCODE_TYPE_OFFSET, "array ref offset argument must have offset type"); op->result = vcode_add_reg(rtype); reg_t *rr = vcode_reg_data(op->result); rr->bounds = vcode_reg_bounds(array); return op->result; } void emit_copy(vcode_reg_t dest, vcode_reg_t src, vcode_reg_t count) { int64_t cconst; if (count != VCODE_INVALID_REG && vcode_reg_const(count, &cconst) && cconst == 0) return; else if (dest == src) return; op_t *op = vcode_add_op(VCODE_OP_COPY); vcode_add_arg(op, dest); vcode_add_arg(op, src); if (count != VCODE_INVALID_REG) vcode_add_arg(op, count); vcode_type_t dtype = vcode_reg_type(dest); vcode_type_t stype = vcode_reg_type(src); vtype_kind_t dkind = vtype_kind(dtype); vtype_kind_t skind = vtype_kind(stype); VCODE_ASSERT(dkind == VCODE_TYPE_POINTER || dkind == VCODE_TYPE_ACCESS, "destination type is not a pointer or access"); VCODE_ASSERT(skind == VCODE_TYPE_POINTER || skind == VCODE_TYPE_ACCESS, "source type is not a pointer or access"); VCODE_ASSERT(vtype_eq(dtype, stype), "source and destination types do not match"); VCODE_ASSERT(count == VCODE_INVALID_REG || vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count is not offset type"); op->type = vtype_pointed(dtype); } void emit_sched_event(vcode_reg_t nets, vcode_reg_t n_elems) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_CLEAR_EVENT) break; else if (other->kind == VCODE_OP_SCHED_EVENT && other->args.items[0] == nets && other->args.items[1] == n_elems) return; } op_t *op = vcode_add_op(VCODE_OP_SCHED_EVENT); vcode_add_arg(op, nets); vcode_add_arg(op, n_elems); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "nets argument to sched event must be signal"); } void emit_clear_event(vcode_reg_t nets, vcode_reg_t n_elems) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_SCHED_EVENT) break; else if (other->kind == VCODE_OP_CLEAR_EVENT && other->args.items[0] == nets && other->args.items[1] == n_elems) return; } op_t *op = vcode_add_op(VCODE_OP_CLEAR_EVENT); vcode_add_arg(op, nets); vcode_add_arg(op, n_elems); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "nets argument to clear event must be signal"); } void emit_resume(ident_t func) { op_t *op = vcode_add_op(VCODE_OP_RESUME); op->func = func; block_t *b = &(active_unit->blocks.items[active_block]); VCODE_ASSERT(b->ops.count == 1, "resume must be first op in a block"); } void emit_memset(vcode_reg_t ptr, vcode_reg_t value, vcode_reg_t len) { int64_t lconst; if (vcode_reg_const(len, &lconst) && lconst == 0) return; op_t *op = vcode_add_op(VCODE_OP_MEMSET); vcode_add_arg(op, ptr); vcode_add_arg(op, value); vcode_add_arg(op, len); VCODE_ASSERT(vtype_kind(vcode_reg_type(ptr)) == VCODE_TYPE_POINTER, "target of memset must have pointer type"); VCODE_ASSERT(vtype_is_scalar(vcode_reg_type(value)), "value of memset must have scalar type"); VCODE_ASSERT(vtype_kind(vcode_reg_type(len)) == VCODE_TYPE_OFFSET, "length of memset must have offset type"); } void emit_case(vcode_reg_t value, vcode_block_t def, const vcode_reg_t *cases, const vcode_block_t *blocks, int ncases) { int64_t cval1, cval2; bool is_const = vcode_reg_const(value, &cval1); for (int i = 0; i < ncases; i++) { bool can_fold = false; if (cases[i] == value) can_fold = true; else if (is_const && vcode_reg_const(cases[i], &cval2)) can_fold = (cval1 == cval2); if (can_fold) { emit_jump(blocks[i]); return; } } if (is_const) { emit_jump(def); return; } op_t *op = vcode_add_op(VCODE_OP_CASE); vcode_add_arg(op, value); vcode_add_target(op, def); for (int i = 0; i < ncases; i++) { vcode_add_arg(op, cases[i]); vcode_add_target(op, blocks[i]); #ifdef DEBUG for (int j = 0; j < i; j++) VCODE_ASSERT(cases[i] != cases[j], "duplicate case choice"); #endif } } void emit_file_open(vcode_reg_t file, vcode_reg_t name, vcode_reg_t length, vcode_reg_t kind, vcode_reg_t status) { op_t *op = vcode_add_op(VCODE_OP_FILE_OPEN); vcode_add_arg(op, file); vcode_add_arg(op, name); vcode_add_arg(op, length); vcode_add_arg(op, kind); if (status != VCODE_INVALID_REG) vcode_add_arg(op, status); VCODE_ASSERT(vtype_is_pointer(vcode_reg_type(file), VCODE_TYPE_FILE), "file open first argument must have file pointer type"); } void emit_file_write(vcode_reg_t file, vcode_reg_t value, vcode_reg_t length) { op_t *op = vcode_add_op(VCODE_OP_FILE_WRITE); vcode_add_arg(op, file); vcode_add_arg(op, value); if (length != VCODE_INVALID_REG) vcode_add_arg(op, length); VCODE_ASSERT(vtype_is_pointer(vcode_reg_type(file), VCODE_TYPE_FILE), "file write first argument must have file pointer type"); } void emit_file_read(vcode_reg_t file, vcode_reg_t ptr, vcode_reg_t inlen, vcode_reg_t outlen) { op_t *op = vcode_add_op(VCODE_OP_FILE_READ); vcode_add_arg(op, file); vcode_add_arg(op, ptr); if (inlen != VCODE_INVALID_REG) { vcode_add_arg(op, inlen); if (outlen != VCODE_INVALID_REG) vcode_add_arg(op, outlen); } VCODE_ASSERT(vtype_is_pointer(vcode_reg_type(file), VCODE_TYPE_FILE), "file read first argument must have file pointer type"); VCODE_ASSERT(vtype_kind(vcode_reg_type(ptr)) == VCODE_TYPE_POINTER, "file read pointer argument must have pointer type"); VCODE_ASSERT(outlen == VCODE_INVALID_REG || vtype_kind(vcode_reg_type(outlen)) == VCODE_TYPE_POINTER, "file read outlen argument must have pointer type"); } vcode_reg_t emit_null(vcode_type_t type) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_NULL) { if (vtype_eq(vcode_reg_type(other->result), type)) return other->result; } op_t *op = vcode_add_op(VCODE_OP_NULL); op->result = vcode_add_reg(type); vtype_kind_t kind = vtype_kind(type); VCODE_ASSERT(kind == VCODE_TYPE_POINTER || kind == VCODE_TYPE_FILE || kind == VCODE_TYPE_ACCESS || kind == VCODE_TYPE_CONTEXT, "null type must be file, access, context, or pointer"); return op->result; } vcode_reg_t emit_new(vcode_type_t type, vcode_reg_t length) { op_t *op = vcode_add_op(VCODE_OP_NEW); if (length != VCODE_INVALID_REG) vcode_add_arg(op, length); op->result = vcode_add_reg(vtype_access(type)); vtype_kind_t kind = vtype_kind(type); VCODE_ASSERT(kind == VCODE_TYPE_INT || kind == VCODE_TYPE_RECORD || kind == VCODE_TYPE_UARRAY || kind == VCODE_TYPE_ACCESS || kind == VCODE_TYPE_REAL || kind == VCODE_TYPE_CONTEXT, "new type must be int, real, record, access, or uarray"); VCODE_ASSERT(length == VCODE_INVALID_REG || vtype_kind(vcode_reg_type(length)) == VCODE_TYPE_OFFSET, "new length must have offset type"); return op->result; } void emit_null_check(vcode_reg_t ptr, vcode_reg_t locus) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_NULL_CHECK && other->args.items[0] == ptr) return; else if (other->kind == VCODE_OP_NEW && other->result == ptr) return; } op_t *op = vcode_add_op(VCODE_OP_NULL_CHECK); vcode_add_arg(op, ptr); vcode_add_arg(op, locus); VCODE_ASSERT(vtype_kind(vcode_reg_type(ptr)) == VCODE_TYPE_ACCESS, "null check argument must be an access"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to null check must be a debug locus"); } void emit_deallocate(vcode_reg_t ptr) { op_t *op = vcode_add_op(VCODE_OP_DEALLOCATE); vcode_add_arg(op, ptr); vcode_type_t ptype = vcode_reg_type(ptr); VCODE_ASSERT(vtype_kind(ptype) == VCODE_TYPE_POINTER && vtype_kind(vtype_pointed(ptype)) == VCODE_TYPE_ACCESS, "deallocate argument must be pointer to access"); } vcode_reg_t emit_all(vcode_reg_t reg) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_ALL) { if (other->args.items[0] == reg) return other->result; } op_t *op = vcode_add_op(VCODE_OP_ALL); vcode_add_arg(op, reg); vcode_type_t vtype = vcode_reg_type(reg); VCODE_ASSERT(vtype_kind(vtype) == VCODE_TYPE_ACCESS, "all argument must be an access"); vcode_type_t pointed = vtype_pointed(vtype); op->result = vcode_add_reg(vtype_pointer(pointed)); reg_t *rr = vcode_reg_data(op->result); rr->bounds = pointed; VCODE_ASSERT(vtype_kind(pointed) != VCODE_TYPE_OPAQUE, "cannot dereference opaque type"); return op->result; } static vcode_reg_t emit_signal_data_op(vcode_op_t kind, vcode_reg_t sig) { block_t *b = &(active_unit->blocks.items[active_block]); for (int i = b->ops.count - 1; i >= 0; i--) { const op_t *other = &(b->ops.items[i]); if (other->kind == kind && other->args.items[0] == sig) return other->result; } op_t *op = vcode_add_op(kind); vcode_add_arg(op, sig); vcode_type_t stype = vcode_reg_type(sig); op->type = stype; VCODE_ASSERT(vtype_kind(stype) == VCODE_TYPE_SIGNAL, "argument r%d to resolved is not a signal", sig); vcode_type_t rtype = vtype_base(stype); const vtype_kind_t rkind = vtype_kind(rtype); if (rkind == VCODE_TYPE_CARRAY || rkind == VCODE_TYPE_UARRAY) rtype = vtype_elem(rtype); VCODE_ASSERT(vtype_is_scalar(rtype), "resolved signal base type must be scalar"); op->result = vcode_add_reg(vtype_pointer(rtype)); reg_t *rr = vcode_reg_data(op->result); rr->bounds = rtype; return op->result; } vcode_reg_t emit_resolved(vcode_reg_t sig, vcode_reg_t count) { return emit_signal_data_op(VCODE_OP_RESOLVED, sig); } vcode_reg_t emit_last_value(vcode_reg_t sig, vcode_reg_t count) { return emit_signal_data_op(VCODE_OP_LAST_VALUE, sig); } vcode_reg_t emit_last_event(vcode_reg_t signal, vcode_reg_t len) { op_t *op = vcode_add_op(VCODE_OP_LAST_EVENT); vcode_add_arg(op, signal); if (len != VCODE_INVALID_REG) vcode_add_arg(op, len); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "signal argument to last event must have signal type"); VCODE_ASSERT(len == VCODE_INVALID_REG || vcode_reg_kind(len) == VCODE_TYPE_OFFSET, "length argument to last event must have offset type"); return (op->result = vcode_add_reg(vtype_time())); } vcode_reg_t emit_last_active(vcode_reg_t signal, vcode_reg_t len) { op_t *op = vcode_add_op(VCODE_OP_LAST_ACTIVE); vcode_add_arg(op, signal); if (len != VCODE_INVALID_REG) vcode_add_arg(op, len); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "signal argument to last active must have signal type"); VCODE_ASSERT(len == VCODE_INVALID_REG || vcode_reg_kind(len) == VCODE_TYPE_OFFSET, "length argument to last active must have offset type"); return (op->result = vcode_add_reg(vtype_time())); } void emit_alias_signal(vcode_reg_t signal, vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_ALIAS_SIGNAL); vcode_add_arg(op, signal); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "signal argument must have signal type"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument must have debug locus type"); } vcode_reg_t emit_driving_flag(vcode_reg_t signal, vcode_reg_t len) { op_t *op = vcode_add_op(VCODE_OP_DRIVING); vcode_add_arg(op, signal); vcode_add_arg(op, len); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "signal argument to last active must have signal type"); VCODE_ASSERT(vcode_reg_kind(len) == VCODE_TYPE_OFFSET, "length argument to last active must have offset type"); return (op->result = vcode_add_reg(vtype_bool())); } vcode_reg_t emit_driving_value(vcode_reg_t signal, vcode_reg_t len) { op_t *op = vcode_add_op(VCODE_OP_DRIVING_VALUE); vcode_add_arg(op, signal); if (len != VCODE_INVALID_REG) vcode_add_arg(op, len); vcode_type_t signal_type = vcode_reg_type(signal); VCODE_ASSERT(vtype_kind(signal_type) == VCODE_TYPE_SIGNAL, "signal argument to last active must have signal type"); VCODE_ASSERT(len == VCODE_INVALID_REG || vcode_reg_kind(len) == VCODE_TYPE_OFFSET, "length argument to last active must have offset type"); vcode_type_t base_type = vtype_base(signal_type); op->result = vcode_add_reg(vtype_pointer(base_type)); reg_t *rr = vcode_reg_data(op->result); rr->bounds = base_type; return op->result; } void emit_length_check(vcode_reg_t llen, vcode_reg_t rlen, vcode_reg_t locus, vcode_reg_t dim) { if (rlen == llen) return; VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_LENGTH_CHECK) { if (other->args.items[0] == llen && other->args.items[1] == rlen) return; } op_t *op = vcode_add_op(VCODE_OP_LENGTH_CHECK); vcode_add_arg(op, llen); vcode_add_arg(op, rlen); vcode_add_arg(op, locus); if (dim != VCODE_INVALID_REG) vcode_add_arg(op, dim); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to length check must be a debug locus"); } void emit_exponent_check(vcode_reg_t exp, vcode_reg_t locus) { int64_t cval; if (vcode_reg_const(exp, &cval) && cval >= 0) return; VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_EXPONENT_CHECK) { if (other->args.items[0] == exp) return; } op_t *op = vcode_add_op(VCODE_OP_EXPONENT_CHECK); vcode_add_arg(op, exp); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(exp) == VCODE_TYPE_INT, "exp argument to exponent check must be a integer"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to exponent check must be a debug locus"); } void emit_zero_check(vcode_reg_t denom, vcode_reg_t locus) { int64_t cval; if (vcode_reg_const(denom, &cval) && cval != 0) return; VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_ZERO_CHECK) { if (other->args.items[0] == denom) return; } op_t *op = vcode_add_op(VCODE_OP_ZERO_CHECK); vcode_add_arg(op, denom); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(denom) == VCODE_TYPE_INT, "denom argument to zero check must be a integer"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to zero check must be a debug locus"); } static bool vcode_can_elide_bounds(vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir) { int64_t dconst; if (vcode_reg_const(dir, &dconst)) { int64_t lconst, rconst; if (vcode_reg_const(left, &lconst) && vcode_reg_const(right, &rconst)) { const bool is_null = (dconst == RANGE_TO && lconst > rconst) || (dconst == RANGE_DOWNTO && rconst > lconst); vtype_t *bounds = vcode_type_data(vcode_reg_bounds(reg)); const bool ok_static = (dconst == RANGE_TO && bounds->low >= lconst && bounds->high <= rconst) || (dconst == RANGE_DOWNTO && bounds->low >= rconst && bounds->high <= lconst) || (!is_null && (reg == left || reg == right)); return ok_static; } else if (vcode_reg_kind(reg) == VCODE_TYPE_REAL) { vtype_t *lbounds = vcode_type_data(vcode_reg_bounds(left)); vtype_t *rbounds = vcode_type_data(vcode_reg_bounds(right)); assert(lbounds->kind == VCODE_TYPE_REAL); assert(rbounds->kind == VCODE_TYPE_REAL); vtype_t *bounds = vcode_type_data(vcode_reg_bounds(reg)); assert(bounds->kind == VCODE_TYPE_REAL); if (isfinite(bounds->rlow) && lbounds->rlow == -DBL_MAX && isfinite(bounds->rhigh) && rbounds->rhigh == DBL_MAX) { // Covers the complete double range so can never overflow return true; } } } return false; } static void emit_bounds_check(vcode_op_t kind, vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir, vcode_reg_t locus, vcode_reg_t hint) { VCODE_FOR_EACH_MATCHING_OP(other, kind) { if (other->args.items[0] == reg && other->args.items[1] == left && other->args.items[2] == right && other->args.items[3] == dir) return; } if (vcode_can_elide_bounds(reg, left, right, dir)) { emit_comment("Elided bounds check for r%d", reg); return; } op_t *op = vcode_add_op(kind); vcode_add_arg(op, reg); vcode_add_arg(op, left); vcode_add_arg(op, right); vcode_add_arg(op, dir); vcode_add_arg(op, locus); vcode_add_arg(op, hint); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to bounds check must be a debug locus"); VCODE_ASSERT(vcode_reg_kind(hint) == VCODE_TYPE_DEBUG_LOCUS, "hint argument to bounds check must be a debug locus"); } void emit_range_check(vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir, vcode_reg_t locus, vcode_reg_t hint) { emit_bounds_check(VCODE_OP_RANGE_CHECK, reg, left, right, dir, locus, hint); } void emit_index_check(vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir, vcode_reg_t locus, vcode_reg_t hint) { emit_bounds_check(VCODE_OP_INDEX_CHECK, reg, left, right, dir, locus, hint); } void emit_dir_check(vcode_reg_t reg, vcode_reg_t dir, vcode_reg_t locus) { if (reg == dir) return; op_t *op = vcode_add_op(VCODE_OP_DIR_CHECK); vcode_add_arg(op, reg); vcode_add_arg(op, dir); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to dir check must be a debug locus"); } void emit_package_scope(vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_PACKAGE_SCOPE); vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to package scope must be a debug locus"); } void emit_array_scope(vcode_reg_t locus, vcode_type_t type) { op_t *op = vcode_add_op(VCODE_OP_ARRAY_SCOPE); vcode_add_arg(op, locus); op->type = type; VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to array scope must be a debug locus"); } void emit_record_scope(vcode_reg_t locus, vcode_type_t type) { op_t *op = vcode_add_op(VCODE_OP_RECORD_SCOPE); vcode_add_arg(op, locus); op->type = type; VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to record scope must be a debug locus"); } void emit_pop_scope(void) { vcode_add_op(VCODE_OP_POP_SCOPE); } vcode_reg_t emit_debug_locus(object_t *obj) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_DEBUG_LOCUS) { if (other->object == obj) return other->result; } op_t *op = vcode_add_op(VCODE_OP_DEBUG_LOCUS); op->object = obj; return (op->result = vcode_add_reg(vtype_debug_locus())); } void emit_debug_out(vcode_reg_t reg) { op_t *op = vcode_add_op(VCODE_OP_DEBUG_OUT); vcode_add_arg(op, reg); } void emit_cover_stmt(uint32_t tag) { op_t *op = vcode_add_op(VCODE_OP_COVER_STMT); op->tag = tag; } void emit_cover_branch(uint32_t tag) { op_t *op = vcode_add_op(VCODE_OP_COVER_BRANCH); op->tag = tag; } void emit_cover_toggle(vcode_reg_t signal, uint32_t tag) { op_t *op = vcode_add_op(VCODE_OP_COVER_TOGGLE); vcode_add_arg(op, signal); op->tag = tag; } void emit_cover_state(vcode_reg_t signal, vcode_reg_t low, uint32_t tag) { op_t *op = vcode_add_op(VCODE_OP_COVER_STATE); vcode_add_arg(op, signal); vcode_add_arg(op, low); op->tag = tag; } void emit_cover_expr(uint32_t tag) { op_t *op = vcode_add_op(VCODE_OP_COVER_EXPR); op->tag = tag; } void emit_unreachable(vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_UNREACHABLE); if (locus != VCODE_INVALID_REG) vcode_add_arg(op, locus); } vcode_reg_t emit_undefined(vcode_type_t type, vcode_type_t bounds) { active_unit->flags |= UNIT_UNDEFINED; op_t *op = vcode_add_op(VCODE_OP_UNDEFINED); op->result = vcode_add_reg(type); vcode_reg_data(op->result)->bounds = bounds; return op->result; } void emit_debug_info(const loc_t *loc) { if (!loc_invalid_p(loc)) vcode_block_data()->last_loc = *loc; } vcode_reg_t emit_link_var(vcode_reg_t context, ident_t name, vcode_type_t type) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_LINK_VAR) { if (other->args.items[0] == context && other->ident == name) return other->result; } op_t *op = vcode_add_op(VCODE_OP_LINK_VAR); vcode_add_arg(op, context); op->ident = name; VCODE_ASSERT(vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "first argument to link var must be context"); if (vtype_kind(type) == VCODE_TYPE_CARRAY) { op->result = vcode_add_reg(vtype_pointer(vtype_elem(type))); vcode_reg_data(op->result)->bounds = vtype_bounds(type); } else { op->result = vcode_add_reg(vtype_pointer(type)); vcode_reg_data(op->result)->bounds = type; } return op->result; } vcode_reg_t emit_link_package(ident_t name) { VCODE_FOR_EACH_OP(other) { if (other->kind == VCODE_OP_LINK_PACKAGE && other->ident == name) return other->result; else if (other->kind == VCODE_OP_PACKAGE_INIT && other->func == name) return other->result; } op_t *op = vcode_add_op(VCODE_OP_LINK_PACKAGE); op->ident = name; VCODE_ASSERT(name != active_unit->name, "cannot link the current unit"); return (op->result = vcode_add_reg(vtype_context(name))); } void emit_enter_state(vcode_reg_t state, vcode_reg_t strong) { VCODE_FOR_EACH_MATCHING_OP(other, VCODE_OP_ENTER_STATE) { if (other->args.items[0] == state) return; } op_t *op = vcode_add_op(VCODE_OP_ENTER_STATE); vcode_add_arg(op, state); if (strong != VCODE_INVALID_REG) vcode_add_arg(op, strong); VCODE_ASSERT(vcode_reg_kind(state) == VCODE_TYPE_INT, "state must have integer type"); VCODE_ASSERT(strong == VCODE_INVALID_REG || vtype_eq(vcode_reg_type(strong), vtype_bool()), "strong argument not is not boolean"); } vcode_reg_t emit_reflect_value(vcode_reg_t value, vcode_reg_t context, vcode_reg_t locus, vcode_reg_t bounds) { op_t *op = vcode_add_op(VCODE_OP_REFLECT_VALUE); vcode_add_arg(op, value); vcode_add_arg(op, context); vcode_add_arg(op, locus); if (bounds != VCODE_INVALID_REG) vcode_add_arg(op, bounds); VCODE_ASSERT(vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "invalid reflect value context argument"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to reflect value must be a debug locus"); return (op->result = vcode_add_reg(vtype_access(vtype_opaque()))); } vcode_reg_t emit_reflect_subtype(vcode_reg_t context, vcode_reg_t locus, vcode_reg_t bounds) { op_t *op = vcode_add_op(VCODE_OP_REFLECT_SUBTYPE); vcode_add_arg(op, context); vcode_add_arg(op, locus); if (bounds != VCODE_INVALID_REG) vcode_add_arg(op, bounds); VCODE_ASSERT(vcode_reg_kind(context) == VCODE_TYPE_CONTEXT, "invalid reflect value context argument"); VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to reflect value must be a debug locus"); return (op->result = vcode_add_reg(vtype_access(vtype_opaque()))); } vcode_reg_t emit_function_trigger(ident_t func, const vcode_reg_t *args, int nargs) { op_t *op = vcode_add_op(VCODE_OP_FUNCTION_TRIGGER); op->func = func; for (int i = 0; i < nargs; i++) vcode_add_arg(op, args[i]); return (op->result = vcode_add_reg(vtype_trigger())); } vcode_reg_t emit_or_trigger(vcode_reg_t left, vcode_reg_t right) { op_t *op = vcode_add_op(VCODE_OP_OR_TRIGGER); vcode_add_arg(op, left); vcode_add_arg(op, right); VCODE_ASSERT(vcode_reg_kind(left) == VCODE_TYPE_TRIGGER, "or trigger left argument must be trigger"); VCODE_ASSERT(vcode_reg_kind(right) == VCODE_TYPE_TRIGGER, "or trigger right argument must be trigger"); return (op->result = vcode_add_reg(vtype_trigger())); } vcode_reg_t emit_cmp_trigger(vcode_reg_t left, vcode_reg_t right) { op_t *op = vcode_add_op(VCODE_OP_CMP_TRIGGER); vcode_add_arg(op, left); vcode_add_arg(op, right); VCODE_ASSERT(vcode_reg_kind(left) == VCODE_TYPE_SIGNAL, "cmp trigger left argument must be signal"); VCODE_ASSERT(vcode_reg_kind(right) == VCODE_TYPE_INT, "cmp trigger right argument must be integer"); return (op->result = vcode_add_reg(vtype_trigger())); } void emit_add_trigger(vcode_reg_t trigger) { op_t *op = vcode_add_op(VCODE_OP_ADD_TRIGGER); vcode_add_arg(op, trigger); VCODE_ASSERT(vcode_reg_kind(trigger) == VCODE_TYPE_TRIGGER, "add trigger argument must be trigger"); } vcode_reg_t emit_port_conversion(vcode_reg_t driving, vcode_reg_t effective) { op_t *op = vcode_add_op(VCODE_OP_PORT_CONVERSION); vcode_add_arg(op, driving); if (effective != VCODE_INVALID_REG && effective != driving) vcode_add_arg(op, effective); VCODE_ASSERT(vcode_reg_kind(driving) == VCODE_TYPE_CLOSURE, "port conversion argument must be a closure"); VCODE_ASSERT(effective == VCODE_INVALID_REG || vcode_reg_kind(effective) == VCODE_TYPE_CLOSURE, "port conversion argument must be a closure"); return (op->result = vcode_add_reg(vtype_conversion())); } vcode_reg_t emit_bind_external(vcode_reg_t locus, ident_t scope, vcode_type_t type, vcode_type_t bounds) { op_t *op = vcode_add_op(VCODE_OP_BIND_EXTERNAL); vcode_add_arg(op, locus); op->type = type; op->ident = scope; VCODE_ASSERT(vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "bind external argument must be locus"); op->result = vcode_add_reg(vtype_pointer(type)); vcode_reg_data(op->result)->bounds = bounds; return op->result; } void emit_put_conversion(vcode_reg_t cf, vcode_reg_t target, vcode_reg_t count, vcode_reg_t values) { op_t *op = vcode_add_op(VCODE_OP_PUT_CONVERSION); vcode_add_arg(op, cf); vcode_add_arg(op, target); vcode_add_arg(op, count); vcode_add_arg(op, values); VCODE_ASSERT(vcode_reg_kind(target) == VCODE_TYPE_SIGNAL, "put conversion target is not signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "put conversion net count is not offset type"); VCODE_ASSERT(vcode_reg_kind(values) != VCODE_TYPE_SIGNAL, "signal cannot be values argument for put conversion"); VCODE_ASSERT(vcode_reg_kind(cf) == VCODE_TYPE_CONVERSION, "cf argument to put conversion must be conversion function"); } void emit_convert_in(vcode_reg_t conv, vcode_reg_t nets, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_CONVERT_IN); vcode_add_arg(op, conv); vcode_add_arg(op, nets); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(conv) == VCODE_TYPE_CONVERSION, "conv argument to convert must be a port conversion"); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "nets argument to convert must be a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument to convert must be offset"); } void emit_convert_out(vcode_reg_t conv, vcode_reg_t nets, vcode_reg_t count) { op_t *op = vcode_add_op(VCODE_OP_CONVERT_OUT); vcode_add_arg(op, conv); vcode_add_arg(op, nets); vcode_add_arg(op, count); VCODE_ASSERT(vcode_reg_kind(conv) == VCODE_TYPE_CONVERSION, "conv argument to convert must be a port conversion"); VCODE_ASSERT(vcode_reg_kind(nets) == VCODE_TYPE_SIGNAL, "nets argument to convert must be a signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "count argument to convert must be offset"); } void emit_bind_foreign(vcode_reg_t spec, vcode_reg_t length, vcode_reg_t locus) { op_t *op = vcode_add_op(VCODE_OP_BIND_FOREIGN); vcode_add_arg(op, spec); vcode_add_arg(op, length); if (locus != VCODE_INVALID_REG) vcode_add_arg(op, locus); VCODE_ASSERT(vcode_reg_kind(spec) == VCODE_TYPE_POINTER, "spec argument to bind foreign must be a pointer"); VCODE_ASSERT(vcode_reg_kind(length) == VCODE_TYPE_OFFSET, "length argument to bind foreign must be offset"); VCODE_ASSERT(locus == VCODE_INVALID_REG || vcode_reg_kind(locus) == VCODE_TYPE_DEBUG_LOCUS, "locus argument to bind foreign value must be a debug locus"); } vcode_reg_t emit_instance_name(vcode_reg_t kind) { op_t *op = vcode_add_op(VCODE_OP_INSTANCE_NAME); vcode_add_arg(op, kind); VCODE_ASSERT(vcode_reg_kind(kind) == VCODE_TYPE_OFFSET, "kind argument to instance name must be offset"); vcode_type_t vchar = vtype_char(); return (op->result = vcode_add_reg(vtype_uarray(1, vchar, vchar))); } void emit_deposit_signal(vcode_reg_t signal, vcode_reg_t count, vcode_reg_t values) { op_t *op = vcode_add_op(VCODE_OP_DEPOSIT_SIGNAL); vcode_add_arg(op, signal); vcode_add_arg(op, count); vcode_add_arg(op, values); VCODE_ASSERT(vcode_reg_kind(signal) == VCODE_TYPE_SIGNAL, "deposit signal target is not signal"); VCODE_ASSERT(vcode_reg_kind(count) == VCODE_TYPE_OFFSET, "deposit signal count is not offset type"); VCODE_ASSERT(vcode_reg_kind(values) != VCODE_TYPE_SIGNAL, "signal cannot be values argument for deposit signal"); } void vcode_walk_dependencies(vcode_unit_t vu, vcode_dep_fn_t fn, void *ctx) { vcode_state_t state; vcode_state_save(&state); vcode_select_unit(vu); const int nblocks = vcode_count_blocks(); for (int i = 0; i < nblocks; i++) { vcode_select_block(i); const int nops = vcode_count_ops(); for (int op = 0; op < nops; op++) { switch (vcode_get_op(op)) { case VCODE_OP_LINK_PACKAGE: (*fn)(vcode_get_ident(op), ctx); break; case VCODE_OP_FCALL: case VCODE_OP_PCALL: case VCODE_OP_CLOSURE: case VCODE_OP_PROTECTED_INIT: case VCODE_OP_PACKAGE_INIT: case VCODE_OP_FUNCTION_TRIGGER: (*fn)(vcode_get_func(op), ctx); break; default: break; } } } vcode_state_restore(&state); } #if VCODE_CHECK_UNIONS #define OP_USE_COUNT_U0(x) \ (OP_HAS_IDENT(x) + OP_HAS_FUNC(x) + OP_HAS_ADDRESS(x)) #define OP_USE_COUNT_U1(x) \ (OP_HAS_CMP(x) + OP_HAS_VALUE(x) + OP_HAS_REAL(x) + \ OP_HAS_COMMENT(x) + OP_HAS_DIM(x) + OP_HAS_TARGET(x) + \ OP_HAS_HOPS(x) + OP_HAS_FIELD(x) + OP_HAS_TAG(x)) __attribute__((constructor)) static void vcode_check_unions(void) { printf("sizeof(op_t) = %ld\n", sizeof(op_t)); for (int i = 0; i < 256; i++) { assert(OP_USE_COUNT_U0(i) <= 1); assert(OP_USE_COUNT_U1(i) <= 1); } } #endif // VCODE_CHECK_UNIONS nvc-r1.17.1/src/vcode.h000066400000000000000000000514621504111170000146070ustar00rootroot00000000000000// // Copyright (C) 2014-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VCODE_H #define _VCODE_H #include "util.h" #include "ident.h" #include "prim.h" #include "rt/rt.h" typedef int32_t vcode_type_t; typedef int32_t vcode_block_t; typedef int32_t vcode_var_t; typedef int32_t vcode_reg_t; typedef enum { VCODE_CMP_EQ, VCODE_CMP_NEQ, VCODE_CMP_LT, VCODE_CMP_GT, VCODE_CMP_LEQ, VCODE_CMP_GEQ, } vcode_cmp_t; typedef enum { VCODE_OP_CMP, VCODE_OP_FCALL, VCODE_OP_WAIT, VCODE_OP_CONST, VCODE_OP_ASSERT, VCODE_OP_JUMP, VCODE_OP_LOAD, VCODE_OP_STORE, VCODE_OP_MUL, VCODE_OP_ADD, VCODE_OP_COMMENT, VCODE_OP_CONST_ARRAY, VCODE_OP_INDEX, VCODE_OP_SUB, VCODE_OP_CAST, VCODE_OP_LOAD_INDIRECT, VCODE_OP_STORE_INDIRECT, VCODE_OP_RETURN, VCODE_OP_SCHED_WAVEFORM, VCODE_OP_COND, VCODE_OP_REPORT, VCODE_OP_DIV, VCODE_OP_NEG, VCODE_OP_EXP, VCODE_OP_ABS, VCODE_OP_MOD, VCODE_OP_REM, VCODE_OP_ALLOC, VCODE_OP_SELECT, VCODE_OP_OR, VCODE_OP_WRAP, VCODE_OP_UARRAY_LEFT, VCODE_OP_UARRAY_RIGHT, VCODE_OP_UARRAY_DIR, VCODE_OP_UNWRAP, VCODE_OP_NOT, VCODE_OP_AND, VCODE_OP_EVENT, VCODE_OP_ACTIVE, VCODE_OP_CONST_RECORD, VCODE_OP_RECORD_REF, VCODE_OP_COPY, VCODE_OP_SCHED_EVENT, VCODE_OP_PCALL, VCODE_OP_RESUME, VCODE_OP_XOR, VCODE_OP_XNOR, VCODE_OP_NAND, VCODE_OP_NOR, VCODE_OP_MEMSET, VCODE_OP_CASE, VCODE_OP_FILE_OPEN, VCODE_OP_FILE_WRITE, VCODE_OP_FILE_READ, VCODE_OP_NULL, VCODE_OP_NEW, VCODE_OP_NULL_CHECK, VCODE_OP_DEALLOCATE, VCODE_OP_ALL, VCODE_OP_CONST_REAL, VCODE_OP_LAST_EVENT, VCODE_OP_DEBUG_OUT, VCODE_OP_COVER_STMT, VCODE_OP_COVER_BRANCH, VCODE_OP_COVER_TOGGLE, VCODE_OP_COVER_EXPR, VCODE_OP_COVER_STATE, VCODE_OP_UARRAY_LEN, VCODE_OP_UNDEFINED, VCODE_OP_RANGE_NULL, VCODE_OP_VAR_UPREF, VCODE_OP_RESOLVED, VCODE_OP_LAST_VALUE, VCODE_OP_INIT_SIGNAL, VCODE_OP_MAP_SIGNAL, VCODE_OP_DRIVE_SIGNAL, VCODE_OP_LINK_VAR, VCODE_OP_RESOLUTION_WRAPPER, VCODE_OP_LAST_ACTIVE, VCODE_OP_DRIVING, VCODE_OP_DRIVING_VALUE, VCODE_OP_ADDRESS_OF, VCODE_OP_CLOSURE, VCODE_OP_PROTECTED_INIT, VCODE_OP_CONTEXT_UPREF, VCODE_OP_CONST_REP, VCODE_OP_PROTECTED_FREE, VCODE_OP_IMPLICIT_SIGNAL, VCODE_OP_DISCONNECT, VCODE_OP_LINK_PACKAGE, VCODE_OP_INDEX_CHECK, VCODE_OP_DEBUG_LOCUS, VCODE_OP_LENGTH_CHECK, VCODE_OP_RANGE_CHECK, VCODE_OP_ARRAY_REF, VCODE_OP_RANGE_LENGTH, VCODE_OP_EXPONENT_CHECK, VCODE_OP_ZERO_CHECK, VCODE_OP_MAP_CONST, VCODE_OP_RESOLVE_SIGNAL, VCODE_OP_PACKAGE_SCOPE, VCODE_OP_POP_SCOPE, VCODE_OP_ALIAS_SIGNAL, VCODE_OP_TRAP_ADD, VCODE_OP_TRAP_SUB, VCODE_OP_TRAP_MUL, VCODE_OP_FORCE, VCODE_OP_RELEASE, VCODE_OP_UNREACHABLE, VCODE_OP_PACKAGE_INIT, VCODE_OP_TRAP_NEG, VCODE_OP_PROCESS_INIT, VCODE_OP_CLEAR_EVENT, VCODE_OP_TRAP_EXP, VCODE_OP_ENTER_STATE, VCODE_OP_REFLECT_VALUE, VCODE_OP_REFLECT_SUBTYPE, VCODE_OP_FUNCTION_TRIGGER, VCODE_OP_ADD_TRIGGER, VCODE_OP_TRANSFER_SIGNAL, VCODE_OP_PORT_CONVERSION, VCODE_OP_CONVERT_IN, VCODE_OP_CONVERT_OUT, VCODE_OP_BIND_FOREIGN, VCODE_OP_OR_TRIGGER, VCODE_OP_CMP_TRIGGER, VCODE_OP_INSTANCE_NAME, VCODE_OP_DEPOSIT_SIGNAL, VCODE_OP_MAP_IMPLICIT, VCODE_OP_BIND_EXTERNAL, VCODE_OP_ARRAY_SCOPE, VCODE_OP_RECORD_SCOPE, VCODE_OP_SYSCALL, VCODE_OP_PUT_CONVERSION, VCODE_OP_DIR_CHECK, } vcode_op_t; typedef enum { VCODE_TYPE_INT, VCODE_TYPE_CARRAY, VCODE_TYPE_POINTER, VCODE_TYPE_OFFSET, VCODE_TYPE_SIGNAL, VCODE_TYPE_UARRAY, VCODE_TYPE_RECORD, VCODE_TYPE_FILE, VCODE_TYPE_ACCESS, VCODE_TYPE_REAL, VCODE_TYPE_OPAQUE, VCODE_TYPE_RESOLUTION, VCODE_TYPE_CLOSURE, VCODE_TYPE_CONTEXT, VCODE_TYPE_DEBUG_LOCUS, VCODE_TYPE_TRIGGER, VCODE_TYPE_CONVERSION, } vtype_kind_t; typedef enum { VCODE_REPR_U1, VCODE_REPR_I8, VCODE_REPR_U8, VCODE_REPR_I16, VCODE_REPR_U16, VCODE_REPR_I32, VCODE_REPR_U32, VCODE_REPR_I64, VCODE_REPR_U64, } vtype_repr_t; typedef enum { VCODE_UNIT_PROCESS, VCODE_UNIT_FUNCTION, VCODE_UNIT_PROCEDURE, VCODE_UNIT_THUNK, VCODE_UNIT_INSTANCE, VCODE_UNIT_PACKAGE, VCODE_UNIT_PROTECTED, VCODE_UNIT_PROPERTY, } vunit_kind_t; typedef struct { vcode_reg_t left; vcode_reg_t right; vcode_reg_t dir; } vcode_dim_t; typedef struct { vcode_unit_t unit; vcode_block_t block; } vcode_state_t; typedef enum { VAR_TEMP = (1 << 1), VAR_HEAP = (1 << 2), VAR_CONST = (1 << 3), VAR_SIGNAL = (1 << 4) } vcode_var_flags_t; #define VCODE_INVALID_REG -1 #define VCODE_INVALID_BLOCK -1 #define VCODE_INVALID_VAR -1 #define VCODE_INVALID_TYPE -1 typedef int (*vcode_dump_fn_t)(int, void *); typedef void (*vcode_dep_fn_t)(ident_t, void *); vcode_type_t vtype_int(int64_t low, int64_t high); vcode_type_t vtype_dynamic(vcode_reg_t low, vcode_reg_t high); vcode_type_t vtype_bool(void); vcode_type_t vtype_carray(int size, vcode_type_t elem, vcode_type_t bounds); vcode_type_t vtype_uarray(int ndim, vcode_type_t elem, vcode_type_t bounds); vcode_type_t vtype_pointer(vcode_type_t to); vcode_type_t vtype_access(vcode_type_t to); vcode_type_t vtype_signal(vcode_type_t base); vcode_type_t vtype_offset(void); vcode_type_t vtype_time(void); vcode_type_t vtype_char(void); vcode_type_t vtype_opaque(void); vcode_type_t vtype_find_named_record(ident_t name); vcode_type_t vtype_named_record(ident_t name, const vcode_type_t *field_types, int nfields); vcode_type_t vtype_file(vcode_type_t base); vcode_type_t vtype_resolution(vcode_type_t base); vcode_type_t vtype_closure(vcode_type_t result); vcode_type_t vtype_context(ident_t name); vcode_type_t vtype_debug_locus(void); vcode_type_t vtype_trigger(void); vcode_type_t vtype_conversion(void); bool vtype_eq(vcode_type_t a, vcode_type_t b); vtype_kind_t vtype_kind(vcode_type_t type); bool vtype_is_scalar(vcode_type_t type); bool vtype_is_composite(vcode_type_t type); bool vtype_is_signal(vcode_type_t type); int64_t vtype_low(vcode_type_t type); int64_t vtype_high(vcode_type_t type); vcode_type_t vtype_elem(vcode_type_t type); vcode_type_t vtype_pointed(vcode_type_t type); vcode_type_t vtype_bounds(vcode_type_t type); unsigned vtype_dims(vcode_type_t type); unsigned vtype_size(vcode_type_t type); int vtype_fields(vcode_type_t type); vcode_type_t vtype_field(vcode_type_t type, int field); vcode_type_t vtype_base(vcode_type_t type); ident_t vtype_name(vcode_type_t type); vcode_type_t vtype_real(double low, double high); vtype_repr_t vtype_repr(vcode_type_t type); int vtype_repr_bits(vtype_repr_t repr); bool vtype_repr_signed(vtype_repr_t repr); vcode_unit_t vcode_unit_next(vcode_unit_t unit); vcode_unit_t vcode_unit_child(vcode_unit_t unit); void vcode_unit_unref(vcode_unit_t unit); void vcode_walk_dependencies(vcode_unit_t vu, vcode_dep_fn_t fn, void *ctx); void vcode_opt(void); void vcode_close(void); void vcode_dump(void); void vcode_dump_with_mark(int mark_op, vcode_dump_fn_t callback, void *arg); void vcode_select_unit(vcode_unit_t vu); void vcode_select_block(vcode_block_t block); int vcode_count_blocks(void); const loc_t *vcode_last_loc(void); const char *vcode_op_string(vcode_op_t op); bool vcode_block_finished(void); bool vcode_block_empty(void); ident_t vcode_unit_name(vcode_unit_t vu); int vcode_unit_depth(vcode_unit_t vu); bool vcode_unit_has_undefined(vcode_unit_t vu); vunit_kind_t vcode_unit_kind(vcode_unit_t vu); vcode_type_t vcode_unit_result(vcode_unit_t vu); vcode_block_t vcode_active_block(void); vcode_unit_t vcode_active_unit(void); vcode_unit_t vcode_unit_context(vcode_unit_t vu); object_t *vcode_unit_object(vcode_unit_t vu); void vcode_set_result(vcode_type_t type); void vcode_state_save(vcode_state_t *state); void vcode_state_restore(const vcode_state_t *state); int vcode_count_params(void); vcode_type_t vcode_param_type(int param); ident_t vcode_param_name(int param); vcode_reg_t vcode_param_reg(int param); int vcode_count_regs(void); vcode_type_t vcode_reg_type(vcode_reg_t reg); vtype_kind_t vcode_reg_kind(vcode_reg_t reg); vcode_type_t vcode_reg_bounds(vcode_reg_t reg); bool vcode_reg_const(vcode_reg_t reg, int64_t *value); void vcode_heap_allocate(vcode_reg_t reg); int vcode_count_ops(void); vcode_op_t vcode_get_op(int op); ident_t vcode_get_func(int op); int64_t vcode_get_value(int op); double vcode_get_real(int op); vcode_cmp_t vcode_get_cmp(int op); const loc_t *vcode_get_loc(int op); vcode_block_t vcode_get_target(int op, int nth); vcode_var_t vcode_get_address(int op); ident_t vcode_get_ident(int op); object_t *vcode_get_object(int op); int vcode_count_args(int op); vcode_reg_t vcode_get_arg(int op, int arg); vcode_type_t vcode_get_type(int op); vcode_reg_t vcode_get_result(int op); unsigned vcode_get_dim(int op); int vcode_get_hops(int op); int vcode_get_field(int op); uint32_t vcode_get_tag(int op); int vcode_count_vars(void); vcode_var_t vcode_find_var(ident_t name); ident_t vcode_var_name(vcode_var_t var); vcode_type_t vcode_var_type(vcode_var_t var); vcode_type_t vcode_var_bounds(vcode_var_t var); vcode_var_flags_t vcode_var_flags(vcode_var_t var); vcode_unit_t emit_function(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_procedure(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_process(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_instance(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_package(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_protected(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_property(ident_t name, object_t *obj, vcode_unit_t context); vcode_unit_t emit_thunk(ident_t name, object_t *obj, vcode_unit_t context); vcode_block_t emit_block(void); vcode_var_t emit_var(vcode_type_t type, vcode_type_t bounds, ident_t name, vcode_var_flags_t flags); vcode_reg_t emit_alloc(vcode_type_t type, vcode_type_t bounds, vcode_reg_t count); vcode_reg_t emit_param(vcode_type_t type, vcode_type_t bounds, ident_t name); vcode_reg_t emit_const(vcode_type_t type, int64_t value); vcode_reg_t emit_const_array(vcode_type_t type, vcode_reg_t *values, int num); vcode_reg_t emit_const_rep(vcode_type_t type, vcode_reg_t value, int rep); vcode_reg_t emit_const_record(vcode_type_t type, vcode_reg_t *values, int num); vcode_reg_t emit_const_real(vcode_type_t type, double value); vcode_reg_t emit_address_of(vcode_reg_t value); vcode_reg_t emit_add(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_sub(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_mul(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_div(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_exp(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_mod(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_rem(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_trap_add(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus); vcode_reg_t emit_trap_sub(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus); vcode_reg_t emit_trap_mul(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus); vcode_reg_t emit_trap_exp(vcode_reg_t lhs, vcode_reg_t rhs, vcode_reg_t locus); void emit_assert(vcode_reg_t value, vcode_reg_t message, vcode_reg_t length, vcode_reg_t severity, vcode_reg_t locus, vcode_reg_t hint_left, vcode_reg_t hint_right); void emit_report(vcode_reg_t message, vcode_reg_t length, vcode_reg_t severity, vcode_reg_t locus); vcode_reg_t emit_cmp(vcode_cmp_t cmp, vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_fcall(ident_t func, vcode_type_t type, vcode_type_t bounds, const vcode_reg_t *args, int nargs); void emit_pcall(ident_t func, const vcode_reg_t *args, int nargs, vcode_block_t resume_bb); vcode_reg_t emit_syscall(ident_t func, vcode_type_t type, vcode_type_t bounds, vcode_reg_t locus, const vcode_reg_t *args, int nargs); void emit_wait(vcode_block_t target, vcode_reg_t time); void emit_jump(vcode_block_t target); vcode_reg_t emit_load(vcode_var_t var); vcode_reg_t emit_load_indirect(vcode_reg_t reg); void emit_store(vcode_reg_t reg, vcode_var_t var); void emit_store_indirect(vcode_reg_t reg, vcode_reg_t ptr); void emit_range_check(vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir, vcode_reg_t locus, vcode_reg_t hint); void emit_index_check(vcode_reg_t reg, vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir, vcode_reg_t locus, vcode_reg_t hint); void emit_dir_check(vcode_reg_t reg, vcode_reg_t dir, vcode_reg_t locus); vcode_reg_t emit_index(vcode_var_t var, vcode_reg_t offset); vcode_reg_t emit_cast(vcode_type_t type, vcode_reg_t bounds, vcode_reg_t reg); void emit_return(vcode_reg_t reg); void emit_sched_waveform(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t values, vcode_reg_t reject, vcode_reg_t after); void emit_force(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t values); void emit_release(vcode_reg_t nets, vcode_reg_t nnets); void emit_disconnect(vcode_reg_t nets, vcode_reg_t nnets, vcode_reg_t reject, vcode_reg_t after); void emit_cond(vcode_reg_t test, vcode_block_t btrue, vcode_block_t bfalse); vcode_reg_t emit_neg(vcode_reg_t lhs); vcode_reg_t emit_trap_neg(vcode_reg_t lhs, vcode_reg_t locus); vcode_reg_t emit_abs(vcode_reg_t lhs); void emit_comment(const char *fmt, ...) __attribute__((format(printf, 1, 2))); vcode_reg_t emit_select(vcode_reg_t test, vcode_reg_t rtrue, vcode_reg_t rfalse); vcode_reg_t emit_or(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_and(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_xor(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_xnor(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_nand(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_nor(vcode_reg_t lhs, vcode_reg_t rhs); vcode_reg_t emit_wrap(vcode_reg_t data, const vcode_dim_t *dims, int ndims); vcode_reg_t emit_uarray_left(vcode_reg_t array, unsigned dim); vcode_reg_t emit_uarray_right(vcode_reg_t array, unsigned dim); vcode_reg_t emit_uarray_dir(vcode_reg_t array, unsigned dim); vcode_reg_t emit_uarray_len(vcode_reg_t array, unsigned dim); vcode_reg_t emit_unwrap(vcode_reg_t array); vcode_reg_t emit_not(vcode_reg_t arg); vcode_reg_t emit_var_upref(int hops, vcode_var_t var); vcode_reg_t emit_init_signal(vcode_type_t type, vcode_reg_t count, vcode_reg_t size, vcode_reg_t value, vcode_reg_t flags, vcode_reg_t locus, vcode_reg_t offset); void emit_resolve_signal(vcode_reg_t signal, vcode_reg_t resolution); vcode_reg_t emit_implicit_signal(vcode_type_t type, vcode_reg_t count, vcode_reg_t size, vcode_reg_t locus, vcode_reg_t kind, vcode_reg_t closure, vcode_reg_t delay); vcode_reg_t emit_resolved(vcode_reg_t sig, vcode_reg_t count); vcode_reg_t emit_last_value(vcode_reg_t sig, vcode_reg_t count); vcode_reg_t emit_event_flag(vcode_reg_t nets, vcode_reg_t len); vcode_reg_t emit_active_flag(vcode_reg_t nets, vcode_reg_t len); vcode_reg_t emit_record_ref(vcode_reg_t record, unsigned field); vcode_reg_t emit_array_ref(vcode_reg_t array, vcode_reg_t offset); void emit_copy(vcode_reg_t dest, vcode_reg_t src, vcode_reg_t count); void emit_sched_event(vcode_reg_t nets, vcode_reg_t n_elems); void emit_clear_event(vcode_reg_t nets, vcode_reg_t count); void emit_resume(ident_t func); void emit_memset(vcode_reg_t ptr, vcode_reg_t value, vcode_reg_t len); void emit_case(vcode_reg_t value, vcode_block_t def, const vcode_reg_t *cases, const vcode_block_t *blocks, int ncases); void emit_file_open(vcode_reg_t file, vcode_reg_t name, vcode_reg_t length, vcode_reg_t kind, vcode_reg_t status); void emit_file_write(vcode_reg_t file, vcode_reg_t value, vcode_reg_t length); void emit_file_read(vcode_reg_t file, vcode_reg_t ptr, vcode_reg_t inlen, vcode_reg_t outlen); vcode_reg_t emit_null(vcode_type_t type); vcode_reg_t emit_new(vcode_type_t type, vcode_reg_t length); void emit_null_check(vcode_reg_t ptr, vcode_reg_t locus); void emit_deallocate(vcode_reg_t ptr); vcode_reg_t emit_all(vcode_reg_t reg); vcode_reg_t emit_last_event(vcode_reg_t signal, vcode_reg_t len); vcode_reg_t emit_last_active(vcode_reg_t signal, vcode_reg_t len); vcode_reg_t emit_driving_flag(vcode_reg_t signal, vcode_reg_t len); vcode_reg_t emit_driving_value(vcode_reg_t signal, vcode_reg_t len); void emit_length_check(vcode_reg_t llen, vcode_reg_t rlen, vcode_reg_t locus, vcode_reg_t dim); void emit_exponent_check(vcode_reg_t exp, vcode_reg_t locus); void emit_zero_check(vcode_reg_t denom, vcode_reg_t locus); void emit_debug_out(vcode_reg_t reg); void emit_cover_stmt(uint32_t tag); void emit_cover_branch(uint32_t tag); void emit_cover_toggle(vcode_reg_t signal, uint32_t tag); void emit_cover_state(vcode_reg_t signal, vcode_reg_t low, uint32_t tag); void emit_cover_expr(uint32_t tag); vcode_reg_t emit_undefined(vcode_type_t type, vcode_type_t bounds); void emit_debug_info(const loc_t *loc); vcode_reg_t emit_range_null(vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir); vcode_reg_t emit_range_length(vcode_reg_t left, vcode_reg_t right, vcode_reg_t dir); vcode_reg_t emit_link_var(vcode_reg_t context, ident_t name, vcode_type_t type); vcode_reg_t emit_link_package(ident_t name); void emit_map_signal(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count); void emit_map_const(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count); void emit_map_implicit(vcode_reg_t src, vcode_reg_t dst, vcode_reg_t count); void emit_drive_signal(vcode_reg_t target, vcode_reg_t count); void emit_transfer_signal(vcode_reg_t target, vcode_reg_t source, vcode_reg_t count, vcode_reg_t reject, vcode_reg_t after); vcode_reg_t emit_resolution_wrapper(vcode_type_t type, vcode_reg_t closure, vcode_reg_t nlits); vcode_reg_t emit_closure(ident_t func, vcode_reg_t context, vcode_type_t rtype); vcode_reg_t emit_protected_init(vcode_type_t type, vcode_reg_t context, vcode_reg_t path_name, vcode_reg_t inst_name); void emit_process_init(ident_t name, vcode_reg_t locus); vcode_reg_t emit_package_init(ident_t name, vcode_reg_t context); void emit_protected_free(vcode_reg_t obj); vcode_reg_t emit_context_upref(int hops); vcode_reg_t emit_debug_locus(object_t *obj); void emit_package_scope(vcode_reg_t locus); void emit_array_scope(vcode_reg_t locus, vcode_type_t type); void emit_record_scope(vcode_reg_t locus, vcode_type_t type); void emit_pop_scope(void); void emit_alias_signal(vcode_reg_t signal, vcode_reg_t locus); void emit_unreachable(vcode_reg_t locus); void emit_enter_state(vcode_reg_t state, vcode_reg_t strong); vcode_reg_t emit_reflect_value(vcode_reg_t value, vcode_reg_t context, vcode_reg_t locus, vcode_reg_t bounds); vcode_reg_t emit_reflect_subtype(vcode_reg_t context, vcode_reg_t locus, vcode_reg_t bounds); vcode_reg_t emit_function_trigger(ident_t func, const vcode_reg_t *args, int nargs); vcode_reg_t emit_or_trigger(vcode_reg_t left, vcode_reg_t right); vcode_reg_t emit_cmp_trigger(vcode_reg_t left, vcode_reg_t right); void emit_add_trigger(vcode_reg_t trigger); vcode_reg_t emit_port_conversion(vcode_reg_t driving, vcode_reg_t effective); void emit_convert_in(vcode_reg_t conv, vcode_reg_t nets, vcode_reg_t count); void emit_convert_out(vcode_reg_t conv, vcode_reg_t nets, vcode_reg_t count); void emit_bind_foreign(vcode_reg_t spec, vcode_reg_t length, vcode_reg_t locus); vcode_reg_t emit_instance_name(vcode_reg_t kind); void emit_deposit_signal(vcode_reg_t signal, vcode_reg_t count, vcode_reg_t values); vcode_reg_t emit_bind_external(vcode_reg_t locus, ident_t scope, vcode_type_t type, vcode_type_t bounds); void emit_put_conversion(vcode_reg_t cf, vcode_reg_t target, vcode_reg_t count, vcode_reg_t values); #endif // _VCODE_H nvc-r1.17.1/src/vhdl/000077500000000000000000000000001504111170000142635ustar00rootroot00000000000000nvc-r1.17.1/src/vhdl/Makefile.am000066400000000000000000000001141504111170000163130ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/vhdl/vhdl-predef.h \ src/vhdl/vhdl-predef.c nvc-r1.17.1/src/vhdl/Makemodule.am000066400000000000000000000001741504111170000166670ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/vhdl/vhdl-lower.h \ src/vhdl/vhdl-predef.c \ src/vhdl/vhdl-priv.h \ src/vhdl/vhdl-lower.c nvc-r1.17.1/src/vhdl/vhdl-lower.c000066400000000000000000000103751504111170000165200ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "mir/mir-unit.h" #include "tree.h" #include "type.h" #include "vhdl/vhdl-lower.h" #include "vhdl/vhdl-priv.h" static void fill_array_type_info(mir_unit_t *mu, type_t type, type_info_t *ti) { ti->ndims = ti->udims = dimension_of(type); for (type_t e = type_elem(type); type_is_array(e) && !type_const_bounds(e); e = type_elem(e)) ti->udims += dimension_of(e); const type_info_t *elem = type_info(mu, type_elem_recur(type)); if (type_const_bounds(type)) { ti->size = elem->size; for (int i = 0; i < ti->ndims; i++) { tree_t r = range_of(type, i); int64_t low, high; range_bounds(r, &low, &high); ti->size *= MAX(high - low + 1, 0); } ti->type = mir_carray_type(mu, ti->size, elem->type); } else ti->type = mir_uarray_type(mu, ti->ndims, elem->type); ti->stamp = elem->stamp; } const type_info_t *type_info(mir_unit_t *mu, type_t type) { type_info_t *ti = mir_get_priv(mu, type); if (ti != NULL) return ti; ti = mir_malloc(mu, sizeof(type_info_t)); ti->type = MIR_NULL_TYPE; ti->stamp = MIR_NULL_STAMP; ti->kind = type_base_kind(type); ti->ndims = 0; ti->udims = 0; ti->size = 1; switch (type_kind(type)) { case T_SUBTYPE: if (type_is_array(type)) fill_array_type_info(mu, type, ti); else { ti->type = type_info(mu, type_base(type))->type; if (type_is_integer(type) || type_is_enum(type)) { tree_t r = range_of(type, 0); int64_t low, high; if (folded_bounds(r, &low, &high)) ti->stamp = mir_int_stamp(mu, low, high); } else if (type_is_real(type)) { tree_t r = range_of(type, 0); double low, high; if (folded_bounds_real(r, &low, &high)) ti->stamp = mir_real_stamp(mu, low, high); } } break; case T_ARRAY: fill_array_type_info(mu, type, ti); break; case T_PHYSICAL: case T_INTEGER: { tree_t r = type_dim(type, 0); int64_t low, high; const bool folded = folded_bounds(r, &low, &high); if (folded) ti->type = mir_int_type(mu, low, high); else ti->type = mir_int_type(mu, INT64_MIN, INT64_MAX); } break; case T_ENUM: ti->type = mir_int_type(mu, 0, type_enum_literals(type) - 1); break; case T_RECORD: { const int nfields = type_fields(type); mir_type_t *fields = xmalloc_array(nfields, sizeof(mir_type_t)); for (int i = 0; i < nfields; i++) fields[i] = type_info(mu, tree_type(type_field(type, i)))->type; ti->type = mir_record_type(mu, type_ident(type), fields, nfields); } break; case T_PROTECTED: ti->type = mir_context_type(mu, type_ident(type)); break; case T_FILE: ti->type = mir_file_type(mu, type_info(mu, type_designated(type))->type); break; case T_ACCESS: should_not_reach_here(); case T_REAL: { tree_t r = type_dim(type, 0); double low, high; const bool folded = folded_bounds_real(r, &low, &high); if (folded) ti->type = mir_real_type(mu, low, high); else ti->type = mir_double_type(mu); } break; case T_INCOMPLETE: ti->type = mir_opaque_type(mu); break; default: fatal_trace("cannot lower type kind %s", type_kind_str(type_kind(type))); } mir_put_priv(mu, type, ti); return ti; } nvc-r1.17.1/src/vhdl/vhdl-lower.h000066400000000000000000000016141504111170000165210ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VHDL_LOWER_H #define _VHDL_LOWER_H #include "prim.h" void vhdl_lower_predef(mir_unit_t *mu, object_t *obj); void vhdl_lower_image_helper(mir_unit_t *mu, object_t *obj); #endif // _VHDL_LOWER_H nvc-r1.17.1/src/vhdl/vhdl-predef.c000066400000000000000000001105161504111170000166330ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "rt/assert.h" #include "tree.h" #include "type.h" #include "vhdl/vhdl-lower.h" #include "vhdl/vhdl-priv.h" #include #include #include typedef enum { _U = 0x0, _X = 0x1, _0 = 0x2, _1 = 0x3, _Z = 0x4, _W = 0x5, _L = 0x6, _H = 0x7, _D = 0x8 } std_ulogic_t; static mir_value_t wrap_string(mir_unit_t *mu, const char *str) { mir_value_t array = mir_const_string(mu, str); mir_value_t addr = mir_build_address_of(mu, array); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_bool = mir_bool_type(mu); mir_dim_t dims[] = { { mir_const(mu, t_offset, 1), mir_const(mu, t_offset, strlen(str)), mir_const(mu, t_bool, RANGE_TO) }, }; return mir_build_wrap(mu, addr, dims, 1); } static void predef_bit_shift(mir_unit_t *mu, tree_t decl, subprogram_kind_t kind) { type_t type = tree_type(tree_port(decl, 0)); const type_info_t *elem = type_info(mu, type_elem(type)); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_bool = mir_bool_type(mu); mir_value_t input = mir_get_param(mu, 1); mir_value_t shift = mir_get_param(mu, 2); mir_value_t data = mir_build_unwrap(mu, input); mir_value_t len = mir_build_uarray_len(mu, input, 0); mir_block_t null_bb = mir_add_block(mu); mir_block_t non_null_bb = mir_add_block(mu); mir_value_t zero = mir_const(mu, t_offset, 0); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t is_null = mir_build_cmp(mu, MIR_CMP_EQ, len, zero); mir_build_cond(mu, is_null, null_bb, non_null_bb); mir_set_cursor(mu, null_bb, MIR_APPEND); mir_build_return(mu, input); mir_set_cursor(mu, non_null_bb, MIR_APPEND); mir_value_t mem = mir_build_alloc(mu, elem->type, elem->stamp, len); mir_value_t i_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("i"), MIR_VAR_TEMP); mir_build_store(mu, i_var, zero); mir_block_t cmp_bb = mir_add_block(mu); mir_block_t body_bb = mir_add_block(mu); mir_block_t exit_bb = mir_add_block(mu); mir_value_t def_val = MIR_NULL_VALUE; switch (kind) { case S_SLL: case S_SRL: case S_ROL: case S_ROR: def_val = zero; break; case S_SRA: { mir_value_t len_minus_1 = mir_build_sub(mu, t_offset, len, one); mir_value_t last_ptr = mir_build_array_ref(mu, data, len_minus_1); def_val = mir_build_load(mu, last_ptr); } break; case S_SLA: def_val = mir_build_load(mu, data); break; default: should_not_reach_here(); } mir_value_t shift_cast = mir_build_cast(mu, t_offset, shift); mir_value_t shift_is_neg = mir_build_cmp(mu, MIR_CMP_LT, shift_cast, zero); mir_build_jump(mu, cmp_bb); mir_set_cursor(mu, cmp_bb, MIR_APPEND); mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t eq = mir_build_cmp(mu, MIR_CMP_EQ, i_val, len); mir_build_cond(mu, eq, exit_bb, body_bb); mir_set_cursor(mu, body_bb, MIR_APPEND); mir_value_t cmp = MIR_NULL_VALUE; switch (kind) { case S_SRL: case S_SRA: { mir_value_t len_plus_shift = mir_build_add(mu, t_offset, len, shift_cast); mir_value_t neg = mir_build_cmp(mu, MIR_CMP_LT, i_val, len_plus_shift); mir_value_t pos = mir_build_cmp(mu, MIR_CMP_GEQ, i_val, shift_cast); cmp = mir_build_select(mu, t_bool, shift_is_neg, neg, pos); } break; case S_SLL: case S_SLA: { mir_value_t neg_shift = mir_build_neg(mu, t_offset, shift_cast); mir_value_t len_minus_shift = mir_build_sub(mu, t_offset, len, shift_cast); mir_value_t neg = mir_build_cmp(mu, MIR_CMP_GEQ, i_val, neg_shift); mir_value_t pos = mir_build_cmp(mu, MIR_CMP_LT, i_val, len_minus_shift); cmp = mir_build_select(mu, t_bool, shift_is_neg, neg, pos); } break; case S_ROL: case S_ROR: cmp = mir_const(mu, t_bool, 1); break; default: should_not_reach_here(); } mir_value_t dst_ptr = mir_build_array_ref(mu, mem, i_val); mir_value_t next = mir_build_add(mu, t_offset, i_val, one); mir_build_store(mu, i_var, next); mir_block_t true_bb = mir_add_block(mu); mir_block_t false_bb = mir_add_block(mu); mir_build_cond(mu, cmp, true_bb, false_bb); mir_set_cursor(mu, true_bb, MIR_APPEND); mir_value_t src_idx = MIR_NULL_VALUE; switch (kind) { case S_SLL: case S_SLA: src_idx = mir_build_add(mu, t_offset, i_val, shift_cast); break; case S_SRL: case S_SRA: src_idx = mir_build_sub(mu, t_offset, i_val, shift_cast); break; case S_ROL: { mir_value_t len_plus_shift = mir_build_add(mu, t_offset, len, shift_cast); mir_value_t idx = mir_build_add(mu, t_offset, i_val, len_plus_shift); src_idx = mir_build_mod(mu, t_offset, idx, len); } break; case S_ROR: { mir_value_t len_minus_shift = mir_build_sub(mu, t_offset, len, shift_cast); mir_value_t idx = mir_build_add(mu, t_offset, i_val, len_minus_shift); src_idx = mir_build_mod(mu, t_offset, idx, len); } break; default: should_not_reach_here(); } mir_value_t src_ptr = mir_build_array_ref(mu, data, src_idx); mir_value_t src_val = mir_build_load(mu, src_ptr); mir_build_store(mu, dst_ptr, src_val); mir_build_jump(mu, cmp_bb); mir_set_cursor(mu, false_bb, MIR_APPEND); mir_build_store(mu, dst_ptr, def_val); mir_build_jump(mu, cmp_bb); mir_set_cursor(mu, exit_bb, MIR_APPEND); mir_value_t left = mir_build_uarray_left(mu, input, 0); mir_value_t right = mir_build_uarray_right(mu, input, 0); mir_value_t dir = mir_build_uarray_dir(mu, input, 0); mir_dim_t dims[] = { { left, right, dir } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } static void predef_match_op(mir_unit_t *mu, tree_t decl, subprogram_kind_t kind) { type_t type = tree_type(tree_port(decl, 0)); mir_cmp_t cmp; bool invert = false; switch (kind) { case S_MATCH_NEQ: invert = true; case S_MATCH_EQ: cmp = MIR_CMP_EQ; break; case S_MATCH_GE: invert = true; case S_MATCH_LT: cmp = MIR_CMP_LT; break; case S_MATCH_GT: invert = true; case S_MATCH_LE: cmp = MIR_CMP_LEQ; break; default: should_not_reach_here(); } bool is_array = false, is_bit = false; if (type_is_array(type)) { is_array = true; is_bit = type_ident(type_elem(type)) == well_known(W_STD_BIT); } else is_bit = type_ident(type) == well_known(W_STD_BIT); mir_value_t left = mir_get_param(mu, 1); mir_value_t right = mir_get_param(mu, 2); mir_value_t result = MIR_NULL_VALUE; if (is_array) { assert(kind == S_MATCH_EQ || kind == S_MATCH_NEQ); mir_value_t left_len = mir_build_uarray_len(mu, left, 0); mir_value_t right_len = mir_build_uarray_len(mu, right, 0); mir_block_t fail_bb = mir_add_block(mu); mir_block_t cont_bb = mir_add_block(mu); mir_value_t len_eq = mir_build_cmp(mu, MIR_CMP_EQ, left_len, right_len); mir_build_cond(mu, len_eq, cont_bb, fail_bb); mir_set_cursor(mu, fail_bb, MIR_APPEND); mir_type_t t_severity = mir_int_type(mu, 0, SEVERITY_FAILURE - 1); mir_value_t failure = mir_const(mu, t_severity, SEVERITY_FAILURE); mir_type_t t_offset = mir_offset_type(mu); static const char msg[] = "arguments have different lengths"; mir_value_t msg_buf = mir_const_string(mu, msg); mir_value_t msg_ptr = mir_build_address_of(mu, msg_buf); mir_value_t msg_len = mir_const(mu, t_offset, sizeof(msg) - 1); mir_value_t locus = mir_build_locus(mu, tree_to_object(decl)); mir_build_report(mu, msg_ptr, msg_len, failure, locus); mir_build_jump(mu, cont_bb); mir_set_cursor(mu, cont_bb, MIR_APPEND); const type_info_t *ti = type_info(mu, type_elem(type)); mir_value_t mem = mir_build_alloc(mu, ti->type, ti->stamp, left_len); mir_value_t result_var = mir_add_var(mu, ti->type, ti->stamp, ident_new("result"), MIR_VAR_TEMP); mir_build_store(mu, result_var, mir_const(mu, ti->type, 0)); mir_value_t i_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("i"), MIR_VAR_TEMP); mir_value_t zero = mir_const(mu, t_offset, 0); mir_build_store(mu, i_var, zero); mir_value_t null = mir_build_cmp(mu, MIR_CMP_EQ, left_len, zero); mir_value_t left_ptr = mir_build_unwrap(mu, left); mir_value_t right_ptr = mir_build_unwrap(mu, right); mir_block_t body_bb = mir_add_block(mu); mir_block_t exit_bb = mir_add_block(mu); mir_build_cond(mu, null, exit_bb, body_bb); mir_set_cursor(mu, body_bb, MIR_APPEND); mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t left_ptr_i = mir_build_array_ref(mu, left_ptr, i_val); mir_value_t right_ptr_i = mir_build_array_ref(mu, right_ptr, i_val); mir_value_t left_src = mir_build_load(mu, left_ptr_i); mir_value_t right_src = mir_build_load(mu, right_ptr_i); mir_value_t tmp; if (is_bit) tmp = mir_build_cmp(mu, cmp, left_src, right_src); else { ident_t func = ident_new( "IEEE.STD_LOGIC_1164.\"?=\"(UU)U$predef"); mir_value_t context = mir_build_link_package(mu, well_known(W_IEEE_1164)); mir_value_t args[] = { context, left_src, right_src }; tmp = mir_build_fcall(mu, func, ti->type, ti->stamp, args, 3); } mir_build_store(mu, mir_build_array_ref(mu, mem, i_val), tmp); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t next = mir_build_add(mu, t_offset, i_val, one); mir_value_t finished = mir_build_cmp(mu, MIR_CMP_EQ, next, left_len); mir_build_store(mu, i_var, next); mir_build_cond(mu, finished, exit_bb, body_bb); mir_set_cursor(mu, exit_bb, MIR_APPEND); mir_dim_t dims[1] = { { .left = mir_build_uarray_left(mu, left, 0), .right = mir_build_uarray_right(mu, left, 0), .dir = mir_build_uarray_dir(mu, left, 0), } }; mir_value_t wrap = mir_build_wrap(mu, mem, dims, 1); ident_t func, context_name; if (is_bit) { func = ident_new("STD.STANDARD.\"and\"(Q)J$predef"); context_name = well_known(W_STD_STANDARD); } else { func = ident_new("IEEE.STD_LOGIC_1164.\"and\"(Y)U"); context_name = well_known(W_IEEE_1164); } mir_value_t context = mir_build_link_package(mu, context_name); mir_value_t args[] = { context, wrap }; result = mir_build_fcall(mu, func, ti->type, ti->stamp, args, 2); } else if (is_bit) result = mir_build_cmp(mu, cmp, left, right); else if (cmp == MIR_CMP_LEQ) { ident_t less_func = ident_new("IEEE.STD_LOGIC_1164.\"?<\"(UU)U$predef"); ident_t eq_func = ident_new("IEEE.STD_LOGIC_1164.\"?=\"(UU)U$predef"); mir_value_t context = mir_build_link_package(mu, well_known(W_IEEE_1164)); mir_value_t args1[] = { context, left, right }; const type_info_t *ti = type_info(mu, type); mir_value_t eq = mir_build_fcall(mu, eq_func, ti->type, ti->stamp, args1, 3); mir_value_t less = mir_build_fcall(mu, less_func, ti->type, ti->stamp, args1, 3); ident_t or_func = ident_new("IEEE.STD_LOGIC_1164.\"or\"(UU)24IEEE.STD_LOGIC_1164.UX01"); mir_value_t args2[] = { context, eq, less }; result = mir_build_fcall(mu, or_func, ti->type, ti->stamp, args2, 3); } else { static const std_ulogic_t match_eq_table[9][9] = { { _U, _U, _U, _U, _U, _U, _U, _U, _1 }, { _U, _X, _X, _X, _X, _X, _X, _X, _1 }, { _U, _X, _1, _0, _X, _X, _1, _0, _1 }, { _U, _X, _0, _1, _X, _X, _0, _1, _1 }, { _U, _X, _X, _X, _X, _X, _X, _X, _1 }, { _U, _X, _X, _X, _X, _X, _X, _X, _1 }, { _U, _X, _1, _0, _X, _X, _1, _0, _1 }, { _U, _X, _0, _1, _X, _X, _0, _1, _1 }, { _1, _1, _1, _1, _1, _1, _1, _1, _1 } }; static const std_ulogic_t match_lt_table[9][9] = { { _U, _U, _U, _U, _U, _U, _U, _U, _X }, { _U, _X, _X, _X, _X, _X, _X, _X, _X }, { _U, _X, _0, _1, _X, _X, _0, _1, _X }, { _U, _X, _0, _0, _X, _X, _0, _0, _X }, { _U, _X, _X, _X, _X, _X, _X, _X, _X }, { _U, _X, _X, _X, _X, _X, _X, _X, _X }, { _U, _X, _0, _1, _X, _X, _0, _1, _X }, { _U, _X, _0, _0, _X, _X, _0, _0, _X }, { _X, _X, _X, _X, _X, _X, _X, _X, _X } }; const std_ulogic_t (*table)[9] = cmp == MIR_CMP_LT ? match_lt_table : match_eq_table; const type_info_t *ti = type_info(mu, type); mir_type_t t_table = mir_carray_type(mu, 9*9, ti->type); mir_value_t elems[9 * 9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) elems[i*9 + j] = mir_const(mu, ti->type, table[i][j]); } mir_value_t table_buf = mir_const_array(mu, t_table, elems, 9*9); mir_value_t table_ptr = mir_build_address_of(mu, table_buf); mir_type_t t_offset = mir_offset_type(mu); if (cmp == MIR_CMP_LT) { mir_value_t dontcare = mir_const(mu, ti->type, _D); mir_value_t lcmp = mir_build_cmp(mu, MIR_CMP_NEQ, left, dontcare); mir_value_t rcmp = mir_build_cmp(mu, MIR_CMP_NEQ, right, dontcare); mir_value_t and = mir_build_and(mu, lcmp, rcmp); const char *msg = "STD_LOGIC_1164: '-' operand for matching ordering operator"; mir_value_t msg_buf = mir_const_string(mu, msg); mir_value_t msg_ptr = mir_build_address_of(mu, msg_buf); mir_value_t msg_len = mir_const(mu, t_offset, sizeof(msg) - 1); mir_type_t t_severity = mir_int_type(mu, 0, SEVERITY_FAILURE - 1); mir_value_t error = mir_const(mu, t_severity, SEVERITY_ERROR); mir_value_t locus = mir_build_locus(mu, tree_to_object(decl)); mir_build_assert(mu, and, msg_ptr, msg_len, error, locus, MIR_NULL_VALUE, MIR_NULL_VALUE); } mir_value_t l_off = mir_build_cast(mu, t_offset, left); mir_value_t r_off = mir_build_cast(mu, t_offset, right); mir_value_t nine = mir_const(mu, t_offset, 9); mir_value_t index = mir_build_add(mu, t_offset, mir_build_mul(mu, t_offset, l_off, nine), r_off); mir_value_t ptr = mir_build_array_ref(mu, table_ptr, index); result = mir_build_load(mu, ptr); } if (invert && is_bit) mir_build_return(mu, mir_build_not(mu, result)); else if (invert) { const type_info_t *ti = type_info(mu, type_result(tree_type(decl))); ident_t func = ident_new( "IEEE.STD_LOGIC_1164.\"not\"(U)24IEEE.STD_LOGIC_1164.UX01"); mir_value_t context = mir_build_link_package(mu, well_known(W_IEEE_1164)); mir_value_t args[2] = { context, result }; mir_value_t call = mir_build_fcall(mu, func, ti->type, ti->stamp, args, 2); mir_build_return(mu, call); } else mir_build_return(mu, result); } static void predef_bit_vec_op(mir_unit_t *mu, tree_t decl, subprogram_kind_t kind) { type_t type = tree_type(tree_port(decl, 0)); type_t elem = type_elem(type); const type_info_t *ti = type_info(mu, elem); mir_type_t t_offset = mir_offset_type(mu); mir_value_t left = mir_get_param(mu, 1), right = MIR_NULL_VALUE; if (kind != S_ARRAY_NOT) right = mir_get_param(mu, 2); mir_value_t left_len = mir_build_uarray_len(mu, left, 0); mir_value_t right_len = MIR_NULL_VALUE; mir_value_t left_data = mir_build_unwrap(mu, left); mir_value_t right_data = MIR_NULL_VALUE; if (kind != S_ARRAY_NOT) { right_len = mir_build_uarray_len(mu, right, 0); right_data = mir_build_unwrap(mu, right); mir_block_t fail_bb = mir_add_block(mu); mir_block_t cont_bb = mir_add_block(mu); mir_value_t len_eq = mir_build_cmp(mu, MIR_CMP_EQ, left_len, right_len); mir_build_cond(mu, len_eq, cont_bb, fail_bb); mir_set_cursor(mu, fail_bb, MIR_APPEND); mir_type_t t_severity = mir_int_type(mu, 0, SEVERITY_FAILURE - 1); mir_value_t failure = mir_const(mu, t_severity, SEVERITY_FAILURE); static const char msg_str[] = "arguments have different lengths"; mir_value_t msg_array = mir_const_string(mu, msg_str); mir_value_t msg_ptr = mir_build_address_of(mu, msg_array); mir_value_t msg_len = mir_const(mu, t_offset, sizeof(msg_str) - 1); mir_value_t locus = mir_build_locus(mu, tree_to_object(decl)); mir_build_report(mu, msg_ptr, msg_len, failure, locus); mir_build_return(mu, left); mir_set_cursor(mu, cont_bb, MIR_APPEND); } mir_value_t mem = mir_build_alloc(mu, ti->type, ti->stamp, left_len); mir_value_t i_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("i"), MIR_VAR_TEMP); mir_build_store(mu, i_var, mir_const(mu, t_offset, 0)); mir_block_t cmp_bb = mir_add_block(mu); mir_block_t body_bb = mir_add_block(mu); mir_block_t exit_bb = mir_add_block(mu); mir_build_jump(mu, cmp_bb); mir_set_cursor(mu, cmp_bb, MIR_APPEND); mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t eq = mir_build_cmp(mu, MIR_CMP_EQ, i_val, left_len); mir_build_cond(mu, eq, exit_bb, body_bb); mir_set_cursor(mu, body_bb, MIR_APPEND); mir_value_t dst_ptr = mir_build_array_ref(mu, mem, i_val); mir_value_t src0_ptr = mir_build_array_ref(mu, left_data, i_val); mir_value_t src0 = mir_build_load(mu, src0_ptr); mir_value_t src1 = MIR_NULL_VALUE; if (kind != S_ARRAY_NOT) { mir_value_t src1_ptr = mir_build_array_ref(mu, right_data, i_val); src1 = mir_build_load(mu, src1_ptr); } bool negate = false; mir_value_t op; switch (kind) { case S_ARRAY_NOT: op = mir_build_not(mu, src0); break; case S_ARRAY_NAND: negate = true; case S_ARRAY_AND: op = mir_build_and(mu, src0, src1); break; case S_ARRAY_NOR: negate = true; case S_ARRAY_OR: op = mir_build_or(mu, src0, src1); break; case S_ARRAY_XNOR: negate = true; case S_ARRAY_XOR: op = mir_build_xor(mu, src0, src1); break; default: should_not_reach_here(); } if (negate) op = mir_build_not(mu, op); mir_build_store(mu, dst_ptr, op); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t next = mir_build_add(mu, t_offset, i_val, one); mir_build_store(mu, i_var, next); mir_build_jump(mu, cmp_bb); mir_set_cursor(mu, exit_bb, MIR_APPEND); mir_value_t b_left = mir_build_uarray_left(mu, left, 0); mir_value_t b_right = mir_build_uarray_right(mu, left, 0); mir_value_t b_dir = mir_build_uarray_dir(mu, left, 0); mir_dim_t dims[] = { { b_left, b_right, b_dir } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } static void predef_edge_op(mir_unit_t *mu, tree_t decl) { mir_type_t t_offset = mir_offset_type(mu); mir_value_t nets = mir_get_param(mu, 1); mir_value_t count = mir_const(mu, t_offset, 1); mir_value_t value = mir_build_load(mu, mir_build_resolved(mu, nets)); if (tree_subkind(decl) == S_FALLING_EDGE) value = mir_build_not(mu, value); mir_value_t event = mir_build_event_flag(mu, nets, count); mir_build_return(mu, mir_build_and(mu, event, value)); } void vhdl_lower_predef(mir_unit_t *mu, object_t *obj) { tree_t decl = tree_from_object(obj); // XXX: should not have null parent mir_type_t t_parent = mir_context_type(mu, ident_new("dummy")); mir_add_param(mu, t_parent, MIR_NULL_STAMP, ident_new("context")); const int nports = tree_ports(decl); for (int i = 0; i < nports; i++) { tree_t p = tree_port(decl, i); assert(tree_subkind(p) == PORT_IN); const type_info_t *ti = type_info(mu, tree_type(p)); mir_type_t type = ti->type; if (tree_class(p) == C_SIGNAL) type = mir_signal_type(mu, type); mir_add_param(mu, type, ti->stamp, tree_ident(p)); } const type_info_t *ti = type_info(mu, type_result(tree_type(decl))); mir_set_result(mu, ti->type); const subprogram_kind_t kind = tree_subkind(decl); assert(kind != S_USER); assert(!is_open_coded_builtin(kind)); switch (kind) { case S_SLL: case S_SRL: case S_SLA: case S_SRA: case S_ROL: case S_ROR: predef_bit_shift(mu, decl, kind); break; case S_MATCH_EQ: case S_MATCH_NEQ: case S_MATCH_LT: case S_MATCH_LE: case S_MATCH_GT: case S_MATCH_GE: predef_match_op(mu, decl, kind); break; case S_ARRAY_NOT: case S_ARRAY_AND: case S_ARRAY_OR: case S_ARRAY_XOR: case S_ARRAY_XNOR: case S_ARRAY_NAND: case S_ARRAY_NOR: predef_bit_vec_op(mu, decl, kind); break; case S_RISING_EDGE: case S_FALLING_EDGE: return predef_edge_op(mu, decl); default: should_not_reach_here(); } } static void enum_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg) { const int nlits = type_enum_literals(type); assert(nlits >= 1); mir_block_t *blocks LOCAL = xmalloc_array(nlits, sizeof(mir_block_t)); mir_value_t *cases LOCAL = xmalloc_array(nlits, sizeof(mir_value_t)); const type_info_t *ti = type_info(mu, type); for (int i = 0; i < nlits; i++) { cases[i] = mir_const(mu, ti->type, i); blocks[i] = mir_add_block(mu); } mir_build_case(mu, arg, blocks[0], cases, blocks, nlits); for (int i = 0; i < nlits; i++) { // LRM specifies result is lowercase for enumerated types when // the value is a basic identifier ident_t id = tree_ident(type_enum_literal(type, i)); if (ident_char(id, 0) != '\'') id = ident_downcase(id); mir_set_cursor(mu, blocks[i], MIR_APPEND); mir_value_t str = wrap_string(mu, istr(id)); mir_build_return(mu, str); } } static void numeric_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg) { ident_t conv_fn; mir_value_t cast; if (type_is_real(type)) { cast = arg; conv_fn = ident_new("NVC.TEXT_UTIL.REAL_TO_STRING(R)S"); } else { mir_type_t t_int64 = mir_int_type(mu, INT64_MIN, INT64_MAX); cast = mir_build_cast(mu, t_int64, arg); conv_fn = ident_new( "NVC.TEXT_UTIL.INT_TO_STRING(21NVC.TEXT_UTIL.T_INT64)S"); } mir_type_t t_string = mir_string_type(mu); mir_value_t text_util = mir_build_link_package(mu, well_known(W_TEXT_UTIL)); mir_value_t conv_args[] = { text_util, cast }; mir_value_t str = mir_build_fcall(mu, conv_fn, t_string, MIR_NULL_STAMP, conv_args, 2); mir_build_return(mu, str); } static void physical_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg) { mir_type_t t_int64 = mir_int_type(mu, INT64_MIN, INT64_MAX); mir_type_t t_string = mir_string_type(mu); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_char = mir_char_type(mu); mir_type_t t_bool = mir_bool_type(mu); mir_value_t cast = mir_build_cast(mu, t_int64, arg); ident_t conv_fn = ident_new("NVC.TEXT_UTIL.INT_TO_STRING(21NVC.TEXT_UTIL.T_INT64)S"); mir_value_t text_util = mir_build_link_package(mu, well_known(W_TEXT_UTIL)); mir_value_t conv_args[] = { text_util, cast }; mir_value_t num_str = mir_build_fcall(mu, conv_fn, t_string, MIR_NULL_STAMP, conv_args, 2); mir_value_t num_len = mir_build_uarray_len(mu, num_str, 0); const char *unit0 = istr(ident_downcase(tree_ident(type_unit(type, 0)))); mir_value_t append_len = mir_const(mu, t_offset, strlen(unit0) + 1); mir_value_t total_len = mir_build_add(mu, t_offset, num_len, append_len); mir_value_t mem = mir_build_alloc(mu, t_char, MIR_NULL_STAMP, total_len); mir_build_copy(mu, mem, mir_build_unwrap(mu, num_str), num_len); mir_value_t ptr0 = mir_build_array_ref(mu, mem, num_len); mir_build_store(mu, ptr0, mir_const(mu, t_char, ' ')); mir_value_t unit = wrap_string(mu, unit0); mir_value_t ptr1 = mir_build_array_ref(mu, ptr0, mir_const(mu, t_offset, 1)); mir_build_copy(mu, ptr1, mir_build_unwrap(mu, unit), mir_const(mu, t_offset, strlen(unit0))); mir_dim_t dims[] = { { .left = mir_const(mu, t_offset, 1), .right = total_len, .dir = mir_const(mu, t_bool, RANGE_TO), } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } static void record_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg) { const int nfields = type_fields(type); mir_value_t regs[nfields]; mir_value_t lengths[nfields]; mir_type_t t_string = mir_string_type(mu); mir_type_t t_char = mir_char_type(mu); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_bool = mir_bool_type(mu); mir_value_t sum = mir_const(mu, t_offset, nfields + 1); mir_type_t t_dummy = mir_context_type(mu, ident_new("dummy")); mir_value_t context_reg = mir_build_null(mu, t_dummy); for (int i = 0; i < nfields; i++) { type_t ftype = type_base_recur(tree_type(type_field(type, i))); ident_t func = ident_prefix(type_ident(ftype), ident_new("image"), '$'); mir_value_t field = mir_build_record_ref(mu, arg, i); if (type_is_scalar(ftype) || mir_points_to(mu, field, MIR_TYPE_UARRAY)) field = mir_build_load(mu, field); mir_value_t args[] = { context_reg, field }; regs[i] = mir_build_fcall(mu, func, t_string, MIR_NULL_STAMP, args, 2); lengths[i] = mir_build_uarray_len(mu, regs[i], 0); sum = mir_build_add(mu, t_offset, sum, lengths[i]); } mir_value_t mem = mir_build_alloc(mu, t_char, MIR_NULL_STAMP, sum); mir_value_t zero = mir_const(mu, t_offset, 0); mir_value_t lparen_ptr = mir_build_array_ref(mu, mem, zero); mir_build_store(mu, lparen_ptr, mir_const(mu, t_char, '(')); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t comma = mir_const(mu, t_char, ','); mir_value_t index = one; for (int i = 0; i < nfields; i++) { if (i > 0) { mir_value_t comma_ptr = mir_build_array_ref(mu, mem, index); mir_build_store(mu, comma_ptr, comma); index = mir_build_add(mu, t_offset, index, one); } mir_value_t src_ptr = mir_build_unwrap(mu, regs[i]); mir_value_t dest_ptr = mir_build_array_ref(mu, mem, index); mir_build_copy(mu, dest_ptr, src_ptr, lengths[i]); index = mir_build_add(mu, t_offset, index, lengths[i]); } mir_value_t rparen_ptr = mir_build_array_ref(mu, mem, index); mir_build_store(mu, rparen_ptr, mir_const(mu, t_char, ')')); mir_dim_t dims[] = { { .left = one, .right = sum, .dir = mir_const(mu, t_bool, RANGE_TO) } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } static void array_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg) { mir_type_t t_char = mir_char_type(mu); mir_type_t t_string = mir_string_type(mu); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_bool = mir_bool_type(mu); mir_type_t fields[] = { mir_pointer_type(mu, t_char), t_offset }; mir_type_t t_rec = mir_record_type(mu, ident_new("elem"), fields, 2); mir_value_t length = mir_build_uarray_len(mu, arg, 0); mir_value_t elems_mem = mir_build_alloc(mu, t_rec, MIR_NULL_STAMP, length); mir_value_t zero = mir_const(mu, t_offset, 0); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t data_ptr = mir_build_unwrap(mu, arg); mir_value_t i_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("i"), MIR_VAR_TEMP); mir_build_store(mu, i_var, zero); mir_block_t loop1_bb = mir_add_block(mu); mir_block_t alloc_bb = mir_add_block(mu); mir_value_t sum_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("sum"), MIR_VAR_TEMP); mir_build_store(mu, sum_var, mir_build_add(mu, t_offset, length, one)); type_t elem = type_base_recur(type_elem(type)); ident_t func = ident_prefix(type_ident(elem), ident_new("image"), '$'); mir_type_t t_dummy = mir_context_type(mu, ident_new("dummy")); mir_value_t context = mir_build_null(mu, t_dummy); mir_value_t null = mir_build_cmp(mu, MIR_CMP_EQ, length, zero); mir_build_cond(mu, null, alloc_bb, loop1_bb); mir_set_cursor(mu, loop1_bb, MIR_APPEND); { mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t sum_val = mir_build_load(mu, sum_var); mir_value_t elem_arg = mir_build_array_ref(mu, data_ptr, i_val); if (type_is_scalar(elem)) elem_arg = mir_build_load(mu, elem_arg); mir_value_t args[] = { context, elem_arg }; mir_value_t str = mir_build_fcall(mu, func, t_string, MIR_NULL_STAMP, args, 2); mir_value_t edata_ptr = mir_build_unwrap(mu, str); mir_value_t elen = mir_build_uarray_len(mu, str, 0); mir_build_store(mu, sum_var, mir_build_add(mu, t_offset, sum_val, elen)); mir_value_t rptr = mir_build_array_ref(mu, elems_mem, i_val); mir_build_store(mu, mir_build_record_ref(mu, rptr, 0), edata_ptr); mir_build_store(mu, mir_build_record_ref(mu, rptr, 1), elen); mir_value_t i_next = mir_build_add(mu, t_offset, i_val, one); mir_build_store(mu, i_var, i_next); mir_value_t done = mir_build_cmp(mu, MIR_CMP_EQ, i_next, length); mir_build_cond(mu, done, alloc_bb, loop1_bb); } mir_set_cursor(mu, alloc_bb, MIR_APPEND); mir_value_t sum_val = mir_build_load(mu, sum_var); mir_value_t mem = mir_build_alloc(mu, t_char, MIR_NULL_STAMP, sum_val); mir_value_t lparen_ptr = mir_build_array_ref(mu, mem, zero); mir_build_store(mu, lparen_ptr, mir_const(mu, t_char, '(')); mir_block_t loop2_bb = mir_add_block(mu); mir_block_t exit_bb = mir_add_block(mu); mir_value_t index_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("index"), MIR_VAR_TEMP); mir_build_store(mu, i_var, zero); mir_build_store(mu, index_var, one); mir_build_cond(mu, null, exit_bb, loop2_bb); mir_set_cursor(mu, loop2_bb, MIR_APPEND); { mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t index = mir_build_load(mu, index_var); mir_value_t rptr = mir_build_array_ref(mu, elems_mem, i_val); mir_value_t edata = mir_build_load(mu, mir_build_record_ref(mu, rptr, 0)); mir_value_t elen = mir_build_load(mu, mir_build_record_ref(mu, rptr, 1)); mir_value_t dest_ptr = mir_build_array_ref(mu, mem, index); mir_build_copy(mu, dest_ptr, edata, elen); mir_value_t comma_index = mir_build_add(mu, t_offset, index, elen); mir_value_t comma_ptr = mir_build_array_ref(mu, mem, comma_index); mir_build_store(mu, comma_ptr, mir_const(mu, t_char, ',')); mir_value_t index_next = mir_build_add(mu, t_offset, comma_index, one); mir_build_store(mu, index_var, index_next); mir_value_t i_next = mir_build_add(mu, t_offset, i_val, one); mir_build_store(mu, i_var, i_next); mir_value_t done = mir_build_cmp(mu, MIR_CMP_EQ, i_next, length); mir_build_cond(mu, done, exit_bb, loop2_bb); } mir_set_cursor(mu, exit_bb, MIR_APPEND); mir_value_t last = mir_build_sub(mu, t_offset, sum_val, one); mir_value_t rparen_ptr = mir_build_array_ref(mu, mem, last); mir_build_store(mu, rparen_ptr, mir_const(mu, t_char, ')')); mir_dim_t dims[] = { { .left = mir_const(mu, t_offset, 1), .right = sum_val, .dir = mir_const(mu, t_bool, RANGE_TO), } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } static void character_array_image_helper(mir_unit_t *mu, type_t type, mir_value_t arg, bool quote) { type_t elem = type_base_recur(type_elem(type)); mir_type_t t_char = mir_char_type(mu); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_bool = mir_bool_type(mu); const int nlits = type_enum_literals(elem); mir_value_t *map LOCAL = xmalloc_array(nlits, sizeof(mir_value_t)); for (int i = 0; i < nlits; i++) { const ident_t id = tree_ident(type_enum_literal(elem, i)); assert(ident_char(id, 0) == '\''); map[i] = mir_const(mu, t_char, ident_char(id, 1)); } mir_type_t t_map = mir_carray_type(mu, nlits, t_char); mir_value_t map_array = mir_const_array(mu, t_map, map, nlits); mir_value_t zero = mir_const(mu, t_offset, 0); mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t two = mir_const(mu, t_offset, 2); mir_value_t length = mir_build_uarray_len(mu, arg, 0); mir_value_t data_ptr = mir_build_unwrap(mu, arg); mir_value_t total = length; if (quote) total = mir_build_add(mu, t_offset, length, two); mir_value_t mem = mir_build_alloc(mu, t_char, MIR_NULL_STAMP, total); mir_value_t i_var = mir_add_var(mu, t_offset, MIR_NULL_STAMP, ident_new("i"), MIR_VAR_TEMP); mir_build_store(mu, i_var, zero); if (quote) { mir_value_t lquote_ptr = mir_build_array_ref(mu, mem, zero); mir_build_store(mu, lquote_ptr, mir_const(mu, t_char, '"')); } mir_value_t null_reg = mir_build_cmp(mu, MIR_CMP_EQ, length, zero); mir_block_t body_bb = mir_add_block(mu); mir_block_t exit_bb = mir_add_block(mu); mir_build_cond(mu, null_reg, exit_bb, body_bb); mir_set_cursor(mu, body_bb, MIR_APPEND); mir_value_t i_val = mir_build_load(mu, i_var); mir_value_t sptr = mir_build_array_ref(mu, data_ptr, i_val); mir_value_t src = mir_build_load(mu, sptr); mir_value_t off = mir_build_cast(mu, t_offset, src); mir_value_t map_ptr = mir_build_address_of(mu, map_array); mir_value_t lptr = mir_build_array_ref(mu, map_ptr, off); mir_value_t doff = i_val; if (quote) doff = mir_build_add(mu, t_offset, doff, one); mir_value_t dptr = mir_build_array_ref(mu, mem, doff); mir_build_store(mu, dptr, mir_build_load(mu, lptr)); mir_value_t next = mir_build_add(mu, t_offset, i_val, one); mir_value_t cmp = mir_build_cmp(mu, MIR_CMP_EQ, next, length); mir_build_store(mu, i_var, next); mir_build_cond(mu, cmp, exit_bb, body_bb); mir_set_cursor(mu, exit_bb, MIR_APPEND); if (quote) { mir_value_t right = mir_build_add(mu, t_offset, length, one); mir_value_t rquote_ptr = mir_build_array_ref(mu, mem, right); mir_build_store(mu, rquote_ptr, mir_const(mu, t_char, '"')); } mir_dim_t dims[] = { { .left = one, .right = total, .dir = mir_const(mu, t_bool, RANGE_TO) } }; mir_build_return(mu, mir_build_wrap(mu, mem, dims, 1)); } void vhdl_lower_image_helper(mir_unit_t *mu, object_t *obj) { tree_t decl = tree_from_object(obj); type_t type = type_base_recur(tree_type(decl)); assert(type_is_representable(type)); mir_set_result(mu, mir_string_type(mu)); mir_type_t t_parent = mir_context_type(mu, mir_get_parent(mu)); mir_add_param(mu, t_parent, MIR_NULL_STAMP, ident_new("context")); const type_info_t *ti = type_info(mu, type); mir_type_t t_param = ti->kind == T_RECORD ? mir_pointer_type(mu, ti->type) : ti->type; mir_value_t arg = mir_add_param(mu, t_param, ti->stamp, ident_new("VAL")); switch (type_kind(type)) { case T_ENUM: enum_image_helper(mu, type, arg); break; case T_INTEGER: case T_REAL: numeric_image_helper(mu, type, arg); break; case T_PHYSICAL: physical_image_helper(mu, type, arg); break; case T_RECORD: record_image_helper(mu, type, arg); break; case T_ARRAY: { type_t elem = type_elem(type); if (type_is_enum(elem) && all_character_literals(elem)) character_array_image_helper(mu, type, arg, true); else array_image_helper(mu, type, arg); } break; default: fatal_trace("cannot lower image helper for type %s", type_pp(type)); } } nvc-r1.17.1/src/vhdl/vhdl-priv.h000066400000000000000000000020361504111170000163500ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VHDL_PRIV_H #define _VHDL_PRIV_H #include "prim.h" #include "mir/mir-node.h" #include "type.h" typedef struct { mir_type_t type; mir_stamp_t stamp; type_kind_t kind; size_t size; unsigned ndims; unsigned udims; } type_info_t; const type_info_t *type_info(mir_unit_t *mu, type_t type); #endif // _VHDL_PRIV_H nvc-r1.17.1/src/vhpi/000077500000000000000000000000001504111170000142745ustar00rootroot00000000000000nvc-r1.17.1/src/vhpi/Makemodule.am000066400000000000000000000003231504111170000166740ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/vhpi/vhpi_sens.c \ src/vhpi/vhpi-str.c \ src/vhpi/vhpi-model.c \ src/vhpi/vhpi-macros.h \ src/vhpi/vhpi-util.h \ src/vhpi/vhpi-util.c include_HEADERS += src/vhpi/vhpi_user.h nvc-r1.17.1/src/vhpi/vhpi-macros.h000066400000000000000000000041311504111170000166740ustar00rootroot00000000000000// // Copyright (C) 2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VHPI_MACROS_H #define _VHPI_MACROS_H #define DEF_CLASS(class, tag, path) \ static UNUSED c_##class *is_##class(c_vhpiObject *obj) \ { \ if (obj->kind == tag) \ return container_of(obj, c_##class, path); \ else \ return NULL; \ } \ \ static UNUSED c_##class *cast_##class(c_vhpiObject *obj) \ { \ c_##class *p = is_##class(obj); \ if (p == NULL) \ vhpi_error(vhpiError, NULL, "class kind %s is not a " \ #tag, vhpi_class_str(obj->kind)); \ return p; \ } #define VHPI_MISSING fatal_trace("VHPI function %s not implemented", __func__) #define VHPI_TRACE(...) do { \ extern int _vhpi_trace_on(void); \ if (unlikely(_vhpi_trace_on())) \ vhpi_trace(__func__, __VA_ARGS__); \ } while (0) #endif // _VHPI_MACROS_H nvc-r1.17.1/src/vhpi/vhpi-model.c000066400000000000000000004240551504111170000165160ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "common.h" #include "diag.h" #include "hash.h" #include "jit/jit-ffi.h" #include "jit/jit-layout.h" #include "jit/jit.h" #include "lib.h" #include "option.h" #include "rt/model.h" #include "rt/rt.h" #include "rt/structs.h" #include "tree.h" #include "type.h" #include "vhpi/vhpi-macros.h" #include "vhpi/vhpi-util.h" #include #include #include #include #include typedef vhpiCharT *vhpiStringT; typedef vhpiSmallEnumT vhpiBooleanT; typedef struct { vhpiClassKindT kind; loc_t loc; } c_vhpiObject; typedef struct { c_vhpiObject object; uint32_t refcount; } c_refcounted; typedef struct { unsigned count; unsigned limit; c_vhpiObject **items; } vhpiObjectListT; typedef A(vhpiHandleT) vhpiHandleListT; typedef void (*vhpiLazyFnT)(c_vhpiObject *); typedef struct { vhpiLazyFnT fn; vhpiObjectListT list; } vhpiLazyListT; typedef struct { c_vhpiObject object; vhpiStringT StrVal; } c_argv; DEF_CLASS(argv, vhpiArgvK, object); typedef struct { c_vhpiObject object; vhpiObjectListT argv; } c_tool; DEF_CLASS(tool, vhpiToolK, object); typedef struct tag_abstractRegion c_abstractRegion; typedef struct tag_expr c_expr; typedef struct tag_abstractRegion { c_vhpiObject object; tree_t tree; rt_scope_t *scope; vhpiLazyListT decls; vhpiLazyListT stmts; c_abstractRegion *UpperRegion; vhpiIntT LineOffset; vhpiIntT LineNo; vhpiStringT FileName; vhpiStringT DefName; vhpiStringT CaseName; vhpiStringT Name; vhpiStringT FullCaseName; vhpiStringT FullName; jit_handle_t handle; } c_abstractRegion; typedef struct { c_vhpiObject object; type_t type; tree_t tree; c_abstractRegion *ImmRegion; vhpiIntT LineOffset; vhpiIntT LineNo; vhpiStringT FileName; vhpiStringT DefName; vhpiStringT CaseName; vhpiStringT Name; vhpiStringT FullCaseName; vhpiStringT FullName; } c_abstractDecl; typedef struct { c_vhpiObject object; c_expr *LeftExpr; c_expr *RightExpr; vhpiBooleanT Staticness; vhpiBooleanT IsUnconstrained; vhpiBooleanT IsNull; vhpiBooleanT IsUp; vhpiBooleanT IsDiscrete; } c_range; typedef struct { c_range range; vhpiPhysT PhysLeftBound; vhpiPhysT PhysRightBound; } c_physRange; DEF_CLASS(physRange, vhpiPhysRangeK, range.object); typedef struct { c_range range; vhpiLongIntT LeftBound; vhpiLongIntT RightBound; } c_intRange; DEF_CLASS(intRange, vhpiIntRangeK, range.object); typedef struct { c_range range; vhpiRealT FloatLeftBound; vhpiRealT FloatRightBound; } c_floatRange; DEF_CLASS(floatRange, vhpiFloatRangeK, range.object); typedef struct tag_typeDecl c_typeDecl; typedef struct tag_typeDecl { c_abstractDecl decl; type_t type; c_typeDecl *BaseType; // XXX: should belong to subtype? vhpiFormatT format; const char *map_str; vhpiIntT numElems; vhpiBooleanT IsAnonymous; // XXX: should belong to subtype? vhpiBooleanT IsComposite; vhpiBooleanT IsScalar; vhpiBooleanT IsUnconstrained; bool homogeneous; bool wrapped; uint8_t size; } c_typeDecl; typedef struct { c_typeDecl typeDecl; vhpiObjectListT Constraints; vhpiBooleanT isResolved; } c_subTypeDecl; DEF_CLASS(subTypeDecl, vhpiSubtypeDeclK, typeDecl.decl.object); typedef struct { c_typeDecl typeDecl; } c_scalarTypeDecl; typedef struct { c_typeDecl typeDecl; } c_compositeTypeDecl; typedef struct { c_scalarTypeDecl scalar; c_range *constraint; } c_intTypeDecl; DEF_CLASS(intTypeDecl, vhpiIntTypeDeclK, scalar.typeDecl.decl.object); typedef struct { c_scalarTypeDecl scalar; vhpiLazyListT EnumLiterals; } c_enumTypeDecl; DEF_CLASS(enumTypeDecl, vhpiEnumTypeDeclK, scalar.typeDecl.decl.object); typedef struct { c_scalarTypeDecl scalar; c_range *constraint; } c_physTypeDecl; DEF_CLASS(physTypeDecl, vhpiPhysTypeDeclK, scalar.typeDecl.decl.object); typedef struct { c_scalarTypeDecl scalar; c_range *constraint; } c_floatTypeDecl; typedef struct { c_typeDecl typeDecl; c_typeDecl *ValType; } c_accessTypeDecl; DEF_CLASS(accessTypeDecl, vhpiAccessTypeDeclK, typeDecl.decl.object); typedef struct { c_typeDecl typeDecl; c_typeDecl *ValType; } c_fileTypeDecl; DEF_CLASS(fileTypeDecl, vhpiFileTypeDeclK, typeDecl.decl.object); typedef struct { c_compositeTypeDecl composite; c_typeDecl *ElemType; vhpiIntT NumDimensions; vhpiObjectListT Constraints; } c_arrayTypeDecl; DEF_CLASS(arrayTypeDecl, vhpiArrayTypeDeclK, composite.typeDecl.decl.object); typedef struct { c_compositeTypeDecl composite; vhpiLazyListT RecordElems; } c_recordTypeDecl; DEF_CLASS(recordTypeDecl, vhpiRecordTypeDeclK, composite.typeDecl.decl.object); typedef struct { c_abstractDecl decl; c_typeDecl *Type; c_abstractDecl *parent; vhpiIntT Position; } c_elemDecl; DEF_CLASS(elemDecl, vhpiElemDeclK, decl.object); typedef struct { c_abstractDecl decl; vhpiLazyListT IndexedNames; vhpiLazyListT SelectedNames; c_typeDecl *Type; vhpiIntT Access; vhpiStaticnessT Staticness; vhpiBooleanT IsDynamic; rt_signal_t *signal; rt_scope_t *scope; } c_objDecl; typedef struct { c_objDecl objDecl; vhpiSigKindT SigKind; vhpiBooleanT IsGuarded; } c_sigDecl; DEF_CLASS(sigDecl, vhpiSigDeclK, objDecl.decl.object); typedef struct { c_objDecl objDecl; vhpiSigKindT SigKind; vhpiBooleanT IsProtectedType; vhpiBooleanT IsShared; } c_varDecl; DEF_CLASS(varDecl, vhpiVarDeclK, objDecl.decl.object); typedef struct { c_vhpiObject object; tree_t tree; vhpiObjectListT Params; } c_subpDecl; typedef struct { c_subpDecl subpDecl; c_typeDecl *ReturnType; vhpiBooleanT IsPure; } c_funcDecl; DEF_CLASS(funcDecl, vhpiFuncDeclK, subpDecl.object); typedef struct { c_subpDecl subpDecl; } c_procDecl; DEF_CLASS(procDecl, vhpiProcDeclK, subpDecl.object); typedef struct { c_objDecl objDecl; vhpiIntT Position; unsigned argslot; } c_interfaceDecl; typedef struct { c_interfaceDecl interface; vhpiModeT Mode; vhpiBooleanT IsLocal; vhpiBooleanT IsOpen; vhpiSigKindT SigKind; } c_portDecl; DEF_CLASS(portDecl, vhpiPortDeclK, interface.objDecl.decl.object); typedef struct { c_interfaceDecl interface; vhpiModeT Mode; vhpiBooleanT IsLocal; vhpiBooleanT IsVital; } c_genericDecl; DEF_CLASS(genericDecl, vhpiGenericDeclK, interface.objDecl.decl.object); typedef struct { c_interfaceDecl interface; vhpiModeT Mode; } c_constParamDecl; DEF_CLASS(constParamDecl, vhpiConstParamDeclK, interface.objDecl.decl.object); typedef struct { c_interfaceDecl interface; vhpiModeT Mode; } c_varParamDecl; DEF_CLASS(varParamDecl, vhpiVarParamDeclK, interface.objDecl.decl.object); typedef struct { c_objDecl objDecl; vhpiBooleanT IsDeferred; } c_constDecl; DEF_CLASS(constDecl, vhpiConstDeclK, objDecl.decl.object); typedef struct { c_abstractDecl decl; vhpiStringT StrVal; vhpiStringT SignatureName; c_enumTypeDecl *Type; vhpiIntT Position; } c_enumLiteral; DEF_CLASS(enumLiteral, vhpiEnumLiteralK, decl.object); typedef struct tag_expr { c_vhpiObject object; c_typeDecl *Type; vhpiStaticnessT Staticness; } c_expr; typedef struct { c_expr expr; } c_literal; typedef struct { c_literal literal; vhpiLongIntT IntVal; } c_intLiteral; typedef struct { c_literal literal; vhpiPhysT PhysVal; } c_physLiteral; typedef struct { c_expr expr; vhpiLazyListT IndexedNames; vhpiLazyListT SelectedNames; vhpiStringT FullCaseName; vhpiStringT CaseName; vhpiStringT FullName; vhpiStringT Name; vhpiStringT DefName; vhpiAccessT Access; } c_name; typedef struct { c_name name; c_vhpiObject *Prefix; rt_signal_t *signal; rt_scope_t *scope; } c_prefixedName; typedef struct { c_prefixedName prefixedName; vhpiIntT BaseIndex; int offset; } c_indexedName; DEF_CLASS(indexedName, vhpiIndexedNameK, prefixedName.name.expr.object); typedef struct { c_prefixedName prefixedName; c_elemDecl *Suffix; } c_selectedName; DEF_CLASS(selectedName, vhpiSelectedNameK, prefixedName.name.expr.object); typedef struct { c_abstractRegion region; vhpiStringT CaseName; vhpiStringT Name; vhpiStringT UnitName; vhpiObjectListT DepUnits; } c_designUnit; typedef struct { c_designUnit designUnit; c_designUnit *PrimaryUnit; } c_secondaryUnit; DEF_CLASS(secondaryUnit, vhpiArchBodyK, designUnit.region.object); typedef struct { c_designUnit designUnit; vhpiObjectListT ports; } c_entityDecl; typedef struct { c_designUnit designUnit; } c_packDecl; typedef struct { c_abstractRegion region; c_designUnit *DesignUnit; } c_designInstUnit; typedef struct { c_designInstUnit designInstUnit; } c_rootInst; DEF_CLASS(rootInst, vhpiRootInstK, designInstUnit.region.object); typedef struct { c_designInstUnit designInstUnit; } c_packInst; DEF_CLASS(packInst, vhpiPackInstK, designInstUnit.region.object); typedef struct { vhpiBooleanT IsSeqStmt; vhpiStringT LabelName; } c_stmt; typedef struct { c_designInstUnit designInstUnit; c_stmt stmt; } c_compInstStmt; DEF_CLASS(compInstStmt, vhpiCompInstStmtK, designInstUnit.region.object); typedef struct { c_abstractRegion region; c_stmt stmt; vhpiBooleanT IsGuarded; } c_blockStmt; DEF_CLASS(blockStmt, vhpiBlockStmtK, region.object); typedef struct { c_abstractRegion region; c_stmt stmt; vhpiIntT GenerateIndex; c_constDecl *ParamDecl; } c_forGenerate; DEF_CLASS(forGenerate, vhpiForGenerateK, region.object); typedef struct { c_abstractRegion region; c_stmt stmt; } c_ifGenerate; DEF_CLASS(ifGenerate, vhpiIfGenerateK, region.object); typedef struct { c_refcounted refcounted; vhpiStateT State; vhpiEnumT Reason; vhpiCbDataT data; vhpiHandleT handle; rt_watch_t *watch; } c_callback; DEF_CLASS(callback, vhpiCallbackK, refcounted.object); typedef void *(*vhpiFilterT)(c_vhpiObject *); typedef struct { c_refcounted refcounted; vhpiObjectListT *list; c_vhpiObject *single; uint32_t pos; vhpiFilterT filter; } c_iterator; DEF_CLASS(iterator, vhpiIteratorK, refcounted.object); typedef struct { c_vhpiObject object; vhpiForeignDataT data; c_subpDecl *decl; vhpiHandleT handle; } c_foreignf; DEF_CLASS(foreignf, vhpiForeignfK, object); #define HANDLE_BITS (sizeof(vhpiHandleT) * 8) #define HANDLE_MAX_INDEX ((UINT64_C(1) << (HANDLE_BITS / 2)) - 1) typedef enum { HANDLE_USER, HANDLE_INTERNAL, } handle_kind_t; typedef struct { c_vhpiObject *obj; handle_kind_t kind; uint32_t generation; } handle_slot_t; STATIC_ASSERT(sizeof(handle_slot_t) <= 16); typedef struct _vhpi_context { c_tool *tool; c_rootInst *root; vhpiObjectListT packages; shash_t *strtab; rt_model_t *model; hash_t *objcache; tree_t top; jit_t *jit; handle_slot_t *handles; unsigned num_handles; unsigned free_hint; vhpiObjectListT foreignfs; jit_scalar_t *args; tlab_t *tlab; vhpiHandleListT callbacks; mem_pool_t *pool; vhpiObjectListT recycle; } vhpi_context_t; static c_typeDecl *cached_typeDecl(type_t type, c_vhpiObject *obj); static c_designUnit *cached_designUnit(tree_t t); static c_typeDecl *build_dynamicSubtype(c_typeDecl *base, void *ptr, vhpiClassKindT kind); static void *vhpi_get_value_ptr(c_vhpiObject *obj); static vhpiClassKindT vhpi_get_prefix_kind(c_vhpiObject *obj); static vhpiStringT vhpi_get_case_name(c_vhpiObject *obj); static vhpiStringT vhpi_get_full_case_name(c_vhpiObject *obj); static void vhpi_lazy_decls(c_vhpiObject *obj); static void vhpi_lazy_selected_names(c_vhpiObject *obj); static void vhpi_lazy_indexed_names(c_vhpiObject *obj); static void vhpi_lazy_enum_literals(c_vhpiObject *obj); static void vhpi_lazy_fields(c_vhpiObject *obj); static const char *handle_pp(vhpiHandleT handle); static c_refcounted *is_refcounted(c_vhpiObject *obj); static vhpi_context_t *global_context = NULL; // TODO: thread local static const vhpiModeT mode_map[] = { vhpiInMode, vhpiInMode, vhpiOutMode, vhpiInoutMode, vhpiBufferMode, vhpiLinkageMode, vhpiLinkageMode /* view */, vhpiLinkageMode /* view */ }; static inline vhpi_context_t *vhpi_context(void) { assert(global_context != NULL); return global_context; } static handle_slot_t *decode_handle(vhpi_context_t *c, vhpiHandleT handle) { const uintptr_t bits = (uintptr_t)handle; const uint32_t index = bits & HANDLE_MAX_INDEX; const uint32_t generation = bits >> HANDLE_BITS/2; if (handle == NULL || index >= c->num_handles) return NULL; handle_slot_t *slot = &(c->handles[index]); if (slot->obj == NULL) return NULL; else if (slot->generation != generation) return NULL; // Use-after-free return slot; } static inline vhpiHandleT encode_handle(handle_slot_t *slot, uint32_t index) { const uintptr_t bits = (uintptr_t)slot->generation << HANDLE_BITS/2 | index; return (vhpiHandleT)bits; } static vhpiHandleT handle_for(c_vhpiObject *obj, handle_kind_t kind) { assert(obj != NULL); vhpi_context_t *c = vhpi_context(); uint32_t index = c->free_hint; if (index >= c->num_handles || c->handles[index].obj != NULL) { for (index = 0; index < c->num_handles; index++) { if (c->handles[index].obj == NULL && c->handles[index].generation < HANDLE_MAX_INDEX) break; } } if (unlikely(index > HANDLE_MAX_INDEX)) { vhpi_error(vhpiFailure, NULL, "too many active handles"); return NULL; } else if (index == c->num_handles) { const int new_size = MAX(c->num_handles * 2, 128); c->handles = xrealloc_array(c->handles, new_size, sizeof(handle_slot_t)); c->num_handles = new_size; for (int i = index; i < new_size; i++) { c->handles[i].obj = NULL; c->handles[i].generation = 1; } } handle_slot_t *slot = &(c->handles[index]); slot->obj = obj; slot->kind = kind; c->free_hint = index + 1; c_refcounted *rc = is_refcounted(obj); if (rc != NULL) rc->refcount++; return encode_handle(slot, index); } static inline vhpiHandleT user_handle_for(c_vhpiObject *obj) { return handle_for(obj, HANDLE_USER); } static inline vhpiHandleT internal_handle_for(c_vhpiObject *obj) { return handle_for(obj, HANDLE_INTERNAL); } static void drop_handle(vhpi_context_t *c, vhpiHandleT handle) { handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) return; c_vhpiObject *obj = slot->obj; slot->obj = NULL; slot->generation++; c->free_hint = slot - c->handles; c_refcounted *rc = is_refcounted(obj); if (rc != NULL) { assert(rc->refcount > 0); if (--(rc->refcount) == 0) APUSH(c->recycle, obj); } } static inline c_vhpiObject *from_handle(vhpiHandleT handle) { handle_slot_t *slot = decode_handle(vhpi_context(), handle); if (likely(slot != NULL)) return slot->obj; vhpi_error(vhpiError, NULL, "invalid handle %p", handle); return NULL; } static c_refcounted *is_refcounted(c_vhpiObject *obj) { switch (obj->kind) { case vhpiCallbackK: case vhpiIteratorK: return container_of(obj, c_refcounted, object); default: return NULL; } } static c_abstractRegion *is_abstractRegion(c_vhpiObject *obj) { switch (obj->kind) { case vhpiRootInstK: case vhpiBlockStmtK: case vhpiCompInstStmtK: case vhpiForGenerateK: case vhpiIfGenerateK: case vhpiPackInstK: case vhpiEntityDeclK: case vhpiArchBodyK: case vhpiPackDeclK: return container_of(obj, c_abstractRegion, object); default: return NULL; } } static c_abstractDecl *is_abstractDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiSigDeclK: case vhpiPortDeclK: case vhpiEnumLiteralK: case vhpiIntTypeDeclK: case vhpiEnumTypeDeclK: case vhpiPhysTypeDeclK: case vhpiFloatTypeDeclK: case vhpiArrayTypeDeclK: case vhpiRecordTypeDeclK: case vhpiAccessTypeDeclK: case vhpiFileTypeDeclK: case vhpiSubtypeDeclK: case vhpiElemDeclK: case vhpiGenericDeclK: case vhpiConstDeclK: case vhpiConstParamDeclK: case vhpiSigParamDeclK: case vhpiVarParamDeclK: return container_of(obj, c_abstractDecl, object); default: return NULL; } } static c_objDecl *is_objDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiSigDeclK: case vhpiPortDeclK: case vhpiGenericDeclK: case vhpiConstDeclK: case vhpiConstParamDeclK: case vhpiVarParamDeclK: case vhpiSigParamDeclK: return container_of(obj, c_objDecl, decl.object); default: return NULL; } } static c_objDecl *cast_objDecl(c_vhpiObject *obj) { c_objDecl *od = is_objDecl(obj); if (od == NULL) vhpi_error(vhpiError, &(obj->loc), "class kind %s is not an object " "declaration", vhpi_class_str(obj->kind)); return od; } static c_interfaceDecl *is_interfaceDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiPortDeclK: case vhpiGenericDeclK: case vhpiConstParamDeclK: case vhpiSigParamDeclK: case vhpiVarParamDeclK: return container_of(obj, c_interfaceDecl, objDecl.decl.object); default: return NULL; } } static c_range *is_range(c_vhpiObject *obj) { switch (obj->kind) { case vhpiPhysRangeK: case vhpiIntRangeK: return container_of(obj, c_range, object); default: return NULL; } } static c_subpDecl *is_subpDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiFuncDeclK: case vhpiProcDeclK: return container_of(obj, c_subpDecl, object); default: return NULL; } } static c_typeDecl *is_typeDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiSubtypeDeclK: case vhpiIntTypeDeclK: case vhpiEnumTypeDeclK: case vhpiPhysTypeDeclK: case vhpiArrayTypeDeclK: case vhpiRecordTypeDeclK: case vhpiAccessTypeDeclK: case vhpiFileTypeDeclK: return container_of(obj, c_typeDecl, decl.object); default: return NULL; } } static c_compositeTypeDecl *is_compositeTypeDecl(c_vhpiObject *obj) { switch (obj->kind) { case vhpiArrayTypeDeclK: case vhpiRecordTypeDeclK: return container_of(obj, c_compositeTypeDecl, typeDecl.decl.object); default: return NULL; } } static c_expr *is_expr(c_vhpiObject *obj) { switch (obj->kind) { case vhpiIndexedNameK: case vhpiSelectedNameK: return container_of(obj, c_expr, object); default: return NULL; } } static c_expr *cast_expr(c_vhpiObject *obj) { c_expr *e = is_expr(obj); if (e == NULL) vhpi_error(vhpiError, &(obj->loc), "class kind %s is not an expression", vhpi_class_str(obj->kind)); return e; } static c_stmt *is_stmt(c_vhpiObject *obj) { switch (obj->kind) { case vhpiBlockStmtK: return &(container_of(obj, c_blockStmt, region.object)->stmt); case vhpiCompInstStmtK: return &(container_of(obj, c_compInstStmt, designInstUnit.region.object)->stmt); case vhpiForGenerateK: return &(container_of(obj, c_forGenerate, region.object)->stmt); case vhpiIfGenerateK: return &(container_of(obj, c_ifGenerate, region.object)->stmt); default: return NULL; } } static c_name *is_name(c_vhpiObject *obj) { switch (obj->kind) { case vhpiIndexedNameK: case vhpiSelectedNameK: return container_of(obj, c_name, expr.object); default: return NULL; } } static c_prefixedName *is_prefixedName(c_vhpiObject *obj) { switch (obj->kind) { case vhpiIndexedNameK: case vhpiSelectedNameK: return container_of(obj, c_prefixedName, name.expr.object); default: return NULL; } } static c_prefixedName *cast_prefixedName(c_vhpiObject *obj) { c_prefixedName *pn = is_prefixedName(obj); if (pn == NULL) vhpi_error(vhpiError, &(obj->loc), "class kind %s is not a prefixed name", vhpi_class_str(obj->kind)); return pn; } static c_designUnit *is_designUnit(c_vhpiObject *obj) { switch (obj->kind) { case vhpiArchBodyK: case vhpiEntityDeclK: case vhpiVerilogModuleK: return container_of(obj, c_designUnit, region.object); default: return NULL; } } static c_designInstUnit *cast_designInstUnit(c_vhpiObject *obj) { switch (obj->kind) { case vhpiRootInstK: case vhpiCompInstStmtK: case vhpiPackInstK: return container_of(obj, c_designInstUnit, region.object); default: vhpi_error(vhpiError, &(obj->loc), "class kind %s is not an instance of " "a design unit", vhpi_class_str(obj->kind)); return NULL; } } static void handle_pp_r(vhpiHandleT handle, text_buf_t *tb) { if (handle == NULL) { tb_cat(tb, "NULL"); return; } tb_printf(tb, "%p:{", handle); handle_slot_t *slot = decode_handle(vhpi_context(), handle); if (slot == NULL) tb_cat(tb, "INVALID"); else { c_vhpiObject *obj = slot->obj; tb_cat(tb, vhpi_class_str(obj->kind)); c_abstractDecl *decl = is_abstractDecl(obj); if (decl != NULL) tb_printf(tb, " Name=%s", vhpi_get_case_name(obj)); c_name *n = is_name(obj); if (n != NULL) tb_printf(tb, " Name=%s", vhpi_get_case_name(obj)); c_iterator *it = is_iterator(obj); if (it != NULL && it->list != NULL) tb_printf(tb, " pos=%d/%d", it->pos, it->list->count); c_callback *cb = is_callback(obj); if (cb != NULL) tb_printf(tb, " Reason=%s State=%s", vhpi_cb_reason_str(cb->Reason), vhpi_state_str(cb->State)); c_range *r = is_range(obj); if (r != NULL) tb_printf(tb, " IsNull=%d IsUp=%d IsUnconstrained=%d", r->IsNull, r->IsUp, r->IsUnconstrained); } tb_append(tb, '}'); } static const char *handle_pp(vhpiHandleT handle) { static __thread text_buf_t *tb = NULL; if (tb == NULL) tb = tb_new(); tb_rewind(tb); handle_pp_r(handle, tb); return tb_get(tb); } static const char *cb_data_pp(const vhpiCbDataT *data) { static __thread text_buf_t *tb = NULL; if (tb == NULL) tb = tb_new(); tb_rewind(tb); tb_printf(tb, "{reason=%s obj=", vhpi_cb_reason_str(data->reason)); handle_pp_r(data->obj, tb); tb_printf(tb, " cb_rtn=%p user_data=%p}", data->cb_rtn, data->user_data); return tb_get(tb); } static void *new_object(size_t size, vhpiClassKindT class) { assert(size >= sizeof(c_vhpiObject)); c_vhpiObject *obj = pool_calloc(vhpi_context()->pool, size); obj->kind = class; obj->loc = LOC_INVALID; return obj; } static void *recyle_object(size_t size, vhpiClassKindT class) { vhpi_context_t *c = vhpi_context(); for (int i = 0; i < c->recycle.count; i++) { c_vhpiObject *obj = c->recycle.items[i]; if (obj->kind == class) { for (int j = i; j < c->recycle.count - 1; j++) c->recycle.items[j] = c->recycle.items[j + 1]; ATRIM(c->recycle, c->recycle.count - 1); memset(obj, '\0', size); obj->kind = class; obj->loc = LOC_INVALID; return obj; } } return new_object(size, class); } static vhpiCharT *new_string(const char *s) { vhpi_context_t *c = vhpi_context(); if (c->strtab == NULL) c->strtab = shash_new(1024); vhpiCharT *p = shash_get(c->strtab, s); if (p == NULL) { const size_t len = strlen(s); vhpiCharT *copy = p = pool_malloc(c->pool, len + 1); memcpy(copy, s, len + 1); shash_put(c->strtab, s, copy); } return p; } __attribute__((format(printf, 1, 2))) static vhpiCharT *new_stringf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *LOCAL buf = xvasprintf(fmt, ap); va_end(ap); return new_string(buf); } static vhpiCharT *new_upper_string(const char *s) { char *copy LOCAL = xstrdup(s); for (char *p = copy; *p; p++) *p = toupper_iso88591(*p); return new_string(copy); } static void vhpi_list_reserve(vhpiObjectListT *list, unsigned num) { if (list->limit >= num) return; assert(list->count == 0); assert(list->items == NULL); mem_pool_t *mp = vhpi_context()->pool; list->limit = num; list->items = pool_malloc_array(mp, num, sizeof(c_vhpiObject *)); } static inline void vhpi_list_add(vhpiObjectListT *list, c_vhpiObject *obj) { assert(list->count < list->limit); list->items[list->count++] = obj; } static void init_abstractRegion(c_abstractRegion *r, c_abstractRegion *upper, tree_t t) { const loc_t *loc = tree_loc(t); r->object.loc = *loc; r->UpperRegion = upper; r->LineNo = loc->first_line; r->LineOffset = loc->line_delta; r->tree = t; r->handle = JIT_HANDLE_INVALID; } static void init_designInstUnit(c_designInstUnit *iu, c_abstractRegion *upper, tree_t t, c_designUnit *u) { init_abstractRegion(&(iu->region), upper, t); iu->DesignUnit = u; } static void init_abstractDecl(c_abstractDecl *d, tree_t t, c_abstractRegion *r) { const loc_t *loc = tree_loc(t); d->object.loc = *loc; d->LineNo = loc->first_line; d->LineOffset = loc->line_delta; d->ImmRegion = r; d->type = tree_type(t); d->tree = t; } static void init_objDecl(c_objDecl *d, tree_t t, c_abstractRegion *ImmRegion) { init_abstractDecl(&(d->decl), t, ImmRegion); d->Type = cached_typeDecl(tree_type(t), &(d->decl.object)); if (d->Type->IsUnconstrained) { void *ptr = vhpi_get_value_ptr(&(d->decl.object)); if (ptr != NULL) { vhpiClassKindT kind = vhpi_get_prefix_kind(&(d->decl.object)); d->Type = build_dynamicSubtype(d->Type, ptr, kind); } } tree_flags_t flags = tree_flags(t); if (flags & TREE_F_LOCALLY_STATIC) d->Staticness = vhpiLocallyStatic; else if (flags & TREE_F_GLOBALLY_STATIC) d->Staticness = vhpiGloballyStatic; else d->Staticness = vhpiDynamic; d->SelectedNames.fn = vhpi_lazy_selected_names; d->IndexedNames.fn = vhpi_lazy_indexed_names; } static void init_interfaceDecl(c_interfaceDecl *d, tree_t t, int Position, c_abstractRegion *ImmRegion) { init_objDecl(&(d->objDecl), t, ImmRegion); d->Position = Position; } static void init_subpDecl(c_subpDecl *d, tree_t t) { d->object.loc = *tree_loc(t); d->tree = t; } static void init_elemDecl(c_elemDecl *ed, tree_t t, c_typeDecl *Type, c_abstractDecl *parent) { init_abstractDecl(&(ed->decl), t, parent->ImmRegion); ed->Type = Type; ed->Position = tree_pos(t); ed->parent = parent; } static void init_typeDecl(c_typeDecl *d, tree_t t, type_t type) { init_abstractDecl(&(d->decl), t, NULL); char *full LOCAL = xasprintf("@%s", istr(type_ident(type))); char *pos = full, *lastpos; while (lastpos = pos, (pos = strchr(pos, '.'))) *pos = ':'; d->decl.FullCaseName = new_string(full); // Kludge to set the name correctly for nested arrays d->decl.CaseName = (vhpiStringT)d->decl.FullCaseName + (lastpos - full) + 1; d->type = type; d->format = vhpi_format_for_type(d->type, &d->map_str); d->IsUnconstrained = type_is_unconstrained(d->type); d->homogeneous = type_is_homogeneous(d->type); d->numElems = d->IsUnconstrained ? -1 : 1; } static void init_scalarTypeDecl(c_scalarTypeDecl *d, tree_t t, type_t type) { init_typeDecl(&(d->typeDecl), t, type); d->typeDecl.IsScalar = true; d->typeDecl.size = type_bit_width(type) / 8; } static void init_compositeTypeDecl(c_compositeTypeDecl *d, tree_t t, type_t type) { init_typeDecl(&(d->typeDecl), t, type); d->typeDecl.IsComposite = true; } static void init_enumLiteral(c_enumLiteral *el, tree_t t, c_enumTypeDecl *Type) { init_abstractDecl(&(el->decl), t, NULL); el->Type = Type; el->Position = tree_pos(t); } static void init_range(c_range *r, vhpiBooleanT IsUp, vhpiBooleanT IsNull, vhpiBooleanT IsDiscrete) { r->IsUp = IsUp; r->IsNull = IsNull; r->IsDiscrete = IsDiscrete; r->LeftExpr = NULL; r->RightExpr = NULL; } static void init_expr(c_expr *e, vhpiStaticnessT Staticness, c_typeDecl *Type) { e->Type = Type; e->Staticness = Staticness; } static void init_stmt(c_stmt *s, tree_t t) { s->IsSeqStmt = false; s->LabelName = new_string(istr(tree_ident(t))); } static void init_name(c_name *n, vhpiStaticnessT Staticness, c_typeDecl *Type, vhpiStringT Name, vhpiStringT FullName) { init_expr(&(n->expr), Staticness, Type); n->CaseName = Name; n->FullCaseName = FullName; n->SelectedNames.fn = vhpi_lazy_selected_names; n->IndexedNames.fn = vhpi_lazy_indexed_names; } static void init_prefixedName(c_prefixedName *pn, c_typeDecl *Type, c_vhpiObject *prefix, const char *suffix) { vhpiStringT Name = NULL, FullName = NULL; vhpiStaticnessT Staticness = vhpiDynamic; c_name *name = is_name(prefix); if (name != NULL) { Name = new_stringf("%s%s", name->Name, suffix); FullName = new_stringf("%s%s", name->FullName, suffix); } c_objDecl *obj = is_objDecl(prefix); if (obj != NULL) { Name = new_stringf("%s%s", vhpi_get_case_name(prefix), suffix); FullName = new_stringf("%s%s", vhpi_get_full_case_name(prefix), suffix); Staticness = obj->Staticness; } init_name(&(pn->name), Staticness, Type, Name, FullName); pn->Prefix = prefix; } static void init_indexedName(c_indexedName *in, c_typeDecl *Type, c_vhpiObject *prefix, vhpiObjectListT *Constraints, vhpiIntT indices[]) { vhpiIntT BaseIndex = 0; LOCAL_TEXT_BUF suffix = tb_new(); tb_append(suffix, '('); for (int i = 0; i < Constraints->count; i++) { if (i != 0) tb_append(suffix, ','); c_intRange *ir = is_intRange(Constraints->items[i]); assert(ir != NULL); int idx; if (ir->LeftBound > ir->RightBound) { idx = ir->LeftBound - indices[i]; BaseIndex *= ir->LeftBound - ir->RightBound + 1; } else { idx = indices[i] - ir->LeftBound; BaseIndex *= ir->RightBound - ir->LeftBound + 1; } BaseIndex += indices[i]; tb_printf(suffix, "%d", idx); } tb_append(suffix, ')'); init_prefixedName(&(in->prefixedName), Type, prefix, tb_get(suffix)); in->BaseIndex = BaseIndex; in->offset = BaseIndex * Type->numElems; if (prefix) { c_indexedName *pin = is_indexedName(prefix); if (pin) in->offset += pin->offset; } } static vhpiIntT range_len(c_intRange *ir) { if (ir->range.IsUp) return MAX(ir->RightBound - ir->LeftBound + 1, 0); else return MAX(ir->LeftBound - ir->RightBound + 1, 0); } static void init_selectedName(c_selectedName *sn, c_vhpiObject *prefix, c_elemDecl *Suffix) { assert(prefix != NULL); LOCAL_TEXT_BUF suffix = tb_new(); tb_append(suffix, '.'); tb_cat(suffix, (const char *)vhpi_get_case_name(&Suffix->decl.object)); init_prefixedName(&(sn->prefixedName), Suffix->Type, prefix, tb_get(suffix)); sn->Suffix = Suffix; } static void init_designUnit(c_designUnit *u, tree_t t) { init_abstractRegion(&(u->region), NULL, t); ident_t uname = tree_ident(t); u->UnitName = new_string(istr(uname)); } static void init_secondaryUnit(c_secondaryUnit *u, tree_t t, c_designUnit *p) { init_designUnit(&(u->designUnit), t); u->PrimaryUnit = p; } static void init_entityDecl(c_entityDecl *e, tree_t t) { init_designUnit(&(e->designUnit), t); } static void init_packDecl(c_packDecl *p, tree_t t) { init_designUnit(&(p->designUnit), t); } static vhpiObjectListT *expand_lazy_list(c_vhpiObject *obj, vhpiLazyListT *lazy) { vhpiLazyFnT fn = lazy->fn; if (fn != NULL) { lazy->fn = NULL; // Avoid infinite recursion (*fn)(obj); } return &(lazy->list); } static void init_refcounted(c_refcounted *rc) { rc->refcount = 0; // No handles point to this object } static bool init_iterator(c_iterator *it, vhpiOneToManyT type, c_vhpiObject *obj) { init_refcounted(&it->refcounted); if (obj == NULL) { switch (type) { case vhpiPackInsts: it->list = &(vhpi_context()->packages); return true; default: return false; } } c_abstractRegion *region = is_abstractRegion(obj); if (region != NULL) { switch (type) { case vhpiDecls: it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiInternalRegions: it->filter = (vhpiFilterT)is_abstractRegion; it->list = expand_lazy_list(obj, &(region->stmts)); return true; case vhpiConstDecls: it->filter = (vhpiFilterT)is_constDecl; it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiVarDecls: it->filter = (vhpiFilterT)is_varDecl; it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiSigDecls: it->filter = (vhpiFilterT)is_sigDecl; it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiGenericDecls: it->filter = (vhpiFilterT)is_genericDecl; it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiPortDecls: it->filter = (vhpiFilterT)is_portDecl; it->list = expand_lazy_list(obj, &(region->decls)); return true; case vhpiStmts: it->list = expand_lazy_list(obj, &(region->stmts)); return true; case vhpiBlockStmts: it->filter = (vhpiFilterT)is_blockStmt; it->list = expand_lazy_list(obj, &(region->stmts)); return true; case vhpiCompInstStmts: it->filter = (vhpiFilterT)is_compInstStmt; it->list = expand_lazy_list(obj, &(region->stmts)); return true; default: return false; } } c_subpDecl *subp = is_subpDecl(obj); if (subp != NULL) { switch (type) { case vhpiParamDecls: it->list = &(subp->Params); return true; default: return false; } } c_arrayTypeDecl *array = is_arrayTypeDecl(obj); if (array != NULL) { if (type == vhpiConstraints) { it->list = &(array->Constraints); return true; } return false; } c_enumTypeDecl *etd = is_enumTypeDecl(obj); if (etd != NULL) { if (type == vhpiEnumLiterals) { it->list = expand_lazy_list(obj, &(etd->EnumLiterals)); return true; } return false; } c_recordTypeDecl *record = is_recordTypeDecl(obj); if (record != NULL) { if (type == vhpiRecordElems) { it->list = expand_lazy_list(obj, &(record->RecordElems)); return true; } return false; } c_subTypeDecl *subtype = is_subTypeDecl(obj); if (subtype != NULL) { if (type == vhpiConstraints) { it->list = &(subtype->Constraints); return true; } return false; } c_physTypeDecl *ptd = is_physTypeDecl(obj); if (ptd != NULL) { if (type == vhpiConstraints) { it->single = &(ptd->constraint->object); return true; } return false; } c_intTypeDecl *itd = is_intTypeDecl(obj); if (itd != NULL) { if (type == vhpiConstraints) { it->single = &(itd->constraint->object); return true; } return false; } c_objDecl *od = is_objDecl(obj); if (od != NULL) { switch(type) { case vhpiIndexedNames: it->list = expand_lazy_list(obj, &(od->IndexedNames)); return true; case vhpiSelectedNames: it->list = expand_lazy_list(obj, &(od->SelectedNames)); return true; default: return false; } } c_name *n = is_name(obj); if (n != NULL) { switch (type) { case vhpiIndexedNames: it->list = expand_lazy_list(obj, &(n->IndexedNames)); return true; case vhpiSelectedNames: it->list = expand_lazy_list(obj, &(n->SelectedNames)); return true; default: return false; } } c_tool *t = is_tool(obj); if (t != NULL) { if (type == vhpiArgvs) { it->list = &(t->argv); return true; } return false; } return false; } static void init_callback(c_callback *cb, const vhpiCbDataT *data, int flags) { init_refcounted(&cb->refcounted); cb->Reason = data->reason; cb->State = (flags & vhpiDisableCb) ? vhpiDisable : vhpiEnable; cb->data = *data; } static void vhpi_signal_event_cb(uint64_t now, rt_signal_t *signal, rt_watch_t *watch, void *user) { c_vhpiObject *obj = from_handle(user); if (obj == NULL) return; c_callback *cb = is_callback(obj); if (cb == NULL) return; if (cb->State != vhpiEnable) return; vhpiTimeT time; if (cb->data.time != NULL) { vhpi_get_time(&time, NULL); cb->data.time = &time; } (cb->data.cb_rtn)(&(cb->data)); } static void vhpi_global_cb(rt_model_t *m, void *user) { vhpiHandleT handle = user; vhpi_context_t *c = vhpi_context(); { handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) return; c_callback *cb = is_callback(slot->obj); if (cb == NULL) return; assert(cb->State != vhpiMature); if (cb->State == vhpiEnable) (cb->data.cb_rtn)(&(cb->data)); } // The handle may be invalidated by the user call { handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) return; c_callback *cb = is_callback(slot->obj); assert(cb != NULL); switch (cb->Reason) { case vhpiCbRepEndOfProcesses: case vhpiCbRepLastKnownDeltaCycle: case vhpiCbRepNextTimeStep: case vhpiCbRepEndOfTimeStep: case vhpiCbRepStartOfNextCycle: case vhpiCbValueChange: break; // Repetitive default: cb->State = vhpiMature; drop_handle(c, handle); break; } } } static rt_scope_t *vhpi_get_scope_abstractRegion(c_abstractRegion *region) { if (region->scope) return region->scope; rt_scope_t *scope = find_scope(vhpi_context()->model, region->tree); if (scope == NULL) { vhpi_error(vhpiError, &(region->object.loc), "cannot find scope object for %s", vhpi_get_case_name(®ion->object)); return NULL; } region->scope = scope; return scope; } static rt_scope_t *vhpi_get_scope_objDecl(c_objDecl *decl) { if (decl->scope) return decl->scope; rt_scope_t *parent = vhpi_get_scope_abstractRegion(decl->decl.ImmRegion); if (parent == NULL) return NULL; decl->scope = child_scope(parent, decl->decl.tree); if (decl->scope == NULL) vhpi_error(vhpiError, &(decl->decl.object.loc), "cannot find scope object for %s", decl->decl.Name); return decl->scope; } static rt_scope_t *vhpi_get_scope_prefixedName(c_prefixedName *pn) { if (pn->scope) return pn->scope; rt_scope_t *parent = NULL; c_prefixedName *ppn = is_prefixedName(pn->Prefix); if (ppn != NULL) parent = vhpi_get_scope_prefixedName(ppn); c_objDecl *od = is_objDecl(pn->Prefix); if (od != NULL) parent = vhpi_get_scope_objDecl(od); if (parent == NULL) return NULL; c_vhpiObject *obj = &(pn->name.expr.object); c_indexedName *in = is_indexedName(obj); c_selectedName *sn = is_selectedName(obj); if (in != NULL) pn->scope = child_scope_at(parent, in->BaseIndex); else if (sn != NULL) pn->scope = child_scope(parent, sn->Suffix->decl.tree); else fatal_trace("class kind %s not supported in %s", vhpi_class_str(obj->kind), __func__); if (pn->scope == NULL) vhpi_error(vhpiError, &(obj->loc), "cannot find scope object for %s", pn->name.Name); return pn->scope; } static rt_signal_t *vhpi_get_signal_objDecl(c_objDecl *decl) { if (decl->signal != NULL) return decl->signal; rt_scope_t *scope = vhpi_get_scope_abstractRegion(decl->decl.ImmRegion); if (scope == NULL) return NULL; rt_signal_t *signal = find_signal(scope, decl->decl.tree); if (signal == NULL) { vhpi_error(vhpiError, &(decl->decl.object.loc), "cannot find signal object for %s", vhpi_get_case_name(&decl->decl.object)); return NULL; } decl->signal = signal; return signal; } static rt_signal_t *vhpi_get_signal_prefixedName(c_prefixedName *pn) { if (pn->signal) return pn->signal; rt_scope_t *scope = NULL; c_prefixedName *ppn = is_prefixedName(pn->Prefix); if (ppn != NULL) { if (ppn->name.expr.Type->homogeneous) pn->signal = vhpi_get_signal_prefixedName(ppn); else scope = vhpi_get_scope_prefixedName(ppn); } c_objDecl *od = is_objDecl(pn->Prefix); if (od != NULL) { if (od->Type->homogeneous) pn->signal = vhpi_get_signal_objDecl(od); else scope = vhpi_get_scope_objDecl(od); } c_vhpiObject *obj = &(pn->name.expr.object); if (scope) { c_selectedName *sn = is_selectedName(obj); assert(sn != NULL); pn->signal = find_signal(scope, sn->Suffix->decl.tree); } if (pn->signal == NULL) vhpi_error(vhpiError, &(obj->loc), "cannot find signal object for %s", pn->name.Name); return pn->signal; } static vhpiClassKindT vhpi_get_prefix_kind(c_vhpiObject *obj) { c_prefixedName *pn = is_prefixedName(obj); if (pn != NULL) return vhpi_get_prefix_kind(pn->Prefix); c_elemDecl *ed = is_elemDecl(obj); if (ed != NULL) return vhpi_get_prefix_kind(&ed->parent->object); return obj->kind; } static void *vhpi_get_bounds_var(c_typeDecl *td) { jit_t *j = vhpi_context()->jit; ident_t id = type_ident(td->type); jit_handle_t handle = jit_lazy_compile(j, ident_runtil(id, '.')); return jit_get_frame_var(j, handle, id); } static const jit_layout_t *vhpi_get_layout(c_vhpiObject *obj) { type_t type = NULL; c_objDecl *od = is_objDecl(obj); if (od != NULL) type = od->decl.type; c_typeDecl *td = is_typeDecl(obj); if (td != NULL) type = td->type; c_expr *expr = is_expr(obj); if (expr != NULL) type = expr->Type->type; if (type == NULL) return NULL; switch (vhpi_get_prefix_kind(obj)) { case vhpiPortDeclK: case vhpiSigDeclK: return signal_layout_of(type); default: return layout_of(type); } } static void *vhpi_get_value_ptr(c_vhpiObject *obj) { jit_t *j = vhpi_context()->jit; c_prefixedName *pn = is_prefixedName(obj); if (pn != NULL) { void *base = vhpi_get_value_ptr(pn->Prefix); if (base == NULL) return NULL; const jit_layout_t *l = vhpi_get_layout(pn->Prefix); if (l == NULL) return NULL; c_selectedName *sn = is_selectedName(obj); if (sn != NULL) { assert(sn->Suffix->Position < l->nparts); return base + l->parts[sn->Suffix->Position].offset; } c_indexedName *in = is_indexedName(obj); if (in != NULL) { if (l->parts[0].class == LC_EXTERNAL) return ((ffi_uarray_t *)base)->ptr; // Wrapped array else return base; } vhpi_error(vhpiInternal, &(obj->loc), "unsupported prefixed name kind %s", vhpi_class_str(obj->kind)); return NULL; } c_compositeTypeDecl *ctd = is_compositeTypeDecl(obj); if (ctd != NULL) { void *base = vhpi_get_bounds_var(&(ctd->typeDecl)); if (base != NULL) return base; vhpi_error(vhpiInternal, &(obj->loc), "missing bounds variable for %s", type_pp(ctd->typeDecl.type)); return NULL; } c_elemDecl *ed = is_elemDecl(obj); if (ed != NULL) { c_vhpiObject *pobj = &(ed->parent->object); void *base = vhpi_get_value_ptr(pobj); if (base == NULL) return NULL; const jit_layout_t *l = vhpi_get_layout(pobj); assert(l != NULL); assert(ed->Position < l->nparts); return base + l->parts[ed->Position].offset; } c_objDecl *decl = is_objDecl(obj); assert(decl != NULL); if (decl->decl.ImmRegion == NULL) return NULL; else if (decl->decl.ImmRegion->handle == JIT_HANDLE_INVALID) { c_packInst *pi = is_packInst(&(decl->decl.ImmRegion->object)); if (pi != NULL) { ident_t qual = tree_ident(decl->decl.ImmRegion->tree); if (pi->designInstUnit.region.UpperRegion != NULL) { for (c_abstractRegion *it = pi->designInstUnit.region.UpperRegion; it != NULL; it = it->UpperRegion) qual = ident_prefix(tree_ident(it->tree), qual, '.'); qual = ident_prefix(lib_name(lib_work()), qual, '.'); } decl->decl.ImmRegion->handle = jit_lazy_compile(j, qual); if (jit_link(j, decl->decl.ImmRegion->handle) == NULL) { vhpi_error(vhpiError, &(obj->loc), "failed to initialise package"); return NULL; } } else { rt_scope_t *scope = vhpi_get_scope_abstractRegion(decl->decl.ImmRegion); if (*mptr_get(scope->privdata) == NULL) { vhpi_error(vhpiError, &(obj->loc), "%s has not been elaborated", decl->decl.FullName); return NULL; } decl->decl.ImmRegion->handle = jit_lazy_compile(j, scope->name); } } ident_t name = tree_ident(decl->decl.tree); return jit_get_frame_var(j, decl->decl.ImmRegion->handle, name); } static void vhpi_get_uarray(c_vhpiObject *obj, void **ptr, ffi_dim_t **dims) { if (ptr) *ptr = NULL; if (dims) *dims = NULL; void *base = vhpi_get_value_ptr(obj); if (base == NULL) return; if (ptr != NULL) *ptr = *(void **)base; if (dims != NULL) { switch (vhpi_get_prefix_kind(obj)) { case vhpiSigDeclK: case vhpiPortDeclK: // Signals have extra word for offset *dims = base + 2*sizeof(int64_t); break; default: *dims = base + sizeof(int64_t); break; } } } static int vhpi_count_subsignals(rt_model_t *m, rt_scope_t *s) { assert(is_signal_scope(s)); int count = s->signals.count; for (int i = 0; i < s->children.count; i++) count += vhpi_count_subsignals(m, s->children.items[i]); return count; } static void vhpi_watch_scope(rt_model_t *m, rt_scope_t *s, rt_watch_t *w) { assert(is_signal_scope(s)); for (int i = 0; i < s->signals.count; i++) model_set_event_cb(m, s->signals.items[i], w); for (int i = 0; i < s->children.count; i++) vhpi_watch_scope(m, s->children.items[i], w); } static vhpiStringT vhpi_get_case_name(c_vhpiObject *obj) { c_abstractDecl *ad = is_abstractDecl(obj); if (ad != NULL && ad->CaseName != NULL) return ad->CaseName; else if (ad != NULL) return (ad->CaseName = new_string(istr(tree_ident(ad->tree)))); c_name *n = is_name(obj); if (n != NULL && n->CaseName != NULL) return n->CaseName; else if (n != NULL) should_not_reach_here(); c_abstractRegion *r = is_abstractRegion(obj); if (r != NULL && r->CaseName != NULL) return r->CaseName; else if (r != NULL) { const char *qual = istr(tree_ident(r->tree)); if (is_design_unit(r->tree)) return (r->CaseName = new_string(strrchr(qual, '.') + 1)); else return (r->CaseName = new_string(qual)); } return NULL; } static vhpiStringT vhpi_get_name(c_vhpiObject *obj) { c_abstractDecl *ad = is_abstractDecl(obj); if (ad != NULL && ad->Name != NULL) return ad->Name; else if (ad != NULL) return (ad->Name = new_upper_string((char *)vhpi_get_case_name(obj))); c_name *n = is_name(obj); if (n != NULL && n->Name != NULL) return n->Name; else if (n != NULL) return (n->Name = new_upper_string((char *)vhpi_get_case_name(obj))); c_abstractRegion *r = is_abstractRegion(obj); if (r != NULL && r->Name != NULL) return r->Name; else if (r != NULL) return (r->Name = new_upper_string((char *)vhpi_get_case_name(obj))); c_tool *t = is_tool(obj); if (t != NULL) return (vhpiStringT)PACKAGE_NAME; return NULL; } static vhpiStringT vhpi_get_full_case_name(c_vhpiObject *obj) { c_abstractDecl *ad = is_abstractDecl(obj); if (ad != NULL && ad->FullCaseName != NULL) return ad->FullCaseName; else if (ad != NULL && ad->ImmRegion != NULL) { vhpiStringT prefix = vhpi_get_full_case_name(&ad->ImmRegion->object); const char *suffix = istr(tree_ident(ad->tree)); return (ad->FullCaseName = new_stringf("%s:%s", prefix, suffix)); } c_abstractRegion *r = is_abstractRegion(obj); if (r != NULL && r->FullCaseName != NULL) return r->FullCaseName; else if (r != NULL) { const char *suffix = istr(tree_ident(r->tree)); if (is_design_unit(r->tree)) return (r->FullCaseName = new_stringf("@%s", suffix)); else return (r->FullCaseName = new_stringf(":%s", suffix)); } c_name *n = is_name(obj); if (n != NULL && n->FullCaseName != NULL) return n->FullCaseName; else if (n != NULL) should_not_reach_here(); should_not_reach_here(); } static vhpiStringT vhpi_get_full_name(c_vhpiObject *obj) { c_abstractDecl *ad = is_abstractDecl(obj); if (ad != NULL && ad->FullName != NULL) return ad->FullName; else if (ad != NULL) { vhpiStringT fcn = vhpi_get_full_case_name(obj); return (ad->FullName = new_upper_string((char *)fcn)); } c_name *n = is_name(obj); if (n != NULL && n->FullName != NULL) return n->FullName; else if (n != NULL) { vhpiStringT fcn = vhpi_get_full_case_name(obj); return (n->FullName = new_upper_string((char *)fcn)); } c_abstractRegion *r = is_abstractRegion(obj); if (r != NULL && r->FullName != NULL) return r->FullName; else if (r != NULL) { vhpiStringT fcn = vhpi_get_full_case_name(obj); return (r->Name = new_upper_string((char *)fcn)); } should_not_reach_here(); } static bool vhpi_name_cmp(c_vhpiObject *obj, const char *str) { return strcasecmp((char *)vhpi_get_case_name(obj), str) == 0; } //////////////////////////////////////////////////////////////////////////////// // Public API DLLEXPORT int vhpi_release_handle(vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("handle=%s", handle_pp(handle)); vhpi_context_t *c = vhpi_context(); handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) { vhpi_error(vhpiError, NULL, "invalid handle %p", handle); return 1; } else if (slot->kind == HANDLE_INTERNAL) { vhpi_error(vhpiError, &(slot->obj->loc), "cannot release this handle as " "it is owned by the system"); return 1; } drop_handle(c, handle); return 0; } DLLEXPORT int vhpi_compare_handles(vhpiHandleT handle1, vhpiHandleT handle2) { vhpi_clear_error(); VHPI_TRACE("vhpi_compare_handles handle1=%p handle2=%p", handle1, handle2); if (handle1 == handle2) return true; vhpi_context_t *c = vhpi_context(); handle_slot_t *slot1 = decode_handle(c, handle1); handle_slot_t *slot2 = decode_handle(c, handle2); return slot1 != NULL && slot2 != NULL && slot1->obj == slot2->obj; } DLLEXPORT vhpiHandleT vhpi_register_cb(vhpiCbDataT *cb_data_p, int32_t flags) { vhpi_clear_error(); VHPI_TRACE("cb_datap_p=%s flags=%x", cb_data_pp(cb_data_p), flags); rt_model_t *m = vhpi_context()->model; switch (cb_data_p->reason) { case vhpiCbStartOfSimulation: case vhpiCbEndOfSimulation: case vhpiCbStartOfInitialization: case vhpiCbEndOfInitialization: case vhpiCbNextTimeStep: case vhpiCbRepNextTimeStep: case vhpiCbStartOfNextCycle: case vhpiCbRepStartOfNextCycle: case vhpiCbEndOfTimeStep: case vhpiCbRepEndOfTimeStep: case vhpiCbEndOfProcesses: case vhpiCbRepEndOfProcesses: case vhpiCbLastKnownDeltaCycle: case vhpiCbRepLastKnownDeltaCycle: { c_callback *cb = recyle_object(sizeof(c_callback), vhpiCallbackK); init_callback(cb, cb_data_p, flags); if (cb->data.obj != NULL) { vhpi_error(vhpiWarning, NULL, "ignoring non-NULL obj field for %s", vhpi_cb_reason_str(cb_data_p->reason)); cb->data.obj = NULL; } if (cb->data.time != NULL) { vhpi_error(vhpiWarning, NULL, "ignoring non-NULL time field for %s", vhpi_cb_reason_str(cb_data_p->reason)); cb->data.time = NULL; } if (cb->data.value != NULL) { vhpi_error(vhpiWarning, NULL, "ignoring non-NULL value field for " "%s", vhpi_cb_reason_str(cb_data_p->reason)); cb->data.value = NULL; } cb->handle = internal_handle_for(&(cb->refcounted.object)); APUSH(vhpi_context()->callbacks, cb->handle); if (flags & vhpiReturnCb) return user_handle_for(&(cb->refcounted.object)); else return NULL; } case vhpiCbAfterDelay: { if (cb_data_p->time == NULL) { vhpi_error(vhpiError, NULL, "missing time for vhpiCbAfterDelay"); return NULL; } c_callback *cb = recyle_object(sizeof(c_callback), vhpiCallbackK); init_callback(cb, cb_data_p, flags); const uint64_t now = model_now(m, NULL); const uint64_t when = vhpi_time_to_native(cb_data_p->time) + now; cb->handle = internal_handle_for(&(cb->refcounted.object)); model_set_timeout_cb(m, when, vhpi_global_cb, cb->handle); if (flags & vhpiReturnCb) return user_handle_for(&(cb->refcounted.object)); else return NULL; } case vhpiCbValueChange: { c_vhpiObject *obj = from_handle(cb_data_p->obj); if (obj == NULL) return NULL; rt_signal_t *signal = NULL; rt_scope_t *scope = NULL; c_prefixedName *pn; c_objDecl *decl; if ((pn = is_prefixedName(obj))) { if ((signal = vhpi_get_signal_prefixedName(pn)) == NULL) return NULL; } else if ((decl = is_objDecl(obj))) { if (decl->Type->homogeneous) { if ((signal = vhpi_get_signal_objDecl(decl)) == NULL) return NULL; } else if ((scope = vhpi_get_scope_objDecl(decl)) == NULL) return NULL; } else { vhpi_error(vhpiInternal, &(obj->loc), "cannot register value " "callback for kind %s", vhpi_class_str(obj->kind)); return NULL; } c_callback *cb = recyle_object(sizeof(c_callback), vhpiCallbackK); init_callback(cb, cb_data_p, flags); // LRM 08 section 23.29: [..] if the obj member of the callback // data structure contains a handle, the VHPI program may // release the handle after the vhpi_register_cb function // returns without affecting registration of the callback. cb->data.obj = internal_handle_for(obj); const int slots = scope != NULL ? vhpi_count_subsignals(m, scope) : 1; cb->handle = internal_handle_for(&(cb->refcounted.object)); cb->watch = watch_new(m, vhpi_signal_event_cb, cb->handle, WATCH_EVENT, slots); if (signal != NULL) cb->watch = model_set_event_cb(m, signal, cb->watch); else vhpi_watch_scope(m, scope, cb->watch); if (flags & vhpiReturnCb) return user_handle_for(&(cb->refcounted.object)); else return NULL; } default: vhpi_error(vhpiInternal, NULL, "unsupported reason %s", vhpi_cb_reason_str(cb_data_p->reason)); return NULL; } } DLLEXPORT int vhpi_remove_cb(vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("handle=%s", handle_pp(handle)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return 1; c_callback *cb = cast_callback(obj); if (cb == NULL) return 1; vhpi_context_t *c = vhpi_context(); if (cb->Reason == vhpiCbValueChange) { watch_free(c->model, cb->watch); cb->watch = NULL; drop_handle(c, cb->data.obj); } cb->State = vhpiMature; drop_handle(c, cb->handle); // Internal handle drop_handle(c, handle); // User handle return 0; } DLLEXPORT int vhpi_disable_cb(vhpiHandleT cb_obj) { vhpi_clear_error(); VHPI_TRACE("cb_obj=%s", handle_pp(cb_obj)); c_vhpiObject *obj = from_handle(cb_obj); if (obj == NULL) return 1; c_callback *cb = cast_callback(obj); if (cb == NULL) return 1; if (cb->State != vhpiEnable) { vhpi_error(vhpiWarning, &(obj->loc), "callback must be enabled in order to disable it"); return 1; } cb->State = vhpiDisable; return 0; } DLLEXPORT int vhpi_enable_cb(vhpiHandleT cb_obj) { vhpi_clear_error(); VHPI_TRACE("cb_obj=%s", handle_pp(cb_obj)); c_vhpiObject *obj = from_handle(cb_obj); if (obj == NULL) return 1; c_callback *cb = cast_callback(obj); if (cb == NULL) return 1; if (cb->State != vhpiDisable) { vhpi_error(vhpiWarning, &(obj->loc), "callback must be disabled in order to enable it"); return 1; } cb->State = vhpiEnable; return 0; } DLLEXPORT int vhpi_get_cb_info(vhpiHandleT object, vhpiCbDataT *cb_data_p) { vhpi_clear_error(); VHPI_TRACE("object=%s", handle_pp(object)); c_vhpiObject *obj = from_handle(object); if (obj == NULL) return 1; c_callback *cb = cast_callback(obj); if (cb == NULL) return 1; *cb_data_p = cb->data; return 0; } DLLEXPORT vhpiHandleT vhpi_handle(vhpiOneToOneT type, vhpiHandleT referenceHandle) { vhpi_clear_error(); VHPI_TRACE("type=%s referenceHandle=%s", vhpi_one_to_one_str(type), handle_pp(referenceHandle)); switch (type) { case vhpiRootInst: { c_rootInst *root = vhpi_context()->root; if (root == NULL) { vhpi_error(vhpiError, NULL, "cannot get root instance before " "simulation has started"); return NULL; } return user_handle_for(&root->designInstUnit.region.object); } case vhpiTool: return user_handle_for(&(vhpi_context()->tool->object)); default: break; } c_vhpiObject *obj = from_handle(referenceHandle); if (obj == NULL) return NULL; switch (type) { case vhpiBaseType: { c_typeDecl *td = is_typeDecl(obj); if (td != NULL) { td = td->BaseType ?: td; return user_handle_for(&(td->decl.object)); } c_objDecl *od = is_objDecl(obj); if (od != NULL) { td = od->Type->BaseType ?: od->Type; return user_handle_for(&(td->decl.object)); } c_expr *e = is_expr(obj); if (e != NULL) { td = e->Type->BaseType ?: e->Type; return user_handle_for(&(td->decl.object)); } c_enumLiteral *el = is_enumLiteral(obj); if (el != NULL) { td = el->Type->scalar.typeDecl.BaseType ?: &(el->Type->scalar.typeDecl); return user_handle_for(&(td->decl.object)); } c_elemDecl *ed = is_elemDecl(obj); if (ed != NULL) { td = ed->Type->BaseType ?: ed->Type; return user_handle_for(&(td->decl.object)); } } break; case vhpiType: case DEPRECATED_vhpiSubtype: { c_objDecl *od = is_objDecl(obj); if (od != NULL) return user_handle_for(&(od->Type->decl.object)); c_elemDecl *ed = is_elemDecl(obj); if (ed != NULL) return user_handle_for(&(ed->Type->decl.object)); c_expr *e = is_expr(obj); if (e != NULL) return user_handle_for(&(e->Type->decl.object)); } break; case vhpiElemType: { c_arrayTypeDecl *a = is_arrayTypeDecl(obj); if (a != NULL) return user_handle_for(&(a->ElemType->decl.object)); } break; case vhpiValType: { c_accessTypeDecl *atd = is_accessTypeDecl(obj); if (atd != NULL && atd->ValType == NULL) return NULL; // Access to incomplete type else if (atd != NULL) return user_handle_for(&(atd->ValType->decl.object)); c_fileTypeDecl *ftd = is_fileTypeDecl(obj); if (ftd != NULL) return user_handle_for(&(ftd->ValType->decl.object)); } break; case vhpiDesignUnit: { c_designInstUnit *iu = cast_designInstUnit(obj); if (iu == NULL) return NULL; if (iu->DesignUnit == NULL) return NULL; // Unbound instance return user_handle_for(&(iu->DesignUnit->region.object)); } case vhpiPrimaryUnit: { c_secondaryUnit *su = cast_secondaryUnit(obj); if (su == NULL) return NULL; return user_handle_for(&(su->PrimaryUnit->region.object)); } case vhpiPrefix: { c_prefixedName *pn = cast_prefixedName(obj); if (pn == NULL) return NULL; return user_handle_for(pn->Prefix); } case vhpiSuffix: { c_selectedName *sn = cast_selectedName(obj); if (sn == NULL) return NULL; return user_handle_for(&(sn->Suffix->decl.object)); } case vhpiParamDecl: { c_forGenerate *g = cast_forGenerate(obj); if (g == NULL) return NULL; return user_handle_for(&(g->ParamDecl->objDecl.decl.object)); } case DEPRECATED_vhpiReturnTypeMark: case DEPRECATED_vhpiName: case DEPRECATED_vhpiTypeMark: case DEPRECATED_vhpiDecl: vhpi_error(vhpiError, &(obj->loc), "relationship %s is deprecated and " "not implemented in vhpi_handle", vhpi_one_to_one_str(type)); return NULL; default: vhpi_error(vhpiInternal, &(obj->loc), "relationship %s not supported in " "vhpi_handle", vhpi_one_to_one_str(type)); return NULL; } vhpi_error(vhpiError, &(obj->loc), "invalid relationship %s for handle %s", vhpi_one_to_one_str(type), handle_pp(referenceHandle)); return NULL; } DLLEXPORT vhpiHandleT vhpi_handle_by_name(const char *name, vhpiHandleT scope) { vhpi_clear_error(); VHPI_TRACE("name=%s scope=%p", name, scope); char *copy LOCAL = xstrdup(name), *saveptr; char *elem = strtok_r(copy, ":.", &saveptr); c_vhpiObject *where = NULL; if (scope == NULL) { vhpi_context_t *c = vhpi_context(); if (vhpi_name_cmp(&c->root->designInstUnit.region.object, elem)) where = &(c->root->designInstUnit.region.object); else { for (int i = 0; i < c->packages.count; i++) { if (vhpi_name_cmp(c->packages.items[i], elem)) { where = c->packages.items[i]; break; } } if (where == NULL) { vhpi_error(vhpiError, NULL, "no design unit instance named %s", elem); return NULL; } } elem = strtok_r(NULL, ":.", &saveptr); } else if ((where = from_handle(scope)) == NULL) return NULL; for (; elem != NULL; elem = strtok_r(NULL, ":.", &saveptr)) { bool found = false; c_iterator it = {}; c_abstractRegion *region = is_abstractRegion(where); if (region != NULL) { vhpiObjectListT *decls = expand_lazy_list(where, &(region->decls)); for (int i = 0; i < decls->count; i++) { if (vhpi_name_cmp(decls->items[i], elem)) { where = decls->items[i]; found = true; break; } } if (!found) { vhpiObjectListT *stmts = expand_lazy_list(where, &(region->stmts)); for (int i = 0; i < stmts->count; i++) { c_abstractRegion *r = is_abstractRegion(stmts->items[i]); if (r != NULL && vhpi_name_cmp(stmts->items[i], elem)) { where = &(r->object); found = true; break; } } } } else if (init_iterator(&it, vhpiSelectedNames, where)) { for (int i = 0; i < it.list->count; i++) { c_selectedName *sn = is_selectedName(it.list->items[i]); assert(sn != NULL); if (vhpi_name_cmp(&sn->Suffix->decl.object, elem)) { where = &(sn->prefixedName.name.expr.object); found = true; break; } } } if (!found) { vhpi_error(vhpiError, &(where->loc), "suffix %s not found in prefix " "of class %s", elem, vhpi_class_str(where->kind)); return NULL; } } return user_handle_for(where); } DLLEXPORT vhpiHandleT vhpi_handle_by_index(vhpiOneToManyT itRel, vhpiHandleT parent, int32_t index) { vhpi_clear_error(); VHPI_TRACE("itRel=%s parent=%s index=%d", vhpi_one_to_many_str(itRel), handle_pp(parent), index); c_vhpiObject *obj = NULL; if (parent != NULL && (obj = from_handle(parent)) == NULL) return NULL; c_iterator it = {}; if (!init_iterator(&it, itRel, obj)) { vhpi_error(vhpiError, obj ? &(obj->loc) : NULL, "relation %s not supported for parent %s", vhpi_one_to_many_str(itRel), handle_pp(parent)); return NULL; } if (it.single ? index : index >= it.list->count) { vhpi_error(vhpiError, obj ? &(obj->loc) : NULL, "invalid %s index %d", vhpi_one_to_many_str(itRel), index); return NULL; } return user_handle_for(it.single ?: it.list->items[index]); } DLLEXPORT vhpiHandleT vhpi_iterator(vhpiOneToManyT type, vhpiHandleT handle) { VHPI_TRACE("type=%s handle=%s", vhpi_one_to_many_str(type), handle_pp(handle)); c_vhpiObject *obj = NULL; if (handle != NULL && (obj = from_handle(handle)) == NULL) return NULL; c_iterator *it = recyle_object(sizeof(c_iterator), vhpiIteratorK); if (!init_iterator(it, type, obj)) { vhpi_error(vhpiError, obj ? &(obj->loc) : NULL, "relation %s not supported for handle %s", vhpi_one_to_many_str(type), handle_pp(handle)); return NULL; } return user_handle_for(&(it->refcounted.object)); } DLLEXPORT vhpiHandleT vhpi_scan(vhpiHandleT iterator) { VHPI_TRACE("handle=%s", handle_pp(iterator)); c_vhpiObject *obj = from_handle(iterator); if (obj == NULL) return NULL; c_iterator *it = cast_iterator(obj); if (it == NULL) return NULL; if (it->single != NULL && it->pos++ > 0) goto end_of_iterator; else if (it->single != NULL) return user_handle_for(it->single); while (it->pos < it->list->count) { c_vhpiObject *obj = it->list->items[it->pos++]; if (it->filter == NULL || (*it->filter)(obj) != NULL) return user_handle_for(obj); } end_of_iterator: // According to LRM 2008 section 23.33 the handle is released by // vhpi_scan when it reaches the end of the list drop_handle(vhpi_context(), iterator); return NULL; } DLLEXPORT vhpiIntT vhpi_get(vhpiIntPropertyT property, vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("property=%s handle=%s", vhpi_property_str(property), handle_pp(handle)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return vhpiUndefined; switch (property) { case vhpiStateP: { c_callback *cb = cast_callback(obj); if (cb == NULL) goto missing_property; return cb->State; } case vhpiKindP: return obj->kind; case vhpiIsCompositeP: case vhpiIsScalarP: { c_typeDecl *td = is_typeDecl(obj); if (td == NULL) goto missing_property; if (property == vhpiIsCompositeP) return td->IsComposite; else return td->IsScalar; } case vhpiSizeP: { c_typeDecl *td = NULL; c_name *n = is_name(obj); if (n != NULL) td = n->expr.Type; else { c_objDecl *decl = is_objDecl(obj); if (decl != NULL) td = decl->Type; } if (td == NULL) goto missing_property; assert(td->numElems >= 0); return td->numElems; } case vhpiArgcP: { c_tool *t = cast_tool(obj); if (t == NULL) return vhpiUndefined; return t->argv.count; } case vhpiNumDimensionsP: { c_arrayTypeDecl *a = is_arrayTypeDecl(obj); if (a != NULL) return a->NumDimensions; c_subTypeDecl *s = is_subTypeDecl(obj); if (s != NULL && s->typeDecl.BaseType->decl.object.kind == vhpiArrayTypeDeclK) return s->Constraints.count; goto missing_property; } case vhpiIsUnconstrainedP: { c_range *r = is_range(obj); if (r != NULL) return r->IsUnconstrained; c_typeDecl *td = is_typeDecl(obj); if (td != NULL) return td->IsUnconstrained; goto missing_property; } case vhpiLeftBoundP: case vhpiRightBoundP: { c_intRange *ir = cast_intRange(obj); if (ir == NULL) goto missing_property; if (ir->range.IsUnconstrained) { vhpi_error(vhpiError, &(obj->loc), "cannot get bounds of " "unconstrained range"); return vhpiUndefined; } else if (property == vhpiLeftBoundP) return ir->LeftBound; else return ir->RightBound; } case vhpiIsUpP: case vhpiIsNullP: case vhpiIsDiscreteP: { c_range *r = is_range(obj); if (r == NULL) goto missing_property; if (property == vhpiIsUpP) return r->IsUp; else if (property == vhpiIsNullP) return r->IsNull; else return r->IsDiscrete; } case vhpiStaticnessP: { c_objDecl *decl = is_objDecl(obj); if (decl != NULL) return decl->Staticness; c_enumLiteral *el = is_enumLiteral(obj); if (el != NULL) return vhpiGloballyStatic; c_expr *e = cast_expr(obj); if (e == NULL) goto missing_property; return e->Staticness; } case vhpiBaseIndexP: { c_indexedName *in = cast_indexedName(obj); if (in == NULL) return vhpiUndefined; return in->BaseIndex; } case vhpiNumLiteralsP: { c_enumTypeDecl *etd = cast_enumTypeDecl(obj); if (etd == NULL) goto missing_property; return expand_lazy_list(obj, &(etd->EnumLiterals))->count; } case vhpiPositionP: { c_elemDecl *ed = is_elemDecl(obj); if (ed != NULL) return ed->Position; c_enumLiteral *el = cast_enumLiteral(obj); if (el == NULL) goto missing_property; return el->Position; } case vhpiNumFieldsP: { c_recordTypeDecl *rtd = cast_recordTypeDecl(obj); if (rtd == NULL) goto missing_property; return expand_lazy_list(obj, &rtd->RecordElems)->count; } case vhpiModeP: { c_genericDecl *gd = is_genericDecl(obj); if (gd != NULL) return gd->Mode; c_portDecl *pd = is_portDecl(obj); if (pd != NULL) return pd->Mode; goto missing_property; } case vhpiIsLocalP: { c_genericDecl *gd = is_genericDecl(obj); if (gd == NULL) goto missing_property; return gd->IsLocal; } case vhpiIsGuardedP: { c_blockStmt *bs = is_blockStmt(obj); if (bs == NULL) goto missing_property; return bs->IsGuarded; } case vhpiIsSeqStmtP: { c_stmt *s = is_stmt(obj); if (s == NULL) goto missing_property; return s->IsSeqStmt; } case vhpiGenerateIndexP: { c_forGenerate *g = is_forGenerate(obj); if (g == NULL) goto missing_property; return g->GenerateIndex; } default: vhpi_error(vhpiFailure, &(obj->loc), "unsupported property %s in " "vhpi_get", vhpi_property_str(property)); return vhpiUndefined; } missing_property: vhpi_error(vhpiError, &(obj->loc), "object does not have property %s", vhpi_property_str(property)); return vhpiUndefined; } DLLEXPORT const vhpiCharT *vhpi_get_str(vhpiStrPropertyT property, vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("property=%s handle=%s", vhpi_property_str(property), handle_pp(handle)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return NULL; switch (property) { case vhpiKindStrP: return (vhpiCharT *)vhpi_class_str(obj->kind); case vhpiNameP: { vhpiStringT str = vhpi_get_name(obj); if (str != NULL) return str; goto missing_property; } case vhpiCaseNameP: { vhpiStringT str = vhpi_get_case_name(obj); if (str != NULL) return str; goto missing_property; } case vhpiFullNameP: { vhpiStringT str = vhpi_get_full_name(obj); if (str != NULL) return str; goto missing_property; } case vhpiFullCaseNameP: { vhpiStringT str = vhpi_get_full_case_name(obj); if (str != NULL) return str; goto missing_property; } case vhpiToolVersionP: { c_tool *t = is_tool(obj); if (t != NULL) return (vhpiCharT *)PACKAGE_VERSION; goto missing_property; } case vhpiUnitNameP: { c_designUnit *du = is_designUnit(obj); if (du != NULL) return du->UnitName; goto missing_property; } case vhpiStrValP: { c_argv *arg = is_argv(obj); if (arg != NULL) return arg->StrVal; c_enumLiteral *el = is_enumLiteral(obj); if (el != NULL) return vhpi_get_name(obj); goto missing_property; } case vhpiLabelNameP: { c_stmt *s = is_stmt(obj); if (s != NULL) return s->LabelName; goto missing_property; } case vhpiFileNameP: { c_abstractRegion *region = is_abstractRegion(obj); if (region != NULL) return (vhpiCharT *)loc_file_str(&(region->object.loc)); c_abstractDecl *d = is_abstractDecl(obj); if (d != NULL) return (vhpiCharT *)loc_file_str(&(d->object.loc)); goto missing_property; } default: vhpi_error(vhpiFailure, &(obj->loc), "unsupported property %s in " "vhpi_get_str", vhpi_property_str(property)); return NULL; } missing_property: vhpi_error(vhpiError, &(obj->loc), "object does not have string property %s", vhpi_property_str(property)); return NULL; } DLLEXPORT vhpiRealT vhpi_get_real(vhpiRealPropertyT property, vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("property=%s handle=%s", vhpi_property_str(property), handle_pp(handle)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return NAN; switch (property) { case vhpiFloatLeftBoundP: case vhpiFloatRightBoundP: { c_floatRange *fr = cast_floatRange(obj); if (fr == NULL) return NAN; if (property == vhpiFloatLeftBoundP) return fr->FloatLeftBound; else return fr->FloatRightBound; } default: vhpi_error(vhpiError, &(obj->loc), "invalid property %s in vhpi_get_real", vhpi_property_str(property)); } return NAN; } DLLEXPORT vhpiPhysT vhpi_get_phys(vhpiPhysPropertyT property, vhpiHandleT handle) { vhpi_clear_error(); VHPI_TRACE("property=%s handle=%s", vhpi_property_str(property), handle_pp(handle)); const vhpiPhysT invalid = { 0, 0 }; if (property == vhpiResolutionLimitP) return vhpiFS; c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return invalid; switch (property) { case vhpiPhysValP: { c_objDecl *decl = cast_objDecl(obj); if (decl == NULL) return invalid; c_typeDecl *t = decl->Type->BaseType ?: decl->Type; c_physTypeDecl *td = cast_physTypeDecl(&(t->decl.object)); if (td == NULL) return invalid; rt_signal_t *signal = vhpi_get_signal_objDecl(decl); if (signal == NULL) return invalid; uint64_t value; signal_expand(signal, &value, 1); return vhpi_phys_from_native(value); } case vhpiPhysLeftBoundP: case vhpiPhysRightBoundP: { c_physRange *pr = cast_physRange(obj); if (pr == NULL) return invalid; if (property == vhpiPhysLeftBoundP) return pr->PhysLeftBound; else return pr->PhysRightBound; } default: vhpi_error(vhpiError, &(obj->loc), "invalid property %s in vhpi_get_phys", vhpi_property_str(property)); } return invalid; } static bool vhpi_scalar_fits_format(vhpiFormatT format, int size) { // Allow reading integral scalar values with a wider type switch (format) { case vhpiLogicVal: case vhpiSmallEnumVal: case vhpiCharVal: return size == 1; case vhpiEnumVal: return size <= 4; case vhpiIntVal: return size <= 4; case vhpiLongIntVal: return size <= 8; default: return false; } } DLLEXPORT int vhpi_get_value(vhpiHandleT expr, vhpiValueT *value_p) { vhpi_clear_error(); VHPI_TRACE("expr=%s value_p=%p", handle_pp(expr), value_p); c_vhpiObject *obj = from_handle(expr); if (obj == NULL) return -1; int offset = 0; c_objDecl *decl = NULL; c_typeDecl *td; c_prefixedName *pn = is_prefixedName(obj); if (pn != NULL) { td = pn->name.expr.Type; c_indexedName *in = is_indexedName(obj); if (in) offset = in->offset; } else { decl = cast_objDecl(obj); if (decl == NULL) return 1; td = decl->Type; } if (td->format == (vhpiFormatT)-1) { vhpi_error(vhpiInternal, &(obj->loc), "type %s not supported in " "vhpi_get_value", type_pp(td->type)); return -1; } int size = td->size, num_elems = td->numElems; const unsigned char *value = NULL; switch (vhpi_get_prefix_kind(obj)) { case vhpiGenericDeclK: case vhpiConstDeclK: { if (td->wrapped) { ffi_dim_t *dims; vhpi_get_uarray(obj, (void **)&value, &dims); assert(num_elems == ffi_array_length(dims[0].length)); } else if ((value = vhpi_get_value_ptr(obj)) == NULL) return -1; } break; case vhpiSigDeclK: case vhpiPortDeclK: { rt_signal_t *signal; if (pn != NULL) signal = vhpi_get_signal_prefixedName(pn); else signal = vhpi_get_signal_objDecl(decl); if (signal == NULL) return -1; value = signal_value(signal); size = signal_size(signal); } break; case vhpiConstParamDeclK: case vhpiVarParamDeclK: { vhpi_context_t *c = vhpi_context(); assert(c->args != NULL); c_interfaceDecl *id = is_interfaceDecl(obj); assert(id != NULL); if (td->wrapped) { value = c->args[id->argslot].pointer; num_elems = ffi_array_length(c->args[id->argslot + 2].integer); } else if (td->IsComposite) { value = c->args[id->argslot].pointer; num_elems = td->numElems; } else value = (void *)&(c->args[id->argslot]); } break; default: vhpi_error(vhpiError, &(obj->loc), "class kind %s cannot be used with " "vhpi_get_value", vhpi_class_str(obj->kind)); return -1; } assert(td->IsComposite || num_elems == 1); assert(num_elems >= 0); if (value_p->format == vhpiObjTypeVal) value_p->format = td->format; else if (value_p->format == vhpiBinStrVal && td->map_str != NULL) value_p->format = vhpiBinStrVal; else if (value_p->format != td->format && !vhpi_scalar_fits_format(value_p->format, size)) { vhpi_error(vhpiError, &(obj->loc), "invalid format %s for object %s: " "expecting %s", vhpi_format_str(value_p->format), pn ? pn->name.Name : decl->decl.Name, vhpi_format_str(td->format)); return -1; } int64_t scalar = 0; switch (td->format) { case vhpiLogicVal: case vhpiSmallEnumVal: case vhpiCharVal: scalar = value[offset]; break; case vhpiEnumVal: #define READ_ENUM(type) scalar = ((const type *)value)[offset] FOR_ALL_SIZES(size, READ_ENUM); break; case vhpiIntVal: scalar = ((const vhpiIntT *)value)[offset]; break; case vhpiLongIntVal: scalar = ((const vhpiLongIntT *)value)[offset]; break; default: break; } switch (value_p->format) { case vhpiLogicVal: value_p->numElems = num_elems; value_p->value.enumv = scalar; return 0; case vhpiSmallEnumVal: value_p->numElems = num_elems; value_p->value.smallenumv = scalar; return 0; case vhpiEnumVal: value_p->numElems = num_elems; value_p->value.enumv = scalar; return 0; case vhpiCharVal: value_p->numElems = num_elems; value_p->value.ch = scalar; return 0; case vhpiIntVal: value_p->numElems = num_elems; value_p->value.intg = scalar; return 0; case vhpiLongIntVal: value_p->numElems = num_elems; value_p->value.longintg = scalar; return 0; case vhpiRealVal: value_p->numElems = num_elems; value_p->value.real = ((const double *)value)[offset]; return 0; case vhpiLogicVecVal: { const int max = value_p->bufSize / sizeof(vhpiEnumT); if (max < num_elems) return num_elems * sizeof(vhpiEnumT); value_p->numElems = num_elems; const uint8_t *p = value + offset; for (int i = 0; i < value_p->numElems; i++) value_p->value.enumvs[i] = *p++; return 0; } case vhpiSmallEnumVecVal: { const int max = value_p->bufSize / sizeof(vhpiSmallEnumT); if (max < num_elems) return num_elems * sizeof(vhpiSmallEnumT); value_p->numElems = num_elems; const uint8_t *p = value + offset; for (int i = 0; i < value_p->numElems; i++) value_p->value.smallenumvs[i] = *p++; return 0; } case vhpiEnumVecVal: { const int max = value_p->bufSize / sizeof(vhpiEnumT); if (max < num_elems) return num_elems * sizeof(vhpiEnumT); value_p->numElems = num_elems; #define READ_ENUMV(type) do { \ const type *p = ((const type *)value) + offset; \ for (int i = 0; i < value_p->numElems; i++) \ value_p->value.enumvs[i] = *p++; \ } while (0) FOR_ALL_SIZES(size, READ_ENUMV); return 0; } case vhpiBinStrVal: case vhpiStrVal: { if (value_p->bufSize < num_elems + 1) return num_elems + 1; value_p->numElems = num_elems; const vhpiCharT *p = value + offset; for (int i = 0; i < value_p->numElems; i++) { if (value_p->format == vhpiBinStrVal) value_p->value.str[i] = td->map_str[*p++]; else value_p->value.str[i] = *p++; } value_p->value.str[value_p->numElems] = '\0'; return 0; } case vhpiRealVecVal: { if (value_p->bufSize / sizeof(vhpiRealT) < num_elems) return num_elems * sizeof(vhpiRealT); value_p->numElems = num_elems; const double *p = ((const double *)value) + offset; for (int i = 0; i < value_p->numElems; i++) value_p->value.reals[i] = *p++; return 0; } case vhpiIntVecVal: { if (value_p->bufSize / sizeof(vhpiIntT) < num_elems) return num_elems * sizeof(vhpiIntT); value_p->numElems = num_elems; #define READ_INTGS(type) do { \ const type *p = ((const type *)value) + offset; \ for (int i = 0; i < value_p->numElems; i++) \ value_p->value.intgs[i] = *p++; \ } while (0) FOR_ALL_SIZES(size, READ_INTGS); return 0; } default: vhpi_error(vhpiError, &(obj->loc), "unsupported format %s", vhpi_format_str(value_p->format)); return -1; } } DLLEXPORT int vhpi_put_value(vhpiHandleT handle, vhpiValueT *value_p, vhpiPutValueModeT mode) { // See LRM 2008 section 22.5.3 for discussion of semantics vhpi_clear_error(); VHPI_TRACE("handle=%s value_p=%p mode=%s", handle_pp(handle), value_p, vhpi_put_value_mode_str(mode)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return 1; int offset = 0; rt_signal_t *signal = NULL; c_typeDecl *td = NULL; c_prefixedName *pn = NULL; c_funcDecl *func = NULL; c_varParamDecl *vpd = NULL; if ((pn = is_prefixedName(obj))) { if ((signal = vhpi_get_signal_prefixedName(pn)) == NULL) return 1; c_indexedName *in = is_indexedName(obj); if (in) offset = in->offset; td = pn->name.expr.Type; } else if ((func = is_funcDecl(obj))) td = func->ReturnType; else if ((vpd = is_varParamDecl(obj))) td = vpd->interface.objDecl.Type; else { c_objDecl *decl = cast_objDecl(obj); if (decl == NULL) return 1; switch (obj->kind) { case vhpiSigDeclK: case vhpiPortDeclK: if ((signal = vhpi_get_signal_objDecl(decl)) == NULL) return 1; break; default: break; } td = decl->Type; } if (mode == vhpiSizeConstraint) { if (func == NULL) { vhpi_error(vhpiError, &(obj->loc), "vhpiSizeConstraint is only valid " "for function result"); return 1; } else if (!func->ReturnType->wrapped) { vhpi_error(vhpiError, &(obj->loc), "function return type does not " "have a size constraint"); return 1; } vhpi_context_t *c = vhpi_context(); c->args[0].pointer = tlab_alloc(c->tlab, value_p->numElems * td->size); c->args[1].integer = 1; c->args[2].integer = value_p->numElems; return 0; } void *ext LOCAL = NULL, *ptr = NULL; union { uint8_t uint8_t_val; uint16_t uint16_t_val; uint32_t uint32_t_val; uint64_t uint64_t_val; int64_t int64_t_val; double double_val; } scalar = { .uint64_t_val = 0 }; int num_elems = 0; switch (value_p->format) { case vhpiLogicVal: num_elems = 1; scalar.uint8_t_val = value_p->value.enumv; ptr = &scalar; break; case vhpiSmallEnumVal: num_elems = 1; scalar.uint8_t_val = value_p->value.smallenumv; ptr = &scalar; break; case vhpiEnumVal: num_elems = 1; ptr = &scalar; #define STORE_ENUM(type) do { \ scalar.type##_val = value_p->value.enumv; \ } while (0) FOR_ALL_SIZES(td->size, STORE_ENUM); break; case vhpiCharVal: num_elems = 1; scalar.uint8_t_val = value_p->value.ch; ptr = &scalar; break; case vhpiIntVal: num_elems = 1; scalar.int64_t_val = value_p->value.intg; ptr = &scalar; // Assume little endian break; case vhpiRealVal: num_elems = 1; scalar.double_val = value_p->value.real; ptr = &scalar; break; case vhpiLogicVecVal: num_elems = value_p->bufSize / sizeof(vhpiEnumT); ext = ptr = xmalloc(num_elems); for (int i = 0; i < num_elems; i++) ((uint8_t *)ext)[i] = value_p->value.enumvs[i]; break; case vhpiSmallEnumVecVal: num_elems = value_p->bufSize / sizeof(vhpiSmallEnumT); ext = ptr = xmalloc(num_elems); for (int i = 0; i < num_elems; i++) ((uint8_t *)ext)[i] = value_p->value.smallenumvs[i]; break; case vhpiEnumVecVal: { num_elems = value_p->bufSize / sizeof(vhpiEnumT); ext = ptr = xmalloc_array(num_elems, td->size); #define STORE_ENUMV(type) do { \ for (int i = 0; i < num_elems; i++) \ ((type *)ext)[i] = value_p->value.enumvs[i]; \ } while (0) FOR_ALL_SIZES(td->size, STORE_ENUMV); break; } case vhpiStrVal: num_elems = value_p->bufSize - 1; ext = ptr = xmalloc(num_elems); for (int i = 0; i < num_elems; i++) ((vhpiCharT *)ext)[i] = value_p->value.str[i]; break; case vhpiRealVecVal: { num_elems = value_p->bufSize / sizeof(vhpiRealT); ext = ptr = xmalloc_array(num_elems, sizeof(double)); for (int i = 0; i < num_elems; i++) ((double *)ext)[i] = value_p->value.reals[i]; break; } case vhpiIntVecVal: { num_elems = value_p->bufSize / sizeof(vhpiIntT); ext = ptr = xmalloc_array(num_elems, sizeof(vhpiIntT)); #define STORE_INTGS(type) do { \ for (int i = 0; i < num_elems; i++) \ ((type *)ext)[i] = (int64_t)value_p->value.intgs[i]; \ } while (0) FOR_ALL_SIZES(td->size, STORE_INTGS); break; } default: vhpi_error(vhpiFailure, &(obj->loc), "value format %d not supported " "in vhpi_put_value", value_p->format); return 1; } if (signal != NULL) { rt_model_t *model = vhpi_context()->model; if (!model_can_create_delta(model)) { vhpi_error(vhpiError, &(obj->loc), "cannot create delta cycle " "during current simulation phase"); return 1; } else if (offset + num_elems > signal_width(signal)) { vhpi_error(vhpiError, &(obj->loc), "too many values (%d) for signal with %d elements", num_elems, signal_width(signal)); return 1; } switch (mode) { case vhpiForcePropagate: force_signal(model, signal, ptr, offset, num_elems); return 0; case vhpiDepositPropagate: deposit_signal(model, signal, ptr, offset, num_elems); return 0; case vhpiRelease: release_signal(model, signal, offset, signal_width(signal)); return 0; default: break; } } else if (func != NULL || vpd != NULL) { vhpi_context_t *c = vhpi_context(); assert(c->args != NULL); const int slot = vpd ? vpd->interface.argslot : 0; switch (mode) { case vhpiForce: case vhpiForcePropagate: case vhpiDeposit: case vhpiDepositPropagate: if (td->IsScalar && vpd == NULL) { c->args[slot].integer = scalar.uint64_t_val; // Function result return 0; } else if (td->IsScalar) { assert(td->size > 0 && td->size <= sizeof(uint64_t)); #define PUT_SCALAR(type) *(type *)c->args[slot].pointer = scalar.type##_val; FOR_ALL_SIZES(td->size, PUT_SCALAR); return 0; } else { const int64_t length = td->wrapped ? ffi_array_length(c->args[slot + 2].integer) : td->numElems; if (offset + num_elems > length) { vhpi_error(vhpiError, &(obj->loc), "too many values (%d) for " "object with %"PRIi64" elements", num_elems, length); return 1; } memcpy(c->args[slot].pointer + offset * td->size, ext, num_elems * td->size); return 0; } case vhpiRelease: return 0; // Specified to have no effect default: break; } } vhpi_error(vhpiFailure, &(obj->loc), "mode %s not supported in " "vhpi_put_value", vhpi_put_value_mode_str(mode)); return 1; } DLLEXPORT int vhpi_protected_call(vhpiHandleT varHdl, vhpiUserFctT userFct, void *userData) { VHPI_MISSING; } DLLEXPORT int vhpi_schedule_transaction(vhpiHandleT drivHdl, vhpiValueT *value_p, uint32_t numValues, vhpiTimeT *delayp, vhpiDelayModeT delayMode, vhpiTimeT *pulseRejp) { VHPI_MISSING; } DLLEXPORT int vhpi_format_value(const vhpiValueT *in_value_p, vhpiValueT *out_value_p) { VHPI_MISSING; } DLLEXPORT void vhpi_get_time(vhpiTimeT *time_p, long *cycles) { vhpi_clear_error(); VHPI_TRACE("time_p=%p cycles=%p", time_p, cycles); unsigned deltas; const uint64_t now = model_now(vhpi_context()->model, &deltas); if (time_p != NULL) { time_p->high = now >> 32; time_p->low = now & 0xffffffff; } if (cycles != NULL) *cycles = deltas; } DLLEXPORT int vhpi_get_next_time(vhpiTimeT *time_p) { vhpi_clear_error(); VHPI_TRACE("time_p=%p", time_p); const uint64_t next = model_next_time(vhpi_context()->model); time_p->high = next >> 32; time_p->low = next & 0xffffffff; return next == TIME_HIGH ? vhpiNoActivity : 0; } DLLEXPORT int vhpi_control(vhpiSimControlT command, ...) { vhpi_clear_error(); VHPI_TRACE("command=%d", command); switch (command) { case vhpiFinish: case vhpiStop: notef("VHPI plugin requested end of simulation"); model_stop(vhpi_context()->model); return 0; case vhpiReset: vhpi_error(vhpiFailure, NULL, "vhpiReset not supported"); return 1; default: vhpi_error(vhpiFailure, NULL, "unsupported command in vhpi_control"); return 1; } } DLLEXPORT vhpiHandleT vhpi_create(vhpiClassKindT kind, vhpiHandleT handle1, vhpiHandleT handle2) { VHPI_MISSING; } DLLEXPORT int vhpi_get_foreignf_info(vhpiHandleT handle, vhpiForeignDataT *foreignDatap) { VHPI_TRACE("handle=%s", handle_pp(handle)); c_vhpiObject *obj = from_handle(handle); if (obj == NULL) return 1; c_foreignf *f = cast_foreignf(obj); if (f == NULL) return 1; *foreignDatap = f->data; return 0; } DLLEXPORT vhpiHandleT vhpi_register_foreignf(vhpiForeignDataT *foreignDatap) { VHPI_TRACE("kind=%d libraryName=%s modelName=%s", foreignDatap->kind, foreignDatap->libraryName, foreignDatap->modelName); switch (foreignDatap->kind) { case vhpiFuncF: case vhpiProcF: { c_foreignf *f = new_object(sizeof(c_foreignf), vhpiForeignfK); f->data = *foreignDatap; // Make a defensive copy of the passed-in strings f->data.libraryName = (char *)new_string(foreignDatap->libraryName); f->data.modelName = (char *)new_string(foreignDatap->modelName); vhpi_context_t *c = vhpi_context(); APUSH(c->foreignfs, &(f->object)); return user_handle_for(&(f->object)); } default: vhpi_error(vhpiInternal, NULL, "foreign model kind not supported"); return NULL; } } DLLEXPORT size_t vhpi_get_data(int32_t id, void *dataLoc, size_t numBytes) { VHPI_MISSING; } DLLEXPORT size_t vhpi_put_data(int32_t id, void *dataLoc, size_t numBytes) { VHPI_MISSING; } //////////////////////////////////////////////////////////////////////////////// // Model construction #if 0 static c_literal *build_literal(tree_t t) { switch (tree_subkind(t)) { case L_INT: { c_intLiteral *l = new_object(sizeof(c_intLiteral), vhpiPhysLiteralK); return &(l->literal); } case L_PHYSICAL: { c_physLiteral *l = new_object(sizeof(c_literal), vhpiPhysLiteralK); return &(l->literal); } default: fatal_trace("cannot build VHPI object for literal kind %d", tree_subkind(t)); } } static c_expr *build_expr(tree_t t) { switch (tree_kind(t)) { case T_LITERAL: return &(build_literal(t)->expr); default: fatal_trace("cannot build VHPI expr for tree kind %s", tree_kind_str(tree_kind(t))); } } #endif static c_physRange *build_phys_range(tree_t t) { const int64_t left = assume_int(tree_left(t)); const int64_t right = assume_int(tree_right(t)); const range_kind_t dir = tree_subkind(t) == RANGE_TO; const bool null = dir == RANGE_TO ? left > right : right > left; c_physRange *pr = new_object(sizeof(c_physRange), vhpiPhysRangeK); init_range(&(pr->range), dir, null, true); pr->PhysLeftBound = vhpi_phys_from_native(left); pr->PhysRightBound = vhpi_phys_from_native(right); return pr; } static c_floatRange *build_float_range(tree_t r) { double left; if (!folded_real(tree_left(r), &left)) left = -INFINITY; double right; if (!folded_real(tree_right(r), &right)) right = +INFINITY; const range_kind_t dir = tree_subkind(r) == RANGE_TO; const bool null = dir == RANGE_TO ? left > right : right > left; c_floatRange *fr = new_object(sizeof(c_floatRange), vhpiFloatRangeK); init_range(&(fr->range), dir, null, true); fr->FloatLeftBound = left; fr->FloatRightBound = right; return fr; } static c_intRange *build_int_range(tree_t r, type_t parent, int dim, c_vhpiObject *obj) { range_kind_t dir = RANGE_TO; int64_t low, high, left = 1, right = 0; if (folded_bounds(r, &low, &high)) { dir = tree_subkind(r); left = (dir == RANGE_TO) ? low : high; right = (dir == RANGE_TO) ? high : low; } else { ffi_dim_t *bounds = NULL; if (obj != NULL) vhpi_get_uarray(obj, NULL, &bounds); else if (parent != NULL && !type_is_unconstrained(parent)) { // The type bounds are not known statically so use the variable // generated by lower_type_bounds_var jit_t *j = vhpi_context()->jit; assert(type_has_ident(parent)); ident_t id = type_ident(parent); jit_handle_t handle = jit_lazy_compile(j, ident_runtil(id, '.')); ffi_uarray_t *u = jit_get_frame_var(j, handle, id); assert(u != NULL); bounds = u->dims; } if (bounds == NULL) vhpi_error(vhpiInternal, tree_loc(r), "cannot get bounds for range"); else { dir = ffi_array_dir(bounds[dim].length); left = bounds[dim].left; right = ffi_array_right(bounds[dim].left, bounds[dim].length); } } const bool null = dir == RANGE_TO ? left > right : right > left; c_intRange *ir = new_object(sizeof(c_intRange), vhpiIntRangeK); init_range(&(ir->range), dir == RANGE_TO, null, true); ir->LeftBound = left; ir->RightBound = right; return ir; } static c_intRange *build_unconstrained(void) { c_intRange *ir = new_object(sizeof(c_intRange), vhpiIntRangeK); ir->range.IsUnconstrained = vhpiTrue; return ir; } static c_typeDecl *build_arrayTypeDecl(type_t type, tree_t decl, type_t parent, c_vhpiObject *obj, int nextdim) { c_arrayTypeDecl *td = new_object(sizeof(c_arrayTypeDecl), vhpiArrayTypeDeclK); init_compositeTypeDecl(&(td->composite), decl, type); td->NumDimensions = dimension_of(type); td->composite.typeDecl.wrapped = !type_const_bounds(type); type_t elem = type_elem(type); if (type_is_array(elem) && is_anonymous_subtype(elem)) { // Anonymous subtype may need to access parent type to // get non-constant bounds td->ElemType = build_arrayTypeDecl(elem, decl, parent, obj, nextdim + td->NumDimensions); } else if (obj == NULL) { c_vhpiObject *tobj = &(td->composite.typeDecl.decl.object); td->ElemType = cached_typeDecl(elem, tobj); } else td->ElemType = cached_typeDecl(elem, obj); td->composite.typeDecl.size = td->ElemType->size; vhpi_list_reserve(&td->Constraints, td->NumDimensions); if (type_is_unconstrained(type)) { for (int i = 0; i < td->NumDimensions; i++) { c_intRange *ir = build_unconstrained(); vhpi_list_add(&td->Constraints, &(ir->range.object)); } } else { td->composite.typeDecl.numElems = td->ElemType->numElems; for (int i = 0; i < td->NumDimensions; i++) { tree_t r = range_of(type, i); c_intRange *ir = build_int_range(r, parent, nextdim + i, obj); td->composite.typeDecl.numElems *= range_len(ir); vhpi_list_add(&td->Constraints, &(ir->range.object)); } } hash_put(vhpi_context()->objcache, type, td); return &(td->composite.typeDecl); } static c_typeDecl *build_dynamicSubtype(c_typeDecl *base, void *ptr, vhpiClassKindT kind) { c_subTypeDecl *td = new_object(sizeof(c_arrayTypeDecl), vhpiSubtypeDeclK); init_typeDecl(&(td->typeDecl), base->decl.tree, base->type); assert(type_is_unconstrained(base->type)); assert(base->IsUnconstrained); td->typeDecl.BaseType = base; td->typeDecl.IsUnconstrained = false; td->typeDecl.IsComposite = true; const bool is_signal = kind == vhpiPortDeclK || kind == vhpiSigDeclK; c_arrayTypeDecl *at = is_arrayTypeDecl(&(base->decl.object)); if (at != NULL) { td->typeDecl.numElems = at->ElemType->numElems; td->typeDecl.wrapped = true; ffi_dim_t *bounds = ptr + (is_signal ? 2 * sizeof(int64_t) : sizeof(int64_t)); vhpi_list_reserve(&td->Constraints, at->NumDimensions); for (int i = 0; i < at->NumDimensions; i++) { const range_kind_t dir = ffi_array_dir(bounds[i].length); const int64_t left = bounds[i].left; const int64_t right = ffi_array_right(bounds[i].left, bounds[i].length); const bool null = dir == RANGE_TO ? left > right : right > left; c_intRange *ir = new_object(sizeof(c_intRange), vhpiIntRangeK); init_range(&(ir->range), dir == RANGE_TO, null, true); ir->LeftBound = left; ir->RightBound = right; td->typeDecl.numElems *= range_len(ir); vhpi_list_add(&td->Constraints, &(ir->range.object)); } } c_recordTypeDecl *rt = is_recordTypeDecl(&(base->decl.object)); if (rt != NULL) { const jit_layout_t *l = is_signal ? signal_layout_of(base->type) :layout_of(base->type); vhpiObjectListT *elems = expand_lazy_list(&(base->decl.object), &rt->RecordElems); vhpi_list_reserve(&td->Constraints, elems->count); for (int i = 0; i < elems->count; i++) { c_elemDecl *ed = is_elemDecl(elems->items[i]); assert(ed != NULL); if (ed->Type->IsUnconstrained) { void *fptr = ptr + l->parts[i].offset; c_typeDecl *sub = build_dynamicSubtype(ed->Type, fptr, kind); c_elemDecl *new = new_object(sizeof(c_elemDecl), vhpiElemDeclK); init_elemDecl(new, ed->decl.tree, sub, &rt->composite.typeDecl.decl); vhpi_list_add(&td->Constraints, &(new->decl.object)); } else vhpi_list_add(&td->Constraints, &(ed->decl.object)); } } return &(td->typeDecl); } static c_typeDecl *build_subTypeDecl(type_t type, tree_t where, c_vhpiObject *obj) { if (type_is_array(type)) { // TODO: should this return c_subTypeDecl? type_t base = type; while (is_anonymous_subtype(base)) base = type_base(base); // Anonymous subtypes have no declaration c_typeDecl *td = build_arrayTypeDecl(type, where, base, obj, 0); if (type != base) td->decl.Name = td->decl.CaseName = new_string(type_pp(base)); return td; } c_subTypeDecl *td = new_object(sizeof(c_subTypeDecl), vhpiSubtypeDeclK); init_typeDecl(&(td->typeDecl), where, type); hash_put(vhpi_context()->objcache, type, td); td->typeDecl.BaseType = cached_typeDecl(type_base(type), NULL); td->typeDecl.IsAnonymous = is_anonymous_subtype(type); td->typeDecl.IsScalar = td->typeDecl.BaseType->IsScalar; td->typeDecl.IsComposite = td->typeDecl.BaseType->IsComposite; td->typeDecl.size = td->typeDecl.BaseType->size; td->isResolved = type_has_resolution(type); c_recordTypeDecl *rtd = is_recordTypeDecl(&(td->typeDecl.BaseType->decl.object)); if (rtd != NULL) { vhpiObjectListT *elems = expand_lazy_list(&(td->typeDecl.BaseType->decl.object), &rtd->RecordElems); vhpi_list_reserve(&td->Constraints, elems->count); for (int i = 0; i < elems->count; i++) { c_elemDecl *ed = is_elemDecl(elems->items[i]); assert(ed != NULL); if (ed->Type->IsUnconstrained) { tree_t cons = type_constraint_for_field(type, ed->decl.tree); if (cons != NULL) { c_abstractDecl *parent = &rtd->composite.typeDecl.decl; if (obj != NULL) parent = is_abstractDecl(obj); assert(parent != NULL); c_elemDecl *new = new_object(sizeof(c_elemDecl), vhpiElemDeclK); init_elemDecl(new, ed->decl.tree, NULL, parent); vhpi_list_add(&td->Constraints, &(new->decl.object)); new->Type = cached_typeDecl(tree_type(cons), &(new->decl.object)); continue; } } vhpi_list_add(&td->Constraints, &(ed->decl.object)); } } if (td->typeDecl.IsScalar && type_has_constraint(type)) { tree_t c = type_constraint(type); assert(tree_subkind(c) == C_RANGE); vhpi_list_reserve(&td->Constraints, 1); tree_t r = tree_range(c, 0); type_t rtype = tree_type(r); if (type_is_real(rtype)) { c_floatRange *fr = build_float_range(r); vhpi_list_add(&td->Constraints, &(fr->range.object)); } else if (type_is_physical(rtype)) { c_physRange *pr = build_phys_range(r); vhpi_list_add(&td->Constraints, &(pr->range.object)); } else { c_intRange *ir = build_int_range(r, NULL, 0, NULL); vhpi_list_add(&td->Constraints, &(ir->range.object)); } } return &(td->typeDecl); } static c_typeDecl *build_anonymousSubTypeDecl(type_t type, c_vhpiObject *obj) { assert(is_anonymous_subtype(type)); assert(obj != NULL); c_abstractDecl *decl = is_abstractDecl(obj); assert(decl != NULL); c_typeDecl *td = build_subTypeDecl(type, decl->tree, obj); td->IsAnonymous = true; return td; } static c_typeDecl *build_typeDecl(tree_t decl, c_abstractRegion *region) { type_t type = tree_type(decl); switch (type_kind(type)) { case T_INTEGER: { c_intTypeDecl *td = new_object(sizeof(c_intTypeDecl), vhpiIntTypeDeclK); init_scalarTypeDecl(&(td->scalar), decl, type); c_vhpiObject *tobj = &(td->scalar.typeDecl.decl.object); vhpi_list_add(&(region->decls.list), tobj); hash_put(vhpi_context()->objcache, type, td); c_intRange *ir = build_int_range(range_of(type, 0), NULL, 0, NULL); td->constraint = &(ir->range); return &(td->scalar.typeDecl); } case T_ENUM: { c_enumTypeDecl *td = new_object(sizeof(c_enumTypeDecl), vhpiEnumTypeDeclK); init_scalarTypeDecl(&(td->scalar), decl, type); c_vhpiObject *tobj = &(td->scalar.typeDecl.decl.object); vhpi_list_add(®ion->decls.list, tobj); hash_put(vhpi_context()->objcache, type, td); td->EnumLiterals.fn = vhpi_lazy_enum_literals; return &(td->scalar.typeDecl); } case T_PHYSICAL: { c_physTypeDecl *td = new_object(sizeof(c_physTypeDecl), vhpiPhysTypeDeclK); init_scalarTypeDecl(&(td->scalar), decl, type); c_vhpiObject *tobj = &(td->scalar.typeDecl.decl.object); vhpi_list_add(®ion->decls.list, tobj); hash_put(vhpi_context()->objcache, type, td); td->constraint = &(build_phys_range(range_of(type, 0))->range); return &(td->scalar.typeDecl); } case T_REAL: { c_floatTypeDecl *td = new_object(sizeof(c_floatTypeDecl), vhpiFloatTypeDeclK); init_scalarTypeDecl(&(td->scalar), decl, type); c_vhpiObject *tobj = &(td->scalar.typeDecl.decl.object); vhpi_list_add(®ion->decls.list, tobj); hash_put(vhpi_context()->objcache, type, td); td->constraint = &(build_float_range(range_of(type, 0))->range); return &(td->scalar.typeDecl); } case T_ARRAY: { c_arrayTypeDecl *td = new_object(sizeof(c_arrayTypeDecl), vhpiArrayTypeDeclK); init_compositeTypeDecl(&(td->composite), decl, type); c_vhpiObject *tobj = &(td->composite.typeDecl.decl.object); vhpi_list_add(®ion->decls.list, tobj); hash_put(vhpi_context()->objcache, type, td); type_t elem = type_elem(type); if (is_anonymous_subtype(elem) && !type_const_bounds(elem)) elem = type_base_recur(elem); td->NumDimensions = dimension_of(type); td->composite.typeDecl.wrapped = true; td->ElemType = cached_typeDecl(elem, tobj); td->composite.typeDecl.size = td->ElemType->size; vhpi_list_reserve(&td->Constraints, td->NumDimensions); for (int i = 0; i < td->NumDimensions; i++) { c_intRange *ir = build_unconstrained(); vhpi_list_add(&td->Constraints, &(ir->range.object)); } return &(td->composite.typeDecl); } case T_RECORD: { c_recordTypeDecl *td = new_object(sizeof(c_recordTypeDecl), vhpiRecordTypeDeclK); init_compositeTypeDecl(&(td->composite), decl, type); c_vhpiObject *tobj = &(td->composite.typeDecl.decl.object); vhpi_list_add(®ion->decls.list, tobj); hash_put(vhpi_context()->objcache, type, td); td->RecordElems.fn = vhpi_lazy_fields; return &(td->composite.typeDecl); } case T_SUBTYPE: { assert(!is_anonymous_subtype(type)); c_typeDecl *td = build_subTypeDecl(type, decl, NULL); vhpi_list_add(®ion->decls.list, &(td->decl.object)); assert(hash_get(vhpi_context()->objcache, type) == td); return td; } case T_INCOMPLETE: return NULL; // Ignore it case T_ACCESS: { c_accessTypeDecl *td = new_object(sizeof(c_accessTypeDecl), vhpiAccessTypeDeclK); init_typeDecl(&td->typeDecl, decl, type); vhpi_list_add(®ion->decls.list, &(td->typeDecl.decl.object)); hash_put(vhpi_context()->objcache, type, td); type_t desig = type_designated(type); if (!type_is_incomplete(desig)) td->ValType = cached_typeDecl(desig, NULL); return &(td->typeDecl); } case T_FILE: { c_fileTypeDecl *td = new_object(sizeof(c_fileTypeDecl), vhpiFileTypeDeclK); init_typeDecl(&td->typeDecl, decl, type); vhpi_list_add(®ion->decls.list, &(td->typeDecl.decl.object)); hash_put(vhpi_context()->objcache, type, td); td->ValType = cached_typeDecl(type_designated(type), NULL); return &(td->typeDecl); } default: fatal_trace("cannot build VHPI typeDecl for %s %s", type_kind_str(type_kind(type)), type_pp(type)); } } static c_typeDecl *cached_typeDecl(type_t type, c_vhpiObject *obj) { hash_t *cache = vhpi_context()->objcache; c_typeDecl *d = hash_get(cache, type); if (d != NULL) return d; else if (is_anonymous_subtype(type)) { d = build_anonymousSubTypeDecl(type, obj); assert(hash_get(cache, type) == d); return d; } else { c_designUnit *du = cached_designUnit(type_container(type)); expand_lazy_list(&(du->region.object), &(du->region.decls)); if ((d = hash_get(cache, type)) == NULL) fatal_trace("cannot find cached type for %s", type_pp(type)); return d; } } static c_designUnit *build_designUnit(tree_t t) { switch (tree_kind(t)) { case T_ENTITY: { c_entityDecl *entity = new_object(sizeof(c_entityDecl), vhpiEntityDeclK); init_entityDecl(entity, t); entity->designUnit.region.decls.fn = vhpi_lazy_decls; return &(entity->designUnit); } case T_ARCH: { c_designUnit *primary = cached_designUnit(tree_primary(t)); c_secondaryUnit *secondary = new_object(sizeof(c_secondaryUnit), vhpiArchBodyK); init_secondaryUnit(secondary, t, primary); secondary->designUnit.region.decls.fn = vhpi_lazy_decls; return &(secondary->designUnit); } case T_PACKAGE: { c_packDecl *pack = new_object(sizeof(c_packDecl), vhpiPackDeclK); init_packDecl(pack, t); pack->designUnit.region.decls.fn = vhpi_lazy_decls; return &(pack->designUnit); } default: fatal_trace("unsupported tree kind %s in build_designUnit", tree_kind_str(tree_kind(t))); } } static c_designUnit *cached_designUnit(tree_t t) { assert(is_design_unit(t)); hash_t *cache = vhpi_context()->objcache; c_designUnit *du = hash_get(cache, t); if (du == NULL) { du = build_designUnit(t); hash_put(cache, t, du); } return du; } static void build_genericDecl(tree_t generic, int pos, c_abstractRegion *region) { c_genericDecl *g = new_object(sizeof(c_genericDecl), vhpiGenericDeclK); init_interfaceDecl(&(g->interface), generic, pos, region); g->IsLocal = (tree_kind(region->tree) == T_COMPONENT); g->IsVital = false; g->Mode = mode_map[tree_subkind(generic)]; vhpi_list_add(®ion->decls.list, &(g->interface.objDecl.decl.object)); } static c_constParamDecl *build_constParamDecl(tree_t param, int pos) { c_constParamDecl *p = new_object(sizeof(c_constParamDecl), vhpiConstParamDeclK); init_interfaceDecl(&(p->interface), param, pos, NULL); p->Mode = mode_map[tree_subkind(param)]; return p; } static c_varParamDecl *build_varParamDecl(tree_t param, int pos) { c_varParamDecl *p = new_object(sizeof(c_varParamDecl), vhpiVarParamDeclK); init_interfaceDecl(&(p->interface), param, pos, NULL); p->Mode = mode_map[tree_subkind(param)]; return p; } static void build_portDecl(tree_t port, int pos, c_abstractRegion *region) { c_portDecl *p = new_object(sizeof(c_portDecl), vhpiPortDeclK); init_interfaceDecl(&(p->interface), port, pos, region); p->Mode = mode_map[tree_subkind(port)]; vhpi_list_add(®ion->decls.list, &(p->interface.objDecl.decl.object)); } static void build_signalDecl(tree_t decl, c_abstractRegion *region) { c_sigDecl *s = new_object(sizeof(c_sigDecl), vhpiSigDeclK); init_objDecl(&(s->objDecl), decl, region); vhpi_list_add(®ion->decls.list, &(s->objDecl.decl.object)); } static c_constDecl *build_constDecl(tree_t decl, c_abstractRegion *region) { c_constDecl *cd = new_object(sizeof(c_constDecl), vhpiConstDeclK); init_objDecl(&(cd->objDecl), decl, region); cd->IsDeferred = !tree_has_value(decl); vhpi_list_add(®ion->decls.list, &(cd->objDecl.decl.object)); return cd; } static void build_paramDecls(tree_t decl, int first, c_subpDecl *subp) { const int nparams = tree_ports(decl); vhpi_list_reserve(&subp->Params, nparams); for (int i = 0, slot = first; i < nparams; i++) { tree_t p = tree_port(decl, i); c_typeDecl *td = NULL; switch (tree_class(p)) { case C_CONSTANT: { c_constParamDecl *cpd = build_constParamDecl(p, i); cpd->interface.argslot = slot; vhpi_list_add(&subp->Params, &(cpd->interface.objDecl.decl.object)); td = cpd->interface.objDecl.Type; } break; case C_VARIABLE: { c_varParamDecl *vpd = build_varParamDecl(p, i); vpd->interface.argslot = slot; vhpi_list_add(&subp->Params, &(vpd->interface.objDecl.decl.object)); td = vpd->interface.objDecl.Type; } break; default: fatal_at(tree_loc(p), "unsupported parameter class"); } slot += td->wrapped ? 1 + 2*dimension_of(td->type) : 1; } } static c_funcDecl *build_funcDecl(tree_t decl) { c_funcDecl *f = new_object(sizeof(c_funcDecl), vhpiFuncDeclK); init_subpDecl(&(f->subpDecl), decl); build_paramDecls(decl, 1, &(f->subpDecl)); f->IsPure = !(tree_flags(decl) & TREE_F_IMPURE); f->ReturnType = cached_typeDecl(type_result(tree_type(decl)), NULL); return f; } static c_procDecl *build_procDecl(tree_t decl) { c_procDecl *f = new_object(sizeof(c_funcDecl), vhpiProcDeclK); init_subpDecl(&(f->subpDecl), decl); build_paramDecls(decl, 2, &(f->subpDecl)); return f; } static c_abstractRegion *build_blockStmt(tree_t t, c_abstractRegion *region) { c_blockStmt *bs = new_object(sizeof(c_blockStmt), vhpiBlockStmtK); init_abstractRegion(&(bs->region), region, t); init_stmt(&(bs->stmt), t); if (tree_decls(t) > 1) { tree_t d1 = tree_decl(t, 1); bs->IsGuarded = (tree_kind(d1) == T_IMPLICIT_SIGNAL && tree_subkind(d1) == IMPLICIT_GUARD); } vhpi_list_add(®ion->stmts.list, &(bs->region.object)); return &(bs->region); } static c_abstractRegion *build_compInstStmt(tree_t t, tree_t inst, c_abstractRegion *region) { assert(tree_kind(t) == T_BLOCK); tree_t inner = t; c_designUnit *du = NULL; switch (tree_kind(inst)) { case T_ARCH: du = cached_designUnit(inst); break; case T_COMPONENT: if (tree_stmts(t) >= 1) { inner = tree_stmt(t, 0); assert(tree_kind(inner) == T_BLOCK); tree_t h = tree_decl(inner, 0); assert(tree_kind(h) == T_HIER); du = cached_designUnit(tree_ref(h)); } break; default: fatal_trace("unexpected instance kind %s in build_compInstStmt", tree_kind_str(tree_kind(inst))); } c_compInstStmt *c = new_object(sizeof(c_compInstStmt), vhpiCompInstStmtK); init_designInstUnit(&(c->designInstUnit), region, t, du); init_stmt(&(c->stmt), t); // Make sure all lookups happen in the implicit inner region (void)vhpi_get_case_name(&c->designInstUnit.region.object); (void)vhpi_get_full_case_name(&c->designInstUnit.region.object); c->designInstUnit.region.tree = inner; vhpi_list_add(®ion->stmts.list, &(c->designInstUnit.region.object)); return &(c->designInstUnit.region); } static c_abstractRegion *build_forGenerate(tree_t t, c_abstractRegion *region) { c_forGenerate *g = new_object(sizeof(c_forGenerate), vhpiForGenerateK); init_abstractRegion(&(g->region), region, t); init_stmt(&(g->stmt), t); assert(tree_generics(t) == 1); assert(tree_genmaps(t) == 1); tree_t index = tree_value(tree_genmap(t, 0)); g->GenerateIndex = assume_int(index); vhpi_list_reserve(&(g->region.decls.list), tree_decls(t) + 1); tree_t g0 = tree_generic(t, 0); g->ParamDecl = build_constDecl(g0, &(g->region)); vhpi_list_add(®ion->stmts.list, &(g->region.object)); return &(g->region); } static c_abstractRegion *build_ifGenerate(tree_t t, c_abstractRegion *region) { c_ifGenerate *g = new_object(sizeof(c_forGenerate), vhpiIfGenerateK); init_abstractRegion(&(g->region), region, t); init_stmt(&(g->stmt), t); vhpi_list_reserve(&(g->region.decls.list), tree_decls(t)); vhpi_list_add(®ion->stmts.list, &(g->region.object)); return &(g->region); } static void build_packInst(tree_t inst, c_abstractRegion *region) { c_designUnit *du = cached_designUnit(tree_ref(inst)); c_packInst *pi = new_object(sizeof(c_packInst), vhpiPackInstK); init_designInstUnit(&(pi->designInstUnit), region, inst, du); pi->designInstUnit.region.decls.fn = vhpi_lazy_decls; // Must expand eagerly otherwise cached_typeDecl cannot find types // declared in this package expand_lazy_list(&(pi->designInstUnit.region.object), &(pi->designInstUnit.region.decls)); } static void vhpi_lazy_selected_names(c_vhpiObject *obj) { c_typeDecl *type = NULL; vhpiObjectListT *list = NULL; c_name *n = is_name(obj); if (n != NULL) { list = &(n->SelectedNames.list); type = n->expr.Type; } c_objDecl *od = is_objDecl(obj); if (od != NULL) { list = &(od->SelectedNames.list); type = od->Type; } assert(list != NULL && type != NULL); assert(list->count == 0); c_subTypeDecl *std = is_subTypeDecl(&(type->decl.object)); if (std != NULL) { vhpi_list_reserve(list, std->Constraints.count); for (int i = 0; i < std->Constraints.count; i++) { c_elemDecl *ed = is_elemDecl(std->Constraints.items[i]); assert(ed != NULL); c_selectedName *sn = new_object(sizeof(c_selectedName), vhpiSelectedNameK); init_selectedName(sn, obj, ed); vhpi_list_add(list, &(sn->prefixedName.name.expr.object)); } } c_recordTypeDecl *rtd = is_recordTypeDecl(&(type->decl.object)); if (rtd != NULL) { vhpiObjectListT *elems = expand_lazy_list(&(type->decl.object), &(rtd->RecordElems)); vhpi_list_reserve(list, elems->count); for (int i = 0; i < elems->count; i++) { c_elemDecl *ed = is_elemDecl(elems->items[i]); assert(ed != NULL); c_selectedName *sn = new_object(sizeof(c_selectedName), vhpiSelectedNameK); init_selectedName(sn, obj, ed); vhpi_list_add(list, &(sn->prefixedName.name.expr.object)); } } } static void vhpi_lazy_indexed_names(c_vhpiObject *obj) { c_typeDecl *type = NULL; vhpiObjectListT *list = NULL; c_name *n = is_name(obj); if (n != NULL) { list = &(n->IndexedNames.list); type = n->expr.Type; } c_objDecl *od = is_objDecl(obj); if (od != NULL) { list = &(od->IndexedNames.list); type = od->Type; } assert(list != NULL && type != NULL); assert(list->count == 0); vhpiObjectListT *Constraints; c_subTypeDecl *std = is_subTypeDecl(&(type->decl.object)); c_arrayTypeDecl *atd = is_arrayTypeDecl(&(type->decl.object)); if (std != NULL) { Constraints = &(std->Constraints); atd = is_arrayTypeDecl(&(type->BaseType->decl.object)); if (atd == NULL) return; } else if (atd != NULL) Constraints = &(atd->Constraints); else return; if (Constraints->count == 0) return; size_t count = 1; vhpiIntT *lens LOCAL = xmalloc_array(Constraints->count, sizeof(vhpiIntT)); for (int i = 0; i < Constraints->count; i++) { c_intRange *ir = is_intRange(Constraints->items[i]); assert(ir != NULL); if ((lens[i] = range_len(ir)) == 0) return; count *= lens[i]; } vhpi_list_reserve(list, count); int pos = 0; vhpiIntT *indices LOCAL = xcalloc_array(Constraints->count, sizeof(vhpiIntT)); do { c_indexedName *in = new_object(sizeof(c_indexedName), vhpiIndexedNameK); init_indexedName(in, atd->ElemType, obj, Constraints, indices); vhpi_list_add(list, &(in->prefixedName.name.expr.object)); for (pos = Constraints->count - 1; pos >= 0; pos--) { indices[pos]++; if (indices[pos] >= lens[pos]) indices[pos] = 0; else break; } } while (pos > 0 || indices[0] != 0); } static void vhpi_lazy_enum_literals(c_vhpiObject *obj) { c_enumTypeDecl *td = is_enumTypeDecl(obj); assert(td != NULL); const int nlits = type_enum_literals(td->scalar.typeDecl.type); vhpi_list_reserve(&td->EnumLiterals.list, nlits); for (int i = 0; i < nlits; i++) { tree_t lit = type_enum_literal(td->scalar.typeDecl.type, i); c_enumLiteral *el = new_object(sizeof(c_enumLiteral), vhpiEnumLiteralK); init_enumLiteral(el, lit, td); vhpi_list_add(&td->EnumLiterals.list, &(el->decl.object)); } } static void vhpi_lazy_fields(c_vhpiObject *obj) { c_recordTypeDecl *td = is_recordTypeDecl(obj); assert(td != NULL); const int nfields = type_fields(td->composite.typeDecl.type); vhpi_list_reserve(&td->RecordElems.list, nfields); for (int i = 0; i < nfields; i++) { tree_t f = type_field(td->composite.typeDecl.type, i); type_t ft = tree_type(f); c_elemDecl *ed = new_object(sizeof(c_elemDecl), vhpiElemDeclK); init_elemDecl(ed, f, NULL, &td->composite.typeDecl.decl); vhpi_list_add(&td->RecordElems.list, &(ed->decl.object)); ed->Type = cached_typeDecl(ft, &(ed->decl.object)); td->composite.typeDecl.numElems += ed->Type->numElems; } } static void vhpi_lazy_stmts(c_vhpiObject *obj) { c_abstractRegion *r = is_abstractRegion(obj); assert(r != NULL); const int nstmts = tree_stmts(r->tree); vhpi_list_reserve(&r->stmts.list, nstmts); for (int i = 0; i < nstmts; i++) { tree_t s = tree_stmt(r->tree, i); switch (tree_kind(s)) { case T_BLOCK: { tree_t h = tree_decl(s, 0); assert(tree_kind(h) == T_HIER); c_abstractRegion *sub = NULL; switch (tree_subkind(h)) { case T_BLOCK: sub = build_blockStmt(s, r); sub->stmts.fn = vhpi_lazy_stmts; sub->decls.fn = vhpi_lazy_decls; break; case T_ARCH: case T_COMPONENT: sub = build_compInstStmt(s, tree_ref(h), r); sub->stmts.fn = vhpi_lazy_stmts; sub->decls.fn = vhpi_lazy_decls; break; case T_FOR_GENERATE: sub = build_forGenerate(s, r); sub->stmts.fn = vhpi_lazy_stmts; sub->decls.fn = vhpi_lazy_decls; break; case T_CASE_GENERATE: // No VHPI kind for this case T_IF_GENERATE: sub = build_ifGenerate(s, r); sub->stmts.fn = vhpi_lazy_stmts; sub->decls.fn = vhpi_lazy_decls; break; default: continue; } } break; default: break; } } } static void vhpi_lazy_decls(c_vhpiObject *obj) { c_abstractRegion *r = is_abstractRegion(obj); assert(r != NULL); int ndecls = tree_decls(r->tree), nports = 0, ngenerics = 0; switch (obj->kind) { case vhpiRootInstK: case vhpiCompInstStmtK: case vhpiEntityDeclK: case vhpiBlockStmtK: nports = tree_ports(r->tree); // Fall-through case vhpiPackDeclK: ngenerics = tree_generics(r->tree); break; default: break; } vhpi_list_reserve(&r->decls.list, ndecls + nports + ngenerics); for (int i = 0; i < nports; i++) { tree_t p = tree_port(r->tree, i); build_portDecl(p, i, r); } for (int i = 0; i < ngenerics; i++) { tree_t g = tree_generic(r->tree, i); build_genericDecl(g, i, r); } for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(r->tree, i); switch (tree_kind(d)) { case T_SIGNAL_DECL: build_signalDecl(d, r); break; case T_CONST_DECL: build_constDecl(d, r); break; case T_TYPE_DECL: case T_SUBTYPE_DECL: build_typeDecl(d, r); break; case T_PACK_INST: build_packInst(d, r); break; default: break; } } } static void vhpi_build_deps_cb(ident_t name, void *ctx) { hset_t *visited = ctx; if (hset_contains(visited, name)) return; hset_insert(visited, name); tree_t unit = lib_get_qualified(name); if (unit == NULL) return; else if (tree_kind(unit) == T_PACKAGE) { c_designUnit *pack = cached_designUnit(unit); assert(pack->region.object.kind == vhpiPackDeclK); c_packInst *pi = new_object(sizeof(c_packInst), vhpiPackInstK); init_designInstUnit(&(pi->designInstUnit), NULL, unit, pack); pi->designInstUnit.region.decls.fn = vhpi_lazy_decls; vhpi_context_t *c = vhpi_context(); assert(hash_get(c->objcache, unit) == pack); hash_put(c->objcache, unit, pi); APUSH(c->packages, &(pi->designInstUnit.region.object)); } tree_walk_deps(unit, vhpi_build_deps_cb, visited); } static void vhpi_run_callbacks(int32_t reason, int32_t rep) { vhpi_context_t *c = vhpi_context(); const int orig_count = c->callbacks.count; int wptr = 0; for (int i = 0; i < orig_count; i++) { vhpiHandleT handle = c->callbacks.items[i]; handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) continue; assert(slot->kind == HANDLE_INTERNAL); c_callback *cb = is_callback(slot->obj); assert(cb != NULL); if (cb->Reason == reason) vhpi_global_cb(c->model, handle); else if (cb->Reason == rep) { vhpi_global_cb(c->model, handle); c->callbacks.items[wptr++] = handle; } else c->callbacks.items[wptr++] = handle; } // Callbacks may register additional callbacks for (int i = orig_count; i < c->callbacks.count; i++) c->callbacks.items[wptr++] = c->callbacks.items[i]; ATRIM(c->callbacks, wptr); } static void vhpi_initialise_cb(rt_model_t *m, void *arg) { vhpi_context_t *c = arg; vhpi_clear_error(); assert(tree_kind(c->top) == T_ELAB); tree_t b0 = tree_stmt(c->top, 0); if (tree_kind(b0) == T_VERILOG) fatal_at(tree_loc(b0), "Verilog top-level modules are not supported " "by VHPI"); assert(tree_kind(b0) == T_BLOCK); tree_t h = tree_decl(b0, 0); assert(tree_kind(h) == T_HIER); tree_t s = tree_ref(h); assert(tree_kind(s) == T_ARCH); c_designUnit *du = cached_designUnit(s); c->root = new_object(sizeof(c_rootInst), vhpiRootInstK); init_designInstUnit(&(c->root->designInstUnit), NULL, b0, du); c_abstractRegion *region = &(c->root->designInstUnit.region); region->stmts.fn = vhpi_lazy_stmts; region->decls.fn = vhpi_lazy_decls; vhpi_run_callbacks(vhpiCbEndOfInitialization, 0); } static void vhpi_phase_cb(rt_model_t *m, void *arg) { const int32_t reason = (intptr_t)arg; int32_t rep = 0; switch (reason) { case vhpiCbEndOfProcesses: rep = vhpiCbRepEndOfProcesses; break; case vhpiCbLastKnownDeltaCycle: rep = vhpiCbRepLastKnownDeltaCycle; break; case vhpiCbNextTimeStep: rep = vhpiCbRepNextTimeStep; break; case vhpiCbEndOfTimeStep: rep = vhpiCbRepEndOfTimeStep; break; case vhpiCbStartOfNextCycle: rep = vhpiCbRepStartOfNextCycle; break; } vhpi_run_callbacks(reason, rep); switch (reason) { case vhpiCbEndOfProcesses: case vhpiCbLastKnownDeltaCycle: case vhpiCbNextTimeStep: case vhpiCbEndOfTimeStep: case vhpiCbStartOfNextCycle: model_set_global_cb(m, vhpi_get_rt_event(reason), vhpi_phase_cb, (void *)(intptr_t)reason); break; } } vhpi_context_t *vhpi_context_new(void) { assert(global_context == NULL); vhpi_context_t *c = global_context = xcalloc(sizeof(vhpi_context_t)); c->objcache = hash_new(128); c->pool = pool_new(); return c; } void vhpi_context_initialise(vhpi_context_t *c, tree_t top, rt_model_t *model, jit_t *jit, int argc, char **argv) { assert(c->model == NULL); assert(c->top == NULL); assert(c->jit == NULL); c->model = model; c->top = top; c->jit = jit; c->tool = new_object(sizeof(c_tool), vhpiToolK); vhpi_list_reserve(&c->tool->argv, argc); for (int i = 0; i < argc; i++) { c_argv *arg = new_object(sizeof(c_argv), vhpiArgvK); arg->StrVal = new_string(argv[i]); vhpi_list_add(&c->tool->argv, &(arg->object)); } hset_t *visited = hset_new(64); tree_walk_deps(c->top, vhpi_build_deps_cb, visited); hset_free(visited); model_set_global_cb(model, RT_END_OF_INITIALISATION, vhpi_initialise_cb, c); static const int32_t reasons[] = { vhpiCbStartOfSimulation, vhpiCbEndOfSimulation, vhpiCbNextTimeStep, vhpiCbEndOfTimeStep, vhpiCbStartOfNextCycle, vhpiCbLastKnownDeltaCycle, vhpiCbEndOfProcesses }; for (size_t i = 0; i < ARRAY_LEN(reasons); i++) model_set_global_cb(model, vhpi_get_rt_event(reasons[i]), vhpi_phase_cb, (void *)(uintptr_t)reasons[i]); } static void vhpi_handles_diag(vhpi_context_t *c, diag_t *d, handle_kind_t kind) { for (int i = 0; i < c->num_handles; i++) { handle_slot_t *slot = &(c->handles[i]); if (slot->obj == NULL || slot->kind != kind) continue; diag_printf(d, "\n%s", handle_pp(encode_handle(slot, i))); c_refcounted *rc = is_refcounted(slot->obj); if (rc != NULL) diag_printf(d, " with %d reference%s", rc->refcount, rc->refcount != 1 ? "s" : ""); } } static void vhpi_check_leaks(vhpi_context_t *c) { int nuser = 0, ninternal UNUSED = 0; for (int i = 0; i < c->num_handles; i++) { if (c->handles[i].obj == NULL) continue; else if (c->handles[i].kind == HANDLE_INTERNAL) ninternal++; else nuser++; } if (nuser > 0) { diag_t *d = diag_new(DIAG_WARN, NULL); diag_printf(d, "VHPI program exited with %d active handles", nuser); vhpi_handles_diag(c, d, HANDLE_USER); diag_emit(d); } #ifdef DEBUG if (ninternal > 0) { diag_t *d = diag_new(DIAG_DEBUG, NULL); diag_printf(d, "VHPI program exited with %d active internal handles", ninternal); vhpi_handles_diag(c, d, HANDLE_INTERNAL); diag_emit(d); } #endif } void vhpi_context_free(vhpi_context_t *c) { for (int i = 0; i < c->foreignfs.count; i++) { c_foreignf *f = is_foreignf(c->foreignfs.items[i]); assert(f != NULL); drop_handle(c, f->handle); } ACLEAR(c->foreignfs); for (int i = 0; i < c->callbacks.count; i++) drop_handle(c, c->callbacks.items[i]); ACLEAR(c->callbacks); ACLEAR(c->packages); ACLEAR(c->recycle); if (opt_get_int(OPT_PLI_DEBUG)) vhpi_check_leaks(c); assert(c == global_context); global_context = NULL; if (c->strtab != NULL) shash_free(c->strtab); #ifdef DEBUG size_t alloc, npages; pool_stats(c->pool, &alloc, &npages); if (npages > 0) debugf("VHPI allocated %zu bytes in %zu pages", alloc, npages); #endif hash_free(c->objcache); pool_free(c->pool); free(c->handles); free(c); } //////////////////////////////////////////////////////////////////////////////// // Foreign function interface vhpiHandleT vhpi_bind_foreign(const char *obj_lib, const char *model, tree_t where) { vhpi_context_t *c = vhpi_context(); for (int i = 0; i < c->foreignfs.count; i++) { c_foreignf *f = cast_foreignf(c->foreignfs.items[i]); if (strcmp(f->data.libraryName, obj_lib)) continue; else if (strcmp(f->data.modelName, model)) continue; assert(tree_kind(where) == T_ATTR_SPEC); tree_t sub = tree_ref(where); if (f->decl != NULL && f->decl->tree == sub) return f->handle; else if (f->decl != NULL) jit_msg(NULL, DIAG_FATAL, "foreign subprogram %s/%s already bound " "to %s", obj_lib, model, type_pp(tree_type(f->decl->tree))); switch (tree_kind(sub)) { case T_FUNC_DECL: case T_FUNC_BODY: f->decl = &(build_funcDecl(sub)->subpDecl); break; case T_PROC_DECL: case T_PROC_BODY: f->decl = &(build_procDecl(sub)->subpDecl); break; default: jit_msg(NULL, DIAG_FATAL, "unsupported foreign subprogram"); } return (f->handle = internal_handle_for(&(f->object))); } return NULL; } void vhpi_call_foreign(vhpiHandleT handle, jit_scalar_t *args, tlab_t *tlab) { c_vhpiObject *obj = from_handle(handle); if (obj == NULL) jit_msg(NULL, DIAG_FATAL, "called invalid foreign subprogram"); c_foreignf *f = is_foreignf(obj); assert(f != NULL); void *orig_p0 = args[0].pointer; vhpi_context_t *c = vhpi_context(); assert(c->args == NULL); c->args = args; c->tlab = tlab; // TODO: don't get/drop this every time? vhpiHandleT subp = internal_handle_for(&(f->decl->object)); vhpiCbDataT data = { .obj = subp }; (*f->data.execf)(&data); drop_handle(c, subp); c->args = NULL; c->tlab = NULL; if (f->decl->object.kind == vhpiFuncDeclK && args[0].pointer == orig_p0) jit_msg(NULL, DIAG_FATAL, "foreign function %s did not return a value", type_pp(tree_type(f->decl->tree))); } nvc-r1.17.1/src/vhpi/vhpi-str.c000066400000000000000000000626511504111170000162260ustar00rootroot00000000000000// // Copyright (C) 2014-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "vhpi/vhpi-util.h" LCOV_EXCL_START static const char *vhpi_fallback_str(int value) { static char buf[16]; checked_sprintf(buf, sizeof(buf), "%d", value); return buf; } const char *vhpi_property_str(int property) { switch (property) { case vhpiAccessP: return "vhpiAccessP"; case vhpiArgcP: return "vhpiArgcP"; case vhpiAttrKindP: return "vhpiAttrKindP"; case vhpiBaseIndexP: return "vhpiBaseIndexP"; case vhpiBeginLineNoP: return "vhpiBeginLineNoP"; case vhpiEndLineNoP: return "vhpiEndLineNoP"; case vhpiEntityClassP: return "vhpiEntityClassP"; case vhpiForeignKindP: return "vhpiForeignKindP"; case vhpiFrameLevelP: return "vhpiFrameLevelP"; case vhpiGenerateIndexP: return "vhpiGenerateIndexP"; case vhpiIntValP: return "vhpiIntValP"; case vhpiIsAnonymousP: return "vhpiIsAnonymousP"; case vhpiIsBasicP: return "vhpiIsBasicP"; case vhpiIsCompositeP: return "vhpiIsCompositeP"; case vhpiIsDefaultP: return "vhpiIsDefaultP"; case vhpiIsDeferredP: return "vhpiIsDeferredP"; case vhpiIsDiscreteP: return "vhpiIsDiscreteP"; case vhpiIsForcedP: return "vhpiIsForcedP"; case vhpiIsForeignP: return "vhpiIsForeignP"; case vhpiIsGuardedP: return "vhpiIsGuardedP"; case vhpiIsImplicitDeclP: return "vhpiIsImplicitDeclP"; case DEPRECATED_vhpiIsInvalidP: return "DEPRECATED_vhpiIsInvalidP"; case vhpiIsLocalP: return "vhpiIsLocalP"; case vhpiIsNamedP: return "vhpiIsNamedP"; case vhpiIsNullP: return "vhpiIsNullP"; case vhpiIsOpenP: return "vhpiIsOpenP"; case vhpiIsPLIP: return "vhpiIsPLIP"; case vhpiIsPassiveP: return "vhpiIsPassiveP"; case vhpiIsPostponedP: return "vhpiIsPostponedP"; case vhpiIsProtectedTypeP: return "vhpiIsProtectedTypeP"; case vhpiIsPureP: return "vhpiIsPureP"; case vhpiIsResolvedP: return "vhpiIsResolvedP"; case vhpiIsScalarP: return "vhpiIsScalarP"; case vhpiIsSeqStmtP: return "vhpiIsSeqStmtP"; case vhpiIsSharedP: return "vhpiIsSharedP"; case vhpiIsTransportP: return "vhpiIsTransportP"; case vhpiIsUnaffectedP: return "vhpiIsUnaffectedP"; case vhpiIsUnconstrainedP: return "vhpiIsUnconstrainedP"; case vhpiIsUninstantiatedP: return "vhpiIsUninstantiatedP"; case vhpiIsUpP: return "vhpiIsUpP"; case vhpiIsVitalP: return "vhpiIsVitalP"; case vhpiIteratorTypeP: return "vhpiIteratorTypeP"; case vhpiKindP: return "vhpiKindP"; case vhpiLeftBoundP: return "vhpiLeftBoundP"; case DEPRECATED_vhpiLevelP: return "DEPRECATED_vhpiLevelP"; case vhpiLineNoP: return "vhpiLineNoP"; case vhpiLineOffsetP: return "vhpiLineOffsetP"; case vhpiLoopIndexP: return "vhpiLoopIndexP"; case vhpiModeP: return "vhpiModeP"; case vhpiNumDimensionsP: return "vhpiNumDimensionsP"; case DEPRECATED_vhpiNumFieldsP: return "DEPRECATED_vhpiNumFieldsP"; case vhpiNumGensP: return "vhpiNumGensP"; case vhpiNumLiteralsP: return "vhpiNumLiteralsP"; case vhpiNumMembersP: return "vhpiNumMembersP"; case vhpiNumParamsP: return "vhpiNumParamsP"; case vhpiNumPortsP: return "vhpiNumPortsP"; case vhpiOpenModeP: return "vhpiOpenModeP"; case vhpiPhaseP: return "vhpiPhaseP"; case vhpiPositionP: return "vhpiPositionP"; case vhpiPredefAttrP: return "vhpiPredefAttrP"; case vhpiReasonP: return "vhpiReasonP"; case vhpiRightBoundP: return "vhpiRightBoundP"; case vhpiSigKindP: return "vhpiSigKindP"; case vhpiSizeP: return "vhpiSizeP"; case vhpiStartLineNoP: return "vhpiStartLineNoP"; case vhpiStateP: return "vhpiStateP"; case vhpiStaticnessP: return "vhpiStaticnessP"; case vhpiVHDLversionP: return "vhpiVHDLversionP"; case vhpiIdP: return "vhpiIdP"; case vhpiCapabilitiesP: return "vhpiCapabilitiesP"; case vhpiAutomaticRestoreP: return "vhpiAutomaticRestoreP"; case vhpiCompInstKindP: return "vhpiCompInstKindP"; case vhpiIsBuiltInP: return "vhpiIsBuiltInP"; case vhpiIsDynamicP: return "vhpiIsDynamicP"; case vhpiIsOperatorP: return "vhpiIsOperatorP"; case vhpiNumFieldsP: return "vhpiNumFieldsP"; case vhpiCaseNameP: return "vhpiCaseNameP"; case vhpiCompNameP: return "vhpiCompNameP"; case vhpiDefNameP: return "vhpiDefNameP"; case vhpiFileNameP: return "vhpiFileNameP"; case vhpiFullCaseNameP: return "vhpiFullCaseNameP"; case vhpiFullNameP: return "vhpiFullNameP"; case vhpiKindStrP: return "vhpiKindStrP"; case vhpiLabelNameP: return "vhpiLabelNameP"; case vhpiLibLogicalNameP: return "vhpiLibLogicalNameP"; case vhpiLibPhysicalNameP: return "vhpiLibPhysicalNameP"; case vhpiLogicalNameP: return "vhpiLogicalNameP"; case vhpiLoopLabelNameP: return "vhpiLoopLabelNameP"; case vhpiNameP: return "vhpiNameP"; case DEPRECATED_vhpiOpNameP: return "DEPRECATED_vhpiOpNameP"; case vhpiStrValP: return "vhpiStrValP"; case vhpiToolVersionP: return "vhpiToolVersionP"; case vhpiUnitNameP: return "vhpiUnitNameP"; case vhpiSaveRestartLocationP: return "vhpiSaveRestartLocationP"; case vhpiCompInstNameP: return "vhpiCompInstNameP"; case vhpiInstNamesP: return "vhpiInstNamesP"; case vhpiSignatureNameP: return "vhpiSignatureNameP"; case vhpiSpecNameP: return "vhpiSpecNameP"; case vhpiFloatLeftBoundP: return "vhpiFloatLeftBoundP"; case vhpiFloatRightBoundP: return "vhpiFloatRightBoundP"; case vhpiRealValP: return "vhpiRealValP"; case vhpiPhysLeftBoundP: return "vhpiPhysLeftBoundP"; case vhpiPhysPositionP: return "vhpiPhysPositionP"; case vhpiPhysRightBoundP: return "vhpiPhysRightBoundP"; case vhpiPhysValP: return "vhpiPhysValP"; case DEPRECATED_vhpiPrecisionP: return "DEPRECATED_vhpiPrecisionP"; case DEPRECATED_vhpiSimTimeUnitP: return "DEPRECATED_vhpiSimTimeUnitP"; case vhpiResolutionLimitP: return "vhpiResolutionLimitP"; case vhpiTimeP: return "vhpiTimeP"; default: return vhpi_fallback_str(property); } } const char *vhpi_class_str(vhpiClassKindT kind) { switch (kind) { case vhpiAccessTypeDeclK: return "vhpiAccessTypeDeclK"; case vhpiAggregateK: return "vhpiAggregateK"; case vhpiAliasDeclK: return "vhpiAliasDeclK"; case vhpiAllK: return "vhpiAllK"; case vhpiAllocatorK: return "vhpiAllocatorK"; case vhpiAnyCollectionK: return "vhpiAnyCollectionK"; case vhpiArchBodyK: return "vhpiArchBodyK"; case vhpiArgvK: return "vhpiArgvK"; case vhpiArrayTypeDeclK: return "vhpiArrayTypeDeclK"; case DEPRECATED_vhpiAssertStmtK: return "DEPRECATED_vhpiAssertStmtK"; case vhpiAssocElemK: return "vhpiAssocElemK"; case vhpiAttrDeclK: return "vhpiAttrDeclK"; case vhpiAttrSpecK: return "vhpiAttrSpecK"; case DEPRECATED_vhpiBinaryExprK: return "DEPRECATED_vhpiBinaryExprK"; case vhpiBitStringLiteralK: return "vhpiBitStringLiteralK"; case vhpiBlockConfigK: return "vhpiBlockConfigK"; case vhpiBlockStmtK: return "vhpiBlockStmtK"; case vhpiBranchK: return "vhpiBranchK"; case vhpiCallbackK: return "vhpiCallbackK"; case vhpiCaseStmtK: return "vhpiCaseStmtK"; case vhpiCharLiteralK: return "vhpiCharLiteralK"; case vhpiCompConfigK: return "vhpiCompConfigK"; case vhpiCompDeclK: return "vhpiCompDeclK"; case vhpiCompInstStmtK: return "vhpiCompInstStmtK"; case vhpiCondSigAssignStmtK: return "vhpiCondSigAssignStmtK"; case vhpiCondWaveformK: return "vhpiCondWaveformK"; case vhpiConfigDeclK: return "vhpiConfigDeclK"; case vhpiConstDeclK: return "vhpiConstDeclK"; case vhpiConstParamDeclK: return "vhpiConstParamDeclK"; case vhpiConvFuncK: return "vhpiConvFuncK"; case vhpiDerefObjK: return "vhpiDerefObjK"; case vhpiDisconnectSpecK: return "vhpiDisconnectSpecK"; case vhpiDriverK: return "vhpiDriverK"; case vhpiDriverCollectionK: return "vhpiDriverCollectionK"; case vhpiElemAssocK: return "vhpiElemAssocK"; case vhpiElemDeclK: return "vhpiElemDeclK"; case vhpiEntityClassEntryK: return "vhpiEntityClassEntryK"; case vhpiEntityDeclK: return "vhpiEntityDeclK"; case vhpiEnumLiteralK: return "vhpiEnumLiteralK"; case vhpiEnumRangeK: return "vhpiEnumRangeK"; case vhpiEnumTypeDeclK: return "vhpiEnumTypeDeclK"; case vhpiExitStmtK: return "vhpiExitStmtK"; case vhpiFileDeclK: return "vhpiFileDeclK"; case vhpiFileParamDeclK: return "vhpiFileParamDeclK"; case vhpiFileTypeDeclK: return "vhpiFileTypeDeclK"; case vhpiFloatRangeK: return "vhpiFloatRangeK"; case vhpiFloatTypeDeclK: return "vhpiFloatTypeDeclK"; case vhpiForGenerateK: return "vhpiForGenerateK"; case vhpiForLoopK: return "vhpiForLoopK"; case vhpiForeignfK: return "vhpiForeignfK"; case vhpiFuncCallK: return "vhpiFuncCallK"; case vhpiFuncDeclK: return "vhpiFuncDeclK"; case vhpiGenericDeclK: return "vhpiGenericDeclK"; case vhpiGroupDeclK: return "vhpiGroupDeclK"; case vhpiGroupTempDeclK: return "vhpiGroupTempDeclK"; case vhpiIfGenerateK: return "vhpiIfGenerateK"; case vhpiIfStmtK: return "vhpiIfStmtK"; case vhpiInPortK: return "vhpiInPortK"; case vhpiIndexedNameK: return "vhpiIndexedNameK"; case vhpiIntLiteralK: return "vhpiIntLiteralK"; case vhpiIntRangeK: return "vhpiIntRangeK"; case vhpiIntTypeDeclK: return "vhpiIntTypeDeclK"; case vhpiIteratorK: return "vhpiIteratorK"; case vhpiLibraryDeclK: return "vhpiLibraryDeclK"; case DEPRECATED_vhpiLoopStmtK: return "DEPRECATED_vhpiLoopStmtK"; case vhpiNextStmtK: return "vhpiNextStmtK"; case vhpiNullLiteralK: return "vhpiNullLiteralK"; case vhpiNullStmtK: return "vhpiNullStmtK"; case DEPRECATED_vhpiOperatorK: return "DEPRECATED_vhpiOperatorK"; case vhpiOthersK: return "vhpiOthersK"; case vhpiOutPortK: return "vhpiOutPortK"; case vhpiPackBodyK: return "vhpiPackBodyK"; case vhpiPackDeclK: return "vhpiPackDeclK"; case vhpiPackInstK: return "vhpiPackInstK"; case vhpiParamAttrNameK: return "vhpiParamAttrNameK"; case vhpiPhysLiteralK: return "vhpiPhysLiteralK"; case vhpiPhysRangeK: return "vhpiPhysRangeK"; case vhpiPhysTypeDeclK: return "vhpiPhysTypeDeclK"; case vhpiPortDeclK: return "vhpiPortDeclK"; case DEPRECATED_vhpiProcCallStmtK: return "DEPRECATED_vhpiProcCallStmtK"; case vhpiProcDeclK: return "vhpiProcDeclK"; case vhpiProcessStmtK: return "vhpiProcessStmtK"; case DEPRECATED_vhpiProtectedTypeK: return "DEPRECATED_vhpiProtectedTypeK"; case vhpiProtectedTypeBodyK: return "vhpiProtectedTypeBodyK"; case vhpiProtectedTypeDeclK: return "vhpiProtectedTypeDeclK"; case vhpiRealLiteralK: return "vhpiRealLiteralK"; case vhpiRecordTypeDeclK: return "vhpiRecordTypeDeclK"; case vhpiReportStmtK: return "vhpiReportStmtK"; case vhpiReturnStmtK: return "vhpiReturnStmtK"; case vhpiRootInstK: return "vhpiRootInstK"; case vhpiSelectSigAssignStmtK: return "vhpiSelectSigAssignStmtK"; case vhpiSelectWaveformK: return "vhpiSelectWaveformK"; case vhpiSelectedNameK: return "vhpiSelectedNameK"; case vhpiSigDeclK: return "vhpiSigDeclK"; case vhpiSigParamDeclK: return "vhpiSigParamDeclK"; case vhpiSimpAttrNameK: return "vhpiSimpAttrNameK"; case vhpiSimpleSigAssignStmtK: return "vhpiSimpleSigAssignStmtK"; case vhpiSliceNameK: return "vhpiSliceNameK"; case vhpiStringLiteralK: return "vhpiStringLiteralK"; case vhpiSubpBodyK: return "vhpiSubpBodyK"; case vhpiSubtypeDeclK: return "vhpiSubtypeDeclK"; case DEPRECATED_vhpiSubtypeIndicK: return "DEPRECATED_vhpiSubtypeIndicK"; case vhpiToolK: return "vhpiToolK"; case vhpiTransactionK: return "vhpiTransactionK"; case vhpiTypeConvK: return "vhpiTypeConvK"; case DEPRECATED_vhpiUnaryExprK: return "DEPRECATED_vhpiUnaryExprK"; case vhpiUnitDeclK: return "vhpiUnitDeclK"; case vhpiUserAttrNameK: return "vhpiUserAttrNameK"; case vhpiVarAssignStmtK: return "vhpiVarAssignStmtK"; case vhpiVarDeclK: return "vhpiVarDeclK"; case vhpiVarParamDeclK: return "vhpiVarParamDeclK"; case vhpiWaitStmtK: return "vhpiWaitStmtK"; case vhpiWaveformElemK: return "vhpiWaveformElemK"; case vhpiWhileLoopK: return "vhpiWhileLoopK"; case vhpiQualifiedExprK: return "vhpiQualifiedExprK"; case vhpiUseClauseK: return "vhpiUseClauseK"; case vhpiConcAssertStmtK: return "vhpiConcAssertStmtK"; case vhpiConcProcCallStmtK: return "vhpiConcProcCallStmtK"; case vhpiForeverLoopK: return "vhpiForeverLoopK"; case vhpiSeqAssertStmtK: return "vhpiSeqAssertStmtK"; case vhpiSeqProcCallStmtK: return "vhpiSeqProcCallStmtK"; case vhpiSeqSigAssignStmtK: return "vhpiSeqSigAssignStmtK"; case vhpiProtectedTypeInstK: return "vhpiProtectedTypeInstK"; case vhpiVerilogModuleK: return "vhpiVerilogModuleK"; default: return vhpi_fallback_str(kind); } } const char *vhpi_one_to_one_str(vhpiOneToOneT kind) { switch (kind) { case vhpiAbstractLiteral: return "vhpiAbstractLiteral"; case vhpiActual: return "vhpiActual"; case vhpiAll: return "vhpiAll"; case vhpiAttrDecl: return "vhpiAttrDecl"; case vhpiAttrSpec: return "vhpiAttrSpec"; case vhpiBaseType: return "vhpiBaseType"; case vhpiBaseUnit: return "vhpiBaseUnit"; case DEPRECATED_vhpiBasicSignal: return "DEPRECATED_vhpiBasicSignal"; case vhpiBlockConfig: return "vhpiBlockConfig"; case vhpiCaseExpr: return "vhpiCaseExpr"; case vhpiCondExpr: return "vhpiCondExpr"; case vhpiConfigDecl: return "vhpiConfigDecl"; case vhpiConfigSpec: return "vhpiConfigSpec"; case vhpiConstraint: return "vhpiConstraint"; case vhpiContributor: return "vhpiContributor"; case vhpiCurCallback: return "vhpiCurCallback"; case DEPRECATED_vhpiCurEqProcess: return "DEPRECATED_vhpiCurEqProcess"; case vhpiCurStackFrame: return "vhpiCurStackFrame"; case vhpiDerefObj: return "vhpiDerefObj"; case DEPRECATED_vhpiDecl: return "DEPRECATED_vhpiDecl"; case vhpiDesignUnit: return "vhpiDesignUnit"; case vhpiDownStack: return "vhpiDownStack"; case DEPRECATED_vhpiElemSubtype: return "DEPRECATED_vhpiElemSubtype"; case vhpiEntityAspect: return "vhpiEntityAspect"; case vhpiEntityDecl: return "vhpiEntityDecl"; case vhpiEqProcessStmt: return "vhpiEqProcessStmt"; case vhpiExpr: return "vhpiExpr"; case vhpiFormal: return "vhpiFormal"; case vhpiFuncDecl: return "vhpiFuncDecl"; case vhpiGroupTempDecl: return "vhpiGroupTempDecl"; case vhpiGuardExpr: return "vhpiGuardExpr"; case vhpiGuardSig: return "vhpiGuardSig"; case vhpiImmRegion: return "vhpiImmRegion"; case vhpiInPort: return "vhpiInPort"; case vhpiInitExpr: return "vhpiInitExpr"; case DEPRECATED_vhpiIterScheme: return "DEPRECATED_vhpiIterScheme"; case vhpiLeftExpr: return "vhpiLeftExpr"; case vhpiLexicalScope: return "vhpiLexicalScope"; case vhpiLhsExpr: return "vhpiLhsExpr"; case vhpiLocal: return "vhpiLocal"; case vhpiLogicalExpr: return "vhpiLogicalExpr"; case DEPRECATED_vhpiName: return "DEPRECATED_vhpiName"; case DEPRECATED_vhpiOperator: return "DEPRECATED_vhpiOperator"; case vhpiOthers: return "vhpiOthers"; case vhpiOutPort: return "vhpiOutPort"; case vhpiParamDecl: return "vhpiParamDecl"; case DEPRECATED_vhpiParamExpr: return "DEPRECATED_vhpiParamExpr"; case vhpiParent: return "vhpiParent"; case vhpiPhysLiteral: return "vhpiPhysLiteral"; case vhpiPrefix: return "vhpiPrefix"; case vhpiPrimaryUnit: return "vhpiPrimaryUnit"; case vhpiProtectedTypeBody: return "vhpiProtectedTypeBody"; case vhpiProtectedTypeDecl: return "vhpiProtectedTypeDecl"; case vhpiRejectTime: return "vhpiRejectTime"; case vhpiReportExpr: return "vhpiReportExpr"; case vhpiResolFunc: return "vhpiResolFunc"; case vhpiReturnExpr: return "vhpiReturnExpr"; case DEPRECATED_vhpiReturnTypeMark: return "DEPRECATED_vhpiReturnTypeMark"; case vhpiRhsExpr: return "vhpiRhsExpr"; case vhpiRightExpr: return "vhpiRightExpr"; case vhpiRootInst: return "vhpiRootInst"; case vhpiSelectExpr: return "vhpiSelectExpr"; case vhpiSeverityExpr: return "vhpiSeverityExpr"; case vhpiSimpleName: return "vhpiSimpleName"; case vhpiSubpBody: return "vhpiSubpBody"; case vhpiSubpDecl: return "vhpiSubpDecl"; case DEPRECATED_vhpiSubtype: return "DEPRECATED_vhpiSubtype"; case vhpiSuffix: return "vhpiSuffix"; case vhpiTimeExpr: return "vhpiTimeExpr"; case vhpiTimeOutExpr: return "vhpiTimeOutExpr"; case vhpiTool: return "vhpiTool"; case vhpiType: return "vhpiType"; case DEPRECATED_vhpiTypeMark: return "DEPRECATED_vhpiTypeMark"; case vhpiUnitDecl: return "vhpiUnitDecl"; case vhpiUpStack: return "vhpiUpStack"; case vhpiUpperRegion: return "vhpiUpperRegion"; case vhpiUse: return "vhpiUse"; case vhpiValExpr: return "vhpiValExpr"; case DEPRECATED_vhpiValSubtype: return "DEPRECATED_vhpiValSubtype"; case vhpiElemType: return "vhpiElemType"; case vhpiFirstNamedType: return "vhpiFirstNamedType"; case vhpiReturnType: return "vhpiReturnType"; case vhpiValType: return "vhpiValType"; case vhpiCurRegion: return "vhpiCurRegion"; case vhpiSignal: return "vhpiSignal"; case vhpiLibraryDecl: return "vhpiLibraryDecl"; case vhpiSimNet: return "vhpiSimNet"; case vhpiAliasedName: return "vhpiAliasedName"; case vhpiCompDecl: return "vhpiCompDecl"; case vhpiProtectedTypeInst: return "vhpiProtectedTypeInst"; case vhpiGenIndex: return "vhpiGenIndex"; default: return vhpi_fallback_str(kind); } } const char *vhpi_one_to_many_str(vhpiOneToManyT kind) { switch (kind) { case vhpiAliasDecls: return "vhpiAliasDecls"; case vhpiArgvs: return "vhpiArgvs"; case vhpiAttrDecls: return "vhpiAttrDecls"; case vhpiAttrSpecs: return "vhpiAttrSpecs"; case vhpiBasicSignals: return "vhpiBasicSignals"; case vhpiBlockStmts: return "vhpiBlockStmts"; case vhpiBranchs: return "vhpiBranchs"; case vhpiChoices: return "vhpiChoices"; case vhpiCompInstStmts: return "vhpiCompInstStmts"; case DEPRECATED_vhpiCondExprs: return "DEPRECATED_vhpiCondExprs"; case vhpiCondWaveforms: return "vhpiCondWaveforms"; case vhpiConfigItems: return "vhpiConfigItems"; case vhpiConfigSpecs: return "vhpiConfigSpecs"; case vhpiConstDecls: return "vhpiConstDecls"; case vhpiConstraints: return "vhpiConstraints"; case DEPRECATED_vhpiContributors: return "DEPRECATED_vhpiContributors"; case vhpiDecls: return "vhpiDecls"; case vhpiDepUnits: return "vhpiDepUnits"; case vhpiDesignUnits: return "vhpiDesignUnits"; case vhpiDrivenSigs: return "vhpiDrivenSigs"; case vhpiDrivers: return "vhpiDrivers"; case vhpiElemAssocs: return "vhpiElemAssocs"; case DEPRECATED_vhpiEntityClassEntrys: return "DEPRECATED_vhpiEntityClassEntrys"; case vhpiEntityDesignators: return "vhpiEntityDesignators"; case vhpiEnumLiterals: return "vhpiEnumLiterals"; case vhpiForeignfs: return "vhpiForeignfs"; case vhpiGenericAssocs: return "vhpiGenericAssocs"; case vhpiGenericDecls: return "vhpiGenericDecls"; case vhpiIndexExprs: return "vhpiIndexExprs"; case vhpiIndexedNames: return "vhpiIndexedNames"; case vhpiInternalRegions: return "vhpiInternalRegions"; case vhpiMembers: return "vhpiMembers"; case vhpiPackInsts: return "vhpiPackInsts"; case vhpiParamAssocs: return "vhpiParamAssocs"; case vhpiParamDecls: return "vhpiParamDecls"; case vhpiPortAssocs: return "vhpiPortAssocs"; case vhpiPortDecls: return "vhpiPortDecls"; case vhpiRecordElems: return "vhpiRecordElems"; case vhpiSelectWaveforms: return "vhpiSelectWaveforms"; case vhpiSelectedNames: return "vhpiSelectedNames"; case DEPRECATED_vhpiSensitivitys: return "DEPRECATED_vhpiSensitivitys"; case vhpiSeqStmts: return "vhpiSeqStmts"; case vhpiSigAttrs: return "vhpiSigAttrs"; case vhpiSigDecls: return "vhpiSigDecls"; case vhpiSigNames: return "vhpiSigNames"; case vhpiSignals: return "vhpiSignals"; case DEPRECATED_vhpiSpecNames: return "DEPRECATED_vhpiSpecNames"; case vhpiSpecs: return "vhpiSpecs"; case vhpiStmts: return "vhpiStmts"; case vhpiTransactions: return "vhpiTransactions"; case DEPRECATED_vhpiTypeMarks: return "DEPRECATED_vhpiTypeMarks"; case vhpiUnitDecls: return "vhpiUnitDecls"; case vhpiUses: return "vhpiUses"; case vhpiVarDecls: return "vhpiVarDecls"; case vhpiWaveformElems: return "vhpiWaveformElems"; case vhpiLibraryDecls: return "vhpiLibraryDecls"; case vhpiLocalLoads: return "vhpiLocalLoads"; case vhpiOptimizedLoads: return "vhpiOptimizedLoads"; case vhpiTypes: return "vhpiTypes"; case vhpiUseClauses: return "vhpiUseClauses"; case vhpiGenerateStmts: return "vhpiGenerateStmts"; case vhpiLocalContributors: return "vhpiLocalContributors"; case vhpiOptimizedContributors: return "vhpiOptimizedContributors"; case vhpiParamExprs: return "vhpiParamExprs"; case vhpiEqProcessStmts: return "vhpiEqProcessStmts"; case vhpiEntityClassEntries: return "vhpiEntityClassEntries"; case vhpiSensitivities: return "vhpiSensitivities"; default: return vhpi_fallback_str(kind); } } const char *vhpi_cb_reason_str(int reason) { switch (reason) { case vhpiCbValueChange: return "vhpiCbValueChange"; case vhpiCbForce: return "vhpiCbForce"; case vhpiCbRelease: return "vhpiCbRelease"; case vhpiCbTransaction: return "vhpiCbTransaction"; case vhpiCbStmt: return "vhpiCbStmt"; case vhpiCbResume: return "vhpiCbResume"; case vhpiCbSuspend: return "vhpiCbSuspend"; case vhpiCbStartOfSubpCall: return "vhpiCbStartOfSubpCall"; case vhpiCbEndOfSubpCall: return "vhpiCbEndOfSubpCall"; case vhpiCbAfterDelay: return "vhpiCbAfterDelay"; case vhpiCbRepAfterDelay: return "vhpiCbRepAfterDelay"; case vhpiCbNextTimeStep: return "vhpiCbNextTimeStep"; case vhpiCbRepNextTimeStep: return "vhpiCbRepNextTimeStep"; case vhpiCbStartOfNextCycle: return "vhpiCbStartOfNextCycle"; case vhpiCbRepStartOfNextCycle: return "vhpiCbRepStartOfNextCycle"; case vhpiCbStartOfProcesses: return "vhpiCbStartOfProcesses"; case vhpiCbRepStartOfProcesses: return "vhpiCbRepStartOfProcesses"; case vhpiCbEndOfProcesses: return "vhpiCbEndOfProcesses"; case vhpiCbRepEndOfProcesses: return "vhpiCbRepEndOfProcesses"; case vhpiCbLastKnownDeltaCycle: return "vhpiCbLastKnownDeltaCycle"; case vhpiCbRepLastKnownDeltaCycle: return "vhpiCbRepLastKnownDeltaCycle"; case vhpiCbStartOfPostponed: return "vhpiCbStartOfPostponed"; case vhpiCbRepStartOfPostponed: return "vhpiCbRepStartOfPostponed"; case vhpiCbEndOfTimeStep: return "vhpiCbEndOfTimeStep"; case vhpiCbRepEndOfTimeStep: return "vhpiCbRepEndOfTimeStep"; case vhpiCbStartOfTool: return "vhpiCbStartOfTool"; case vhpiCbEndOfTool: return "vhpiCbEndOfTool"; case vhpiCbStartOfAnalysis: return "vhpiCbStartOfAnalysis"; case vhpiCbEndOfAnalysis: return "vhpiCbEndOfAnalysis"; case vhpiCbStartOfElaboration: return "vhpiCbStartOfElaboration"; case vhpiCbEndOfElaboration: return "vhpiCbEndOfElaboration"; case vhpiCbStartOfInitialization: return "vhpiCbStartOfInitialization"; case vhpiCbEndOfInitialization: return "vhpiCbEndOfInitialization"; case vhpiCbStartOfSimulation: return "vhpiCbStartOfSimulation"; case vhpiCbEndOfSimulation: return "vhpiCbEndOfSimulation"; case vhpiCbQuiescense: return "vhpiCbQuiescense"; case vhpiCbPLIError: return "vhpiCbPLIError"; case vhpiCbStartOfSave: return "vhpiCbStartOfSave"; case vhpiCbEndOfSave: return "vhpiCbEndOfSave"; case vhpiCbStartOfRestart: return "vhpiCbStartOfRestart"; case vhpiCbEndOfRestart: return "vhpiCbEndOfRestart"; case vhpiCbStartOfReset: return "vhpiCbStartOfReset"; case vhpiCbEndOfReset: return "vhpiCbEndOfReset"; case vhpiCbEnterInteractive: return "vhpiCbEnterInteractive"; case vhpiCbExitInteractive: return "vhpiCbExitInteractive"; case vhpiCbSigInterrupt: return "vhpiCbSigInterrupt"; case vhpiCbTimeOut: return "vhpiCbTimeOut"; case vhpiCbRepTimeOut: return "vhpiCbRepTimeOut"; case vhpiCbSensitivity: return "vhpiCbSensitivity"; default: return vhpi_fallback_str(reason); } } const char *vhpi_put_value_mode_str(vhpiPutValueModeT mode) { switch (mode) { case vhpiDeposit: return "vhpiDeposit"; case vhpiDepositPropagate: return "vhpiDepositPropagate"; case vhpiForce: return "vhpiForce"; case vhpiForcePropagate: return "vhpiForcePropagate"; case vhpiRelease: return "vhpiRelease"; case vhpiSizeConstraint: return "vhpiSizeConstraint"; default: return vhpi_fallback_str(mode); } } const char *vhpi_state_str(vhpiStateT state) { switch (state) { case vhpiEnable: return "vhpiEnable"; case vhpiDisable: return "vhpiDisable"; case vhpiMature: return "vhpiMature"; default: return vhpi_fallback_str(state); } } const char *vhpi_format_str(vhpiFormatT format) { switch (format) { case vhpiBinStrVal: return "vhpiBinStrVal"; case vhpiOctStrVal: return "vhpiOctStrVal"; case vhpiDecStrVal: return "vhpiDecStrVal"; case vhpiHexStrVal: return "vhpiHexStrVal"; case vhpiEnumVal: return "vhpiEnumVal"; case vhpiIntVal: return "vhpiIntVal"; case vhpiLongIntVal: return "vhpiLongIntVal"; case vhpiLogicVal: return "vhpiLogicVal"; case vhpiRealVal: return "vhpiRealVal"; case vhpiStrVal: return "vhpiStrVal"; case vhpiCharVal: return "vhpiCharVal"; case vhpiObjTypeVal: return "vhpiObjTypeVal"; case vhpiLogicVecVal: return "vhpiLogicVecVal"; default: return vhpi_fallback_str(format); } } LCOV_EXCL_STOP nvc-r1.17.1/src/vhpi/vhpi-util.c000066400000000000000000000211151504111170000163610ustar00rootroot00000000000000// // Copyright (C) 2014-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "debug.h" #include "diag.h" #include "jit/jit-ffi.h" #include "option.h" #include "rt/assert.h" #include "type.h" #include "vhpi/vhpi-macros.h" #include "vhpi/vhpi-util.h" #include #include #include #include #include static __thread vhpiErrorInfoT last_error; //////////////////////////////////////////////////////////////////////////////// // Public API DLLEXPORT const vhpiPhysT vhpiFS = { 0, 1 }; DLLEXPORT const vhpiPhysT vhpiPS = { 0, 0x3e8 }; DLLEXPORT const vhpiPhysT vhpiNS = { 0, 0xf4240 }; DLLEXPORT const vhpiPhysT vhpiUS = { 0, 0x3b9aca00 }; DLLEXPORT const vhpiPhysT vhpiMS = { 0xe8, 0xd4a51000 }; DLLEXPORT const vhpiPhysT vhpiS = { 0x38d7e, 0xa4c68000 }; DLLEXPORT const vhpiPhysT vhpiMN = { 0xd529ae, 0x9e860000 }; DLLEXPORT const vhpiPhysT vhpiHR = { 0x31f5c4ed, 0x27680000 }; DLLEXPORT int vhpi_printf(const char *format, ...) { vhpi_clear_error(); va_list ap; va_start(ap, format); const int ret = vhpi_vprintf(format, ap); va_end(ap); return ret; } DLLEXPORT int vhpi_vprintf(const char *format, va_list args) { vhpi_clear_error(); char *buf LOCAL = xvasprintf(format, args); size_t len = strlen(buf); for (char *eptr = buf + len - 1; eptr >= buf && *eptr == '\n'; eptr--, len--) *eptr = '\0'; diag_t *d = diag_new(DIAG_NOTE, NULL); diag_write(d, buf, len); diag_emit(d); return len; } DLLEXPORT int vhpi_check_error(vhpiErrorInfoT *error_info_p) { if (last_error.severity == 0) return 0; else { *error_info_p = last_error; return last_error.severity; } } DLLEXPORT int vhpi_assert(vhpiSeverityT severity, char *formatmsg, ...) { vhpi_clear_error(); VHPI_TRACE("severity=%d formatmsg=\"%s\"", severity, formatmsg); vhdl_severity_t vhdl = SEVERITY_ERROR; switch (severity) { case vhpiNote: vhdl = SEVERITY_NOTE; break; case vhpiWarning: vhdl = SEVERITY_WARNING; break; case vhpiError: vhdl = SEVERITY_ERROR; break; case vhpiFailure: case vhpiSystem: case vhpiInternal: vhdl = SEVERITY_FAILURE; break; } va_list ap; va_start(ap, formatmsg); diag_t *d = diag_new(get_diag_severity(vhdl), NULL); diag_vprintf(d, formatmsg, ap); va_end(ap); emit_vhdl_diag(d, vhdl); return 0; } DLLEXPORT int vhpi_is_printable(char ch) { return isprint_iso88591(ch); } //////////////////////////////////////////////////////////////////////////////// // Internal interface int _vhpi_trace_on(void) { static int trace_on = -1; if (trace_on == -1) trace_on = opt_get_verbose(OPT_PLI_TRACE, NULL); return trace_on; } void vhpi_trace(const char *func, const char *fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(stderr, "VHPI: %s ", func); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); } void vhpi_clear_error(void) { last_error.severity = 0; } void vhpi_error(vhpiSeverityT sev, const loc_t *loc, const char *fmt, ...) { vhpi_clear_error(); last_error.severity = sev; last_error.str = NULL; if (!loc_invalid_p(loc)) { last_error.file = (char *)loc_file_str(loc); last_error.line = loc->first_line; } free(last_error.message); va_list ap; va_start(ap, fmt); last_error.message = xvasprintf(fmt, ap); va_end(ap); static const diag_level_t map[] = { [vhpiNote] = DIAG_NOTE, [vhpiWarning] = DIAG_WARN, [vhpiError] = DIAG_ERROR, [vhpiFailure] = DIAG_FATAL, [vhpiSystem] = DIAG_ERROR, [vhpiInternal] = DIAG_FATAL, }; if (!opt_get_int(OPT_PLI_DEBUG)) return; // Also report the error as a diagnostic for debugging diag_t *d = diag_new(sev < ARRAY_LEN(map) ? map[sev] : DIAG_ERROR, loc); diag_printf(d, "%s", last_error.message); debug_info_t *trace = debug_capture(); const debug_frame_t *last_prog = NULL, *first_lib = NULL; const int nframes = debug_count_frames(trace); for (int i = 0; i < nframes; i++) { const debug_frame_t *f = debug_get_frame(trace, i); if (f->kind == FRAME_PROG) last_prog = f; else if (f->kind == FRAME_LIB) { first_lib = f; break; } } if (last_prog != NULL && strncmp(last_prog->symbol, "vhpi", 4) == 0) diag_hint(d, NULL, "in call to VHPI function $bold$%s$$", last_prog->symbol); if (first_lib != NULL) diag_hint(d, NULL, "called from user function $bold$%s$$ " "at %s:%d", first_lib->symbol, first_lib->srcfile, first_lib->lineno); debug_free(trace); diag_emit(d); } rt_event_t vhpi_get_rt_event(int reason) { switch (reason){ case vhpiCbNextTimeStep: case vhpiCbRepNextTimeStep: return RT_NEXT_TIME_STEP; case vhpiCbStartOfNextCycle: case vhpiCbRepStartOfNextCycle: return RT_NEXT_CYCLE; case vhpiCbEndOfTimeStep: case vhpiCbRepEndOfTimeStep: return RT_END_TIME_STEP; case vhpiCbRepEndOfProcesses: case vhpiCbEndOfProcesses: return RT_END_OF_PROCESSES; case vhpiCbStartOfSimulation: return RT_START_OF_SIMULATION; case vhpiCbEndOfSimulation: return RT_END_OF_SIMULATION; case vhpiCbRepLastKnownDeltaCycle: case vhpiCbLastKnownDeltaCycle: return RT_LAST_KNOWN_DELTA_CYCLE; case vhpiCbEndOfInitialization: return RT_END_OF_INITIALISATION; default: fatal_trace("unhandled value %d in vhpi_get_rt_event", reason); } } vhpiFormatT vhpi_format_for_type(type_t type, const char **map_str) { type_t base = type_base_recur(type); *map_str = NULL; switch (type_kind(base)) { case T_ENUM: switch (is_well_known(type_ident(base))) { case W_IEEE_LOGIC: case W_IEEE_ULOGIC: *map_str = "UX01ZWLH-"; return vhpiLogicVal; case W_STD_BIT: *map_str = "01"; return vhpiLogicVal; case W_STD_CHAR: return vhpiCharVal; default: if (type_enum_literals(base) <= 256) return vhpiSmallEnumVal; else return vhpiEnumVal; } break; case T_INTEGER: return vhpiIntVal; case T_REAL: return vhpiRealVal; case T_ARRAY: { type_t elem = type_base_recur(type_elem(base)); switch (type_kind(elem)) { case T_ENUM: { switch (is_well_known(type_ident(elem))) { case W_IEEE_LOGIC: case W_IEEE_ULOGIC: *map_str = "UX01ZWLH-"; return vhpiLogicVecVal; case W_STD_BIT: *map_str = "01"; return vhpiLogicVecVal; case W_STD_CHAR: return vhpiStrVal; default: if (type_enum_literals(elem) <= 256) return vhpiSmallEnumVecVal; else return vhpiEnumVecVal; } break; } case T_REAL: return vhpiRealVecVal; case T_INTEGER: return vhpiIntVecVal; default: break; } } break; default: break; } return (vhpiFormatT)-1; // Not supported } vhpiPhysT vhpi_phys_from_native(int64_t value) { const vhpiPhysT result = { .low = value & 0xffffffff, .high = value >> 32 }; return result; } uint64_t vhpi_time_to_native(const vhpiTimeT *time) { return ((uint64_t)time->high << 32) | (uint64_t)time->low; } void vhpi_load_plugins(const char *plugins) { char *plugins_copy LOCAL = xstrdup(plugins); char *tok = strtok(plugins_copy, ","); do { notef("loading VHPI plugin %s", tok); jit_dll_t *dll = ffi_load_dll(tok); void (**startup_funcs)() = ffi_find_symbol(dll, "vhpi_startup_routines"); if (startup_funcs != NULL) { while (*startup_funcs) (*startup_funcs++)(); } } while ((tok = strtok(NULL, ","))); } nvc-r1.17.1/src/vhpi/vhpi-util.h000066400000000000000000000044251504111170000163730ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VHPI_UTIL_H #define _VHPI_UTIL_H #include "prim.h" #include "jit/jit.h" #include "rt/rt.h" #ifdef __MINGW32__ #define PLI_DLLISPEC __declspec(dllexport) #define PLI_DLLESPEC #else #define PLI_DLLISPEC #define PLI_DLLESPEC #endif #include "vhpi/vhpi_user.h" __attribute__((format(printf, 2, 3))) void vhpi_trace(const char *func, const char *fmt, ...); __attribute__((format(printf, 3, 4))) void vhpi_error(vhpiSeverityT sev, const loc_t *loc, const char *fmt, ...); vhpi_context_t *vhpi_context_new(void); void vhpi_context_initialise(vhpi_context_t *c, tree_t top, rt_model_t *model, jit_t *jit, int argc, char **argv); void vhpi_context_free(vhpi_context_t *c); void vhpi_load_plugins(const char *plugins); void vhpi_clear_error(void); rt_event_t vhpi_get_rt_event(int reason); vhpiFormatT vhpi_format_for_type(type_t type, const char **map_str); uint64_t vhpi_time_to_native(const vhpiTimeT *time); vhpiPhysT vhpi_phys_from_native(int64_t value); vhpiHandleT vhpi_bind_foreign(const char *obj_lib, const char *model, tree_t where); void vhpi_call_foreign(vhpiHandleT handle, jit_scalar_t *args, tlab_t *tlab); const char *vhpi_cb_reason_str(int reason); const char *vhpi_one_to_many_str(vhpiOneToManyT kind); const char *vhpi_one_to_one_str(vhpiOneToOneT kind); const char *vhpi_class_str(vhpiClassKindT kind); const char *vhpi_property_str(int property); const char *vhpi_put_value_mode_str(vhpiPutValueModeT mode); const char *vhpi_state_str(vhpiStateT state); const char *vhpi_format_str(vhpiFormatT format); #endif // _VHPI_UTIL_H nvc-r1.17.1/src/vhpi/vhpi_sens.c000066400000000000000000000076561504111170000164540ustar00rootroot00000000000000/* -------------------------------------------------------------------- * * Copyright 2019 IEEE P1076 WG Authors * * See the LICENSE file distributed with this work for copyright and * licensing information and the AUTHORS file. * * This file to you under the Apache License, Version 2.0 (the "License"). * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. * * * Title : vhpi_sens.c * : * Developers: IEEE P1076 Working Group, VHPI Task Force * : * Purpose : This file defines function for manipulating * : sensitivity-set bitmaps. The definitions of the macros * : in the header file invoke functions defined in this file. * : * Note : A tool provider may replace the definitions with * : implementation-specific definitions that have the effect * : described in this clause. Such definitions may invoke * : implementation-defined functions or may be in the form * : of in-line code. * : * -------------------------------------------------------------------- * modification history : * -------------------------------------------------------------------- * $Revision: 1219 $ * $Date: 2008-04-10 16:40:28 +0930 (Thu, 10 Apr 2008) $ * -------------------------------------------------------------------- */ #include #include "vhpi_user.h" #define BITS_vhpiIntT (CHAR_BIT * sizeof(vhpiIntT)) int vhpi_sens_first(vhpiValueT *sens) { int i; vhpiIntT t; if (sens->format != vhpiIntVecVal) return -1; for (i = 0; i < sens->numElems; i++) { if ((t = sens->value.intgs[i])) { int f; for (f = 0; f < BITS_vhpiIntT; f++) { if (t & (1 << f)) return f + (i * BITS_vhpiIntT); } } } return -1; } int vhpi_sens_zero(vhpiValueT *sens) { int i; if (sens->format != vhpiIntVecVal) return -1; for (i = 0; i < sens->numElems; i++) { sens->value.intgs[i] = 0; } return 0; } int vhpi_sens_clr(int obj, vhpiValueT *sens) { int i, r; if (sens->format != vhpiIntVecVal) return -1; if (obj >= (sens->numElems * BITS_vhpiIntT)) return -1; i = obj / BITS_vhpiIntT; r = obj % BITS_vhpiIntT; sens->value.intgs[i] &= ~(1 << r); return 0; } int vhpi_sens_set(int obj, vhpiValueT *sens) { int i, r; if (sens->format != vhpiIntVecVal) return -1; if (obj >= (sens->numElems * BITS_vhpiIntT)) return -1; i = obj / BITS_vhpiIntT; r = obj % BITS_vhpiIntT; sens->value.intgs[i] |= (1 << r); return 0; } int vhpi_sens_isset(int obj, vhpiValueT *sens) { int i, r; if (sens->format != vhpiIntVecVal) return -1; if (obj >= (sens->numElems * BITS_vhpiIntT)) return -1; i = obj / BITS_vhpiIntT; r = obj % BITS_vhpiIntT; return (sens->value.intgs[i] & (1 << r)) ? 1 : 0; } #ifdef REGRESS_TEST main() { int i; vhpiValueT sens; vhpiValueT *s = &sens; s->numElems = 4; s->format = vhpiIntVecVal; s->value.intgs = (vhpiIntT *) malloc(4 * sizeof(vhpiIntT)); #define TRACE(action, arg, result) { int r = (result); printf("%s\t%d\t%d\t%08x %08x %08x %08x\n", action, arg, r, s->value.intgs[0], s->value.intgs[1], s->value.intgs[2], s->value.intgs[3]); } TRACE("START", 0, 0); TRACE("ZERO", 0, vhpi_sens_zero(s)); for (i = 0; i < ((4 * BITS_vhpiIntT) + 1); i++) { TRACE("ISSET", i, vhpi_sens_isset(i, s)); TRACE("SET", i, vhpi_sens_set(i, s)); TRACE("ISSET", i, vhpi_sens_isset(i, s)); TRACE("FIRST", 0, vhpi_sens_first(s)); TRACE("ISSET", (i-1), vhpi_sens_isset((i-1), s)); TRACE("CLR", (i - 1), vhpi_sens_clr((i-1), s)); TRACE("ISSET", (i-1), vhpi_sens_isset((i-1), s)); } } #endif nvc-r1.17.1/src/vhpi/vhpi_user.h000066400000000000000000001103151504111170000164520ustar00rootroot00000000000000/* -------------------------------------------------------------------- * * Copyright 2019 IEEE P1076 WG Authors * * See the LICENSE file distributed with this work for copyright and * licensing information and the AUTHORS file. * * This file to you under the Apache License, Version 2.0 (the "License"). * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. * * * Title : vhpi_user.h * : * Developers: IEEE P1076 Working Group, VHPI Task Force * : * Purpose : This header file describes the procedural interface * : to access VHDL compiled, instantiated and run-time * : data.It is derived from the UML model. For conformance * : with the VHPI standard, a VHPI application or program * : shall reference this header file. * : * Note : The contents of this file may be modified in an * : implementation to provide implementation-defined * : functionality, as described in B.3. * : * -------------------------------------------------------------------- * modification history : * -------------------------------------------------------------------- * $Revision: 1315 $ * $Date: 2008-07-13 10:11:53 +0930 (Sun, 13 Jul 2008) $ * -------------------------------------------------------------------- */ #ifndef VHPI_USER_H #define VHPI_USER_H #include #include /* Ensure that size-critical types are defined on all OS platforms. */ #if defined (_MSC_VER) typedef unsigned __int64 uint64_t; typedef unsigned __int32 uint32_t; typedef unsigned __int8 uint8_t; typedef signed __int64 int64_t; typedef signed __int32 int32_t; typedef signed __int8 int8_t; #elif defined(__MINGW32__) || defined(__APPLE__) #include #elif defined(__linux) #include #else #include #endif #ifdef __cplusplus extern "C" { #endif /*--------------------------------------------------------------------*/ /*--------------------------- Portability Help -----------------------*/ /*--------------------------------------------------------------------*/ /* Use to export a symbol */ #if defined (_MSC_VER) || defined (__MINGW32__) || defined (__CYGWIN__) #ifndef PLI_DLLISPEC #define PLI_DLLISPEC __declspec(dllimport) #define VHPI_USER_DEFINED_DLLISPEC 1 #endif #else #ifndef PLI_DLLISPEC #define PLI_DLLISPEC #endif #endif /* Use to import a symbol */ #if defined (_MSC_VER) || defined (__MINGW32__) || defined (__CYGWIN__) #ifndef PLI_DLLESPEC #define PLI_DLLESPEC __declspec(dllexport) #define VHPI_USER_DEFINED_DLLESPEC 1 #endif #else #ifndef PLI_DLLESPEC #define PLI_DLLESPEC #endif #endif /* Use to mark a function as external */ #ifndef PLI_EXTERN #define PLI_EXTERN #endif /* Use to mark a variable as external */ #ifndef PLI_VEXTERN #define PLI_VEXTERN extern #endif #ifndef PLI_PROTOTYPES #define PLI_PROTOTYPES /* object is defined imported by the application */ #define XXTERN PLI_EXTERN PLI_DLLISPEC /* object is exported by the application */ #define EETERN PLI_EXTERN PLI_DLLESPEC #endif /* basic typedefs */ #ifndef VHPI_TYPES #define VHPI_TYPES typedef uint32_t *vhpiHandleT; typedef uint32_t vhpiEnumT; typedef uint8_t vhpiSmallEnumT; typedef int32_t vhpiIntT; typedef int64_t vhpiLongIntT; typedef unsigned char vhpiCharT; typedef double vhpiRealT; typedef int32_t vhpiSmallPhysT; typedef struct vhpiPhysS { int32_t high; uint32_t low; } vhpiPhysT; /********************** time structure ****************************/ typedef struct vhpiTimeS { int32_t high; uint32_t low; } vhpiTimeT; /********************** value structure **************************/ /* value formats */ typedef enum { vhpiBinStrVal = 1, /* do not move */ vhpiOctStrVal = 2, /* do not move */ vhpiDecStrVal = 3, /* do not move */ vhpiHexStrVal = 4, /* do not move */ vhpiEnumVal = 5, vhpiIntVal = 6, vhpiLogicVal = 7, vhpiRealVal = 8, vhpiStrVal = 9, vhpiCharVal = 10, vhpiTimeVal = 11, vhpiPhysVal = 12, vhpiObjTypeVal = 13, vhpiPtrVal = 14, vhpiEnumVecVal = 15, vhpiIntVecVal = 16, vhpiLogicVecVal = 17, vhpiRealVecVal = 18, vhpiTimeVecVal = 19, vhpiPhysVecVal = 20, vhpiPtrVecVal = 21, vhpiRawDataVal = 22, vhpiSmallEnumVal = 23, vhpiSmallEnumVecVal = 24, vhpiLongIntVal = 25, vhpiLongIntVecVal = 26, vhpiSmallPhysVal = 27, vhpiSmallPhysVecVal = 28 #ifdef VHPIEXTEND_VAL_FORMATS VHPIEXTEND_VAL_FORMATS #endif } vhpiFormatT; /* value structure */ typedef struct vhpiValueS { vhpiFormatT format; /* vhpi[Char,[Bin,Oct,Dec,Hex]Str, [Small]Enum,Logic,Int,Real, [Small]Phys,Time,Ptr, [Small]EnumVec,LogicVec,IntVect,RealVec, [Small]PhysVec,TimeVec, PtrVec,ObjType,RawData]Val */ size_t bufSize; /* the size in bytes of the value buffer; this is set by the user */ int32_t numElems; /* different meanings depending on the format: vhpiStrVal, vhpi{Bin...}StrVal: size of string array type values: number of array elements scalar type values: undefined */ vhpiPhysT unit; union { vhpiEnumT enumv, *enumvs; vhpiSmallEnumT smallenumv, *smallenumvs; vhpiIntT intg, *intgs; vhpiLongIntT longintg, *longintgs; vhpiRealT real, *reals; vhpiSmallPhysT smallphys, *smallphyss; vhpiPhysT phys, *physs; vhpiTimeT time, *times; vhpiCharT ch, *str; void *ptr, **ptrs; } value; } vhpiValueT; #endif /* Following are the constant definitions. They are divided into three major areas: 1) object types 2) access methods 3) properties */ #define vhpiUndefined -1 /*************** OBJECT KINDS *******************/ typedef enum { vhpiAccessTypeDeclK = 1001, vhpiAggregateK = 1002, vhpiAliasDeclK = 1003, vhpiAllK = 1004, vhpiAllocatorK = 1005, vhpiAnyCollectionK = 1006, vhpiArchBodyK = 1007, vhpiArgvK = 1008, vhpiArrayTypeDeclK = 1009, DEPRECATED_vhpiAssertStmtK = 1010, vhpiAssocElemK = 1011, vhpiAttrDeclK = 1012, vhpiAttrSpecK = 1013, DEPRECATED_vhpiBinaryExprK = 1014, vhpiBitStringLiteralK = 1015, vhpiBlockConfigK = 1016, vhpiBlockStmtK = 1017, vhpiBranchK = 1018, vhpiCallbackK = 1019, vhpiCaseStmtK = 1020, vhpiCharLiteralK = 1021, vhpiCompConfigK = 1022, vhpiCompDeclK = 1023, vhpiCompInstStmtK = 1024, vhpiCondSigAssignStmtK = 1025, vhpiCondWaveformK = 1026, vhpiConfigDeclK = 1027, vhpiConstDeclK = 1028, vhpiConstParamDeclK = 1029, vhpiConvFuncK = 1030, vhpiDerefObjK = 1031, vhpiDisconnectSpecK = 1032, vhpiDriverK = 1033, vhpiDriverCollectionK = 1034, vhpiElemAssocK = 1035, vhpiElemDeclK = 1036, vhpiEntityClassEntryK = 1037, vhpiEntityDeclK = 1038, vhpiEnumLiteralK = 1039, vhpiEnumRangeK = 1040, vhpiEnumTypeDeclK = 1041, vhpiExitStmtK = 1042, vhpiFileDeclK = 1043, vhpiFileParamDeclK = 1044, vhpiFileTypeDeclK = 1045, vhpiFloatRangeK = 1046, vhpiFloatTypeDeclK = 1047, vhpiForGenerateK = 1048, vhpiForLoopK = 1049, vhpiForeignfK = 1050, vhpiFuncCallK = 1051, vhpiFuncDeclK = 1052, vhpiGenericDeclK = 1053, vhpiGroupDeclK = 1054, vhpiGroupTempDeclK = 1055, vhpiIfGenerateK = 1056, vhpiIfStmtK = 1057, vhpiInPortK = 1058, vhpiIndexedNameK = 1059, vhpiIntLiteralK = 1060, vhpiIntRangeK = 1061, vhpiIntTypeDeclK = 1062, vhpiIteratorK = 1063, vhpiLibraryDeclK = 1064, DEPRECATED_vhpiLoopStmtK = 1065, vhpiNextStmtK = 1066, vhpiNullLiteralK = 1067, vhpiNullStmtK = 1068, DEPRECATED_vhpiOperatorK = 1069, vhpiOthersK = 1070, vhpiOutPortK = 1071, vhpiPackBodyK = 1072, vhpiPackDeclK = 1073, vhpiPackInstK = 1074, vhpiParamAttrNameK = 1075, vhpiPhysLiteralK = 1076, vhpiPhysRangeK = 1077, vhpiPhysTypeDeclK = 1078, vhpiPortDeclK = 1079, DEPRECATED_vhpiProcCallStmtK = 1080, vhpiProcDeclK = 1081, vhpiProcessStmtK = 1082, DEPRECATED_vhpiProtectedTypeK = 1083, vhpiProtectedTypeBodyK = 1084, vhpiProtectedTypeDeclK = 1085, vhpiRealLiteralK = 1086, vhpiRecordTypeDeclK = 1087, vhpiReportStmtK = 1088, vhpiReturnStmtK = 1089, vhpiRootInstK = 1090, vhpiSelectSigAssignStmtK = 1091, vhpiSelectWaveformK = 1092, vhpiSelectedNameK = 1093, vhpiSigDeclK = 1094, vhpiSigParamDeclK = 1095, vhpiSimpAttrNameK = 1096, vhpiSimpleSigAssignStmtK = 1097, vhpiSliceNameK = 1098, vhpiStringLiteralK = 1099, vhpiSubpBodyK = 1100, vhpiSubtypeDeclK = 1101, DEPRECATED_vhpiSubtypeIndicK = 1102, vhpiToolK = 1103, vhpiTransactionK = 1104, vhpiTypeConvK = 1105, DEPRECATED_vhpiUnaryExprK = 1106, vhpiUnitDeclK = 1107, vhpiUserAttrNameK = 1108, vhpiVarAssignStmtK = 1109, vhpiVarDeclK = 1110, vhpiVarParamDeclK = 1111, vhpiWaitStmtK = 1112, vhpiWaveformElemK = 1113, vhpiWhileLoopK = 1114, vhpiQualifiedExprK = 1115, vhpiUseClauseK = 1116, vhpiConcAssertStmtK = 1117, vhpiConcProcCallStmtK = 1118, vhpiForeverLoopK = 1119, vhpiSeqAssertStmtK = 1120, vhpiSeqProcCallStmtK = 1121, vhpiSeqSigAssignStmtK = 1122, vhpiProtectedTypeInstK = 1123, #ifdef VHPIEXTEND_CLASSES VHPIEXTEND_CLASSES #endif vhpiVerilogModuleK = 2001, } vhpiClassKindT; /********* methods used to traverse 1 to 1 relationships **************/ typedef enum { vhpiAbstractLiteral = 1301, vhpiActual = 1302, vhpiAll = 1303, vhpiAttrDecl = 1304, vhpiAttrSpec = 1305, vhpiBaseType = 1306, vhpiBaseUnit = 1307, DEPRECATED_vhpiBasicSignal = 1308, vhpiBlockConfig = 1309, vhpiCaseExpr = 1310, vhpiCondExpr = 1311, vhpiConfigDecl = 1312, vhpiConfigSpec = 1313, vhpiConstraint = 1314, vhpiContributor = 1315, vhpiCurCallback = 1316, DEPRECATED_vhpiCurEqProcess = 1317, vhpiCurStackFrame = 1318, vhpiDerefObj = 1319, DEPRECATED_vhpiDecl = 1320, vhpiDesignUnit = 1321, vhpiDownStack = 1322, DEPRECATED_vhpiElemSubtype = 1323, vhpiEntityAspect = 1324, vhpiEntityDecl = 1325, vhpiEqProcessStmt = 1326, vhpiExpr = 1327, vhpiFormal = 1328, vhpiFuncDecl = 1329, vhpiGroupTempDecl = 1330, vhpiGuardExpr = 1331, vhpiGuardSig = 1332, vhpiImmRegion = 1333, vhpiInPort = 1334, vhpiInitExpr = 1335, DEPRECATED_vhpiIterScheme = 1336, vhpiLeftExpr = 1337, vhpiLexicalScope = 1338, vhpiLhsExpr = 1339, vhpiLocal = 1340, vhpiLogicalExpr = 1341, DEPRECATED_vhpiName = 1342, DEPRECATED_vhpiOperator = 1343, vhpiOthers = 1344, vhpiOutPort = 1345, vhpiParamDecl = 1346, DEPRECATED_vhpiParamExpr = 1347, vhpiParent = 1348, vhpiPhysLiteral = 1349, vhpiPrefix = 1350, vhpiPrimaryUnit = 1351, vhpiProtectedTypeBody = 1352, vhpiProtectedTypeDecl = 1353, vhpiRejectTime = 1354, vhpiReportExpr = 1355, vhpiResolFunc = 1356, vhpiReturnExpr = 1357, DEPRECATED_vhpiReturnTypeMark = 1358, vhpiRhsExpr = 1359, vhpiRightExpr = 1360, vhpiRootInst = 1361, vhpiSelectExpr = 1362, vhpiSeverityExpr = 1363, vhpiSimpleName = 1364, vhpiSubpBody = 1365, vhpiSubpDecl = 1366, DEPRECATED_vhpiSubtype = 1367, vhpiSuffix = 1368, vhpiTimeExpr = 1369, vhpiTimeOutExpr = 1370, vhpiTool = 1371, vhpiType = 1372, DEPRECATED_vhpiTypeMark = 1373, vhpiUnitDecl = 1374, vhpiUpStack = 1375, vhpiUpperRegion = 1376, vhpiUse = 1377, vhpiValExpr = 1378, DEPRECATED_vhpiValSubtype = 1379, vhpiElemType = 1380, vhpiFirstNamedType = 1381, vhpiReturnType = 1382, vhpiValType = 1383, vhpiCurRegion = 1384, vhpiSignal = 1385, vhpiLibraryDecl = 1386, vhpiSimNet = 1387, vhpiAliasedName = 1388, vhpiCompDecl = 1389, vhpiProtectedTypeInst = 1390, vhpiGenIndex = 1391 #ifdef VHPIEXTEND_ONE_METHODS VHPIEXTEND_ONE_METHODS #endif } vhpiOneToOneT; /******* methods used to traverse 1 to many relationships ************/ typedef enum { vhpiAliasDecls = 1501, vhpiArgvs = 1502, vhpiAttrDecls = 1503, vhpiAttrSpecs = 1504, vhpiBasicSignals = 1505, vhpiBlockStmts = 1506, vhpiBranchs = 1507, /* 1508 */ vhpiChoices = 1509, vhpiCompInstStmts = 1510, DEPRECATED_vhpiCondExprs = 1511, vhpiCondWaveforms = 1512, vhpiConfigItems = 1513, vhpiConfigSpecs = 1514, vhpiConstDecls = 1515, vhpiConstraints = 1516, DEPRECATED_vhpiContributors = 1517, /* 1518 */ vhpiDecls = 1519, vhpiDepUnits = 1520, vhpiDesignUnits = 1521, vhpiDrivenSigs = 1522, vhpiDrivers = 1523, vhpiElemAssocs = 1524, DEPRECATED_vhpiEntityClassEntrys = 1525, vhpiEntityDesignators = 1526, vhpiEnumLiterals = 1527, vhpiForeignfs = 1528, vhpiGenericAssocs = 1529, vhpiGenericDecls = 1530, vhpiIndexExprs = 1531, vhpiIndexedNames = 1532, vhpiInternalRegions = 1533, vhpiMembers = 1534, vhpiPackInsts = 1535, vhpiParamAssocs = 1536, vhpiParamDecls = 1537, vhpiPortAssocs = 1538, vhpiPortDecls = 1539, vhpiRecordElems = 1540, vhpiSelectWaveforms = 1541, vhpiSelectedNames = 1542, DEPRECATED_vhpiSensitivitys = 1543, vhpiSeqStmts = 1544, vhpiSigAttrs = 1545, vhpiSigDecls = 1546, vhpiSigNames = 1547, vhpiSignals = 1548, DEPRECATED_vhpiSpecNames = 1549, vhpiSpecs = 1550, vhpiStmts = 1551, vhpiTransactions = 1552, DEPRECATED_vhpiTypeMarks = 1553, vhpiUnitDecls = 1554, vhpiUses = 1555, vhpiVarDecls = 1556, vhpiWaveformElems = 1557, vhpiLibraryDecls = 1558, vhpiLocalLoads = 1559, vhpiOptimizedLoads = 1560, vhpiTypes = 1561, vhpiUseClauses = 1562, vhpiGenerateStmts = 1563, vhpiLocalContributors = 1564, vhpiOptimizedContributors = 1565, vhpiParamExprs = 1566, vhpiEqProcessStmts = 1567, vhpiEntityClassEntries = 1568, vhpiSensitivities = 1569 #ifdef VHPIEXTEND_MANY_METHODS VHPIEXTEND_MANY_METHODS #endif } vhpiOneToManyT; /* Note: The following macro is defined for compatibility with prototype implementations that use the incorrectly spelled enumeration value. The macro is deprecated and will be removed in a future revision of the standard. */ #define vhpiSensitivitys DEPRECATED_vhpiSensitivitys /****************** PROPERTIES *******************/ /******* INTEGER or BOOLEAN PROPERTIES **********/ typedef enum { vhpiAccessP = 1001, vhpiArgcP = 1002, vhpiAttrKindP = 1003, vhpiBaseIndexP = 1004, vhpiBeginLineNoP = 1005, vhpiEndLineNoP = 1006, vhpiEntityClassP = 1007, vhpiForeignKindP = 1008, vhpiFrameLevelP = 1009, vhpiGenerateIndexP = 1010, vhpiIntValP = 1011, vhpiIsAnonymousP = 1012, vhpiIsBasicP = 1013, vhpiIsCompositeP = 1014, vhpiIsDefaultP = 1015, vhpiIsDeferredP = 1016, vhpiIsDiscreteP = 1017, vhpiIsForcedP = 1018, vhpiIsForeignP = 1019, vhpiIsGuardedP = 1020, vhpiIsImplicitDeclP = 1021, DEPRECATED_vhpiIsInvalidP = 1022, vhpiIsLocalP = 1023, vhpiIsNamedP = 1024, vhpiIsNullP = 1025, vhpiIsOpenP = 1026, vhpiIsPLIP = 1027, vhpiIsPassiveP = 1028, vhpiIsPostponedP = 1029, vhpiIsProtectedTypeP = 1030, vhpiIsPureP = 1031, vhpiIsResolvedP = 1032, vhpiIsScalarP = 1033, vhpiIsSeqStmtP = 1034, vhpiIsSharedP = 1035, vhpiIsTransportP = 1036, vhpiIsUnaffectedP = 1037, vhpiIsUnconstrainedP = 1038, vhpiIsUninstantiatedP = 1039, vhpiIsUpP = 1040, vhpiIsVitalP = 1041, vhpiIteratorTypeP = 1042, vhpiKindP = 1043, vhpiLeftBoundP = 1044, DEPRECATED_vhpiLevelP = 1045, vhpiLineNoP = 1046, vhpiLineOffsetP = 1047, vhpiLoopIndexP = 1048, vhpiModeP = 1049, vhpiNumDimensionsP = 1050, DEPRECATED_vhpiNumFieldsP = 1051, vhpiNumGensP = 1052, vhpiNumLiteralsP = 1053, vhpiNumMembersP = 1054, vhpiNumParamsP = 1055, vhpiNumPortsP = 1056, vhpiOpenModeP = 1057, vhpiPhaseP = 1058, vhpiPositionP = 1059, vhpiPredefAttrP = 1060, /* 1061 */ vhpiReasonP = 1062, vhpiRightBoundP = 1063, vhpiSigKindP = 1064, vhpiSizeP = 1065, vhpiStartLineNoP = 1066, vhpiStateP = 1067, vhpiStaticnessP = 1068, vhpiVHDLversionP = 1069, vhpiIdP = 1070, vhpiCapabilitiesP = 1071, vhpiAutomaticRestoreP = 1072, vhpiCompInstKindP = 1073, vhpiIsBuiltInP = 1074, vhpiIsDynamicP = 1075, vhpiIsOperatorP = 1076, vhpiNumFieldsP = 1077 #ifdef VHPIEXTEND_INT_PROPERTIES VHPIEXTEND_INT_PROPERTIES #endif } vhpiIntPropertyT; /******* STRING PROPERTIES **********/ typedef enum { vhpiCaseNameP = 1301, vhpiCompNameP = 1302, vhpiDefNameP = 1303, vhpiFileNameP = 1304, vhpiFullCaseNameP = 1305, vhpiFullNameP = 1306, vhpiKindStrP = 1307, vhpiLabelNameP = 1308, vhpiLibLogicalNameP = 1309, vhpiLibPhysicalNameP = 1310, vhpiLogicalNameP = 1311, vhpiLoopLabelNameP = 1312, vhpiNameP = 1313, DEPRECATED_vhpiOpNameP = 1314, vhpiStrValP = 1315, vhpiToolVersionP = 1316, vhpiUnitNameP = 1317, vhpiSaveRestartLocationP = 1318, vhpiCompInstNameP = 1319, vhpiInstNamesP = 1320, vhpiSignatureNameP = 1321, vhpiSpecNameP = 1322 #ifdef VHPIEXTEND_STR_PROPERTIES VHPIEXTEND_STR_PROPERTIES #endif } vhpiStrPropertyT; /******* REAL PROPERTIES **********/ typedef enum { vhpiFloatLeftBoundP = 1601, vhpiFloatRightBoundP = 1602, vhpiRealValP = 1603 #ifdef VHPIEXTEND_REAL_PROPERTIES VHPIEXTEND_REAL_PROPERTIES #endif } vhpiRealPropertyT; /******* PHYSICAL PROPERTIES **********/ typedef enum { vhpiPhysLeftBoundP = 1651, vhpiPhysPositionP = 1652, vhpiPhysRightBoundP = 1653, vhpiPhysValP = 1654, DEPRECATED_vhpiPrecisionP = 1655, DEPRECATED_vhpiSimTimeUnitP = 1656, vhpiResolutionLimitP = 1657, vhpiTimeP = 1658 #ifdef VHPIEXTEND_PHYS_PROPERTIES VHPIEXTEND_PHYS_PROPERTIES #endif } vhpiPhysPropertyT; /******************* PROPERTY VALUES ************************/ /* vhpiCapabilitiesP */ typedef enum { vhpiProvidesHierarchy = 1, vhpiProvidesStaticAccess = 2, vhpiProvidesConnectivity = 4, vhpiProvidesPostAnalysis = 8, vhpiProvidesForeignModel = 16, vhpiProvidesAdvancedForeignModel = 32, vhpiProvidesSaveRestart = 64, vhpiProvidesReset = 128, vhpiProvidesDebugRuntime = 256, vhpiProvidesAdvancedDebugRuntime = 512, vhpiProvidesDynamicElab = 1024 } vhpiCapabibilityT; /* vhpiOpenModeP */ typedef enum { vhpiInOpen = 1001, vhpiOutOpen = 1002, vhpiReadOpen = 1003, vhpiWriteOpen = 1004, vhpiAppendOpen = 1005 } vhpiOpenModeT; /* vhpiModeP */ typedef enum { vhpiInMode = 1001, vhpiOutMode = 1002, vhpiInoutMode = 1003, vhpiBufferMode = 1004, vhpiLinkageMode = 1005 } vhpiModeT; /* vhpiSigKindP */ typedef enum { vhpiRegister = 1001, vhpiBus = 1002, vhpiNormal = 1003 } vhpiSigKindT; /* vhpiStaticnessP */ typedef enum { vhpiLocallyStatic = 1001, vhpiGloballyStatic = 1002, vhpiDynamic = 1003 } vhpiStaticnessT; /* vhpiPredefAttrP */ typedef enum { vhpiActivePA = 1001, vhpiAscendingPA = 1002, vhpiBasePA = 1003, vhpiDelayedPA = 1004, vhpiDrivingPA = 1005, vhpiDriving_valuePA= 1006, vhpiEventPA = 1007, vhpiHighPA = 1008, vhpiImagePA = 1009, vhpiInstance_namePA= 1010, vhpiLast_activePA = 1011, vhpiLast_eventPA = 1012, vhpiLast_valuePA = 1013, vhpiLeftPA = 1014, vhpiLeftofPA = 1015, vhpiLengthPA = 1016, vhpiLowPA = 1017, vhpiPath_namePA = 1018, vhpiPosPA = 1019, vhpiPredPA = 1020, vhpiQuietPA = 1021, vhpiRangePA = 1022, vhpiReverse_rangePA= 1023, vhpiRightPA = 1024, vhpiRightofPA = 1025, vhpiSimple_namePA = 1026, vhpiStablePA = 1027, vhpiSuccPA = 1028, vhpiTransactionPA = 1029, vhpiValPA = 1030, vhpiValuePA = 1031 } vhpiPredefAttrT; /* vhpiAttrKindP */ typedef enum { vhpiFunctionAK = 1, vhpiRangeAK = 2, vhpiSignalAK = 3, vhpiTypeAK = 4, vhpiValueAK = 5 #ifdef VHPIEXTEND_ATTR VHPIEXTEND_ATTR #endif } vhpiAttrKindT; /* vhpiEntityClassP */ typedef enum { vhpiEntityEC = 1001, vhpiArchitectureEC = 1002, vhpiConfigurationEC = 1003, vhpiProcedureEC = 1004, vhpiFunctionEC = 1005, vhpiPackageEC = 1006, vhpiTypeEC = 1007, vhpiSubtypeEC = 1008, vhpiConstantEC = 1009, vhpiSignalEC = 1010, vhpiVariableEC = 1011, vhpiComponentEC = 1012, vhpiLabelEC = 1013, vhpiLiteralEC = 1014, vhpiUnitsEC = 1015, vhpiFileEC = 1016, vhpiGroupEC = 1017 } vhpiEntityClassT; /* vhpiAccessP */ typedef enum { vhpiRead = 1, vhpiWrite = 2, vhpiConnectivity = 4, vhpiNoAccess = 8 } vhpiAccessT; /* value for vhpiStateP property for callbacks */ typedef enum { vhpiEnable, vhpiDisable, vhpiMature /* callback has occurred */ } vhpiStateT; /* enumeration type for vhpiCompInstKindP property */ typedef enum { vhpiDirect, vhpiComp, vhpiConfig } vhpiCompInstKindT; /* the following values are used only for the vhpiResolutionLimitP property and for setting the unit field of the value structure; they represent the physical position of a given VHDL time unit */ /* time unit physical position values {high, low} */ PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiFS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiPS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiNS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiUS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiMS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiS; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiMN; PLI_VEXTERN PLI_DLLISPEC const vhpiPhysT vhpiHR; /* IEEE std_logic values */ #define vhpiU 0 /* uninitialized */ #define vhpiX 1 /* unknown */ #define vhpi0 2 /* forcing 0 */ #define vhpi1 3 /* forcing 1 */ #define vhpiZ 4 /* high impedance */ #define vhpiW 5 /* weak unknown */ #define vhpiL 6 /* weak 0 */ #define vhpiH 7 /* weak 1 */ #define vhpiDontCare 8 /* don't care */ /* IEEE std bit values */ #define vhpibit0 0 /* bit 0 */ #define vhpibit1 1 /* bit 1 */ /* IEEE std boolean values */ #define vhpiFalse 0 /* false */ #define vhpiTrue 1 /* true */ /************** vhpiPhaseP property values *************/ typedef enum { vhpiRegistrationPhase = 1, vhpiAnalysisPhase = 2, vhpiElaborationPhase = 3, vhpiInitializationPhase = 4, vhpiSimulationPhase = 5, vhpiTerminationPhase = 6, vhpiSavePhase = 7, vhpiRestartPhase = 8, vhpiResetPhase = 9 } vhpiPhaseT ; /**************** PLI error information structure ****************/ typedef enum { vhpiNote = 1, vhpiWarning = 2, vhpiError = 3, vhpiFailure = 6, vhpiSystem = 4, vhpiInternal = 5 } vhpiSeverityT; typedef struct vhpiErrorInfoS { vhpiSeverityT severity; char *message; char *str; char *file; /* Name of the VHDL file where the VHPI error originated */ int32_t line; /* Line number in the VHDL file */ } vhpiErrorInfoT; /********************* callback structures ************************/ /* callback user data structure */ typedef struct vhpiCbDataS { int32_t reason; /* callback reason */ void (*cb_rtn) (const struct vhpiCbDataS *); /* call routine */ vhpiHandleT obj; /* trigger object */ vhpiTimeT *time; /* callback time */ vhpiValueT *value; /* trigger object value */ void *user_data; /* pointer to user data to be passed to the callback function */ } vhpiCbDataT; /************************* CALLBACK REASONS *************************/ /*********************** Simulation object related ******************/ /* These are repetitive callbacks */ #define vhpiCbValueChange 1001 #define vhpiCbForce 1002 #define vhpiCbRelease 1003 #define vhpiCbTransaction 1004 /* optional callback reason */ /************************** Statement related ***********************/ /* These are repetitive callbacks */ #define vhpiCbStmt 1005 #define vhpiCbResume 1006 #define vhpiCbSuspend 1007 #define vhpiCbStartOfSubpCall 1008 #define vhpiCbEndOfSubpCall 1009 /************************** Time related ****************************/ /* the Rep callback reasons are the repeated versions of the callbacks */ #define vhpiCbAfterDelay 1010 #define vhpiCbRepAfterDelay 1011 /*********************** Simulation cycle phase related *************/ #define vhpiCbNextTimeStep 1012 #define vhpiCbRepNextTimeStep 1013 #define vhpiCbStartOfNextCycle 1014 #define vhpiCbRepStartOfNextCycle 1015 #define vhpiCbStartOfProcesses 1016 #define vhpiCbRepStartOfProcesses 1017 #define vhpiCbEndOfProcesses 1018 #define vhpiCbRepEndOfProcesses 1019 #define vhpiCbLastKnownDeltaCycle 1020 #define vhpiCbRepLastKnownDeltaCycle 1021 #define vhpiCbStartOfPostponed 1022 #define vhpiCbRepStartOfPostponed 1023 #define vhpiCbEndOfTimeStep 1024 #define vhpiCbRepEndOfTimeStep 1025 /************************** Action related **************************/ /* these are one time callback unless otherwise noted */ #define vhpiCbStartOfTool 1026 #define vhpiCbEndOfTool 1027 #define vhpiCbStartOfAnalysis 1028 #define vhpiCbEndOfAnalysis 1029 #define vhpiCbStartOfElaboration 1030 #define vhpiCbEndOfElaboration 1031 #define vhpiCbStartOfInitialization 1032 #define vhpiCbEndOfInitialization 1033 #define vhpiCbStartOfSimulation 1034 #define vhpiCbEndOfSimulation 1035 #define vhpiCbQuiescense 1036 /* repetitive */ #define vhpiCbPLIError 1037 /* repetitive */ #define vhpiCbStartOfSave 1038 #define vhpiCbEndOfSave 1039 #define vhpiCbStartOfRestart 1040 #define vhpiCbEndOfRestart 1041 #define vhpiCbStartOfReset 1042 #define vhpiCbEndOfReset 1043 #define vhpiCbEnterInteractive 1044 /* repetitive */ #define vhpiCbExitInteractive 1045 /* repetitive */ #define vhpiCbSigInterrupt 1046 /* repetitive */ /* Foreign model callbacks */ #define vhpiCbTimeOut 1047 /* non repetitive */ #define vhpiCbRepTimeOut 1048 /* repetitive */ #define vhpiCbSensitivity 1049 /* repetitive */ /************************* CALLBACK FLAGS ***************************/ #define vhpiReturnCb 0x00000001 #define vhpiDisableCb 0x00000010 /************** vhpiAutomaticRestoreP property values *************/ typedef enum { vhpiRestoreAll = 1, vhpiRestoreUserData = 2, vhpiRestoreHandles = 4, vhpiRestoreCallbacks = 8 } vhpiAutomaticRestoreT ; /******************** FUNCTION DECLARATIONS *********************/ XXTERN int vhpi_assert (vhpiSeverityT severity, char *formatmsg, ...); /* callback related */ XXTERN vhpiHandleT vhpi_register_cb (vhpiCbDataT *cb_data_p, int32_t flags); XXTERN int vhpi_remove_cb (vhpiHandleT cb_obj); XXTERN int vhpi_disable_cb (vhpiHandleT cb_obj); XXTERN int vhpi_enable_cb (vhpiHandleT cb_obj); XXTERN int vhpi_get_cb_info (vhpiHandleT object, vhpiCbDataT *cb_data_p); /* utilities for sensitivity-set bitmaps */ /* The replacement text for these macros is implementation defined */ /* The behavior is specified in G.1 */ #define VHPI_SENS_ZERO(sens) vhpi_sens_zero(sens) #define VHPI_SENS_SET(obj, sens) vhpi_sens_set(obj, sens) #define VHPI_SENS_CLR(obj, sens) vhpi_sens_clr(obj, sens) #define VHPI_SENS_ISSET(obj, sens) vhpi_sens_isset(obj, sens) #define VHPI_SENS_FIRST(sens) vhpi_sens_first(sens) /* for obtaining handles */ XXTERN vhpiHandleT vhpi_handle_by_name (const char *name, vhpiHandleT scope); XXTERN vhpiHandleT vhpi_handle_by_index (vhpiOneToManyT itRel, vhpiHandleT parent, int32_t indx); /* for traversing relationships */ XXTERN vhpiHandleT vhpi_handle (vhpiOneToOneT type, vhpiHandleT referenceHandle); XXTERN vhpiHandleT vhpi_iterator (vhpiOneToManyT type, vhpiHandleT referenceHandle); XXTERN vhpiHandleT vhpi_scan (vhpiHandleT iterator); /* for processsing properties */ XXTERN vhpiIntT vhpi_get (vhpiIntPropertyT property, vhpiHandleT object); XXTERN const vhpiCharT * vhpi_get_str (vhpiStrPropertyT property, vhpiHandleT object); XXTERN vhpiRealT vhpi_get_real (vhpiRealPropertyT property, vhpiHandleT object); XXTERN vhpiPhysT vhpi_get_phys (vhpiPhysPropertyT property, vhpiHandleT object); /* for access to protected types */ typedef int (*vhpiUserFctT)(); XXTERN int vhpi_protected_call (vhpiHandleT varHdl, vhpiUserFctT userFct, void *userData); /* value processing */ /* vhpi_put_value modes */ typedef enum { vhpiDeposit, vhpiDepositPropagate, vhpiForce, vhpiForcePropagate, vhpiRelease, vhpiSizeConstraint } vhpiPutValueModeT; typedef enum { vhpiInertial, vhpiTransport } vhpiDelayModeT; XXTERN int vhpi_get_value (vhpiHandleT expr, vhpiValueT *value_p); XXTERN int vhpi_put_value (vhpiHandleT object, vhpiValueT *value_p, vhpiPutValueModeT mode); XXTERN int vhpi_schedule_transaction (vhpiHandleT drivHdl, vhpiValueT *value_p, uint32_t numValues, vhpiTimeT *delayp, vhpiDelayModeT delayMode, vhpiTimeT *pulseRejp); XXTERN int vhpi_format_value (const vhpiValueT *in_value_p, vhpiValueT *out_value_p); /* time processing */ XXTERN void vhpi_get_time (vhpiTimeT *time_p, long *cycles); #define vhpiNoActivity -1 XXTERN int vhpi_get_next_time (vhpiTimeT *time_p); /* simulation control */ typedef enum { vhpiStop = 0, vhpiFinish = 1, vhpiReset = 2 #ifdef VHPIEXTEND_CONTROL VHPIEXTEND_CONTROL #endif } vhpiSimControlT; XXTERN int vhpi_control (vhpiSimControlT command, ...); /* I/O routine */ XXTERN int vhpi_printf (const char *format, ...); XXTERN int vhpi_vprintf (const char *format, va_list args); /* utilities to print VHDL strings */ XXTERN int vhpi_is_printable( char ch ); /* utility routines */ XXTERN int vhpi_compare_handles (vhpiHandleT handle1, vhpiHandleT handle2); XXTERN int vhpi_check_error (vhpiErrorInfoT *error_info_p); XXTERN int vhpi_release_handle (vhpiHandleT object); /* creation functions */ XXTERN vhpiHandleT vhpi_create (vhpiClassKindT kind, vhpiHandleT handle1, vhpiHandleT handle2); /* Foreign model data structures and functions */ typedef enum { vhpiArchF = 1, vhpiFuncF = 2, vhpiProcF = 3, vhpiLibF = 4, vhpiAppF = 5 } vhpiForeignKindT; typedef struct vhpiForeignDataS { vhpiForeignKindT kind; char * libraryName; char * modelName; void (*elabf)(const struct vhpiCbDataS *cb_data_p); void (*execf)(const struct vhpiCbDataS *cb_data_p); } vhpiForeignDataT; XXTERN vhpiHandleT vhpi_register_foreignf (vhpiForeignDataT *foreignDatap); /* vhpi_get_foreign_info is DEPRECATED and is replaced by the function vhpi_get_foreignf_info */ XXTERN int vhpi_get_foreignf_info (vhpiHandleT hdl, vhpiForeignDataT *foreignDatap); /* for saving and restoring foreign models data */ XXTERN size_t vhpi_get_data (int32_t id, void *dataLoc, size_t numBytes); XXTERN size_t vhpi_put_data (int32_t id, void *dataLoc, size_t numBytes); #ifdef VHPIEXTEND_FUNCTIONS VHPIEXTEND_FUNCTIONS #endif /**************************** Typedef for VHPI registration functions ****************************/ typedef void (*vhpiRegistrationFctT)(); #undef PLI_EXTERN #undef PLI_VEXTERN #ifdef VHPI_USER_DEFINED_DLLISPEC #undef VHPI_USER_DEFINED_DLLISPEC #undef PLI_DLLISPEC #endif #ifdef VHPI_USER_DEFINED_DLLESPEC #undef VHPI_USER_DEFINED_DLLESPEC #undef PLI_DLLESPEC #endif #ifdef PLI_PROTOTYPES #undef PLI_PROTOTYPES #undef XXTERN #undef EETERN #endif #ifdef __cplusplus } #endif #endif /* VHPI_USER_H */ nvc-r1.17.1/src/vlog/000077500000000000000000000000001504111170000142755ustar00rootroot00000000000000nvc-r1.17.1/src/vlog/Makemodule.am000066400000000000000000000007511504111170000167020ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/vlog/vlog-node.h \ src/vlog/vlog-node.c \ src/vlog/vlog-phase.h \ src/vlog/vlog-dump.c \ src/vlog/vlog-lower.c \ src/vlog/vlog-number.h \ src/vlog/vlog-number.c \ src/vlog/vlog-trans.c \ src/vlog/vlog-simp.c \ src/vlog/vlog-util.c \ src/vlog/vlog-defs.h \ src/vlog/vlog-util.h \ src/vlog/vlog-sem.c \ src/vlog/vlog-pp.l \ src/vlog/vlog-parse.c \ src/vlog/vlog-udp.c \ src/vlog/vlog-inst.c \ src/vlog/vlog-symtab.h \ src/vlog/vlog-symtab.c nvc-r1.17.1/src/vlog/vlog-defs.h000066400000000000000000000021051504111170000163320ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_DEFS_H #define _VLOG_DEFS_H #define T_LOGIC "19NVC.VERILOG.T_LOGIC" #define T_LOGIC_ARRAY "25NVC.VERILOG.T_LOGIC_ARRAY" #define T_INT64 "19NVC.VERILOG.T_INT64" #define T_NET_VALUE "23NVC.VERILOG.T_NET_VALUE" #define T_NET_ARRAY "23NVC.VERILOG.T_NET_ARRAY" #define T_WIRE_ARRAY "24NVC.VERILOG.T_WIRE_ARRAY" #define T_STRENGTH "22NVC.VERILOG.T_STRENGTH" #endif // _VLOG_DEFS_H nvc-r1.17.1/src/vlog/vlog-dump.c000066400000000000000000000545121504111170000163620ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "object.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include #define DUMP_ADDRESS 0 static inline void tab(int indent) { print_syntax("%*s", indent, ""); } static void vlog_dump_address(vlog_node_t v) { #if DUMP_ADDRESS uint32_t a = (uint32_t)((uintptr_t)object_arena(vlog_to_object(v)) >> 2); a = (a ^ 61) ^ (a >> 16); a = a + (a << 3); a = a ^ (a >> 4); a = a * UINT32_C(0x27d4eb2d); a = a ^ (a >> 15); const int r = 1 + a % 5; const int g = 1 + (a >> 8) % 5; const int b = 1 + (a >> 16) % 5; const int color = 16 + 36*r + 6*g + b; char *LOCAL fmt = xasprintf("$!#%d${%%p:%s}$$", color, vlog_kind_str(vlog_kind(v))); color_printf(fmt, v); #endif } static void vlog_dump_paren(vlog_node_t v, int indent) { switch (vlog_kind(v)) { case V_REF: case V_BIT_SELECT: case V_NUMBER: vlog_dump(v, indent); break; default: print_syntax("("); vlog_dump(v, indent); print_syntax(")"); } } static void vlog_dump_module(vlog_node_t v, int indent) { vlog_dump_address(v); print_syntax("#module %s", istr(vlog_ident2(v))); const int nports = vlog_ports(v); if (nports > 0) { print_syntax(" ("); for (int i = 0; i < nports; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_port(v, i), 0); } print_syntax(")"); } print_syntax(";\n"); const int ndecls = vlog_decls(v); for (int i = 0; i < ndecls; i++) vlog_dump(vlog_decl(v, i), indent + 2); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) vlog_dump(vlog_stmt(v, i), indent + 2); print_syntax("#endmodule // %s\n\n", istr(vlog_ident2(v))); } static void vlog_dump_primitive(vlog_node_t v, int indent) { vlog_dump_address(v); print_syntax("#primitive %s", istr(vlog_ident2(v))); const int nports = vlog_ports(v); if (nports > 0) { print_syntax(" ("); for (int i = 0; i < nports; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_port(v, i), 0); } print_syntax(")"); } print_syntax(";\n"); const int ndecls = vlog_decls(v); for (int i = 0; i < ndecls; i++) vlog_dump(vlog_decl(v, i), indent + 2); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) vlog_dump(vlog_stmt(v, i), indent + 2); print_syntax("#endprimitive // %s\n\n", istr(vlog_ident2(v))); } static void vlog_dump_udp_entry(vlog_node_t v, int indent) { tab(indent); vlog_udp_symbol_t last = V_UDP_SYMBOL_INPUT; const int nsymbols = vlog_params(v); for (int i = 0; i < nsymbols; i++) { vlog_node_t sym = vlog_param(v, i); const vlog_udp_symbol_t kind = vlog_subkind(sym); if (kind != last) { print_syntax(":"); last = kind; } print_syntax("%c", (char)vlog_ival(sym)); } print_syntax(";\n"); } static void vlog_dump_udp_table(vlog_node_t v, int indent) { tab(indent); print_syntax("#table\n"); const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) vlog_dump(vlog_param(v, i), indent + 2); tab(indent); print_syntax("#endtable\n"); } static void vlog_dump_port_decl(vlog_node_t v, int indent) { tab(indent); vlog_dump_address(v); switch (vlog_subkind(v)) { case V_PORT_INPUT: print_syntax("#input"); break; case V_PORT_INOUT: print_syntax("#inout"); break; case V_PORT_OUTPUT: print_syntax("#output"); break; } print_syntax(" %s;\n", istr(vlog_ident(v))); } static void vlog_dump_dimensions(vlog_node_t v, int indent) { const int ndims = vlog_ranges(v); int dim = 0; for (; dim < ndims; dim++) { vlog_node_t d = vlog_range(v, dim); print_syntax(" ["); vlog_dump(vlog_left(d), indent); print_syntax(":"); vlog_dump(vlog_right(d), indent); print_syntax("]"); } } static void vlog_dump_net_decl(vlog_node_t v, int indent) { tab(indent); vlog_dump_address(v); switch (vlog_subkind(v)) { case V_NET_WIRE: print_syntax("#wire "); break; } vlog_dump(vlog_type(v), indent); print_syntax(" %s", istr(vlog_ident(v))); vlog_dump_dimensions(v, indent); print_syntax(";\n"); } static void vlog_dump_var_decl(vlog_node_t v, int indent) { tab(indent); vlog_dump_address(v); vlog_dump(vlog_type(v), indent); print_syntax(" %s", istr(vlog_ident(v))); vlog_dump_dimensions(v, indent); if (vlog_has_value(v)) { print_syntax(" = "); vlog_dump(vlog_value(v), indent); } print_syntax(";\n"); } static void vlog_dump_always(vlog_node_t v, int indent) { tab(indent); print_syntax("#always "); vlog_dump(vlog_stmt(v, 0), indent); print_syntax("\n"); } static void vlog_dump_initial(vlog_node_t v, int indent) { tab(indent); print_syntax("#initial "); vlog_dump(vlog_stmt(v, 0), indent); print_syntax("\n"); } static void vlog_dump_block(vlog_node_t v, int indent) { print_syntax("#begin\n"); const int ndecls = vlog_decls(v); for (int i = 0; i < ndecls; i++) vlog_dump(vlog_decl(v, i), indent + 2); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { tab(indent + 2); vlog_dump(vlog_stmt(v, i), indent + 2); print_syntax("\n"); } tab(indent); print_syntax("#end"); } static void vlog_dump_timing(vlog_node_t v, int indent) { vlog_dump(vlog_value(v), indent); if (vlog_stmts(v) > 0) vlog_dump(vlog_stmt(v, 0), indent); else print_syntax(";\n"); } static void vlog_dump_event(vlog_node_t v) { switch (vlog_subkind(v)) { case V_EVENT_POSEDGE: print_syntax("#posedge "); break; case V_EVENT_NEGEDGE: print_syntax("#negedge "); break; } vlog_dump(vlog_value(v), 0); } static void vlog_dump_event_control(vlog_node_t v) { print_syntax("@("); const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_param(v, i), 0); } print_syntax(") "); } static void vlog_dump_nbassign(vlog_node_t v, int indent) { vlog_dump(vlog_target(v), 0); print_syntax(" <= "); if (vlog_has_delay(v)) vlog_dump(vlog_delay(v), 0); vlog_dump(vlog_value(v), 0); print_syntax(";"); } static void vlog_dump_bassign(vlog_node_t v, int indent) { vlog_dump(vlog_target(v), 0); switch (vlog_subkind(v)) { case V_ASSIGN_EQUALS: print_syntax(" = "); break; } if (vlog_has_delay(v)) vlog_dump(vlog_delay(v), 0); vlog_dump(vlog_value(v), 0); print_syntax(";"); } static void vlog_dump_assign(vlog_node_t v, int indent) { tab(indent); print_syntax("#assign "); vlog_dump(vlog_target(v), 0); print_syntax(" = "); vlog_dump(vlog_value(v), 0); print_syntax(";\n"); } static void vlog_dump_stmt_or_null(vlog_node_t v, int indent) { switch (vlog_stmts(v)) { case 0: print_syntax(";"); break; case 1: vlog_dump(vlog_stmt(v, 0), indent); break; default: should_not_reach_here(); } } static void vlog_dump_if(vlog_node_t v, int indent) { print_syntax("#if "); const int nconds = vlog_conds(v); for (int i = 0; i < nconds; i++) { if (i > 0) { print_syntax("\n"); tab(indent); print_syntax("#else "); } vlog_node_t c = vlog_cond(v, i); if (vlog_has_value(c)) { print_syntax("("); vlog_dump(vlog_value(c), 0); print_syntax(") "); } vlog_dump_stmt_or_null(c, indent); } } static void vlog_dump_sys_tcall(vlog_node_t v, int indent) { print_syntax("%s", istr(vlog_ident(v))); const int nparams = vlog_params(v); if (nparams > 0) { print_syntax("("); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_param(v, i), 0); } print_syntax(")"); } print_syntax(";"); } static void vlog_dump_sys_fcall(vlog_node_t v) { print_syntax("%s", istr(vlog_ident(v))); const int nparams = vlog_params(v); if (nparams > 0) { print_syntax("("); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_param(v, i), 0); } print_syntax(")"); } } static void vlog_dump_string(vlog_node_t v) { print_syntax("\""); number_t n = vlog_number(v); for (int i = number_width(n)/8 - 1; i >= 0; i--) print_syntax("%c", number_byte(n, i)); print_syntax("\""); } static void vlog_dump_number(vlog_node_t v) { LOCAL_TEXT_BUF tb = tb_new(); number_print(vlog_number(v), tb); print_syntax("%s", tb_get(tb)); } static void vlog_dump_real(vlog_node_t v) { print_syntax("%g", vlog_dval(v)); } static void vlog_dump_binary(vlog_node_t v) { vlog_dump_paren(vlog_left(v), 0); switch (vlog_subkind(v)) { case V_BINARY_OR: print_syntax(" | "); break; case V_BINARY_AND: print_syntax(" & "); break; case V_BINARY_CASE_EQ: print_syntax(" === "); break; case V_BINARY_CASE_NEQ: print_syntax(" !== "); break; case V_BINARY_LOG_EQ: print_syntax(" == "); break; case V_BINARY_LOG_NEQ: print_syntax(" != "); break; case V_BINARY_LOG_OR: print_syntax(" || "); break; case V_BINARY_LOG_AND: print_syntax(" && "); break; case V_BINARY_PLUS: print_syntax(" + "); break; case V_BINARY_MINUS: print_syntax(" - "); break; case V_BINARY_LT: print_syntax(" < "); break; case V_BINARY_GT: print_syntax(" > "); break; } vlog_dump_paren(vlog_right(v), 0); } static void vlog_dump_unary(vlog_node_t v) { switch (vlog_subkind(v)) { case V_UNARY_NOT: print_syntax("!"); break; case V_UNARY_BITNEG: print_syntax("~~"); break; } vlog_dump(vlog_value(v), 0); } static void vlog_dump_postfix(vlog_node_t v) { vlog_dump(vlog_target(v), 0); switch (vlog_subkind(v)) { case V_INCDEC_PLUS: print_syntax("++"); break; case V_INCDEC_MINUS: print_syntax("--"); break; } } static void vlog_dump_prefix(vlog_node_t v) { switch (vlog_subkind(v)) { case V_INCDEC_PLUS: print_syntax("++"); break; case V_INCDEC_MINUS: print_syntax("--"); break; } vlog_dump(vlog_target(v), 0); } static void vlog_dump_delay_control(vlog_node_t v, int indent) { print_syntax("##"); vlog_dump(vlog_value(v), 0); print_syntax(" "); } static void vlog_dump_gate_inst(vlog_node_t v, int indent) { tab(indent); switch (vlog_subkind(v)) { case V_GATE_PULLUP: print_syntax("#pullup "); break; case V_GATE_PULLDOWN: print_syntax("#pulldown "); break; } const int nparams = vlog_params(v); if (nparams > 0) { print_syntax("("); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(","); vlog_dump(vlog_param(v, i), 0); } print_syntax(") "); } if (vlog_has_ident(v)) print_syntax("%s ", istr(vlog_ident(v))); print_syntax("("); vlog_dump(vlog_target(v), 0); print_syntax(");\n"); } static void vlog_dump_mod_inst(vlog_node_t v, int indent) { print_syntax("%s ", istr(vlog_ident(v))); const int nparams = vlog_params(v); print_syntax("("); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(","); vlog_dump(vlog_param(v, i), 0); } print_syntax(")"); } static void vlog_dump_inst_list(vlog_node_t v, int indent) { tab(indent); print_syntax("%s ", istr(vlog_ident(v))); const int nparams = vlog_params(v); if (nparams > 0) { print_syntax("##("); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(","); vlog_dump(vlog_param(v, i), 0); } print_syntax(") "); } const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_stmt(v, i), indent + 2); } print_syntax(";\n"); } static void vlog_dump_param_assign(vlog_node_t v, int indent) { if (vlog_has_ident(v)) { print_syntax(".%s(", istr(vlog_ident(v))); if (vlog_has_value(v)) vlog_dump(vlog_value(v), indent); print_syntax(")"); } else vlog_dump(vlog_value(v), indent); } static void vlog_dump_strength(vlog_node_t v, int indent) { static const char *map[] = { "highz", "small", "medium", "weak", "large", "pull", "strong", "supply" }; const unsigned level = vlog_subkind(v); print_syntax("%s0,%s1", map[STRENGTH0(level)], map[STRENGTH1(level)]); } static void vlog_dump_bit_select(vlog_node_t v, int indent) { vlog_dump(vlog_value(v), 0); const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) { print_syntax("["); vlog_dump(vlog_param(v, i), 0); print_syntax("]"); } } static void vlog_dump_part_select(vlog_node_t v, int indent) { vlog_dump(vlog_value(v), 0); print_syntax("["); vlog_dump(vlog_left(v), 0); print_syntax(":"); vlog_dump(vlog_right(v), 0); print_syntax("]"); } static void vlog_dump_data_type(vlog_node_t v, int indent) { switch (vlog_subkind(v)) { case DT_LOGIC: print_syntax("#logic"); break; case DT_REAL: print_syntax("#real"); break; case DT_REALTIME: print_syntax("#realtime"); break; case DT_SHORTREAL: print_syntax("#shortreal"); break; case DT_INTEGER: print_syntax("#integer"); break; case DT_BIT: print_syntax("#bit"); break; case DT_INT: print_syntax("#int"); break; default: should_not_reach_here(); } vlog_dump_dimensions(v, indent); } static void vlog_dump_do_while(vlog_node_t v, int indent) { print_syntax("#do "); vlog_dump_stmt_or_null(v, indent); print_syntax(" #while ("); vlog_dump(vlog_value(v), indent); print_syntax(");"); } static void vlog_dump_while(vlog_node_t v, int indent) { print_syntax("#while ("); vlog_dump(vlog_value(v), indent); print_syntax(")"); vlog_dump_stmt_or_null(v, indent); } static void vlog_dump_repeat(vlog_node_t v, int indent) { print_syntax("#repeat ("); vlog_dump(vlog_value(v), indent); print_syntax(") "); vlog_dump_stmt_or_null(v, indent); } static void vlog_dump_forever(vlog_node_t v, int indent) { print_syntax("#forever "); vlog_dump_stmt_or_null(v, indent); } static void vlog_dump_for_init(vlog_node_t v, int indent) { const int nstmts = vlog_stmts(v); if (nstmts == 0) print_syntax(";"); else { for (int i = 0; i < nstmts; i++) { vlog_dump(vlog_stmt(v, i), indent); print_syntax(" "); } } } static void vlog_dump_for_step(vlog_node_t v, int indent) { const int nstmts = vlog_stmts(v); if (nstmts == 0) print_syntax(";"); else { for (int i = 0; i < nstmts; i++) { print_syntax(" "); vlog_dump(vlog_stmt(v, i), indent); } } } static void vlog_dump_for_loop(vlog_node_t v, int indent) { print_syntax("#for ("); vlog_dump(vlog_left(v), 0); if (vlog_has_value(v)) vlog_dump(vlog_value(v), 0); print_syntax(";"); vlog_dump(vlog_right(v), 0); print_syntax(") "); vlog_dump_stmt_or_null(v, indent); } static void vlog_dump_case(vlog_node_t v, int indent) { static const char *suffix[] = { "", "x", "z" }; print_syntax("#case%s (", suffix[vlog_subkind(v)]); vlog_dump(vlog_value(v), indent); print_syntax(")\n"); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) vlog_dump(vlog_stmt(v, i), indent + 2); tab(indent); print_syntax("#endcase"); } static void vlog_dump_case_item(vlog_node_t v, int indent) { tab(indent); const int nparams = vlog_params(v); if (nparams == 0) print_syntax("#default"); else { vlog_dump(vlog_param(v, 0), 0); for (int i = 1; i < nparams; i++) { print_syntax(", "); vlog_dump(vlog_param(v, i), 0); } } print_syntax(": "); vlog_dump_stmt_or_null(v, indent); print_syntax("\n"); } static void vlog_dump_cond_expr(vlog_node_t v, int indent) { vlog_dump(vlog_value(v), 0); print_syntax(" ? "); vlog_dump(vlog_left(v), 0); print_syntax(" : "); vlog_dump(vlog_right(v), 0); } static void vlog_dump_concat(vlog_node_t v, int indent) { print_syntax("{"); const bool multiple = vlog_has_value(v); if (multiple) { vlog_dump_paren(vlog_value(v), 0); print_syntax("{"); } const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) { if (i > 0) print_syntax(", "); vlog_dump(vlog_param(v, i), 0); } if (multiple) print_syntax("}"); print_syntax("}"); } static void vlog_dump_param_decl(vlog_node_t v, int indent) { tab(indent); vlog_dump_address(v); switch (vlog_kind(v)) { case V_PARAM_DECL: print_syntax("#parameter "); break; case V_LOCALPARAM: print_syntax("#localparam "); break; default: should_not_reach_here(); } vlog_dump(vlog_type(v), indent); print_syntax(" %s", istr(vlog_ident(v))); if (vlog_has_value(v)) { print_syntax(" = "); vlog_dump(vlog_value(v), indent); } print_syntax(";\n"); } static void vlog_dump_ref(vlog_node_t v, int indent) { if (vlog_has_ref(v)) vlog_dump_address(vlog_ref(v)); print_syntax("%s", istr(vlog_ident(v))); } static void vlog_dump_task_decl(vlog_node_t v, int indent) { tab(indent); print_syntax("#task %s(", istr(vlog_ident(v))); print_syntax(");\n"); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { tab(indent + 2); vlog_dump(vlog_stmt(v, i), indent + 2); print_syntax("\n"); } tab(indent); print_syntax("#endtask\n"); } static void vlog_dump_func_decl(vlog_node_t v, int indent) { tab(indent); print_syntax("#function %s(", istr(vlog_ident(v))); print_syntax(");\n"); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { tab(indent + 2); vlog_dump(vlog_stmt(v, i), indent + 2); print_syntax("\n"); } tab(indent); print_syntax("#endfunction\n"); } static void vlog_dump_wait(vlog_node_t v, int indent) { print_syntax("#wait ("); vlog_dump(vlog_value(v), 0); print_syntax(") "); vlog_dump_stmt_or_null(v, indent); } void vlog_dump(vlog_node_t v, int indent) { switch (vlog_kind(v)) { case V_INST_BODY: print_syntax("// Instantiated module %s\n", istr(vlog_ident(v))); // Fall-through case V_MODULE: vlog_dump_module(v, indent); break; case V_PRIMITIVE: vlog_dump_primitive(v, indent); break; case V_REF: vlog_dump_ref(v, indent); break; case V_PORT_DECL: vlog_dump_port_decl(v, indent); break; case V_NET_DECL: vlog_dump_net_decl(v, indent); break; case V_VAR_DECL: vlog_dump_var_decl(v, indent); break; case V_ALWAYS: vlog_dump_always(v, indent); break; case V_INITIAL: vlog_dump_initial(v, indent); break; case V_TIMING: vlog_dump_timing(v, indent); break; case V_EVENT: vlog_dump_event(v); break; case V_EVENT_CONTROL: vlog_dump_event_control(v); break; case V_NBASSIGN: vlog_dump_nbassign(v, indent); break; case V_BASSIGN: vlog_dump_bassign(v, indent); break; case V_ASSIGN: vlog_dump_assign(v, indent); break; case V_BLOCK: vlog_dump_block(v, indent); break; case V_SYS_TCALL: vlog_dump_sys_tcall(v, indent); break; case V_SYS_FCALL: vlog_dump_sys_fcall(v); break; case V_STRING: vlog_dump_string(v); break; case V_NUMBER: vlog_dump_number(v); break; case V_REAL: vlog_dump_real(v); break; case V_IF: case V_IF_GENERATE: vlog_dump_if(v, indent); break; case V_BINARY: vlog_dump_binary(v); break; case V_UNARY: vlog_dump_unary(v); break; case V_POSTFIX: vlog_dump_postfix(v); break; case V_PREFIX: vlog_dump_prefix(v); break; case V_DELAY_CONTROL: vlog_dump_delay_control(v, indent); break; case V_GATE_INST: vlog_dump_gate_inst(v, indent); break; case V_MOD_INST: vlog_dump_mod_inst(v, indent); break; case V_INST_LIST: vlog_dump_inst_list(v, indent); break; case V_STRENGTH: vlog_dump_strength(v, indent); break; case V_BIT_SELECT: vlog_dump_bit_select(v, indent); break; case V_PART_SELECT: vlog_dump_part_select(v, indent); break; case V_UDP_ENTRY: vlog_dump_udp_entry(v, indent); break; case V_UDP_TABLE: vlog_dump_udp_table(v, indent); break; case V_DATA_TYPE: vlog_dump_data_type(v, indent); break; case V_EMPTY: break; case V_DO_WHILE: vlog_dump_do_while(v, indent); break; case V_WHILE: vlog_dump_while(v, indent); break; case V_REPEAT: vlog_dump_repeat(v, indent); break; case V_FOREVER: vlog_dump_forever(v, indent); break; case V_FOR_LOOP: vlog_dump_for_loop(v, indent); break; case V_FOR_INIT: vlog_dump_for_init(v, indent); break; case V_FOR_STEP: vlog_dump_for_step(v, indent); break; case V_CASE: vlog_dump_case(v, indent); break; case V_COND_EXPR: vlog_dump_cond_expr(v, indent); break; case V_CASE_ITEM: vlog_dump_case_item(v, indent); break; case V_CONCAT: vlog_dump_concat(v, indent); break; case V_PARAM_DECL: case V_LOCALPARAM: vlog_dump_param_decl(v, indent); break; case V_PARAM_ASSIGN: case V_PORT_CONN: vlog_dump_param_assign(v, indent); break; case V_TASK_DECL: vlog_dump_task_decl(v, indent); break; case V_FUNC_DECL: vlog_dump_func_decl(v, indent); break; case V_WAIT: vlog_dump_wait(v, indent); break; default: print_syntax("\n"); fflush(stdout); fatal_trace("cannot dump %s", vlog_kind_str(vlog_kind(v))); } } nvc-r1.17.1/src/vlog/vlog-inst.c000066400000000000000000000071521504111170000163700ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include static vlog_node_t bind_parameter(vlog_node_t decl, int nth, vlog_node_t inst) { vlog_node_t value = NULL; if (vlog_has_value(decl)) value = vlog_value(decl); if (inst != NULL) { vlog_node_t p; const int nparams = vlog_params(inst); if (nth < nparams && !vlog_has_ident((p = vlog_param(inst, nth)))) value = vlog_value(p); else { // TODO: search named } } if (value == NULL) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(inst)); diag_printf(d, "missing value for parameter %s", istr(vlog_ident(decl))); diag_hint(d, vlog_loc(decl), "parameter declared here"); diag_emit(d); } vlog_node_t local = vlog_new(V_LOCALPARAM); vlog_set_loc(local, vlog_loc(decl)); vlog_set_ident(local, vlog_ident(decl)); vlog_set_value(local, value); vlog_set_type(local, vlog_type(decl)); return local; } static bool should_copy_pred(vlog_node_t v, void *ctx) { switch (vlog_kind(v)) { case V_REF: return vlog_kind(vlog_ref(v)) == V_PARAM_DECL; default: return false; } } static vlog_node_t fixup_refs_cb(vlog_node_t v, void *ctx) { hash_t *map = ctx; if (vlog_kind(v) == V_REF) { vlog_node_t new = hash_get(map, vlog_ref(v)); if (new != NULL) vlog_set_ref(v, new); } return v; } vlog_node_t vlog_new_instance(vlog_node_t mod, vlog_node_t inst, ident_t prefix) { ident_t suffix = vlog_ident(vlog_stmt(inst, 0)); vlog_node_t v = vlog_new(V_INST_BODY); vlog_set_ident(v, ident_prefix(prefix, suffix, '.')); vlog_set_ident2(v, vlog_ident2(mod)); vlog_set_loc(v, vlog_loc(inst)); vlog_node_t copy = vlog_copy(mod, should_copy_pred, NULL); hash_t *map = hash_new(16); const int nports = vlog_ports(copy); for (int i = 0; i < nports; i++) vlog_add_port(v, vlog_port(copy, i)); int pidx = 0; const int ndecls = vlog_decls(copy); for (int i = 0; i < ndecls; i++) { vlog_node_t d = vlog_decl(copy, i); switch (vlog_kind(d)) { case V_PARAM_DECL: { vlog_node_t local = bind_parameter(d, pidx++, inst); vlog_add_decl(v, local); hash_put(map, d, local); } break; default: vlog_add_decl(v, d); break; } } if (inst != NULL) { const int nparams = vlog_params(inst); if (pidx < nparams) error_at(vlog_loc(inst), "module %s has %d parameter%s but %d " "values given", istr(vlog_ident2(mod)), pidx, pidx != 1 ? "s" : "", nparams); } const int nstmts = vlog_stmts(copy); for (int i = 0; i < nstmts; i++) vlog_add_stmt(v, vlog_stmt(copy, i)); vlog_rewrite(v, fixup_refs_cb, map); vlog_simp(v); hash_free(map); return v; } nvc-r1.17.1/src/vlog/vlog-lower.c000066400000000000000000001513741504111170000165510ustar00rootroot00000000000000// // Copyright (C) 2023-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "type.h" #include "vlog/vlog-defs.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include #include #include #include typedef struct { mir_type_t type; unsigned size; } type_info_t; typedef struct { mir_value_t nets; mir_value_t offset; mir_value_t in_range; unsigned size; } vlog_lvalue_t; STATIC_ASSERT(sizeof(vlog_lvalue_t) <= 16); typedef struct { mir_unit_t *mu; ihash_t *temps; } vlog_gen_t; #define PUSH_DEBUG_INFO(mu, v) \ __attribute__((cleanup(_mir_pop_debug_info), unused)) \ const mir_saved_loc_t _old_loc = \ _mir_push_debug_info((mu), vlog_loc((v))); static void vlog_lower_stmts(vlog_gen_t *g, vlog_node_t v); static mir_value_t vlog_lower_rvalue(vlog_gen_t *g, vlog_node_t v); static const type_info_t *vlog_type_info(vlog_gen_t *g, vlog_node_t v) { assert(vlog_kind(v) == V_DATA_TYPE); type_info_t *ti = mir_get_priv(g->mu, v); if (ti == NULL) { ti = mir_malloc(g->mu, sizeof(type_info_t)); ti->size = vlog_size(v); ti->type = mir_vec4_type(g->mu, ti->size, false); } return ti; } static mir_value_t vlog_get_temp(vlog_gen_t *g, mir_type_t type) { if (g->temps == NULL) g->temps = ihash_new(16); else { mir_value_t exist = { .bits = (uintptr_t)ihash_get(g->temps, type.bits) }; if (!mir_is_null(exist)) return exist; } mir_value_t temp = mir_add_var(g->mu, type, MIR_NULL_STAMP, ident_uniq("tmp"), MIR_VAR_TEMP); ihash_put(g->temps, type.bits, (void *)(uintptr_t)temp.bits); return temp; } static mir_value_t vlog_lower_array_off(vlog_gen_t *g, vlog_node_t r, vlog_node_t v) { mir_value_t index = vlog_lower_rvalue(g, v); mir_type_t index_type = mir_get_type(g->mu, index); if (mir_get_class(g->mu, index_type) == MIR_TYPE_VEC4) { // TODO: check X/Z handling const int size = mir_get_size(g->mu, index_type); mir_type_t vec2 = mir_vec2_type(g->mu, size, false); index = mir_build_cast(g->mu, vec2, index); } mir_type_t t_offset = mir_offset_type(g->mu); mir_value_t cast = mir_build_cast(g->mu, t_offset, index); assert(vlog_kind(r) == V_DIMENSION); int64_t lconst, rconst; vlog_bounds(r, &lconst, &rconst); mir_value_t left = mir_const(g->mu, t_offset, lconst); if (lconst < rconst) return mir_build_sub(g->mu, t_offset, cast, left); else return mir_build_sub(g->mu, t_offset, left, cast); } static vlog_lvalue_t vlog_lower_lvalue_ref(vlog_gen_t *g, vlog_node_t v) { vlog_node_t decl = vlog_ref(v); if (vlog_kind(decl) == V_PORT_DECL) decl = vlog_ref(decl); int hops; mir_value_t var = mir_search_object(g->mu, decl, &hops); assert(!mir_is_null(var)); assert(hops > 0); mir_value_t upref = mir_build_var_upref(g->mu, hops, var.id); const type_info_t *ti = vlog_type_info(g, vlog_type(decl)); mir_type_t t_bool = mir_bool_type(g->mu); mir_type_t t_offset = mir_offset_type(g->mu); vlog_lvalue_t result = { .nets = mir_build_load(g->mu, upref), .size = ti->size, .offset = mir_const(g->mu, t_offset, 0), .in_range = mir_const(g->mu, t_bool, 1), }; return result; } static vlog_lvalue_t vlog_lower_lvalue(vlog_gen_t *g, vlog_node_t v) { PUSH_DEBUG_INFO(g->mu, v); switch (vlog_kind(v)) { case V_REF: return vlog_lower_lvalue_ref(g, v); case V_BIT_SELECT: { vlog_node_t prefix = vlog_value(v); assert(vlog_kind(prefix) == V_REF); vlog_lvalue_t ref = vlog_lower_lvalue_ref(g, prefix); vlog_node_t decl = vlog_ref(prefix), dt = vlog_type(decl); const int nunpacked = vlog_ranges(decl); const int nparams = vlog_params(v); assert(nparams <= vlog_ranges(dt) + nunpacked); unsigned size = vlog_size(decl) * ref.size; mir_type_t t_offset = mir_offset_type(g->mu); mir_value_t zero = mir_const(g->mu, t_offset, 0), off = zero; mir_value_t in_range = ref.in_range; for (int i = 0; i < nparams; i++) { vlog_node_t dim; if (i < nunpacked) dim = vlog_range(decl, i); else dim = vlog_range(dt, i - nunpacked); const unsigned dim_size = vlog_size(dim); assert(size % dim_size == 0); size /= dim_size; mir_value_t this_off = vlog_lower_array_off(g, dim, vlog_param(v, i)); mir_value_t count = mir_const(g->mu, t_offset, dim_size); mir_value_t cmp_low = mir_build_cmp(g->mu, MIR_CMP_GEQ, this_off, zero); mir_value_t cmp_high = mir_build_cmp(g->mu, MIR_CMP_LT, this_off, count); mir_value_t this_in_range = mir_build_and(g->mu, cmp_low, cmp_high); if (size != 1) { mir_value_t scale = mir_const(g->mu, t_offset, size); this_off = mir_build_mul(g->mu, t_offset, this_off, scale); } in_range = mir_build_and(g->mu, in_range, this_in_range); off = mir_build_add(g->mu, t_offset, off, this_off); } vlog_lvalue_t lvalue = { .nets = ref.nets, .offset = off, .size = size, .in_range = in_range, }; return lvalue; } case V_PART_SELECT: { vlog_lvalue_t prefix = vlog_lower_lvalue(g, vlog_value(v)); vlog_node_t dt = vlog_type(vlog_ref(vlog_value(v))); vlog_node_t dim = vlog_range(dt, 0); mir_value_t off = vlog_lower_array_off(g, dim, vlog_left(v)); mir_type_t t_offset = mir_offset_type(g->mu); vlog_lvalue_t lvalue = { .nets = prefix.nets, .offset = mir_build_add(g->mu, t_offset, off, prefix.offset), .size = vlog_size(v), .in_range = prefix.in_range, // XXX }; return lvalue; } default: CANNOT_HANDLE(v); } } static void vlog_assign_variable(vlog_gen_t *g, vlog_node_t target, mir_value_t value) { assert(mir_is_vector(g->mu, value)); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, target); mir_type_t t_offset = mir_offset_type(g->mu); mir_type_t t_vec = mir_vec4_type(g->mu, lvalue.size, false); mir_value_t resize = mir_build_cast(g->mu, t_vec, value); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); mir_block_t resume_bb = mir_add_block(g->mu); int64_t in_range_const; if (mir_get_const(g->mu, lvalue.in_range, &in_range_const)) { if (!in_range_const) { mir_comment(g->mu, "Out-of-range assignment"); return; } } else { mir_block_t guarded_bb = mir_add_block(g->mu); mir_build_cond(g->mu, lvalue.in_range, guarded_bb, resume_bb); mir_set_cursor(g->mu, guarded_bb, MIR_APPEND); } mir_value_t dst = mir_build_array_ref(g->mu, lvalue.nets, lvalue.offset); mir_value_t tmp = MIR_NULL_VALUE; if (lvalue.size > 1) { mir_type_t t_elem = mir_logic_type(g->mu); mir_type_t t_array = mir_carray_type(g->mu, lvalue.size, t_elem); tmp = vlog_get_temp(g, t_array); } mir_value_t unpacked = mir_build_unpack(g->mu, resize, 0, tmp); mir_build_deposit_signal(g->mu, dst, count, unpacked); // Delay one delta cycle to see the update mir_value_t zero_time = mir_const(g->mu, mir_time_type(g->mu), 0); mir_build_wait(g->mu, resume_bb, zero_time); mir_set_cursor(g->mu, resume_bb, MIR_APPEND); } static mir_value_t vlog_lower_unary(vlog_gen_t *g, vlog_node_t v) { mir_value_t input = vlog_lower_rvalue(g, vlog_value(v)); mir_type_t type = mir_get_type(g->mu, input); mir_vec_op_t mop; switch (vlog_subkind(v)) { case V_UNARY_BITNEG: mop = MIR_VEC_BIT_NOT; break; case V_UNARY_NOT: mop = MIR_VEC_LOG_NOT; break; case V_UNARY_NEG: mop = MIR_VEC_SUB; break; case V_UNARY_OR: mop = MIR_VEC_BIT_OR; break; default: CANNOT_HANDLE(v); } return mir_build_unary(g->mu, mop, type, input); } static mir_value_t vlog_lower_binary(vlog_gen_t *g, vlog_node_t v) { mir_value_t left = vlog_lower_rvalue(g, vlog_left(v)); mir_value_t right = vlog_lower_rvalue(g, vlog_right(v)); assert(mir_is_vector(g->mu, left)); assert(mir_is_vector(g->mu, right)); mir_type_t ltype = mir_get_type(g->mu, left); mir_type_t rtype = mir_get_type(g->mu, right); const mir_class_t lclass = mir_get_class(g->mu, ltype); const mir_class_t rclass = mir_get_class(g->mu, rtype); const int lsize = mir_get_size(g->mu, ltype); const int rsize = mir_get_size(g->mu, rtype); mir_type_t type; if (lclass == MIR_TYPE_VEC4 || rclass == MIR_TYPE_VEC4) type = mir_vec4_type(g->mu, MAX(lsize, rsize), false); else type = mir_vec2_type(g->mu, MAX(lsize, rsize), false); mir_value_t lcast = mir_build_cast(g->mu, type, left); mir_value_t rcast = mir_build_cast(g->mu, type, right); mir_vec_op_t mop; switch (vlog_subkind(v)) { case V_BINARY_AND: mop = MIR_VEC_BIT_AND; break; case V_BINARY_OR: mop = MIR_VEC_BIT_OR; break; case V_BINARY_LOG_AND: mop = MIR_VEC_LOG_AND; break; case V_BINARY_LOG_OR: mop = MIR_VEC_LOG_OR; break; case V_BINARY_LT: mop = MIR_VEC_LT; break; case V_BINARY_LEQ: mop = MIR_VEC_LEQ; break; case V_BINARY_GT: mop = MIR_VEC_GT; break; case V_BINARY_GEQ: mop = MIR_VEC_GEQ; break; case V_BINARY_LOG_EQ: mop = MIR_VEC_LOG_EQ; break; case V_BINARY_LOG_NEQ: mop = MIR_VEC_LOG_NEQ; break; case V_BINARY_CASE_EQ: mop = MIR_VEC_CASE_EQ; break; case V_BINARY_CASE_NEQ: mop = MIR_VEC_CASE_NEQ; break; case V_BINARY_PLUS: mop = MIR_VEC_ADD; break; case V_BINARY_MINUS: mop = MIR_VEC_SUB; break; case V_BINARY_TIMES: mop = MIR_VEC_MUL; break; case V_BINARY_SHIFT_LL: mop = MIR_VEC_SLL; break; case V_BINARY_SHIFT_RL: mop = MIR_VEC_SRL; break; default: CANNOT_HANDLE(v); } return mir_build_binary(g->mu, mop, type, lcast, rcast); } static mir_value_t vlog_lower_systf_param(vlog_gen_t *g, vlog_node_t v) { switch (vlog_kind(v)) { case V_REF: case V_STRING: case V_NUMBER: case V_EMPTY: return MIR_NULL_VALUE; case V_UNARY: case V_BINARY: case V_SYS_FCALL: case V_PREFIX: case V_POSTFIX: case V_BIT_SELECT: // TODO: these should not be evaluated until vpi_get_value is called return vlog_lower_rvalue(g, v); default: CANNOT_HANDLE(v); } } static mir_value_t vlog_lower_sys_tfcall(vlog_gen_t *g, vlog_node_t v) { const int nparams = vlog_params(v); mir_value_t *args LOCAL = xmalloc_array((nparams * 2) + 1, sizeof(mir_value_t)); int actual = 0; mir_type_t t_offset = mir_offset_type(g->mu); for (int i = 0; i < nparams; i++) { mir_value_t arg = vlog_lower_systf_param(g, vlog_param(v, i)); if (mir_is_null(arg)) continue; mir_type_t type = mir_get_type(g->mu, arg); switch (mir_get_class(g->mu, type)) { case MIR_TYPE_VEC4: args[actual++] = mir_const(g->mu, t_offset, mir_get_size(g->mu, type)); args[actual++] = arg; break; case MIR_TYPE_VEC2: { // TODO: remove the cast const int size = mir_get_size(g->mu, type); mir_type_t t_vec4 = mir_vec4_type(g->mu, size, false); args[actual++] = mir_const(g->mu, t_offset, size); args[actual++] = mir_build_cast(g->mu, t_vec4, arg); } break; default: should_not_reach_here(); } } mir_value_t locus = mir_build_locus(g->mu, vlog_to_object(v)); mir_type_t type = MIR_NULL_TYPE; if (vlog_kind(v) == V_SYS_FCALL) type = mir_vec2_type(g->mu, 64, false); // XXX: hack for $time return mir_build_syscall(g->mu, vlog_ident(v), type, MIR_NULL_STAMP, locus, args, actual); } static mir_value_t vlog_lower_resolved(mir_unit_t *mu, vlog_node_t v) { switch (vlog_kind(v)) { case V_PORT_DECL: case V_REF: return vlog_lower_resolved(mu, vlog_ref(v)); case V_VAR_DECL: case V_NET_DECL: { int hops; mir_value_t var = mir_search_object(mu, v, &hops); assert(!mir_is_null(var)); assert(hops > 0); mir_value_t upref = mir_build_var_upref(mu, hops, var.id); mir_value_t nets = mir_build_load(mu, upref); return mir_build_resolved(mu, nets); } default: CANNOT_HANDLE(v); } } static mir_value_t vlog_lower_truthy(vlog_gen_t *g, vlog_node_t v) { mir_value_t test = vlog_lower_rvalue(g, v); assert(mir_is_vector(g->mu, test)); mir_type_t type = mir_get_type(g->mu, test); mir_value_t zero = mir_const_vec(g->mu, type, 0, 0); return mir_build_cmp(g->mu, MIR_CMP_NEQ, test, zero); } static mir_value_t vlog_lower_bit_select(vlog_gen_t *g, vlog_node_t v) { vlog_node_t value = vlog_value(v); assert(vlog_kind(value) == V_REF); mir_value_t data = vlog_lower_resolved(g->mu, value); vlog_node_t decl = vlog_ref(value), dt = vlog_type(decl); const int nunpacked = vlog_ranges(decl); const int nparams = vlog_params(v); assert(nparams <= vlog_ranges(dt) + nunpacked); unsigned size = vlog_size(decl) * vlog_size(dt); mir_type_t t_offset = mir_offset_type(g->mu); mir_value_t zero = mir_const(g->mu, t_offset, 0), off = zero; mir_value_t in_range = mir_const(g->mu, mir_bool_type(g->mu), 1); for (int i = 0; i < nparams; i++) { vlog_node_t dim; if (i < nunpacked) dim = vlog_range(decl, i); else dim = vlog_range(dt, i - nunpacked); const unsigned dim_size = vlog_size(dim); assert(size % dim_size == 0); size /= dim_size; mir_value_t this_off = vlog_lower_array_off(g, dim, vlog_param(v, i)); mir_value_t count = mir_const(g->mu, t_offset, dim_size); mir_value_t cmp_low = mir_build_cmp(g->mu, MIR_CMP_GEQ, this_off, zero); mir_value_t cmp_high = mir_build_cmp(g->mu, MIR_CMP_LT, this_off, count); mir_value_t this_in_range = mir_build_and(g->mu, cmp_low, cmp_high); if (size != 1) { mir_value_t scale = mir_const(g->mu, t_offset, size); this_off = mir_build_mul(g->mu, t_offset, this_off, scale); } in_range = mir_build_and(g->mu, in_range, this_in_range); off = mir_build_add(g->mu, t_offset, off, this_off); } mir_type_t type = mir_vec4_type(g->mu, size, false); mir_block_t merge_bb = MIR_NULL_BLOCK; mir_value_t tmp; int64_t in_range_const; if (mir_get_const(g->mu, in_range, &in_range_const)) { if (!in_range_const) return mir_const_vec(g->mu, type, 1, 1); } else { // TODO: use a phi node here tmp = mir_add_var(g->mu, type, MIR_NULL_STAMP, ident_uniq("tmp"), MIR_VAR_TEMP); mir_build_store(g->mu, tmp, mir_const_vec(g->mu, type, 1, 1)); mir_block_t guarded_bb = mir_add_block(g->mu); merge_bb = mir_add_block(g->mu); mir_build_cond(g->mu, in_range, guarded_bb, merge_bb); mir_set_cursor(g->mu, guarded_bb, MIR_APPEND); } mir_value_t ptr = mir_build_array_ref(g->mu, data, off), packed; if (size == 1) { mir_value_t bit = mir_build_load(g->mu, ptr); packed = mir_build_pack(g->mu, type, bit); } else packed = mir_build_pack(g->mu, type, ptr); if (mir_is_null(merge_bb)) return packed; else { mir_build_store(g->mu, tmp, packed); mir_build_jump(g->mu, merge_bb); mir_set_cursor(g->mu, merge_bb, MIR_APPEND); return mir_build_load(g->mu, tmp); } } static mir_value_t vlog_lower_rvalue(vlog_gen_t *g, vlog_node_t v) { PUSH_DEBUG_INFO(g->mu, v); switch (vlog_kind(v)) { case V_REF: { vlog_node_t decl = vlog_ref(v); if (vlog_kind(decl) == V_LOCALPARAM) return vlog_lower_rvalue(g, vlog_value(decl)); mir_value_t data = vlog_lower_resolved(g->mu, decl); const type_info_t *ti = vlog_type_info(g, vlog_type(decl)); if (ti->size == 1) data = mir_build_load(g->mu, data); return mir_build_pack(g->mu, ti->type, data); } case V_EVENT: { vlog_node_t value = vlog_value(v); mir_type_t t_offset = mir_offset_type(g->mu); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, value); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); // XXX: check in range mir_value_t nets = mir_build_array_ref(g->mu, lvalue.nets, lvalue.offset); mir_value_t event = mir_build_event_flag(g->mu, nets, count); const v_event_kind_t ekind = vlog_subkind(v); if (ekind == V_EVENT_LEVEL) return event; mir_type_t t_logic = mir_vec4_type(g->mu, 1, false); mir_value_t level = mir_const_vec(g->mu, t_logic, ekind == V_EVENT_POSEDGE, 0); mir_value_t rvalue = vlog_lower_rvalue(g, value); mir_value_t cmp = mir_build_cmp(g->mu, MIR_CMP_EQ, rvalue, level); return mir_build_and(g->mu, event, cmp); } case V_NUMBER: { number_t num = vlog_number(v); const int width = number_width(num); assert(width < 64); if (number_is_defined(num)) { mir_type_t t_vec2 = mir_vec2_type(g->mu, width, false); return mir_const_vec(g->mu, t_vec2, number_integer(num), 0); } else { uint64_t abits = 0, bbits = 0; for (int i = 0; i < width; i++) { vlog_logic_t bit = number_bit(num, width - i - 1); abits = (abits << 1) | (bit & 1); bbits = (bbits << 1) | ((bit >> 1) & 1); } mir_type_t t_vec4 = mir_vec4_type(g->mu, width, false); return mir_const_vec(g->mu, t_vec4, abits, bbits); } } case V_BINARY: return vlog_lower_binary(g, v); case V_UNARY: return vlog_lower_unary(g, v); case V_SYS_FCALL: return vlog_lower_sys_tfcall(g, v); case V_BIT_SELECT: return vlog_lower_bit_select(g, v); case V_PART_SELECT: { mir_value_t base = vlog_lower_resolved(g->mu, vlog_value(v)); vlog_node_t dt = vlog_type(vlog_ref(vlog_value(v))); vlog_node_t dim = vlog_range(dt, 0); mir_value_t off = vlog_lower_array_off(g, dim, vlog_left(v)); mir_value_t ptr = mir_build_array_ref(g->mu, base, off); mir_type_t t_vec = mir_vec4_type(g->mu, vlog_size(v), false); return mir_build_pack(g->mu, t_vec, ptr); } case V_CONCAT: { int size = 0, repeat = 1, pos = 0; const int nparams = vlog_params(v); mir_value_t *inputs LOCAL = xmalloc_array(nparams, sizeof(mir_value_t)); for (int i = 0; i < nparams; i++) { inputs[i] = vlog_lower_rvalue(g, vlog_param(v, i)); assert(mir_is_vector(g->mu, inputs[i])); size += mir_get_size(g->mu, mir_get_type(g->mu, inputs[i])); } if (vlog_has_value(v)) size *= (repeat = MAX(0, vlog_get_const(vlog_value(v)))); mir_type_t type = mir_vec4_type(g->mu, size, false); mir_value_t result = mir_const_vec(g->mu, type, 0, 0); for (int i = 0; i < repeat; i++) { for (int j = nparams - 1; j >= 0; j--) { // TODO: add a vector-insert operation mir_value_t cast = mir_build_cast(g->mu, type, inputs[j]); mir_value_t amount = mir_const_vec(g->mu, type, pos, 0); mir_value_t shift = mir_build_binary(g->mu, MIR_VEC_SLL, type, cast, amount); result = mir_build_binary(g->mu, MIR_VEC_BIT_OR, type, result, shift); pos += mir_get_size(g->mu, mir_get_type(g->mu, inputs[j])); } } return result; } case V_PREFIX: { vlog_node_t target = vlog_target(v); mir_value_t prev = vlog_lower_rvalue(g, target); mir_type_t type = mir_get_type(g->mu, prev); mir_value_t one = mir_const_vec(g->mu, type, 1, 0); mir_value_t inc = mir_build_binary(g->mu, MIR_VEC_ADD, type, prev, one); // Must save/restore around blocking assignment mir_value_t tmp = mir_add_var(g->mu, type, MIR_NULL_STAMP, ident_uniq("prefix"), MIR_VAR_TEMP); mir_build_store(g->mu, tmp, inc); vlog_assign_variable(g, target, inc); return mir_build_load(g->mu, tmp); } case V_POSTFIX: { vlog_node_t target = vlog_target(v); mir_value_t prev = vlog_lower_rvalue(g, target); mir_type_t type = mir_get_type(g->mu, prev); mir_value_t one = mir_const_vec(g->mu, type, 1, 0); mir_value_t inc = mir_build_binary(g->mu, MIR_VEC_ADD, type, prev, one); vlog_assign_variable(g, target, inc); return inc; } case V_COND_EXPR: { // TODO: check semantics for return type // TODO: do not evaluate both sides mir_value_t cmp = vlog_lower_truthy(g, vlog_value(v)); mir_value_t left = vlog_lower_rvalue(g, vlog_left(v)); mir_value_t right = vlog_lower_rvalue(g, vlog_right(v)); mir_type_t type = mir_get_type(g->mu, left); return mir_build_select(g->mu, type, cmp, left, right); } default: CANNOT_HANDLE(v); } } static mir_value_t vlog_lower_time(vlog_gen_t *g, vlog_node_t v) { assert(vlog_kind(v) == V_NUMBER); mir_type_t t_time = mir_time_type(g->mu); number_t num = vlog_number(v); return mir_const(g->mu, t_time, number_integer(num)); } static void vlog_lower_sensitivity(vlog_gen_t *g, vlog_node_t v) { const vlog_kind_t kind = vlog_kind(v); switch (kind) { case V_REF: { switch (vlog_kind(vlog_ref(v))) { case V_PORT_DECL: case V_NET_DECL: case V_VAR_DECL: { mir_type_t t_offset = mir_offset_type(g->mu); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, v); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); mir_build_sched_event(g->mu, lvalue.nets, count); } break; case V_PARAM_DECL: case V_LOCALPARAM: break; default: CANNOT_HANDLE(v); } } break; case V_BIT_SELECT: case V_PART_SELECT: { vlog_node_t prefix = vlog_longest_static_prefix(v); if (prefix == v) { mir_type_t t_offset = mir_offset_type(g->mu); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, v); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); // XXX: check in range mir_value_t nets = mir_build_array_ref(g->mu, lvalue.nets, lvalue.offset); mir_build_sched_event(g->mu, nets, count); } else vlog_lower_sensitivity(g, prefix); if (kind == V_BIT_SELECT) { const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) vlog_lower_sensitivity(g, vlog_param(v, i)); } else vlog_lower_sensitivity(g, vlog_left(v)); } break; case V_EVENT: vlog_lower_sensitivity(g, vlog_value(v)); break; case V_NUMBER: break; case V_BINARY: vlog_lower_sensitivity(g, vlog_left(v)); vlog_lower_sensitivity(g, vlog_right(v)); break; case V_UNARY: vlog_lower_sensitivity(g, vlog_value(v)); break; case V_COND_EXPR: vlog_lower_sensitivity(g, vlog_value(v)); vlog_lower_sensitivity(g, vlog_left(v)); vlog_lower_sensitivity(g, vlog_right(v)); break; case V_CONCAT: { const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) vlog_lower_sensitivity(g, vlog_param(v, i)); } break; default: CANNOT_HANDLE(v); } } static void vlog_lower_timing(vlog_gen_t *g, vlog_node_t v, bool is_static) { mir_block_t true_bb = mir_add_block(g->mu), false_bb = MIR_NULL_BLOCK; vlog_node_t ctrl = vlog_value(v); switch (vlog_kind(ctrl)) { case V_DELAY_CONTROL: { mir_type_t t_time = mir_time_type(g->mu); mir_value_t delay = vlog_lower_rvalue(g, vlog_value(ctrl)); mir_value_t cast = mir_build_cast(g->mu, t_time, delay); mir_build_wait(g->mu, true_bb, cast); mir_set_cursor(g->mu, true_bb, MIR_APPEND); } break; case V_EVENT_CONTROL: { mir_value_t test = MIR_NULL_VALUE; const int nparams = vlog_params(ctrl); if (nparams > 0) { test = vlog_lower_rvalue(g, vlog_param(ctrl, 0)); for (int i = 1; i < nparams; i++) { mir_value_t sub = vlog_lower_rvalue(g, vlog_param(ctrl, i)); test = mir_build_or(g->mu, test, sub); } } false_bb = mir_add_block(g->mu); if (mir_is_null(test)) mir_build_jump(g->mu, false_bb); else mir_build_cond(g->mu, test, true_bb, false_bb); mir_set_cursor(g->mu, true_bb, MIR_APPEND); } break; default: CANNOT_HANDLE(ctrl); } vlog_lower_stmts(g, v); if (!mir_is_null(false_bb)) { if (!mir_block_finished(g->mu, mir_get_cursor(g->mu, NULL))) mir_build_jump(g->mu, false_bb); mir_set_cursor(g->mu, false_bb, MIR_APPEND); } } static void vlog_lower_blocking_assignment(vlog_gen_t *g, vlog_node_t v) { if (vlog_has_delay(v)) { vlog_node_t delay = vlog_delay(v); assert(vlog_kind(delay) == V_DELAY_CONTROL); mir_block_t delay_bb = mir_add_block(g->mu); mir_build_wait(g->mu, delay_bb, vlog_lower_time(g, vlog_value(delay))); mir_set_cursor(g->mu, delay_bb, MIR_APPEND); } mir_value_t value = vlog_lower_rvalue(g, vlog_value(v)); vlog_assign_variable(g, vlog_target(v), value); } static void vlog_lower_non_blocking_assignment(vlog_gen_t *g, vlog_node_t v) { vlog_node_t target = vlog_target(v); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, target); // XXX: check in range mir_value_t nets = mir_build_array_ref(g->mu, lvalue.nets, lvalue.offset); mir_value_t value = vlog_lower_rvalue(g, vlog_value(v)); assert(mir_is_vector(g->mu, value)); mir_type_t t_offset = mir_offset_type(g->mu); mir_type_t t_vec = mir_vec4_type(g->mu, lvalue.size, false); mir_value_t resize = mir_build_cast(g->mu, t_vec, value); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); mir_value_t tmp = MIR_NULL_VALUE; if (lvalue.size > 1) { mir_type_t t_elem = mir_logic_type(g->mu); mir_type_t t_array = mir_carray_type(g->mu, lvalue.size, t_elem); tmp = vlog_get_temp(g, t_array); } const uint8_t strength = vlog_is_net(target) ? ST_STRONG : 0; mir_value_t unpacked = mir_build_unpack(g->mu, resize, strength, tmp); mir_type_t t_time = mir_time_type(g->mu); mir_value_t reject = mir_const(g->mu, t_time, 0); mir_value_t after; if (vlog_has_delay(v)) { vlog_node_t delay = vlog_delay(v); assert(vlog_kind(delay) == V_DELAY_CONTROL); after = vlog_lower_time(g, vlog_value(delay)); } else after = mir_const(g->mu, t_time, 0); mir_build_sched_waveform(g->mu, nets, count, unpacked, reject, after); } static void vlog_lower_if(vlog_gen_t *g, vlog_node_t v) { mir_block_t exit_bb = MIR_NULL_BLOCK; const int nconds = vlog_conds(v); for (int i = 0; i < nconds; i++) { vlog_node_t c = vlog_cond(v, i); mir_block_t next_bb = MIR_NULL_BLOCK; if (vlog_has_value(c)) { mir_value_t cmp = vlog_lower_truthy(g, vlog_value(c)); mir_block_t btrue = mir_add_block(g->mu); if (i == nconds - 1) { if (mir_is_null(exit_bb)) exit_bb = mir_add_block(g->mu); next_bb = exit_bb; } else next_bb = mir_add_block(g->mu); mir_build_cond(g->mu, cmp, btrue, next_bb); mir_set_cursor(g->mu, btrue, MIR_APPEND); } vlog_lower_stmts(g, c); if (!mir_block_finished(g->mu, MIR_NULL_BLOCK)) { if (mir_is_null(exit_bb)) exit_bb = mir_add_block(g->mu); mir_build_jump(g->mu, exit_bb); } if (mir_is_null(next_bb)) break; mir_set_cursor(g->mu, next_bb, MIR_APPEND); } if (!mir_is_null(exit_bb)) mir_set_cursor(g->mu, exit_bb, MIR_APPEND); } static void vlog_lower_forever(vlog_gen_t *g, vlog_node_t v) { mir_block_t body_bb = mir_add_block(g->mu); mir_build_jump(g->mu, body_bb); mir_set_cursor(g->mu, body_bb, MIR_APPEND); vlog_lower_stmts(g, v); mir_build_jump(g->mu, body_bb); } static void vlog_lower_for_loop(vlog_gen_t *g, vlog_node_t v) { mir_comment(g->mu, "Begin for loop"); vlog_node_t init = vlog_left(v); assert(vlog_kind(init) == V_FOR_INIT); assert(vlog_decls(init) == 0); // TODO vlog_lower_stmts(g, init); mir_block_t body_bb = mir_add_block(g->mu); mir_block_t step_bb = mir_add_block(g->mu); mir_block_t test_bb = mir_add_block(g->mu); mir_block_t exit_bb = mir_add_block(g->mu); mir_build_jump(g->mu, test_bb); mir_set_cursor(g->mu, test_bb, MIR_APPEND); mir_comment(g->mu, "For loop test"); mir_value_t test = vlog_lower_rvalue(g, vlog_value(v)); assert(mir_is_vector(g->mu, test)); mir_value_t zero = mir_const_vec(g->mu, mir_get_type(g->mu, test), 0, 0); mir_value_t cmp = mir_build_cmp(g->mu, MIR_CMP_NEQ, test, zero); mir_build_cond(g->mu, cmp, body_bb, exit_bb); mir_set_cursor(g->mu, body_bb, MIR_APPEND); mir_comment(g->mu, "For loop body"); vlog_lower_stmts(g, v); if (!mir_block_finished(g->mu, MIR_NULL_BLOCK)) mir_build_jump(g->mu, step_bb); mir_set_cursor(g->mu, step_bb, MIR_APPEND); mir_comment(g->mu, "For loop step"); vlog_node_t step = vlog_right(v); assert(vlog_kind(step) == V_FOR_STEP); const int nstmts = vlog_stmts(step); for (int i = 0; i < nstmts; i++) { vlog_node_t s = vlog_stmt(step, i); if (vlog_kind(s) == V_BASSIGN) // XXX: should be op assign vlog_lower_blocking_assignment(g, s); else vlog_lower_rvalue(g, s); } mir_build_jump(g->mu, test_bb); mir_set_cursor(g->mu, exit_bb, MIR_APPEND); mir_comment(g->mu, "End for loop"); } static void vlog_lower_case(vlog_gen_t *g, vlog_node_t v) { mir_comment(g->mu, "Begin case statement"); mir_value_t value = vlog_lower_rvalue(g, vlog_value(v)); mir_type_t type = mir_get_type(g->mu, value); // TODO: use a parallel case for small integer types const int nitems = vlog_stmts(v); mir_block_t *blocks LOCAL = xmalloc_array(nitems, sizeof(mir_block_t)); mir_type_t t_logic = mir_vec4_type(g->mu, 1, false); mir_value_t zero = mir_const_vec(g->mu, t_logic, 0, 0); for (int i = 0; i < nitems; i++) { vlog_node_t item = vlog_stmt(v, i); assert(vlog_kind(item) == V_CASE_ITEM); blocks[i] = mir_add_block(g->mu); mir_block_t else_bb = mir_add_block(g->mu); mir_value_t comb = MIR_NULL_VALUE; const int nparams = vlog_params(item); for (int j = 0; j < nparams; j++) { mir_value_t test = vlog_lower_rvalue(g, vlog_param(item, j)); mir_value_t cast = mir_build_cast(g->mu, type, test); mir_value_t case_eq = mir_build_binary(g->mu, MIR_VEC_CASE_EQ, type, cast, value); mir_value_t cmp = mir_build_cmp(g->mu, MIR_CMP_NEQ, case_eq, zero); if (mir_is_null(comb)) comb = cmp; else comb = mir_build_or(g->mu, comb, cmp); } if (mir_is_null(comb)) mir_build_jump(g->mu, blocks[i]); else mir_build_cond(g->mu, comb, blocks[i], else_bb); mir_set_cursor(g->mu, else_bb, MIR_APPEND); } mir_block_t exit_bb = mir_get_cursor(g->mu, NULL); for (int i = 0; i < nitems; i++) { vlog_node_t item = vlog_stmt(v, i); assert(vlog_kind(item) == V_CASE_ITEM); mir_set_cursor(g->mu, blocks[i], MIR_APPEND); vlog_lower_stmts(g, item); if (!mir_block_finished(g->mu, MIR_NULL_BLOCK)) mir_build_jump(g->mu, exit_bb); } mir_set_cursor(g->mu, exit_bb, MIR_APPEND); mir_comment(g->mu, "End case statement"); } static void vlog_lower_stmts(vlog_gen_t *g, vlog_node_t v) { const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { vlog_node_t s = vlog_stmt(v, i); mir_set_loc(g->mu, vlog_loc(s)); switch (vlog_kind(s)) { case V_TIMING: vlog_lower_timing(g, s, false); break; case V_BASSIGN: vlog_lower_blocking_assignment(g, s); break; case V_NBASSIGN: vlog_lower_non_blocking_assignment(g, s); break; case V_BLOCK: vlog_lower_stmts(g, s); break; case V_SYS_TCALL: vlog_lower_sys_tfcall(g, s); break; case V_IF: vlog_lower_if(g, s); break; case V_FOREVER: vlog_lower_forever(g, s); break; case V_FOR_LOOP: vlog_lower_for_loop(g, s); break; case V_CASE: vlog_lower_case(g, s); break; default: CANNOT_HANDLE(s); } } } static void vlog_lower_driver(vlog_gen_t *g, vlog_node_t v) { mir_type_t t_offset = mir_offset_type(g->mu); vlog_node_t prefix = vlog_longest_static_prefix(v); vlog_lvalue_t target = vlog_lower_lvalue(g, prefix); // XXX: check in range mir_value_t nets = mir_build_array_ref(g->mu, target.nets, target.offset); mir_value_t one = mir_const(g->mu, t_offset, target.size); mir_build_drive_signal(g->mu, nets, one); } static void vlog_driver_cb(vlog_node_t v, void *context) { vlog_gen_t *g = context; switch (vlog_kind(v)) { case V_NBASSIGN: case V_ASSIGN: vlog_lower_driver(g, vlog_target(v)); break; default: break; } } static void vlog_lower_always(vlog_gen_t *g, vlog_node_t v) { mir_block_t start_bb = mir_add_block(g->mu); assert(start_bb.id == 1); vlog_visit(v, vlog_driver_cb, g); vlog_node_t timing = NULL, s0 = vlog_stmt(v, 0); if (vlog_kind(s0) == V_TIMING) { timing = s0; vlog_node_t ctrl = vlog_value(timing); assert(vlog_kind(ctrl) == V_EVENT_CONTROL); const int nparams = vlog_params(ctrl); for (int i = 0; i < nparams; i++) vlog_lower_sensitivity(g, vlog_param(ctrl, i)); } mir_build_return(g->mu, MIR_NULL_VALUE); mir_set_cursor(g->mu, start_bb, MIR_APPEND); if (timing != NULL) vlog_lower_timing(g, timing, true); else vlog_lower_stmts(g, v); mir_build_wait(g->mu, start_bb, MIR_NULL_VALUE); } static void vlog_lower_initial(vlog_gen_t *g, vlog_node_t v) { mir_block_t start_bb = mir_add_block(g->mu); assert(start_bb.id == 1); vlog_visit(v, vlog_driver_cb, g); mir_build_return(g->mu, MIR_NULL_VALUE); mir_set_cursor(g->mu, start_bb, MIR_APPEND); vlog_lower_stmts(g, v); if (!mir_block_finished(g->mu, MIR_NULL_BLOCK)) mir_build_return(g->mu, MIR_NULL_VALUE); } static void vlog_lower_continuous_assign(vlog_gen_t *g, vlog_node_t v) { mir_block_t start_bb = mir_add_block(g->mu); assert(start_bb.id == 1); vlog_visit(v, vlog_driver_cb, g); vlog_lower_sensitivity(g, vlog_value(v)); mir_build_return(g->mu, MIR_NULL_VALUE); mir_set_cursor(g->mu, start_bb, MIR_APPEND); vlog_lower_non_blocking_assignment(g, v); mir_build_wait(g->mu, start_bb, MIR_NULL_VALUE); } static void vlog_lower_gate_inst(vlog_gen_t *g, vlog_node_t v) { mir_block_t start_bb = mir_add_block(g->mu); assert(start_bb.id == 1); vlog_lower_driver(g, vlog_target(v)); mir_type_t t_offset = mir_offset_type(g->mu); mir_type_t t_time = mir_time_type(g->mu); mir_type_t t_logic = mir_vec4_type(g->mu, 1, false); const int nparams = vlog_params(v); int first_term = 0; for (int i = 0; i < nparams; i++) { vlog_node_t p = vlog_param(v, i); if (vlog_kind(p) == V_STRENGTH) first_term = i + 1; else { vlog_lvalue_t lvalue = vlog_lower_lvalue(g, p); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); mir_build_sched_event(g->mu, lvalue.nets, count); } } mir_build_return(g->mu, MIR_NULL_VALUE); mir_set_cursor(g->mu, start_bb, MIR_APPEND); bool negate = false; uint8_t strength = ST_STRONG; mir_value_t value = MIR_NULL_VALUE; const vlog_gate_kind_t kind = vlog_subkind(v); switch (kind) { case V_GATE_PULLUP: case V_GATE_PULLDOWN: strength = vlog_subkind(vlog_param(v, 0)); value = mir_const_vec(g->mu, t_logic, kind == V_GATE_PULLUP, 0); break; case V_GATE_NAND: case V_GATE_NOR: case V_GATE_XNOR: negate = true; case V_GATE_AND: case V_GATE_OR: case V_GATE_XOR: { static const mir_vec_op_t op_map[] = { [V_GATE_AND] = MIR_VEC_BIT_AND, [V_GATE_NAND] = MIR_VEC_BIT_AND, [V_GATE_OR] = MIR_VEC_BIT_OR, [V_GATE_NOR] = MIR_VEC_BIT_OR, [V_GATE_XOR] = MIR_VEC_BIT_XOR, [V_GATE_XNOR] = MIR_VEC_BIT_XOR, }; value = vlog_lower_rvalue(g, vlog_param(v, first_term)); const int nelems = nparams - first_term; for (int i = 1; i < nelems; i++) { vlog_node_t p = vlog_param(v, first_term + i); mir_value_t arg = vlog_lower_rvalue(g, p); value = mir_build_binary(g->mu, op_map[kind], t_logic, value, arg); } if (negate) value = mir_build_unary(g->mu, MIR_VEC_BIT_NOT, t_logic, value); } break; case V_GATE_NOT: { const int nparams = vlog_params(v); mir_value_t input = vlog_lower_rvalue(g, vlog_param(v, nparams - 1)); value = mir_build_unary(g->mu, MIR_VEC_BIT_NOT, t_logic, input); } break; default: CANNOT_HANDLE(v); } mir_value_t unpacked = mir_build_unpack(g->mu, value, strength, MIR_NULL_VALUE); mir_value_t reject = mir_const(g->mu, t_time, 0); mir_value_t after = mir_const(g->mu, t_time, 0); vlog_lvalue_t lvalue = vlog_lower_lvalue(g, vlog_target(v)); mir_value_t count = mir_const(g->mu, t_offset, lvalue.size); // XXX: check in range mir_value_t nets = mir_build_array_ref(g->mu, lvalue.nets, lvalue.offset); mir_build_sched_waveform(g->mu, nets, count, unpacked, reject, after); mir_build_wait(g->mu, start_bb, MIR_NULL_VALUE); } static void vlog_lower_cleanup(vlog_gen_t *g) { if (g->temps != NULL) ihash_free(g->temps); } void vlog_lower_deferred(mir_unit_t *mu, object_t *obj) { vlog_node_t v = vlog_from_object(obj); assert(v != NULL); vlog_gen_t g = { .mu = mu, }; switch (vlog_kind(v)) { case V_ALWAYS: vlog_lower_always(&g, v); break; case V_INITIAL: vlog_lower_initial(&g, v); break; case V_ASSIGN: vlog_lower_continuous_assign(&g, v); break; case V_GATE_INST: vlog_lower_gate_inst(&g, v); break; default: CANNOT_HANDLE(v); } vlog_lower_cleanup(&g); } static void vlog_lower_net_decl(mir_unit_t *mu, vlog_node_t v, tree_t wrap, mir_value_t resfn) { mir_type_t t_net_value = mir_int_type(mu, 0, 255); mir_type_t t_net_signal = mir_signal_type(mu, t_net_value); mir_type_t t_offset = mir_offset_type(mu); assert(!vlog_has_value(v)); // Should have been replaced with assign mir_value_t value = mir_const(mu, t_net_value, LOGIC_X); mir_value_t count = mir_const(mu, t_offset, vlog_size(vlog_type(v))); mir_value_t size = mir_const(mu, t_offset, 1); mir_value_t flags = mir_const(mu, t_offset, 0); mir_value_t locus = mir_build_locus(mu, tree_to_object(wrap)); mir_value_t signal = mir_build_init_signal(mu, t_net_value, count, size, value, flags, locus, MIR_NULL_VALUE); mir_build_resolve_signal(mu, signal, resfn); mir_value_t var = mir_add_var(mu, t_net_signal, MIR_NULL_STAMP, vlog_ident(v), MIR_VAR_SIGNAL); mir_build_store(mu, var, signal); mir_put_object(mu, v, var); } static void vlog_lower_var_decl(vlog_gen_t *g, vlog_node_t v, tree_t wrap) { mir_type_t t_logic = mir_int_type(g->mu, 0, 3); mir_type_t t_logic_signal = mir_signal_type(g->mu, t_logic); mir_type_t t_offset = mir_offset_type(g->mu); const type_info_t *ti = vlog_type_info(g, vlog_type(v)); const int total_size = ti->size * vlog_size(v); mir_value_t value; if (vlog_has_value(v)) { mir_value_t tmp = MIR_NULL_VALUE; if (ti->size > 1) { mir_type_t t_elem = mir_logic_type(g->mu); mir_type_t t_array = mir_carray_type(g->mu, total_size, t_elem); tmp = vlog_get_temp(g, t_array); } mir_value_t packed = vlog_lower_rvalue(g, vlog_value(v)); mir_value_t cast = mir_build_cast(g->mu, ti->type, packed); value = mir_build_unpack(g->mu, cast, 0, tmp); } else value = mir_const(g->mu, t_logic, LOGIC_X); mir_value_t count = mir_const(g->mu, t_offset, total_size); mir_value_t size = mir_const(g->mu, t_offset, 1); mir_value_t flags = mir_const(g->mu, t_offset, 0); mir_value_t locus = mir_build_locus(g->mu, tree_to_object(wrap)); mir_value_t signal = mir_build_init_signal(g->mu, t_logic, count, size, value, flags, locus, MIR_NULL_VALUE); mir_value_t var = mir_add_var(g->mu, t_logic_signal, MIR_NULL_STAMP, vlog_ident(v), MIR_VAR_SIGNAL); mir_build_store(g->mu, var, signal); mir_put_object(g->mu, v, var); } static mir_type_t vlog_lower_vhdl_type(mir_unit_t *mu, type_t type) { if (type_eq(type, ieee_type(IEEE_STD_ULOGIC))) return mir_int_type(mu, 0, 8); else if (type_eq(type, ieee_type(IEEE_STD_ULOGIC_VECTOR))) return mir_uarray_type(mu, 1, mir_int_type(mu, 0, 8)); else if (type_eq(type, verilog_type(VERILOG_NET_VALUE))) return mir_int_type(mu, 0, 255); else if (type_eq(type, verilog_type(VERILOG_LOGIC))) return mir_int_type(mu, 0, 3); else if (type_eq(type, verilog_type(VERILOG_WIRE_ARRAY)) || type_eq(type, verilog_type(VERILOG_NET_ARRAY))) return mir_uarray_type(mu, 1, mir_int_type(mu, 0, 3)); fatal_trace("cannot lower VHDL type %s", type_pp(type)); } static void vlog_lower_converter(mir_unit_t *mu, tree_t cf, mir_value_t in, mir_value_t out) { tree_t decl = tree_ref(cf); assert(tree_kind(decl) == T_FUNC_DECL); type_t rtype = type_result(tree_type(decl)); // Dummy return value to force function calling convention mir_type_t t_offset = mir_offset_type(mu); mir_set_result(mu, t_offset); mir_type_t t_context = mir_context_type(mu, mir_get_parent(mu)); mir_add_param(mu, t_context, MIR_NULL_STAMP, ident_new("context")); mir_type_t t_conv = mir_conversion_type(mu); mir_value_t conv = mir_add_param(mu, t_conv, MIR_NULL_STAMP, ident_new("cf")); mir_type_t t_out = vlog_lower_vhdl_type(mu, rtype); ident_t func = tree_ident2(tree_ref(cf)); mir_value_t pkg = mir_build_link_package(mu, well_known(W_NVC_VERILOG)); mir_value_t count = MIR_NULL_VALUE; if (mir_is(mu, in, MIR_TYPE_UARRAY)) { count = mir_build_uarray_len(mu, in, 0); in = mir_build_unwrap(mu, in); } else if (type_is_array(rtype)) { int64_t length; if (!folded_length(range_of(tree_type(tree_value(cf)), 0), &length)) should_not_reach_here(); count = mir_const(mu, t_offset, length); } mir_value_t resolved = mir_build_resolved(mu, in); mir_value_t arg; if (!mir_is_null(count)) { mir_dim_t dims[] = { { .left = mir_const(mu, t_offset, 1), .right = count, .dir = mir_const(mu, mir_bool_type(mu), RANGE_TO), } }; arg = mir_build_wrap(mu, resolved, dims, 1); } else { arg = mir_build_load(mu, resolved); count = mir_const(mu, t_offset, 1); } mir_value_t args[] = { pkg, arg }; mir_value_t result = mir_build_fcall(mu, func, t_out, MIR_NULL_STAMP, args, ARRAY_LEN(args)); if (mir_is(mu, result, MIR_TYPE_UARRAY)) result = mir_build_unwrap(mu, result); if (mir_is(mu, out, MIR_TYPE_UARRAY)) out = mir_build_unwrap(mu, out); mir_build_put_conversion(mu, conv, out, count, result); mir_build_return(mu, mir_const(mu, t_offset, 0)); } static void vlog_lower_convert_in(mir_unit_t *mu, object_t *obj) { tree_t map = tree_from_object(obj); assert(tree_kind(map) == T_PARAM); tree_t cf = tree_value(map); assert(tree_kind(cf) == T_CONV_FUNC); mir_context_t *mc = mir_get_context(mu); ident_t parent1 = mir_get_parent(mu); mir_shape_t *shape1 = mir_get_shape(mc, parent1); ident_t parent2 = mir_get_shape_parent(shape1); mir_shape_t *shape2 = mir_get_shape(mc, parent2); tree_t arg = tree_value(cf); assert(tree_kind(arg) == T_REF); int nth = mir_find_slot(shape2, tree_ident(tree_ref(arg))); assert(nth >= 0); mir_value_t in_upref = mir_build_var_upref(mu, 2, nth); mir_value_t in_nets = mir_build_load(mu, in_upref); int hops; mir_value_t var = mir_search_object(mu, map, &hops); assert(!mir_is_null(var)); assert(hops == 1); mir_value_t out_upref = mir_build_var_upref(mu, hops, var.id); mir_value_t out_nets = mir_build_load(mu, out_upref); vlog_lower_converter(mu, cf, in_nets, out_nets); } static void vlog_lower_convert_out(mir_unit_t *mu, object_t *obj) { tree_t map = tree_from_object(obj); assert(tree_kind(map) == T_PARAM); tree_t cf = tree_name(map); assert(tree_kind(cf) == T_CONV_FUNC); mir_context_t *mc = mir_get_context(mu); ident_t parent1 = mir_get_parent(mu); mir_shape_t *shape1 = mir_get_shape(mc, parent1); ident_t parent2 = mir_get_shape_parent(shape1); mir_shape_t *shape2 = mir_get_shape(mc, parent2); int hops; mir_value_t var = mir_search_object(mu, map, &hops); assert(!mir_is_null(var)); assert(hops == 1); mir_value_t in_upref = mir_build_var_upref(mu, hops, var.id); mir_value_t in_nets = mir_build_load(mu, in_upref); tree_t dst = tree_value(map); assert(tree_kind(dst) == T_REF); int nth = mir_find_slot(shape2, tree_ident(tree_ref(dst))); assert(nth >= 0); mir_value_t out_upref = mir_build_var_upref(mu, 2, nth); mir_value_t out_nets = mir_build_load(mu, out_upref); vlog_lower_converter(mu, cf, in_nets, out_nets); } void vlog_lower_block(mir_context_t *mc, ident_t parent, tree_t b) { tree_t hier = tree_decl(b, 0); assert(tree_kind(hier) == T_HIER); mir_shape_t *shape = mir_get_shape(mc, parent); ident_t qual = tree_ident2(hier); mir_unit_t *mu = mir_unit_new(mc, qual, tree_to_object(b), MIR_UNIT_INSTANCE, shape); tree_t wrap = tree_ref(hier); assert(tree_kind(wrap) == T_VERILOG); vlog_node_t body = tree_vlog(wrap); assert(vlog_kind(body) == V_INST_BODY); hash_t *map = hash_new(16); const int vhdl_ndecls = tree_decls(b); const int vlog_ndecls = vlog_decls(body); for (int i = 1, pos = 0; i < vhdl_ndecls; i++) { tree_t t = tree_decl(b, i); ident_t id = tree_ident(t); for (; pos < vlog_ndecls; pos++) { vlog_node_t v = vlog_decl(body, pos); if (vlog_ident(v) == id) { hash_put(map, v, t); break; } } if (pos == vlog_ndecls) fatal_trace("missing VHDL signal for %s", istr(id)); } const int nports = vlog_ports(body); assert(tree_ports(b) == nports); assert(tree_params(b) == nports); for (int i = 0; i < nports; i++) hash_put(map, vlog_ref(vlog_ref(vlog_port(body, i))), tree_port(b, i)); ident_t pkg_name = well_known(W_NVC_VERILOG); mir_value_t pkg = mir_build_package_init(mu, pkg_name, MIR_NULL_VALUE); mir_type_t t_net_value = mir_int_type(mu, 0, 255); mir_type_t t_resolution = mir_resolution_type(mu, t_net_value); ident_t var_name = ident_new("NVC.VERILOG.T_WIRE$resolution"); mir_value_t resfn = mir_build_link_var(mu, pkg_name, pkg, var_name, t_resolution); vlog_gen_t g = { .mu = mu, }; for (int i = 0; i < vlog_ndecls; i++) { vlog_node_t d = vlog_decl(body, i); switch (vlog_kind(d)) { case V_PORT_DECL: break; // Translated below case V_NET_DECL: vlog_lower_net_decl(mu, d, hash_get(map, d), resfn); break; case V_VAR_DECL: vlog_lower_var_decl(&g, d, hash_get(map, d)); break; case V_LOCALPARAM: break; // Always inlined for now default: CANNOT_HANDLE(d); } } mir_value_t self = mir_build_context_upref(mu, 0); mir_type_t t_self = mir_context_type(mu, qual); mir_type_t t_offset = mir_offset_type(mu); for (int i = 0; i < nports; i++) { vlog_node_t ref = vlog_port(body, i); assert(vlog_kind(ref) == V_REF); vlog_node_t port = vlog_ref(ref); assert(vlog_kind(port) == V_PORT_DECL); int hops; mir_value_t var = mir_search_object(mu, vlog_ref(port), &hops); assert(!mir_is_null(var)); assert(hops == 0); mir_put_object(mu, port, var); mir_value_t count = mir_const(mu, t_offset, vlog_size(vlog_type(port))); tree_t map = tree_param(b, i); tree_t value = tree_value(map); mir_value_t in_conv = MIR_NULL_VALUE; if (tree_kind(value) == T_CONV_FUNC) { mir_put_object(mu, map, var); ident_t func = ident_sprintf("%s.%s$verilog_convert_in", istr(qual), istr(vlog_ident(port))); mir_defer(mc, func, qual, MIR_UNIT_FUNCTION, vlog_lower_convert_in, tree_to_object(map)); mir_value_t closure = mir_build_closure(mu, func, self, t_self, t_offset); in_conv = mir_build_port_conversion(mu, closure, closure); value = tree_value(value); } assert(tree_kind(value) == T_REF); int nth = mir_find_slot(shape, tree_ident(tree_ref(value))); assert(nth >= 0); mir_value_t upref = mir_build_var_upref(mu, 1, nth); mir_value_t dst_nets = mir_build_load(mu, upref); if (mir_is(mu, dst_nets, MIR_TYPE_UARRAY)) dst_nets = mir_build_unwrap(mu, dst_nets); mir_value_t out_conv = MIR_NULL_VALUE; if (tree_subkind(map) == P_NAMED) { tree_t name = tree_name(map); if (tree_kind(name) == T_CONV_FUNC) { mir_put_object(mu, map, var); ident_t func = ident_sprintf("%s.%s$verilog_convert_out", istr(qual), istr(vlog_ident(port))); mir_defer(mc, func, qual, MIR_UNIT_FUNCTION, vlog_lower_convert_out, tree_to_object(map)); mir_value_t closure = mir_build_closure(mu, func, self, t_self, t_offset); out_conv = mir_build_port_conversion(mu, closure, closure); } } mir_value_t src_nets = mir_build_load(mu, var); if (mir_is(mu, src_nets, MIR_TYPE_UARRAY)) src_nets = mir_build_unwrap(mu, src_nets); switch (vlog_subkind(port)) { case V_PORT_INPUT: if (mir_is_null(in_conv)) mir_build_map_signal(mu, dst_nets, src_nets, count); else { mir_build_convert_out(mu, in_conv, src_nets, count); mir_build_convert_in(mu, in_conv, dst_nets, count); } break; case V_PORT_OUTPUT: if (mir_is_null(out_conv)) mir_build_map_signal(mu, src_nets, dst_nets, count); else { mir_build_convert_out(mu, out_conv, dst_nets, count); mir_build_convert_in(mu, out_conv, src_nets, count); } break; default: CANNOT_HANDLE(port); } } mir_build_return(mu, MIR_NULL_VALUE); vlog_lower_cleanup(&g); hash_free(map); mir_optimise(mu, MIR_PASS_O1); mir_put_unit(mc, mu); } nvc-r1.17.1/src/vlog/vlog-node.c000066400000000000000000000401501504111170000163330ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "object.h" #include #include #include static const imask_t has_map[V_LAST_NODE_KIND] = { // V_MODULE (I_IDENT | I_PORTS | I_STMTS | I_DECLS | I_IDENT2), // V_PORT_DECL (I_IDENT | I_SUBKIND | I_IDENT2 | I_REF | I_RANGES | I_TYPE | I_VALUE), // V_REF (I_IDENT | I_REF), // V_ALWAYS (I_IDENT | I_SUBKIND | I_STMTS), // V_TIMING (I_VALUE | I_STMTS), // V_NBASSIGN (I_TARGET | I_VALUE | I_DELAY), // V_EVENT (I_SUBKIND | I_VALUE), // V_INITIAL (I_IDENT | I_STMTS), // V_BLOCK (I_IDENT | I_DECLS | I_STMTS), // V_SYS_TCALL (I_IDENT | I_PARAMS), // V_STRING (I_NUMBER), // V_NUMBER (I_NUMBER), // V_NET_DECL (I_IDENT | I_SUBKIND | I_TYPE | I_RANGES | I_VALUE), // V_ASSIGN (I_TARGET | I_VALUE | I_IDENT | I_DELAY), // V_DIMENSION (I_SUBKIND | I_LEFT | I_RIGHT), // V_IF (I_CONDS), // V_COND (I_VALUE | I_STMTS), // V_VAR_DECL (I_IDENT | I_TYPE | I_RANGES | I_VALUE), // V_DELAY_CONTROL (I_VALUE), // V_BINARY (I_LEFT | I_RIGHT | I_SUBKIND), // V_BASSIGN (I_TARGET | I_VALUE | I_SUBKIND | I_DELAY), // V_UNARY (I_VALUE | I_SUBKIND), // V_GATE_INST (I_SUBKIND | I_PARAMS | I_IDENT | I_REF | I_TARGET), // V_STRENGTH (I_SUBKIND), // V_MOD_INST (I_IDENT | I_PARAMS), // V_BIT_SELECT (I_VALUE | I_PARAMS), // V_SYS_FCALL (I_IDENT | I_PARAMS), // V_FOREVER (I_STMTS), // V_SPECIFY (I_DECLS), // V_PRIMITIVE (I_IDENT | I_IDENT2 | I_PORTS | I_DECLS | I_STMTS), // V_UDP_TABLE (I_IDENT | I_PARAMS | I_SUBKIND | I_STMTS), // V_UDP_ENTRY (I_PARAMS), // V_DATA_TYPE (I_SUBKIND | I_RANGES), // V_TYPE_DECL (I_IDENT | I_TYPE), // V_ENUM_DECL (I_IDENT | I_TYPE | I_RANGES | I_DECLS), // V_ENUM_NAME (I_IDENT | I_TYPE), // V_UNION_DECL (I_IDENT | I_DECLS), // V_STRUCT_DECL (I_IDENT | I_DECLS), // V_EVENT_CONTROL (I_PARAMS), // V_EMPTY (0), // V_REPEAT (I_VALUE | I_STMTS), // V_WHILE (I_VALUE | I_STMTS), // V_DO_WHILE (I_VALUE | I_STMTS), // V_TASK_DECL (I_IDENT | I_STMTS | I_DECLS | I_PORTS), // V_FUNC_DECL (I_IDENT | I_STMTS | I_DECLS | I_TYPE | I_PORTS), // V_WAIT (I_VALUE | I_STMTS), // V_PARAM_DECL (I_IDENT | I_VALUE | I_TYPE), // V_COND_EXPR (I_VALUE | I_LEFT | I_RIGHT), // V_REAL (I_DVAL), // V_CONCAT (I_PARAMS | I_VALUE), // V_FOR_LOOP (I_LEFT | I_VALUE | I_RIGHT | I_STMTS), // V_FOR_INIT (I_DECLS | I_STMTS), // V_FOR_STEP (I_STMTS), // V_PREFIX (I_TARGET | I_SUBKIND), // V_POSTFIX (I_TARGET | I_SUBKIND), // V_LOCALPARAM (I_IDENT | I_VALUE | I_TYPE), // V_CASE (I_SUBKIND | I_VALUE | I_STMTS), // V_CASE_ITEM (I_PARAMS | I_STMTS), // V_INST_LIST (I_PARAMS | I_STMTS | I_IDENT), // V_PARAM_ASSIGN (I_IDENT | I_VALUE), // V_INST_BODY (I_IDENT | I_IDENT2 | I_PORTS | I_STMTS | I_DECLS), // V_PORT_CONN (I_IDENT | I_VALUE), // V_PART_SELECT (I_SUBKIND | I_VALUE | I_LEFT | I_RIGHT), // V_IF_GENERATE (I_CONDS), // V_EVENT_TRIGGER (I_IDENT), // V_USER_FCALL (I_IDENT | I_REF | I_PARAMS), // V_UDP_LEVEL (I_SUBKIND | I_IVAL), // V_UDP_EDGE (I_SUBKIND | I_LEFT | I_RIGHT), // V_SPECPARAM (I_IDENT | I_VALUE), // V_FORK (I_IDENT | I_DECLS | I_STMTS), // V_ATTR_INST (0), // V_USER_TCALL (I_IDENT | I_REF | I_PARAMS), // V_VOID_CALL (I_VALUE), // V_GENVAR_DECL (I_IDENT), // V_FOR_GENERATE (I_LEFT | I_VALUE | I_RIGHT | I_STMTS), }; static const char *kind_text_map[V_LAST_NODE_KIND] = { "V_MODULE", "V_PORT_DECL", "V_REF", "V_ALWAYS", "V_TIMING", "V_NBASSIGN", "V_EVENT", "V_INITIAL", "V_BLOCK", "V_SYS_TCALL", "V_STRING", "V_NUMBER", "V_NET_DECL", "V_ASSIGN", "V_DIMENSION", "V_IF", "V_COND", "V_VAR_DECL", "V_DELAY_CONTROL", "V_BINARY", "V_BASSIGN", "V_UNARY", "V_GATE_INST", "V_STRENGTH", "V_MOD_INST", "V_BIT_SELECT", "V_SYS_FCALL", "V_FOREVER", "V_SPECIFY", "V_PRIMITIVE", "V_UDP_TABLE", "V_UDP_ENTRY", "V_DATA_TYPE", "V_TYPE_DECL", "V_ENUM_DECL", "V_ENUM_NAME", "V_UNION_DECL", "V_STRUCT_DECL", "V_EVENT_CONTROL", "V_EMPTY", "V_REPEAT", "V_WHILE", "V_DO_WHILE", "V_TASK_DECL", "V_FUNC_DECL", "V_WAIT", "V_PARAM_DECL", "V_COND_EXPR", "V_REAL", "V_CONCAT", "V_FOR_LOOP", "V_FOR_INIT", "V_FOR_STEP", "V_PREFIX", "V_POSTFIX", "V_LOCALPARAM", "V_CASE", "V_CASE_ITEM", "V_INST_LIST", "V_PARAM_ASSIGN", "V_INST_BODY", "V_PORT_CONN", "V_PART_SELECT", "V_IF_GENERATE", "V_EVENT_TRIGGER", "V_USER_FCALL", "V_UDP_LEVEL", "V_UDP_EDGE", "V_SPECPARAM", "V_FORK", "V_ATTR_INST", "V_USER_TCALL", "V_VOID_CALL", "V_GENVAR_DECL", "V_FOR_GENERATE", }; static const change_allowed_t change_allowed[] = { { -1, -1 } }; object_class_t vlog_object = { .name = "vlog", .change_allowed = change_allowed, .has_map = has_map, .kind_text_map = kind_text_map, .tag = OBJECT_TAG_VLOG, .last_kind = V_LAST_NODE_KIND, .has_loc = true, .gc_roots = { V_MODULE, V_PRIMITIVE }, .gc_num_roots = 2 }; struct _vlog_node { object_t object; }; static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n) { object_t *o = obj_array_nth(item->obj_array, n); return container_of(o, struct _vlog_node, object); } static inline void vlog_array_add(item_t *item, vlog_node_t v) { obj_array_add(&(item->obj_array), &(v->object)); } vlog_node_t vlog_new(vlog_kind_t kind) { object_t *o = object_new(NULL, &vlog_object, kind); return container_of(o, struct _vlog_node, object); } vlog_kind_t vlog_kind(vlog_node_t v) { return v->object.kind; } const char *vlog_kind_str(vlog_kind_t kind) { return kind_text_map[kind]; } ident_t vlog_ident(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_IDENT); assert(item->ident != NULL); return item->ident; } void vlog_set_ident(vlog_node_t v, ident_t i) { lookup_item(&vlog_object, v, I_IDENT)->ident = i; } bool vlog_has_ident(vlog_node_t v) { return lookup_item(&vlog_object, v, I_IDENT)->ident != NULL; } ident_t vlog_ident2(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_IDENT2); assert(item->ident != NULL); return item->ident; } void vlog_set_ident2(vlog_node_t v, ident_t i) { lookup_item(&vlog_object, v, I_IDENT2)->ident = i; } const loc_t *vlog_loc(vlog_node_t v) { assert(v != NULL); return &(v->object.loc); } void vlog_set_loc(vlog_node_t v, const loc_t *loc) { assert(v != NULL); assert(loc != NULL); v->object.loc = *loc; } vlog_node_t vlog_ref(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_REF); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } bool vlog_has_ref(vlog_node_t v) { return lookup_item(&vlog_object, v, I_REF)->object != NULL; } void vlog_set_ref(vlog_node_t v, vlog_node_t d) { lookup_item(&vlog_object, v, I_REF)->object = &(d->object); object_write_barrier(&(v->object), &(d->object)); } unsigned vlog_stmts(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_STMTS); return obj_array_count(item->obj_array); } vlog_node_t vlog_stmt(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_STMTS); return vlog_array_nth(item, n); } void vlog_add_stmt(vlog_node_t v, vlog_node_t s) { assert(s != NULL); vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s); object_write_barrier(&(v->object), &(s->object)); } unsigned vlog_ports(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_PORTS); return obj_array_count(item->obj_array); } vlog_node_t vlog_port(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_PORTS); return vlog_array_nth(item, n); } void vlog_add_port(vlog_node_t v, vlog_node_t p) { assert(p != NULL); assert(p->object.kind == V_REF || p->object.kind == V_PORT_DECL); vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p); object_write_barrier(&(v->object), &(p->object)); } unsigned vlog_params(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_PARAMS); return obj_array_count(item->obj_array); } vlog_node_t vlog_param(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_PARAMS); return vlog_array_nth(item, n); } void vlog_add_param(vlog_node_t v, vlog_node_t p) { assert(p != NULL); vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p); object_write_barrier(&(v->object), &(p->object)); } unsigned vlog_ranges(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_RANGES); return obj_array_count(item->obj_array); } vlog_node_t vlog_range(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_RANGES); return vlog_array_nth(item, n); } void vlog_add_range(vlog_node_t v, vlog_node_t r) { assert(r != NULL); assert(r->object.kind == V_DIMENSION); vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r); object_write_barrier(&(v->object), &(r->object)); } unsigned vlog_decls(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_DECLS); return obj_array_count(item->obj_array); } vlog_node_t vlog_decl(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_DECLS); return vlog_array_nth(item, n); } void vlog_add_decl(vlog_node_t v, vlog_node_t d) { assert(d != NULL); vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d); object_write_barrier(&(v->object), &(d->object)); } unsigned vlog_conds(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_CONDS); return obj_array_count(item->obj_array); } vlog_node_t vlog_cond(vlog_node_t v, unsigned n) { item_t *item = lookup_item(&vlog_object, v, I_CONDS); return vlog_array_nth(item, n); } void vlog_add_cond(vlog_node_t v, vlog_node_t c) { assert(c != NULL && c->object.kind == V_COND); vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c); object_write_barrier(&(v->object), &(c->object)); } unsigned vlog_subkind(vlog_node_t v) { return lookup_item(&vlog_object, v, I_SUBKIND)->ival; } void vlog_set_subkind(vlog_node_t v, unsigned sub) { lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub; } vlog_node_t vlog_value(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_VALUE); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } bool vlog_has_value(vlog_node_t v) { return lookup_item(&vlog_object, v, I_VALUE)->object != NULL; } void vlog_set_value(vlog_node_t v, vlog_node_t e) { lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object); object_write_barrier(&(v->object), &(e->object)); } vlog_node_t vlog_target(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_TARGET); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } void vlog_set_target(vlog_node_t v, vlog_node_t e) { lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object); object_write_barrier(&(v->object), &(e->object)); } vlog_node_t vlog_delay(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_DELAY); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } bool vlog_has_delay(vlog_node_t v) { return lookup_item(&vlog_object, v, I_DELAY)->object != NULL; } void vlog_set_delay(vlog_node_t v, vlog_node_t d) { lookup_item(&vlog_object, v, I_DELAY)->object = &(d->object); object_write_barrier(&(v->object), &(d->object)); } vlog_node_t vlog_type(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_TYPE); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } bool vlog_has_type(vlog_node_t v) { return lookup_item(&vlog_object, v, I_TYPE)->object != NULL; } void vlog_set_type(vlog_node_t v, vlog_node_t t) { lookup_item(&vlog_object, v, I_TYPE)->object = &(t->object); object_write_barrier(&(v->object), &(t->object)); } number_t vlog_number(vlog_node_t v) { return lookup_item(&vlog_object, v, I_NUMBER)->number; } void vlog_set_number(vlog_node_t v, number_t n) { lookup_item(&vlog_object, v, I_NUMBER)->number = n; } vlog_node_t vlog_left(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_LEFT); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } void vlog_set_left(vlog_node_t v, vlog_node_t e) { lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object); object_write_barrier(&(v->object), &(e->object)); } vlog_node_t vlog_right(vlog_node_t v) { item_t *item = lookup_item(&vlog_object, v, I_RIGHT); assert(item->object != NULL); return container_of(item->object, struct _vlog_node, object); } void vlog_set_right(vlog_node_t v, vlog_node_t e) { lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object); object_write_barrier(&(v->object), &(e->object)); } double vlog_dval(vlog_node_t v) { return lookup_item(&vlog_object, v, I_DVAL)->dval; } void vlog_set_dval(vlog_node_t v, double d) { lookup_item(&vlog_object, v, I_DVAL)->dval = d; } int64_t vlog_ival(vlog_node_t v) { return lookup_item(&vlog_object, v, I_IVAL)->ival; } void vlog_set_ival(vlog_node_t v, int64_t i) { lookup_item(&vlog_object, v, I_IVAL)->ival = i; } void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context) { vlog_visit_only(v, fn, context, V_LAST_NODE_KIND); } void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context, vlog_kind_t kind) { assert(v != NULL); object_visit_ctx_t ctx = { .count = 0, .postorder = (object_visit_fn_t)fn, .preorder = NULL, .context = context, .kind = kind, .tag = OBJECT_TAG_VLOG, .generation = object_next_generation(), .deep = false }; object_visit(&(v->object), &ctx); } vlog_node_t vlog_rewrite(vlog_node_t v, vlog_rewrite_fn_t fn, void *context) { object_arena_t *arena = object_arena(&(v->object)); if (arena_frozen(arena)) return v; object_rewrite_ctx_t ctx = { .generation = object_next_generation(), .context = context, .arena = arena, }; ctx.post_fn[OBJECT_TAG_VLOG] = (object_rewrite_post_fn_t)fn; object_t *result = object_rewrite(&(v->object), &ctx); free(ctx.cache); return container_of(result, struct _vlog_node, object); } vlog_node_t vlog_copy(vlog_node_t v, vlog_copy_pred_t pred, void *ctx) { object_copy_ctx_t *copy LOCAL = xcalloc_flex(sizeof(object_copy_ctx_t), 1, sizeof(object_t *)); copy->generation = object_next_generation(); copy->pred_context = ctx; copy->nroots = 1; copy->roots[0] = &(v->object); copy->should_copy[OBJECT_TAG_VLOG] = (object_copy_pred_t)pred; object_copy(copy); return container_of(copy->roots[0], struct _vlog_node, object); } object_t *vlog_to_object(vlog_node_t v) { return &(v->object); } vlog_node_t vlog_from_object(object_t *obj) { if (obj != NULL && obj->tag == OBJECT_TAG_VLOG) return container_of(obj, struct _vlog_node, object); else return NULL; } nvc-r1.17.1/src/vlog/vlog-node.h000066400000000000000000000170161504111170000163450ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_NODE_H #define _VLOG_NODE_H #include "prim.h" typedef enum { V_EVENT_LEVEL, V_EVENT_POSEDGE, V_EVENT_NEGEDGE, } v_event_kind_t; typedef enum { V_PORT_INPUT, V_PORT_OUTPUT, V_PORT_INOUT, } v_port_kind_t; typedef enum { V_NET_NONE, V_NET_WIRE, V_NET_UWIRE, V_NET_SUPPLY0, V_NET_SUPPLY1, V_NET_TRI, V_NET_TRIAND, V_NET_TRIOR, V_NET_TRIREG, V_NET_TRI0, V_NET_TRI1, V_NET_WAND, V_NET_WOR, } vlog_net_kind_t; typedef enum { V_UDP_COMB, V_UDP_SEQ, } vlog_udp_kind_t; typedef enum { V_ALWAYS_PLAIN, V_ALWAYS_FF, V_ALWAYS_COMB, V_ALWAYS_LATCH, } vlog_always_kind_t; typedef enum { V_CASE_NORMAL, V_CASE_X, V_CASE_Z, } vlog_case_kind_t; typedef enum { V_MODULE, V_PORT_DECL, V_REF, V_ALWAYS, V_TIMING, V_NBASSIGN, V_EVENT, V_INITIAL, V_BLOCK, V_SYS_TCALL, V_STRING, V_NUMBER, V_NET_DECL, V_ASSIGN, V_DIMENSION, V_IF, V_COND, V_VAR_DECL, V_DELAY_CONTROL, V_BINARY, V_BASSIGN, V_UNARY, V_GATE_INST, V_STRENGTH, V_MOD_INST, V_BIT_SELECT, V_SYS_FCALL, V_FOREVER, V_SPECIFY, V_PRIMITIVE, V_UDP_TABLE, V_UDP_ENTRY, V_DATA_TYPE, V_TYPE_DECL, V_ENUM_DECL, V_ENUM_NAME, V_UNION_DECL, V_STRUCT_DECL, V_EVENT_CONTROL, V_EMPTY, V_REPEAT, V_WHILE, V_DO_WHILE, V_TASK_DECL, V_FUNC_DECL, V_WAIT, V_PARAM_DECL, V_COND_EXPR, V_REAL, V_CONCAT, V_FOR_LOOP, V_FOR_INIT, V_FOR_STEP, V_PREFIX, V_POSTFIX, V_LOCALPARAM, V_CASE, V_CASE_ITEM, V_INST_LIST, V_PARAM_ASSIGN, V_INST_BODY, V_PORT_CONN, V_PART_SELECT, V_IF_GENERATE, V_EVENT_TRIGGER, V_USER_FCALL, V_UDP_LEVEL, V_UDP_EDGE, V_SPECPARAM, V_FORK, V_ATTR_INST, V_USER_TCALL, V_VOID_CALL, V_GENVAR_DECL, V_FOR_GENERATE, V_LAST_NODE_KIND } vlog_kind_t; typedef enum { DT_LOGIC, DT_INTEGER, DT_REAL, DT_STRUCT, DT_BYTE, DT_SHORTINT, DT_INT, DT_LONGINT, DT_TIME, DT_BIT, DT_SHORTREAL, DT_REALTIME, DT_EVENT, } data_type_t; typedef enum { V_DIM_PACKED, V_DIM_UNPACKED } vlog_dimension_kind_t; typedef enum { V_RANGE_CONST, V_RANGE_POS, V_RANGE_NEG, } vlog_range_kind_t; typedef enum { V_BINARY_OR, V_BINARY_AND, V_BINARY_PLUS, V_BINARY_MINUS, V_BINARY_TIMES, V_BINARY_DIVIDE, V_BINARY_MOD, V_BINARY_LOG_EQ, V_BINARY_LOG_NEQ, V_BINARY_CASE_EQ, V_BINARY_CASE_NEQ, V_BINARY_LOG_OR, V_BINARY_LOG_AND, V_BINARY_SHIFT_LL, V_BINARY_SHIFT_RL, V_BINARY_SHIFT_LA, V_BINARY_SHIFT_RA, V_BINARY_LT, V_BINARY_GT, V_BINARY_LEQ, V_BINARY_GEQ, V_BINARY_EXP, V_BINARY_XOR, V_BINARY_XNOR, } vlog_binary_t; typedef enum { V_UNARY_BITNEG, V_UNARY_NOT, V_UNARY_NEG, V_UNARY_IDENTITY, V_UNARY_AND, V_UNARY_OR, V_UNARY_XOR, } vlog_unary_t; typedef enum { V_INCDEC_PLUS, V_INCDEC_MINUS, } vlog_incdec_t; typedef enum { V_ASSIGN_EQUALS, } vlog_assign_t; typedef enum { V_GATE_PULLDOWN, V_GATE_PULLUP, V_GATE_AND, V_GATE_NAND, V_GATE_OR, V_GATE_NOR, V_GATE_XOR, V_GATE_XNOR, V_GATE_NOT, V_GATE_BUF, } vlog_gate_kind_t; typedef enum { V_STRENGTH_HIGHZ, V_STRENGTH_SMALL, V_STRENGTH_MEDIUM, V_STRENGTH_WEAK, V_STRENGTH_LARGE, V_STRENGTH_PULL, V_STRENGTH_STRONG, V_STRENGTH_SUPPLY, } vlog_strength_t; typedef enum { V_UDP_SYMBOL_OUTPUT, V_UDP_SYMBOL_INPUT, } vlog_udp_symbol_t; #define STRENGTH1(st) (((st) >> 5) & 7) #define STRENGTH0(st) (((st) >> 2) & 7) #define MAKE_STRENGTH(s0, s1) ((s1) << 5 | (s0) << 2) #define ST_SUPPLY MAKE_STRENGTH(V_STRENGTH_SUPPLY, V_STRENGTH_SUPPLY) #define ST_STRONG MAKE_STRENGTH(V_STRENGTH_STRONG, V_STRENGTH_STRONG) #define ST_PULLUP MAKE_STRENGTH(V_STRENGTH_PULL, V_STRENGTH_PULL) vlog_node_t vlog_new(vlog_kind_t kind); vlog_kind_t vlog_kind(vlog_node_t v); const char *vlog_kind_str(vlog_kind_t kind); void make_new_vlog_arena(void); const loc_t *vlog_loc(vlog_node_t v); void vlog_set_loc(vlog_node_t v, const loc_t *loc); ident_t vlog_ident(vlog_node_t v); void vlog_set_ident(vlog_node_t v, ident_t i); bool vlog_has_ident(vlog_node_t v); ident_t vlog_ident2(vlog_node_t v); void vlog_set_ident2(vlog_node_t v, ident_t i); vlog_node_t vlog_ref(vlog_node_t v); void vlog_set_ref(vlog_node_t v, vlog_node_t d); bool vlog_has_ref(vlog_node_t v); unsigned vlog_stmts(vlog_node_t v); vlog_node_t vlog_stmt(vlog_node_t v, unsigned n); void vlog_add_stmt(vlog_node_t v, vlog_node_t s); unsigned vlog_ports(vlog_node_t v); vlog_node_t vlog_port(vlog_node_t v, unsigned n); void vlog_add_port(vlog_node_t v, vlog_node_t p); unsigned vlog_params(vlog_node_t v); vlog_node_t vlog_param(vlog_node_t v, unsigned n); void vlog_add_param(vlog_node_t v, vlog_node_t p); unsigned vlog_ranges(vlog_node_t v); vlog_node_t vlog_range(vlog_node_t v, unsigned n); void vlog_add_range(vlog_node_t v, vlog_node_t r); unsigned vlog_decls(vlog_node_t v); vlog_node_t vlog_decl(vlog_node_t v, unsigned n); void vlog_add_decl(vlog_node_t v, vlog_node_t d); unsigned vlog_conds(vlog_node_t v); vlog_node_t vlog_cond(vlog_node_t v, unsigned n); void vlog_add_cond(vlog_node_t v, vlog_node_t c); unsigned vlog_subkind(vlog_node_t v); void vlog_set_subkind(vlog_node_t v, unsigned sub); vlog_node_t vlog_value(vlog_node_t v); bool vlog_has_value(vlog_node_t v); void vlog_set_value(vlog_node_t v, vlog_node_t e); vlog_node_t vlog_target(vlog_node_t v); void vlog_set_target(vlog_node_t v, vlog_node_t e); vlog_node_t vlog_delay(vlog_node_t v); bool vlog_has_delay(vlog_node_t v); void vlog_set_delay(vlog_node_t v, vlog_node_t d); vlog_node_t vlog_type(vlog_node_t v); bool vlog_has_type(vlog_node_t v); void vlog_set_type(vlog_node_t v, vlog_node_t t); vlog_node_t vlog_left(vlog_node_t v); void vlog_set_left(vlog_node_t v, vlog_node_t e); vlog_node_t vlog_right(vlog_node_t v); void vlog_set_right(vlog_node_t v, vlog_node_t e); const char *vlog_text(vlog_node_t v); void vlog_set_text(vlog_node_t v, const char *text); number_t vlog_number(vlog_node_t v); void vlog_set_number(vlog_node_t v, number_t n); double vlog_dval(vlog_node_t v); void vlog_set_dval(vlog_node_t v, double d); int64_t vlog_ival(vlog_node_t v); void vlog_set_ival(vlog_node_t v, int64_t i); typedef void (*vlog_visit_fn_t)(vlog_node_t v, void *context); void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context); void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context, vlog_kind_t kind); typedef vlog_node_t (*vlog_rewrite_fn_t)(vlog_node_t t, void *context); vlog_node_t vlog_rewrite(vlog_node_t v, vlog_rewrite_fn_t fn, void *context); typedef bool (*vlog_copy_pred_t)(vlog_node_t, void *); vlog_node_t vlog_copy(vlog_node_t v, vlog_copy_pred_t pred, void *ctx); object_t *vlog_to_object(vlog_node_t v); vlog_node_t vlog_from_object(object_t *obj); #endif // _VLOG_NODE_H nvc-r1.17.1/src/vlog/vlog-number.c000066400000000000000000000433341504111170000167050ustar00rootroot00000000000000// // Copyright (C) 2023-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "fbuf.h" #include "hash.h" #include "vlog/vlog-number.h" #include "thread.h" #include #include #include #include typedef enum { RADIX_STR = 0, RADIX_BIN = 2, RADIX_DEC = 10, RADIX_HEX = 16, } vlog_radix_t; typedef struct _bignum { unsigned width; bool issigned; uint64_t words[]; } bignum_t; #define BIGNUM_WORDS(w) (((w) + 63) / 64) #ifdef DEBUG #define SCRATCH_NUMBER number_t __attribute__((cleanup(_number_zap))) #else #define SCRATCH_NUMBER number_t #endif __attribute__((always_inline)) static inline int bignum_words(const bignum_t *bn) { return BIGNUM_WORDS(bn->width); } __attribute__((always_inline)) static inline uint64_t *bignum_abits(bignum_t *bn) { return bn->words; } __attribute__((always_inline)) static inline uint64_t *bignum_bbits(bignum_t *bn) { return bn->words + bignum_words(bn); } __attribute__((always_inline)) static inline int bignum_abit(bignum_t *bn, unsigned n) { assert(n < bn->width); return (bignum_abits(bn)[n / 64] >> (n % 64)) & 1; } __attribute__((always_inline)) static inline int bignum_bbit(bignum_t *bn, unsigned n) { assert(n < bn->width); return (bignum_bbits(bn)[n / 64] >> (n % 64)) & 1; } static inline void bignum_set_abit(bignum_t *bn, unsigned n, int b) { if (n < bn->width) bignum_abits(bn)[n / 64] |= (uint64_t)(b & 1) << (n % 64); } static inline void bignum_set_bbit(bignum_t *bn, unsigned n, int b) { if (n < bn->width) bignum_bbits(bn)[n / 64] |= (uint64_t)(b & 1) << (n % 64); } static inline void bignum_set_nibble(bignum_t *bn, unsigned n, int value) { for (int i = 0; i < 4; i++) bignum_set_abit(bn, n + i, value >> i); } static uint32_t bignum_hash(const void *p) { const bignum_t *bn = p; uint64_t hash = knuth_hash(bn->width) ^ bn->issigned; for (int i = 0; i < bignum_words(bn) * 2; i++) hash ^= mix_bits_64(bn->words[i]); return hash; } static bool bignum_cmp(const void *pa, const void *pb) { const bignum_t *a = pa, *b = pb; if (a->width != b->width || a->issigned != b->issigned) return false; for (int i = 0; i < bignum_words(a) * 2; i++) { if (a->words[i] != b->words[i]) return false; } return true; } static number_t number_intern(number_t n) { static mem_pool_t *pool = NULL; static ghash_t *hash = NULL; INIT_ONCE( pool = pool_new(); hash = ghash_new(32, bignum_hash, bignum_cmp); ); LOCAL_TEXT_BUF tb = tb_new(); number_print(n, tb); bignum_t *bn = ghash_get(hash, n.big); if (bn == NULL) { const int nwords = bignum_words(n.big) * 2; bn = pool_malloc_flex(pool, sizeof(bignum_t), nwords, sizeof(uint64_t)); bn->width = n.big->width; bn->issigned = n.big->issigned; for (int i = 0; i < nwords; i++) bn->words[i] = n.big->words[i]; ghash_put(hash, bn, bn); } return (number_t){ .big = bn }; } static number_t number_scratch(int width, bool issigned) { static __thread bignum_t *cache = NULL; static __thread int max_words = -1; const int nwords = MAX(1, BIGNUM_WORDS(width)); if (nwords > max_words) { cache = xrealloc_flex(cache, sizeof(bignum_t), nwords * 2, sizeof(uint64_t)); max_words = nwords; } ASAN_UNPOISON(cache, sizeof(bignum_t) + nwords * 2 * sizeof(uint64_t)); cache->width = width; cache->issigned = issigned; for (int i = 0; i < nwords * 2; i++) cache->words[i] = 0; return (number_t){ .big = cache }; } static number_t number_scratch_copy(number_t n) { number_t copy = number_scratch(n.big->width, n.big->issigned); memcpy(copy.big->words, n.big->words, bignum_words(n.big) * 2 * sizeof(uint64_t)); return copy; } #ifdef DEBUG static void _number_zap(number_t *p) { #if ASAN_ENABLED const int nwords = bignum_words(p->big); ASAN_POISON(p->big, sizeof(bignum_t) + nwords * 2 * sizeof(uint64_t)); #else p->big->width = 0; p->big->issigned = false; p->bits = 0; #endif } #endif number_t number_new(const char *str, const loc_t *loc) { int width = 32; const char *p = str; if (*p == '"') width = 8 * (strlen(str) - 2); else { const char *tick = strchr(str, '\''); if (tick == str) p++; else if (tick != NULL) { char *eptr; width = strtol(str, &eptr, 10); if (eptr != tick) should_not_reach_here(); p = tick + 1; } } SCRATCH_NUMBER result = number_scratch(width, false); vlog_radix_t radix = RADIX_DEC; switch (*p) { case 'b': radix = RADIX_BIN; p++; break; case 'h': radix = RADIX_HEX; p++; break; case 'd': radix = RADIX_DEC; p++; break; case '"': radix = RADIX_STR; p++; break; default: result.big->issigned = true; break; } if (radix == RADIX_STR) { for (int bit = width - 8; !(*p == '"' && *(p + 1) == '\0'); p++, bit -= 8) { const uint8_t byte = *p; bignum_set_nibble(result.big, bit, byte); bignum_set_nibble(result.big, bit + 4, byte >> 4); } } else if (radix == RADIX_DEC) { for (; *p; p++) { switch (*p) { case '0'...'9': { const uint64_t ten[] = { 10 }; const uint64_t digit[] = { *p - '0' }; vec2_mul(result.big->words, width, ten, 64); vec2_add(result.big->words, width, digit, 64); } break; case '_': continue; default: error_at(loc, "invalid character '%c' in number %s", *p, str); } } } else { const char *start = p; for (; *(p + 1); p++); for (int bit = 0; p >= start; p--) { switch (radix) { case RADIX_BIN: { switch (*p) { case '0': break; case '1': bignum_set_abit(result.big, bit, 1); break; case 'x': bignum_set_abit(result.big, bit, 1); bignum_set_bbit(result.big, bit, 1); break; case 'z': bignum_set_bbit(result.big, bit, 1); break; case '_': continue; default: error_at(loc, "invalid character '%c' in number %s", *p, str); } if (bit >= width) { warn_at(loc, "excess digits in binary constant %s", str); return number_intern(result); } bit++; } break; case RADIX_HEX: { switch (*p) { case 'x': for (int i = 0; i < 4; i++) { bignum_set_abit(result.big, bit + i, 1); bignum_set_bbit(result.big, bit + i, 1); } break; case 'z': for (int i = 0; i < 4; i++) bignum_set_bbit(result.big, bit + i, 1); break; case '0'...'9': bignum_set_nibble(result.big, bit, *p - '0'); break; case 'a'...'f': bignum_set_nibble(result.big, bit, 10 + *p - 'a'); break; case 'A'...'F': bignum_set_nibble(result.big, bit, 10 + *p - 'A'); break; case '_': continue; default: error_at(loc, "invalid character '%c' in number %s", *p, str); } if (bit >= width) { warn_at(loc, "excess digits in hex constant %s", str); return number_intern(result); } bit += 4; } break; default: should_not_reach_here(); } } } return number_intern(result); } void number_print(number_t val, text_buf_t *tb) { if (number_is_defined(val)) { if (val.big->width == 32 && val.big->issigned) { tb_printf(tb, "%"PRIi64, bignum_abits(val.big)[0]); return; } else if (val.big->width > 1 && val.big->width <= 32) { tb_printf(tb, "%u'%sd%"PRIu64, val.big->width, val.big->issigned ? "s" : "", bignum_abits(val.big)[0]); return; } } tb_printf(tb, "%u'b", number_width(val)); static const char map[] = "01zx"; bool leading = true; for (int i = val.big->width - 1; i >= 0; i--) { const vlog_logic_t bit = number_bit(val, i); if (leading && bit != LOGIC_0) leading = false; else if (leading) continue; tb_append(tb, map[bit]); } if (leading) tb_append(tb, '0'); } bool number_is_defined(number_t val) { const int nwords = bignum_words(val.big); const uint64_t *bbits = bignum_bbits(val.big); for (int i = 0; i < nwords; i++) { if (bbits[i] != 0) return false; } return true; } int64_t number_integer(number_t val) { assert(number_width(val) <= 64); assert(number_is_defined(val)); return bignum_abits(val.big)[0]; } unsigned number_width(number_t val) { return val.big->width; } vlog_logic_t number_bit(number_t val, unsigned n) { return bignum_abit(val.big, n) | (bignum_bbit(val.big, n) << 1); } uint8_t number_byte(number_t val, unsigned n) { assert(number_is_defined(val)); assert(n < bignum_words(val.big) * 8); const uint64_t *abits = bignum_abits(val.big); return (abits[n / 8] >> (n * 8) % 64) & 0xff; } // TODO: remove this number_t number_pack(const uint8_t *bits, unsigned width) { const int nwords = BIGNUM_WORDS(width); bignum_t *bn = xmalloc_flex(sizeof(bignum_t), nwords * 2, sizeof(uint64_t)); bn->width = width; bn->issigned = 0; for (int i = 0; i < nwords * 2; i++) bn->words[i] = 0; for (int i = 0; i < width; i++) { bignum_set_abit(bn, i, bits[width - 1 - i]); bignum_set_bbit(bn, i, bits[width - 1 - i] >> 1); } return (number_t){ .big = bn }; } bool number_equal(number_t a, number_t b) { if (a.big->width != b.big->width) return false; else if (a.big->issigned != b.big->issigned) return false; const int nwords = bignum_words(a.big); for (int i = 0; i < nwords; i++) { if (a.big->words[i] != b.big->words[i]) return false; } return true; } bool number_truthy(number_t a) { const int nwords = bignum_words(a.big); for (int i = 0; i < nwords; i++) { if (bignum_bbits(a.big)[i] != 0) return false; else if (bignum_abits(a.big)[i] != 0) return true; } return false; } bool number_signed(number_t a) { return a.big->issigned; } void number_write(number_t val, fbuf_t *f) { const int64_t width = val.big->width; // Widen fbuf_put_int(f, val.big->issigned ? -width : width); const int nwords = bignum_words(val.big); write_raw(val.big->words, nwords * 2 * sizeof(uint64_t), f); } number_t number_read(fbuf_t *f) { const int64_t enc = fbuf_get_int(f); const unsigned width = llabs(enc); const int nwords = BIGNUM_WORDS(width); SCRATCH_NUMBER result = number_scratch(width, enc < 0); read_raw(result.big->words, nwords * 2 * sizeof(uint64_t), f); return number_intern(result); } number_t number_add(number_t a, number_t b) { const int width = MAX(a.big->width, b.big->width) + 1; const bool issigned = a.big->issigned && b.big->issigned; SCRATCH_NUMBER result = number_scratch(width, issigned); assert(bignum_words(result.big) == 1); // TODO bignum_abits(result.big)[0] = bignum_abits(a.big)[0] + bignum_abits(b.big)[0]; bignum_bbits(result.big)[0] = bignum_bbits(a.big)[0] | bignum_bbits(b.big)[0]; return number_intern(result); } number_t number_sub(number_t a, number_t b) { const int width = MAX(a.big->width, b.big->width) + 1; const bool issigned = a.big->issigned && b.big->issigned; SCRATCH_NUMBER result = number_scratch(width, issigned); assert(bignum_words(result.big) == 1); // TODO bignum_abits(result.big)[0] = bignum_abits(a.big)[0] - bignum_abits(b.big)[0]; bignum_bbits(result.big)[0] = bignum_bbits(a.big)[0] | bignum_bbits(b.big)[0]; return number_intern(result); } number_t number_negate(number_t a) { SCRATCH_NUMBER result = number_scratch_copy(a); vec2_negate(result.big->words, result.big->width); return number_intern(result); } number_t number_logical_equal(number_t a, number_t b) { SCRATCH_NUMBER result = number_scratch(1, false); assert(bignum_words(a.big) == 1); // TODO assert(bignum_words(b.big) == 1); // TODO bignum_abits(result.big)[0] = bignum_abits(a.big)[0] == bignum_abits(b.big)[0]; bignum_bbits(result.big)[0] = bignum_bbits(a.big)[0] | bignum_bbits(b.big)[0]; return number_intern(result); } number_t number_greater(number_t a, number_t b) { SCRATCH_NUMBER result = number_scratch(1, false); if (number_is_defined(a) && number_is_defined(b)) { vlog_logic_t cmp; if (a.big->issigned && b.big->issigned) cmp = vec2_sgt(a.big->words, a.big->width, b.big->words, b.big->width); else cmp = vec2_gt(a.big->words, a.big->width, b.big->words, b.big->width); bignum_abits(result.big)[0] = (cmp == LOGIC_1); bignum_bbits(result.big)[0] = 0; } else bignum_abits(result.big)[0] = bignum_bbits(result.big)[0] = 1; return number_intern(result); } number_t number_greater_equal(number_t a, number_t b) { SCRATCH_NUMBER result = number_scratch(1, false); if (number_is_defined(a) && number_is_defined(b)) { vlog_logic_t cmp; if (a.big->issigned && b.big->issigned) cmp = vec2_sge(a.big->words, a.big->width, b.big->words, b.big->width); else cmp = vec2_ge(a.big->words, a.big->width, b.big->words, b.big->width); bignum_abits(result.big)[0] = (cmp == LOGIC_1); bignum_bbits(result.big)[0] = 0; } else bignum_abits(result.big)[0] = bignum_bbits(result.big)[0] = 1; return number_intern(result); } number_t number_less(number_t a, number_t b) { SCRATCH_NUMBER result = number_scratch(1, false); if (number_is_defined(a) && number_is_defined(b)) { vlog_logic_t cmp; if (a.big->issigned && b.big->issigned) cmp = vec2_slt(a.big->words, a.big->width, b.big->words, b.big->width); else cmp = vec2_lt(a.big->words, a.big->width, b.big->words, b.big->width); bignum_abits(result.big)[0] = (cmp == LOGIC_1); bignum_bbits(result.big)[0] = 0; } else bignum_abits(result.big)[0] = bignum_bbits(result.big)[0] = 1; return number_intern(result); } number_t number_less_equal(number_t a, number_t b) { SCRATCH_NUMBER result = number_scratch(1, false); if (number_is_defined(a) && number_is_defined(b)) { vlog_logic_t cmp; if (a.big->issigned && b.big->issigned) cmp = vec2_sle(a.big->words, a.big->width, b.big->words, b.big->width); else cmp = vec2_le(a.big->words, a.big->width, b.big->words, b.big->width); bignum_abits(result.big)[0] = (cmp == LOGIC_1); bignum_bbits(result.big)[0] = 0; } else bignum_abits(result.big)[0] = bignum_bbits(result.big)[0] = 1; return number_intern(result); } void vec2_add(uint64_t *a, size_t asize, const uint64_t *b, size_t bsize) { if (asize <= 64 && bsize <= 64) a[0] += b[0]; else should_not_reach_here(); // TODO } void vec2_mul(uint64_t *a, size_t asize, const uint64_t *b, size_t bsize) { if (asize <= 64 && bsize <= 64) a[0] *= b[0]; else should_not_reach_here(); // TODO } void vec2_negate(uint64_t *a, size_t asize) { if (asize <= 64) a[0] = -a[0]; else should_not_reach_here(); // TODO } #define VEC2_CMP_OP(name, op) \ vlog_logic_t vec2_##name(const uint64_t *a, size_t asize, \ const uint64_t *b, size_t bsize) \ { \ if (asize <= 64 && bsize <= 64) \ return a[0] op b[0] ? LOGIC_1 : LOGIC_0; \ else \ should_not_reach_here(); /* TODO */ \ } \ \ vlog_logic_t vec2_s##name(const uint64_t *a, size_t asize, \ const uint64_t *b, size_t bsize) \ { \ if (asize <= 64 && bsize <= 64) \ return (int64_t)a[0] op (int64_t)b[0] ? LOGIC_1 : LOGIC_0; \ else \ should_not_reach_here(); /* TODO */ \ } VEC2_CMP_OP(lt, <); VEC2_CMP_OP(gt, >); VEC2_CMP_OP(le, <=); VEC2_CMP_OP(ge, >=); nvc-r1.17.1/src/vlog/vlog-number.h000066400000000000000000000063151504111170000167100ustar00rootroot00000000000000// // Copyright (C) 2023-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_NUMBER_H #define _VLOG_NUMBER_H #include "prim.h" #include "util.h" #include typedef enum { LOGIC_0 = 0b00, LOGIC_1 = 0b01, LOGIC_X = 0b11, LOGIC_Z = 0b10, } vlog_logic_t; typedef struct _bignum bignum_t; typedef enum { TAG_BIGNUM = 0x0, } number_tag_t; // Packed representation of Verilog's four-state logic type typedef union _number { bignum_t *big; uint64_t bits; struct { uint64_t tag : 2; } common; } number_t; STATIC_ASSERT(sizeof(number_t) == 8); number_t number_new(const char *str, const loc_t *loc); void number_print(number_t val, text_buf_t *tb); bool number_is_defined(number_t val); int64_t number_integer(number_t val); unsigned number_width(number_t val); vlog_logic_t number_bit(number_t val, unsigned n); uint8_t number_byte(number_t val, unsigned n); number_t number_pack(const uint8_t *bits, unsigned width); bool number_equal(number_t a, number_t b); bool number_truthy(number_t a); bool number_signed(number_t a); void number_write(number_t val, fbuf_t *f); number_t number_read(fbuf_t *f); number_t number_add(number_t a, number_t b); number_t number_sub(number_t a, number_t b); number_t number_negate(number_t a); number_t number_logical_equal(number_t a, number_t b); number_t number_greater(number_t a, number_t b); number_t number_greater_equal(number_t a, number_t b); number_t number_less(number_t a, number_t b); number_t number_less_equal(number_t a, number_t b); void vec2_add(uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); void vec2_mul(uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); void vec2_negate(uint64_t *a, size_t asize); vlog_logic_t vec2_sgt(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_gt(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_slt(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_lt(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_sge(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_ge(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_sle(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); vlog_logic_t vec2_le(const uint64_t *a, size_t asize, const uint64_t *b, size_t bsize); #endif // _VLOG_NUMBER_H nvc-r1.17.1/src/vlog/vlog-parse.c000066400000000000000000004314461504111170000165340ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "ident.h" #include "lib.h" #include "object.h" #include "scan.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-symtab.h" #include "vlog/vlog-util.h" #include #include #include #include #define RECOVER_THRESH 5 #define TRACE_PARSE 0 #define TRACE_RECOVERY 0 #define TOKENQ_SIZE 8 typedef struct { token_t token; yylval_t lval; loc_t loc; } tokenq_t; typedef struct { loc_t start_loc; loc_t last_loc; const char *hint_str; int n_correct; tokenq_t tokenq[TOKENQ_SIZE]; int tokenq_head; int tokenq_tail; yylval_t last_lval; token_t opt_hist[8]; int nopt_hist; #if TRACE_PARSE int depth; #endif } parse_state_t; typedef struct { const char *old_hint; loc_t old_start_loc; } rule_state_t; static parse_state_t state; static vlog_kind_t param_kind; static vlog_net_kind_t implicit_kind; static vlog_symtab_t *symtab; static vlog_node_t last_attr; extern loc_t yylloc; #define scan(...) _scan(1, __VA_ARGS__, -1) #define expect(...) _expect(1, __VA_ARGS__, -1) #define one_of(...) _one_of(1, __VA_ARGS__, -1) #define not_at_token(...) ((peek() != tEOF) && !_scan(1, __VA_ARGS__, -1)) #define peek() peek_nth(1) #define parse_error(loc, ...) do { \ if (state.n_correct >= RECOVER_THRESH) \ error_at((loc), __VA_ARGS__); \ } while (0) #if TRACE_PARSE static void _push_state(const rule_state_t *s); #else #define _push_state(s) #endif #define EXTEND(s) \ __attribute__((cleanup(_pop_state), unused)) \ const rule_state_t _state = { state.hint_str, state.start_loc }; \ state.hint_str = s; \ _push_state(&_state); #define BEGIN_WITH_HEAD(s, t) \ EXTEND(s); \ state.start_loc = (t) ? *vlog_loc(t) : LOC_INVALID; \ #define BEGIN(s) BEGIN_WITH_HEAD(s, NULL) #define CURRENT_LOC _diff_loc(&state.start_loc, &state.last_loc) static vlog_node_t p_statement_or_null(void); static vlog_node_t p_expression(void); static vlog_node_t p_constant_expression(void); static vlog_node_t p_data_type(void); static void p_list_of_variable_decl_assignments(vlog_node_t parent, vlog_node_t datatype); static vlog_node_t p_variable_lvalue(void); static vlog_node_t p_select(ident_t id); static vlog_net_kind_t p_net_type(void); static void p_module_or_generate_item(vlog_node_t mod); static void p_block_item_declaration(vlog_node_t parent); static vlog_node_t p_attribute_instance(void); static vlog_node_t p_drive_strength(void); static vlog_strength_t p_strength0(void); static vlog_strength_t p_strength1(void); static inline void _pop_state(const rule_state_t *r) { #if TRACE_PARSE printf("%*s<-- %s\n", state.depth--, "", state.hint_str); #endif state.hint_str = r->old_hint; if (r->old_start_loc.first_line != LINE_INVALID) state.start_loc = r->old_start_loc; } #if TRACE_PARSE static inline void _push_state(const rule_state_t *r) { printf("%*s--> %s\n", state.depth++, "", state.hint_str); } #endif static token_t peek_nth(int n) { while (((state.tokenq_head - state.tokenq_tail) & (TOKENQ_SIZE - 1)) < n) { const token_t token = processed_yylex(); int next = (state.tokenq_head + 1) & (TOKENQ_SIZE - 1); assert(next != state.tokenq_tail); extern yylval_t yylval; state.tokenq[state.tokenq_head].token = token; state.tokenq[state.tokenq_head].lval = yylval; state.tokenq[state.tokenq_head].loc = yylloc; state.tokenq_head = next; } const int pos = (state.tokenq_tail + n - 1) & (TOKENQ_SIZE - 1); return state.tokenq[pos].token; } static void drop_token(void) { assert(state.tokenq_head != state.tokenq_tail); if (state.start_loc.first_line == LINE_INVALID) state.start_loc = state.tokenq[state.tokenq_tail].loc; state.last_lval = state.tokenq[state.tokenq_tail].lval; state.last_loc = state.tokenq[state.tokenq_tail].loc; state.tokenq_tail = (state.tokenq_tail + 1) & (TOKENQ_SIZE - 1); state.nopt_hist = 0; } static void drop_tokens_until(token_t tok) { token_t next = tEOF; do { free_token(tok, &state.last_lval); next = peek(); drop_token(); } while ((tok != next) && (next != tEOF)); #if TRACE_RECOVERY if (peek() != tEOF) fmt_loc(stdout, &(tokenq[tokenq_tail].loc)); #endif } static void _vexpect(va_list ap) { if (state.n_correct >= RECOVER_THRESH) { diag_t *d = diag_new(DIAG_ERROR, &(state.tokenq[state.tokenq_tail].loc)); diag_printf(d, "unexpected $yellow$%s$$ while parsing %s, expecting ", token_str(peek()), state.hint_str); bool first = true; for (int i = 0; i < state.nopt_hist; i++) { diag_printf(d, "%s$yellow$%s$$", i == 0 ? "one of " : ", ", token_str(state.opt_hist[i])); first = false; } int tok = va_arg(ap, int); while (tok != -1) { const int tmp = tok; tok = va_arg(ap, int); if (first && (tok != -1)) diag_printf(d, "one of "); else if (!first) diag_printf(d, (tok == -1) ? " or " : ", "); diag_printf(d, "$yellow$%s$$", token_str(tmp)); first = false; } diag_hint(d, &(state.tokenq[state.tokenq_tail].loc), "this token was unexpected"); diag_emit(d); } state.n_correct = 0; drop_token(); vlog_symtab_suppress(symtab); } static vlog_node_t peek_reference(void) { assert(peek() == tID); ident_t id = ident_new(state.tokenq[state.tokenq_tail].lval.str); return vlog_symtab_query(symtab, id); } static void _expect(int dummy, ...) { va_list ap; va_start(ap, dummy); _vexpect(ap); va_end(ap); } static bool consume(token_t tok) { const token_t got = peek(); if (tok != got) { expect(tok); return false; } else { state.n_correct++; drop_token(); return true; } } static bool optional(token_t tok) { if (peek() == tok) { consume(tok); return true; } else { if (state.nopt_hist < ARRAY_LEN(state.opt_hist)) state.opt_hist[state.nopt_hist++] = tok; return false; } } static bool _scan(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); return found; } static int _one_of(int dummy, ...) { va_list ap; va_start(ap, dummy); token_t p = peek(); bool found = false; while (!found) { const int tok = va_arg(ap, token_t); if (tok == -1) break; else if (p == tok) found = true; } va_end(ap); if (found) { consume(p); return p; } else { va_start(ap, dummy); _vexpect(ap); va_end(ap); return -1; } } static const loc_t *_diff_loc(const loc_t *start, const loc_t *end) { static loc_t result; result = get_loc(start->first_line, start->first_column, end->first_line + end->line_delta, end->first_column + end->column_delta, start->file_ref); return &result; } static void set_timescale(const char *unit_value, const char *unit_name, const char *prec_value, const char *prec_name, const loc_t *loc) { // See IEEE 1800-2017 section 22.7 for rules struct { const char *value; const char *name; int64_t parsed; } args[] = { { unit_value, unit_name }, { prec_value, prec_name }, }; for (int i = 0; i < ARRAY_LEN(args); i++) { static const struct { const char *name; int64_t value; } valid_units[] = { { "s", INT64_C(60000000000000) }, { "ms", 1000000000000 }, { "us", 1000000000 }, { "ns", 1000000 }, { "ps", 1000 }, { "fs", 1 }, }; bool name_valid = false; for (int j = 0; j < ARRAY_LEN(valid_units); j++) { if (strcmp(valid_units[j].name, args[i].name) == 0) { args[i].parsed = valid_units[j].value; name_valid = true; break; } } if (!name_valid) error_at(loc, "invalid time unit name '%s'", args[i].name); const int scale = atoi(args[i].value); if (scale != 1 && scale != 10 && scale != 100) { diag_t *d = diag_new(DIAG_ERROR, loc); diag_printf(d, "invalid order of magnitude in `timescale directive"); diag_hint(d, NULL, "the valid values are 1, 10, and 100"); diag_emit(d); } args[i].parsed *= scale; } // TODO: do something with parsed scale/precision } static void skip_over_attributes(void) { while (peek() == tATTRBEGIN) last_attr = p_attribute_instance(); } static void optional_attributes(void) { if (peek() == tATTRBEGIN) { // If the current token is (* and there is a saved attribute // instance from skip_over_attributes() then the attribute must // have been placed incorrectly as there were other tokens between // the last closing *) and this if (last_attr != NULL) parse_error(vlog_loc(last_attr), "attribute instance is not " "allowed here"); do { (void)p_attribute_instance(); } while (peek() == tATTRBEGIN); } last_attr = NULL; } static ident_t error_marker(void) { return well_known(W_ERROR); } static vlog_node_t dummy_expression(void) { vlog_node_t v = vlog_new(V_NUMBER); vlog_set_number(v, number_new("1'b0", NULL)); return v; } static vlog_node_t logic_type(void) { vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, DT_LOGIC); return v; } static ident_t p_identifier(void) { if (consume(tID)) { ident_t id = ident_new(state.last_lval.str); free(state.last_lval.str); return id; } else return error_marker(); } static void p_external_identifier(ident_t *id, ident_t *ext) { if (consume(tID)) { *id = ident_new(state.last_lval.str); for (char *p = state.last_lval.str; *p; p++) *p = toupper_iso88591(*p); *ext = ident_new(state.last_lval.str); free(state.last_lval.str); } else *id = *ext = error_marker(); } static ident_t p_system_tf_identifier(void) { if (consume(tSYSTASK)) { ident_t id = ident_new(state.last_lval.str); free(state.last_lval.str); return id; } else return error_marker(); } static void p_attr_spec(void) { // attr_name [ = constant_expression ] BEGIN("attribute specification"); (void)p_identifier(); if (optional(tEQ)) (void)p_constant_expression(); } static vlog_node_t p_attribute_instance(void) { // (* attr_spec { , attr_spec } *) BEGIN("attribute instance"); consume(tATTRBEGIN); vlog_node_t v = vlog_new(V_ATTR_INST); do { p_attr_spec(); } while (optional(tCOMMA)); consume(tATTREND); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_unsigned_number(void) { // decimal_digit { _ | decimal_digit } BEGIN("unsigned number"); consume(tUNSIGNED); vlog_node_t v = vlog_new(V_NUMBER); vlog_set_loc(v, CURRENT_LOC); vlog_set_number(v, number_new(state.last_lval.str, CURRENT_LOC)); free(state.last_lval.str); return v; } static vlog_node_t p_integral_number(void) { // decimal_number | octal_number | binary_number | hex_number BEGIN("integral number"); if (peek() == tUNSIGNED) return p_unsigned_number(); else { consume(tNUMBER); vlog_node_t v = vlog_new(V_NUMBER); vlog_set_loc(v, CURRENT_LOC); vlog_set_number(v, number_new(state.last_lval.str, CURRENT_LOC)); free(state.last_lval.str); return v; } } static vlog_node_t p_real_number(void) { // fixed_point_number // | unsigned_number [ . unsigned_number ] exp [ sign ] unsigned_number BEGIN("real number"); consume(tREAL); vlog_node_t v = vlog_new(V_REAL); vlog_set_dval(v, state.last_lval.real); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_number(void) { // integral_number | real_number BEGIN("number"); if (peek() == tREAL) return p_real_number(); else return p_integral_number(); } static vlog_node_t p_string_literal(void) { // " { Any_ASCII_Characters } " BEGIN("string literal"); consume(tSTRING); vlog_node_t v = vlog_new(V_STRING); vlog_set_loc(v, CURRENT_LOC); vlog_set_number(v, number_new(state.last_lval.str, CURRENT_LOC)); return v; } static vlog_node_t p_primary_literal(void) { // number | time_literal | unbased_unsized_literal | string_literal BEGIN("primary literal"); switch (peek()) { case tNUMBER: case tUNSIGNED: case tREAL: return p_number(); case tSTRING: return p_string_literal(); default: one_of(tNUMBER, tUNSIGNED, tREAL, tSTRING); return dummy_expression(); } } static vlog_node_t p_constant_select(ident_t id) { // [ { . member_identifier constant_bit_select } . member_identifier ] // constant_bit_select [ [ constant_part_select_range ] ] EXTEND("constant select"); // Checked for constant-ness later return p_select(id); } static vlog_node_t p_constant_expression(void) { // constant_primary | unary_operator { attribute_instance } constant_primary // | constant_expression binary_operator { attribute_instance } // constant_expression // | constant_expression ? { attribute_instance } // constant_expression : constant_expression BEGIN("constant expression"); // Checked for constant-ness later return p_expression(); } static void p_constant_range(vlog_node_t *left, vlog_node_t *right) { // constant_expression : constant_expression BEGIN("constant range"); *left = p_constant_expression(); consume(tCOLON); *right = p_constant_expression(); } static vlog_node_t p_constant_range_expression(void) { // constant_expression | constant_part_select_range BEGIN("constant range expression"); return p_constant_expression(); } static vlog_node_t p_constant_mintypmax_expression(void) { // constant_expression // | constant_expression : constant_expression : constant_expression return p_constant_expression(); } static vlog_node_t p_packed_dimension(void) { // [ constant_range ] | unsized_dimension BEGIN("packed dimension"); consume(tLSQUARE); vlog_node_t left, right; p_constant_range(&left, &right); consume(tRSQUARE); vlog_node_t v = vlog_new(V_DIMENSION); vlog_set_subkind(v, V_DIM_PACKED); vlog_set_left(v, left); vlog_set_right(v, right); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_unpacked_dimension(void) { // [ constant_range ] | [ constant_expression ] BEGIN("unpacked dimension"); consume(tLSQUARE); vlog_node_t left, right; p_constant_range(&left, &right); consume(tRSQUARE); vlog_node_t v = vlog_new(V_DIMENSION); vlog_set_subkind(v, V_DIM_UNPACKED); vlog_set_left(v, left); vlog_set_right(v, right); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_data_type_or_void(void) { // data_type | void BEGIN("data type or void"); if (optional(tVOID)) return NULL; else return p_data_type(); } static void p_struct_union_member(vlog_node_t v) { // { attribute_instance } [ random_qualifier ] data_type_or_void // list_of_variable_decl_assignments ; BEGIN("struct or union member"); optional_attributes(); vlog_node_t dt = p_data_type_or_void(); p_list_of_variable_decl_assignments(v, dt); consume(tSEMI); } static void p_enum_name_declaration(vlog_node_t parent) { // enum_identifier [ [ integral_number [ : integral_number ] ] ] // [ = constant_expression ] BEGIN("enum name declaration"); vlog_node_t v = vlog_new(V_ENUM_NAME); vlog_set_ident(v, p_identifier()); vlog_set_type(v, parent); vlog_add_decl(parent, v); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); } static vlog_node_t p_integer_atom_type(void) { // byte | shortint | int | longint | integer | time BEGIN("integer atom type"); data_type_t dt = DT_BYTE; switch (one_of(tBYTE, tSHORTINT, tSVINT, tLONGINT, tINTEGER, tTIME)) { case tBYTE: dt = DT_BYTE; break; case tSHORTINT: dt = DT_SHORTINT; break; case tSVINT: dt = DT_INT; break; case tLONGINT: dt = DT_LONGINT; break; case tINTEGER: dt = DT_INTEGER; break; case tTIME: dt = DT_TIME; break; } vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, dt); vlog_set_loc(v, &state.last_loc); return v; } static vlog_node_t p_integer_vector_type(void) { // bit | logic | reg BEGIN("integer vector type"); data_type_t dt = DT_LOGIC; switch (one_of(tBIT, tLOGIC, tREG)) { case tBIT: dt = DT_BIT; break; case tLOGIC: case tREG: dt = DT_LOGIC; break; } vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, dt); vlog_set_loc(v, &state.last_loc); return v; } static vlog_node_t p_non_integer_type(void) { // shortreal | real | realtime BEGIN("non-integer type"); data_type_t dt = DT_REAL; switch (one_of(tSVREAL, tSHORTREAL, tREALTIME)) { case tSVREAL: dt = DT_REAL; break; case tSHORTREAL: dt = DT_SHORTREAL; break; case tREALTIME: dt = DT_REALTIME; break; } vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, dt); vlog_set_loc(v, &state.last_loc); return v; } static vlog_node_t p_struct_union(void) { // struct | union [ tagged ] BEGIN("struct or union"); switch (one_of(tSTRUCT, tUNION)) { case tUNION: { vlog_node_t v = vlog_new(V_UNION_DECL); optional(tTAGGED); return v; } case tSTRUCT: default: return vlog_new(V_STRUCT_DECL); } } static vlog_node_t p_data_type(void) { // integer_vector_type [ signing ] { packed_dimension } // | integer_atom_type [ signing ] | non_integer_type // | struct_union [ packed [ signing ] ] // { struct_union_member { struct_union_member } } { packed_dimension } // | enum [ enum_base_type ] { enum_name_declaration // { , enum_name_declaration } } { packed_dimension } // | string | chandle // | virtual [ interface ] interface_identifier // [ parameter_value_assignment ] [ . modport_identifier ] // | [ class_scope | package_scope ] type_identifier { packed_dimension } // | class_type | event | ps_covergroup_identifier | type_reference BEGIN("data type"); switch (peek()) { case tBIT: case tLOGIC: case tREG: { vlog_node_t v = p_integer_vector_type(); while (peek() == tLSQUARE) vlog_add_range(v, p_packed_dimension()); return v; } case tBYTE: case tSHORTINT: case tSVINT: case tLONGINT: case tINTEGER: case tTIME: return p_integer_atom_type(); case tSVREAL: case tREALTIME: case tSHORTREAL: return p_non_integer_type(); case tSTRUCT: case tUNION: { vlog_node_t v = p_struct_union(); (void)optional(tPACKED); consume(tLBRACE); vlog_symtab_push(symtab, v); do { p_struct_union_member(v); } while (not_at_token(tRBRACE)); vlog_symtab_pop(symtab); consume(tRBRACE); if (peek() == tLSQUARE) vlog_add_range(v, p_packed_dimension()); vlog_set_loc(v, CURRENT_LOC); return v; } case tENUM: { consume(tENUM); vlog_node_t v = vlog_new(V_ENUM_DECL); consume(tLBRACE); do { p_enum_name_declaration(v); } while (optional(tCOMMA)); consume(tRBRACE); while (peek() == tLSQUARE) vlog_add_range(v, p_packed_dimension()); vlog_set_loc(v, CURRENT_LOC); return v; } case tEVENT: { consume(tEVENT); vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, DT_EVENT); vlog_set_loc(v, &state.last_loc); return v; } case tID: { ident_t id = p_identifier(); vlog_node_t dt = vlog_symtab_query(symtab, id); if (dt == NULL) should_not_reach_here(); // Guarded by peek_reference() call else if (!is_data_type(dt)) { diag_t *d = diag_new(DIAG_ERROR, &state.last_loc); diag_printf(d, "'%s' is not a data type", istr(id)); diag_hint(d, vlog_loc(dt), "'%s' declared here", istr(id)); diag_emit(d); return logic_type(); } else return dt; } default: one_of(tBIT, tLOGIC, tREG, tBYTE, tSHORTINT, tSVINT, tLONGINT, tINTEGER, tTIME, tSVREAL, tREALTIME, tSHORTREAL, tSTRUCT, tUNION, tENUM, tEVENT, tID); return logic_type(); } } static vlog_node_t p_implicit_data_type(void) { // [ signing ] { packed_dimension } BEGIN("implicit data type"); vlog_node_t v = vlog_new(V_DATA_TYPE); vlog_set_subkind(v, DT_LOGIC); while (peek() == tLSQUARE) vlog_add_range(v, p_packed_dimension()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_data_type_or_implicit(void) { // data_type | implicit_data_type BEGIN("data type or implicit"); switch (peek()) { case tID: if (peek_nth(2) == tID) return p_data_type(); else return p_implicit_data_type(); break; case tREG: case tSTRUCT: case tUNION: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tTIME: case tLOGIC: case tBIT: case tEVENT: return p_data_type(); default: return p_implicit_data_type(); } } static void p_net_port_type(vlog_net_kind_t *kind, vlog_node_t *dt) { // [ net_type ] data_type_or_implicit | net_type_identifier // | interconnect implicit_data_type BEGIN("net port type"); if (scan(tSUPPLY0, tSUPPLY1, tTRI, tTRIAND, tTRIOR, tTRIREG, tTRI0, tTRI1, tUWIRE, tWIRE, tWAND, tWOR)) *kind = p_net_type(); else *kind = V_NET_WIRE; *dt = p_data_type_or_implicit(); } static vlog_node_t p_var_data_type(void) { // data_type | var data_type_or_implicit BEGIN("var data type"); return p_data_type(); } static vlog_node_t p_variable_port_type(void) { // var_data_type BEGIN("variable port type"); return p_var_data_type(); } static void p_list_of_port_identifiers(vlog_node_t mod, v_port_kind_t kind, vlog_node_t datatype) { // port_identifier { unpacked_dimension } // { , port_identifier { unpacked_dimension } } BEGIN("list of port identifiers"); do { ident_t id, ext; p_external_identifier(&id, &ext); vlog_node_t v = vlog_new(V_PORT_DECL); vlog_set_subkind(v, kind); vlog_set_ident(v, id); vlog_set_ident2(v, ext); vlog_set_type(v, datatype); vlog_set_loc(v, &state.last_loc); vlog_add_decl(mod, v); vlog_symtab_put(symtab, v); vlog_node_t ref = vlog_new(V_REF); vlog_set_loc(ref, CURRENT_LOC); vlog_set_ident(ref, id); vlog_set_ref(ref, v); vlog_add_port(mod, ref); } while (optional(tCOMMA)); } static void p_list_of_variable_port_identifiers(vlog_node_t mod, v_port_kind_t kind, vlog_node_t datatype) { // port_identifier { variable_dimension } [ = constant_expression ] // { , port_identifier { variable_dimension } [ = constant_expression ] } BEGIN("list of variable port identifiers"); do { ident_t id, ext; p_external_identifier(&id, &ext); vlog_node_t v = vlog_new(V_PORT_DECL); vlog_set_subkind(v, kind); vlog_set_ident(v, id); vlog_set_ident2(v, ext); vlog_set_type(v, datatype); vlog_set_loc(v, &state.last_loc); vlog_add_decl(mod, v); vlog_symtab_put(symtab, v); vlog_node_t reg = vlog_new(V_VAR_DECL); vlog_set_loc(reg, vlog_loc(v)); vlog_set_ident(reg, id); vlog_set_type(reg, datatype); vlog_add_decl(mod, reg); vlog_symtab_put(symtab, reg); vlog_node_t ref = vlog_new(V_REF); vlog_set_loc(ref, CURRENT_LOC); vlog_set_ident(ref, id); vlog_set_ref(ref, v); vlog_add_port(mod, ref); } while (optional(tCOMMA)); } static void p_inout_declaration(vlog_node_t mod) { // inout net_port_type list_of_port_identifiers BEGIN("inout declaration"); consume(tINOUT); vlog_node_t dt; vlog_net_kind_t kind; p_net_port_type(&kind, &dt); p_list_of_port_identifiers(mod, V_PORT_INOUT, dt); } static void p_input_declaration(vlog_node_t mod) { // input net_port_type list_of_port_identifiers // | input variable_port_type list_of_variable_identifiers BEGIN("input declaration"); consume(tINPUT); vlog_node_t dt; vlog_net_kind_t kind; switch (peek()) { case tREG: dt = p_variable_port_type(); p_list_of_variable_port_identifiers(mod, V_PORT_INPUT, dt); break; default: p_net_port_type(&kind, &dt); p_list_of_port_identifiers(mod, V_PORT_INPUT, dt); break; } } static void p_output_declaration(vlog_node_t mod) { // output net_port_type list_of_port_identifiers // | output variable_port_type list_of_variable_port_identifiers BEGIN("output declaration"); consume(tOUTPUT); switch (peek()) { case tREG: { vlog_node_t dt = p_variable_port_type(); p_list_of_variable_port_identifiers(mod, V_PORT_OUTPUT, dt); } break; default: { vlog_node_t dt; vlog_net_kind_t kind; p_net_port_type(&kind, &dt); p_list_of_port_identifiers(mod, V_PORT_OUTPUT, dt); } break; } } static void p_port_declaration(vlog_node_t mod) { // { attribute_instance } inout_declaration // | { attribute_instance } input_declaration // | { attribute_instance } output_declaration // | { attribute_instance } ref_declaration // | { attribute_instance } interface_port_declaration BEGIN("port declaration"); switch (peek()) { case tINOUT: p_inout_declaration(mod); break; case tINPUT: p_input_declaration(mod); break; case tOUTPUT: p_output_declaration(mod); break; default: should_not_reach_here(); } } static vlog_node_t p_net_port_header(v_port_kind_t *dir, bool *isreg) { // [ port_direction ] net_port_type BEGIN("net port header"); if (optional(tINPUT)) { *dir = V_PORT_INPUT; *isreg = (peek() == tREG); } else if (optional(tINOUT)) { *dir = V_PORT_INOUT; *isreg = false; } else if (optional(tOUTPUT)) { *dir = V_PORT_OUTPUT; *isreg = (peek() == tREG); } vlog_net_kind_t kind; vlog_node_t dt; p_net_port_type(&kind, &dt); return dt; } static void p_part_select_range(vlog_node_t ps) { // constant_expression : constant_expression // | expression +: constant_expression // | expression -: constant_expression BEGIN("part select range"); vlog_range_kind_t kind = V_RANGE_CONST; switch (one_of(tCOLON, tINDEXPOS, tINDEXNEG)) { case tINDEXPOS: kind = V_RANGE_POS; break; case tINDEXNEG: kind = V_RANGE_NEG; break; } vlog_set_subkind(ps, kind); vlog_set_right(ps, p_constant_expression()); } static vlog_node_t p_select(ident_t id) { // [ { . member_identifier bit_select } . member_identifier ] // { [ expression ] } [ [ part_select_range ] ] EXTEND("select"); vlog_node_t prefix = vlog_new(V_REF); vlog_set_ident(prefix, id); vlog_set_loc(prefix, CURRENT_LOC); vlog_symtab_lookup(symtab, prefix); if (optional(tLSQUARE)) { do { vlog_node_t expr = p_expression(); if (scan(tCOLON, tINDEXPOS, tINDEXNEG)) { vlog_node_t ps = vlog_new(V_PART_SELECT); vlog_set_left(ps, expr); vlog_set_value(ps, prefix); p_part_select_range(ps); consume(tRSQUARE); vlog_set_loc(ps, CURRENT_LOC); return ps; } if (vlog_kind(prefix) == V_BIT_SELECT) vlog_add_param(prefix, expr); else { vlog_node_t bs = vlog_new(V_BIT_SELECT); vlog_set_loc(bs, CURRENT_LOC); vlog_set_value(bs, prefix); vlog_add_param(bs, expr); prefix = bs; } consume(tRSQUARE); } while (optional(tLSQUARE)); } return prefix; } static void p_list_of_arguments(vlog_node_t call) { // [ expression ] { , [ expression ] } { , . identifier ( [ expression ] ) } // | . identifier ( [ expression ] ) { , . identifier ( [ expression ] ) } BEGIN("list of arguments"); if (peek() != tRPAREN) do { if (peek() == tCOMMA) { vlog_node_t v = vlog_new(V_EMPTY); vlog_set_loc(v, &state.last_loc); vlog_add_param(call, v); } else vlog_add_param(call, p_expression()); } while (optional(tCOMMA)); } static vlog_node_t p_system_tf_call(vlog_kind_t kind) { // system_tf_identifier [ ( list_of_arguments ) ] BEGIN("system task or function call"); vlog_node_t v = vlog_new(kind); vlog_set_ident(v, p_system_tf_identifier()); if (optional(tLPAREN)) { p_list_of_arguments(v); consume(tRPAREN); } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_tf_call(vlog_kind_t kind) { // ps_or_hierarchical_tf_identifier { attribute_instance } // [ ( list_of_arguments ) ] BEGIN("task or function call"); vlog_node_t v = vlog_new(kind); vlog_set_ident(v, p_identifier()); if (optional(tLPAREN)) { p_list_of_arguments(v); consume(tRPAREN); } vlog_set_loc(v, CURRENT_LOC); vlog_symtab_lookup(symtab, v); return v; } static vlog_node_t p_subroutine_call(vlog_kind_t kind) { // tf_call | system_tf_call | method_call | [ std:: ] randomize_call BEGIN("subroutine call"); if (peek() == tSYSTASK) return p_system_tf_call(kind); else return p_tf_call(kind); } static vlog_node_t p_mintypmax_expression(void) { // expression | expression : expression : expression BEGIN("mintypmax expression"); return p_expression(); } static vlog_node_t p_concatenation(vlog_node_t head) { // { expression { , expression } } BEGIN_WITH_HEAD("concatenation", head); if (head == NULL) { consume(tLBRACE); head = p_expression(); } vlog_node_t v = vlog_new(V_CONCAT); vlog_add_param(v, head); while (optional(tCOMMA)) vlog_add_param(v, p_expression()); consume(tRBRACE); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_multiple_concatenation(vlog_node_t head) { // { expression concatenation } BEGIN_WITH_HEAD("multiple concatenation", head); vlog_node_t v = p_concatenation(NULL); vlog_set_value(v, head); consume(tRBRACE); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_primary(void) { // primary_literal | empty_queue // | [ class_qualifier | package_scope ] hierarchical_identifier select // | concatenation [ [ range_expression ] ] // | multiple_concatenation [ [ range_expression ] ] // | function_subroutine_call // | let_expression | ( mintypmax_expression ) | cast // | assignment_pattern_expression | streaming_concatenation // | sequence_method_call | this | $ | null BEGIN("primary"); switch (peek()) { case tID: if (peek_nth(2) == tLPAREN) return p_subroutine_call(V_USER_FCALL); else return p_select(p_identifier()); case tSTRING: case tNUMBER: case tUNSIGNED: case tREAL: return p_primary_literal(); case tSYSTASK: return p_subroutine_call(V_SYS_FCALL); case tLPAREN: { consume(tLPAREN); vlog_node_t expr = p_mintypmax_expression(); consume(tRPAREN); return expr; } case tLBRACE: { consume(tLBRACE); vlog_node_t head = p_expression(); if (peek() == tLBRACE) return p_multiple_concatenation(head); else return p_concatenation(head); } default: one_of(tID, tSTRING, tNUMBER, tUNSIGNED, tREAL, tSYSTASK, tLPAREN, tLBRACE); return p_select(error_marker()); } } static vlog_binary_t p_binary_operator(void) { // + | - | * | / | % | == | != | === | !== | ==? | !=? | && | || // | ** | < | <= | > | >= | & | | | ^ | ^~ | ~^ | >> | << // | >>> | <<< | -> | <-> BEGIN("binary operator"); switch (one_of(tBAR, tPLUS, tAMP, tCASEEQ, tCASENEQ, tLOGOR, tLOGEQ, tLOGNEQ, tDBLAMP, tSHIFTLL, tSHIFTRL, tSHIFTLA, tSHIFTRA, tLT, tGT, tLE, tGE, tMINUS, tTIMES, tOVER, tPERCENT, tPOWER, tCARET, tTILDECARET)) { case tBAR: return V_BINARY_OR; case tAMP: return V_BINARY_AND; case tCASEEQ: return V_BINARY_CASE_EQ; case tCASENEQ: return V_BINARY_CASE_NEQ; case tLOGEQ: return V_BINARY_LOG_EQ; case tLOGNEQ: return V_BINARY_LOG_NEQ; case tLOGOR: return V_BINARY_LOG_OR; case tDBLAMP: return V_BINARY_LOG_AND; case tSHIFTLL: return V_BINARY_SHIFT_LL; case tSHIFTRL: return V_BINARY_SHIFT_RL; case tSHIFTLA: return V_BINARY_SHIFT_LA; case tSHIFTRA: return V_BINARY_SHIFT_RA; case tLT: return V_BINARY_LT; case tGT: return V_BINARY_GT; case tLE: return V_BINARY_LEQ; case tGE: return V_BINARY_GEQ; case tMINUS: return V_BINARY_MINUS; case tTIMES: return V_BINARY_TIMES; case tOVER: return V_BINARY_DIVIDE; case tPERCENT: return V_BINARY_MOD; case tPOWER: return V_BINARY_EXP; case tCARET: return V_BINARY_XOR; case tTILDECARET: return V_BINARY_XNOR; case tPLUS: default: return V_BINARY_PLUS; } } static vlog_unary_t p_unary_operator(void) { // + | - | ! | ~ | & | ~& | | | ~| | ^ | ~^ | ^~ BEGIN("unary operator"); switch (one_of(tMINUS, tPLUS, tTILDE, tBANG, tAMP, tBAR, tCARET)) { case tMINUS: return V_UNARY_NEG; case tTILDE: return V_UNARY_BITNEG; case tBANG: return V_UNARY_NOT; case tAMP: return V_UNARY_AND; case tBAR: return V_UNARY_OR; case tCARET: return V_UNARY_XOR; case tPLUS: default: return V_UNARY_IDENTITY; } } static vlog_incdec_t p_inc_or_dec_operator(void) { // ++ | -- BEGIN("inc or dec operator"); switch (one_of(tPLUSPLUS, tMINUSMINUS)) { case tMINUSMINUS: return V_INCDEC_MINUS; case tPLUSPLUS: default: return V_INCDEC_PLUS; } } static vlog_node_t p_inc_or_dec_expression(vlog_node_t head) { // inc_or_dec_operator { attribute_instance } variable_lvalue // | variable_lvalue { attribute_instance } inc_or_dec_operator BEGIN_WITH_HEAD("inc or dec expression", head); vlog_node_t v = vlog_new(head ? V_POSTFIX : V_PREFIX); vlog_set_subkind(v, p_inc_or_dec_operator()); vlog_set_target(v, head ?: p_variable_lvalue()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_nonbinary_expression(void) { // primary | unary_operator { attribute_instance } primary // | inc_or_dec_expression | ( operator_assignment ) // | conditional_expression | inside_expression | tagged_union_expression switch (peek()) { case tID: case tSTRING: case tNUMBER: case tUNSIGNED: case tREAL: case tSYSTASK: case tLPAREN: case tLBRACE: return p_primary(); case tMINUS: case tPLUS: case tTILDE: case tBANG: case tAMP: case tBAR: case tCARET: { vlog_node_t v = vlog_new(V_UNARY); vlog_set_subkind(v, p_unary_operator()); vlog_set_value(v, p_primary()); vlog_set_loc(v, CURRENT_LOC); return v; } case tPLUSPLUS: case tMINUSMINUS: return p_inc_or_dec_expression(NULL); default: one_of(tID, tSTRING, tNUMBER, tUNSIGNED, tREAL, tSYSTASK, tLPAREN, tLBRACE, tMINUS, tTILDE, tBANG, tAMP, tBAR, tCARET, tPLUSPLUS, tMINUSMINUS); return p_select(error_marker()); } } static vlog_node_t p_conditional_expression(vlog_node_t head) { // cond_predicate ? { attribute_instance } expression : expression BEGIN_WITH_HEAD("conditional expression", head); vlog_node_t v = vlog_new(V_COND_EXPR); vlog_set_value(v, head); consume(tQUESTION); optional_attributes(); vlog_set_left(v, p_expression()); consume(tCOLON); vlog_set_right(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static bool peek_binary_operator(int *prec) { // See LRM 1800-2017 section 11.3.2 for operator precedence table switch (peek()) { case tPOWER: *prec = 12; return true; case tTIMES: case tOVER: case tPERCENT: *prec = 11; return true; case tPLUS: case tMINUS: *prec = 10; return true; case tSHIFTLL: case tSHIFTRL: case tSHIFTLA: case tSHIFTRA: *prec = 9; return true; case tLT: case tGT: case tLE: case tGE: *prec = 8; return true; case tCASEEQ: case tCASENEQ: case tLOGEQ: case tLOGNEQ: *prec = 7; return true; case tAMP: *prec = 6; return true; case tTILDECARET: case tCARET: *prec = 5; return true; case tBAR: *prec = 4; return true; case tDBLAMP: *prec = 3; return true; case tLOGOR: *prec = 2; return true; case tQUESTION: *prec = 1; return true; default: return false; } } static vlog_node_t p_binary_expression(vlog_node_t lhs, int min_prec) { // Precedence climbing method, see // https://en.wikipedia.org/wiki/Operator-precedence_parser int prec1; while (peek_binary_operator(&prec1) && prec1 >= min_prec) { if (peek() == tQUESTION) lhs = p_conditional_expression(lhs); else { vlog_node_t v = vlog_new(V_BINARY); vlog_set_subkind(v, p_binary_operator()); vlog_set_left(v, lhs); vlog_node_t rhs = p_nonbinary_expression(); int prec2; while (peek_binary_operator(&prec2) && prec2 > prec1) rhs = p_binary_expression(rhs, prec1 + (prec2 > prec1)); vlog_set_right(v, rhs); vlog_set_loc(v, CURRENT_LOC); lhs = v; } } return lhs; } static vlog_node_t p_expression(void) { // primary | unary_operator { attribute_instance } primary // | inc_or_dec_expression | ( operator_assignment ) // | expression binary_operator { attribute_instance } expression // | conditional_expression | inside_expression | tagged_union_expression BEGIN("expression"); vlog_node_t head = p_nonbinary_expression(); return p_binary_expression(head, 0); } static void p_event_expression(vlog_node_t ctrl) { // [ edge_identifier ] expression [ iff expression ] // | sequence_instance [ iff expression ] // | event_expression or event_expression // | event_expression , event_expression // | ( event_expression ) BEGIN("event expression"); do { if (optional(tLPAREN)) { p_event_expression(ctrl); consume(tRPAREN); } else { vlog_node_t v = vlog_new(V_EVENT); if (optional(tPOSEDGE)) vlog_set_subkind(v, V_EVENT_POSEDGE); else if (optional(tNEGEDGE)) vlog_set_subkind(v, V_EVENT_NEGEDGE); else vlog_set_subkind(v, V_EVENT_LEVEL); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); vlog_add_param(ctrl, v); } } while (optional(tOR) || optional(tCOMMA)); } static vlog_node_t p_cond_predicate(void) { // expression_or_cond_pattern { &&& expression_or_cond_pattern } BEGIN("cond predicate"); return p_expression(); } static vlog_node_t p_event_control(void) { // @ hierarchical_event_identifier | @ ( event_expression ) // | @* | @ (*) | @ ps_or_hierarchical_sequence_identifier BEGIN("event control"); consume(tAT); vlog_node_t v = vlog_new(V_EVENT_CONTROL); switch (one_of(tLPAREN, tTIMES, tPARENSTAR)) { case tLPAREN: p_event_expression(v); consume(tRPAREN); break; case tTIMES: case tPARENSTAR: break; } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_delay_value(void) { // unsigned_number | real_number | ps_identifier | time_literal | 1step BEGIN("delay value"); return p_unsigned_number(); } static vlog_node_t p_delay_control(void) { // # delay_value | # ( mintypmax_expression ) BEGIN("delay control"); consume(tHASH); vlog_node_t v = vlog_new(V_DELAY_CONTROL); if (peek() != tLPAREN) vlog_set_value(v, p_delay_value()); else vlog_set_value(v, p_mintypmax_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_delay3(void) { // # delay_value | # ( mintypmax_expression [ , mintypmax_expression // [ , mintypmax_expression ] ] ) BEGIN("delay3"); consume(tHASH); if (peek() != tLPAREN) p_delay_value(); else { consume(tLPAREN); int expr_cnt = 0; do { (void)p_mintypmax_expression(); expr_cnt++; } while (optional(tCOMMA) && (expr_cnt < 3)); consume(tRPAREN); } } static vlog_node_t p_delay_or_event_control(void) { // delay_control | event_control | repeat ( expression ) event_control BEGIN("delay or event control"); return p_delay_control(); } static vlog_node_t p_variable_lvalue(void) { // [ implicit_class_handle . | package_scope ] // hierarchical_variable_identifier select // | { variable_lvalue { , variable_lvalue } } // | [ assignment_pattern_expression_type ] // assignment_pattern_variable_lvalue // | streaming_concatenation BEGIN("variable lvalue"); ident_t id = p_identifier(); vlog_node_t v = p_select(id); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_net_lvalue(void) { // ps_or_hierarchical_net_identifier constant_select // | { net_lvalue { , net_lvalue } } // | [ assignment_pattern_expression_type ] assignment_pattern_net_lvalue BEGIN("net lvalue"); if (optional(tLBRACE)) { vlog_node_t v = vlog_new(V_CONCAT); do { vlog_add_param(v, p_net_lvalue()); } while (optional(tCOMMA)); consume(tRBRACE); vlog_set_loc(v, CURRENT_LOC); return v; } else { ident_t id = p_identifier(); vlog_node_t v = p_constant_select(id); vlog_set_loc(v, CURRENT_LOC); return v; } } static vlog_node_t p_operator_assignment(vlog_node_t lhs) { // variable_lvalue assignment_operator expression BEGIN_WITH_HEAD("operator assignment", lhs); consume(tEQ); vlog_node_t v = vlog_new(V_BASSIGN); vlog_set_target(v, lhs); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_blocking_assignment(vlog_node_t lhs) { // variable_lvalue = delay_or_event_control expression // | nonrange_variable_lvalue = dynamic_array_new // | [ implicit_class_handle . | class_scope | package_scope ] // hierarchical_variable_identifier select != class_new // | operator_assignment BEGIN_WITH_HEAD("blocking assignment", lhs); switch (peek_nth(2)) { case tHASH: case tAT: { consume(tEQ); vlog_node_t v = vlog_new(V_BASSIGN); vlog_set_target(v, lhs); vlog_set_delay(v, p_delay_or_event_control()); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } default: return p_operator_assignment(lhs); } } static vlog_node_t p_nonblocking_assignment(vlog_node_t lhs) { // variable_lvalue <= [ delay_or_event_control ] expression BEGIN_WITH_HEAD("non-blocking assignment", lhs); consume(tLE); vlog_node_t v = vlog_new(V_NBASSIGN); vlog_set_target(v, lhs); if (scan(tHASH, tAT)) vlog_set_delay(v, p_delay_or_event_control()); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_procedural_timing_control(void) { // delay_control | event_control | cycle_delay BEGIN("procedural timing control"); switch (peek()) { case tAT: return p_event_control(); case tHASH: return p_delay_control(); default: should_not_reach_here(); } } static vlog_node_t p_procedural_timing_control_statement(void) { // procedural_timing_control statement_or_null BEGIN("procedural timing control statement"); vlog_node_t v = vlog_new(V_TIMING); vlog_set_value(v, p_procedural_timing_control()); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_seq_block(void) { // begin [ : block_identifier ] { block_item_declaration } // { statement_or_null } end [ : block_identifier ] BEGIN("sequential block"); consume(tBEGIN); vlog_node_t v = vlog_new(V_BLOCK); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_push(symtab, v); if (optional(tCOLON)) vlog_set_ident(v, p_identifier()); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC)) { p_block_item_declaration(v); skip_over_attributes(); } while (not_at_token(tEND)) { vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); } vlog_symtab_pop(symtab); consume(tEND); if (optional(tCOLON)) { ident_t name = p_identifier(); if (!vlog_has_ident(v)) parse_error(&state.last_loc, "initial block does not have a label"); else if (name != vlog_ident(v)) parse_error(&state.last_loc, "'%s' does not match label '%s'", istr(name), istr(vlog_ident(v))); } return v; } static vlog_node_t p_par_block(void) { // fork [ : block_identifier ] { block_item_declaration } // { statement_or_null } join_keyword [ : block_identifier ] BEGIN("parallel block"); consume(tFORK); vlog_node_t v = vlog_new(V_FORK); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_push(symtab, v); if (optional(tCOLON)) vlog_set_ident(v, p_identifier()); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC)) { p_block_item_declaration(v); skip_over_attributes(); } while (not_at_token(tJOIN)) { vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); } vlog_symtab_pop(symtab); consume(tJOIN); if (optional(tCOLON)) { ident_t name = p_identifier(); if (!vlog_has_ident(v)) parse_error(&state.last_loc, "fork block does not have a label"); else if (name != vlog_ident(v)) parse_error(&state.last_loc, "'%s' does not match label '%s'", istr(name), istr(vlog_ident(v))); } return v; } static vlog_node_t p_subroutine_call_statement(void) { // subroutine_call ; | void ' ( function_subroutine_call ) ; BEGIN("subroutine call statement"); vlog_node_t v; switch (peek()) { case tSYSTASK: v = p_subroutine_call(V_SYS_TCALL); break; case tVOID: { consume(tVOID); consume(tTICK); consume(tLPAREN); const vlog_kind_t kind = peek() == tSYSTASK ? V_SYS_FCALL : V_USER_FCALL; v = vlog_new(V_VOID_CALL); vlog_set_value(v, p_subroutine_call(kind)); consume(tRPAREN); } break; case tID: default: v = p_subroutine_call(V_USER_TCALL); break; } consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_conditional_statement(void) { // [ unique_priority ] if ( cond_predicate ) statement_or_null // { else if ( cond_predicate ) statement_or_null } // [ else statement_or_null ] BEGIN("conditional statement"); vlog_node_t v = vlog_new(V_IF); consume(tIF); consume(tLPAREN); vlog_node_t c0 = vlog_new(V_COND); vlog_set_value(c0, p_cond_predicate()); vlog_add_cond(v, c0); consume(tRPAREN); vlog_node_t s0 = p_statement_or_null(); if (s0 != NULL) vlog_add_stmt(c0, s0); bool stop = false; while (!stop && optional(tELSE)) { vlog_node_t c = vlog_new(V_COND); vlog_add_cond(v, c); if (optional(tIF)) { consume(tLPAREN); vlog_set_value(c, p_cond_predicate()); consume(tRPAREN); } else stop = true; vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(c, s); } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_variable_assignment(vlog_kind_t kind) { // variable_lvalue = expression BEGIN("variable assignment"); vlog_node_t v = vlog_new(kind); vlog_set_target(v, p_variable_lvalue()); consume(tEQ); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_list_of_variable_assignments(vlog_node_t parent) { // variable_assignment { , variable_assignment } BEGIN("list of variable assignments"); do { vlog_node_t v = p_variable_assignment(V_BASSIGN); vlog_add_stmt(parent, v); } while (optional(tCOMMA)); } static void p_for_variable_declaration(vlog_node_t parent) { // [ var ] data_type variable_identifier = expression // { , variable_identifier = expression } BEGIN("for variable declaration"); optional(tVAR); vlog_node_t dt = p_data_type(); do { vlog_node_t v = vlog_new(V_VAR_DECL); vlog_set_ident(v, p_identifier()); vlog_set_type(v, dt); consume(tEQ); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); vlog_add_decl(parent, v); vlog_symtab_put(symtab, v); } while (optional(tCOMMA)); } static vlog_node_t p_for_initialization(void) { // list_of_variable_assignments // | for_variable_declaration { , for_variable_declaration } BEGIN("for initialization"); vlog_node_t v = vlog_new(V_FOR_INIT); if (scan(tREG, tSTRUCT, tUNION, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tLOGIC, tVAR)) { do { p_for_variable_declaration(v); } while (optional(tCOMMA)); } else p_list_of_variable_assignments(v); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_for_step(void) { // operator_assignment | inc_or_dec_expression | function_subroutine_call BEGIN("for step"); vlog_node_t v = vlog_new(V_FOR_STEP); switch (peek()) { case tPLUSPLUS: case tMINUSMINUS: vlog_add_stmt(v, p_inc_or_dec_expression(NULL)); break; default: { vlog_node_t head = p_variable_lvalue(); switch (peek()) { case tPLUSPLUS: case tMINUSMINUS: vlog_add_stmt(v, p_inc_or_dec_expression(head)); break; default: vlog_add_stmt(v, p_operator_assignment(head)); break; } } break; } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_loop_statement(void) { // forever statement_or_null // | repeat ( expression ) statement_or_null // | while ( expression ) statement_or_null // | for ( [ for_initialization ] ; [ expression ] ; [ for_step ] ) // statement_or_null // | do statement_or_null while ( expression ) ; // | foreach ( ps_or_hierarchical_array_identifier [ loop_variables ] ) // statement BEGIN("loop statement"); switch (one_of(tFOREVER, tWHILE, tREPEAT, tDO, tFOR)) { case tFOREVER: { vlog_node_t v = vlog_new(V_FOREVER); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } case tWHILE: { vlog_node_t v = vlog_new(V_WHILE); consume(tLPAREN); vlog_set_value(v, p_expression()); consume(tRPAREN); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } case tREPEAT: { vlog_node_t v = vlog_new(V_REPEAT); consume(tLPAREN); vlog_set_value(v, p_expression()); consume(tRPAREN); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } case tDO: { vlog_node_t v = vlog_new(V_DO_WHILE); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); consume(tWHILE); consume(tLPAREN); vlog_set_value(v, p_expression()); consume(tRPAREN); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } case tFOR: { vlog_node_t v = vlog_new(V_FOR_LOOP); vlog_symtab_push(symtab, v); consume(tLPAREN); if (not_at_token(tSEMI)) vlog_set_left(v, p_for_initialization()); else vlog_set_left(v, vlog_new(V_FOR_INIT)); consume(tSEMI); if (not_at_token(tSEMI)) vlog_set_value(v, p_expression()); consume(tSEMI); if (not_at_token(tRPAREN)) vlog_set_right(v, p_for_step()); else vlog_set_right(v, vlog_new(V_FOR_STEP)); consume(tRPAREN); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_symtab_pop(symtab); vlog_set_loc(v, CURRENT_LOC); return v; } default: should_not_reach_here(); } } static vlog_node_t p_wait_statement(void) { // wait ( expression ) statement_or_null // | wait fork ; // | wait_order ( hierarchical_identifier { , hierarchical_identifier } ) // action_block BEGIN("wait statement"); consume(tWAIT); vlog_node_t v = vlog_new(V_WAIT); consume(tLPAREN); vlog_set_value(v, p_expression()); consume(tRPAREN); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_case_item(void) { // case_item_expression { , case_item_expression } : statement_or_null // | default [ : ] statement_or_null BEGIN("case item"); vlog_node_t v = vlog_new(V_CASE_ITEM); if (optional(tDEFAULT)) optional(tCOLON); else { do { vlog_add_param(v, p_expression()); } while (optional(tCOMMA)); consume(tCOLON); } vlog_set_loc(v, CURRENT_LOC); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); return v; } static vlog_node_t p_case_statement(void) { // [ unique_priority ] case_keyword ( case_expression ) // case_item { case_item } endcase // | [ unique_priority ] case_keyword ( case_expression ) matches // case_pattern_item { case_pattern_item } endcase // | [ unique_priority ] case ( case_expression ) inside case_inside_item // { case_inside_item } endcase BEGIN("case statement"); vlog_case_kind_t kind = V_CASE_NORMAL; switch (one_of(tCASE, tCASEX, tCASEZ)) { case tCASEX: kind = V_CASE_X; break; case tCASEZ: kind = V_CASE_Z; break; } vlog_node_t v = vlog_new(V_CASE); vlog_set_subkind(v, kind); consume(tLPAREN); vlog_set_value(v, p_expression()); consume(tRPAREN); do { vlog_add_stmt(v, p_case_item()); } while (not_at_token(tENDCASE)); consume(tENDCASE); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_event_trigger(void) { // -> hierarchical_event_identifier ; // | ->> [ delay_or_event_control ] hierarchical_event_identifier ; BEGIN("event trigger"); consume(tIFIMPL); vlog_node_t v = vlog_new(V_EVENT_TRIGGER); vlog_set_ident(v, p_identifier()); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_statement_item(void) { // blocking_assignment ; | nonblocking_assignment ; // | procedural_continuous_assignment ; | case_statement // | conditional_statement | inc_or_dec_expression ; // | subroutine_call_statement | disable_statement // | event_trigger | loop_statement | jump_statement // | par_block | procedural_timing_control_statement // | seq_block | wait_statement | procedural_assertion_statement // | clocking_drive ; | randsequence_statement | randcase_statement // | expect_property_statement BEGIN("statement item"); switch (peek()) { case tID: if (peek_nth(2) == tLPAREN) return p_subroutine_call_statement(); else { vlog_node_t lhs = p_variable_lvalue(), v = NULL; if (peek() == tLE) v = p_nonblocking_assignment(lhs); else v = p_blocking_assignment(lhs); consume(tSEMI); return v; } case tAT: case tHASH: return p_procedural_timing_control_statement(); case tBEGIN: return p_seq_block(); case tFORK: return p_par_block(); case tSYSTASK: case tVOID: return p_subroutine_call_statement(); case tIF: return p_conditional_statement(); case tFOREVER: case tWHILE: case tREPEAT: case tDO: case tFOR: return p_loop_statement(); case tWAIT: return p_wait_statement(); case tCASE: case tCASEX: case tCASEZ: return p_case_statement(); case tIFIMPL: return p_event_trigger(); default: one_of(tID, tAT, tHASH, tBEGIN, tFORK, tSYSTASK, tVOID, tIF, tFOREVER, tWHILE, tREPEAT, tDO, tFOR, tWAIT, tCASE, tCASEX, tCASEZ, tIFIMPL); drop_tokens_until(tSEMI); return vlog_new(V_BLOCK); // Dummy statement } } static vlog_node_t p_statement(void) { // [ block_identifier : ] { attribute_instance } statement_item BEGIN("statement"); if (peek() == tID && peek_nth(2) == tCOLON) { (void)p_identifier(); consume(tCOLON); } optional_attributes(); return p_statement_item(); } static vlog_node_t p_statement_or_null(void) { // statement | { attribute_instance } ; BEGIN("statement or null"); if (optional(tSEMI)) return NULL; else return p_statement(); } static vlog_node_t p_always_construct(void) { // always_keyword statement BEGIN("always construct"); vlog_node_t v = vlog_new(V_ALWAYS); switch (one_of(tALWAYS, tALWAYSCOMB, tALWAYSFF, tALWAYSLATCH)) { case tALWAYSCOMB: vlog_set_subkind(v, V_ALWAYS_COMB); break; case tALWAYSFF: vlog_set_subkind(v, V_ALWAYS_FF); break; case tALWAYSLATCH: vlog_set_subkind(v, V_ALWAYS_LATCH); break; default: vlog_set_subkind(v, V_ALWAYS_PLAIN); break; } vlog_set_ident(v, ident_uniq("__always#line%d", yylloc.first_line)); vlog_add_stmt(v, p_statement()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_initial_construct(void) { // initial statement_or_null BEGIN("initial construct"); consume(tINITIAL); vlog_node_t v = vlog_new(V_INITIAL); vlog_set_ident(v, ident_uniq("__initial#line%d", yylloc.first_line)); vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(v, s); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_net_assignment(void) { // net_lvalue = expression BEGIN("net assignment"); vlog_symtab_set_implicit(symtab, implicit_kind); vlog_node_t v = vlog_new(V_ASSIGN); vlog_set_target(v, p_net_lvalue()); vlog_set_ident(v, ident_uniq("__assign#line%d", state.last_loc.first_line)); vlog_symtab_set_implicit(symtab, V_NET_NONE); consume(tEQ); vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_list_of_net_assignments(vlog_node_t mod) { // net_assignment { , net_assignment } BEGIN("list of net assignments"); do { vlog_add_stmt(mod, p_net_assignment()); } while (optional(tCOMMA)); } static void p_continuous_assign(vlog_node_t mod) { // assign [ drive_strength ] [ delay3 ] list_of_net_assignments ; // | assign [ delay_control ] list_of_variable_assignments ; BEGIN("continuous assignment"); consume(tASSIGN); if (peek() == tLPAREN) { p_drive_strength(); if (peek() == tHASH) p_delay3(); } else { if (peek() == tHASH) p_delay_control(); } p_list_of_net_assignments(mod); consume(tSEMI); } static vlog_net_kind_t p_net_type(void) { // supply0 | supply1 | tri | triand | trior | trireg | tri0 // | tri1 | uwire | wire | wand | wor BEGIN("net type"); switch (one_of(tWIRE, tUWIRE, tSUPPLY0, tSUPPLY1, tTRI, tTRIAND, tTRIOR, tTRIREG, tTRI0, tTRI1, tWAND, tWOR)) { case tSUPPLY0: return V_NET_SUPPLY0; case tSUPPLY1: return V_NET_SUPPLY1; case tTRI: return V_NET_TRI; case tTRIAND: return V_NET_TRIAND; case tTRIOR: return V_NET_TRIOR; case tTRIREG: return V_NET_TRIREG; case tTRI0: return V_NET_TRI0; case tTRI1: return V_NET_TRI1; case tUWIRE: return V_NET_UWIRE; case tWAND: return V_NET_WAND; case tWOR: return V_NET_WOR; case tWIRE: default: return V_NET_WIRE; } } static vlog_node_t p_net_decl_assignment(vlog_net_kind_t kind, vlog_node_t datatype) { // net_identifier { unpacked_dimension } [ = expression ] BEGIN("net declaration assignment"); vlog_node_t v = vlog_new(V_NET_DECL); vlog_set_subkind(v, kind); vlog_set_type(v, datatype); vlog_set_ident(v, p_identifier()); while (peek() == tLSQUARE) vlog_add_range(v, p_unpacked_dimension()); if (optional(tEQ)) vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); return v; } static void p_list_of_net_decl_assignments(vlog_node_t mod, vlog_net_kind_t kind, vlog_node_t datatype) { // net_decl_assignment { , net_decl_assignment } BEGIN("list of net declaration assignments"); do { vlog_node_t v = p_net_decl_assignment(kind, datatype); vlog_add_decl(mod, v); } while (optional(tCOMMA)); } static vlog_node_t p_drive_strength(void) { //( strength0 , strength1 ) | ( strength1 , strength0 ) //| ( strength0 , highz1 ) | ( strength1 , highz0 ) //| ( highz0 , strength1 ) | ( highz1 , strength0 ) BEGIN("drive strength"); consume(tLPAREN); vlog_strength_t s0, s1; switch (peek()) { case tSUPPLY0: case tSTRONG0: case tPULL0: case tWEAK0: { s0 = p_strength0(); consume(tCOMMA); if (optional(tHIGHZ1)) s1 = V_STRENGTH_HIGHZ; else s1 = p_strength1(); } break; case tHIGHZ0: { s0 = V_STRENGTH_HIGHZ; consume(tHIGHZ0); consume(tCOMMA); s1 = p_strength1(); } break; case tSUPPLY1: case tSTRONG1: case tPULL1: case tWEAK1: { s1 = p_strength1(); consume(tCOMMA); if (optional(tHIGHZ0)) s0 = V_STRENGTH_HIGHZ; else s0 = p_strength0(); } break; case tHIGHZ1: { s1 = V_STRENGTH_HIGHZ; consume(tHIGHZ1); consume(tCOMMA); s0 = p_strength0(); } break; default: should_not_reach_here(); } consume(tRPAREN); vlog_node_t v = vlog_new(V_STRENGTH); vlog_set_subkind(v, MAKE_STRENGTH(s0, s1)); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_strength_t p_charge_strength(void) { // ( small ) | ( medium ) | ( large ) BEGIN("drive charge"); consume(tLPAREN); vlog_strength_t s; switch (one_of(tSMALL, tMEDIUM, tLARGE)) { default: case tSMALL: s = V_STRENGTH_SMALL; case tMEDIUM: s = V_STRENGTH_MEDIUM; case tLARGE: s = V_STRENGTH_LARGE; } consume(tRPAREN); return s; } static void p_net_declaration(vlog_node_t mod) { // net_type [ drive_strength | charge_strength ] [ vectored | scalared ] // data_type_or_implicit [ delay3 ] list_of_net_decl_assignments ; // | net_type_identifier [ delay_control ] list_of_net_decl_assignments ; // | interconnect implicit_data_type [ # delay_value ] net_identifier // { unpacked_dimension } [ , net_identifier { unpacked_dimension } ] ; BEGIN("net declaration"); ident_t id; vlog_node_t dt; vlog_net_kind_t kind = V_NET_WIRE; switch (peek()) { case tINTERCONNECT: { consume(tINTERCONNECT); dt = p_implicit_data_type(); if (optional(tHASH)) p_delay_value(); do { id = p_identifier(); if (peek() == tLSQUARE) p_unpacked_dimension(); } while (optional(tCOMMA)); } break; case tID: { id = p_identifier(); dt = vlog_symtab_query(symtab, id); if (dt == NULL) should_not_reach_here(); // TODO check that the identifier is actually // a user declared nettype if (peek() == tHASH) p_delay_control(); p_list_of_net_decl_assignments(mod, kind, dt); } break; default: { kind = p_net_type(); if (peek() == tLPAREN) { switch (peek_nth(2)) { case tHIGHZ0: case tHIGHZ1: case tSUPPLY0: case tSUPPLY1: case tSTRONG0: case tSTRONG1: case tPULL0: case tPULL1: case tWEAK0: case tWEAK1: p_drive_strength(); break; case tSMALL: case tMEDIUM: case tLARGE: if (kind != V_NET_TRIREG) parse_error(&state.last_loc, "charge strength only allowed " "with the trireg keyword"); p_charge_strength(); break; default: one_of(tHIGHZ0, tHIGHZ1, tSUPPLY0, tSUPPLY1, tSTRONG0, tSTRONG1, tPULL0, tPULL1, tWEAK0, tWEAK1, tSMALL, tMEDIUM, tLARGE); drop_tokens_until(tSEMI); return; } } bool need_packed = false; if (optional(tVECTORED) || optional(tSCALARED)) need_packed = true; dt = p_data_type_or_implicit(); if (need_packed) { bool has_packed = false; unsigned ranges = vlog_ranges(dt); for (unsigned i = 0; i < ranges; i++) { vlog_node_t r = vlog_range(dt, i); if (vlog_subkind(r) == V_DIM_PACKED) has_packed |= true; } if (!has_packed) parse_error(&state.last_loc, "vectored and scalared keywords " "are only allowed with at least a packed dimension"); } if (peek() == tHASH) p_delay3(); p_list_of_net_decl_assignments(mod, kind, dt); } } consume(tSEMI); } static vlog_node_t p_variable_dimension(void) { // unsized_dimension | unpacked_dimension | associative_dimension // | queue_dimension BEGIN("variable dimension"); return p_unpacked_dimension(); } static vlog_node_t p_variable_decl_assignment(vlog_node_t datatype) { // variable_identifier { variable_dimension } [ = expression ] // | dynamic_array_variable_identifier unsized_dimension // { variable_dimension } [ = dynamic_array_new ] // | class_variable_identifier [ = class_new ] BEGIN("variable declaration assignment"); vlog_node_t v = vlog_new(V_VAR_DECL); vlog_set_ident(v, p_identifier()); vlog_set_type(v, datatype); while (peek() == tLSQUARE) vlog_add_range(v, p_variable_dimension()); if (optional(tEQ)) vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); return v; } static void p_list_of_variable_decl_assignments(vlog_node_t parent, vlog_node_t datatype) { // variable_decl_assignment { , variable_decl_assignment } BEGIN("list of variable declaration assignments"); do { vlog_add_decl(parent, p_variable_decl_assignment(datatype)); } while (optional(tCOMMA)); } static vlog_node_t p_type_declaration(void) { // typedef data_type type_identifier { variable_dimension } ; // | typedef interface_instance_identifier constant_bit_select . // type_identifier type_identifier ; // | typedef [ enum | struct | union | class | interface class ] // type_identifier ; BEGIN("type declaration"); consume(tTYPEDEF); vlog_node_t v = vlog_new(V_TYPE_DECL); vlog_set_type(v, p_data_type()); vlog_set_ident(v, p_identifier()); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); return v; } static void p_data_declaration(vlog_node_t mod) { // [ const ] [ var ] [ lifetime ] data_type_or_implicit // list_of_variable_decl_assignments ; // | type_declaration | package_import_declaration | net_type_declaration BEGIN("data declaration"); switch (peek()) { case tTYPEDEF: vlog_add_decl(mod, p_type_declaration()); break; default: { vlog_node_t dt = p_data_type_or_implicit(); p_list_of_variable_decl_assignments(mod, dt); consume(tSEMI); } } } static v_port_kind_t p_port_direction(void) { // input | output | inout | ref BEGIN("port direction"); switch (one_of(tINPUT, tOUTPUT, tINOUT)) { case tINPUT: return V_PORT_INPUT; case tOUTPUT: return V_PORT_OUTPUT; case tINOUT: return V_PORT_INOUT; default: return V_PORT_INPUT; } } static v_port_kind_t p_tf_port_direction(void) { // port_direction | const ref BEGIN("task or function port direction"); return p_port_direction(); } static vlog_node_t p_tf_port_item(void) { // { attribute_instance } [ tf_port_direction ] [ var ] // data_type_or_implicit [ port_identifier { variable_dimension } // [ = expression ] ] BEGIN("task or function port item"); vlog_node_t v = vlog_new(V_PORT_DECL); skip_over_attributes(); if (scan(tINPUT, tOUTPUT, tINOUT)) vlog_set_subkind(v, p_tf_port_direction()); else vlog_set_subkind(v, V_PORT_INPUT); vlog_set_type(v, p_data_type_or_implicit()); if (peek() == tID) { vlog_set_ident(v, p_identifier()); if (optional(tEQ)) vlog_set_value(v, p_expression()); } vlog_set_loc(v, CURRENT_LOC); return v; } static void p_tf_port_list(vlog_node_t tf) { // tf_port_item { , tf_port_item } BEGIN("task or function port list"); do { vlog_node_t v = p_tf_port_item(); vlog_add_port(tf, v); if (vlog_has_ident(v)) // Ignore unnamed ports vlog_symtab_put(symtab, v); } while (optional(tCOMMA)); } static void p_list_of_tf_variable_identifiers(vlog_node_t tf, v_port_kind_t kind, vlog_node_t dt) { // port_identifier { variable_dimension } [ = expression ] // { , port_identifier { variable_dimension } [ = expression ] } BEGIN("list of task or function variable identifiers"); do { vlog_node_t v = vlog_new(V_PORT_DECL); vlog_set_subkind(v, kind); vlog_set_type(v, dt); vlog_set_ident(v, p_identifier()); vlog_set_loc(v, &state.last_loc); if (optional(tEQ)) vlog_set_value(v, p_expression()); vlog_add_port(tf, v); vlog_symtab_put(symtab, v); } while (optional(tCOMMA)); } static void p_tf_port_declaration(vlog_node_t tf) { // { attribute_instance } tf_port_direction [ var ] data_type_or_implicit // list_of_tf_variable_identifiers ; BEGIN("task or function port declaration"); v_port_kind_t kind = p_tf_port_direction(); optional(tVAR); vlog_node_t dt = p_data_type_or_implicit(); p_list_of_tf_variable_identifiers(tf, kind, dt); consume(tSEMI); } static void p_tf_item_declaration(vlog_node_t tf) { // block_item_declaration | tf_port_declaration BEGIN("task or function item declaration"); switch (peek()) { case tINPUT: case tOUTPUT: case tCONST: p_tf_port_declaration(tf); break; default: p_block_item_declaration(tf); break; } } static void p_task_body_declaration(vlog_node_t task) { // [ interface_identifier . | class_scope ] task_identifier ; // { tf_item_declaration } { statement_or_null } // endtask [ : task_identifier ] // | [ interface_identifier . | class_scope ] task_identifier // ( [ tf_port_list ] ) ; { block_item_declaration } // { statement_or_null } endtask [ : task_identifier ] BEGIN("task body declaration"); ident_t id = p_identifier(); vlog_set_ident(task, id); vlog_set_loc(task, &state.last_loc); vlog_symtab_put(symtab, task); vlog_symtab_push(symtab, task); if (optional(tLPAREN)) { if (peek() != tRPAREN) p_tf_port_list(task); consume(tRPAREN); consume(tSEMI); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC)) { p_block_item_declaration(task); skip_over_attributes(); } } else { consume(tSEMI); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC, tINPUT, tOUTPUT)) { p_tf_item_declaration(task); skip_over_attributes(); } } while (not_at_token(tENDTASK)) { vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(task, s); } consume(tENDTASK); vlog_symtab_pop(symtab); } static void p_lifetime(void) { // static | automatic BEGIN("lifetime"); one_of(tAUTOMATIC); } static vlog_node_t p_task_declaration(void) { // task [ dynamic_override_specifiers ] [ lifetime ] task_body_declaration BEGIN("task declaration"); vlog_node_t v = vlog_new(V_TASK_DECL); consume(tTASK); if (scan(tAUTOMATIC)) p_lifetime(); p_task_body_declaration(v); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_function_data_type_or_implicit(void) { // data_type_or_void | implicit_data_type BEGIN("function data type or implicit"); if (scan(tREG, tSTRUCT, tUNION, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tLOGIC, tBIT, tEVENT)) return p_data_type_or_void(); else return p_implicit_data_type(); } static void p_function_body_declaration(vlog_node_t func) { // function_data_type_or_implicit [ interface_identifier . | class_scope ] // function_identifier ; { tf_item_declaration } // { function_statement_or_null } endfunction [ : function_identifier ] // | function_data_type_or_implicit [ interface_identifier . | class_scope ] // function_identifier ( [ tf_port_list ] ) ; { block_item_declaration } // { function_statement_or_null } endfunction [ : function_identifier ] BEGIN("function body declaration"); vlog_set_type(func, p_function_data_type_or_implicit()); ident_t id = p_identifier(); vlog_set_ident(func, id); vlog_set_loc(func, &state.last_loc); vlog_symtab_put(symtab, func); vlog_symtab_push(symtab, func); if (optional(tLPAREN)) { if (peek() != tRPAREN) p_tf_port_list(func); consume(tRPAREN); consume(tSEMI); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC)) { p_block_item_declaration(func); skip_over_attributes(); } } else { consume(tSEMI); skip_over_attributes(); while (scan(tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tBIT, tLOGIC, tINPUT, tOUTPUT)) { p_tf_item_declaration(func); skip_over_attributes(); } } while (not_at_token(tENDFUNCTION)) { vlog_node_t s = p_statement_or_null(); if (s != NULL) vlog_add_stmt(func, s); } consume(tENDFUNCTION); vlog_symtab_pop(symtab); } static vlog_node_t p_function_declaration(void) { // function [ lifetime ] function_body_declaration BEGIN("function declaration"); vlog_node_t v = vlog_new(V_FUNC_DECL); consume(tFUNCTION); if (scan(tAUTOMATIC)) p_lifetime(); p_function_body_declaration(v); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_constant_param_expression(void) { // mintypmax_expression | data_type | $ BEGIN("constant parameter expression"); return p_mintypmax_expression(); } static vlog_node_t p_param_assignment(vlog_node_t datatype, vlog_kind_t kind) { // parameter_identifier { unpacked_dimension } // [ = constant_param_expression ] BEGIN("parameter assignment"); vlog_node_t v = vlog_new(kind); vlog_set_ident(v, p_identifier()); vlog_set_type(v, datatype); if (optional(tEQ)) vlog_set_value(v, p_constant_param_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_list_of_param_assignments(vlog_node_t parent, vlog_node_t datatype, vlog_kind_t kind) { // param_assignment { , param_assignment } BEGIN("list of parameter assignments"); do { vlog_node_t v = p_param_assignment(datatype, kind); vlog_symtab_put(symtab, v); vlog_add_decl(parent, v); } while (peek_nth(2) == tID && optional(tCOMMA)); } static void p_parameter_declaration(vlog_node_t mod) { // parameter data_type_or_implicit list_of_param_assignments BEGIN("parameter declaration"); consume(tPARAMETER); vlog_node_t dt = p_data_type_or_implicit(); p_list_of_param_assignments(mod, dt, param_kind); } static void p_local_parameter_declaration(vlog_node_t mod) { // localparam data_type_or_implicit list_of_param_assignments BEGIN("local parameter declaration"); consume(tLOCALPARAM); vlog_node_t dt = p_data_type_or_implicit(); p_list_of_param_assignments(mod, dt, V_LOCALPARAM); } static void p_block_item_declaration(vlog_node_t parent) { // { attribute_instance } data_declaration // | { attribute_instance } local_parameter_declaration ; // | { attribute_instance } parameter_declaration ; // | { attribute_instance } overload_declaration // | { attribute_instance } let_declaration BEGIN("block item declaration"); optional_attributes(); switch (peek()) { case tREG: case tSTRUCT: case tUNION: case tTYPEDEF: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tBIT: case tLOGIC: p_data_declaration(parent); break; default: should_not_reach_here(); } } static void p_package_or_generate_item_declaration(vlog_node_t mod) { // net_declaration | data_declaration | task_declaration // | function_declaration | checker_declaration | dpi_import_export // | extern_constraint_declaration | class_declaration // | class_constructor_declaration | local_parameter_declaration ; // | parameter_declaration ; | covergroup_declaration // | overload_declaration | assertion_item_declaration | ; BEGIN("package or generate item declaration"); switch (peek()) { case tWIRE: case tUWIRE: case tSUPPLY0: case tSUPPLY1: case tTRI: case tTRI0: case tTRI1: case tTRIAND: case tTRIOR: case tTRIREG: case tWAND: case tWOR: case tINTERCONNECT: p_net_declaration(mod); break; case tREG: case tSTRUCT: case tUNION: case tTYPEDEF: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tTIME: case tEVENT: case tID: p_data_declaration(mod); break; case tTASK: vlog_add_decl(mod, p_task_declaration()); break; case tFUNCTION: vlog_add_decl(mod, p_function_declaration()); break; case tLOCALPARAM: p_local_parameter_declaration(mod); consume(tSEMI); break; case tPARAMETER: p_parameter_declaration(mod); consume(tSEMI); break; default: one_of(tWIRE, tUWIRE, tSUPPLY0, tSUPPLY1, tTRI, tTRI0, tTRI1, tTRIAND, tTRIOR, tTRIREG, tWAND, tWOR, tINTERCONNECT, tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tTIME, tEVENT, tTASK, tFUNCTION, tLOCALPARAM, tPARAMETER); drop_tokens_until(tSEMI); break; } } static void p_list_of_genvar_identifiers(vlog_node_t mod) { // genvar_identifier { , genvar_identifier } BEGIN("list of genvar identifiers"); do { vlog_node_t v = vlog_new(V_GENVAR_DECL); vlog_set_ident(v, p_identifier()); vlog_set_loc(v, CURRENT_LOC); vlog_add_decl(mod, v); vlog_symtab_put(symtab, v); } while (optional(tCOMMA)); } static void p_genvar_declaration(vlog_node_t mod) { // genvar list_of_genvar_identifiers ; BEGIN("genvar declaration"); consume(tGENVAR); p_list_of_genvar_identifiers(mod); consume(tSEMI); } static void p_module_or_generate_item_declaration(vlog_node_t mod) { // package_or_generate_item_declaration | genvar_declaration // | clocking_declaration | default clocking clocking_identifier ; // | default disable iff expression_or_dist ; BEGIN("module or generate item declaration"); switch (peek()) { case tGENVAR: p_genvar_declaration(mod); break; default: p_package_or_generate_item_declaration(mod); break; } } static void p_generate_item(vlog_node_t parent) { // module_or_generate_item | interface_or_generate_item // | checker_or_generate_item BEGIN("generate item"); p_module_or_generate_item(parent); } static void p_generate_block(vlog_node_t parent) { // generate_item // | [ generate_block_identifier : ] begin [ : generate_block_identifier ] // { generate_item } end [ : generate_block_identifier ] BEGIN("generate item"); if (scan(tID, tBEGIN)) { vlog_node_t b = vlog_new(V_BLOCK); if (peek() == tID) { vlog_set_ident(b, p_identifier()); consume(tCOLON); } consume(tBEGIN); if (optional(tCOLON)) { ident_t name = p_identifier(); if (vlog_has_ident(b)) // 1800-2023 section 9.3.5 parse_error(&state.last_loc, "cannot specify both a label and a " "name for the same block"); else vlog_set_ident(b, name); } vlog_symtab_push(symtab, b); while (not_at_token(tEND)) p_generate_item(b); vlog_symtab_pop(symtab); consume(tEND); if (optional(tCOLON)) { ident_t name = p_identifier(); if (!vlog_has_ident(b)) parse_error(&state.last_loc, "block does not have a label"); else if (name != vlog_ident(b)) parse_error(&state.last_loc, "'%s' does not match label '%s'", istr(name), istr(vlog_ident(b))); } vlog_set_loc(b, CURRENT_LOC); vlog_add_stmt(parent, b); } else p_generate_item(parent); } static vlog_node_t p_if_generate_construct(void) { // if ( constant_expression ) generate_block [ else generate_block ] BEGIN("if generate construct"); vlog_node_t v = vlog_new(V_IF_GENERATE); consume(tIF); consume(tLPAREN); vlog_node_t c0 = vlog_new(V_COND); vlog_set_value(c0, p_constant_expression()); consume(tRPAREN); vlog_set_loc(c0, CURRENT_LOC); p_generate_block(c0); vlog_add_cond(v, c0); if (optional(tELSE)) { vlog_node_t c1 = vlog_new(V_COND); vlog_set_loc(c1, &state.last_loc); p_generate_block(c1); vlog_add_cond(v, c1); } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_conditional_generate_construct(void) { // if_generate_construct | case_generate_construct BEGIN("conditional generate construct"); switch (peek()) { case tIF: return p_if_generate_construct(); default: should_not_reach_here(); } } static vlog_node_t p_genvar_initialization(void) { // [ genvar ] genvar_identifier = constant_expression BEGIN("genvar initialization"); vlog_node_t v = vlog_new(V_FOR_INIT); vlog_node_t ref = vlog_new(V_REF); vlog_set_ident(ref, p_identifier()); vlog_set_loc(ref, &state.last_loc); vlog_symtab_lookup(symtab, ref); consume(tEQ); vlog_node_t a = vlog_new(V_BASSIGN); vlog_set_target(a, ref); vlog_set_value(a, p_constant_expression()); vlog_set_loc(a, CURRENT_LOC); vlog_add_stmt(v, a); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_genvar_iteration(void) { // genvar_identifier assignment_operator genvar_expression // | inc_or_dec_operator genvar_identifier // | genvar_identifier inc_or_dec_operator BEGIN("genvar iteration"); vlog_node_t v = vlog_new(V_FOR_STEP); vlog_node_t prefix = NULL; if (scan(tPLUSPLUS, tMINUSMINUS)) { prefix = vlog_new(V_PREFIX); vlog_set_subkind(prefix, p_inc_or_dec_operator()); } vlog_node_t ref = vlog_new(V_REF); vlog_set_ident(ref, p_identifier()); vlog_set_loc(ref, &state.last_loc); vlog_symtab_lookup(symtab, ref); if (prefix != NULL) { vlog_set_target(prefix, ref); vlog_add_stmt(v, prefix); } else if (optional(tEQ)) { vlog_node_t a = vlog_new(V_BASSIGN); vlog_set_target(a, ref); vlog_set_value(a, p_constant_expression()); vlog_add_stmt(v, a); } else { vlog_node_t a = vlog_new(V_POSTFIX); vlog_set_subkind(a, p_inc_or_dec_operator()); vlog_set_target(a, ref); vlog_add_stmt(v, a); } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_loop_generate_construct(void) { // for ( genvar_initialization ; genvar_expression ; genvar_iteration ) // generate_block BEGIN("loop generate construct"); consume(tFOR); consume(tLPAREN); vlog_node_t v = vlog_new(V_FOR_GENERATE); vlog_symtab_push(symtab, v); vlog_set_left(v, p_genvar_initialization()); consume(tSEMI); vlog_set_value(v, p_constant_expression()); consume(tSEMI); vlog_set_right(v, p_genvar_iteration()); consume(tRPAREN); p_generate_block(v); vlog_symtab_pop(symtab); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_module_common_item(vlog_node_t mod) { // module_or_generate_item_declaration // | interface_instantiation | program_instantiation // | assertion_item | bind_directive | continuous_assign // | net_alias | initial_construct | final_construct // | always_construct | loop_generate_construct // | conditional_generate_construct | elaboration_system_task BEGIN("module common item"); switch (peek()) { case tALWAYS: case tALWAYSCOMB: case tALWAYSFF: case tALWAYSLATCH: vlog_add_stmt(mod, p_always_construct()); break; case tINITIAL: vlog_add_stmt(mod, p_initial_construct()); break; case tWIRE: case tUWIRE: case tSUPPLY0: case tSUPPLY1: case tTRI: case tTRI0: case tTRI1: case tTRIAND: case tTRIOR: case tTRIREG: case tWAND: case tWOR: case tINTERCONNECT: case tREG: case tSTRUCT: case tUNION: case tTYPEDEF: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tTIME: case tTASK: case tFUNCTION: case tLOCALPARAM: case tPARAMETER: case tEVENT: case tID: case tGENVAR: p_module_or_generate_item_declaration(mod); break; case tASSIGN: p_continuous_assign(mod); break; case tFOR: vlog_add_stmt(mod, p_loop_generate_construct()); break; case tIF: vlog_add_stmt(mod, p_conditional_generate_construct()); break; default: one_of(tALWAYS, tALWAYSCOMB, tALWAYSFF, tALWAYSLATCH, tWIRE, tUWIRE, tSUPPLY0, tSUPPLY1, tTRI, tTRI0, tTRI1, tTRIAND, tTRIOR, tTRIREG, tWAND, tWOR, tINTERCONNECT, tREG, tSTRUCT, tUNION, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tTIME, tTASK, tFUNCTION, tPARAMETER, tLOCALPARAM, tEVENT, tID, tGENVAR, tASSIGN, tFOR, tIF); drop_tokens_until(tSEMI); } } static vlog_strength_t p_strength0(void) { // supply0 | strong0 | pull0 | weak0 BEGIN("strength0"); switch (one_of(tSUPPLY0, tSTRONG0, tPULL0, tWEAK0)) { default: case tSUPPLY0: return V_STRENGTH_SUPPLY; case tSTRONG0: return V_STRENGTH_STRONG; case tPULL0: return V_STRENGTH_PULL; case tWEAK0: return V_STRENGTH_WEAK; } } static vlog_strength_t p_strength1(void) { // supply1 | strong1 | pull1 | weak1 BEGIN("strength1"); switch (one_of(tSUPPLY1, tSTRONG1, tPULL1, tWEAK1)) { default: case tSUPPLY1: return V_STRENGTH_SUPPLY; case tSTRONG1: return V_STRENGTH_STRONG; case tPULL1: return V_STRENGTH_PULL; case tWEAK1: return V_STRENGTH_WEAK; } } static vlog_node_t p_pulldown_strength(void) { // ( strength0 , strength1 ) | ( strength1 , strength0 ) | ( strength0 ) BEGIN("pulldown strength"); consume(tLPAREN); vlog_strength_t s0, s1; switch (peek()) { case tSUPPLY1: case tSTRONG1: case tPULL1: case tWEAK1: s1 = p_strength1(); consume(tCOMMA); s0 = p_strength0(); break; default: s0 = s1 = p_strength0(); if (optional(tCOMMA)) s1 = p_strength1(); break; } consume(tRPAREN); vlog_node_t v = vlog_new(V_STRENGTH); vlog_set_subkind(v, MAKE_STRENGTH(s0, s1)); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_pullup_strength(void) { // ( strength0 , strength1 ) | ( strength1 , strength0 ) | ( strength1 ) BEGIN("pullup strength"); consume(tLPAREN); vlog_strength_t s0, s1; switch (peek()) { case tSUPPLY0: case tSTRONG0: case tPULL0: case tWEAK0: s0 = p_strength0(); consume(tCOMMA); s1 = p_strength1(); break; default: s1 = s0 = p_strength1(); if (optional(tCOMMA)) s0 = p_strength0(); break; } consume(tRPAREN); vlog_node_t v = vlog_new(V_STRENGTH); vlog_set_subkind(v, MAKE_STRENGTH(s0, s1)); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_pull_gate_instance(vlog_gate_kind_t kind, vlog_node_t st) { // [ name_of_instance ] ( output_terminal ) BEGIN("pull gate instance"); vlog_node_t v = vlog_new(V_GATE_INST); vlog_set_subkind(v, kind); vlog_add_param(v, st); if (peek() == tID) { vlog_set_ident(v, p_identifier()); vlog_set_loc(v, &state.last_loc); vlog_symtab_put(symtab, v); } else vlog_set_ident(v, ident_uniq("#gate")); consume(tLPAREN); vlog_symtab_set_implicit(symtab, implicit_kind); vlog_set_target(v, p_net_lvalue()); vlog_symtab_set_implicit(symtab, V_NET_NONE); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_n_terminal_gate_instance(vlog_gate_kind_t kind) { // [ name_of_instance ] ( output_terminal , input_terminal // { , input_terminal } ) BEGIN("N-terminal gate instance"); vlog_node_t v = vlog_new(V_GATE_INST); vlog_set_subkind(v, kind); if (peek() == tID) { vlog_set_ident(v, p_identifier()); vlog_set_loc(v, &state.last_loc); vlog_symtab_put(symtab, v); } else vlog_set_ident(v, ident_uniq("#gate")); consume(tLPAREN); vlog_symtab_set_implicit(symtab, implicit_kind); vlog_set_target(v, p_net_lvalue()); consume(tCOMMA); do { vlog_add_param(v, p_expression()); } while (optional(tCOMMA)); vlog_symtab_set_implicit(symtab, V_NET_NONE); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_gate_instantiation(vlog_node_t mod) { // cmos_switchtype [ delay3 ] cmos_switch_instance // { , cmos_switch_instance } ; // | enable_gatetype [ drive_strength ] [ delay3 ] // enable_gate_instance { , enable_gate_instance } ; // | mos_switchtype [ delay3 ] mos_switch_instance // { , mos_switch_instance } ; // | n_input_gatetype [ drive_strength ] [ delay2 ] n_input_gate_instance // { , n_input_gate_instance } ; // | n_output_gatetype [ drive_strength ] [ delay2 ] n_output_gate_instance // { , n_output_gate_instance } ; // | pass_en_switchtype [ delay2 ] pass_enable_switch_instance // { , pass_enable_switch_instance } ; // | pass_switchtype pass_switch_instance { , pass_switch_instance } ; // | pulldown [ pulldown_strength ] pull_gate_instance // { , pull_gate_instance } ; // | pullup [ pullup_strength ] pull_gate_instance // { , pull_gate_instance } ; BEGIN("gate instantiation"); switch (one_of(tPULLDOWN, tPULLUP, tAND, tNAND, tOR, tNOR, tXOR, tXNOR, tNOT, tBUF)) { case tPULLDOWN: { vlog_node_t st; if (peek() == tLPAREN && peek_nth(2) != tID) st = p_pulldown_strength(); else { st = vlog_new(V_STRENGTH); vlog_set_subkind(st, ST_PULLUP); } do { vlog_node_t g = p_pull_gate_instance(V_GATE_PULLDOWN, st); vlog_add_stmt(mod, g); } while (optional(tCOMMA)); } break; case tPULLUP: { vlog_node_t st; if (peek() == tLPAREN && peek_nth(2) != tID) st = p_pullup_strength(); else { st = vlog_new(V_STRENGTH); vlog_set_subkind(st, ST_PULLUP); } do { vlog_node_t g = p_pull_gate_instance(V_GATE_PULLUP, st); vlog_add_stmt(mod, g); } while (optional(tCOMMA)); } break; case tAND: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_AND)); } while (optional(tCOMMA)); break; case tNAND: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_NAND)); } while (optional(tCOMMA)); break; case tOR: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_OR)); } while (optional(tCOMMA)); break; case tNOR: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_NOR)); } while (optional(tCOMMA)); break; case tXOR: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_XOR)); } while (optional(tCOMMA)); break; case tXNOR: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_XNOR)); } while (optional(tCOMMA)); break; case tNOT: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_NOT)); } while (optional(tCOMMA)); break; case tBUF: do { vlog_add_stmt(mod, p_n_terminal_gate_instance(V_GATE_BUF)); } while (optional(tCOMMA)); break; default: break; } consume(tSEMI); } static vlog_node_t p_module_path_expression(void) { // module_path_primary // | unary_module_path_operator { attribute_instance } module_path_primary // | module_path_expression binary_module_path_operator // { attribute_instance } module_path_expression // | module_path_conditional_expression BEGIN("module path expression"); // TODO: sem should check valid subset return p_expression(); } static void p_path_delay_expression(void) { // constant_expression // | constant_expression : constant_expression : constant_expression BEGIN("path delay expression"); (void)p_constant_expression(); } static void p_list_of_path_delay_expressions(void) { // path_delay_expression { , path_delay_expression } BEGIN("list of path delay expressions"); do { p_path_delay_expression(); } while (optional(tCOMMA)); } static void p_path_delay_value(void) { // list_of_path_delay_expressions | ( list_of_path_delay_expressions ) BEGIN("path delay value"); if (optional(tLPAREN)) { p_list_of_path_delay_expressions(); consume(tRPAREN); } else p_list_of_path_delay_expressions(); } static vlog_node_t p_specify_terminal_descriptor(void) { // identifier [ [ constant_range_expression ] ] BEGIN("specify terminal descriptor"); vlog_node_t v = vlog_new(V_REF); vlog_set_ident(v, p_identifier()); vlog_set_loc(v, CURRENT_LOC); if (optional(tLSQUARE)) { (void)p_constant_range_expression(); consume(tRSQUARE); } return v; } static void p_list_of_path_inputs(vlog_node_t v, vlog_node_t head) { // specify_input_terminal_descriptor { , specify_input_terminal_descriptor } BEGIN_WITH_HEAD("list of path inputs", head); while (optional(tCOMMA)) (void)p_specify_terminal_descriptor(); } static void p_list_of_path_outputs(vlog_node_t v) { // specify_output_terminal_descriptor // { , specify_output_terminal_descriptor } BEGIN("list of path outputs"); do { (void)p_specify_terminal_descriptor(); } while (optional(tCOMMA)); } static void p_polarity_operator(void) { // + | - BEGIN("polarity operator"); (void)one_of(tPLUS, tMINUS); } static vlog_node_t p_parallel_path_description(vlog_node_t head) { // ( specify_input_terminal_descriptor [ polarity_operator ] // => specify_output_terminal_descriptor ) EXTEND("parallel path description"); if (scan(tPLUS, tMINUS)) (void)p_polarity_operator(); consume(tASSOC); (void)p_specify_terminal_descriptor(); consume(tRPAREN); return NULL; } static vlog_node_t p_full_path_description(vlog_node_t head) { // ( list_of_path_inputs [ polarity_operator ] *> list_of_path_outputs ) EXTEND("full path description"); p_list_of_path_inputs(NULL, head); if (scan(tPLUS, tMINUS)) (void)p_polarity_operator(); consume(tTIMESGT); p_list_of_path_outputs(NULL); consume(tRPAREN); return NULL; } static vlog_node_t p_simple_path_declaration(void) { // parallel_path_description = path_delay_value // | full_path_description = path_delay_value BEGIN("simple path declaration"); // Parse up to the first terminal descriptor to determine which // production to use consume(tLPAREN); vlog_node_t head = p_specify_terminal_descriptor(); if (scan(tCOMMA, tTIMESGT) || peek_nth(2) == tTIMESGT) (void)p_full_path_description(head); else (void)p_parallel_path_description(head); consume(tEQ); (void)p_path_delay_value(); return NULL; } static void p_edge_identifier(void) { // posedge | negedge | edge BEGIN("edge identifier"); one_of(tPOSEDGE, tNEGEDGE, tEDGE); } static vlog_node_t p_parallel_edge_sensitive_path_description(vlog_node_t head) { // ( [ edge_identifier ] specify_input_terminal_descriptor // [ polarity_operator ] => ( specify_output_terminal_descriptor // [ polarity_operator ] : data_source_expression ) ) EXTEND("parallel edge sensitive path description"); if (scan(tPLUS, tMINUS)) (void)p_polarity_operator(); consume(tASSOC); consume(tLPAREN); (void)p_specify_terminal_descriptor(); if (scan(tPLUS, tMINUS)) { (void)p_polarity_operator(); consume(tCOLON); } else if (scan(tINDEXPOS, tINDEXNEG)) consume(peek()); // Lexing ambiguity with +: and -: else consume(tCOLON); (void)p_expression(); consume(tRPAREN); consume(tRPAREN); return NULL; } static vlog_node_t p_full_edge_sensitive_path_description(vlog_node_t head) { // ( [ edge_identifier ] list_of_path_inputs [ polarity_operator ] *> // ( list_of_path_outputs [ polarity_operator ] // : data_source_expression ) ) EXTEND("full edge sensitive path description"); p_list_of_path_inputs(NULL, head); if (scan(tPLUS, tMINUS)) (void)p_polarity_operator(); consume(tTIMESGT); consume(tLPAREN); p_list_of_path_outputs(NULL); if (scan(tPLUS, tMINUS)) { (void)p_polarity_operator(); consume(tCOLON); } else if (scan(tINDEXPOS, tINDEXNEG)) consume(peek()); // Lexing ambiguity with +: and -: else consume(tCOLON); (void)p_expression(); consume(tRPAREN); consume(tRPAREN); return NULL; } static vlog_node_t p_edge_sensitive_path_declaration(void) { // parallel_edge_sensitive_path_description = path_delay_value // | full_edge_sensitive_path_description = path_delay_value BEGIN("edge sensitive path declaration"); // Parse up to the first terminal descriptor to determine which // production to use consume(tLPAREN); if (scan(tEDGE, tPOSEDGE, tNEGEDGE)) p_edge_identifier(); vlog_node_t head = p_specify_terminal_descriptor(); if (scan(tCOMMA, tTIMESGT) || peek_nth(2) == tTIMESGT) (void)p_full_edge_sensitive_path_description(head); else (void)p_parallel_edge_sensitive_path_description(head); consume(tEQ); (void)p_path_delay_value(); return NULL; } static vlog_node_t p_state_dependent_path_declaration(void) { // if ( module_path_expression ) simple_path_declaration // | if ( module_path_expression ) edge_sensitive_path_declaration // | ifnone simple_path_declaration BEGIN("state dependent path declaration"); switch (one_of(tIF, tIFNONE)) { case tIF: consume(tLPAREN); (void)p_module_path_expression(); consume(tRPAREN); break; case tIFNONE: break; } if (peek_nth(2) == tID) (void)p_simple_path_declaration(); else { // This is invalid for ifnone according to the grammar but is // accepted by some simulators and seen in the wild (void)p_edge_sensitive_path_declaration(); } return NULL; } static vlog_node_t p_path_declaration(void) { // simple_path_declaration ; // | edge_sensitive_path_declaration ; // | state_dependent_path_declaration ; BEGIN("path declaration"); switch (peek()) { case tIF: case tIFNONE: (void)p_state_dependent_path_declaration(); break; case tLPAREN: switch (peek_nth(2)) { case tEDGE: case tNEGEDGE: case tPOSEDGE: (void)p_edge_sensitive_path_declaration(); break; default: (void)p_simple_path_declaration(); break; } break; default: one_of(tIF, tIFNONE); } consume(tSEMI); return NULL; } static void p_timing_check_event_control(void) { // posedge | negedge | edge | edge_control_specifier BEGIN("timing check event control"); one_of(tPOSEDGE, tNEGEDGE, tEDGE); } static void p_scalar_timing_check_condition(void) { // expression // | ~ expression // | expression == scalar_constant // | expression === scalar_constant // | expression != scalar_constant // | expression !== scalar_constant BEGIN("scalar timing check condition") p_expression(); } static void p_timing_check_condition(void) { // scalar_timing_check_condition // | ( scalar_timing_check_condition ) BEGIN("timing check condition"); if (optional(tLPAREN)) { p_scalar_timing_check_condition(); consume(tRPAREN); } else p_scalar_timing_check_condition(); } static vlog_node_t p_timing_check_event(void) { // [ timing_check_event_control ] specify_terminal_descriptor // [ &&& timing_check_condition ] BEGIN("timing check event"); if (scan(tEDGE, tPOSEDGE, tNEGEDGE)) p_timing_check_event_control(); (void)p_specify_terminal_descriptor(); if (optional(tTRPLAMP)) p_timing_check_condition(); return NULL; } static vlog_node_t p_controlled_timing_check_event(void) { // timing_check_event_control specify_terminal_descriptor // [ &&& timing_check_condition ] BEGIN("controlled timing check event"); p_timing_check_event_control(); (void)p_specify_terminal_descriptor(); if (optional(tTRPLAMP)) p_timing_check_condition(); return NULL; } static vlog_node_t p_setup_or_hold_timing_check(void) { // $setup ( data_event , reference_event , timing_check_limit // [ , [ notifier ] ] ) ; // // $hold ( reference_event , data_event , timing_check_limit // [ , [ notifier ] ] ) ; BEGIN("setup/hold timing check"); one_of(tDLRSETUP, tDLRHOLD); consume(tLPAREN); (void)p_timing_check_event(); consume(tCOMMA); (void)p_timing_check_event(); consume(tCOMMA); (void)p_expression(); if (optional(tCOMMA)) { if (peek() == tID) p_identifier(); } consume(tRPAREN); consume(tSEMI); return NULL; } static vlog_node_t p_recovery_or_removal_timing_check(void) { // $recovery ( reference_event , data_event , timing_check_limit // [ , [ notifier ] ] ) ; // // $removal ( reference_event , data_event , timing_check_limit // [ , [ notifier ] ] ) ; BEGIN("recovery/removal timing check"); one_of(tDLRRECOVERY, tDLRREMOVAL); consume(tLPAREN); (void)p_timing_check_event(); consume(tCOMMA); (void)p_timing_check_event(); consume(tCOMMA); (void)p_expression(); if (optional(tCOMMA)) { if (peek() == tID) p_identifier(); } consume(tRPAREN); consume(tSEMI); return NULL; } static vlog_node_t p_width_timing_check(void) { // $width ( controlled_reference_event , timing_check_limit , threshold // [ , [ notifier ] ] ) ; BEGIN("width timing check"); consume(tDLRWIDTH); consume(tLPAREN); (void)p_controlled_timing_check_event(); consume(tCOMMA); (void)p_expression(); consume(tCOMMA); (void)p_constant_expression(); if (optional(tCOMMA)) { if (peek() == tID) p_identifier(); } consume(tRPAREN); consume(tSEMI); return NULL; } static vlog_node_t p_delayed_data_or_reference(void) { // terminal_identifier // | terminal_identifier [ constant_mintypmax_expression ] BEGIN("delayed data/reference"); p_identifier(); return NULL; } static vlog_node_t p_setuphold_or_recrem_timing_check(void) { // $setuphold ( reference_event , data_event , timing_check_limit , // timing_check_limit [ , [ notifier ] [ , [ timestamp_condition ] // [ , [ timecheck_condition ] [ , [ delayed_reference ] // [ , [ delayed_data ] ] ] ] ] ] ) ; BEGIN("setuphold/recrem timing check"); one_of(tDLRSETUPHOLD, tDLRRECREM); consume(tLPAREN); (void)p_timing_check_event(); consume(tCOMMA); (void)p_timing_check_event(); consume(tCOMMA); (void)p_expression(); consume(tCOMMA); (void)p_expression(); if (optional(tCOMMA)) { if (peek() == tID) p_identifier(); // notifier if (optional(tCOMMA)) { if (not_at_token(tCOMMA, tRPAREN)) (void)p_mintypmax_expression(); // timestamp_condition if (optional(tCOMMA)) { if (not_at_token(tCOMMA, tRPAREN)) (void)p_mintypmax_expression(); // timecheck_condition if (optional(tCOMMA)) { if (not_at_token(tCOMMA, tRPAREN)) p_delayed_data_or_reference(); // delayed_reference if (optional(tCOMMA)) { if (not_at_token(tCOMMA, tRPAREN)) p_delayed_data_or_reference(); // delayed_data } } } } } consume(tRPAREN); consume(tSEMI); return NULL; } static vlog_node_t p_system_timing_check(void) { // $setup_timing_check | $hold_timing_check | $setuphold_timing_check // | $recovery_timing_check | $removal_timing_check | $recrem_timing_check // | $skew_timing_check | $timeskew_timing_check | $fullskew_timing_check // | $period_timing_check | $width_timing_check | $nochange_timing_check BEGIN("system timing check"); switch (peek()) { case tDLRSETUP: case tDLRHOLD: return p_setup_or_hold_timing_check(); case tDLRRECOVERY: case tDLRREMOVAL: return p_recovery_or_removal_timing_check(); case tDLRWIDTH: return p_width_timing_check(); case tDLRSETUPHOLD: case tDLRRECREM: return p_setuphold_or_recrem_timing_check(); default: should_not_reach_here(); } } static vlog_node_t p_specparam_assignment(void) { // specparam_identifier = constant_mintypmax_expression // | pulse_control_specparam BEGIN("specparam assignment"); vlog_node_t v = vlog_new(V_SPECPARAM); vlog_set_ident(v, p_identifier()); consume(tEQ); vlog_set_value(v, p_constant_mintypmax_expression()); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); return v; } static void p_list_of_specparam_assignments(vlog_node_t parent) { // specparam_assignment { , specparam_assignment } BEGIN("list of specparam assignments"); do { vlog_add_decl(parent, p_specparam_assignment()); } while (optional(tCOMMA)); } static void p_specparam_declaration(vlog_node_t parent) { // specparam [ packed_dimension ] list_of_specparam_assignments ; BEGIN("specparam declaration"); consume(tSPECPARAM); if (peek() == tLSQUARE) (void)p_packed_dimension(); p_list_of_specparam_assignments(parent); consume(tSEMI); } static void p_specify_item(vlog_node_t parent) { // specparam_declaration | pulsestyle_declaration | showcancelled_declaration // | path_declaration | system_timing_check BEGIN("specify item"); switch (peek()) { case tSPECPARAM: p_specparam_declaration(parent); break; case tLPAREN: case tIF: case tIFNONE: (void)p_path_declaration(); break; case tDLRSETUP: case tDLRHOLD: case tDLRRECOVERY: case tDLRREMOVAL: case tDLRSETUPHOLD: case tDLRRECREM: case tDLRWIDTH: (void)p_system_timing_check(); break; default: one_of(tSPECPARAM, tLPAREN, tIF, tIFNONE, tDLRSETUP, tDLRHOLD, tDLRRECOVERY, tDLRREMOVAL, tDLRSETUPHOLD, tDLRRECREM, tDLRWIDTH); } } static vlog_node_t p_specify_block(void) { // specify { specify_item } endspecify BEGIN("specify block"); consume(tSPECIFY); vlog_node_t v = vlog_new(V_SPECIFY); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_push(symtab, v); while (not_at_token(tENDSPECIFY)) p_specify_item(v); vlog_symtab_pop(symtab); consume(tENDSPECIFY); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_ordered_port_connection(void) { // { attribute_instance } [ expression ] BEGIN("ordered port connection"); vlog_node_t v = vlog_new(V_PORT_CONN); if (not_at_token(tCOMMA, tRPAREN)) vlog_set_value(v, p_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_named_port_connection(void) { // { attribute_instance } . port_identifier [ ( [ expression ] ) ] // | { attribute_instance } .* BEGIN("named port connection"); vlog_node_t v = vlog_new(V_PORT_CONN); consume(tDOT); vlog_set_ident(v, p_identifier()); if (optional(tLPAREN)) { if (peek() != tRPAREN) vlog_set_value(v, p_expression()); consume(tRPAREN); } vlog_set_loc(v, CURRENT_LOC); return v; } static void p_list_of_port_connections(vlog_node_t inst) { // ordered_port_connection { , ordered_port_connection } // | named_port_connection { , named_port_connection } BEGIN("list of port connections"); vlog_symtab_set_implicit(symtab, implicit_kind); do { if (peek() == tDOT) vlog_add_param(inst, p_named_port_connection()); else vlog_add_param(inst, p_ordered_port_connection()); } while (optional(tCOMMA)); vlog_symtab_set_implicit(symtab, V_NET_NONE); } static vlog_node_t p_hierarchical_instance(void) { // name_of_instance ( [ list_of_port_connections ] ) BEGIN("hierarchical instance"); vlog_node_t v = vlog_new(V_MOD_INST); vlog_set_ident(v, p_identifier()); consume(tLPAREN); if (peek() != tRPAREN) p_list_of_port_connections(v); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); vlog_symtab_put(symtab, v); return v; } static vlog_node_t p_udp_instance(void) { // [ name_of_instance ] ( output_terminal , input_terminal // { , input_terminal } ) BEGIN("udp instance"); vlog_node_t v = vlog_new(V_MOD_INST); if (peek() == tID) vlog_set_ident(v, p_identifier()); else vlog_set_ident(v, ident_uniq("$unnamed")); consume(tLPAREN); p_list_of_port_connections(v); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_param_expression(void) { // mintypmax_expression | data_type | $ BEGIN("param expression"); return p_expression(); // TODO } static vlog_node_t p_named_parameter_assignment(void) { // . parameter_identifier ( [ param_expression ] ) BEGIN("named parameter assignment"); consume(tDOT); vlog_node_t v = vlog_new(V_PARAM_ASSIGN); vlog_set_ident(v, p_identifier()); consume(tLPAREN); if (peek() != tRPAREN) vlog_set_value(v, p_param_expression()); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_ordered_parameter_assignment(void) { // param_expression BEGIN("ordered parameter assignment"); vlog_node_t v = vlog_new(V_PARAM_ASSIGN); vlog_set_value(v, p_param_expression()); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_list_of_parameter_assignments(vlog_node_t inst) { // ordered_parameter_assignment { , ordered_parameter_assignment } // | named_parameter_assignment { , named_parameter_assignment } BEGIN("list of parameter assignments"); do { if (peek() == tDOT) vlog_add_param(inst, p_named_parameter_assignment()); else vlog_add_param(inst, p_ordered_parameter_assignment()); } while (optional(tCOMMA)); } static void p_parameter_value_assignment(vlog_node_t inst) { // # ( [ list_of_parameter_assignments ] ) BEGIN("parameter value assignment"); consume(tHASH); consume(tLPAREN); if (peek() != tRPAREN) p_list_of_parameter_assignments(inst); consume(tRPAREN); } static void p_module_or_udp_instantiation(vlog_node_t mod) { // module_identifier [ parameter_value_assignment ] hierarchical_instance // { , hierarchical_instance } ; // // udp_identifier [ drive_strength ] [ delay2 ] udp_instance // { , udp_instance } ; BEGIN("module instantiation"); vlog_node_t v = vlog_new(V_INST_LIST); vlog_set_ident(v, p_identifier()); if (peek() == tHASH) p_parameter_value_assignment(v); do { if (peek() == tLPAREN) vlog_add_stmt(v, p_udp_instance()); else vlog_add_stmt(v, p_hierarchical_instance()); } while (optional(tCOMMA)); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); vlog_add_stmt(mod, v); } static void p_module_or_generate_item(vlog_node_t mod) { // { attribute_instance } parameter_override // | { attribute_instance } gate_instantiation // | { attribute_instance } udp_instantiation // | { attribute_instance } module_instantiation // | { attribute_instance } module_common_item BEGIN("module or generate item"); optional_attributes(); switch (peek()) { case tALWAYS: case tALWAYSCOMB: case tALWAYSFF: case tALWAYSLATCH: case tWIRE: case tUWIRE: case tSUPPLY0: case tSUPPLY1: case tTRI: case tTRI0: case tTRI1: case tTRIAND: case tTRIOR: case tTRIREG: case tWAND: case tWOR: case tINTERCONNECT: case tREG: case tSTRUCT: case tUNION: case tASSIGN: case tINITIAL: case tTYPEDEF: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tTIME: case tTASK: case tFUNCTION: case tLOCALPARAM: case tPARAMETER: case tIF: case tFOR: case tEVENT: case tGENVAR: p_module_common_item(mod); break; case tPULLDOWN: case tPULLUP: case tAND: case tNAND: case tOR: case tNOR: case tXOR: case tXNOR: case tNOT: case tBUF: p_gate_instantiation(mod); break; case tID: { vlog_node_t ref = peek_reference(); if (ref == NULL) p_module_or_udp_instantiation(mod); else p_module_common_item(mod); } break; default: one_of(tALWAYS, tALWAYSCOMB, tALWAYSFF, tALWAYSLATCH, tWIRE, tUWIRE, tSUPPLY0, tSUPPLY1, tTRI, tTRI0, tTRI1, tTRIAND, tTRIOR, tTRIREG, tWAND, tWOR, tINTERCONNECT, tREG, tSTRUCT, tUNION, tASSIGN, tINITIAL, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tTIME, tTASK, tFUNCTION, tLOCALPARAM, tPARAMETER, tIF, tFOR, tEVENT, tGENVAR, tPULLDOWN, tPULLUP, tID, tAND, tNAND, tOR, tNOR, tXOR, tXNOR, tNOT, tBUF); drop_tokens_until(tSEMI); } } static void p_generate_region(vlog_node_t mod) { // generate { generate_item } endgenerate BEGIN("generate region"); // Has no real meaning in System Verilog // TODO: generate regions do not nest so check mod is V_MODULE consume(tGENERATE); while (not_at_token(tENDGENERATE)) p_generate_item(mod); consume(tENDGENERATE); } static void p_non_port_module_item(vlog_node_t mod) { // generate_region | module_or_generate_item | specify_block // | { attribute_instance } specparam_declaration | program_declaration // | module_declaration | interface_declaration | timeunits_declaration BEGIN("non-port module item"); switch (peek()) { case tALWAYS: case tALWAYSCOMB: case tALWAYSFF: case tALWAYSLATCH: case tWIRE: case tUWIRE: case tSUPPLY0: case tSUPPLY1: case tTRI: case tTRI0: case tTRI1: case tTRIAND: case tTRIOR: case tTRIREG: case tWAND: case tWOR: case tINTERCONNECT: case tREG: case tSTRUCT: case tUNION: case tASSIGN: case tINITIAL: case tPULLDOWN: case tPULLUP: case tID: case tATTRBEGIN: case tAND: case tNAND: case tOR: case tNOR: case tXOR: case tXNOR: case tNOT: case tBUF: case tTYPEDEF: case tENUM: case tSVINT: case tINTEGER: case tSVREAL: case tSHORTREAL: case tREALTIME: case tTIME: case tTASK: case tFUNCTION: case tLOCALPARAM: case tPARAMETER: case tEVENT: case tIF: case tFOR: case tGENVAR: p_module_or_generate_item(mod); break; case tSPECIFY: vlog_add_stmt(mod, p_specify_block()); break; case tGENERATE: p_generate_region(mod); break; default: one_of(tALWAYS, tALWAYSCOMB, tALWAYSFF, tALWAYSLATCH, tWIRE, tUWIRE, tSUPPLY0, tSUPPLY1, tTRI, tTRI0, tTRI1, tTRIAND, tTRIOR, tTRIREG, tWAND, tWOR, tINTERCONNECT, tREG, tSTRUCT, tUNION, tASSIGN, tPULLDOWN, tPULLUP, tID, tATTRBEGIN, tAND, tNAND, tOR, tNOR, tXOR, tXNOR, tNOT, tBUF, tTYPEDEF, tENUM, tSVINT, tINTEGER, tSVREAL, tSHORTREAL, tREALTIME, tTIME, tTASK, tFUNCTION, tLOCALPARAM, tPARAMETER, tEVENT, tIF, tFOR, tGENVAR, tSPECIFY, tGENERATE); drop_tokens_until(tSEMI); } } static void p_module_item(vlog_node_t mod) { // port_declaration ; | non_port_module_item BEGIN("module item"); if (scan(tINOUT, tINPUT, tOUTPUT)) { p_port_declaration(mod); consume(tSEMI); } else p_non_port_module_item(mod); } static void p_ansi_port_declaration(vlog_node_t mod, v_port_kind_t *kind, bool *isreg) { // [ net_port_header | interface_port_header ] port_identifier // { unpacked_dimension } [ = constant_expression ] // | [ variable_port_header ] port_identifier { variable_dimension } // [ = constant_expression ] // | [ port_direction ] . port_identifier ( [ expression ] ) BEGIN("ANSI port declaration"); vlog_node_t dt; if (peek() != tID) dt = p_net_port_header(kind, isreg); else dt = logic_type(); ident_t id, ext; p_external_identifier(&id, &ext); vlog_node_t v = vlog_new(V_PORT_DECL); vlog_set_subkind(v, *kind); vlog_set_ident(v, id); vlog_set_ident2(v, ext); vlog_set_type(v, dt); vlog_set_loc(v, &state.last_loc); vlog_add_decl(mod, v); vlog_symtab_put(symtab, v); if (*isreg) { vlog_node_t reg = vlog_new(V_VAR_DECL); vlog_set_loc(reg, CURRENT_LOC); vlog_set_ident(reg, id); vlog_set_type(reg, dt); vlog_add_decl(mod, reg); vlog_symtab_put(symtab, reg); } vlog_node_t ref = vlog_new(V_REF); vlog_set_loc(ref, CURRENT_LOC); vlog_set_ident(ref, id); vlog_set_ref(ref, v); vlog_add_port(mod, ref); } static void p_list_of_port_declarations(vlog_node_t mod) { // ( [ { attribute_instance } ansi_port_declaration // { , { attribute_instance } ansi_port_declaration } ] ) BEGIN("list of port declarations"); consume(tLPAREN); if (peek() != tRPAREN) { v_port_kind_t kind = V_PORT_INPUT; bool isreg = false; do { optional_attributes(); p_ansi_port_declaration(mod, &kind, &isreg); } while (optional(tCOMMA)); } consume(tRPAREN); } static void p_parameter_port_declaration(vlog_node_t mod) { // parameter_declaration // | local_parameter_declaration // | data_type list_of_param_assignments // | type list_of_type_assignments BEGIN("parameter port declaration"); switch (peek()) { case tPARAMETER: p_parameter_declaration(mod); break; case tLOCALPARAM: p_local_parameter_declaration(mod); break; default: // TODO: Add parsing of "type" declarations example #(type T = bit) { vlog_node_t datatype = p_data_type(); p_list_of_param_assignments(mod, datatype, V_PARAM_DECL); } break; } } static void p_parameter_port_list(vlog_node_t mod) { // # ( list_of_param_assignments { , parameter_port_declaration } ) // | # ( parameter_port_declaration { , parameter_port_declaration } ) // | # ( ) BEGIN("parameter port list"); consume(tHASH); consume(tLPAREN); if (peek() != tRPAREN) { do { if (peek() == tID) p_list_of_param_assignments(mod, NULL, V_PARAM_DECL); else p_parameter_port_declaration(mod); } while(optional(tCOMMA)); } consume(tRPAREN); } static void p_module_ansi_header(vlog_node_t mod) { // { attribute_instance } module_keyword [ lifetime ] module_identifier // { package_import_declaration } [ parameter_port_list ] /// [ list_of_port_declarations ] ; EXTEND("module ANSI header"); if (peek() == tHASH) { p_parameter_port_list(mod); param_kind = V_LOCALPARAM; } if (peek() == tLPAREN) p_list_of_port_declarations(mod); consume(tSEMI); vlog_set_loc(mod, CURRENT_LOC); } static vlog_node_t p_port_reference(void) { // port_identifier constant_select BEGIN("port reference"); vlog_node_t v = vlog_new(V_REF); vlog_set_ident(v, p_identifier()); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_port_expression(void) { // port_reference | { port_reference { , port_reference } } BEGIN("port expression"); return p_port_reference(); } static vlog_node_t p_port(void) { // [ port_expression ] | . port_identifier ( [ port_expression ] ) BEGIN("port"); return p_port_expression(); } static void p_list_of_ports(vlog_node_t mod) { // ( port { , port } ) BEGIN("list of ports"); consume(tLPAREN); do { p_port(); } while (optional(tCOMMA)); consume(tRPAREN); } static void p_module_nonansi_header(vlog_node_t mod) { // { attribute_instance } module_keyword [ lifetime ] module_identifier // { package_import_declaration } [ parameter_port_list ] list_of_ports ; EXTEND("module non-ANSI header"); p_list_of_ports(mod); consume(tSEMI); vlog_set_loc(mod, CURRENT_LOC); } static vlog_node_t p_module_declaration(void) { // module_nonansi_header [ timeunits_declaration ] { module_item } // endmodule [ : module_identifier ] // | module_ansi_header [ timeunits_declaration ] { non_port_module_item } // endmodule [ : module_identifier ] // | { attribute_instance } module_keyword [ lifetime ] module_identifier // ( .* ) ; [ timeunits_declaration ] { module_item } endmodule // [ : module_identifier ] // | extern module_nonansi_header // | extern module_ansi_header BEGIN("module declaration"); vlog_node_t mod = vlog_new(V_MODULE); optional_attributes(); consume(tMODULE); ident_t id, ext; p_external_identifier(&id, &ext); vlog_set_ident2(mod, id); vlog_set_loc(mod, &state.last_loc); ident_t qual = ident_prefix(lib_name(lib_work()), ext, '.'); vlog_set_ident(mod, qual); vlog_symtab_push(symtab, mod); if (peek() == tLPAREN && peek_nth(2) == tID) p_module_nonansi_header(mod); else p_module_ansi_header(mod); while (not_at_token(tENDMODULE)) p_module_item(mod); consume(tENDMODULE); vlog_symtab_pop(symtab); return mod; } static void p_udp_port_list(vlog_node_t udp) { // output_port_identifier , input_port_identifier { , input_port_identifier } BEGIN("UDP port list"); vlog_node_t oref = vlog_new(V_REF); vlog_set_ident(oref, p_identifier()); vlog_set_loc(oref, &state.last_loc); vlog_add_port(udp, oref); consume(tCOMMA); vlog_node_t iref = vlog_new(V_REF); vlog_set_ident(iref, p_identifier()); vlog_set_loc(iref, &state.last_loc); vlog_add_port(udp, iref); while (optional(tCOMMA)) { vlog_node_t iref = vlog_new(V_REF); vlog_set_ident(iref, p_identifier()); vlog_set_loc(iref, &state.last_loc); vlog_add_port(udp, iref); } } static vlog_node_t p_udp_nonansi_declaration(void) { // { attribute_instance } primitive udp_identifier ( udp_port_list ) ; BEGIN("UDP non-ANSI declaration"); vlog_node_t udp = vlog_new(V_PRIMITIVE); consume(tPRIMITIVE); ident_t id, ext; p_external_identifier(&id, &ext); vlog_set_ident2(udp, id); ident_t qual = ident_prefix(lib_name(lib_work()), ext, '.'); vlog_set_ident(udp, qual); consume(tLPAREN); p_udp_port_list(udp); consume(tRPAREN); consume(tSEMI); vlog_set_loc(udp, CURRENT_LOC); return udp; } static void p_list_of_udp_port_identifiers(vlog_node_t udp, v_port_kind_t kind) { // port_identifier { , port_identifier } BEGIN("list of UDP port identifiers"); do { ident_t id, ext; p_external_identifier(&id, &ext); vlog_node_t p = vlog_new(V_PORT_DECL); vlog_set_subkind(p, kind); vlog_set_ident(p, id); vlog_set_ident2(p, ext); vlog_set_type(p, logic_type()); vlog_set_loc(p, &state.last_loc); vlog_add_decl(udp, p); vlog_symtab_put(symtab, p); } while (optional(tCOMMA)); } static void p_udp_output_declaration(vlog_node_t udp, bool *has_reg) { // { attribute_instance } output port_identifier // | { attribute_instance } output reg port_identifier // [ = constant_expression ] BEGIN("UDP output declaration"); consume(tOUTPUT); const bool isreg = optional(tREG); ident_t id, ext; p_external_identifier(&id, &ext); vlog_node_t logic = logic_type(); vlog_node_t v = vlog_new(V_PORT_DECL); vlog_set_subkind(v, V_PORT_OUTPUT); vlog_set_ident(v, id); vlog_set_ident2(v, ext); vlog_set_type(v, logic); vlog_set_loc(v, &state.last_loc); vlog_add_decl(udp, v); vlog_symtab_put(symtab, v); if (isreg) { vlog_node_t reg = vlog_new(V_VAR_DECL); vlog_set_loc(reg, &state.last_loc); vlog_set_ident(reg, id); vlog_set_type(reg, logic); vlog_add_decl(udp, reg); vlog_symtab_put(symtab, reg); *has_reg = true; } } static void p_udp_input_declaration(vlog_node_t udp) { // { attribute_instance } input list_of_udp_port_identifiers BEGIN("UDP input declaration"); consume(tINPUT); p_list_of_udp_port_identifiers(udp, V_PORT_INPUT); } static vlog_node_t p_udp_reg_declaration(void) { // { attribute_instance } reg variable_identifier BEGIN("UDP reg declaration"); consume(tREG); ident_t id = p_identifier(); vlog_node_t reg = vlog_new(V_VAR_DECL); vlog_set_loc(reg, &state.last_loc); vlog_set_ident(reg, id); vlog_set_type(reg, logic_type()); return reg; } static void p_udp_port_declaration(vlog_node_t udp, bool *has_reg) { // udp_output_declaration ; | udp_input_declaration ; | udp_reg_declaration ; BEGIN("UDP port declaration"); switch (peek()) { case tOUTPUT: p_udp_output_declaration(udp, has_reg); break; case tINPUT: p_udp_input_declaration(udp); break; case tREG: { vlog_node_t v = p_udp_reg_declaration(); vlog_add_decl(udp, v); vlog_symtab_put(symtab, v); *has_reg = true; } break; default: one_of(tOUTPUT, tINPUT, tREG); break; } consume(tSEMI); } static void p_udp_declaration_port_list(vlog_node_t udp, bool *has_reg) { // udp_output_declaration , udp_input_declaration { , udp_input_declaration } BEGIN("UDP declaration port list"); p_udp_output_declaration(udp, has_reg); consume(tCOMMA); do { p_udp_input_declaration(udp); } while (optional(tCOMMA)); const int ndecls = vlog_decls(udp); for (int i = 0; i < ndecls; i++) { vlog_node_t p = vlog_decl(udp, i); if (vlog_kind(p) != V_PORT_DECL) continue; vlog_node_t ref = vlog_new(V_REF); vlog_set_loc(ref, vlog_loc(p)); vlog_set_ident(ref, vlog_ident(p)); vlog_set_ref(ref, p); vlog_add_port(udp, ref); } } static vlog_node_t p_output_symbol(void) { // 0 | 1 | x | X BEGIN("output symbol"); vlog_node_t v = vlog_new(V_UDP_LEVEL); vlog_set_subkind(v, V_UDP_SYMBOL_OUTPUT); if (consume(tUDPLEVEL)) { switch (state.last_lval.i64) { case '0': case '1': case 'x': case 'X': vlog_set_ival(v, state.last_lval.i64); break; default: parse_error(&state.last_loc, "'%c' is not a valid output symbol", (char)state.last_lval.i64); break; } } vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_level_symbol(void) { // 0 | 1 | x | X | ? | b | B BEGIN("level symbol"); consume(tUDPLEVEL); vlog_node_t v = vlog_new(V_UDP_LEVEL); vlog_set_subkind(v, V_UDP_SYMBOL_INPUT); vlog_set_ival(v, state.last_lval.i64); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_next_state(void) { // output_symbol | - BEGIN("next state"); switch (peek()) { case tMINUS: consume(tMINUS); break; case tUDPLEVEL: return p_output_symbol(); default: one_of(tUDPLEVEL, tMINUS); } vlog_node_t v = vlog_new(V_UDP_LEVEL); vlog_set_subkind(v, V_UDP_SYMBOL_OUTPUT); vlog_set_ival(v, '-'); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_edge_symbol(void) { // r | R | f | F | p | P | n | N | * BEGIN("edge symbol"); consume(tUDPEDGE); char left, right; switch (state.last_lval.i64) { case 'r': case 'R': left = '0'; right = '1'; break; case 'f': case 'F': left = '1'; right = '0'; break; case 'p': case 'P': left = 'p'; right = 'p'; break; case 'n': case 'N': left = 'n'; right = 'N'; break; case '*': left = '?'; right = '?'; break; } vlog_node_t lsym = vlog_new(V_UDP_LEVEL); vlog_set_ival(lsym, left); vlog_node_t rsym = vlog_new(V_UDP_LEVEL); vlog_set_ival(rsym, right); vlog_node_t v = vlog_new(V_UDP_EDGE); vlog_set_subkind(v, V_UDP_SYMBOL_INPUT); vlog_set_left(v, lsym); vlog_set_right(v, rsym); vlog_set_loc(v, CURRENT_LOC); return v; } static void p_level_input_list(vlog_node_t entry) { // level_symbol { level_symbol } BEGIN("level input list"); do { vlog_add_param(entry, p_level_symbol()); } while (not_at_token(tCOLON)); } static vlog_node_t p_edge_indicator(void) { // ( level_symbol level_symbol ) | edge_symbol BEGIN("edge indicator"); switch (peek()) { case tUDPEDGE: return p_edge_symbol(); case tLPAREN: { consume(tLPAREN); vlog_node_t v = vlog_new(V_UDP_EDGE); vlog_set_left(v, p_level_symbol()); vlog_set_right(v, p_level_symbol()); consume(tRPAREN); vlog_set_loc(v, CURRENT_LOC); return v; } break; default: should_not_reach_here(); } } static void p_seq_input_list(vlog_node_t entry) { // level_input_list | edge_input_list BEGIN("sequential input list"); bool have_edge = false; do { switch (peek()) { case tUDPEDGE: case tLPAREN: vlog_add_param(entry, p_edge_indicator()); if (have_edge) parse_error(&state.last_loc, "a sequential input list may have at " "most one edge indicator"); have_edge = true; break; case tUDPLEVEL: vlog_add_param(entry, p_level_symbol()); break; default: one_of(tUDPEDGE, tUDPIND, tUDPLEVEL); break; } } while (not_at_token(tCOLON)); } static vlog_node_t p_combinational_entry(void) { // level_input_list : output_symbol ; BEGIN("combinational entry"); vlog_node_t v = vlog_new(V_UDP_ENTRY); p_level_input_list(v); consume(tCOLON); vlog_add_param(v, p_output_symbol()); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_combinational_body(void) { // table combinational_entry { combinational_entry } endtable BEGIN("combinational UDP body"); consume(tTABLE); scan_as_udp(); vlog_node_t v = vlog_new(V_UDP_TABLE); vlog_set_subkind(v, V_UDP_COMB); vlog_set_ident(v, ident_new("combinational")); do { vlog_add_param(v, p_combinational_entry()); } while (not_at_token(tENDTABLE)); scan_as_verilog(); consume(tENDTABLE); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_sequential_entry(void) { // seq_input_list : current_state : next_state ; BEGIN("sequential entry"); vlog_node_t v = vlog_new(V_UDP_ENTRY); p_seq_input_list(v); consume(tCOLON); vlog_add_param(v, p_level_symbol()); consume(tCOLON); vlog_add_param(v, p_next_state()); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_udp_initial_statement(void) { // initial output_port_identifier = init_val ; BEGIN("UDP initial statement"); consume(tINITIAL); vlog_node_t ref = vlog_new(V_REF); vlog_set_ident(ref, p_identifier()); vlog_set_loc(ref, &state.last_loc); vlog_symtab_lookup(symtab, ref); consume(tEQ); vlog_node_t v = vlog_new(V_BASSIGN); vlog_set_target(v, ref); vlog_set_value(v, p_integral_number()); consume(tSEMI); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_sequential_body(void) { // [ udp_initial_statement ] table sequential_entry // { sequential_entry } endtable BEGIN("sequential UDP body"); vlog_node_t v = vlog_new(V_UDP_TABLE); vlog_set_subkind(v, V_UDP_SEQ); vlog_set_ident(v, ident_new("sequential")); if (peek() == tINITIAL) vlog_add_stmt(v, p_udp_initial_statement()); consume(tTABLE); scan_as_udp(); do { vlog_add_param(v, p_sequential_entry()); } while (not_at_token(tENDTABLE)); scan_as_verilog(); consume(tENDTABLE); vlog_set_loc(v, CURRENT_LOC); return v; } static vlog_node_t p_udp_body(bool has_reg) { // combinational_body | sequential_body BEGIN("UDP body"); if (has_reg) return p_sequential_body(); else return p_combinational_body(); } static vlog_node_t p_udp_ansi_declaration(bool *has_reg) { // { attribute_instance } primitive udp_identifier // ( udp_declaration_port_list ) ; BEGIN("UDP ANSI declaration"); optional_attributes(); vlog_node_t udp = vlog_new(V_PRIMITIVE); consume(tPRIMITIVE); ident_t id, ext; p_external_identifier(&id, &ext); vlog_set_ident2(udp, id); ident_t qual = ident_prefix(lib_name(lib_work()), ext, '.'); vlog_set_ident(udp, qual); vlog_symtab_push(symtab, udp); consume(tLPAREN); p_udp_declaration_port_list(udp, has_reg); consume(tRPAREN); consume(tSEMI); vlog_set_loc(udp, CURRENT_LOC); return udp; } static vlog_node_t p_udp_declaration(void) { // udp_nonansi_declaration udp_port_declaration { udp_port_declaration } // udp_body endprimitive [ : udp_identifier ] // | udp_ansi_declaration udp_body endprimitive [ : udp_identifier ] // | extern udp_nonansi_declaration // | extern udp_ansi_declaration // | { attribute_instance } primitive udp_identifier ( .* ) ; // { udp_port_declaration } udp_body endprimitive [ : udp_identifier ] BEGIN("UDP declaration"); bool has_reg = false; vlog_node_t udp; if (peek_nth(4) == tID) { udp = p_udp_nonansi_declaration(); vlog_symtab_push(symtab, udp); do { p_udp_port_declaration(udp, &has_reg); } while (not_at_token(tTABLE, tINITIAL)); const int nports = vlog_ports(udp); for (int i = 0; i < nports; i++) vlog_symtab_lookup(symtab, vlog_port(udp, i)); } else udp = p_udp_ansi_declaration(&has_reg); vlog_add_stmt(udp, p_udp_body(has_reg)); vlog_symtab_pop(symtab); consume(tENDPRIMITIVE); return udp; } static vlog_node_t p_description(void) { // module_declaration | udp_declaration | interface_declaration // | program_declaration | package_declaration // | { attribute_instance } package_item // | { attribute_instance } bind_directive // | config_declaration BEGIN("description"); skip_over_attributes(); switch (peek()) { case tMODULE: return p_module_declaration(); case tPRIMITIVE: return p_udp_declaration(); default: expect(tPRIMITIVE, tMODULE); return NULL; } } static void p_timescale_compiler_directive(void) { // `timescale time_unit / time_precision BEGIN("timescale compiler directive"); consume(tTIMESCALE); consume(tUNSIGNED); char *unit_value LOCAL = state.last_lval.str; consume(tID); char *unit_name LOCAL = state.last_lval.str; consume(tOVER); consume(tUNSIGNED); char *prec_value LOCAL = state.last_lval.str; consume(tID); char *prec_name LOCAL = state.last_lval.str; set_timescale(unit_value, unit_name, prec_value, prec_name, CURRENT_LOC); } static void p_defaultnettype_compiler_directive(void) { // `default_nettype wire | tri | tri0 | tri1 | wand | triand | wor // | trior | trireg | uwire | none BEGIN("default_nettype directive"); consume(tDEFNETTYPE); switch (one_of(tWIRE, tTRI, tTRI0, tTRI1, tWAND, tTRIAND, tWOR, tTRIOR, tTRIREG, tUWIRE, tNONE)) { case tWIRE: implicit_kind = V_NET_WIRE; break; case tNONE: implicit_kind = V_NET_NONE; break; } } static void p_keywords_directive(void) { // `begin_keywords "version_specifier" BEGIN("keywords directive"); consume(tBEGINKEYWORDS); consume(tSTRING); free(state.last_lval.str); } static void p_endkeywords_directive(void) { // `end_keywords BEGIN("endkeywords directive"); consume(tENDKEYWORDS); } static void p_resetall_directive(void) { // `resetall BEGIN("resetall directive"); consume(tRESETALL); implicit_kind = V_NET_WIRE; } static void p_directive_list(void) { BEGIN("directive list"); for (;;) { switch (peek()) { case tDEFNETTYPE: p_defaultnettype_compiler_directive(); break; case tTIMESCALE: p_timescale_compiler_directive(); break; case tBEGINKEYWORDS: p_keywords_directive(); break; case tENDKEYWORDS: p_endkeywords_directive(); break; case tRESETALL: p_resetall_directive(); break; default: return; } } } static vlog_node_t end_of_file(void) { vlog_symtab_pop(symtab); vlog_symtab_free(symtab); symtab = NULL; return NULL; } vlog_node_t vlog_parse(void) { state.n_correct = RECOVER_THRESH; param_kind = V_PARAM_DECL; scan_as_verilog(); if (symtab == NULL) { symtab = vlog_symtab_new(); vlog_symtab_push(symtab, NULL); // Compilation unit scope vlog_symtab_poison(symtab, error_marker()); } if (peek() == tEOF) return end_of_file(); p_directive_list(); make_new_arena(); if (peek() == tEOF) return end_of_file(); return p_description(); } void reset_verilog_parser(void) { state.tokenq_head = state.tokenq_tail = 0; implicit_kind = V_NET_WIRE; last_attr = NULL; if (symtab != NULL) { vlog_symtab_free(symtab); symtab = NULL; } } nvc-r1.17.1/src/vlog/vlog-phase.h000066400000000000000000000024511504111170000165150ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_PHASE_H #define _VLOG_PHASE_H #include "prim.h" void vlog_preprocess(text_buf_t *tb, bool precise); vlog_node_t vlog_parse(void); void vlog_check(vlog_node_t v); void vlog_dump(vlog_node_t v, int indent); void vlog_simp(vlog_node_t mod); void vlog_trans(vlog_node_t mod, tree_t out); void vlog_lower_deferred(mir_unit_t *mu, object_t *obj); void vlog_lower_udp(mir_unit_t *mu, object_t *obj); void vlog_lower_block(mir_context_t *mc, ident_t parent, tree_t b); vlog_node_t vlog_new_instance(vlog_node_t mod, vlog_node_t inst, ident_t prefix); #endif // _VLOG_PHASE_H nvc-r1.17.1/src/vlog/vlog-pp.l000066400000000000000000000227661504111170000160530ustar00rootroot00000000000000/* -*- mode: c; c-basic-offset: 3 -*- */ /* * Copyright (C) 2023-2024 Nick Gasson * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ %option prefix="vlogpp_" %option noyywrap %option nounput %option noinput %{ #include "util.h" #include "array.h" #include "diag.h" #include "hash.h" #include "option.h" #include "scan.h" #include "vlog/vlog-phase.h" #include #define YY_INPUT(buf, result, max_size) { \ result = get_next_char(buf, max_size); \ if (result <= 0) \ result = YY_NULL; \ } #define YY_USER_ACTION convert_line_ending(); typedef struct _ifdef_stack ifdef_stack_t; struct _ifdef_stack { ifdef_stack_t *next; loc_t loc; }; typedef A(YY_BUFFER_STATE) buffer_stack_t; static int comment_caller = 0; static shash_t *macros; static char *macro_name; static text_buf_t *macro_text; static text_buf_t *output; static ifdef_stack_t *ifdefs = NULL; static buffer_stack_t buffer_stack = AINIT; static bool emit_locs; static bool continuation = false; static void define_macro(void); static void undef_macro(void); static void push_ifdef(void); static void pop_ifdef(void); static void convert_line_ending(void); static void push_macro(const char *name, const char *text); static void pop_buffer(void); extern loc_t yylloc; %} ID [a-zA-Z_]([a-zA-Z0-9_$])* %x COMMENT C_COMMENT MACRO_NAME MACRO_TEXT IFDEF_NAME IFDEF_TRUE IFDEF_FALSE %x IFNDEF_NAME %% "//"[^\r\n]* { tb_cat(output, vlogpp_text); } "/*" { comment_caller = YY_START; tb_cat(output, vlogpp_text); BEGIN(C_COMMENT); } [^\r\n] { tb_cat(output, vlogpp_text); } \n\r | \r\n | \n | \r { tb_append(output, '\n'); } "*/" { tb_cat(output, vlogpp_text); BEGIN(comment_caller); } `define[ \t]* { BEGIN(MACRO_NAME); } `ifdef[ \t]* { push_ifdef(); BEGIN(IFDEF_NAME); } `ifndef[ \t]* { push_ifdef(); BEGIN(IFNDEF_NAME); } `endif { pop_ifdef(); BEGIN(INITIAL); } `else { if (ifdefs == NULL) error_at(&yylloc, "`else outside of `ifdef"); BEGIN(IFDEF_FALSE); } `undef[ \t]+{ID}[ \t]* { undef_macro(); } `__FILE__ { tb_cat(output, loc_file_str(&yylloc)); } `__LINE__ { tb_printf(output, "%d", yylloc.first_line); } `timescale | `default_nettype | `resetall | `pragma | `begin_keywords | `end_keywords | `celldefine | `endcelldefine { tb_cat(output, vlogpp_text); } `{ID} { const char *text = shash_get(macros, vlogpp_text + 1); if (text != NULL) push_macro(vlogpp_text + 1, text); else warn_at(&yylloc, "macro %s undefined", vlogpp_text + 1); } {ID}[ \t]* { macro_name = xstrdup(vlogpp_text); tb_rewind(macro_text); BEGIN(MACRO_TEXT); } . { error_at(&yylloc, "expected macro name after " "`define"); BEGIN(INITIAL); } {ID} { if (shash_get(macros, vlogpp_text) != NULL) BEGIN(INITIAL); else BEGIN(IFDEF_FALSE); } . { error_at(&yylloc, "expected macro name after `ifdef"); pop_ifdef(); BEGIN(INITIAL); } {ID} { if (shash_get(macros, vlogpp_text) == NULL) BEGIN(INITIAL); else BEGIN(IFDEF_FALSE); } . { error_at(&yylloc, "expected macro name after " "`ifndef"); pop_ifdef(); BEGIN(INITIAL); } `else { assert(ifdefs != NULL); BEGIN(INITIAL); } `endif { pop_ifdef(); BEGIN(INITIAL); } [^\r\n] { } \n\r | \r\n | \n | \r { tb_append(output, '\n'); } \\ { continuation = true; } [^\r\n] { if (continuation) { tb_append(macro_text, '\\'); continuation = false; } tb_cat(macro_text, vlogpp_text); } \n\r | \r\n | \n | \r { if (continuation) { tb_append(macro_text, '\n'); tb_append(output, '\n'); continuation = false; } else { define_macro(); tb_cat(output, vlogpp_text); BEGIN(INITIAL); } } [^\r\n] { tb_cat(output, vlogpp_text); } \n\r | \r\n | \n | \r { tb_append(output, '\n'); } <> { if (buffer_stack.count > 0) pop_buffer(); else yyterminate(); } %% static void strip_whitespace(char *s) { char *p = s + strlen(s); while (p > s && isspace_iso88591(p[-1])) *(--p) = '\0'; } static void convert_line_ending(void) { if (vlogpp_leng >= 2) { char *c1 = vlogpp_text + vlogpp_leng - 1; char *c2 = vlogpp_text + vlogpp_leng - 2; if (*c1 == '\n' && *c2 == '\r') { *c1 = '\0'; *c2 = '\n'; vlogpp_leng--; } else if (*c1 == '\r' && *c2 == '\n') { *c1 = '\0'; vlogpp_leng--; } } begin_token(vlogpp_text, vlogpp_leng); } static void define_macro(void) { char *copy = xstrdup(tb_get(macro_text)); strip_whitespace(macro_name); strip_whitespace(copy); shash_put(macros, macro_name, copy); macro_name = NULL; tb_rewind(macro_text); } static void undef_macro(void) { char *s = yytext + sizeof("`undef"); while (*s == ' ' || *s == '\t') s++; strip_whitespace(s); shash_delete(macros, s); } static void push_ifdef(void) { ifdef_stack_t *s = xcalloc(sizeof(ifdef_stack_t)); s->next = ifdefs; s->loc = yylloc; ifdefs = s; } static void pop_ifdef(void) { if (ifdefs == NULL) error_at(&yylloc, "`endif outside of `ifdef"); else { ifdef_stack_t *tmp = ifdefs->next; free(ifdefs); ifdefs = tmp; } } static void push_macro(const char *name, const char *text) { if (emit_locs) tb_printf(output, "\n`__nvc_push %s,%d:%d,%d\n", name, yylloc.first_line, yylloc.first_column, yylloc.column_delta); APUSH(buffer_stack, YY_CURRENT_BUFFER); yy_switch_to_buffer(yy_scan_string(text)); } static void pop_buffer(void) { assert(buffer_stack.count > 0); if (emit_locs) tb_printf(output, "\n`__nvc_pop\n"); yy_delete_buffer(YY_CURRENT_BUFFER); yy_switch_to_buffer(APOP(buffer_stack)); } static void vlog_define_cb(const char *key, const char *value, void *ctx) { shash_put(macros, key, (void *)value); } void vlog_preprocess(text_buf_t *tb, bool precise) { if (macros == NULL) { macros = shash_new(64); pp_defines_iter(vlog_define_cb, NULL); } else assert(opt_get_int(OPT_SINGLE_UNIT)); assert(macro_text == NULL); macro_text = tb_new(); assert(output == NULL); output = tb; assert(ifdefs == NULL); emit_locs = precise; continuation = false; YY_FLUSH_BUFFER; BEGIN(INITIAL); vlogpp_lex(); output = NULL; while (ifdefs != NULL) { error_at(&(ifdefs->loc), "no corresponding `endif before end of file"); pop_ifdef(); } if (!opt_get_int(OPT_SINGLE_UNIT)) { shash_free(macros); macros = NULL; } free(macro_name); macro_name = NULL; tb_free(macro_text); macro_text = NULL; assert(buffer_stack.count == 0); ACLEAR(buffer_stack); } nvc-r1.17.1/src/vlog/vlog-sem.c000066400000000000000000000314101504111170000161710ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include #include static void name_for_diag(diag_t *d, vlog_node_t v, const char *alt) { switch (vlog_kind(v)) { case V_REF: diag_printf(d, "'%s'", istr(vlog_ident(v))); break; default: diag_printf(d, "%s", alt); break; } } static bool has_error(vlog_node_t v) { switch (vlog_kind(v)) { case V_REF: case V_USER_FCALL: case V_USER_TCALL: if (vlog_has_ref(v)) return false; else { assert(error_count() > 0); return true; } case V_PORT_DECL: if (vlog_has_ref(v)) return false; else return true; // XXX: check this default: return false; } } static bool constant_equal(vlog_node_t a, vlog_node_t b) { const vlog_kind_t kind = vlog_kind(a); if (kind != vlog_kind(b)) return false; if (has_error(a) || has_error(b)) return true; // Suppress cascading errors switch (kind) { case V_NUMBER: { number_t an = vlog_number(a); number_t bn = vlog_number(b); return number_equal(an, bn); } case V_BINARY: return vlog_subkind(a) == vlog_subkind(b) && constant_equal(vlog_left(a), vlog_left(b)) && constant_equal(vlog_right(a), vlog_right(b)); case V_REF: return vlog_ref(a) == vlog_ref(b); default: return false; } } static void vlog_check_const_expr(vlog_node_t expr) { switch (vlog_kind(expr)) { case V_NUMBER: break; case V_REF: if (vlog_has_ref(expr)) { vlog_node_t decl = vlog_ref(expr); switch (vlog_kind(decl)) { case V_PARAM_DECL: case V_LOCALPARAM: break; default: { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(expr)); diag_printf(d, "cannot reference %s '%s' in constant expression", vlog_is_net(decl) ? "net" : "variable", istr(vlog_ident(decl))); diag_hint(d, vlog_loc(decl), "%s declared here", istr(vlog_ident(decl))); diag_emit(d); } break; } } break; case V_COND_EXPR: vlog_check_const_expr(vlog_value(expr)); // Fall-through case V_BINARY: vlog_check_const_expr(vlog_left(expr)); vlog_check_const_expr(vlog_right(expr)); break; case V_UNARY: vlog_check_const_expr(vlog_value(expr)); break; case V_BIT_SELECT: { const int nparams = vlog_params(expr); for (int i = 0; i < nparams; i++) vlog_check_const_expr(vlog_param(expr, i)); } break; default: error_at(vlog_loc(expr), "expression is not a constant"); break; } } static void vlog_check_variable_target(vlog_node_t target) { if (vlog_is_net(target)) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(target)); name_for_diag(d, target, "target"); diag_printf(d, " cannot be assigned in a procedural block"); diag_emit(d); } } static void vlog_check_nbassign(vlog_node_t stmt) { vlog_node_t target = vlog_target(stmt); vlog_check_variable_target(target); } static void vlog_check_bassign(vlog_node_t stmt) { vlog_node_t target = vlog_target(stmt); vlog_check_variable_target(target); } static void vlog_check_net_lvalue(vlog_node_t v, vlog_node_t where) { switch (vlog_kind(v)) { case V_NET_DECL: break; case V_PORT_DECL: if (vlog_has_ref(v)) vlog_check_net_lvalue(vlog_ref(v), where); break; case V_REF: if (vlog_has_ref(v)) vlog_check_net_lvalue(vlog_ref(v), v); break; case V_BIT_SELECT: case V_PART_SELECT: vlog_check_net_lvalue(vlog_value(v), v); break; case V_CONCAT: { const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) { vlog_node_t p = vlog_param(v, i); vlog_check_net_lvalue(p, p); } } break; default: { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(where)); name_for_diag(d, where, "target"); diag_suppress(d, has_error(where)); diag_printf(d, " cannot be driven by continuous assignment"); diag_emit(d); } } } static void vlog_check_assign(vlog_node_t stmt) { vlog_node_t target = vlog_target(stmt); vlog_check_net_lvalue(target, target); } static void vlog_check_consistent(vlog_node_t a, vlog_node_t b) { vlog_node_t at = vlog_type(a); vlog_node_t bt = vlog_type(b); if (at == bt) return; const int aranges = vlog_ranges(at); assert(aranges == vlog_ranges(bt)); for (int i = 0; i < aranges; i++) { vlog_node_t ar = vlog_range(at, i); vlog_node_t br = vlog_range(bt, i); vlog_node_t aleft = vlog_left(ar); vlog_node_t bleft = vlog_left(br); vlog_node_t aright = vlog_right(ar); vlog_node_t bright = vlog_right(br); if (!constant_equal(aleft, bleft) || !constant_equal(aright, bright)) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(br)); diag_printf(d, "inconsistent dimensions for '%s'", istr(vlog_ident(b))); diag_hint(d, vlog_loc(a), "earlier declaration here"); diag_emit(d); } } } static void vlog_check_port_decl(vlog_node_t port) { vlog_check_consistent(port, vlog_ref(port)); } static void vlog_check_primitive(vlog_node_t udp) { const int nports = vlog_ports(udp); for (int i = 0; i < nports; i++) { vlog_node_t p = vlog_port(udp, i); if (vlog_has_ref(p)) { vlog_node_t decl = vlog_ref(p); assert(vlog_kind(decl) == V_PORT_DECL); if (i == 0 && vlog_subkind(decl) != V_PORT_OUTPUT) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(p)); diag_printf(d, "the first port of a primitive must be an output"); diag_hint(d, vlog_loc(decl), "port declaration here"); diag_emit(d); } else if (i > 0 && vlog_subkind(decl) != V_PORT_INPUT) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(p)); diag_printf(d, "all ports of a primitive except the first must " "be inputs"); diag_hint(d, vlog_loc(decl), "port declaration here"); diag_emit(d); } } } assert(vlog_stmts(udp) == 1); vlog_node_t table = vlog_stmt(udp, 0); assert(vlog_kind(table) == V_UDP_TABLE); const vlog_udp_kind_t kind = vlog_subkind(table); const int expect = kind == V_UDP_SEQ ? nports + 1 : nports; const int nparams = vlog_params(table); for (int i = 0; i < nparams; i++) { vlog_node_t row = vlog_param(table, i); assert(vlog_kind(row) == V_UDP_ENTRY); const int nsymbols = vlog_params(row); if (nsymbols != expect) { error_at(vlog_loc(row), "expected %d symbols in UDP table entry but " "have %d", expect, nsymbols); break; } } } static void vlog_check_dimension(vlog_node_t v) { vlog_node_t left = vlog_left(v); vlog_check_const_expr(left); vlog_node_t right = vlog_right(v); vlog_check_const_expr(right); } static void vlog_check_part_select(vlog_node_t v) { if (vlog_subkind(v) == V_RANGE_CONST) { vlog_node_t left = vlog_left(v); vlog_check_const_expr(left); } vlog_node_t right = vlog_right(v); vlog_check_const_expr(right); } static void vlog_check_localparam(vlog_node_t decl) { if (!vlog_has_value(decl)) error_at(vlog_loc(decl), "local parameter declaration must have a " "default value"); } static void vlog_check_case(vlog_node_t v) { bool seen_default = false; const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) { vlog_node_t item = vlog_stmt(v, i); assert(vlog_kind(item) == V_CASE_ITEM); const int nparams = vlog_params(item); if (nparams == 0 && !seen_default) seen_default = true; else if (nparams == 0) error_at(vlog_loc(item), "multiple default statements within a single " "case statement"); } } static void vlog_check_if_generate(vlog_node_t v) { const int nconds = vlog_conds(v); for (int i = 0; i < nconds; i++) { vlog_node_t c = vlog_cond(v, i); assert(vlog_kind(c) == V_COND); if (vlog_has_value(c)) { vlog_node_t value = vlog_value(c); vlog_check_const_expr(value); } } } static void vlog_check_call_args(vlog_node_t v, vlog_node_t sub) { const int nparams = vlog_params(v); const int nports = vlog_ports(sub); if (nparams != nports) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(v)); diag_printf(d, "expected %d argument%s for '%s' but have %d", nports, nports != 1 ? "s" : "", istr(vlog_ident(sub)), nparams); diag_hint(d, vlog_loc(sub), "'%s' declared here", istr(vlog_ident(sub))); diag_emit(d); return; } } static void vlog_check_user_fcall(vlog_node_t v) { vlog_node_t func = vlog_ref(v); if (vlog_kind(func) != V_FUNC_DECL) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(v)); diag_printf(d, "'%s' is not a function", istr(vlog_ident(func))); diag_hint(d, vlog_loc(func), "'%s' declared here", istr(vlog_ident(func))); diag_emit(d); return; } vlog_check_call_args(v, func); } static void vlog_check_user_tcall(vlog_node_t v) { vlog_node_t func = vlog_ref(v); if (vlog_kind(func) != V_TASK_DECL) { diag_t *d = diag_new(DIAG_ERROR, vlog_loc(v)); diag_printf(d, "'%s' is not a task", istr(vlog_ident(func))); diag_hint(d, vlog_loc(func), "'%s' declared here", istr(vlog_ident(func))); diag_emit(d); return; } vlog_check_call_args(v, func); } static vlog_node_t vlog_check_cb(vlog_node_t v, void *ctx) { if (has_error(v)) return v; switch (vlog_kind(v)) { case V_MODULE: break; case V_PRIMITIVE: vlog_check_primitive(v); break; case V_NBASSIGN: vlog_check_nbassign(v); break; case V_BASSIGN: vlog_check_bassign(v); break; case V_ASSIGN: vlog_check_assign(v); break; case V_PORT_DECL: vlog_check_port_decl(v); break; case V_DIMENSION: vlog_check_dimension(v); break; case V_PART_SELECT: vlog_check_part_select(v); break; case V_LOCALPARAM: vlog_check_localparam(v); break; case V_CASE: vlog_check_case(v); break; case V_IF_GENERATE: vlog_check_if_generate(v); break; case V_USER_FCALL: vlog_check_user_fcall(v); break; case V_USER_TCALL: vlog_check_user_tcall(v); break; case V_CASE_ITEM: case V_UDP_LEVEL: case V_UDP_EDGE: case V_UDP_ENTRY: case V_UDP_TABLE: case V_GATE_INST: case V_ENUM_NAME: case V_ENUM_DECL: case V_STRUCT_DECL: case V_UNION_DECL: case V_WAIT: case V_PARAM_DECL: case V_SPECPARAM: case V_FOREVER: case V_REPEAT: case V_TYPE_DECL: case V_DATA_TYPE: case V_SPECIFY: case V_STRENGTH: case V_NET_DECL: case V_VAR_DECL: case V_PORT_CONN: case V_PARAM_ASSIGN: case V_FUNC_DECL: case V_TASK_DECL: case V_EMPTY: case V_COND_EXPR: case V_CONCAT: case V_FOR_LOOP: case V_FOR_INIT: case V_FOR_STEP: case V_MOD_INST: case V_INST_LIST: case V_ALWAYS: case V_INITIAL: case V_TIMING: case V_EVENT: case V_EVENT_CONTROL: case V_DELAY_CONTROL: case V_BLOCK: case V_FORK: case V_SYS_TCALL: case V_SYS_FCALL: case V_NUMBER: case V_STRING: case V_REAL: case V_IF: case V_BINARY: case V_UNARY: case V_REF: case V_COND: case V_PREFIX: case V_POSTFIX: case V_BIT_SELECT: case V_VOID_CALL: case V_GENVAR_DECL: case V_FOR_GENERATE: break; default: fatal_at(vlog_loc(v), "cannot check verilog node %s", vlog_kind_str(vlog_kind(v))); } return v; } void vlog_check(vlog_node_t v) { assert(is_top_level(v)); vlog_rewrite(v, vlog_check_cb, NULL); } nvc-r1.17.1/src/vlog/vlog-simp.c000066400000000000000000000215641504111170000163660ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include #include #include #include static vlog_node_t simp_net_decl(vlog_node_t decl, vlog_node_t mod) { const vlog_net_kind_t kind = vlog_subkind(decl); if (kind == V_NET_SUPPLY0 || kind == V_NET_SUPPLY1) { vlog_node_t g = vlog_new(V_GATE_INST); vlog_set_loc(g, vlog_loc(decl)); ident_t name = vlog_ident(decl); ident_t id = ident_prefix(name, ident_new("pull"), '#'); vlog_set_ident(g, id); vlog_node_t s = vlog_new(V_STRENGTH); vlog_set_subkind(s, ST_SUPPLY); vlog_add_param(g, s); if (kind == V_NET_SUPPLY0) vlog_set_subkind(g, V_GATE_PULLDOWN); else vlog_set_subkind(g, V_GATE_PULLUP); vlog_node_t target = vlog_new(V_REF); vlog_set_loc(target, vlog_loc(decl)); vlog_set_ident(target, name); vlog_set_ref(target, decl); vlog_set_target(g, target); vlog_add_stmt(mod, g); } if (vlog_has_value(decl)) { vlog_node_t value = vlog_value(decl); vlog_set_value(decl, NULL); ident_t id = vlog_ident(decl); const loc_t *loc = vlog_loc(decl); vlog_node_t ref = vlog_new(V_REF); vlog_set_ref(ref, decl); vlog_set_ident(ref, id); vlog_set_loc(ref, loc); vlog_node_t a = vlog_new(V_ASSIGN); vlog_set_target(a, ref); vlog_set_value(a, value); vlog_set_loc(a, loc); vlog_set_ident(a, ident_uniq("__assign#%s", istr(id))); vlog_add_stmt(mod, a); } return decl; } static vlog_node_t simp_port_decl(vlog_node_t decl, vlog_node_t mod) { if (vlog_has_ref(decl)) return decl; vlog_node_t wire = vlog_new(V_NET_DECL); vlog_set_subkind(wire, V_NET_WIRE); vlog_set_loc(wire, vlog_loc(decl)); vlog_set_ident(wire, vlog_ident(decl)); vlog_set_type(wire, vlog_type(decl)); vlog_set_ref(decl, wire); vlog_add_decl(mod, wire); return decl; } static void build_sensitivity(vlog_node_t ctrl, vlog_node_t v) { switch (vlog_kind(v)) { case V_NBASSIGN: case V_BASSIGN: case V_UNARY: build_sensitivity(ctrl, vlog_value(v)); break; case V_BINARY: build_sensitivity(ctrl, vlog_left(v)); build_sensitivity(ctrl, vlog_right(v)); break; case V_REF: case V_BIT_SELECT: case V_PART_SELECT: { vlog_node_t e = vlog_new(V_EVENT); vlog_set_subkind(e, V_EVENT_LEVEL); vlog_set_value(e, v); vlog_set_loc(e, vlog_loc(ctrl)); vlog_add_param(ctrl, e); } break; case V_NUMBER: case V_STRING: break; case V_IF: { const int nconds = vlog_conds(v); for (int i = 0; i < nconds; i++) build_sensitivity(ctrl, vlog_cond(v, i)); } break; case V_COND: { if (vlog_has_value(v)) build_sensitivity(ctrl, vlog_value(v)); const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) build_sensitivity(ctrl, vlog_stmt(v, i)); } break; case V_CASE: build_sensitivity(ctrl, vlog_value(v)); // Fall-through case V_CASE_ITEM: case V_BLOCK: { const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) build_sensitivity(ctrl, vlog_stmt(v, i)); } break; case V_CONCAT: case V_SYS_FCALL: case V_SYS_TCALL: case V_USER_FCALL: case V_USER_TCALL: { const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) build_sensitivity(ctrl, vlog_param(v, i)); } break; case V_COND_EXPR: build_sensitivity(ctrl, vlog_value(v)); build_sensitivity(ctrl, vlog_left(v)); build_sensitivity(ctrl, vlog_right(v)); break; default: fatal_at(vlog_loc(v), "cannot handle %s in build_sensitivity", vlog_kind_str(vlog_kind(v))); } } static vlog_node_t simp_timing(vlog_node_t v) { vlog_node_t ctrl = vlog_value(v); if (vlog_kind(ctrl) == V_EVENT_CONTROL && vlog_params(ctrl) == 0) { const int nstmts = vlog_stmts(v); for (int i = 0; i < nstmts; i++) build_sensitivity(ctrl, vlog_stmt(v, i)); if (vlog_params(ctrl) == 0) warn_at(vlog_loc(v), "timing statement has no sensitivities and " "so will never trigger"); } return v; } static vlog_node_t simp_data_type(vlog_node_t v) { switch (vlog_subkind(v)) { case DT_INTEGER: { const loc_t *loc = vlog_loc(v); vlog_node_t left = vlog_new(V_NUMBER); vlog_set_number(left, number_new("31", NULL)); vlog_set_loc(left, loc); vlog_node_t right = vlog_new(V_NUMBER); vlog_set_number(right, number_new("0", NULL)); vlog_set_loc(right, loc); vlog_node_t r = vlog_new(V_DIMENSION); vlog_set_subkind(r, V_DIM_PACKED); vlog_set_left(r, left); vlog_set_right(r, right); vlog_set_loc(r, loc); vlog_set_subkind(v, DT_LOGIC); vlog_add_range(v, r); } break; } return v; } static vlog_node_t simp_ref(vlog_node_t v) { vlog_node_t decl = vlog_ref(v); switch (vlog_kind(decl)) { case V_LOCALPARAM: { vlog_node_t value = vlog_value(decl); if (vlog_kind(value) == V_NUMBER) return value; else return v; } default: return v; } } static vlog_node_t simp_binary(vlog_node_t v) { vlog_node_t left = vlog_left(v); vlog_node_t right = vlog_right(v); if (vlog_kind(left) != V_NUMBER || vlog_kind(right) != V_NUMBER) return v; number_t nleft = vlog_number(left); number_t nright = vlog_number(right); number_t result; switch (vlog_subkind(v)) { case V_BINARY_PLUS: result = number_add(nleft, nright); break; case V_BINARY_MINUS: result = number_sub(nleft, nright); break; case V_BINARY_LOG_EQ: result = number_logical_equal(nleft, nright); break; case V_BINARY_GT: result = number_greater(nleft, nright); break; case V_BINARY_GEQ: result = number_greater_equal(nleft, nright); break; case V_BINARY_LT: result = number_less(nleft, nright); break; case V_BINARY_LEQ: result = number_less_equal(nleft, nright); break; default: return v; } vlog_node_t new = vlog_new(V_NUMBER); vlog_set_loc(new, vlog_loc(v)); vlog_set_number(new, result); return new; } static vlog_node_t simp_unary(vlog_node_t v) { vlog_node_t value = vlog_value(v); if (vlog_kind(value) != V_NUMBER) return v; number_t n = vlog_number(value); number_t result; switch (vlog_subkind(v)) { case V_UNARY_NEG: result = number_negate(n); break; case V_UNARY_IDENTITY: result = n; break; default: return v; } vlog_node_t new = vlog_new(V_NUMBER); vlog_set_loc(new, vlog_loc(v)); vlog_set_number(new, result); return new; } static vlog_node_t simp_if_generate(vlog_node_t v) { const int nconds = vlog_conds(v); for (int i = 0; i < nconds; i++) { vlog_node_t c = vlog_cond(v, i); if (vlog_has_value(c)) { vlog_node_t value = vlog_value(c); if (vlog_kind(value) != V_NUMBER) return v; else if (!number_truthy(vlog_number(value))) continue; } return vlog_stmts(c) == 1 ? vlog_stmt(c, 0) : NULL; } return NULL; // None of the conditions are true } static vlog_node_t vlog_simp_cb(vlog_node_t v, void *context) { switch (vlog_kind(v)) { case V_NET_DECL: return simp_net_decl(v, context); case V_PORT_DECL: return simp_port_decl(v, context); case V_TIMING: return simp_timing(v); case V_DATA_TYPE: return simp_data_type(v); case V_BINARY: return simp_binary(v); case V_UNARY: return simp_unary(v); case V_REF: return simp_ref(v); case V_IF_GENERATE: return simp_if_generate(v); default: return v; } } void vlog_simp(vlog_node_t mod) { assert(is_top_level(mod)); vlog_rewrite(mod, vlog_simp_cb, mod); } nvc-r1.17.1/src/vlog/vlog-symtab.c000066400000000000000000000171371504111170000167160ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-symtab.h" #include #include #define POISON_NODE (vlog_node_t)-1 typedef struct _vlog_scope vlog_scope_t; typedef A(vlog_node_t) node_list_t; typedef struct _vlog_symtab { vlog_scope_t *top; hash_t *scopes; mem_pool_t *pool; vlog_net_kind_t implicit; } vlog_symtab_t; typedef struct { ident_t name; vlog_node_t node; } vlog_symbol_t; typedef struct _vlog_scope { vlog_scope_t *parent; vlog_node_t container; size_t max_symbols; size_t num_symbols; vlog_symbol_t *symbols; node_list_t tfcalls; bool suppress; } vlog_scope_t; vlog_symtab_t *vlog_symtab_new(void) { vlog_symtab_t *st = xcalloc(sizeof(vlog_symtab_t)); st->pool = pool_new(); st->scopes = hash_new(16); st->implicit = V_NET_NONE; return st; } void vlog_symtab_free(vlog_symtab_t *st) { assert(st->top == NULL); pool_free(st->pool); hash_free(st->scopes); free(st); } static vlog_symbol_t *fresh_symbol_for(vlog_symtab_t *st, ident_t name) { vlog_scope_t *s = st->top; assert(s != NULL); assert(is_power_of_2(s->max_symbols)); if (unlikely(s->num_symbols + 1 > s->max_symbols / 2)) { const int old_max = s->max_symbols; s->max_symbols = MAX(s->max_symbols * 2, 8); const vlog_symbol_t *old_symbols = s->symbols; size_t size = s->max_symbols * sizeof(vlog_symbol_t); s->symbols = pool_calloc(st->pool, size); for (int i = 0; i < old_max; i++) { if (old_symbols[i].name != NULL) { int slot = ident_hash(old_symbols[i].name) & (s->max_symbols - 1); for (; ; slot = (slot + 1) & (s->max_symbols - 1)) { if (s->symbols[slot].name == NULL) { s->symbols[slot] = old_symbols[i]; break; } else assert(s->symbols[slot].name != old_symbols[i].name); } } } } for (int slot = ident_hash(name) & (s->max_symbols - 1);; slot = (slot + 1) & (s->max_symbols - 1)) { if (s->symbols[slot].name == name) return &(s->symbols[slot]); else if (s->symbols[slot].name == NULL) { s->symbols[slot].name = name; s->num_symbols++; return &(s->symbols[slot]); } } } static const vlog_symbol_t *symbol_for(vlog_symtab_t *st, ident_t name) { for (vlog_scope_t *s = st->top; s != NULL; s = s->parent) { assert(is_power_of_2(s->max_symbols)); if (s->num_symbols > 0) { for (int slot = ident_hash(name) & (s->max_symbols - 1); s->symbols[slot].name != NULL; slot = (slot + 1) & (s->max_symbols - 1)) { if (s->symbols[slot].name == name) return &(s->symbols[slot]); } } } return NULL; } void vlog_symtab_push(vlog_symtab_t *st, vlog_node_t v) { vlog_scope_t *s = pool_calloc(st->pool, sizeof(vlog_scope_t)); s->parent = st->top; s->container = v; st->top = s; } void vlog_symtab_pop(vlog_symtab_t *st) { assert(st->top != NULL); if (st->top->parent == NULL) { for (int i = 0; i < st->top->tfcalls.count; i++) { vlog_node_t v = st->top->tfcalls.items[i]; ident_t name = vlog_ident(v); error_at(vlog_loc(v), "no visible declaration for %s", istr(name)); vlog_symtab_poison(st, name); } } else { for (int i = 0; i < st->top->tfcalls.count; i++) { vlog_node_t v = st->top->tfcalls.items[i]; const vlog_symbol_t *sym = symbol_for(st, vlog_ident(v)); if (sym != NULL) vlog_set_ref(v, sym->node); else APUSH(st->top->parent->tfcalls, v); } } ACLEAR(st->top->tfcalls); st->top = st->top->parent; } void vlog_symtab_set_implicit(vlog_symtab_t *st, vlog_net_kind_t kind) { st->implicit = kind; } void vlog_symtab_lookup(vlog_symtab_t *st, vlog_node_t v) { if (vlog_has_ref(v)) return; assert(!loc_invalid_p(vlog_loc(v))); ident_t name = vlog_ident(v); const vlog_symbol_t *sym = symbol_for(st, name); if (sym == NULL && st->implicit != V_NET_NONE) { // See 1800-2017 section 6.10 "Implicit declarations" vlog_node_t decl = vlog_new(V_NET_DECL); vlog_set_ident(decl, name); vlog_set_loc(decl, vlog_loc(v)); vlog_set_subkind(decl, V_NET_WIRE); vlog_node_t dt = vlog_new(V_DATA_TYPE); vlog_set_subkind(dt, DT_LOGIC); vlog_set_type(decl, dt); vlog_set_ref(v, decl); assert(vlog_kind(st->top->container) == V_MODULE); vlog_add_decl(st->top->container, decl); fresh_symbol_for(st, name)->node = decl; } else if (sym == NULL) { switch (vlog_kind(v)) { case V_USER_FCALL: case V_USER_TCALL: // May be declared later APUSH(st->top->tfcalls, v); break; default: error_at(vlog_loc(v), "no visible declaration for %s", istr(name)); vlog_symtab_poison(st, name); } } else if (sym->node != POISON_NODE) vlog_set_ref(v, sym->node); } void vlog_symtab_put(vlog_symtab_t *st, vlog_node_t v) { ident_t name = vlog_ident(v); vlog_symbol_t *sym = fresh_symbol_for(st, name); assert(!loc_invalid_p(vlog_loc(v))); if (sym->node == POISON_NODE) return; if (sym->node != NULL && vlog_kind(v) == V_PORT_DECL) { switch (vlog_kind(sym->node)) { case V_VAR_DECL: case V_NET_DECL: if (!vlog_has_ref(v)) { vlog_set_ref(v, sym->node); sym->node = v; return; } break; default: break; } } if (sym->node != NULL) { switch (vlog_kind(sym->node)) { case V_PORT_DECL: if (!vlog_has_ref(sym->node)) { switch (vlog_kind(v)) { case V_VAR_DECL: case V_NET_DECL: vlog_set_ref(sym->node, v); return; default: break; } } default: break; } diag_t *d = diag_new(DIAG_ERROR, vlog_loc(v)); diag_printf(d, "duplicate declaration of %s", istr(name)); diag_hint(d, vlog_loc(sym->node), "%s was previously declared here", istr(name)); diag_hint(d, vlog_loc(v), "duplicate declaration"); diag_suppress(d, name == well_known(W_ERROR) || st->top->suppress); diag_emit(d); } sym->node = v; } void vlog_symtab_poison(vlog_symtab_t *st, ident_t name) { vlog_symbol_t *sym = fresh_symbol_for(st, name); sym->node = POISON_NODE; } vlog_node_t vlog_symtab_query(vlog_symtab_t *st, ident_t name) { const vlog_symbol_t *sym = symbol_for(st, name); if (sym == NULL || sym->node == POISON_NODE) return NULL; return sym->node; } void vlog_symtab_suppress(vlog_symtab_t *st) { st->top->suppress = true; } nvc-r1.17.1/src/vlog/vlog-symtab.h000066400000000000000000000025161504111170000167160ustar00rootroot00000000000000// // Copyright (C) 2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_SYMTAB_H #define _VLOG_SYMTAB_H #include "prim.h" #include "vlog/vlog-node.h" vlog_symtab_t *vlog_symtab_new(void); void vlog_symtab_free(vlog_symtab_t *st); void vlog_symtab_push(vlog_symtab_t *st, vlog_node_t v); void vlog_symtab_pop(vlog_symtab_t *st); void vlog_symtab_set_implicit(vlog_symtab_t *st, vlog_net_kind_t kind); void vlog_symtab_lookup(vlog_symtab_t *st, vlog_node_t v); void vlog_symtab_put(vlog_symtab_t *st, vlog_node_t v); void vlog_symtab_poison(vlog_symtab_t *st, ident_t name); void vlog_symtab_suppress(vlog_symtab_t *st); vlog_node_t vlog_symtab_query(vlog_symtab_t *st, ident_t name); #endif // _VLOG_SYMTAB nvc-r1.17.1/src/vlog/vlog-trans.c000066400000000000000000000206711504111170000165430ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "common.h" #include "diag.h" #include "hash.h" #include "tree.h" #include "type.h" #include "vlog/vlog-defs.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include "vlog/vlog-util.h" #include #define CANNOT_HANDLE(v) do { \ fatal_at(vlog_loc(v), "cannot handle %s in %s" , \ vlog_kind_str(vlog_kind(v)), __FUNCTION__); \ } while (0) typedef struct { tree_t out; hash_t *map; } trans_gen_t; static tree_t trans_expr(trans_gen_t *g, vlog_node_t v) { switch (vlog_kind(v)) { case V_NUMBER: { number_t n = vlog_number(v); type_t std_int = std_type(NULL, STD_INTEGER); tree_t lit = tree_new(T_LITERAL); tree_set_subkind(lit, L_INT); tree_set_type(lit, std_int); if (number_is_defined(n)) tree_set_ival(lit, number_integer(n)); else tree_set_ival(lit, 0); return lit; } case V_REF: { tree_t decl = hash_get(g->map, vlog_ref(v)); if (decl == NULL) fatal_at(vlog_loc(v), "missing VHDL declaration for %s", istr(vlog_ident(v))); if (tree_kind(decl) == T_CONST_DECL && tree_has_value(decl)) { tree_t value = tree_value(decl); if (is_literal(value)) return value; } return make_ref(decl); } case V_BINARY: { tree_t left = trans_expr(g, vlog_left(v)); tree_t right = trans_expr(g, vlog_right(v)); assert(type_eq(tree_type(left), tree_type(right))); type_t std_int = std_type(NULL, STD_INTEGER); if (!type_eq(tree_type(left), std_int)) fatal_at(vlog_loc(v), "only integer expressions are supported"); tree_t t = tree_new(T_FCALL); tree_set_loc(t, vlog_loc(v)); tree_set_type(t, std_int); switch (vlog_subkind(v)) { case V_BINARY_MINUS: tree_set_ident(t, well_known(W_OP_MINUS)); tree_set_ref(t, std_func(ident_new("STD.STANDARD.\"-\"(I)I"))); break; case V_BINARY_PLUS: tree_set_ident(t, well_known(W_OP_ADD)); tree_set_ref(t, std_func(ident_new("STD.STANDARD.\"+\"(I)I"))); break; default: CANNOT_HANDLE(v); } add_param(t, left, P_POS, NULL); add_param(t, right, P_POS, NULL); return t; } default: CANNOT_HANDLE(v); } } static type_t trans_type(trans_gen_t *g, vlog_node_t decl, verilog_type_t scalar_type, verilog_type_t packed_type) { const int nranges = vlog_ranges(decl); if (nranges > 0) { type_t packed = verilog_type(packed_type); tree_t c = tree_new(T_CONSTRAINT); tree_set_subkind(c, C_INDEX); tree_set_loc(c, vlog_loc(decl)); for (int i = 0; i < nranges; i++) { type_t index_type = index_type_of(packed, i); vlog_node_t vr = vlog_range(decl, i); tree_t left = trans_expr(g, vlog_left(vr)); tree_t right = trans_expr(g, vlog_right(vr)); int64_t ileft, iright; const bool left_is_const = folded_int(left, &ileft); const bool right_is_const = folded_int(right, &iright); range_kind_t dir; if (left_is_const && right_is_const) dir = ileft < iright ? RANGE_TO : RANGE_DOWNTO; else if (left_is_const) dir = RANGE_TO; // Heuristic else dir = RANGE_DOWNTO; // Heuristic tree_t r = tree_new(T_RANGE); tree_set_subkind(r, dir); tree_set_left(r, left); tree_set_right(r, right); tree_set_loc(r, vlog_loc(decl)); tree_set_type(r, index_type); tree_add_range(c, r); } type_t sub = type_new(T_SUBTYPE); type_set_base(sub, packed); type_set_constraint(sub, c); return sub; } else return verilog_type(scalar_type); } static type_t trans_var_type(trans_gen_t *g, vlog_node_t v) { vlog_node_t type = vlog_type(v); return trans_type(g, type, VERILOG_LOGIC, VERILOG_LOGIC_ARRAY); } static type_t trans_net_type(trans_gen_t *g, vlog_node_t v) { vlog_node_t type = vlog_type(v); return trans_type(g, type, VERILOG_WIRE, VERILOG_WIRE_ARRAY); } static void trans_port_decl(trans_gen_t *g, vlog_node_t v) { static const port_mode_t map[] = { [V_PORT_INPUT] = PORT_IN, [V_PORT_OUTPUT] = PORT_OUT, [V_PORT_INOUT] = PORT_INOUT, }; const v_port_kind_t kind = vlog_subkind(v); tree_t t = tree_new(T_PORT_DECL); tree_set_ident(t, vlog_ident(v)); tree_set_subkind(t, map[kind]); tree_set_class(t, C_SIGNAL); vlog_node_t net = vlog_ref(v); if (vlog_is_net(net)) { type_t type = trans_net_type(g, net); tree_set_type(t, type); } else { type_t type = trans_var_type(g, net); tree_set_type(t, type); } tree_add_port(g->out, t); } static void trans_param_decl(trans_gen_t *g, vlog_node_t v) { tree_t t = tree_new(T_GENERIC_DECL); tree_set_ident(t, vlog_ident(v)); tree_set_class(t, C_CONSTANT); tree_set_subkind(t, PORT_IN); // XXX: should be integer for untyped only /// tree_set_type(t, trans_var_type(g, v)); tree_set_type(t, std_type(NULL, STD_INTEGER)); tree_add_generic(g->out, t); hash_put(g->map, v, t); } static void trans_localparam(trans_gen_t *g, vlog_node_t v) { tree_t t = tree_new(T_CONST_DECL); tree_set_ident(t, vlog_ident(v)); tree_set_flag(t, TREE_F_GLOBALLY_STATIC); if (vlog_has_value(v)) { tree_t value = trans_expr(g, vlog_value(v)); tree_set_value(t, value); tree_set_type(t, tree_type(value)); } else assert(error_count() > 0); tree_add_decl(g->out, t); hash_put(g->map, v, t); } static void trans_var_decl(trans_gen_t *g, vlog_node_t v) { type_t type = trans_var_type(g, v); tree_t t = tree_new(T_SIGNAL_DECL); tree_set_ident(t, vlog_ident(v)); tree_set_type(t, type); tree_add_decl(g->out, t); } static void trans_net_decl(trans_gen_t *g, vlog_node_t decl) { type_t type = trans_net_type(g, decl); tree_t t = tree_new(T_SIGNAL_DECL); tree_set_ident(t, vlog_ident(decl)); tree_set_type(t, type); tree_add_decl(g->out, t); } void vlog_trans(vlog_node_t mod, tree_t out) { assert(is_top_level(mod)); trans_gen_t gen = { .map = hash_new(16), .out = out, }; hset_t *ports = hset_new(16); const int nports = vlog_ports(mod); for (int i = 0; i < nports; i++) { vlog_node_t ref = vlog_port(mod, i); assert(vlog_kind(ref) == V_REF); // Do not translate the associated var/net declaration twice vlog_node_t port = vlog_ref(ref); hset_insert(ports, vlog_ref(port)); } const int ndecls = vlog_decls(mod); for (int i = 0; i < ndecls; i++) { vlog_node_t d = vlog_decl(mod, i); switch (vlog_kind(d)) { case V_PORT_DECL: break; // Translated below case V_VAR_DECL: if (!hset_contains(ports, d)) trans_var_decl(&gen, d); break; case V_NET_DECL: if (!hset_contains(ports, d)) trans_net_decl(&gen, d); break; case V_PARAM_DECL: trans_param_decl(&gen, d); break; case V_LOCALPARAM: trans_localparam(&gen, d); break; default: CANNOT_HANDLE(d); } } for (int i = 0; i < nports; i++) { vlog_node_t ref = vlog_port(mod, i); assert(vlog_kind(ref) == V_REF); vlog_node_t port = vlog_ref(ref); assert(vlog_kind(port) == V_PORT_DECL); trans_port_decl(&gen, port); } hash_free(gen.map); hset_free(ports); } nvc-r1.17.1/src/vlog/vlog-udp.c000066400000000000000000000242011504111170000161750ustar00rootroot00000000000000// // Copyright (C) 2023-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include #include #define CANNOT_HANDLE(v) do { \ fatal_at(vlog_loc(v), "cannot handle %s in %s" , \ vlog_kind_str(vlog_kind(v)), __FUNCTION__); \ } while (0) static mir_value_t vlog_lower_rvalue(mir_unit_t *mu, vlog_node_t v) { switch (vlog_kind(v)) { case V_NUMBER: { number_t num = vlog_number(v); assert(number_width(num) == 1); mir_type_t t_logic = mir_vec4_type(mu, 1, false); return mir_const_vec(mu, t_logic, number_bit(num, 0), 1); } default: CANNOT_HANDLE(v); } } void vlog_lower_udp(mir_unit_t *mu, object_t *obj) { vlog_node_t udp = vlog_from_object(obj); assert(vlog_kind(udp) == V_INST_BODY); vlog_node_t table = vlog_stmt(udp, 0); assert(vlog_kind(table) == V_UDP_TABLE); const vlog_udp_kind_t kind = vlog_subkind(table); mir_block_t start_bb = mir_add_block(mu); assert(start_bb.id == 1); vlog_node_t out_decl = vlog_ref(vlog_port(udp, 0)); assert(vlog_kind(out_decl) == V_PORT_DECL); assert(vlog_subkind(out_decl) == V_PORT_OUTPUT); int hops; mir_value_t out_var = mir_search_object(mu, out_decl, &hops); assert(!mir_is_null(out_var)); const int nports = vlog_ports(udp); mir_value_t *in_vars LOCAL = xmalloc_array(nports - 1, sizeof(mir_value_t)); for (int i = 1; i < nports; i++) { vlog_node_t decl = vlog_ref(vlog_port(udp, i)); assert(vlog_kind(decl) == V_PORT_DECL); assert(vlog_subkind(decl) == V_PORT_INPUT); int hops; in_vars[i - 1] = mir_search_object(mu, decl, &hops); assert(!mir_is_null(in_vars[i - 1])); } mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_logic = mir_vec4_type(mu, 1, false); mir_type_t t_time = mir_time_type(mu); mir_value_t result_var = mir_add_var(mu, t_logic, MIR_NULL_STAMP, ident_new("result"), MIR_VAR_TEMP); { mir_value_t upref = mir_build_var_upref(mu, hops, out_var.id); mir_value_t out = mir_build_load(mu, upref); mir_value_t one = mir_const(mu, t_offset, 1); mir_build_drive_signal(mu, out, one); for (int i = 1; i < nports; i++) { mir_value_t upref = mir_build_var_upref(mu, hops, in_vars[i - 1].id); mir_value_t nets = mir_build_load(mu, upref); mir_build_sched_event(mu, nets, one); } if (vlog_stmts(table) > 0) { vlog_node_t init = vlog_value(vlog_stmt(table, 0)); mir_build_map_const(mu, vlog_lower_rvalue(mu, init), out, one); } mir_build_return(mu, MIR_NULL_VALUE); } mir_block_t wait_bb = mir_add_block(mu); mir_set_cursor(mu, start_bb, MIR_APPEND); { mir_value_t one = mir_const(mu, t_offset, 1); mir_value_t zero = mir_const(mu, t_time, 1); mir_value_t logic0 = mir_const_vec(mu, t_logic, 0, 0); mir_value_t logic1 = mir_const_vec(mu, t_logic, 1, 0); mir_value_t logicX = mir_const_vec(mu, t_logic, 1, 1); mir_value_t level_map[127]; level_map['0'] = logic0; level_map['1'] = logic1; level_map['x'] = level_map['X'] = logicX; mir_value_t *mem LOCAL = xmalloc_array(nports * 2, sizeof(mir_value_t)); mir_value_t *in_regs = mem, *in_nets = mem + nports; for (int i = 1; i < nports; i++) { mir_value_t upref = mir_build_var_upref(mu, hops, in_vars[i - 1].id); mir_value_t nets = mir_build_load(mu, upref); mir_value_t value = mir_build_load(mu, mir_build_resolved(mu, nets)); in_regs[i - 1] = mir_build_pack(mu, t_logic, value); in_nets[i - 1] = nets; } mir_block_t test_bb = start_bb; const int nentries = vlog_params(table); for (int i = 0; i < nentries; i++) { vlog_node_t entry = vlog_param(table, i); assert(vlog_kind(entry) == V_UDP_ENTRY); mir_block_t hit_bb = mir_add_block(mu); mir_value_t and = MIR_NULL_VALUE; int pos = 0; for (int j = 0; j < nports - 1; j++) { mir_value_t cmp = MIR_NULL_VALUE; vlog_node_t sym = vlog_param(entry, pos++); switch (vlog_kind(sym)) { case V_UDP_LEVEL: switch (vlog_ival(sym)) { case '0': case '1': case 'x': case 'X': cmp = mir_build_cmp(mu, MIR_CMP_EQ, in_regs[j], level_map[vlog_ival(sym)]); break; case '*': cmp = mir_build_event_flag(mu, in_nets[j], one); break; case 'b': { mir_value_t is0 = mir_build_cmp(mu, MIR_CMP_EQ, in_regs[j], logic0); mir_value_t is1 = mir_build_cmp(mu, MIR_CMP_EQ, in_regs[j], logic1); cmp = mir_build_and(mu, is0, is1); } break; case '?': break; default: CANNOT_HANDLE(sym); } break; case V_UDP_EDGE: { const char left = vlog_ival(vlog_left(sym)); const char right = vlog_ival(vlog_right(sym)); cmp = mir_build_event_flag(mu, in_nets[j], one); if (left != '?') { mir_value_t last_ptr = mir_build_last_value(mu, in_nets[j]); mir_value_t last = mir_build_load(mu, last_ptr); mir_value_t packed = mir_build_pack(mu, t_logic, last); mir_value_t eq = mir_build_cmp(mu, MIR_CMP_EQ, packed, level_map[(unsigned)left]); cmp = mir_build_and(mu, cmp, eq); } if (right != '?') { mir_value_t eq = mir_build_cmp(mu, MIR_CMP_EQ, in_regs[j], level_map[(unsigned)right]); cmp = mir_build_and(mu, cmp, eq); } } break; default: CANNOT_HANDLE(entry); } if (mir_is_null(and)) and = cmp; else if (!mir_is_null(cmp)) and = mir_build_and(mu, and, cmp); } if (kind == V_UDP_SEQ) { mir_value_t upref = mir_build_var_upref(mu, hops, out_var.id); mir_value_t out = mir_build_load(mu, upref); mir_value_t resolved = mir_build_resolved(mu, out); mir_value_t cur = mir_build_load(mu, resolved); mir_value_t packed = mir_build_pack(mu, t_logic, cur); vlog_node_t sym = vlog_param(entry, pos++); assert(vlog_kind(sym) == V_UDP_LEVEL); mir_value_t cmp = MIR_NULL_VALUE; switch (vlog_ival(sym)) { case '0': case '1': case 'x': case 'X': cmp = mir_build_cmp(mu, MIR_CMP_EQ, packed, level_map[vlog_ival(sym)]); break; case '?': break; default: CANNOT_HANDLE(sym); } if (mir_is_null(and)) and = cmp; else if (!mir_is_null(cmp)) and = mir_build_and(mu, and, cmp); } if (mir_is_null(and)) { mir_build_jump(mu, hit_bb); break; } else { test_bb = mir_add_block(mu); mir_build_cond(mu, and, hit_bb, test_bb); } mir_set_cursor(mu, hit_bb, MIR_APPEND); vlog_node_t sym = vlog_param(entry, pos++); assert(vlog_kind(sym) == V_UDP_LEVEL); assert(pos == vlog_params(entry)); mir_value_t drive; switch (vlog_ival(sym)) { case '0': case '1': case 'x': case 'X': drive = level_map[vlog_ival(sym)]; break; case '-': // No change, skip assignment to output drive = MIR_NULL_VALUE; mir_build_wait(mu, start_bb, MIR_NULL_VALUE); mir_set_cursor(mu, test_bb, MIR_APPEND); continue; default: CANNOT_HANDLE(entry); } mir_build_store(mu, result_var, drive); mir_build_jump(mu, wait_bb); mir_set_cursor(mu, test_bb, MIR_APPEND); } mir_set_cursor(mu, test_bb, MIR_APPEND); if (!mir_block_finished(mu, test_bb)) { if (kind == V_UDP_SEQ) mir_build_wait(mu, start_bb, MIR_NULL_VALUE); // Skip assignment else { mir_build_store(mu, result_var, logicX); mir_build_jump(mu, wait_bb); } } mir_set_cursor(mu, wait_bb, MIR_APPEND); mir_value_t result = mir_build_load(mu, result_var); const uint8_t strength = kind == V_UDP_COMB ? ST_STRONG : 0; mir_value_t drive = mir_build_unpack(mu, result, strength, MIR_NULL_VALUE); mir_value_t upref = mir_build_var_upref(mu, hops, out_var.id); mir_value_t out = mir_build_load(mu, upref); mir_build_sched_waveform(mu, out, one, drive, zero, zero); mir_build_wait(mu, start_bb, MIR_NULL_VALUE); } } nvc-r1.17.1/src/vlog/vlog-util.c000066400000000000000000000101121504111170000163560ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "ident.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-util.h" #include bool vlog_is_net(vlog_node_t v) { switch (vlog_kind(v)) { case V_REF: return vlog_has_ref(v) ? vlog_is_net(vlog_ref(v)) : false; case V_PORT_DECL: return vlog_has_ref(v) ? vlog_is_net(vlog_ref(v)) : true; case V_NET_DECL: return true; default: return false; } } unsigned vlog_dimensions(vlog_node_t v) { return vlog_ranges(vlog_type(v)) + vlog_ranges(v); } int64_t vlog_get_const(vlog_node_t v) { switch (vlog_kind(v)) { case V_NUMBER: return number_integer(vlog_number(v)); case V_REF: return vlog_get_const(vlog_ref(v)); case V_LOCALPARAM: return vlog_get_const(vlog_value(v)); default: fatal_at(vlog_loc(v), "expression is not constant"); } } bool vlog_is_const(vlog_node_t v) { switch (vlog_kind(v)) { case V_NUMBER: return true; case V_REF: return vlog_is_const(vlog_ref(v)); case V_LOCALPARAM: return vlog_is_const(vlog_value(v)); default: return false; } } void vlog_bounds(vlog_node_t v, int64_t *left, int64_t *right) { *left = vlog_get_const(vlog_left(v)); *right = vlog_get_const(vlog_right(v)); } unsigned vlog_size(vlog_node_t v) { switch (vlog_kind(v)) { case V_DATA_TYPE: case V_VAR_DECL: case V_NET_DECL: case V_PORT_DECL: { unsigned size = 1; const int nranges = vlog_ranges(v); for (int i = 0; i < nranges; i++) { vlog_node_t r = vlog_range(v, i); int64_t left, right; vlog_bounds(r, &left, &right); if (left < right) size *= right - left + 1; else size *= left - right + 1; } return size; } case V_DIMENSION: case V_PART_SELECT: { int64_t left, right; vlog_bounds(v, &left, &right); if (left < right) return right - left + 1; else return left - right + 1; } default: CANNOT_HANDLE(v); } } bool is_top_level(vlog_node_t v) { switch (vlog_kind(v)) { case V_MODULE: case V_PRIMITIVE: case V_INST_BODY: return true; default: return false; } } bool is_data_type(vlog_node_t v) { switch (vlog_kind(v)) { case V_DATA_TYPE: case V_ENUM_DECL: case V_STRUCT_DECL: case V_UNION_DECL: case V_TYPE_DECL: return true; default: return false; } } vlog_node_t vlog_longest_static_prefix(vlog_node_t v) { switch (vlog_kind(v)) { case V_REF: return v; case V_BIT_SELECT: { vlog_node_t value = vlog_value(v); vlog_node_t prefix = vlog_longest_static_prefix(value); if (prefix != value) return prefix; const int nparams = vlog_params(v); for (int i = 0; i < nparams; i++) { if (!vlog_is_const(vlog_param(v, i))) return prefix; } return v; } case V_PART_SELECT: { vlog_node_t value = vlog_value(v); vlog_node_t prefix = vlog_longest_static_prefix(value); if (prefix != value) return prefix; if (!vlog_is_const(vlog_left(v))) return prefix; return v; } default: fatal_at(vlog_loc(v), "cannot calculate longest static prefix"); } } nvc-r1.17.1/src/vlog/vlog-util.h000066400000000000000000000025711504111170000163750ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VLOG_UTIL_H #define _VLOG_UTIL_H #include "prim.h" bool vlog_is_net(vlog_node_t v); unsigned vlog_dimensions(vlog_node_t v); int64_t vlog_get_const(vlog_node_t v); bool vlog_is_const(vlog_node_t v); void vlog_bounds(vlog_node_t v, int64_t *left, int64_t *right); unsigned vlog_size(vlog_node_t v); bool is_top_level(vlog_node_t v); bool is_data_type(vlog_node_t v); vlog_node_t vlog_longest_static_prefix(vlog_node_t v); #define CANNOT_HANDLE(v) do { \ fatal_at(vlog_loc(v), "cannot handle %s in %s" , \ vlog_kind_str(vlog_kind(v)), __FUNCTION__); \ } while (0) #endif // _VLOG_UTIL_H nvc-r1.17.1/src/vpi/000077500000000000000000000000001504111170000141245ustar00rootroot00000000000000nvc-r1.17.1/src/vpi/Makemodule.am000066400000000000000000000003141504111170000165240ustar00rootroot00000000000000lib_libnvc_a_SOURCES += \ src/vpi/vpi_user.h \ src/vpi/vpi-model.h \ src/vpi/vpi-model.c \ src/vpi/vpi-priv.h \ src/vpi/vpi-str.c \ src/vpi/vpi-util.c \ src/vpi/vpi-systf.c \ src/vpi/vpi-macros.h nvc-r1.17.1/src/vpi/vpi-macros.h000066400000000000000000000041651504111170000163630ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VPI_MACROS_H #define _VPI_MACROS_H #define DEF_CLASS(class, tag, path) \ static UNUSED c_##class *is_##class(c_vpiObject *obj) \ { \ if (obj->type == tag) \ return container_of(obj, c_##class, path); \ else \ return NULL; \ } \ \ static UNUSED c_##class *cast_##class(c_vpiObject *obj) \ { \ c_##class *p = is_##class(obj); \ if (p == NULL) \ vpi_error(vpiError, NULL, "object type %s is not a " \ #tag, vpi_type_str(obj->type)); \ return p; \ } #define VPI_MISSING fatal_trace("VPI function %s not implemented", __func__) #define VPI_TRACE(...) do { \ extern int _vhpi_trace_on(void); \ if (unlikely(_vhpi_trace_on())) \ vpi_trace(__func__, __VA_ARGS__); \ } while (0) #endif // _VPI_MACROS_H nvc-r1.17.1/src/vpi/vpi-model.c000066400000000000000000000676721504111170000162060ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "array.h" #include "diag.h" #include "hash.h" #include "ident.h" #include "jit/jit-ffi.h" #include "jit/jit.h" #include "option.h" #include "rt/model.h" #include "rt/mspace.h" #include "rt/structs.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vpi/vpi-macros.h" #include "vpi/vpi-model.h" #include "vpi/vpi-priv.h" #include #include #include typedef struct { PLI_INT32 type; loc_t loc; } c_vpiObject; typedef struct { c_vpiObject object; uint32_t refcount; } c_refcounted; typedef struct { unsigned count; unsigned limit; c_vpiObject **items; } vpiObjectList; typedef A(vpiHandle) vpiHandleList; typedef void (*vpiLazyFn)(c_vpiObject *); typedef struct { vpiLazyFn fn; vpiObjectList list; } vpiLazyList; typedef struct { c_refcounted refcounted; ident_t name; s_vpi_systf_data systf; } c_callback; DEF_CLASS(callback, vpiCallback, refcounted.object); typedef struct { c_vpiObject object; vlog_node_t where; jit_handle_t handle; vpiLazyList decls; } c_abstractScope; typedef struct { c_abstractScope scope; tree_t block; rt_scope_t *rtscope; } c_module; DEF_CLASS(module, vpiModule, scope.object); typedef struct { c_vpiObject object; vpiObjectList args; vlog_node_t where; c_abstractScope *scope; } c_tfCall; typedef struct { c_tfCall tfcall; c_callback *callback; vpiHandle handle; } c_sysTfCall; typedef struct { c_sysTfCall systfcall; } c_sysTaskCall; DEF_CLASS(sysTaskCall, vpiSysTaskCall, systfcall.tfcall.object); typedef struct { c_sysTfCall systfcall; } c_sysFuncCall; DEF_CLASS(sysFuncCall, vpiSysFuncCall, systfcall.tfcall.object); typedef struct { c_vpiObject object; vlog_node_t where; unsigned argpos; } c_expr; typedef struct { c_expr expr; PLI_INT32 subtype; PLI_INT32 size; } c_constant; DEF_CLASS(constant, vpiConstant, expr.object); typedef struct { c_expr expr; PLI_INT32 subtype; unsigned argslot; } c_operation; DEF_CLASS(operation, vpiOperation, expr.object); typedef struct { c_refcounted refcounted; vpiObjectList *list; uint32_t pos; } c_iterator; DEF_CLASS(iterator, vpiIterator, refcounted.object); typedef struct { c_vpiObject object; vlog_node_t where; c_abstractScope *scope; UNSAFE_MPTR mptr; } c_abstractDecl; typedef struct { c_abstractDecl decl; } c_net; DEF_CLASS(net, vpiNet, decl.object); typedef struct { c_abstractDecl decl; } c_reg; DEF_CLASS(reg, vpiReg, decl.object); #define HANDLE_BITS (sizeof(vpiHandle) * 8) #define HANDLE_MAX_INDEX ((UINT64_C(1) << (HANDLE_BITS / 2)) - 1) typedef enum { HANDLE_USER, HANDLE_INTERNAL, } handle_kind_t; typedef struct { c_vpiObject *obj; handle_kind_t kind; uint32_t generation; } handle_slot_t; STATIC_ASSERT(sizeof(handle_slot_t) <= 16); typedef struct _vpi_context { shash_t *strtab; rt_model_t *model; hash_t *objcache; tree_t top; jit_t *jit; handle_slot_t *handles; unsigned num_handles; unsigned free_hint; vpiHandleList systasks; vpiObjectList syscalls; c_sysTfCall *call; jit_scalar_t *args; tlab_t *tlab; text_buf_t *valuestr; mem_pool_t *pool; vpiObjectList recycle; } vpi_context_t; static c_vpiObject *build_expr(vlog_node_t v, c_abstractScope *scope); static void vpi_lazy_decls(c_vpiObject *obj); static c_refcounted *is_refcounted(c_vpiObject *obj); static vpi_context_t *global_context = NULL; // TODO: thread local static inline vpi_context_t *vpi_context(void) { assert(global_context != NULL); return global_context; } static handle_slot_t *decode_handle(vpi_context_t *c, vpiHandle handle) { const uintptr_t bits = (uintptr_t)handle; const uint32_t index = bits & HANDLE_MAX_INDEX; const uint32_t generation = bits >> HANDLE_BITS/2; if (handle == NULL || index >= c->num_handles) return NULL; handle_slot_t *slot = &(c->handles[index]); if (slot->obj == NULL) return NULL; else if (slot->generation != generation) return NULL; // Use-after-free return slot; } static inline vpiHandle encode_handle(handle_slot_t *slot, uint32_t index) { const uintptr_t bits = (uintptr_t)slot->generation << HANDLE_BITS/2 | index; return (vpiHandle)bits; } static vpiHandle handle_for(c_vpiObject *obj, handle_kind_t kind) { assert(obj != NULL); vpi_context_t *c = vpi_context(); uint32_t index = c->free_hint; if (index >= c->num_handles || c->handles[index].obj != NULL) { for (index = 0; index < c->num_handles; index++) { if (c->handles[index].obj == NULL && c->handles[index].generation < HANDLE_MAX_INDEX) break; } } if (unlikely(index > HANDLE_MAX_INDEX)) { vpi_error(vpiSystem, NULL, "too many active handles"); return NULL; } else if (index == c->num_handles) { const int new_size = MAX(c->num_handles * 2, 128); c->handles = xrealloc_array(c->handles, new_size, sizeof(handle_slot_t)); c->num_handles = new_size; for (int i = index; i < new_size; i++) { c->handles[i].obj = NULL; c->handles[i].generation = 1; } } handle_slot_t *slot = &(c->handles[index]); slot->obj = obj; slot->kind = kind; c->free_hint = index + 1; c_refcounted *rc = is_refcounted(obj); if (rc != NULL) rc->refcount++; return encode_handle(slot, index); } static inline vpiHandle user_handle_for(c_vpiObject *obj) { return handle_for(obj, HANDLE_USER); } static inline vpiHandle internal_handle_for(c_vpiObject *obj) { return handle_for(obj, HANDLE_INTERNAL); } static void drop_handle(vpi_context_t *c, vpiHandle handle) { handle_slot_t *slot = decode_handle(c, handle); if (slot == NULL) return; c_vpiObject *obj = slot->obj; slot->obj = NULL; slot->generation++; c->free_hint = slot - c->handles; c_refcounted *rc = is_refcounted(obj); if (rc != NULL) { assert(rc->refcount > 0); if (--(rc->refcount) == 0) APUSH(c->recycle, obj); } } static inline c_vpiObject *from_handle(vpiHandle handle) { handle_slot_t *slot = decode_handle(vpi_context(), handle); if (likely(slot != NULL)) return slot->obj; vpi_error(vpiSystem, NULL, "invalid handle %p", handle); return NULL; } static c_refcounted *is_refcounted(c_vpiObject *obj) { switch (obj->type) { case vpiCallback: case vpiIterator: return container_of(obj, c_refcounted, object); default: return NULL; } } static c_tfCall *is_tfCall(c_vpiObject *obj) { switch (obj->type) { case vpiSysTaskCall: case vpiSysFuncCall: return container_of(obj, c_tfCall, object); default: return NULL; } } static c_sysTfCall *is_sysTfCall(c_vpiObject *obj) { switch (obj->type) { case vpiSysTaskCall: case vpiSysFuncCall: return container_of(obj, c_sysTfCall, tfcall.object); default: return NULL; } } static c_abstractDecl *is_abstractDecl(c_vpiObject *obj) { switch (obj->type) { case vpiReg: case vpiNet: return container_of(obj, c_abstractDecl, object); default: return NULL; } } static c_abstractScope *is_abstractScope(c_vpiObject *obj) { switch (obj->type) { case vpiModule: return container_of(obj, c_abstractScope, object); default: return NULL; } } static const char *handle_pp(vpiHandle handle) { static __thread text_buf_t *tb = NULL; if (handle == NULL) return "NULL"; if (tb == NULL) tb = tb_new(); else tb_rewind(tb); tb_printf(tb, "%p:{", handle); handle_slot_t *slot = decode_handle(vpi_context(), handle); if (slot == NULL) tb_cat(tb, "INVALID"); else { c_vpiObject *obj = slot->obj; tb_cat(tb, vpi_type_str(obj->type)); } tb_append(tb, '}'); return tb_get(tb); } static void *new_object(size_t size, PLI_INT32 type) { assert(size >= sizeof(c_vpiObject)); c_vpiObject *obj = pool_calloc(vpi_context()->pool, size); obj->type = type; obj->loc = LOC_INVALID; return obj; } static void *recyle_object(size_t size, PLI_INT32 type) { vpi_context_t *c = vpi_context(); for (int i = 0; i < c->recycle.count; i++) { c_vpiObject *obj = c->recycle.items[i]; if (obj->type == type) { for (int j = i; j < c->recycle.count - 1; j++) c->recycle.items[j] = c->recycle.items[j + 1]; ATRIM(c->recycle, c->recycle.count - 1); memset(obj, '\0', size); obj->type = type; obj->loc = LOC_INVALID; return obj; } } return new_object(size, type); } static void vpi_list_reserve(vpiObjectList *list, unsigned num) { if (list->limit >= num) return; assert(list->count == 0); assert(list->items == NULL); mem_pool_t *mp = vpi_context()->pool; list->limit = num; list->items = pool_malloc_array(mp, num, sizeof(c_vpiObject *)); } static inline void vpi_list_add(vpiObjectList *list, c_vpiObject *obj) { assert(list->count < list->limit); list->items[list->count++] = obj; } static vpiObjectList *expand_lazy_list(c_vpiObject *obj, vpiLazyList *lazy) { vpiLazyFn fn = lazy->fn; if (fn != NULL) { lazy->fn = NULL; // Avoid infinite recursion (*fn)(obj); } return &(lazy->list); } static void init_expr(c_expr *expr, vlog_node_t v) { expr->where = v; } static void init_tfCall(c_tfCall *call, vlog_node_t v, c_abstractScope *scope) { call->where = v; call->scope = scope; const int nparams = vlog_params(v); vpi_list_reserve(&(call->args), nparams); for (int i = 0, argslot = 1; i < nparams; i++) { c_vpiObject *obj = build_expr(vlog_param(v, i), scope); vpi_list_add(&(call->args), obj); c_operation *op = is_operation(obj); if (op != NULL) { op->argslot = argslot; argslot += 3; } } } static void init_sysTfCall(c_sysTfCall *call, vlog_node_t v, c_callback *callback, c_abstractScope *scope) { init_tfCall(&call->tfcall, v, scope); call->callback = callback; vpi_context_t *c = vpi_context(); APUSH(c->syscalls, &(call->tfcall.object)); } static void init_abstractDecl(c_abstractDecl *decl, vlog_node_t v, c_abstractScope *scope) { decl->object.loc = *vlog_loc(v); decl->where = v; decl->scope = scope; } static void init_abstractScope(c_abstractScope *scope, vlog_node_t v) { scope->object.loc = *vlog_loc(v); scope->where = v; scope->handle = JIT_HANDLE_INVALID; scope->decls.fn = vpi_lazy_decls; } static void build_net(vlog_node_t v, c_abstractScope *scope) { c_net *net = new_object(sizeof(c_net), vpiNet); init_abstractDecl(&(net->decl), v, scope); vpi_list_add(&scope->decls.list, &(net->decl.object)); } static void build_reg(vlog_node_t v, c_abstractScope *scope) { c_reg *reg = new_object(sizeof(c_reg), vpiNet); init_abstractDecl(&(reg->decl), v, scope); vpi_list_add(&scope->decls.list, &(reg->decl.object)); } static c_constant *build_constant(vlog_node_t v) { c_constant *con = new_object(sizeof(c_constant), vpiConstant); init_expr(&con->expr, v); switch (vlog_kind(v)) { case V_STRING: con->subtype = vpiStringConst; con->size = number_width(vlog_number(v)); assert(con->size % 8 == 0); break; case V_NUMBER: con->subtype = vpiBinaryConst; con->size = number_width(vlog_number(v)); break; default: should_not_reach_here(); } return con; } static c_operation *build_operation(vlog_node_t v) { c_operation *op = new_object(sizeof(c_operation), vpiOperation); init_expr(&op->expr, v); switch (vlog_kind(v)) { case V_EMPTY: op->subtype = vpiNullOp; break; case V_POSTFIX: op->subtype = vlog_subkind(v) == V_INCDEC_PLUS ? vpiPostIncOp : vpiPostDecOp; break; case V_PREFIX: op->subtype = vlog_subkind(v) == V_INCDEC_PLUS ? vpiPreIncOp : vpiPreDecOp; break; default: break; } return op; } static c_vpiObject *build_expr(vlog_node_t v, c_abstractScope *scope) { switch (vlog_kind(v)) { case V_STRING: case V_NUMBER: return &(build_constant(v)->expr.object); case V_REF: { vlog_node_t d = vlog_ref(v); if (vlog_kind(d) == V_PORT_DECL) d = vlog_ref(d); vpiObjectList *list = expand_lazy_list(&(scope->object), &(scope->decls)); for (int i = 0; i < list->count; i++) { c_abstractDecl *decl = is_abstractDecl(list->items[i]); assert(decl != NULL); if (decl->where == d) return &(decl->object); } fatal_trace("cannot find declaration for %s", istr(vlog_ident(d))); } case V_BINARY: case V_UNARY: case V_SYS_FCALL: case V_EMPTY: case V_PREFIX: case V_POSTFIX: case V_BIT_SELECT: // XXX: check this return &(build_operation(v)->expr.object); default: fatal_trace("cannot build VPI expr for node kind %s", vlog_kind_str(vlog_kind(v))); } return NULL; } static c_sysTaskCall *build_sysTaskCall(vlog_node_t where, c_callback *callback, c_abstractScope *scope) { c_sysTaskCall *call = new_object(sizeof(c_sysTaskCall), vpiSysTaskCall); init_sysTfCall(&call->systfcall, where, callback, scope); return call; } static c_sysFuncCall *build_sysFuncCall(vlog_node_t where, c_callback *callback, c_abstractScope *scope) { c_sysFuncCall *call = new_object(sizeof(c_sysTaskCall), vpiSysFuncCall); init_sysTfCall(&call->systfcall, where, callback, scope); return call; } static bool init_iterator(c_iterator *it, PLI_INT32 type, c_vpiObject *obj) { c_tfCall *call = is_tfCall(obj); if (call != NULL) { switch (type) { case vpiArgument: it->list = &(call->args); return true; default: return false; } } return false; } static c_module *build_module(vlog_node_t v, tree_t block, rt_scope_t *s) { c_module *m = new_object(sizeof(c_module), vpiModule); init_abstractScope(&m->scope, v); m->block = block; m->rtscope = s; return m; } static c_module *cached_module(tree_t block, rt_scope_t *s) { assert(tree_kind(block) == T_BLOCK); hash_t *cache = vpi_context()->objcache; c_module *m = hash_get(cache, block); if (m == NULL) { tree_t hier = tree_decl(block, 0); assert(tree_kind(hier) == T_HIER); tree_t wrap = tree_ref(hier); assert(tree_kind(wrap) == T_VERILOG); vlog_node_t body = tree_vlog(wrap); assert(vlog_kind(body) == V_INST_BODY); m = build_module(body, block, s); hash_put(cache, block, m); } return m; } static jit_t *vpi_get_jit(vpi_context_t *c) { if (c->jit != NULL) return c->jit; return jit_for_thread(); } static void *vpi_get_ptr(c_abstractDecl *decl) { if (decl->mptr != NULL) return decl->mptr; jit_t *jit = vpi_get_jit(vpi_context()); if (decl->scope->handle == JIT_HANDLE_INVALID) { c_module *mod = is_module(&(decl->scope->object)); if (mod != NULL) decl->scope->handle = jit_lazy_compile(jit, mod->rtscope->name); } ident_t name = vlog_ident(decl->where); if (decl->scope->handle == JIT_HANDLE_INVALID) fatal_at(&(decl->object.loc), "cannot get pointer to %s", istr(name)); return (decl->mptr = jit_get_frame_var(jit, decl->scope->handle, name)); } static void vpi_lazy_decls(c_vpiObject *obj) { c_abstractScope *s = is_abstractScope(obj); assert(s != NULL); const int ndecls = vlog_decls(s->where); vpi_list_reserve(&s->decls.list, ndecls); for (int i = 0; i < ndecls; i++) { vlog_node_t v = vlog_decl(s->where, i); switch (vlog_kind(v)) { case V_NET_DECL: build_net(v, s); break; case V_VAR_DECL: build_reg(v, s); break; default: break; } } } //////////////////////////////////////////////////////////////////////////////// // Public API DLLEXPORT vpiHandle vpi_register_systf(p_vpi_systf_data systf_data_p) { vpi_clear_error(); VPI_TRACE("tfname=%s", systf_data_p->tfname); assert(systf_data_p->tfname[0] == '$'); // TODO: add test c_callback *cb = recyle_object(sizeof(c_callback), vpiCallback); cb->systf = *systf_data_p; cb->name = ident_new(systf_data_p->tfname); vpiHandle handle = internal_handle_for(&cb->refcounted.object); APUSH(vpi_context()->systasks, handle); return handle; } DLLEXPORT PLI_INT32 vpi_release_handle(vpiHandle object) { vpi_clear_error(); VPI_TRACE("handle=%s", handle_pp(object)); vpi_context_t *c = vpi_context(); handle_slot_t *slot = decode_handle(c, object); if (slot == NULL) { vpi_error(vpiError, NULL, "invalid handle %p", object); return 0; } else if (slot->kind == HANDLE_INTERNAL) { vpi_error(vpiError, &(slot->obj->loc), "cannot release this handle as " "it is owned by the system"); return 0; } drop_handle(c, object); return 1; } DLLEXPORT vpiHandle vpi_handle(PLI_INT32 type, vpiHandle refHandle) { vpi_clear_error(); VPI_TRACE("type=%s refHandle=%s", vpi_method_str(type), handle_pp(refHandle)); vpi_context_t *c = vpi_context(); if (refHandle == NULL) { switch (type) { case vpiSysTfCall: if (c->call != NULL) return user_handle_for(&c->call->tfcall.object); else return NULL; } } return NULL; } DLLEXPORT vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle refHandle) { vpi_clear_error(); VPI_TRACE("type=%s handle=%s", vpi_method_str(type), handle_pp(refHandle)); c_vpiObject *obj = NULL; if (refHandle != NULL && (obj = from_handle(refHandle)) == NULL) return NULL; c_iterator *it = recyle_object(sizeof(c_iterator), vpiIterator); if (!init_iterator(it, type, obj)) { vpi_error(vpiError, obj ? &(obj->loc) : NULL, "relation %s not supported for handle %s", vpi_method_str(type), handle_pp(refHandle)); return NULL; } return user_handle_for(&(it->refcounted.object)); } DLLEXPORT vpiHandle vpi_scan(vpiHandle iterator) { vpi_clear_error(); VPI_TRACE("iterator=%s", handle_pp(iterator)); c_vpiObject *obj = from_handle(iterator); if (obj == NULL) return NULL; c_iterator *it = cast_iterator(obj); if (it == NULL) return NULL; if (it->pos < it->list->count) return user_handle_for(it->list->items[it->pos++]); return NULL; } DLLEXPORT PLI_INT32 vpi_get(PLI_INT32 property, vpiHandle object) { vpi_clear_error(); VPI_TRACE("property=%s object=%s", vpi_property_str(property), handle_pp(object)); c_vpiObject *obj = from_handle(object); if (obj == NULL) return vpiUndefined; if (property == vpiType) return obj->type; c_constant *con = is_constant(obj); if (con != NULL) { switch (property) { case vpiConstType: return con->subtype; case vpiSize: return con->size; default: goto missing_property; } } c_operation *op = is_operation(obj); if (op != NULL) { switch (property) { case vpiSize: { vpi_context_t *c = vpi_context(); if (c->args != NULL) return c->args[op->argslot].integer; goto missing_property; } } } c_abstractDecl *decl = is_abstractDecl(obj); if (decl != NULL) { switch (property) { case vpiSize: { sig_shared_t **ss = vpi_get_ptr(decl); rt_signal_t *s = container_of(*ss, rt_signal_t, shared); return signal_width(s); } } } missing_property: vpi_error(vpiError, &(obj->loc), "object does not have property %s", vpi_property_str(property)); return vpiUndefined; } DLLEXPORT void vpi_get_value(vpiHandle handle, p_vpi_value value_p) { vpi_clear_error(); VPI_TRACE("handle=%s value_p=%p", handle_pp(handle), value_p); c_vpiObject *obj = from_handle(handle); if (obj == NULL) return; vpi_context_t *c = vpi_context(); tb_rewind(c->valuestr); c_constant *con = is_constant(obj); if (con != NULL) { switch (con->subtype) { case vpiStringConst: { number_t n = vlog_number(con->expr.where); for (int i = con->size/8 - 1; i >= 0; i--) tb_append(c->valuestr, number_byte(n, i)); value_p->format = vpiStringVal; value_p->value.str = (PLI_BYTE8 *)tb_get(c->valuestr); } return; case vpiBinaryConst: { number_t n = vlog_number(con->expr.where); vpi_format_number(n, value_p->format, c->valuestr); value_p->value.str = (PLI_BYTE8 *)tb_get(c->valuestr); return; } } } c_operation *op = is_operation(obj); if (op != NULL && c->args != NULL) { int size = c->args[op->argslot].integer; assert(size <= 64); uint64_t abits = c->args[op->argslot + 1].integer; uint64_t bbits = c->args[op->argslot + 2].integer; vpi_format_number2(size, abits, bbits, value_p->format, c->valuestr); value_p->value.str = (PLI_BYTE8 *)tb_get(c->valuestr); return; } c_abstractDecl *decl = is_abstractDecl(obj); if (decl != NULL) { sig_shared_t **ss = vpi_get_ptr(decl); rt_signal_t *s = container_of(*ss, rt_signal_t, shared); number_t num = number_pack(signal_value(s), signal_width(s)); vpi_format_number(num, value_p->format, c->valuestr); value_p->value.str = (PLI_BYTE8 *)tb_get(c->valuestr); return; } vpi_error(vpiError, &(obj->loc), "cannot evaluate %s", handle_pp(handle)); } DLLEXPORT vpiHandle vpi_put_value(vpiHandle handle, p_vpi_value value_p, p_vpi_time time_p, PLI_INT32 flags) { vpi_clear_error(); VPI_TRACE("handle=%s value_p=%p", handle_pp(handle), value_p); c_vpiObject *obj = from_handle(handle); if (obj == NULL) return NULL; vpi_context_t *c = vpi_context(); c_sysFuncCall *fcall = is_sysFuncCall(obj); if (fcall != NULL && c->args != NULL) { assert(fcall->systfcall.callback->systf.sysfunctype == vpiTimeFunc); assert(value_p->format == vpiTimeVal); const p_vpi_time tm = value_p->value.time; c->args[0].integer = (uint64_t)tm->high << 32 | tm->low; c->args[1].integer = 0; return NULL; } vpi_error(vpiError, &(obj->loc), "cannot change value of %s", handle_pp(handle)); return NULL; } vpi_context_t *vpi_context_new(void) { assert(global_context == NULL); vpi_context_t *c = global_context = xcalloc(sizeof(vpi_context_t)); c->objcache = hash_new(128); c->valuestr = tb_new(); c->pool = pool_new(); vpi_register_builtins(); return c; } void vpi_context_initialise(vpi_context_t *c, tree_t top, rt_model_t *model, jit_t *jit, int argc, char **argv) { assert(c->model == NULL); assert(c->top == NULL); assert(c->jit == NULL); c->model = model; c->top = top; c->jit = jit; } static void vpi_handles_diag(vpi_context_t *c, diag_t *d, handle_kind_t kind) { for (int i = 0; i < c->num_handles; i++) { handle_slot_t *slot = &(c->handles[i]); if (slot->obj == NULL || slot->kind != kind) continue; diag_printf(d, "\n%s", handle_pp(encode_handle(slot, i))); c_refcounted *rc = is_refcounted(slot->obj); if (rc != NULL) diag_printf(d, " with %d reference%s", rc->refcount, rc->refcount != 1 ? "s" : ""); } } static void vpi_check_leaks(vpi_context_t *c) { int nuser = 0, ninternal UNUSED = 0; for (int i = 0; i < c->num_handles; i++) { if (c->handles[i].obj == NULL) continue; else if (c->handles[i].kind == HANDLE_INTERNAL) ninternal++; else nuser++; } if (nuser > 0) { diag_t *d = diag_new(DIAG_WARN, NULL); diag_printf(d, "VPI program exited with %d active handles", nuser); vpi_handles_diag(c, d, HANDLE_USER); diag_emit(d); } #ifdef DEBUG if (ninternal > 0) { diag_t *d = diag_new(DIAG_DEBUG, NULL); diag_printf(d, "VPI program exited with %d active internal handles", ninternal); vpi_handles_diag(c, d, HANDLE_INTERNAL); diag_emit(d); } #endif } void vpi_context_free(vpi_context_t *c) { if (opt_get_int(OPT_PLI_DEBUG)) { // Release all system call handles to prevent false positives for (int i = 0; i < c->syscalls.count; i++) { c_sysTfCall *call = is_sysTfCall(c->syscalls.items[i]); assert(call != NULL); if (call->handle != NULL) drop_handle(c, call->handle); } for (int i = 0; i < c->systasks.count; i++) drop_handle(c, c->systasks.items[i]); vpi_check_leaks(c); } assert(c == global_context); global_context = NULL; if (c->strtab != NULL) shash_free(c->strtab); ACLEAR(c->syscalls); ACLEAR(c->systasks); ACLEAR(c->recycle); #ifdef DEBUG size_t alloc, npages; pool_stats(c->pool, &alloc, &npages); if (npages > 1) debugf("VPI allocated %zu bytes in %zu pages", alloc, npages); #endif pool_free(c->pool); tb_free(c->valuestr); hash_free(c->objcache); free(c->handles); free(c); } //////////////////////////////////////////////////////////////////////////////// // Foreign function interface vpiHandle vpi_bind_foreign(ident_t name, vlog_node_t where) { vpi_context_t *c = vpi_context(); c_vpiObject *obj = hash_get(c->objcache, where); if (obj != NULL) { c_sysTfCall *call = is_sysTfCall(obj); assert(call != NULL); return call->handle; } rt_model_t *m = get_model(); rt_scope_t *scope = get_active_scope(m); c_module *mod = cached_module(scope->where, scope); for (int i = 0; i < c->systasks.count; i++) { c_vpiObject *obj = from_handle(c->systasks.items[i]); if (obj == NULL) continue; c_callback *cb = is_callback(obj); assert(cb != NULL); if (cb->name != name) continue; c_sysTfCall *call; if (cb->systf.type == vpiSysTask) call = &(build_sysTaskCall(where, cb, &(mod->scope))->systfcall); else call = &(build_sysFuncCall(where, cb, &(mod->scope))->systfcall); return (call->handle = internal_handle_for(&(call->tfcall.object))); } return NULL; } void vpi_call_foreign(vpiHandle handle, jit_scalar_t *args, tlab_t *tlab) { c_vpiObject *obj = from_handle(handle); if (obj == NULL) jit_msg(NULL, DIAG_FATAL, "called invalid system task"); c_sysTfCall *call = is_sysTfCall(obj); assert(call != NULL); void *orig_p0 = args[0].pointer; vpi_context_t *c = vpi_context(); assert(c->call == NULL); c->call = call; c->args = args; c->tlab = tlab; (*call->callback->systf.calltf)(call->callback->systf.user_data); assert(c->call == call); c->call = NULL; c->args = NULL; c->tlab = NULL; if (call->callback->systf.type == vpiSysFunc && args[0].pointer == orig_p0) jit_msg(NULL, DIAG_FATAL, "system function %s did not return a value", call->callback->systf.tfname); } nvc-r1.17.1/src/vpi/vpi-model.h000066400000000000000000000023231504111170000161710ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VPI_MODEL_H #define _VPI_MODEL_H #include "prim.h" #include "jit/jit.h" typedef unsigned int PLI_UINT32; typedef PLI_UINT32 *vpiHandle; vpi_context_t *vpi_context_new(void); void vpi_context_initialise(vpi_context_t *c, tree_t top, rt_model_t *model, jit_t *jit, int argc, char **argv); void vpi_context_free(vpi_context_t *c); vpiHandle vpi_bind_foreign(ident_t name, vlog_node_t where); void vpi_call_foreign(vpiHandle handle, jit_scalar_t *args, tlab_t *tlab); #endif // _VPI_MODEL_H nvc-r1.17.1/src/vpi/vpi-priv.h000066400000000000000000000030171504111170000160520ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VPI_PRIV_H #define _VPI_PRIV_H #include "prim.h" #ifdef __MINGW32__ #define PLI_DLLISPEC __declspec(dllexport) #define PLI_DLLESPEC #else #define PLI_DLLISPEC #define PLI_DLLESPEC #endif #include "vpi/vpi_user.h" const char *vpi_type_str(PLI_INT32 type); const char *vpi_method_str(PLI_INT32 type); const char *vpi_property_str(PLI_INT32 property); __attribute__((format(printf, 3, 4))) void vpi_error(PLI_INT32 sev, const loc_t *loc, const char *fmt, ...); __attribute__((format(printf, 2, 3))) void vpi_trace(const char *func, const char *fmt, ...); void vpi_register_builtins(void); void vpi_clear_error(void); void vpi_format_number(number_t n, PLI_INT32 format, text_buf_t *tb); void vpi_format_number2(int size, uint64_t abits, uint64_t bbits, PLI_INT32 format, text_buf_t *tb); #endif // _VPI_PRIV_H nvc-r1.17.1/src/vpi/vpi-str.c000066400000000000000000000040151504111170000156740ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "vpi/vpi-priv.h" // LCOV_EXCL_START ///////////////////////////////////////////////////////////// static const char *vpi_fallback_str(int value) { static char buf[16]; checked_sprintf(buf, sizeof(buf), "%d", value); return buf; } const char *vpi_type_str(PLI_INT32 type) { switch (type) { case vpiSysFuncCall: return "vpiSysFuncCall"; case vpiSysTaskCall: return "vpiSysTaskCall"; case vpiIterator: return "vpiIterator"; case vpiCallback: return "vpiCallback"; case vpiConstant: return "vpiConstant"; case vpiOperation: return "vpiOperation"; case vpiModule: return "vpiModule"; case vpiScope: return "vpiScope"; case vpiPort: return "vpiPort"; case vpiNet: return "vpiNet"; case vpiReg: return "vpiReg"; default: return vpi_fallback_str(type); } } const char *vpi_method_str(PLI_INT32 type) { switch (type) { case vpiArgument: return "vpiArgument"; case vpiSysTfCall: return "vpiSysTfCall"; default: return vpi_fallback_str(type); } } const char *vpi_property_str(PLI_INT32 property) { switch (property) { case vpiType: return "vpiType"; case vpiConstType: return "vpiConstType"; case vpiSize: return "vpiSize"; default: return vpi_fallback_str(property); } } // LCOV_EXCL_STOP ////////////////////////////////////////////////////////////// nvc-r1.17.1/src/vpi/vpi-systf.c000066400000000000000000000131131504111170000162330ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "jit/jit.h" #include "rt/model.h" #include "vpi/vpi-priv.h" #include #include #include #include #include static void format_string(vpiHandle it, int fwidth) { vpiHandle arg = vpi_scan(it); if (arg == NULL) return; s_vpi_value argval = { .format = vpiStringVal }; vpi_get_value(arg, &argval); fputs(argval.value.str, stdout); vpi_release_handle(arg); } static int calc_dec_size(int nr_bits, bool is_signed) { // From Icarus Verilog vpi/sys_display.c if (is_signed) --nr_bits; int r = (nr_bits * 146L + 484) / 485; if (is_signed) ++r; return r; } static void format_number(vpiHandle it, char radix, int fwidth) { vpiHandle arg = vpi_scan(it); if (arg == NULL) return; switch (radix) { case 'd': case 't': { s_vpi_value argval = { .format = vpiDecStrVal }; vpi_get_value(arg, &argval); const int nbits = vpi_get(vpiSize, arg); const int dmax = calc_dec_size(nbits, false); if (dmax > strlen(argval.value.str)) printf("%*s", dmax, argval.value.str); else fputs(argval.value.str, stdout); } break; case 'x': case 'h': { s_vpi_value argval = { .format = vpiHexStrVal }; vpi_get_value(arg, &argval); fputs(argval.value.str, stdout); } break; } vpi_release_handle(arg); } static void interpret_format(const char *fmt, vpiHandle it) { const char *start = fmt, *p = fmt; for (; *p; p++) { if (*p == '%') { if (start < p) fwrite(start, 1, p - start, stdout); p++; // Skip over '%' int fwidth = 0; if (isdigit_iso88591(*p)) fwidth = strtol(p + 1, (char **)&p, 10); switch (*p) { case 's': format_string(it, fwidth); break; case 'd': case 'x': case 'h': case 't': format_number(it, *p, fwidth); break; default: jit_msg(NULL, DIAG_FATAL, "unknown format specifier '%c'", *p); } start = p + 1; } } if (start < p) fwrite(start, 1, p - start, stdout); } static void verilog_printf(void) { vpiHandle call = vpi_handle(vpiSysTfCall, NULL); assert(call != NULL); vpiHandle it = vpi_iterate(vpiArgument, call); vpiHandle arg = vpi_scan(it); if (arg == NULL) goto release_handles; const bool has_format = vpi_get(vpiType, arg) == vpiConstant && vpi_get(vpiConstType, arg) == vpiStringConst; if (has_format) { s_vpi_value argval = { .format = vpiStringVal }; vpi_get_value(arg, &argval); char *copy = xstrdup(argval.value.str); interpret_format(copy, it); free(copy); vpi_release_handle(arg); arg = vpi_scan(it); } // TODO: iterate remaining arguments release_handles: vpi_release_handle(it); vpi_release_handle(call); } static PLI_INT32 display_tf(PLI_BYTE8 *userdata) { verilog_printf(); printf("\n"); return 0; } static PLI_INT32 write_tf(PLI_BYTE8 *userdata) { verilog_printf(); return 0; } static PLI_INT32 finish_tf(PLI_BYTE8 *userdata) { notef("$finish called"); jit_abort(); } static PLI_INT32 fatal_tf(PLI_BYTE8 *userdata) { diag_t *d = diag_new(DIAG_FATAL, NULL); diag_printf(d, "$fatal called"); diag_emit(d); jit_abort_with_status(1); } static PLI_INT32 monitor_tf(PLI_BYTE8 *userdata) { // TODO return 0; } static PLI_INT32 time_tf(PLI_BYTE8 *userdata) { rt_model_t *m = get_model(); const int64_t now = model_now(m, NULL); s_vpi_time timeval = { .type = vpiSimTime, .high = now >> 32, .low = now & 0xffffffff }; s_vpi_value result = { .format = vpiTimeVal, .value = { .time = &timeval }, }; vpiHandle call = vpi_handle(vpiSysTfCall, NULL); assert(call != NULL); vpi_put_value(call, &result, NULL, 0); vpi_release_handle(call); return 0; } static s_vpi_systf_data builtins[] = { { .type = vpiSysTask, .tfname = "$display", .calltf = display_tf }, { .type = vpiSysTask, .tfname = "$write", .calltf = write_tf }, { .type = vpiSysTask, .tfname = "$finish", .calltf = finish_tf }, { .type = vpiSysTask, .tfname = "$fatal", .calltf = fatal_tf }, { .type = vpiSysTask, .tfname = "$monitor", .calltf = monitor_tf }, { .type = vpiSysFunc, .tfname = "$time", .sysfunctype = vpiTimeFunc, .calltf = time_tf } }; void vpi_register_builtins(void) { for (int i = 0; i < ARRAY_LEN(builtins); i++) { vpiHandle handle = vpi_register_systf(&builtins[i]); if (handle == NULL) fatal("failed to register system task %s", builtins[i].tfname); } } nvc-r1.17.1/src/vpi/vpi-util.c000066400000000000000000000075711504111170000160530ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "debug.h" #include "diag.h" #include "option.h" #include "vlog/vlog-number.h" #include "vpi/vpi-priv.h" #include #include #include static __thread s_vpi_error_info last_error; void vpi_trace(const char *func, const char *fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(stderr, "VPI: %s ", func); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); } void vpi_error(PLI_INT32 sev, const loc_t *loc, const char *fmt, ...) { last_error.level = sev; last_error.state = vpiRun; if (!loc_invalid_p(loc)) { last_error.file = (char *)loc_file_str(loc); last_error.line = loc->first_line; } free(last_error.message); va_list ap; va_start(ap, fmt); last_error.message = xvasprintf(fmt, ap); va_end(ap); static const diag_level_t map[] = { [vpiNotice] = DIAG_NOTE, [vpiWarning] = DIAG_WARN, [vpiError] = DIAG_ERROR, [vpiSystem] = DIAG_ERROR, [vpiInternal] = DIAG_FATAL, }; if (!opt_get_int(OPT_PLI_DEBUG)) return; // Also report the error as a diagnostic for debugging diag_t *d = diag_new(sev < ARRAY_LEN(map) ? map[sev] : DIAG_ERROR, loc); diag_printf(d, "%s", last_error.message); debug_info_t *trace = debug_capture(); const debug_frame_t *last_prog = NULL, *first_lib = NULL; const int nframes = debug_count_frames(trace); for (int i = 0; i < nframes; i++) { const debug_frame_t *f = debug_get_frame(trace, i); if (f->kind == FRAME_PROG) last_prog = f; else if (f->kind == FRAME_LIB) { first_lib = f; break; } } if (last_prog != NULL && strncmp(last_prog->symbol, "vhpi", 4) == 0) diag_hint(d, NULL, "in call to VHPI function $bold$%s$$", last_prog->symbol); if (first_lib != NULL) diag_hint(d, NULL, "called from user function $bold$%s$$ " "at %s:%d", first_lib->symbol, first_lib->srcfile, first_lib->lineno); debug_free(trace); diag_emit(d); } void vpi_clear_error(void) { last_error.level = 0; free(last_error.message); last_error.message = 0; } void vpi_format_number(number_t n, PLI_INT32 format, text_buf_t *tb) { switch (format) { case vpiBinStrVal: number_print(n, tb); break; case vpiDecStrVal: if (number_is_defined(n)) tb_printf(tb, "%"PRIi64, number_integer(n)); else tb_cat(tb, "x"); break; case vpiHexStrVal: if (number_is_defined(n)) tb_printf(tb, "%0*"PRIx64, number_width(n) / 4, number_integer(n)); else tb_printf(tb, "%*s", number_width(n) / 4, "x"); break; } } void vpi_format_number2(int size, uint64_t abits, uint64_t bbits, PLI_INT32 format, text_buf_t *tb) { switch (format) { case vpiBinStrVal: should_not_reach_here(); break; case vpiDecStrVal: if (bbits == 0) tb_printf(tb, "%"PRIi64, abits); else tb_cat(tb, "x"); break; case vpiHexStrVal: if (bbits == 0) tb_printf(tb, "%0*"PRIx64, size / 4, abits); else tb_printf(tb, "%*s", size / 4, "x"); break; } } nvc-r1.17.1/src/vpi/vpi_user.h000066400000000000000000001314751504111170000161440ustar00rootroot00000000000000/******************************************************************************* * vpi_user.h * * IEEE Std 1800-2017 Programming Language Interface (PLI) * * This file contains the constant definitions, structure definitions, and * routine declarations used by the SystemVerilog Verification Procedural * Interface (VPI) access routines. * ******************************************************************************/ /******************************************************************************* * NOTE: the constant values 1 through 299 are reserved for use in this * vpi_user.h file. ******************************************************************************/ #ifndef VPI_USER_H #define VPI_USER_H #include #ifdef __cplusplus extern "C" { #endif /*----------------------------------------------------------------------------*/ /*----------------------------- Portability Help -----------------------------*/ /*----------------------------------------------------------------------------*/ /* Define size-critical types on all OS platforms. */ #if defined (_MSC_VER) typedef unsigned __int64 uint64_t; typedef unsigned __int32 uint32_t; typedef unsigned __int8 uint8_t; typedef signed __int64 int64_t; typedef signed __int32 int32_t; typedef signed __int8 int8_t; #elif defined(__MINGW32__) #include #elif defined(__linux) || (defined(__APPLE__) && defined(__MACH__)) #include #else #include #endif /* Sized variables */ #ifndef SVPI_TYPES #define SVPI_TYPES typedef int64_t PLI_INT64; typedef uint64_t PLI_UINT64; #endif #ifndef PLI_TYPES #define PLI_TYPES typedef int PLI_INT32; typedef unsigned int PLI_UINT32; typedef short PLI_INT16; typedef unsigned short PLI_UINT16; typedef char PLI_BYTE8; typedef unsigned char PLI_UBYTE8; #endif /* Use to import a symbol */ #if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)) #ifndef PLI_DLLISPEC #define PLI_DLLISPEC __declspec(dllimport) #define VPI_USER_DEFINED_DLLISPEC 1 #endif #else #ifndef PLI_DLLISPEC #define PLI_DLLISPEC #endif #endif /* Use to export a symbol */ #if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__)) #ifndef PLI_DLLESPEC #define PLI_DLLESPEC __declspec(dllexport) #define VPI_USER_DEFINED_DLLESPEC 1 #endif #else #ifndef PLI_DLLESPEC #define PLI_DLLESPEC #endif #endif /* Use to mark a function as external */ #ifndef PLI_EXTERN #define PLI_EXTERN #endif /* Use to mark a variable as external */ #ifndef PLI_VEXTERN #define PLI_VEXTERN extern #endif #ifndef PLI_PROTOTYPES #define PLI_PROTOTYPES #define PROTO_PARAMS(params) params /* object is defined imported by the application */ #undef XXTERN #define XXTERN PLI_EXTERN PLI_DLLISPEC /* object is exported by the application */ #undef EETERN #define EETERN PLI_EXTERN PLI_DLLESPEC #endif /********************************** TYPEDEFS **********************************/ typedef PLI_UINT32 *vpiHandle; /******************************** OBJECT TYPES ********************************/ #define vpiAlways 1 /* always procedure */ #define vpiAssignStmt 2 /* quasi-continuous assignment */ #define vpiAssignment 3 /* procedural assignment */ #define vpiBegin 4 /* block statement */ #define vpiCase 5 /* case statement */ #define vpiCaseItem 6 /* case statement item */ #define vpiConstant 7 /* numerical constant or string literal */ #define vpiContAssign 8 /* continuous assignment */ #define vpiDeassign 9 /* deassignment statement */ #define vpiDefParam 10 /* defparam */ #define vpiDelayControl 11 /* delay statement (e.g., #10) */ #define vpiDisable 12 /* named block disable statement */ #define vpiEventControl 13 /* wait on event, e.g., @e */ #define vpiEventStmt 14 /* event trigger, e.g., ->e */ #define vpiFor 15 /* for statement */ #define vpiForce 16 /* force statement */ #define vpiForever 17 /* forever statement */ #define vpiFork 18 /* fork-join block */ #define vpiFuncCall 19 /* function call */ #define vpiFunction 20 /* function */ #define vpiGate 21 /* primitive gate */ #define vpiIf 22 /* if statement */ #define vpiIfElse 23 /* if-else statement */ #define vpiInitial 24 /* initial procedure */ #define vpiIntegerVar 25 /* integer variable */ #define vpiInterModPath 26 /* intermodule wire delay */ #define vpiIterator 27 /* iterator */ #define vpiIODecl 28 /* input/output declaration */ #define vpiMemory 29 /* behavioral memory */ #define vpiMemoryWord 30 /* single word of memory */ #define vpiModPath 31 /* module path for path delays */ #define vpiModule 32 /* module instance */ #define vpiNamedBegin 33 /* named block statement */ #define vpiNamedEvent 34 /* event variable */ #define vpiNamedFork 35 /* named fork-join block */ #define vpiNet 36 /* scalar or vector net */ #define vpiNetBit 37 /* bit of vector net */ #define vpiNullStmt 38 /* a semicolon. Ie. #10 ; */ #define vpiOperation 39 /* behavioral operation */ #define vpiParamAssign 40 /* module parameter assignment */ #define vpiParameter 41 /* module parameter */ #define vpiPartSelect 42 /* part-select */ #define vpiPathTerm 43 /* terminal of module path */ #define vpiPort 44 /* module port */ #define vpiPortBit 45 /* bit of vector module port */ #define vpiPrimTerm 46 /* primitive terminal */ #define vpiRealVar 47 /* real variable */ #define vpiReg 48 /* scalar or vector reg */ #define vpiRegBit 49 /* bit of vector reg */ #define vpiRelease 50 /* release statement */ #define vpiRepeat 51 /* repeat statement */ #define vpiRepeatControl 52 /* repeat control in an assign stmt */ #define vpiSchedEvent 53 /* vpi_put_value() event */ #define vpiSpecParam 54 /* specparam */ #define vpiSwitch 55 /* transistor switch */ #define vpiSysFuncCall 56 /* system function call */ #define vpiSysTaskCall 57 /* system task call */ #define vpiTableEntry 58 /* UDP state table entry */ #define vpiTask 59 /* task */ #define vpiTaskCall 60 /* task call */ #define vpiTchk 61 /* timing check */ #define vpiTchkTerm 62 /* terminal of timing check */ #define vpiTimeVar 63 /* time variable */ #define vpiTimeQueue 64 /* simulation event queue */ #define vpiUdp 65 /* user-defined primitive */ #define vpiUdpDefn 66 /* UDP definition */ #define vpiUserSystf 67 /* user-defined system task/function */ #define vpiVarSelect 68 /* variable array selection */ #define vpiWait 69 /* wait statement */ #define vpiWhile 70 /* while statement */ /********************** object types added with 1364-2001 *********************/ #define vpiAttribute 105 /* attribute of an object */ #define vpiBitSelect 106 /* Bit-select of parameter, var select */ #define vpiCallback 107 /* callback object */ #define vpiDelayTerm 108 /* Delay term which is a load or driver */ #define vpiDelayDevice 109 /* Delay object within a net */ #define vpiFrame 110 /* reentrant task/func frame */ #define vpiGateArray 111 /* gate instance array */ #define vpiModuleArray 112 /* module instance array */ #define vpiPrimitiveArray 113 /* vpiprimitiveArray type */ #define vpiNetArray 114 /* multidimensional net */ #define vpiRange 115 /* range declaration */ #define vpiRegArray 116 /* multidimensional reg */ #define vpiSwitchArray 117 /* switch instance array */ #define vpiUdpArray 118 /* UDP instance array */ #define vpiContAssignBit 128 /* Bit of a vector continuous assignment */ #define vpiNamedEventArray 129 /* multidimensional named event */ /********************** object types added with 1364-2005 *********************/ #define vpiIndexedPartSelect 130 /* Indexed part-select object */ #define vpiGenScopeArray 133 /* array of generated scopes */ #define vpiGenScope 134 /* A generated scope */ #define vpiGenVar 135 /* Object used to instantiate gen scopes */ /*********************************** METHODS **********************************/ /**************** methods used to traverse 1 to 1 relationships ***************/ #define vpiCondition 71 /* condition expression */ #define vpiDelay 72 /* net or gate delay */ #define vpiElseStmt 73 /* else statement */ #define vpiForIncStmt 74 /* increment statement in for loop */ #define vpiForInitStmt 75 /* initialization statement in for loop */ #define vpiHighConn 76 /* higher connection to port */ #define vpiLhs 77 /* left-hand side of assignment */ #define vpiIndex 78 /* index of var select, bit-select, etc. */ #define vpiLeftRange 79 /* left range of vector or part-select */ #define vpiLowConn 80 /* lower connection to port */ #define vpiParent 81 /* parent object */ #define vpiRhs 82 /* right-hand side of assignment */ #define vpiRightRange 83 /* right range of vector or part-select */ #define vpiScope 84 /* containing scope object */ #define vpiSysTfCall 85 /* task function call */ #define vpiTchkDataTerm 86 /* timing check data term */ #define vpiTchkNotifier 87 /* timing check notifier */ #define vpiTchkRefTerm 88 /* timing check reference term */ /************* methods used to traverse 1 to many relationships ***************/ #define vpiArgument 89 /* argument to (system) task/function */ #define vpiBit 90 /* bit of vector net or port */ #define vpiDriver 91 /* driver for a net */ #define vpiInternalScope 92 /* internal scope in module */ #define vpiLoad 93 /* load on net or reg */ #define vpiModDataPathIn 94 /* data terminal of a module path */ #define vpiModPathIn 95 /* Input terminal of a module path */ #define vpiModPathOut 96 /* output terminal of a module path */ #define vpiOperand 97 /* operand of expression */ #define vpiPortInst 98 /* connected port instance */ #define vpiProcess 99 /* process in module, program or interface */ #define vpiVariables 100 /* variables in module */ #define vpiUse 101 /* usage */ /******** methods which can traverse 1 to 1, or 1 to many relationships *******/ #define vpiExpr 102 /* connected expression */ #define vpiPrimitive 103 /* primitive (gate, switch, UDP) */ #define vpiStmt 104 /* statement in process or task */ /************************ methods added with 1364-2001 ************************/ #define vpiActiveTimeFormat 119 /* active $timeformat() system task */ #define vpiInTerm 120 /* To get to a delay device's drivers. */ #define vpiInstanceArray 121 /* vpiInstance arrays */ #define vpiLocalDriver 122 /* local drivers (within a module */ #define vpiLocalLoad 123 /* local loads (within a module */ #define vpiOutTerm 124 /* To get to a delay device's loads. */ #define vpiPorts 125 /* Module port */ #define vpiSimNet 126 /* simulated net after collapsing */ #define vpiTaskFunc 127 /* task/function */ /************************ methods added with 1364-2005 ************************/ #define vpiBaseExpr 131 /* Indexed part-select's base expression */ #define vpiWidthExpr 132 /* Indexed part-select's width expression */ /************************ methods added with 1800-2009 ************************/ #define vpiAutomatics 136 /* Automatic variables of a frame */ /********************************* PROPERTIES *********************************/ /************************** generic object properties *************************/ #define vpiUndefined -1 /* undefined property */ #define vpiType 1 /* type of object */ #define vpiName 2 /* local name of object */ #define vpiFullName 3 /* full hierarchical name */ #define vpiSize 4 /* size of gate, net, port, etc. */ #define vpiFile 5 /* File name in which the object is used*/ #define vpiLineNo 6 /* line number where the object is used */ /***************************** module properties ******************************/ #define vpiTopModule 7 /* top-level module (Boolean) */ #define vpiCellInstance 8 /* cell (Boolean) */ #define vpiDefName 9 /* module definition name */ #define vpiProtected 10 /* source protected module (Boolean) */ #define vpiTimeUnit 11 /* module time unit */ #define vpiTimePrecision 12 /* module time precision */ #define vpiDefNetType 13 /* default net type */ #define vpiUnconnDrive 14 /* unconnected port drive strength */ #define vpiHighZ 1 /* No default drive given */ #define vpiPull1 2 /* default pull1 drive */ #define vpiPull0 3 /* default pull0 drive */ #define vpiDefFile 15 /* File name where the module is defined*/ #define vpiDefLineNo 16 /* line number for module definition */ #define vpiDefDelayMode 47 /* Default delay mode for a module */ #define vpiDelayModeNone 1 /* no delay mode specified */ #define vpiDelayModePath 2 /* path delay mode */ #define vpiDelayModeDistrib 3 /* distributed delay mode */ #define vpiDelayModeUnit 4 /* unit delay mode */ #define vpiDelayModeZero 5 /* zero delay mode */ #define vpiDelayModeMTM 6 /* min:typ:max delay mode */ #define vpiDefDecayTime 48 /* Default decay time for a module */ /*************************** port and net properties **************************/ #define vpiScalar 17 /* scalar (Boolean) */ #define vpiVector 18 /* vector (Boolean) */ #define vpiExplicitName 19 /* port is explicitly named */ #define vpiDirection 20 /* direction of port: */ #define vpiInput 1 /* input */ #define vpiOutput 2 /* output */ #define vpiInout 3 /* inout */ #define vpiMixedIO 4 /* mixed input-output */ #define vpiNoDirection 5 /* no direction */ #define vpiConnByName 21 /* connected by name (Boolean) */ #define vpiNetType 22 /* net subtypes: */ #define vpiWire 1 /* wire net */ #define vpiWand 2 /* wire-and net */ #define vpiWor 3 /* wire-or net */ #define vpiTri 4 /* tri net */ #define vpiTri0 5 /* pull-down net */ #define vpiTri1 6 /* pull-up net */ #define vpiTriReg 7 /* three-state reg net */ #define vpiTriAnd 8 /* three-state wire-and net */ #define vpiTriOr 9 /* three-state wire-or net */ #define vpiSupply1 10 /* supply-1 net */ #define vpiSupply0 11 /* supply-0 net */ #define vpiNone 12 /* no default net type (1364-2001) */ #define vpiUwire 13 /* unresolved wire net (1364-2005) */ #define vpiExplicitScalared 23 /* explicitly scalared (Boolean) */ #define vpiExplicitVectored 24 /* explicitly vectored (Boolean) */ #define vpiExpanded 25 /* expanded vector net (Boolean) */ #define vpiImplicitDecl 26 /* implicitly declared net (Boolean) */ #define vpiChargeStrength 27 /* charge decay strength of net */ /* Defined as part of strengths section. #define vpiLargeCharge 0x10 #define vpiMediumCharge 0x04 #define vpiSmallCharge 0x02 */ #define vpiArray 28 /* variable array (Boolean) */ #define vpiPortIndex 29 /* Port index */ /************************ gate and terminal properties ************************/ #define vpiTermIndex 30 /* Index of a primitive terminal */ #define vpiStrength0 31 /* 0-strength of net or gate */ #define vpiStrength1 32 /* 1-strength of net or gate */ #define vpiPrimType 33 /* primitive subtypes: */ #define vpiAndPrim 1 /* and gate */ #define vpiNandPrim 2 /* nand gate */ #define vpiNorPrim 3 /* nor gate */ #define vpiOrPrim 4 /* or gate */ #define vpiXorPrim 5 /* xor gate */ #define vpiXnorPrim 6 /* xnor gate */ #define vpiBufPrim 7 /* buffer */ #define vpiNotPrim 8 /* not gate */ #define vpiBufif0Prim 9 /* zero-enabled buffer */ #define vpiBufif1Prim 10 /* one-enabled buffer */ #define vpiNotif0Prim 11 /* zero-enabled not gate */ #define vpiNotif1Prim 12 /* one-enabled not gate */ #define vpiNmosPrim 13 /* nmos switch */ #define vpiPmosPrim 14 /* pmos switch */ #define vpiCmosPrim 15 /* cmos switch */ #define vpiRnmosPrim 16 /* resistive nmos switch */ #define vpiRpmosPrim 17 /* resistive pmos switch */ #define vpiRcmosPrim 18 /* resistive cmos switch */ #define vpiRtranPrim 19 /* resistive bidirectional */ #define vpiRtranif0Prim 20 /* zero-enable resistive bidirectional */ #define vpiRtranif1Prim 21 /* one-enable resistive bidirectional */ #define vpiTranPrim 22 /* bidirectional */ #define vpiTranif0Prim 23 /* zero-enabled bidirectional */ #define vpiTranif1Prim 24 /* one-enabled bidirectional */ #define vpiPullupPrim 25 /* pullup */ #define vpiPulldownPrim 26 /* pulldown */ #define vpiSeqPrim 27 /* sequential UDP */ #define vpiCombPrim 28 /* combinational UDP */ /**************** path, path terminal, timing check properties ****************/ #define vpiPolarity 34 /* polarity of module path... */ #define vpiDataPolarity 35 /* ...or data path: */ #define vpiPositive 1 /* positive */ #define vpiNegative 2 /* negative */ #define vpiUnknown 3 /* unknown (unspecified) */ #define vpiEdge 36 /* edge type of module path: */ #define vpiNoEdge 0x00 /* no edge */ #define vpiEdge01 0x01 /* 0 -> 1 */ #define vpiEdge10 0x02 /* 1 -> 0 */ #define vpiEdge0x 0x04 /* 0 -> x */ #define vpiEdgex1 0x08 /* x -> 1 */ #define vpiEdge1x 0x10 /* 1 -> x */ #define vpiEdgex0 0x20 /* x -> 0 */ #define vpiPosedge (vpiEdgex1 | vpiEdge01 | vpiEdge0x) #define vpiNegedge (vpiEdgex0 | vpiEdge10 | vpiEdge1x) #define vpiAnyEdge (vpiPosedge | vpiNegedge) #define vpiPathType 37 /* path delay connection subtypes: */ #define vpiPathFull 1 /* ( a *> b ) */ #define vpiPathParallel 2 /* ( a => b ) */ #define vpiTchkType 38 /* timing check subtypes: */ #define vpiSetup 1 /* $setup */ #define vpiHold 2 /* $hold */ #define vpiPeriod 3 /* $period */ #define vpiWidth 4 /* $width */ #define vpiSkew 5 /* $skew */ #define vpiRecovery 6 /* $recovery */ #define vpiNoChange 7 /* $nochange */ #define vpiSetupHold 8 /* $setuphold */ #define vpiFullskew 9 /* $fullskew -- added for 1364-2001 */ #define vpiRecrem 10 /* $recrem -- added for 1364-2001 */ #define vpiRemoval 11 /* $removal -- added for 1364-2001 */ #define vpiTimeskew 12 /* $timeskew -- added for 1364-2001 */ /**************************** expression properties ***************************/ #define vpiOpType 39 /* operation subtypes: */ #define vpiMinusOp 1 /* unary minus */ #define vpiPlusOp 2 /* unary plus */ #define vpiNotOp 3 /* unary not */ #define vpiBitNegOp 4 /* bitwise negation */ #define vpiUnaryAndOp 5 /* bitwise reduction AND */ #define vpiUnaryNandOp 6 /* bitwise reduction NAND */ #define vpiUnaryOrOp 7 /* bitwise reduction OR */ #define vpiUnaryNorOp 8 /* bitwise reduction NOR */ #define vpiUnaryXorOp 9 /* bitwise reduction XOR */ #define vpiUnaryXNorOp 10 /* bitwise reduction XNOR */ #define vpiSubOp 11 /* binary subtraction */ #define vpiDivOp 12 /* binary division */ #define vpiModOp 13 /* binary modulus */ #define vpiEqOp 14 /* binary equality */ #define vpiNeqOp 15 /* binary inequality */ #define vpiCaseEqOp 16 /* case (x and z) equality */ #define vpiCaseNeqOp 17 /* case inequality */ #define vpiGtOp 18 /* binary greater than */ #define vpiGeOp 19 /* binary greater than or equal */ #define vpiLtOp 20 /* binary less than */ #define vpiLeOp 21 /* binary less than or equal */ #define vpiLShiftOp 22 /* binary left shift */ #define vpiRShiftOp 23 /* binary right shift */ #define vpiAddOp 24 /* binary addition */ #define vpiMultOp 25 /* binary multiplication */ #define vpiLogAndOp 26 /* binary logical AND */ #define vpiLogOrOp 27 /* binary logical OR */ #define vpiBitAndOp 28 /* binary bitwise AND */ #define vpiBitOrOp 29 /* binary bitwise OR */ #define vpiBitXorOp 30 /* binary bitwise XOR */ #define vpiBitXNorOp 31 /* binary bitwise XNOR */ #define vpiBitXnorOp vpiBitXNorOp /* added with 1364-2001 */ #define vpiConditionOp 32 /* ternary conditional */ #define vpiConcatOp 33 /* n-ary concatenation */ #define vpiMultiConcatOp 34 /* repeated concatenation */ #define vpiEventOrOp 35 /* event OR */ #define vpiNullOp 36 /* null operation */ #define vpiListOp 37 /* list of expressions */ #define vpiMinTypMaxOp 38 /* min:typ:max: delay expression */ #define vpiPosedgeOp 39 /* posedge */ #define vpiNegedgeOp 40 /* negedge */ #define vpiArithLShiftOp 41 /* arithmetic left shift (1364-2001) */ #define vpiArithRShiftOp 42 /* arithmetic right shift (1364-2001) */ #define vpiPowerOp 43 /* arithmetic power op (1364-2001) */ /* From System Verilog */ #define vpiPostIncOp 62 /* ++ post-increment */ #define vpiPreIncOp 63 /* ++ pre-increment */ #define vpiPostDecOp 64 /* -- post-decrement */ #define vpiPreDecOp 65 /* -- pre-decrement */ #define vpiConstType 40 /* constant subtypes: */ #define vpiDecConst 1 /* decimal integer */ #define vpiRealConst 2 /* real */ #define vpiBinaryConst 3 /* binary integer */ #define vpiOctConst 4 /* octal integer */ #define vpiHexConst 5 /* hexadecimal integer */ #define vpiStringConst 6 /* string literal */ #define vpiIntConst 7 /* integer constant (1364-2001) */ #define vpiTimeConst 8 /* time constant */ #define vpiBlocking 41 /* blocking assignment (Boolean) */ #define vpiCaseType 42 /* case statement subtypes: */ #define vpiCaseExact 1 /* exact match */ #define vpiCaseX 2 /* ignore X's */ #define vpiCaseZ 3 /* ignore Z's */ #define vpiNetDeclAssign 43 /* assign part of decl (Boolean) */ /************************** task/function properties **************************/ #define vpiFuncType 44 /* function & system function type */ #define vpiIntFunc 1 /* returns integer */ #define vpiRealFunc 2 /* returns real */ #define vpiTimeFunc 3 /* returns time */ #define vpiSizedFunc 4 /* returns an arbitrary size */ #define vpiSizedSignedFunc 5 /* returns sized signed value */ /** alias 1364-1995 system function subtypes to 1364-2001 function subtypes ***/ #define vpiSysFuncType vpiFuncType #define vpiSysFuncInt vpiIntFunc #define vpiSysFuncReal vpiRealFunc #define vpiSysFuncTime vpiTimeFunc #define vpiSysFuncSized vpiSizedFunc #define vpiUserDefn 45 /*user-defined system task/func(Boolean)*/ #define vpiScheduled 46 /* object still scheduled (Boolean) */ /*********************** properties added with 1364-2001 **********************/ #define vpiActive 49 /* reentrant task/func frame is active */ #define vpiAutomatic 50 /* task/func obj is automatic */ #define vpiCell 51 /* configuration cell */ #define vpiConfig 52 /* configuration config file */ #define vpiConstantSelect 53 /* (Boolean) bit-select or part-select indices are constant expressions */ #define vpiDecompile 54 /* decompile the object */ #define vpiDefAttribute 55 /* Attribute defined for the obj */ #define vpiDelayType 56 /* delay subtype */ #define vpiModPathDelay 1 /* module path delay */ #define vpiInterModPathDelay 2 /* intermodule path delay */ #define vpiMIPDelay 3 /* module input port delay */ #define vpiIteratorType 57 /* object type of an iterator */ #define vpiLibrary 58 /* configuration library */ #define vpiOffset 60 /* offset from LSB */ #define vpiResolvedNetType 61 /* net subtype after resolution, returns same subtypes as vpiNetType */ #define vpiSaveRestartID 62 /* unique ID for save/restart data */ #define vpiSaveRestartLocation 63 /* name of save/restart data file */ /* vpiValid,vpiValidTrue,vpiValidFalse were deprecated in 1800-2009 */ #define vpiValid 64 /* reentrant task/func frame or automatic variable is valid */ #define vpiValidFalse 0 #define vpiValidTrue 1 #define vpiSigned 65 /* TRUE for vpiIODecl and any object in the expression class if the object has the signed attribute */ #define vpiLocalParam 70 /* TRUE when a param is declared as a localparam */ #define vpiModPathHasIfNone 71 /* Mod path has an ifnone statement */ /*********************** properties added with 1364-2005 **********************/ #define vpiIndexedPartSelectType 72 /* Indexed part-select type */ #define vpiPosIndexed 1 /* +: */ #define vpiNegIndexed 2 /* -: */ #define vpiIsMemory 73 /* TRUE for a one-dimensional reg array */ #define vpiIsProtected 74 /* TRUE for protected design information */ /*************** vpi_control() constants (added with 1364-2001) ***************/ #define vpiStop 66 /* execute simulator's $stop */ #define vpiFinish 67 /* execute simulator's $finish */ #define vpiReset 68 /* execute simulator's $reset */ #define vpiSetInteractiveScope 69 /* set simulator's interactive scope */ /**************************** I/O related defines *****************************/ #define VPI_MCD_STDOUT 0x00000001 /*************************** STRUCTURE DEFINITIONS ****************************/ /******************************* time structure *******************************/ typedef struct t_vpi_time { PLI_INT32 type; /* [vpiScaledRealTime, vpiSimTime, vpiSuppressTime] */ PLI_UINT32 high, low; /* for vpiSimTime */ double real; /* for vpiScaledRealTime */ } s_vpi_time, *p_vpi_time; /* time types */ #define vpiScaledRealTime 1 #define vpiSimTime 2 #define vpiSuppressTime 3 /****************************** delay structures ******************************/ typedef struct t_vpi_delay { struct t_vpi_time *da; /* pointer to application-allocated array of delay values */ PLI_INT32 no_of_delays; /* number of delays */ PLI_INT32 time_type; /* [vpiScaledRealTime, vpiSimTime, vpiSuppressTime] */ PLI_INT32 mtm_flag; /* true for mtm values */ PLI_INT32 append_flag; /* true for append */ PLI_INT32 pulsere_flag; /* true for pulsere values */ } s_vpi_delay, *p_vpi_delay; /***************************** value structures *******************************/ /* vector value */ #ifndef VPI_VECVAL /* added in 1364-2005 */ #define VPI_VECVAL typedef struct t_vpi_vecval { /* following fields are repeated enough times to contain vector */ PLI_UINT32 aval, bval; /* bit encoding: ab: 00=0, 10=1, 11=X, 01=Z */ } s_vpi_vecval, *p_vpi_vecval; #endif /* strength (scalar) value */ typedef struct t_vpi_strengthval { PLI_INT32 logic; /* vpi[0,1,X,Z] */ PLI_INT32 s0, s1; /* refer to strength coding below */ } s_vpi_strengthval, *p_vpi_strengthval; /* strength values */ #define vpiSupplyDrive 0x80 #define vpiStrongDrive 0x40 #define vpiPullDrive 0x20 #define vpiWeakDrive 0x08 #define vpiLargeCharge 0x10 #define vpiMediumCharge 0x04 #define vpiSmallCharge 0x02 #define vpiHiZ 0x01 /* generic value */ typedef struct t_vpi_value { PLI_INT32 format; /* vpi[[Bin,Oct,Dec,Hex]Str,Scalar,Int,UInt,Real,String, Vector,Strength,Suppress,Time,ObjType]Val */ union { PLI_BYTE8 *str; /* string value */ PLI_INT32 scalar; /* vpi[0,1,X,Z] */ PLI_INT32 integer; /* integer value */ double real; /* real value */ struct t_vpi_time *time; /* time value */ struct t_vpi_vecval *vector; /* vector value */ struct t_vpi_strengthval *strength; /* strength value */ PLI_BYTE8 *misc; /* ...other */ } value; } s_vpi_value, *p_vpi_value; typedef struct t_vpi_arrayvalue { PLI_UINT32 format; /* vpi[Int,Real,Time,ShortInt,LongInt,ShortReal, RawTwoState,RawFourState]Val */ PLI_UINT32 flags; /* array bit flags- vpiUserAllocFlag */ union { PLI_INT32 *integers; /* integer values */ PLI_INT16 *shortints; /* short integer values */ PLI_INT64 *longints; /* long integer values */ PLI_BYTE8 *rawvals; /* 2/4-state vector elements */ struct t_vpi_vecval *vectors; /* 4-state vector elements */ struct t_vpi_time *times; /* time values */ double *reals; /* real values */ float *shortreals; /* short real values */ } value; } s_vpi_arrayvalue, *p_vpi_arrayvalue; /* value formats */ #define vpiBinStrVal 1 #define vpiOctStrVal 2 #define vpiDecStrVal 3 #define vpiHexStrVal 4 #define vpiScalarVal 5 #define vpiIntVal 6 #define vpiUIntVal 19 #define vpiRealVal 7 #define vpiStringVal 8 #define vpiVectorVal 9 #define vpiStrengthVal 10 #define vpiTimeVal 11 #define vpiObjTypeVal 12 #define vpiSuppressVal 13 #define vpiShortIntVal 14 #define vpiLongIntVal 15 #define vpiShortRealVal 16 #define vpiRawTwoStateVal 17 #define vpiRawFourStateVal 18 /* delay modes */ #define vpiNoDelay 1 #define vpiInertialDelay 2 #define vpiTransportDelay 3 #define vpiPureTransportDelay 4 /* force and release flags */ #define vpiForceFlag 5 #define vpiReleaseFlag 6 /* scheduled event cancel flag */ #define vpiCancelEvent 7 /* bit mask for the flags argument to vpi_put_value() */ #define vpiReturnEvent 0x1000 /* bit flags for vpi_get_value_array flags field */ #define vpiUserAllocFlag 0x2000 /* bit flags for vpi_put_value_array flags field */ #define vpiOneValue 0x4000 #define vpiPropagateOff 0x8000 /* scalar values */ #define vpi0 0 #define vpi1 1 #define vpiZ 2 #define vpiX 3 #define vpiH 4 #define vpiL 5 #define vpiDontCare 6 /* #define vpiNoChange 7 Defined under vpiTchkType, but can be used here. */ /*********************** system task/function structure ***********************/ typedef struct t_vpi_systf_data { PLI_INT32 type; /* vpiSysTask, vpiSysFunc */ PLI_INT32 sysfunctype; /* vpiSysTask, vpi[Int,Real,Time,Sized, SizedSigned]Func */ PLI_BYTE8 *tfname; /* first character must be '$' */ PLI_INT32 (*calltf)(PLI_BYTE8 *); PLI_INT32 (*compiletf)(PLI_BYTE8 *); PLI_INT32 (*sizetf)(PLI_BYTE8 *); /* for sized function callbacks only */ PLI_BYTE8 *user_data; } s_vpi_systf_data, *p_vpi_systf_data; #define vpiSysTask 1 #define vpiSysFunc 2 /* the subtypes are defined under the vpiFuncType property */ /**************** SystemVerilog execution information structure ***************/ typedef struct t_vpi_vlog_info { PLI_INT32 argc; PLI_BYTE8 **argv; PLI_BYTE8 *product; PLI_BYTE8 *version; } s_vpi_vlog_info, *p_vpi_vlog_info; /*********************** PLI error information structure **********************/ typedef struct t_vpi_error_info { PLI_INT32 state; /* vpi[Compile,PLI,Run] */ PLI_INT32 level; /* vpi[Notice,Warning,Error,System,Internal] */ PLI_BYTE8 *message; PLI_BYTE8 *product; PLI_BYTE8 *code; PLI_BYTE8 *file; PLI_INT32 line; } s_vpi_error_info, *p_vpi_error_info; /* state when error occurred */ #define vpiCompile 1 #define vpiPLI 2 #define vpiRun 3 /* error severity levels */ #define vpiNotice 1 #define vpiWarning 2 #define vpiError 3 #define vpiSystem 4 #define vpiInternal 5 /**************************** callback structures *****************************/ /* normal callback structure */ typedef struct t_cb_data { PLI_INT32 reason; /* callback reason */ PLI_INT32 (*cb_rtn)(struct t_cb_data *); /* call routine */ vpiHandle obj; /* trigger object */ p_vpi_time time; /* callback time */ p_vpi_value value; /* trigger object value */ PLI_INT32 index; /* index of the memory word or var select that changed */ PLI_BYTE8 *user_data; } s_cb_data, *p_cb_data; /****************************** CALLBACK REASONS ******************************/ /***************************** Simulation related *****************************/ #define cbValueChange 1 #define cbStmt 2 #define cbForce 3 #define cbRelease 4 /******************************** Time related ********************************/ #define cbAtStartOfSimTime 5 #define cbReadWriteSynch 6 #define cbReadOnlySynch 7 #define cbNextSimTime 8 #define cbAfterDelay 9 /******************************* Action related *******************************/ #define cbEndOfCompile 10 #define cbStartOfSimulation 11 #define cbEndOfSimulation 12 #define cbError 13 #define cbTchkViolation 14 #define cbStartOfSave 15 #define cbEndOfSave 16 #define cbStartOfRestart 17 #define cbEndOfRestart 18 #define cbStartOfReset 19 #define cbEndOfReset 20 #define cbEnterInteractive 21 #define cbExitInteractive 22 #define cbInteractiveScopeChange 23 #define cbUnresolvedSystf 24 /**************************** Added with 1364-2001 ****************************/ #define cbAssign 25 #define cbDeassign 26 #define cbDisable 27 #define cbPLIError 28 #define cbSignal 29 /**************************** Added with 1364-2005 ****************************/ #define cbNBASynch 30 #define cbAtEndOfSimTime 31 /**************************** FUNCTION DECLARATIONS ***************************/ /* Include compatibility mode macro definitions. */ //#include "vpi_compatibility.h" /* callback related */ XXTERN vpiHandle vpi_register_cb PROTO_PARAMS((p_cb_data cb_data_p)); XXTERN PLI_INT32 vpi_remove_cb PROTO_PARAMS((vpiHandle cb_obj)); XXTERN void vpi_get_cb_info PROTO_PARAMS((vpiHandle object, p_cb_data cb_data_p)); XXTERN vpiHandle vpi_register_systf PROTO_PARAMS((p_vpi_systf_data systf_data_p)); XXTERN void vpi_get_systf_info PROTO_PARAMS((vpiHandle object, p_vpi_systf_data systf_data_p)); /* for obtaining handles */ XXTERN vpiHandle vpi_handle_by_name PROTO_PARAMS((PLI_BYTE8 *name, vpiHandle scope)); XXTERN vpiHandle vpi_handle_by_index PROTO_PARAMS((vpiHandle object, PLI_INT32 indx)); /* for traversing relationships */ XXTERN vpiHandle vpi_handle PROTO_PARAMS((PLI_INT32 type, vpiHandle refHandle)); XXTERN vpiHandle vpi_handle_multi PROTO_PARAMS((PLI_INT32 type, vpiHandle refHandle1, vpiHandle refHandle2, ... )); XXTERN vpiHandle vpi_iterate PROTO_PARAMS((PLI_INT32 type, vpiHandle refHandle)); XXTERN vpiHandle vpi_scan PROTO_PARAMS((vpiHandle iterator)); /* for processing properties */ XXTERN PLI_INT32 vpi_get PROTO_PARAMS((PLI_INT32 property, vpiHandle object)); XXTERN PLI_INT64 vpi_get64 PROTO_PARAMS((PLI_INT32 property, vpiHandle object)); XXTERN PLI_BYTE8 *vpi_get_str PROTO_PARAMS((PLI_INT32 property, vpiHandle object)); /* delay processing */ XXTERN void vpi_get_delays PROTO_PARAMS((vpiHandle object, p_vpi_delay delay_p)); XXTERN void vpi_put_delays PROTO_PARAMS((vpiHandle object, p_vpi_delay delay_p)); /* value processing */ XXTERN void vpi_get_value PROTO_PARAMS((vpiHandle expr, p_vpi_value value_p)); XXTERN vpiHandle vpi_put_value PROTO_PARAMS((vpiHandle object, p_vpi_value value_p, p_vpi_time time_p, PLI_INT32 flags)); XXTERN void vpi_get_value_array PROTO_PARAMS((vpiHandle object, p_vpi_arrayvalue arrayvalue_p, PLI_INT32 *index_p, PLI_UINT32 num)); XXTERN void vpi_put_value_array PROTO_PARAMS((vpiHandle object, p_vpi_arrayvalue arrayvalue_p, PLI_INT32 *index_p, PLI_UINT32 num)); /* time processing */ XXTERN void vpi_get_time PROTO_PARAMS((vpiHandle object, p_vpi_time time_p)); /* I/O routines */ XXTERN PLI_UINT32 vpi_mcd_open PROTO_PARAMS((PLI_BYTE8 *fileName)); XXTERN PLI_UINT32 vpi_mcd_close PROTO_PARAMS((PLI_UINT32 mcd)); XXTERN PLI_BYTE8 *vpi_mcd_name PROTO_PARAMS((PLI_UINT32 cd)); XXTERN PLI_INT32 vpi_mcd_printf PROTO_PARAMS((PLI_UINT32 mcd, PLI_BYTE8 *format, ...)); XXTERN PLI_INT32 vpi_printf PROTO_PARAMS((PLI_BYTE8 *format, ...)); /* utility routines */ XXTERN PLI_INT32 vpi_compare_objects PROTO_PARAMS((vpiHandle object1, vpiHandle object2)); XXTERN PLI_INT32 vpi_chk_error PROTO_PARAMS((p_vpi_error_info error_info_p)); /* vpi_free_object() was deprecated in 1800-2009 */ XXTERN PLI_INT32 vpi_free_object PROTO_PARAMS((vpiHandle object)); XXTERN PLI_INT32 vpi_release_handle PROTO_PARAMS((vpiHandle object)); XXTERN PLI_INT32 vpi_get_vlog_info PROTO_PARAMS((p_vpi_vlog_info vlog_info_p)); /* routines added with 1364-2001 */ XXTERN PLI_INT32 vpi_get_data PROTO_PARAMS((PLI_INT32 id, PLI_BYTE8 *dataLoc, PLI_INT32 numOfBytes)); XXTERN PLI_INT32 vpi_put_data PROTO_PARAMS((PLI_INT32 id, PLI_BYTE8 *dataLoc, PLI_INT32 numOfBytes)); XXTERN void *vpi_get_userdata PROTO_PARAMS((vpiHandle obj)); XXTERN PLI_INT32 vpi_put_userdata PROTO_PARAMS((vpiHandle obj, void *userdata)); #ifndef SWIG XXTERN PLI_INT32 vpi_vprintf PROTO_PARAMS((PLI_BYTE8 *format, va_list ap)); XXTERN PLI_INT32 vpi_mcd_vprintf PROTO_PARAMS((PLI_UINT32 mcd, PLI_BYTE8 *format, va_list ap)); #endif XXTERN PLI_INT32 vpi_flush PROTO_PARAMS((void)); XXTERN PLI_INT32 vpi_mcd_flush PROTO_PARAMS((PLI_UINT32 mcd)); XXTERN PLI_INT32 vpi_control PROTO_PARAMS((PLI_INT32 operation, ...)); XXTERN vpiHandle vpi_handle_by_multi_index PROTO_PARAMS((vpiHandle obj, PLI_INT32 num_index, PLI_INT32 *index_array)); /****************************** GLOBAL VARIABLES ******************************/ PLI_VEXTERN PLI_DLLESPEC void (*vlog_startup_routines[])( void ); /* array of function pointers, last pointer should be null */ #undef PLI_EXTERN #undef PLI_VEXTERN #ifdef VPI_USER_DEFINED_DLLISPEC # undef VPI_USER_DEFINED_DLLISPEC # undef PLI_DLLISPEC #endif #ifdef VPI_USER_DEFINED_DLLESPEC # undef VPI_USER_DEFINED_DLLESPEC # undef PLI_DLLESPEC #endif #ifdef PLI_PROTOTYPES # undef PLI_PROTOTYPES # undef PROTO_PARAMS # undef XXTERN # undef EETERN #endif #ifdef __cplusplus } #endif #endif /* VPI_USER_H */ nvc-r1.17.1/test/000077500000000000000000000000001504111170000135165ustar00rootroot00000000000000nvc-r1.17.1/test/Makemodule.am000066400000000000000000000101141504111170000161150ustar00rootroot00000000000000TESTS = \ bin/unit_test \ bin/run_regr # Must always be last check_PROGRAMS += $(TESTS) bin/fstdump EXTRA_PROGRAMS += \ bin/lockbench \ bin/jitperf \ bin/workqbench \ bin/mtstress \ vpi-dump.vpi EXTRA_DIST += test/cobertura.dtd bin_unit_test_SOURCES = \ test/test_util.c \ test/test_util.h \ test/unit_test.c \ test/test_ident.c \ test/test_lower.c \ test/test_parse.c \ test/test_lib.c \ test/test_sem.c \ test/test_simp.c \ test/test_misc.c \ test/test_elab.c \ test/test_bounds.c \ test/test_value.c \ test/test_debug.c \ test/test_mspace.c \ test/test_jit.c \ test/test_model.c \ test/test_psl.c \ test/test_sdf.c \ test/test_charset.c \ test/test_dump.c \ test/test_driver.c \ test/test_vlog.c \ test/test_mir.c if ARCH_X86_64 bin_unit_test_SOURCES += test/test_native.c endif if ENABLE_TCL bin_unit_test_SOURCES += test/test_shell.c endif if ENABLE_SERVER bin_unit_test_SOURCES += test/test_server.c endif bin_unit_test_LDADD = \ lib/libnvc.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ lib/libsha1.a \ $(check_LIBS) \ $(libdw_LIBS) \ $(libffi_LIBS) \ $(capstone_LIBS) \ $(libzstd_LIBS) \ $(jansson_LIBS) \ $(TCL_LIBS) \ $(libdwarf_LIBS) bin_unit_test_LDFLAGS = $(LDFLAGS) $(AM_LDFLAGS) $(EXPORT_LDFLAGS) EXTRA_bin_unit_test_DEPENDENCIES = src/symbols.txt bin_run_regr_SOURCES = test/run_regr.c bin_fstdump_SOURCES = test/fstdump.c bin_fstdump_LDADD = lib/libfst.a lib/libfastlz.a $(zlib_LIBS) bin_lockbench_SOURCES = test/lockbench.c bin_lockbench_LDADD = \ lib/libnvc.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ $(libdw_LIBS) \ $(libffi_LIBS) \ $(libzstd_LIBS) bin_jitperf_SOURCES = test/jitperf.c bin_jitperf_LDADD = \ lib/libnvc.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ $(libdw_LIBS) \ $(libffi_LIBS) \ $(capstone_LIBS) \ $(libzstd_LIBS) bin_jitperf_LDFLAGS = $(LDFLAGS) $(AM_LDFLAGS) $(EXPORT_LDFLAGS) if ENABLE_LLVM bin_jitperf_LDADD += \ $(LLVM_LIBS) endif bin_workqbench_SOURCES = test/workqbench.c bin_workqbench_LDADD = \ lib/libnvc.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ $(libdw_LIBS) \ $(libffi_LIBS) \ $(check_LIBS) \ $(libzstd_LIBS) bin_mtstress_SOURCES = test/mtstress.c bin_mtstress_LDFLAGS = $(LDFLAGS) $(AM_LDFLAGS) $(EXPORT_LDFLAGS) bin_mtstress_LDADD = \ lib/libnvc.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ $(libdw_LIBS) \ $(libffi_LIBS) \ $(check_LIBS) \ $(libzstd_LIBS) vpi_dump_vpi_SOURCES = test/vpi-dump.c vpi_dump_vpi_CFLAGS = $(SHLIB_CFLAGS) $(AM_LDFLAGS) vpi_dump_vpi_LDFLAGS = $(SHLIB_LDFLAGS) $(AM_LDFLAGS) TESTS_ENVIRONMENT = \ BUILD_DIR=$(top_builddir) \ NVC_LIBPATH=$(abs_top_builddir)/lib \ EXEEXT=$(EXEEXT) test/run_regr: $(VHPI_PLUGINS) covdir = $(top_builddir)/coverage if ENABLE_GCOV cov-reset: rm -rf $(covdir) find $(top_builddir) -name '*.gcda' -exec rm {} \; lcov --directory $(top_builddir)/src --zerocounters cov-generate: mkdir -p $(covdir) lcov --directory $(top_builddir)/src --capture \ --output-file $(covdir)/nvc.raw.info \ --rc 'lcov_excl_line=LCOV_EXCL_LINE|fatal_trace|should_not_reach_here' lcov --output-file $(covdir)/nvc.info \ --remove $(covdir)/nvc.raw.info \ '/usr/*' '*/lexer.c' '*/vlog-pp.c' cov-report: cov-generate genhtml -o $(covdir) $(covdir)/nvc.info -x-www-browser $(covdir)/index.html endif if MAINTAINER_MODE update-test-dist: $(AM_V_GEN)( \ echo "# Generated automatically, do not edit." ; \ echo "EXTRA_DIST += \\" ; \ cd $(top_srcdir) ; \ git ls-files -- 'test/*.vhd' 'test/*.txt' 'test/*.sh' 'test/*.dump' \ 'test/*.gtkw' 'test/*.tcl' 'test/*.v' 'test/*.xml' 'test/*.sdf' \ | sort | sed -e 's/^/\t/' -e '$$ ! s/$$/ \\/' ; \ ) > $(top_srcdir)/test/dist.mk orphan-tests: ( \ cd $(top_srcdir) ; \ missing=$$(comm -23 \ <(git ls-files -- 'test/regress/*.vhd' 'test/regress/*.v' \ | sed 's|.*/\([[:alnum:]]*\)\..*|\1|' | sort | uniq) \ <(cut -d' ' -f1 test/regress/testlist.txt | sort) \ | tee /dev/stderr | wc -l) ; \ [ "$$missing" = 0 ] || exit 1 ; \ ) endif .PHONY: update-test-dist include test/dist.mk nvc-r1.17.1/test/bounds/000077500000000000000000000000001504111170000150105ustar00rootroot00000000000000nvc-r1.17.1/test/bounds/aggregate.vhd000066400000000000000000000044711504111170000174470ustar00rootroot00000000000000entity aggregate is end entity; architecture test of aggregate is type my_enum is (A, B, C); type my_enum_map is array (my_enum) of integer; constant c1 : my_enum_map := (A => 1, A => 2, C => 3); -- Error constant c2 : my_enum_map := my_enum_map'(A => 1, B => 2); -- Error constant c3 : my_enum_map := (b => 1, a to c => 2); -- Error subtype my_bit_vec is bit_vector(3 downto 1); type my_int is range 10 downto 5; type my_int_map is array (my_int) of integer; constant c4 : my_bit_vec := (3 => '1', 2 => '0'); -- Error constant c5 : my_int_map := (7 => 2); -- Error constant c6 : integer_vector(1 to 3) := (1, 2, 3); -- OK constant c7 : integer_vector(1 to 4) := (c6, 4); -- OK constant c8 : integer_vector(1 to 3) := (c6, 4); -- Error constant c9 : integer_vector(1 to 5) := (c6, 4); -- Error constant c10 : integer_vector(1 to 3) := (1 to 3 => c6); -- OK constant c11 : integer_vector(1 to 3) := (1 to 2 => c6(1 to 2)); -- Error constant c12 : integer_vector(1 to 4) := (1 to 4 => c6); -- Error constant c13 : integer_vector(1 to 4) := ( integer_vector'(1, 2), integer_vector'(3, 4) ); -- OK constant c14 : bit_vector(7 downto 0) := (3 downto 0 => "111", others => '0'); -- Error type t_pos_vec is array (natural range <>) of positive; constant c15 : t_pos_vec(1 to 5) := (others => -1); -- Error type t_nibble_vec is array (natural range <>) of bit_vector(1 to 4); constant c16 : t_nibble_vec(1 to 1) := (others => (1 to 3 => '1')); -- Error type t_arr2 is array (integer range <>, boolean range <>) of my_bit_vec; constant c17 : t_arr2(1 to 3, false to true) := (others => (others => c4)); -- OK constant c18 : t_arr2(1 to 3, false to true) := (others => (true => c4)); -- Error constant c19 : t_nibble_vec(1 downto 0) := (c16, X"4"); -- OK constant c20 : t_nibble_vec(1 downto 0) := (1 downto 1 => c16, 0 => X"4"); -- OK type t_rec is record f : bit_vector; end record; type t_rec_array is array (natural range <>) of t_rec; constant c21 : t_rec_array(3 downto 0)(f(1 to 3)) := (others => (f => "101")); -- OK constant c22 : t_rec_array := (c21(3 downto 1), c21(3)); -- OK constant c23 : t_rec_array := c21(3 downto 1) & c21(3); -- OK begin end architecture; nvc-r1.17.1/test/bounds/bounds.vhd000066400000000000000000000163571504111170000170210ustar00rootroot00000000000000entity bounds is end entity; architecture test of bounds is type foo is range 1 to 5; type my_vec1 is array (positive range <>) of integer; type my_vec2 is array (foo range <>) of integer; signal s : my_vec1(1 to 10); signal n : my_vec1(1 downto 10); subtype bool_true is boolean range true to true; function fun(x : in bit_vector(7 downto 0)) return bit; procedure proc(x : in bit_vector(7 downto 0)); function natfunc(x : in natural) return boolean; function enumfunc(x : in bool_true) return boolean; function realfunc(x : in real) return boolean; type matrix is array (integer range <>, integer range <>) of integer; procedure proc2(x : in matrix(1 to 3, 1 to 3)); begin process is variable a : my_vec1(0 to 10); -- Error variable b : my_vec2(1 to 60); -- Error begin end process; s(-52) <= 5; -- Error s(1 to 11) <= (others => 0); -- Error s(0 to 2) <= (others => 0); -- Error process is begin report (0 => 'a'); -- Error end process; process is variable v1 : bit_vector(3 downto 0); variable v2 : bit_vector(8 downto 1); variable m1 : matrix(1 to 3, 2 to 4); variable m2 : matrix(1 to 3, 1 to 4); begin assert fun(v1) = '1'; -- Error proc(v1); -- Error proc(v2); -- OK proc2(m1); -- OK proc2(m2); -- Error end process; s <= s(1 to 9); -- Error n <= s(1 to 2); -- Error n <= (1, 2, 3); -- Error process is variable v : my_vec1(1 to 3); begin v := s; -- Error end process; process is variable x : integer; begin x := s(11); -- Error! x := s(-1); -- Error! end process; process is variable a : my_vec1(1 to 3); begin a := (1, 2, 3); -- OK a := (5 => 1, 1 => 2, 0 => 3); -- Error end process; process is subtype alpha is character range 'a' to 'z'; variable a : alpha; variable p : positive; begin a := 'c'; -- OK a := '1'; -- Error p := 0; -- Error end process; process is begin assert s'length(5) = 5; -- Error end process; process is begin assert natfunc(-1); -- Error end process; process is subtype str is string; constant c : str := "hello"; -- OK begin end process; process is variable a : my_vec1(1 to 3); begin a := (1, others => 2); -- OK a := (5 => 1, others => 2); -- Error end process; process is type mat2d is array (integer range <>, integer range <>) of integer; procedure p(m : in mat2d); begin p(((0, 1, 2, 3), (1 to 2 => 5))); -- Error end process; -- Reduced from Billowitch tc1374 process is type t_rec3 is record f1 : boolean; end record; subtype st_rec3 is t_rec3 ; type t_arr3 is array (integer range <>, boolean range <>) of st_rec3 ; subtype st_arr3 is t_arr3 (1 to 5, true downto false) ; variable v_st_arr3 : st_arr3; begin v_st_arr3(1, true) := (f1 => false); end process; process is variable i : integer; attribute a : bit_vector; attribute a of i : variable is "101"; begin assert i'a(14) = '0'; -- Error end process; process is constant FPO_LOG_MAX_ITERATIONS : integer := 9; type T_FPO_LOG_ALPHA is array (0 to FPO_LOG_MAX_ITERATIONS-1) of integer; variable alpha : T_FPO_LOG_ALPHA; begin if alpha(0 to 5) = (5, 4, 6, 6, 6, 6) then -- OK null; end if; end process; process is procedure real_proc(x : in real range 0.0 to 1.0); begin real_proc(0.0); -- OK real_proc(1.0); -- OK real_proc(2.0); -- Error end process; process is type e is (one, two, three, four, five); subtype se is e range two to four; type t_arr is array (se range <>) of boolean; constant c1 : t_arr(two to four) := (true, true); constant c2 : t_arr(two to four) := (true, true, true, true); procedure enum_proc( arg1 : e range two to four; arg2 : e range three downto two ) is begin end procedure; begin enum_proc(arg1 => two, arg2 => two); -- ok enum_proc(arg1 => three, arg2 => one); -- Error enum_proc(arg1 => four, arg2 => four); -- Error enum_proc(arg1 => one, arg2 => three); -- Error enum_proc(arg1 => five, arg2 => three); -- Error end process; process is type e is (one, two, three, four, five); type t_arr is array (two to four) of integer; variable a : t_arr; begin a := (1, others => 2); -- OK a := (two => 1, others => 2); -- OK a := (one => 1, others => 2); -- Error a := (two to four => 1, others => 2); -- OK a := (one to five => 1, others => 2); -- Error end process; process is type e is (one, two, three, four, five); type mat2d is array (e range <>, e range <>) of integer; procedure p(m : in mat2d); begin p(((0, 1, 2, 3), (one to three => 5))); -- Error end process; process is type e is (one, two, three, four, five); subtype se is e range two to three; type arr is array (se range <>) of integer; variable v1 : arr(two to three); -- OK variable v2 : arr(one to four); -- Error begin end process; process is procedure phys_proc_to(a : in time range 0 ns to 10 ns) is begin end procedure; procedure phys_proc_dt(a : in time range 10 sec downto 20 us) is begin end procedure; begin phys_proc_to(5 ns); -- OK phys_proc_to(-5 ns); -- Error phys_proc_dt(1 ms); -- OK phys_proc_dt(5 ns); -- Error end process; process variable t : time range -10 ns to 10 ns; begin t := 200 ns; -- Error t := -200 ns; -- Error t := 0 ns; -- OK end process; process is type char_map is array (character range 'a' to 'z') of integer; variable m : char_map; begin m('A') := 1; -- Error m('1' to '3') := (others => 3); -- Error end process; process is variable v : bit_vector(1 to 3); alias a : bit_vector(1 to 4) is v; -- Error begin a(4) := '1'; -- OK end process; process is constant k : positive := 42; begin for i in 0 to k loop -- OK (base is INTEGER) wait; end loop; end process; end architecture; nvc-r1.17.1/test/bounds/bounds2.vhd000066400000000000000000000077161504111170000171020ustar00rootroot00000000000000entity bounds2 is end entity; architecture test of bounds2 is begin asssignment_delays: block signal b1,b2,b3,b4,b5,b6,b7 : boolean; begin b1 <= true; -- OK b2 <= true after 10 ns; -- OK b3 <= true after 0 ns; -- OK b4 <= true after -1 ns; -- Error process begin b5 <= true; -- OK b5 <= true after 0 ns; -- OK b5 <= true after 1 fs; -- OK b5 <= true after -1 fs; -- Error wait; end process; b6 <= true after -10 ns when now = 5 ns else false; b7 <= true when now = 1 ns else false after -10 ns; end block; rejection_limits: block signal b1,b2,b3 : boolean; begin b1 <= reject 10 ns inertial true after 10 ns; -- OK b2 <= reject -10 ns inertial true; -- Error b3 <= reject 10 ns inertial true after 5 ns; -- Error end block; process begin wait for -10 ns; -- Error wait; end process; default_values: block type r is range 0 to 1; constant ok1 : integer range 0 to 1 := 1; -- OK constant ok2 : character range 'a' to 'z' := 'b'; -- OK constant ok3 : real range 0.0 to 1.0 := 0.0; -- OK constant ok4 : time range 10 ns to 20 ns := 10 ns; -- OK constant ok5 : r := 0; -- OK signal s : integer range 0 to 9 := 20; -- Error constant c1 : character range 'a' to 'z' := 'Z'; -- Error shared variable v : real range 0.0 to 5.0 := 10.0; -- Error constant t : time range 10 ns to 10 us := 0 fs; -- Error constant c2 : r := 10; -- Error subtype subint is integer range 1 to 10; procedure test(a : subint := 30) is begin end procedure; function test(a : character range 'a' to 'b' := 'c') return integer is begin return 1; end function; component comp is generic ( g2 : integer range 10 downto 0 := 20 ); port ( p2 : in integer range 0 to 1 := 2 ); end component; begin process is variable v2 : real range 0.0 to 5.0 := 5.1; -- Error begin end process; end block; ascending_time: block signal s : integer; signal del : time; begin process begin s <= 0 after 10 ns, 1 after 11 ns; -- OK s <= 0, 1 after 1 ns; -- OK s <= 10 after del; -- OK s <= 10 after del, 20 after del + 1 ns; -- OK s <= 0, 1; -- Error s <= 0 after 1 ns, 1; -- Error s <= 0 after 2 ns, 1 after 1 ns; -- Error s <= 0 after 1 ns, 1 after del, 2; -- Error s <= 1 after del, 2; -- Error wait; end process; end block; textio1: block is function unit_string (unit : time) return string is begin if unit = fs then -- OK return " fs"; elsif unit = ps then return " ps"; elsif unit = ns then return " ns"; else report "invalid unit " & time'image(unit); end if; end function; begin end block; typeconv: process is type bv10 is array (1 to 10) of bit; variable a : bv10; variable b : bit_vector(1 to 10); begin a := bv10(b); -- OK a := bv10(b(1 to 9)); -- Error wait; end process; end architecture; nvc-r1.17.1/test/bounds/case.vhd000066400000000000000000000066221504111170000164340ustar00rootroot00000000000000entity bounds_case is end entity; architecture test of bounds_case is begin process is type letter is (A, B, C); subtype ab is letter range B to letter'right; variable l : letter; variable m : ab; begin case l is -- Choice C not covered when a => null; when b => null; end case; case m is -- Choice B not covered when c => null; end case; wait; end process; process is variable x : integer; variable y : natural; begin case x is -- Missing range when 0 to 9 => null; when 20 => null; end case; case x is -- Missing range when 1 | 2 | 3 => null; end case; case x is -- OK when others => null; end case; case x is -- Missing integer'right when integer'left to integer'right - 1 => null; end case; case x is when 1 to 100 => null; when 50 => -- Duplicate null; when 60 to 64 => -- Duplicate null; when others => null; end case; case y is when -1 => -- Out of range null; end case; end process; process is variable x : bit_vector(1 to 3); variable y : bit_vector(0 to 0); subtype small is character range 'a' to 'k'; type char_vector is array (integer range <>) of character; type small_vector is array (integer range <>) of small; variable p : char_vector(1 to 2); variable q : small_vector(1 to 2); begin case y is when "0" => null; when "1" => null; end case; -- OK case x is when "000" | "001" => null; end case; -- Missing 6 values case x is when ('0', '1') => -- Too few values null; when ('1', '0', '1', '1') => -- Too many values null; when "10" => -- Too few values null; when "1111" => -- Too many values null; when others => null; end case; case p is when ('0', '1') => null; when ('1', '1') => null; end case; -- Missing lots of values case q is when ('a', 'b') => null; when ('b', 'b') => null; end case; -- Missing 98 values end process; process is type my_int is range 10 downto 1; variable x : my_int; begin case x is when 10 downto 4 => null; end case; -- Error case x is when 11 downto 3 => null; -- Error when 2 downto 1 => null; end case; end process; end architecture; nvc-r1.17.1/test/bounds/case2.vhd000066400000000000000000000021711504111170000165110ustar00rootroot00000000000000entity incorrect_choice_length is end entity; architecture arch of incorrect_choice_length is type some_datastructure_t is record name : string; value : natural range 0 to 3; end record; type some_datastructure_array is array (natural range <>) of some_datastructure_t; constant some_datastructure : some_datastructure_array(0 to 3) := ( 0 => (name => "zarro", value => 0), 1 => (name => "one", value => 1), 2 => (name => "two", value => 2), 3 => (name => "three", value => 3) ); begin process is variable int : integer; procedure printValue(constant x: some_datastructure_t) is begin case x.name is when "zarro" => report "We got value : " & natural'image(x.value); when "one" => report "We got value : " & natural'image(x.value); when "two" => report "We got value : " & natural'image(x.value); when "three" => report "We got value : " & natural'image(x.value); end case; end procedure; begin printValue(some_datastructure(0)); printValue(some_datastructure(1)); printValue(some_datastructure(2)); printValue(some_datastructure(3)); end process; end architecture; nvc-r1.17.1/test/bounds/case3.vhd000066400000000000000000000007061504111170000165140ustar00rootroot00000000000000entity case3 is end entity; architecture test of case3 is signal s : bit_vector(1 to 3); signal t : bit; begin p1: process (s) is begin case s is when "100" => t <= '1'; when "101" => t <= '0'; when "100" => -- Error t <= '1'; when others => null; end case; end process; end architecture; nvc-r1.17.1/test/bounds/case4.vhd000066400000000000000000000014101504111170000165060ustar00rootroot00000000000000entity case4 is end entity; architecture test of case4 is type int_vec is array (natural range <>) of integer; procedure test (s : string) is begin case s is -- Error when "hello" => null; end case; end procedure; procedure test2 (n : natural) is subtype t_not_static is natural range 0 to n; variable v : t_not_static; begin case v is -- Error when 0 => null; when 1 => null; end case; end procedure; begin process is variable s : string(1 to 12); begin case s is -- Error when "0123456789ab" => null; end case; end process; end architecture; nvc-r1.17.1/test/bounds/case5.vhd000066400000000000000000000011211504111170000165060ustar00rootroot00000000000000package pack1 is type t_type is (foo, bar, baz); end package; ------------------------------------------------------------------------------- package pack2 is alias t_type is work.pack1.t_type; end package; ------------------------------------------------------------------------------- use work.pack2.all; package pack3 is procedure test1 (x : t_type); end package; package body pack3 is procedure test1 (x : t_type) is begin case x is -- Error when foo | bar => null; end case; end procedure; end package body; nvc-r1.17.1/test/bounds/cons1.vhd000066400000000000000000000007531504111170000165430ustar00rootroot00000000000000package cons1 is type t_rec1 is record f1 : string; f2 : string(-1 to 0); -- Error end record; constant c1 : t_rec1(f1(0 to 4)) := (f1 => "hello", f2 => "12"); -- Error subtype t_string_sub is string(0 to 5); -- Error subtype t_sub_sub is t_string_sub; -- OK type t_array is array (natural range <>) of string(0 to 3); -- Error constant c2 : t_array'element; -- OK constant c3 : t_array'element; -- OK end package; nvc-r1.17.1/test/bounds/driver1.vhd000066400000000000000000000007211504111170000170670ustar00rootroot00000000000000entity driver1 is end entity; architecture test of driver1 is signal s : bit_vector(1 to 3); begin p1: process is begin if 3 < 2 then -- Cannot delete this s(5) <= '1'; -- Error else s(7) <= '0'; -- Error end if; while false loop s(-1) <= '0'; -- Error end loop; wait; end process; end architecture; nvc-r1.17.1/test/bounds/initial.vhd000066400000000000000000000013271504111170000171470ustar00rootroot00000000000000entity initial is end entity; architecture test of initial is type real_vector is array (natural range <>) of real; constant c1 : real_vector := (1.0, 0.0, 1.0, 0.0, 1.0); constant c2 : real_vector(1 to c1'length) := (0.0, 1.0, 0.0, 1.0, c1(2), 0.0); -- Error signal s1 : real_vector := (1.0, 0.0, 1.0, 0.0, 1.0); signal s2 : real_vector(1 to s1'length) := (0.0, 1.0, 0.0, 1.0, c1(2), 0.0); -- Error begin p1: process is variable v1 : real_vector := (1.0, 0.0, 1.0, 0.0, 1.0); variable v2 : real_vector(1 to v1'length) := (0.0, 1.0, 0.0, 1.0, 1.0, 0.0); -- Error begin wait for 5 ns; assert false; end process; end architecture; nvc-r1.17.1/test/bounds/issue1021.vhd000066400000000000000000000002501504111170000171440ustar00rootroot00000000000000entity noconst is end noconst; architecture arch of noconst is type map_type is array(bit) of character; constant smap : map_type := ""; -- Error begin end; nvc-r1.17.1/test/bounds/issue1040.vhd000066400000000000000000000002641504111170000171520ustar00rootroot00000000000000entity crash is end entity; architecture rtl of crash is signal crash_signal : bit_vector(31 downto 0); begin crash_signal(11 downto 0) <= crash_signal; end architecture; nvc-r1.17.1/test/bounds/issue1091.vhd000066400000000000000000000005751504111170000171650ustar00rootroot00000000000000package pkg is type vec is array(0 to 3) of integer; end pkg; use work.pkg.all; entity ent is port ( p0 : boolean := vec'(0=>0, 1=>0) = vec'(3=>0); p1 : boolean := vec'(0=>0, 1=>1, 1 to 2=>1) = vec'(others=>0); p2 : boolean := vec'(0=>0, 1=>1, 2 to 3=>1) = vec'(others=>0) ); end ent; architecture arch of ent is begin end architecture arch; nvc-r1.17.1/test/bounds/issue150.vhd000066400000000000000000000006071504111170000170740ustar00rootroot00000000000000entity issue150 is end entity issue150; architecture tb of issue150 is type t_lut8x8 is array (0 to 7,0 to 7) of integer; constant C_SAMPLE : t_lut8x8 := ( (1,1,1,1,1,1,1,1), (1,1,1,1,1,1,1,1), (1,1,1,1,1,1,1,1), (1,1,1,1,1,1,1,1), (1,1,1,1,1,1,1,1), (1,1,1,1,1,1,1,1) ); -- Crash lowering here begin end architecture; nvc-r1.17.1/test/bounds/issue200.vhd000066400000000000000000000003771504111170000170740ustar00rootroot00000000000000entity issue200 is end entity; architecture a of issue200 is begin main : process -- Static error variable bv : bit_vector(-1 downto 0) := (others => '0'); begin report integer'image(bv'length); wait; end process; end architecture; nvc-r1.17.1/test/bounds/issue208.vhd000066400000000000000000000013071504111170000170760ustar00rootroot00000000000000entity test is end test; architecture fum of test is signal foo : bit_vector(1 downto 0); alias foo1 is foo(1); alias foo0 is foo(0); begin dummy: process is begin for i in foo'range loop -- range is 1 downto 0 case i is -- OK when 0 => report "foo(0) = " & bit'image(foo0); when 1 => report "foo(1) = " & bit'image(foo1); end case; case i is -- Error when 0 => report "foo(0) = " & bit'image(foo0); end case; end loop; wait; end process dummy; end architecture fum; nvc-r1.17.1/test/bounds/issue247.vhd000066400000000000000000000003151504111170000170770ustar00rootroot00000000000000package issue247 is subtype natural_down is natural range 10 downto 0; type array_t is array (natural_down range <>) of boolean; constant c : array_t(9 downto 5); -- ok end package issue247; nvc-r1.17.1/test/bounds/issue251.vhd000066400000000000000000000014041504111170000170720ustar00rootroot00000000000000entity sub is port ( x : in bit_vector(3 downto 0); y : out bit ); end entity; architecture test of sub is begin y <= x(0) xor x(1) xor x(2) xor x(3); end architecture; ------------------------------------------------------------------------------- entity issue251 is end entity; architecture test of issue251 is signal a : bit_vector(3 downto 0); signal b : bit_vector(1 downto 0); begin sub1_i: entity work.sub port map ( x(-1) => a(0), -- Error x(3 downto 0) => a, y => open ); sub2_i: entity work.sub port map ( x(3) => a(-1), -- Error x(2 downto 0) => a, -- Error y => open ); end architecture; nvc-r1.17.1/test/bounds/issue269.vhd000066400000000000000000000002521504111170000171030ustar00rootroot00000000000000package issue269 is constant CWIDTH : positive := 10; type int_vec is array (integer range <>) of integer; signal s1 : int_vec(CWIDTH downto 0); end package; nvc-r1.17.1/test/bounds/issue307b.vhd000066400000000000000000000016411504111170000172410ustar00rootroot00000000000000-- test_ng_2.vhd use std.textio.all; entity TEST_NG_2 is end TEST_NG_2; architecture MODEL of TEST_NG_2 is constant TIME_WIDTH : integer := 13; begin process variable text_line : LINE; procedure p(T:in time;M:in string) is begin if (TIME_WIDTH > 0) then WRITE(text_line, T, RIGHT, ABS(TIME_WIDTH)); -- Bogus bounds -- check failure elsif (TIME_WIDTH < 0) then WRITE(text_line, T, LEFT , ABS(TIME_WIDTH)); end if; WRITE(text_line, string'(" ") & M); WRITELINE(OUTPUT, text_line); end procedure; begin p(Now, string'("Simulation Start.")); wait for 10 ns; p(Now, string'("Simulation Done.")); assert FALSE report "Simulation complete." severity FAILURE; end process; end MODEL; nvc-r1.17.1/test/bounds/issue356.vhd000066400000000000000000000012361504111170000171030ustar00rootroot00000000000000entity nvc_bug is end nvc_bug; architecture behav of nvc_bug is type std_logic_vector is array (integer range <>) of integer; function to_bitvector(x : std_logic_vector) return bit_vector is begin return ""; end function; signal mode : std_logic_vector(1 downto 0); begin process subtype modetype is bit_vector(mode'range); begin case modetype'(to_bitvector(mode)) is when "00" => when "01" => when "10" => when "11" => when others => end case; assert false report "end of test" severity note; wait; end process; end behav; nvc-r1.17.1/test/bounds/issue36.vhd000066400000000000000000000006711504111170000170200ustar00rootroot00000000000000entity bounds18 is generic ( W : integer range 1 to integer'high := 8 ); function func2(x : integer; w : natural) return integer is begin return x + w; end func2; pure function fA ( iA : integer range 0 to 2**W-1 ) return integer is begin return func2(iA, W); end function fA; begin assert (fA(0) = 0) report "should not assert" severity failure; end entity bounds18; nvc-r1.17.1/test/bounds/issue477a.vhd000066400000000000000000000052021504111170000172450ustar00rootroot00000000000000package test_pkg is type t_segment_type is ( TYPE_0, TYPE_1, TYPE_2, TYPE_3, TYPE_4, TYPE_5 ); type unsigned is array (natural range <>) of bit; type t_data_segment is record data_word : bit_vector(15 downto 0); -- 0: 16 word_idx : unsigned(11 downto 0); -- 16: 12 segment_type : t_segment_type; -- 28: 1+3 word_length : natural range 1 to 2; -- 32: 4 crc_check : boolean; -- 36: 1+3 table : natural range 1 to 2; -- 40: 4 end record; type t_data_segment_template is array(t_segment_type) of t_data_segment; constant C_SEGMENT_RECORDS : t_data_segment_template := ( TYPE_0 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_0, word_length => 1, crc_check => false, table => 16#a0#), TYPE_1 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_1, word_length => 2, crc_check => false, table => 1), TYPE_2 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_2, word_length => 1, crc_check => false, table => 16#a1#), TYPE_3 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_3, word_length => 2, crc_check => true, table => 16#a2#), TYPE_4 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_4, word_length => 2, crc_check => true, table => 16#a3#), TYPE_5 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_5, word_length => 2, crc_check => true, table => 16#a4#) ); constant C_DATA_INVALID_VERSION : bit_vector(7 downto 0) := x"FF"; constant C_DATA_VERSION : bit_vector(C_SEGMENT_RECORDS(TYPE_2).word_length*8-1 downto 0) := C_DATA_INVALID_VERSION; end package; nvc-r1.17.1/test/bounds/issue477b.vhd000066400000000000000000000045521504111170000172550ustar00rootroot00000000000000package test_pkg is type t_segment_type is ( TYPE_0, TYPE_1, TYPE_2, TYPE_3, TYPE_4, TYPE_5 ); type unsigned is array (natural range <>) of bit; type t_data_segment is record data_word : bit_vector(15 downto 0); -- 0: 16 word_idx : unsigned(11 downto 0); -- 16: 12 segment_type : t_segment_type; -- 28: 1+3 word_length : natural range 1 to 2; -- 32: 4 crc_check : boolean; -- 36: 1+3 table : natural range 1 to 2; -- 40: 4 end record; type t_data_segment_template is array(t_segment_type) of t_data_segment; constant C_SEGMENT_RECORDS : t_data_segment_template := ( TYPE_0 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_0, word_length => 1, crc_check => false, table => 16#a0#), TYPE_1 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_1, word_length => 2, crc_check => false, table => 1), TYPE_2 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_2, word_length => 1, crc_check => false, table => 16#a1#), TYPE_3 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_3, word_length => 2, crc_check => true, table => 16#a2#), TYPE_4 => ( data_word => (others => '0'), word_idx => (others => '0'), segment_type => TYPE_4, word_length => 2, crc_check => true, table => 16#a3#) -- Error ); constant C_DATA_INVALID_VERSION : bit_vector(7 downto 0) := x"FF"; constant C_DATA_VERSION : bit_vector(C_SEGMENT_RECORDS(TYPE_2).word_length*8-1 downto 0) := C_DATA_INVALID_VERSION; end package; nvc-r1.17.1/test/bounds/issue54.vhd000066400000000000000000000006721504111170000170210ustar00rootroot00000000000000entity issue54 is begin end entity issue54; architecture a of issue54 is begin p : process variable v : bit_vector(7 downto 0) := (others => '0'); begin v(3 downto 0) := (7 downto 4 => '1'); -- OK v(7 downto 4) := (3 downto 0 => '1'); -- OK v(7 downto 4) := (3 downto 0 => '1', others => '0'); -- Error assert (v = (7 downto 0 => '1')); wait; end process p; end architecture a; nvc-r1.17.1/test/bounds/issue617.vhd000066400000000000000000000007071504111170000171050ustar00rootroot00000000000000entity issue617 is end entity; architecture rtl of issue617 is type sfixed is array (integer range <>) of bit; procedure func(y: in bit_vector) is begin end procedure; begin process variable example : sfixed(31 downto -32); variable null_range : sfixed(-33 downto -32); begin func(bit_vector(example)); -- Error func(bit_vector(null_range)); -- OK wait; end process; end rtl; nvc-r1.17.1/test/bounds/issue734.vhd000066400000000000000000000004451504111170000171040ustar00rootroot00000000000000entity issue734 is end entity ; architecture arch of issue734 is signal val : bit_vector(0 downto 1) ; begin tb : process begin val(0) <= '0' ; -- Error val(1 downto 0) <= "00"; -- Error wait ; end process ; end architecture ; nvc-r1.17.1/test/bounds/issue800.vhd000066400000000000000000000007001504111170000170700ustar00rootroot00000000000000entity issue800 is end entity; architecture test of issue800 is signal x : bit_vector(1 to 3); begin p1: process is begin assert x = "00"; -- Warning assert x /= "101010101"; -- Warning assert x = "000"; -- OK assert string'("101") = "1111"; -- No warning (folded) assert "111" = x(1 to 1); -- Warning wait; end process; end architecture; nvc-r1.17.1/test/bounds/issue806.vhd000066400000000000000000000007761504111170000171130ustar00rootroot00000000000000package a is constant W : natural := 9; end package a; use work.a.all; entity opt is port ( o : out bit_vector(W-1 downto 0) ); end entity opt; architecture rtl of opt is signal size_8 : bit_vector(7 downto 0); signal size_9 : bit_vector(8 downto 0); begin o <= size_9 when W = 9 else size_8; process (size_8, size_9) begin if W = 9 then o <= size_9; else o <= size_8; end if; end process; end architecture rtl; nvc-r1.17.1/test/bounds/issue817.vhd000066400000000000000000000015721504111170000171100ustar00rootroot00000000000000package test_pkg is type array_of_vectors is array(integer range 0 to 31) of bit_vector(7 downto 0); end package; use work.test_pkg.array_of_vectors ; entity test is port ( in_a : in array_of_vectors ; outs : out array_of_vectors ) ; end entity ; architecture arch of test is begin process(all) begin outs(0) <= in_a(0); end process ; end architecture ; use work.test_pkg.array_of_vectors ; entity issue817 is end entity ; architecture arch of issue817 is signal a : bit; signal b : bit_vector(7 downto 0); begin U_test_a : entity work.test port map ( in_a(0) => "1111111" & a, -- OK in_a(1) => "111111" & a, -- Error outs(0) => b ) ; tb : process begin wait for 100 ns ; report "Done" ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/bounds/issue819.vhd000066400000000000000000000016641504111170000171140ustar00rootroot00000000000000package my_logic is type std_ulogic is ('0', '1'); type std_ulogic_vector is array (natural range <>) of std_ulogic; type unsigned is array (natural range <>) of std_ulogic; type signed is array (natural range <>) of std_ulogic; end package; ------------------------------------------------------------------------------- use work.my_logic.all; package uCPUtypes is alias logic is std_ulogic; alias logic_vec is std_ulogic_vector; end package uCPUtypes; ------------------------------------------------------------------------------- use work.uCPUtypes.all; entity uCPU is end entity uCPU; architecture RTL of uCPU is signal rom_data : logic_vec(11 downto 0); begin --------------- combination logic ---------------- process (rom_data) is begin case rom_data(11 downto 10) is when "00" => null; when others => null; end case; end process; end architecture RTL; nvc-r1.17.1/test/bounds/issue863.vhd000066400000000000000000000006721504111170000171110ustar00rootroot00000000000000entity test is end entity ; architecture arch of test is type real_matrix is array (natural range <>, natural range <>) of real ; constant m : real_matrix := ( (1.0, 2.0, 3.0, 4.0), (2.0, 3.0, 4.0, 5.0) ) ; procedure print(x : in string) is begin end procedure ; begin tb : process begin print("m length: " & integer'image(m'length(0))) ; -- Error wait; end process ; end architecture ; nvc-r1.17.1/test/bounds/issue951.vhd000066400000000000000000000016121504111170000171020ustar00rootroot00000000000000entity issue951 is end entity; architecture test of issue951 is type line is access string; type line_vector is array (natural range <>) of line; type lines_t is access line_vector; impure function split ( constant s : string; constant sep : string; constant max_split : integer := -1) return lines_t is variable ret_val : lines_t; begin return ret_val; end split; type NaturalArray_t is array (natural range <>) of natural; impure function ParseIntStr(str : string) return NaturalArray_t is variable parts : lines_t := split(str, ", "); variable return_value : NaturalArray_t(parts'range); begin for i in parts'range loop -- Crash here return_value(i) := integer'value(parts(i).all); end loop; return return_value; end; begin end architecture; nvc-r1.17.1/test/bounds/issue966.vhd000066400000000000000000000021501504111170000171060ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package pack is function matching_cases ( opcode: std_logic_vector ) return natural; end package; package body pack is function matching_cases ( opcode: std_logic_vector ) return natural is variable bytes : natural := 0; begin case? opcode is when "00000000" => bytes := 1; when "00000001" => bytes := 1; when "010000--" => bytes := 1; when "010000--" => -- SAME CONDITION AS ABOVE ARM!!! bytes := 2; when others => bytes := 4; end case?; case ? opcode is when "--00--0000" => bytes := 1; when "00--00-00-" => bytes := 2; end case?; -- Error case ? opcode is when "--00--0000" => bytes := 1; when "----------" => bytes := 2; end case?; -- OK return bytes; end; end package body; nvc-r1.17.1/test/bounds/issue975.vhd000066400000000000000000000006521504111170000171130ustar00rootroot00000000000000entity array_issue is end entity array_issue; architecture rtl of array_issue is constant C_LENGTH : positive := 7; type t_array1 is array (C_LENGTH downto 0) of bit; -- OK type t_array2 is array (0 to C_LENGTH) of bit; -- OK type t_array3 is array (positive range 0 to C_LENGTH) of bit; -- Error type t_array4 is array (positive range C_LENGTH downto 0) of bit; -- Error begin end architecture rtl; nvc-r1.17.1/test/bounds/issue98.vhd000066400000000000000000000014441504111170000170270ustar00rootroot00000000000000entity issue98a is end entity; architecture foo of issue98a is signal i: integer := Time'POS(Time'High); -- should produce error -- 6.4.2.3 Signal declarations, para 5, first sentence: -- If the signal declaration includes the assignment symbol followed by an -- expression, it shall be of the same type as the signal. Such an -- expression is said to be a default expression. -- -- -1993 4.3.1.2 Signal declarations, para 6, first sentence: -- If the signal declaration includes the assignment symbol followed by -- an expression, it must be of the same type as the signal. -- 'POS returns universal integer -- begin assert False report "i = " & integer'IMAGE(i) -- shows left clipping instead of error severity ERROR; end architecture; nvc-r1.17.1/test/bounds/issue99.vhd000066400000000000000000000005011504111170000170210ustar00rootroot00000000000000entity Top_PhysicalTest_Simple is end entity; architecture top of Top_PhysicalTest_Simple is type my_int is range 1 to 5; constant int_1 : INTEGER := natural(0.5); -- OK constant int_2 : INTEGER := natural(-1.5); -- Error constant int_3 : my_int := my_int(integer'(-1)); -- Error begin end; nvc-r1.17.1/test/bounds/map1.vhd000066400000000000000000000024401504111170000163510ustar00rootroot00000000000000entity map1 is end entity; architecture test of map1 is constant c : bit_vector(1 to 99) := (others => '0'); signal s : bit_vector(1 to 50); signal i : integer; function to_int(x : bit_vector) return integer is begin return 1; end function; subtype bv2 is bit_vector(1 to 2); function to_bv2(x : integer) return bv2 is constant c1 : bit_vector(1 to 3) := "111"; begin return c1; -- Error end function; begin b1: block is generic ( g1 : bit_vector(1 to 3); g2 : integer range 0 to 3 ); generic map ( g1 => c(1 to 4), -- Error g2 => 7 ); -- Error port ( p1 : bit_vector(1 to 3) ); port map ( p1 => s(1 to 2) ); -- Error begin end block; b2: block is port ( p1 : in bit_vector(1 to 3); p2 : in integer; p3 : inout bit_vector(1 to 5); p4 : inout integer ); port map ( p1 => to_bv2(i), -- Error p2 => to_int(s), -- OK to_int(p3) => to_bv2(i), -- OK to_bv2(p4) => to_int(s) ); -- OK begin end block; end architecture; nvc-r1.17.1/test/bounds/map2.vhd000066400000000000000000000015061504111170000163540ustar00rootroot00000000000000entity bounds21 is end entity; architecture test of bounds21 is type boolean_v is array (integer range <>) of boolean; subtype boolean_4 is boolean_v (1 to 4); subtype boolean_7 is boolean_v (1 to 7); function return_array return boolean_4 is constant l_operand : boolean_4 := (true,false,true,false); begin return l_operand; end return_array; begin l : block generic ( info : boolean_7 ); generic map ( return_array & return_array ); begin assert not(info = (true,false,true,false,true,false,true)) report "***passed test: c07s02b04x00p20n01i02094" severity note; assert (info = (true,false,true,false,true,false,true)) report "***failed test: c07s02b04x00p20n01i02094 - function array concatenation did not succeed." severity error; end block; end architecture; nvc-r1.17.1/test/bounds/nullrange.vhd000066400000000000000000000007161504111170000175060ustar00rootroot00000000000000entity test is end entity test; architecture beh of test is signal sig : bit_vector(-1 downto 0); signal sig2 : bit_vector(0 to -1); begin process(sig,sig2) begin sig <= (sig'range => '0'); -- OK sig2 <= (sig2'range => '0'); -- OK end process; process is type t_null_int is range 0 to -1; variable x : t_null_int := 0; -- Error begin end process; end architecture beh; nvc-r1.17.1/test/bounds/osvvm1.vhd000066400000000000000000000024061504111170000167500ustar00rootroot00000000000000 package NameStorePkg is subtype integer_max is integer; type NameIDType is record ID : integer_max ; end record NameIDType ; type NameStorePType is protected impure function Get (ID : integer ; DefaultName : string := "") return string ; end protected NameStorePType ; end package NameStorePkg ; --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// package body NameStorePkg is type NameStorePType is protected body ------------------------------------------------------------ impure function Get (ID : integer ; DefaultName : string := "") return string is ------------------------------------------------------------ begin return DefaultName; end function Get ; end protected body NameStorePType ; shared variable NameStore : NameStorePType ; ------------------------------------------------------------ impure function GetOpt (ID : NameIDType) return string is ------------------------------------------------------------ begin return NameStore.Get(ID.ID) ; end function GetOpt ; end package body NameStorePkg ; nvc-r1.17.1/test/bounds/range1.vhd000066400000000000000000000004501504111170000166670ustar00rootroot00000000000000entity range1 is end entity; architecture test of range1 is begin p1: process is variable x : bit_vector(1 to 10); begin assert x'range(2+0)'left = 5; -- Error assert x'reverse_range(-1)'right = 6; -- Error wait; end process; end architecture; nvc-r1.17.1/test/bounds/subtype.vhd000066400000000000000000000007301504111170000172060ustar00rootroot00000000000000package pack is type int8 is range 0 to 255; subtype int8_sub1 is int8 range -1 to 200; -- Error subtype int8_sub2 is int8 range 100 to 300; -- Error type abc is (a, b, c); subtype ab is abc range a to b; -- OK subtype bc is ab range b to c; -- Error type real10 is range 0.0 to 10.0; subtype real10_sub1 is real10 range -1.0 to 5.0; -- Error type t_array is array (positive range -1 to 8) of bit; -- Error end package; nvc-r1.17.1/test/bounds/tc1147.vhd000066400000000000000000000041331504111170000164370ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1147.vhd,v 1.2 2001-10-26 16:29:39 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c06s05b00x00p05n03i01147ent IS END c06s05b00x00p05n03i01147ent; ARCHITECTURE c06s05b00x00p05n03i01147arch OF c06s05b00x00p05n03i01147ent IS SUBTYPE thirteen is INTEGER range 0 to 12; BEGIN TESTING: PROCESS VARIABLE null_array : bit_vector ( 1 to 0 ); -- OK, a nice clean null array VARIABLE slice : bit_vector ( thirteen ); BEGIN assert NOT( null_array = slice (11 to 10) and null_array = slice (-1 to -5) and null_array = slice (15 to 14) ) report "***PASSED TEST: c06s05b00x00p05n03i01147" severity NOTE; assert ( null_array = slice (11 to 10) and null_array = slice (-1 to -5) and null_array = slice (15 to 14) ) report "***FAILED TEST: c06s05b00x00p05n03i01147 - The bounds of a null slice need not belong to the subtype of the index." severity ERROR; wait; END PROCESS TESTING; END c06s05b00x00p05n03i01147arch; nvc-r1.17.1/test/builds.sr.ht/000077500000000000000000000000001504111170000160355ustar00rootroot00000000000000nvc-r1.17.1/test/builds.sr.ht/alpine.yml000066400000000000000000000011071504111170000200270ustar00rootroot00000000000000image: alpine/edge arch: x86_64 packages: - automake - autoconf - llvm-dev - check-dev - flex - zlib-dev - pkgconf - elfutils-dev - libffi-dev - zstd-dev sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh mkdir build cd build ../configure --enable-debug --disable-lto - build: | cd nvc/build make - test: | export BROKEN_LIBC=1 cd nvc/build make check - release: | cd nvc/build make distclean ../configure --disable-debug make nvc-r1.17.1/test/builds.sr.ht/archlinux.yml000066400000000000000000000007761504111170000205670ustar00rootroot00000000000000image: archlinux packages: - automake - autoconf - llvm - elfutils - check - libffi - libzstd - tcl sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh mkdir build cd build ../configure --enable-debug --enable-tcl - build: | cd nvc/build make - test: | cd nvc/build make check - release: | cd nvc/build make distclean ../configure --disable-debug --enable-tcl make nvc-r1.17.1/test/builds.sr.ht/debian.yml000066400000000000000000000011551504111170000200040ustar00rootroot00000000000000image: debian/stable arch: amd64 packages: - automake - autoconf - llvm-dev - check - flex - build-essential - zlib1g-dev - pkg-config - libdw-dev - libzstd-dev - tcl-dev - libreadline-dev sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh mkdir build cd build ../configure --enable-debug --disable-lto --enable-tcl - build: | cd nvc/build make - test: | cd nvc/build make check - release: | cd nvc/build make distclean ../configure --disable-debug --enable-tcl make nvc-r1.17.1/test/builds.sr.ht/freebsd.yml000066400000000000000000000012751504111170000201770ustar00rootroot00000000000000image: freebsd/latest packages: - automake - autoconf - llvm - check - libunwind - pkgconf - libffi - zstd - tcl86 sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh export CPPFLAGS="-I/usr/local/include" export LDFLAGS="-L/usr/local/lib" mkdir build cd build ../configure --enable-debug --enable-tcl - build: | cd nvc/build make -j2 - test: | cd nvc/build make check - release: | cd nvc/build make distclean export CPPFLAGS="-I/usr/local/include" export LDFLAGS="-L/usr/local/lib" ../configure --disable-debug --enable-tcl make nvc-r1.17.1/test/builds.sr.ht/openbsd.yml000066400000000000000000000013321504111170000202110ustar00rootroot00000000000000image: openbsd/latest packages: - automake-1.15.1 - autoconf-2.71 - llvm - libdwarf - check - libffi - zstd sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc export AUTOCONF_VERSION=2.71 export AUTOMAKE_VERSION=1.15 ./autogen.sh export CPPFLAGS="-I/usr/local/include" export LDFLAGS="-L/usr/local/lib" mkdir build cd build ../configure --enable-debug - build: | cd nvc/build make - test: | cd nvc/build make check - release: | cd nvc/build make distclean export CPPFLAGS="-I/usr/local/include" export LDFLAGS="-L/usr/local/lib" ../configure --disable-debug make nvc-r1.17.1/test/builds.sr.ht/rockylinux.yml000066400000000000000000000012361504111170000207710ustar00rootroot00000000000000image: rockylinux/8 arch: x86_64 packages: - automake - autoconf - llvm-devel - check-devel - flex - zlib-devel - libffi-devel - pkg-config - elfutils-devel - capstone-devel - tcl-devel - libzstd-devel - readline-devel sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh mkdir build cd build ../configure --enable-debug --disable-lto --enable-tcl - build: | cd nvc/build make - test: | cd nvc/build make check - release: | cd nvc/build make distclean ../configure --disable-debug --enable-tcl make make check nvc-r1.17.1/test/builds.sr.ht/ubuntu.yml000066400000000000000000000016551504111170000201110ustar00rootroot00000000000000image: ubuntu/20.04 arch: amd64 packages: - automake - autoconf - llvm-dev - check - flex - build-essential - zlib1g-dev - pkg-config - libdw-dev - libzstd-dev - tcl-dev - libreadline-dev sources: - https://git.sr.ht/~nickg/nvc tasks: - setup: | uname -a cd nvc ./autogen.sh mkdir build cd build ../configure --enable-debug --enable-asan \ --with-llvm=/usr/bin/llvm-config --enable-tcl - build: | cd nvc/build make - test: | export ASAN_OPTIONS=detect_leaks=0 cd nvc/build make check - benchmarks: | cd nvc/build make bin/jitperf ./bin/jitperf -L lib/ ../test/perf/simple.vhd - interpreter: | cd nvc/build ../configure --disable-llvm --enable-debug --enable-tcl make clean check - release: | cd nvc/build make distclean ../configure --disable-debug --enable-tcl make nvc-r1.17.1/test/charset/000077500000000000000000000000001504111170000151475ustar00rootroot00000000000000nvc-r1.17.1/test/charset/iso8859-1.vhd000066400000000000000000000005421504111170000171410ustar00rootroot00000000000000-- -*- coding: iso-8859-1 -*- entity ÚÛÜÝÞ is end entity; architecture ûüýþÿûüýþÿ of ÚÛÜÝÞ is signal çxÿÑ : bit; constant ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ : integer := 1; -- ßÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞÿ constant ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ : integer := 2; constant times× : integer := 3; -- Error begin end architecture; nvc-r1.17.1/test/charset/strings.vhd000066400000000000000000000001461504111170000173440ustar00rootroot00000000000000-- -*- coding: iso-8859-1 -*- package strings is constant s1 : string := "ångström"; end package; nvc-r1.17.1/test/charset/utf8.vhd000066400000000000000000000001551504111170000165410ustar00rootroot00000000000000-- -*- coding: utf-8 -*- package test is constant Ã…xyzß : bit := '1'; -- Warning end package; nvc-r1.17.1/test/cobertura.dtd000066400000000000000000000037561504111170000162140ustar00rootroot00000000000000 nvc-r1.17.1/test/copybench.c000066400000000000000000000104201504111170000156310ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include #include #include #include #include #include #include #define ITERS 10000000 static inline void copy_bytes(void *restrict dst, const void *restrict src, size_t size) { if (__builtin_expect(size <= 32, 1)) { #if 0 asm volatile ("rep movsb" : "=D" (dst), "=S" (src), "=c" (size) : "0" (dst), "1" (src), "2" (size) : "memory"); #else for (; size > 7; size -= 8, dst += 8, src += 8) *(uint64_t *)dst = *(const uint64_t *)src; for (; size > 0; size--, dst++, src++) *(uint8_t *)dst = *(const uint8_t *)src; #endif } else memcpy(dst, src, size); } static inline bool cmp_bytes(const void *a, const void *b, size_t size) { if (__builtin_expect(size <= 128, 1)) { for (; size > 7; size -= 8, a += 8, b += 8) { if (*(const uint64_t *)a != *(const uint64_t *)b) return false; } for (; size > 0; size--, a++, b++) { if (*(const uint8_t *)a != *(const uint8_t *)b) return false; } return true; } else return memcmp(a, b, size) == 0; } __attribute__((noinline)) uint64_t get_timestamp_ns(void) { struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) abort(); return ts.tv_nsec + (ts.tv_sec * 1000000000ull); } __attribute__((noinline)) static void bench_copy(void *dst, const void *src, int size) { { const uint64_t start = get_timestamp_ns(); for (int i = 0; i < ITERS; i++) memcpy(dst, src, size); const uint64_t end = get_timestamp_ns(); printf("%-7.1f ", (double)(end - start) / ITERS); } { const uint64_t start = get_timestamp_ns(); for (int i = 0; i < ITERS; i++) copy_bytes(dst, src, size); const uint64_t end = get_timestamp_ns(); printf("%-7.1f ", (double)(end - start) / ITERS); } } __attribute__((noinline)) static int bench_cmp(uint8_t *a, uint8_t *b, int size) { int sum = 0; memset(a, '\0', size); memset(b, '\0', size); { const uint64_t start = get_timestamp_ns(); for (int i = 0; i < ITERS/2; i++) { a[ITERS%size] = 0; sum += memcmp(a, b, size) == 0; } for (int i = 0; i < ITERS/2; i++) { a[ITERS%size] = 1; sum += memcmp(a, b, size) == 0; a[ITERS%size] = 0; } const uint64_t end = get_timestamp_ns(); printf("%-7.1f ", (double)(end - start) / ITERS); } { const uint64_t start = get_timestamp_ns(); for (int i = 0; i < ITERS/2; i++) { a[ITERS%size] = 0; sum += cmp_bytes(a, b, size) == 0; } for (int i = 0; i < ITERS/2; i++) { a[ITERS%size] = 1; sum += cmp_bytes(a, b, size) == 0; a[ITERS%size] = 0; } const uint64_t end = get_timestamp_ns(); printf("%-7.1f ", (double)(end - start) / ITERS); } printf(" (%d)", sum); return sum; } int main(int argc, char **argv) { const int sizes[] = { 1, 2, 5, 7, 8, 10, 15, 16, 20, 32, 35, 40, 50, 100, 200, 1000, 2048, 3000, 10000 }; printf("SIZE MEMCPY COPY_BYTES MEMCMP CMP_BYTES\n"); for (unsigned i = 0; i < sizeof(sizes)/sizeof(int); i++) { void *src = malloc(sizes[i]); void *dst = malloc(sizes[i]); printf("%-6d ", sizes[i]); bench_copy(dst, src, sizes[i]); printf(" "); bench_cmp(dst, src, sizes[i]); printf("\n"); free(src); free(dst); } return 0; } nvc-r1.17.1/test/copyperf.c000066400000000000000000000031141504111170000155100ustar00rootroot00000000000000#include #include #include #include #include #include "rt/copy.h" typedef struct { size_t off1, size, off2; } case_t; uint64_t get_timestamp_ns(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_nsec + (ts.tv_sec * 1000000000ul); } int main(int argc, char **argv) { FILE *f = fopen("cases.txt", "r"); assert(f); int ncases = 0, maxmem = 0, maxlen = 0; while (!feof(f)) { size_t off1, size, off2; int n = fscanf(f, "%zu %zu %ld\n", &off1, &size, &off2); assert(n == 3); ncases++; if (off2 + size > maxmem) maxmem = off2 + size; if (size > maxlen) maxlen = size; } printf("%d cases, %d bytes max offset; %d bytes max length\n", ncases, maxmem, maxlen); rewind(f); case_t *cases = malloc(ncases * sizeof(case_t)); assert(cases); for (int i = 0; i < ncases; i++) { int n = fscanf(f, "%zu %zu %ld\n", &cases[i].off1, &cases[i].size, &cases[i].off2); assert(n == 3); } unsigned char *mem = malloc(maxmem); for (int i = 0; i < maxmem; i++) mem[i] = i; unsigned char *src = malloc(maxlen); for (int i = 0; i < maxlen; i++) src[i] = i; const unsigned long start = get_timestamp_ns(); for (int n = 0; n < 1000; n++) { for (int i = 0; i < ncases; i++) copy2(mem + cases[i].off1, mem + cases[i].off2, src, cases[i].size); } const unsigned long end = get_timestamp_ns(); printf("===> %lu us\n", (end - start) / 1000); return 0; } nvc-r1.17.1/test/diag/000077500000000000000000000000001504111170000144225ustar00rootroot00000000000000nvc-r1.17.1/test/diag/diag1.vhd000066400000000000000000000014061504111170000161130ustar00rootroot00000000000000entity diag1 is end entity; architecture test of diag1 is --------------------------------------------------------------------------- -- All three of the following lines should appear in the error message signal x : integer; constant k : integer := 2; signal x : integer; -- Error --------------------------------------------------------------------------- -- There should be a gap between the two error lines here signal y : integer; -- One -- Two -- Three -- Four signal y : integer; -- Error /* Requires a later standard */ --------------------------------------------------------------------------- constant b : boolean := '1' = '1'; -- Error begin end architecture; nvc-r1.17.1/test/dist.mk000066400000000000000000002004101504111170000150070ustar00rootroot00000000000000# Generated automatically, do not edit. EXTRA_DIST += \ test/bounds/aggregate.vhd \ test/bounds/bounds2.vhd \ test/bounds/bounds.vhd \ test/bounds/case2.vhd \ test/bounds/case3.vhd \ test/bounds/case4.vhd \ test/bounds/case5.vhd \ test/bounds/case.vhd \ test/bounds/cons1.vhd \ test/bounds/driver1.vhd \ test/bounds/initial.vhd \ test/bounds/issue1021.vhd \ test/bounds/issue1040.vhd \ test/bounds/issue1091.vhd \ test/bounds/issue150.vhd \ test/bounds/issue200.vhd \ test/bounds/issue208.vhd \ test/bounds/issue247.vhd \ test/bounds/issue251.vhd \ test/bounds/issue269.vhd \ test/bounds/issue307b.vhd \ test/bounds/issue356.vhd \ test/bounds/issue36.vhd \ test/bounds/issue477a.vhd \ test/bounds/issue477b.vhd \ test/bounds/issue54.vhd \ test/bounds/issue617.vhd \ test/bounds/issue734.vhd \ test/bounds/issue800.vhd \ test/bounds/issue806.vhd \ test/bounds/issue817.vhd \ test/bounds/issue819.vhd \ test/bounds/issue863.vhd \ test/bounds/issue951.vhd \ test/bounds/issue966.vhd \ test/bounds/issue975.vhd \ test/bounds/issue98.vhd \ test/bounds/issue99.vhd \ test/bounds/map1.vhd \ test/bounds/map2.vhd \ test/bounds/nullrange.vhd \ test/bounds/osvvm1.vhd \ test/bounds/range1.vhd \ test/bounds/subtype.vhd \ test/bounds/tc1147.vhd \ test/charset/iso8859-1.vhd \ test/charset/strings.vhd \ test/charset/utf8.vhd \ test/diag/diag1.vhd \ test/driver/issue930.vhd \ test/driver/issue953.vhd \ test/driver/sanity1.vhd \ test/driver/sanity2.vhd \ test/driver/unique1.vhd \ test/driver/unique2.vhd \ test/driver/unique3.vhd \ test/dump/psl1.vhd \ test/dump/vhdl1.vhd \ test/dump/vhdl2.vhd \ test/dump/vhdl3.vhd \ test/dump/vhdl4.vhd \ test/dump/vhdl5.vhd \ test/dump/vhdl6.vhd \ test/dump/vhdl7.vhd \ test/dump/vlog1.v \ test/elab/assert7.vhd \ test/elab/block1.vhd \ test/elab/block2.vhd \ test/elab/body1.vhd \ test/elab/bounds10.vhd \ test/elab/bounds11.vhd \ test/elab/bounds14.vhd \ test/elab/bounds40.vhd \ test/elab/bounds41.vhd \ test/elab/bounds42.vhd \ test/elab/bounds7.vhd \ test/elab/comp2.vhd \ test/elab/comp3.vhd \ test/elab/comp4.vhd \ test/elab/comp.vhd \ test/elab/config1.vhd \ test/elab/const1.vhd \ test/elab/copy1.vhd \ test/elab/elab1.vhd \ test/elab/elab2.vhd \ test/elab/elab3.vhd \ test/elab/ename1.vhd \ test/elab/ename2.vhd \ test/elab/ename3.vhd \ test/elab/eval1.vhd \ test/elab/fold1.vhd \ test/elab/fold2.vhd \ test/elab/gbounds.vhd \ test/elab/genagg.vhd \ test/elab/generate1.vhd \ test/elab/generic1.vhd \ test/elab/generic2.vhd \ test/elab/generic3.vhd \ test/elab/genpack1.vhd \ test/elab/genpack2.vhd \ test/elab/genpack3.vhd \ test/elab/genpack4.vhd \ test/elab/genpack5.vhd \ test/elab/gentype1.vhd \ test/elab/ifgen.vhd \ test/elab/issue1012.vhd \ test/elab/issue1017.vhd \ test/elab/issue1195.vhd \ test/elab/issue1201.vhd \ test/elab/issue1204.vhd \ test/elab/issue153.vhd \ test/elab/issue157.vhd \ test/elab/issue159.vhd \ test/elab/issue175.vhd \ test/elab/issue17.vhd \ test/elab/issue184.vhd \ test/elab/issue19.vhd \ test/elab/issue228.vhd \ test/elab/issue232.vhd \ test/elab/issue305.vhd \ test/elab/issue307.vhd \ test/elab/issue315.vhd \ test/elab/issue325.vhd \ test/elab/issue328.vhd \ test/elab/issue330.vhd \ test/elab/issue336.vhd \ test/elab/issue373.vhd \ test/elab/issue374.vhd \ test/elab/issue404.vhd \ test/elab/issue435.vhd \ test/elab/issue442.vhd \ test/elab/issue448.vhd \ test/elab/issue459.vhd \ test/elab/issue514.vhd \ test/elab/issue518.vhd \ test/elab/issue539.vhd \ test/elab/issue669.vhd \ test/elab/issue707.vhd \ test/elab/issue759.vhd \ test/elab/issue855.vhd \ test/elab/issue860.vhd \ test/elab/issue864.vhd \ test/elab/issue93.vhd \ test/elab/issue969.vhd \ test/elab/jcore1.vhd \ test/elab/jcore2.vhd \ test/elab/libbind2.vhd \ test/elab/libbind3.vhd \ test/elab/libbind.vhd \ test/elab/link1.vhd \ test/elab/mixed1.v \ test/elab/mixed1.vhd \ test/elab/neorv1.vhd \ test/elab/null1.vhd \ test/elab/open2.vhd \ test/elab/open3.vhd \ test/elab/opencase.vhd \ test/elab/openinout.vhd \ test/elab/open.vhd \ test/elab/record.vhd \ test/elab/signal34.vhd \ test/elab/tc2881.vhd \ test/elab/tc3138.vhd \ test/elab/tc846.vhd \ test/elab/toplevel2.vhd \ test/elab/toplevel3.vhd \ test/elab/toplevel4.vhd \ test/elab/toplevel5.vhd \ test/elab/view1.vhd \ test/elab/vlog1.v \ test/eopt/alias1.vhd \ test/eopt/array3.vhd \ test/eopt/arrayref1.vhd \ test/eopt/arrayref2.vhd \ test/eopt/arrayref3.vhd \ test/eopt/arrayref4.vhd \ test/eopt/buffer1.vhd \ test/eopt/issue250.vhd \ test/eopt/issue371.vhd \ test/eopt/issue427.vhd \ test/eopt/issue72.vhd \ test/eopt/issue73.vhd \ test/eopt/issue95.vhd \ test/eopt/jcore2.vhd \ test/eopt/jcore4.vhd \ test/eopt/map1.vhd \ test/eopt/map2.vhd \ test/eopt/nonconst1.vhd \ test/eopt/partial1.vhd \ test/eopt/pcall1.vhd \ test/eopt/pcall2.vhd \ test/eopt/ram1.vhd \ test/eopt/recref1.vhd \ test/eopt/recref2.vhd \ test/eopt/slice1.vhd \ test/eopt/slice2.vhd \ test/eopt/source1.vhd \ test/expect.vhd \ test/ghdl.sh \ test/issue746.sh \ test/iverilog.sh \ test/jit/access1.vhd \ test/jit/add1.vhd \ test/jit/arith1.vhd \ test/jit/array1.vhd \ test/jit/assert1.vhd \ test/jit/case1.vhd \ test/jit/context1.vhd \ test/jit/fact.vhd \ test/jit/ieeewarn.vhd \ test/jit/issue496.vhd \ test/jit/issue575.vhd \ test/jit/layout.vhd \ test/jit/overflow.vhd \ test/jit/proc1.vhd \ test/jit/prot1.vhd \ test/jit/range1.vhd \ test/jit/real1.vhd \ test/jit/record1.vhd \ test/jit/record2.vhd \ test/jit/record3.vhd \ test/jit/record4.vhd \ test/jit/relop1.vhd \ test/jit/sum.vhd \ test/jit/trace1.vhd \ test/jit/trim1.vhd \ test/jit/unreachable.vhd \ test/jit/value1.vhd \ test/lower/access1.vhd \ test/lower/access2.vhd \ test/lower/access_bug.vhd \ test/lower/alias1.vhd \ test/lower/arith1.vhd \ test/lower/array1.vhd \ test/lower/array2.vhd \ test/lower/arrayop1.vhd \ test/lower/assert1.vhd \ test/lower/assert2.vhd \ test/lower/assign1.vhd \ test/lower/assign2.vhd \ test/lower/assign3.vhd \ test/lower/attr1.vhd \ test/lower/attr2.vhd \ test/lower/bigarray.vhd \ test/lower/bounds1.vhd \ test/lower/bounds2.vhd \ test/lower/case1.vhd \ test/lower/case2.vhd \ test/lower/choice1.vhd \ test/lower/closefile.vhd \ test/lower/concat.vhd \ test/lower/cond1.vhd \ test/lower/cond2.vhd \ test/lower/const1.vhd \ test/lower/const2.vhd \ test/lower/const3.vhd \ test/lower/conv1.vhd \ test/lower/copy1.vhd \ test/lower/cover.vhd \ test/lower/dealloc.vhd \ test/lower/directmap2.vhd \ test/lower/directmap3.vhd \ test/lower/directmap5.vhd \ test/lower/directmap6.vhd \ test/lower/directmap.vhd \ test/lower/driver1.vhd \ test/lower/event1.vhd \ test/lower/extern1.vhd \ test/lower/func1.vhd \ test/lower/func5.vhd \ test/lower/funcif.vhd \ test/lower/genpack1.vhd \ test/lower/genpack2.vhd \ test/lower/hintbug.vhd \ test/lower/iffold.vhd \ test/lower/incomplete.vhd \ test/lower/instance1.vhd \ test/lower/issue1029.vhd \ test/lower/issue1080.vhd \ test/lower/issue1155.vhd \ test/lower/issue116.vhd \ test/lower/issue1191.vhd \ test/lower/issue1194.vhd \ test/lower/issue1196.vhd \ test/lower/issue1199.vhd \ test/lower/issue1208.vhd \ test/lower/issue122.vhd \ test/lower/issue1234.vhd \ test/lower/issue124.vhd \ test/lower/issue125.vhd \ test/lower/issue134.vhd \ test/lower/issue135.vhd \ test/lower/issue136.vhd \ test/lower/issue149.vhd \ test/lower/issue158.vhd \ test/lower/issue164.vhd \ test/lower/issue167.vhd \ test/lower/issue181.vhd \ test/lower/issue203.vhd \ test/lower/issue215.vhd \ test/lower/issue303.vhd \ test/lower/issue324.vhd \ test/lower/issue333.vhd \ test/lower/issue338b.vhd \ test/lower/issue338.vhd \ test/lower/issue347.vhd \ test/lower/issue351.vhd \ test/lower/issue357.vhd \ test/lower/issue389.vhd \ test/lower/issue426.vhd \ test/lower/issue444.vhd \ test/lower/issue462.vhd \ test/lower/issue476.vhd \ test/lower/issue478.vhd \ test/lower/issue582.vhd \ test/lower/issue591.vhd \ test/lower/issue613.vhd \ test/lower/issue662.vhd \ test/lower/issue725.vhd \ test/lower/issue756.vhd \ test/lower/issue768.vhd \ test/lower/issue791.vhd \ test/lower/issue837.vhd \ test/lower/issue844.vhd \ test/lower/issue859.vhd \ test/lower/issue934.vhd \ test/lower/issue94.vhd \ test/lower/issue972.vhd \ test/lower/link1.vhd \ test/lower/loop1.vhd \ test/lower/loop2.vhd \ test/lower/memset.vhd \ test/lower/mulphys.vhd \ test/lower/nest1.vhd \ test/lower/nullarray.vhd \ test/lower/osvvm2.vhd \ test/lower/osvvm3.vhd \ test/lower/pack1.vhd \ test/lower/predef1.vhd \ test/lower/proc1.vhd \ test/lower/proc3.vhd \ test/lower/proc4.vhd \ test/lower/proc7.vhd \ test/lower/protpcall.vhd \ test/lower/protupref.vhd \ test/lower/real1.vhd \ test/lower/record1.vhd \ test/lower/record2.vhd \ test/lower/record6.vhd \ test/lower/recsignal1.vhd \ test/lower/resfn1.vhd \ test/lower/sig2var.vhd \ test/lower/signal11.vhd \ test/lower/signal1.vhd \ test/lower/signal2.vhd \ test/lower/signal4.vhd \ test/lower/signal5.vhd \ test/lower/sigvar.vhd \ test/lower/slice1.vhd \ test/lower/staticwait.vhd \ test/lower/subtype1.vhd \ test/lower/subtype2.vhd \ test/lower/sum.vhd \ test/lower/synopsys1.vhd \ test/lower/tag.vhd \ test/lower/thunk.vhd \ test/lower/tounsigned.vhd \ test/lower/transfer1.vhd \ test/lower/trigger1.vhd \ test/lower/vital1.vhd \ test/lower/vital2.vhd \ test/lower/vunit1.vhd \ test/lower/vunit2.vhd \ test/lower/vunit3.vhd \ test/lower/vunit4.vhd \ test/lower/vunit5.vhd \ test/lower/wait1.vhd \ test/lower/wait2.vhd \ test/lower/while1.vhd \ test/misc/bufr_test.vhd \ test/misc/elide.vhd \ test/misc/kcuart.vhd \ test/misc/lut4_test.vhd \ test/misc/ramb_test.vhd \ test/model/alias1.vhd \ test/model/basic1.vhd \ test/model/event1.vhd \ test/model/fast1.vhd \ test/model/fast2.vhd \ test/model/index1.vhd \ test/model/pending1.vhd \ test/model/process1.vhd \ test/model/stateless1.vhd \ test/parse/access.vhd \ test/parse/aggregate2.vhd \ test/parse/aggregate.vhd \ test/parse/alias2.vhd \ test/parse/alias3.vhd \ test/parse/alias4.vhd \ test/parse/alias5.vhd \ test/parse/alias.vhd \ test/parse/arch.vhd \ test/parse/array.vhd \ test/parse/attr.vhd \ test/parse/badprimary.vhd \ test/parse/based.vhd \ test/parse/basic_identifier.vhd \ test/parse/bitstring.vhd \ test/parse/block.vhd \ test/parse/comp.vhd \ test/parse/concat.vhd \ test/parse/conc.vhd \ test/parse/cond1.vhd \ test/parse/config.vhd \ test/parse/context.vhd \ test/parse/defer1.vhd \ test/parse/empty.vhd \ test/parse/entity.vhd \ test/parse/enum.vhd \ test/parse/error10.vhd \ test/parse/error11.vhd \ test/parse/error12.vhd \ test/parse/error13.vhd \ test/parse/error2.vhd \ test/parse/error3.vhd \ test/parse/error4.vhd \ test/parse/error5.vhd \ test/parse/error6.vhd \ test/parse/error7.vhd \ test/parse/error8.vhd \ test/parse/error9.vhd \ test/parse/error.vhd \ test/parse/explicit.vhd \ test/parse/expr.vhd \ test/parse/extended.vhd \ test/parse/external.vhd \ test/parse/func.vhd \ test/parse/generate.vhd \ test/parse/gensub.vhd \ test/parse/group.vhd \ test/parse/guarded.vhd \ test/parse/hang.vhd \ test/parse/homograph.vhd \ test/parse/implicit.vhd \ test/parse/instance.vhd \ test/parse/interface.vhd \ test/parse/ir1045.vhd \ test/parse/issue1038.vhd \ test/parse/issue1055.vhd \ test/parse/issue1090.vhd \ test/parse/issue1091b.vhd \ test/parse/issue1091.vhd \ test/parse/issue1096.vhd \ test/parse/issue1124.vhd \ test/parse/issue1129.vhd \ test/parse/issue1138.vhd \ test/parse/issue1152.vhd \ test/parse/issue1174.vhd \ test/parse/issue1188.vhd \ test/parse/issue1202.vhd \ test/parse/issue1249.vhd \ test/parse/issue205.vhd \ test/parse/issue222.vhd \ test/parse/issue360.vhd \ test/parse/issue367.vhd \ test/parse/issue369.vhd \ test/parse/issue388.vhd \ test/parse/issue416.vhd \ test/parse/issue443.vhd \ test/parse/issue457.vhd \ test/parse/issue458.vhd \ test/parse/issue461.vhd \ test/parse/issue464.vhd \ test/parse/issue468.vhd \ test/parse/issue479.vhd \ test/parse/issue532.vhd \ test/parse/issue539.vhd \ test/parse/issue541.vhd \ test/parse/issue568.vhd \ test/parse/issue569.vhd \ test/parse/issue580.vhd \ test/parse/issue604.vhd \ test/parse/issue644.vhd \ test/parse/issue653.vhd \ test/parse/issue654.vhd \ test/parse/issue663.vhd \ test/parse/issue686.vhd \ test/parse/issue687.vhd \ test/parse/issue688.vhd \ test/parse/issue701.vhd \ test/parse/issue708.vhd \ test/parse/issue727.vhd \ test/parse/issue751.vhd \ test/parse/issue753.vhd \ test/parse/issue760.vhd \ test/parse/issue761.vhd \ test/parse/issue776.vhd \ test/parse/issue783.vhd \ test/parse/issue789.vhd \ test/parse/issue792.vhd \ test/parse/issue793.vhd \ test/parse/issue802.vhd \ test/parse/issue805.vhd \ test/parse/issue837.vhd \ test/parse/issue845.vhd \ test/parse/issue848.vhd \ test/parse/issue870.vhd \ test/parse/issue875.vhd \ test/parse/issue889.vhd \ test/parse/issue892.vhd \ test/parse/issue893.vhd \ test/parse/issue905.vhd \ test/parse/issue917.vhd \ test/parse/issue942.vhd \ test/parse/issue952.vhd \ test/parse/issue956.vhd \ test/parse/issue961.vhd \ test/parse/issue977.vhd \ test/parse/issue991.vhd \ test/parse/lcs2016_i03.vhd \ test/parse/literal.vhd \ test/parse/loc.vhd \ test/parse/names2.vhd \ test/parse/names3.vhd \ test/parse/names.vhd \ test/parse/osvvm6.vhd \ test/parse/osvvm7.vhd \ test/parse/package.vhd \ test/parse/pkgindecl.vhd \ test/parse/procedure.vhd \ test/parse/process.vhd \ test/parse/protected2.vhd \ test/parse/protected3.vhd \ test/parse/protected.vhd \ test/parse/qual.vhd \ test/parse/range1.vhd \ test/parse/seq.vhd \ test/parse/slow1.vhd \ test/parse/spec.vhd \ test/parse/subtype2008.vhd \ test/parse/synth.vhd \ test/parse/tc1012.vhd \ test/parse/types.vhd \ test/parse/typo.vhd \ test/parse/uvvm1.vhd \ test/parse/uvvm2.vhd \ test/parse/vests1.vhd \ test/parse/vests2.vhd \ test/parse/vests3.vhd \ test/parse/vests4.vhd \ test/parse/vests5.vhd \ test/parse/vests6.vhd \ test/parse/vhdl2008.vhd \ test/parse/vhdl2019.vhd \ test/parse/visibility10.vhd \ test/parse/visibility11.vhd \ test/parse/visibility12.vhd \ test/parse/visibility1.vhd \ test/parse/visibility2.vhd \ test/parse/visibility3.vhd \ test/parse/visibility4.vhd \ test/parse/visibility5.vhd \ test/parse/visibility6.vhd \ test/parse/visibility7.vhd \ test/parse/visibility8.vhd \ test/parse/visibility9.vhd \ test/parse/vunit10.vhd \ test/parse/vunit5.vhd \ test/parse/vunit6.vhd \ test/parse/vunit7.vhd \ test/parse/vunit8.vhd \ test/parse/vunit9.vhd \ test/perf/alloc.vhd \ test/perf/arraycase.vhd \ test/perf/bigcase.vhd \ test/perf/bigram.vhd \ test/perf/binarytrees.vhd \ test/perf/dyn_agg.vhd \ test/perf/ename.vhd \ test/perf/grind.vhd \ test/perf/math_real.vhd \ test/perf/numeric_std.vhd \ test/perf/simple.vhd \ test/perf/std_logic.vhd \ test/perf/synopsys.vhd \ test/perf/textio.vhd \ test/perf/toggle_cov.vhd \ test/perf/value.vhd \ test/perf/vital.vhd \ test/psl/clock1.vhd \ test/psl/issue1001.vhd \ test/psl/issue910.vhd \ test/psl/parse1.vhd \ test/psl/parse2.vhd \ test/psl/parse3.vhd \ test/psl/parse4.vhd \ test/psl/parse5.vhd \ test/psl/sem1.vhd \ test/psl/sem2.vhd \ test/questa.sh \ test/regress/access10.vhd \ test/regress/access11.vhd \ test/regress/access12.vhd \ test/regress/access1.vhd \ test/regress/access2.vhd \ test/regress/access3.vhd \ test/regress/access4.vhd \ test/regress/access5.vhd \ test/regress/access6.vhd \ test/regress/access7.vhd \ test/regress/access8.vhd \ test/regress/access9.vhd \ test/regress/agg10.vhd \ test/regress/agg11.vhd \ test/regress/agg12.vhd \ test/regress/agg13.vhd \ test/regress/agg14.vhd \ test/regress/agg1.vhd \ test/regress/agg2.vhd \ test/regress/agg3.vhd \ test/regress/agg4.vhd \ test/regress/agg5.vhd \ test/regress/agg6.vhd \ test/regress/agg7.vhd \ test/regress/agg8.vhd \ test/regress/agg9.vhd \ test/regress/alias10.vhd \ test/regress/alias11.vhd \ test/regress/alias12.vhd \ test/regress/alias13.vhd \ test/regress/alias14.vhd \ test/regress/alias15.vhd \ test/regress/alias1.vhd \ test/regress/alias2.vhd \ test/regress/alias3.vhd \ test/regress/alias4.vhd \ test/regress/alias5.vhd \ test/regress/alias6.vhd \ test/regress/alias7.vhd \ test/regress/alias8.vhd \ test/regress/alias9.vhd \ test/regress/arith1.vhd \ test/regress/arith2.vhd \ test/regress/arith3.vhd \ test/regress/arith4.vhd \ test/regress/arith5.vhd \ test/regress/array10.vhd \ test/regress/array11.vhd \ test/regress/array12.vhd \ test/regress/array13.vhd \ test/regress/array14.vhd \ test/regress/array15.vhd \ test/regress/array16.vhd \ test/regress/array17.vhd \ test/regress/array18.vhd \ test/regress/array19.vhd \ test/regress/array1.vhd \ test/regress/array2.vhd \ test/regress/array3.vhd \ test/regress/array4.vhd \ test/regress/array5.vhd \ test/regress/array6.vhd \ test/regress/array7.vhd \ test/regress/array8.vhd \ test/regress/array9.vhd \ test/regress/assert10.vhd \ test/regress/assert11.vhd \ test/regress/assert12.vhd \ test/regress/assert13.vhd \ test/regress/assert1.vhd \ test/regress/assert2.vhd \ test/regress/assert3.vhd \ test/regress/assert4.vhd \ test/regress/assert5.vhd \ test/regress/assert6.vhd \ test/regress/assert7.vhd \ test/regress/assert8.vhd \ test/regress/assert9.vhd \ test/regress/assign1.vhd \ test/regress/assign2.vhd \ test/regress/assign3.vhd \ test/regress/assign4.vhd \ test/regress/assign5.vhd \ test/regress/assign6.vhd \ test/regress/assign7.vhd \ test/regress/assign8.vhd \ test/regress/assign9.vhd \ test/regress/attr10.vhd \ test/regress/attr11.vhd \ test/regress/attr12.vhd \ test/regress/attr13.vhd \ test/regress/attr14.vhd \ test/regress/attr15.vhd \ test/regress/attr16.vhd \ test/regress/attr17.vhd \ test/regress/attr18.vhd \ test/regress/attr19.vhd \ test/regress/attr1.vhd \ test/regress/attr20.vhd \ test/regress/attr21.vhd \ test/regress/attr2.vhd \ test/regress/attr3.vhd \ test/regress/attr4.vhd \ test/regress/attr5.vhd \ test/regress/attr6.vhd \ test/regress/attr7.vhd \ test/regress/attr8.vhd \ test/regress/bitstr1.vhd \ test/regress/bitvec.vhd \ test/regress/block1.vhd \ test/regress/block2.vhd \ test/regress/bounds10.vhd \ test/regress/bounds11.vhd \ test/regress/bounds12.vhd \ test/regress/bounds13.vhd \ test/regress/bounds15.vhd \ test/regress/bounds16.vhd \ test/regress/bounds17.vhd \ test/regress/bounds18.vhd \ test/regress/bounds19.vhd \ test/regress/bounds1.vhd \ test/regress/bounds20.vhd \ test/regress/bounds22.vhd \ test/regress/bounds23.vhd \ test/regress/bounds24.vhd \ test/regress/bounds25.vhd \ test/regress/bounds26.vhd \ test/regress/bounds27.vhd \ test/regress/bounds28.vhd \ test/regress/bounds29.vhd \ test/regress/bounds2.vhd \ test/regress/bounds30.vhd \ test/regress/bounds31.vhd \ test/regress/bounds32.vhd \ test/regress/bounds33.vhd \ test/regress/bounds34.vhd \ test/regress/bounds35.vhd \ test/regress/bounds36.vhd \ test/regress/bounds37.vhd \ test/regress/bounds38.vhd \ test/regress/bounds39.vhd \ test/regress/bounds3.vhd \ test/regress/bounds40.vhd \ test/regress/bounds41.vhd \ test/regress/bounds42.vhd \ test/regress/bounds43.vhd \ test/regress/bounds44.vhd \ test/regress/bounds45.vhd \ test/regress/bounds4.vhd \ test/regress/bounds5.vhd \ test/regress/bounds6.vhd \ test/regress/bounds7.vhd \ test/regress/bounds8.vhd \ test/regress/bounds9.vhd \ test/regress/buffer1.vhd \ test/regress/case10.vhd \ test/regress/case11.vhd \ test/regress/case13.vhd \ test/regress/case14.vhd \ test/regress/case15.vhd \ test/regress/case1.vhd \ test/regress/case2.vhd \ test/regress/case3.vhd \ test/regress/case4.vhd \ test/regress/case5.vhd \ test/regress/case6.vhd \ test/regress/case7.vhd \ test/regress/case8.vhd \ test/regress/case9.vhd \ test/regress/cmdline11.sh \ test/regress/cmdline12.sh \ test/regress/cmdline13.sh \ test/regress/cmdline14.sh \ test/regress/cmdline15.sh \ test/regress/cmdline16.sh \ test/regress/cmdline1.sh \ test/regress/cmdline2.sh \ test/regress/cmdline3.sh \ test/regress/cmdline4.sh \ test/regress/cmdline5.sh \ test/regress/cmdline6.sh \ test/regress/cmdline7.sh \ test/regress/cmdline8.sh \ test/regress/cmdline9.sh \ test/regress/comp1.vhd \ test/regress/comp2.vhd \ test/regress/comp3.vhd \ test/regress/concat1.vhd \ test/regress/concat2.vhd \ test/regress/concat3.vhd \ test/regress/concat4.vhd \ test/regress/concat5.vhd \ test/regress/concat6.vhd \ test/regress/concat7.vhd \ test/regress/cond1.vhd \ test/regress/cond2.vhd \ test/regress/cond3.vhd \ test/regress/cond4.vhd \ test/regress/cond5.vhd \ test/regress/cond6.vhd \ test/regress/conf1.vhd \ test/regress/conf2.vhd \ test/regress/conf3.vhd \ test/regress/conf4.vhd \ test/regress/conf5.vhd \ test/regress/const10.vhd \ test/regress/const1.vhd \ test/regress/const2.vhd \ test/regress/const3.vhd \ test/regress/const4.vhd \ test/regress/const5.vhd \ test/regress/const6.vhd \ test/regress/const7.vhd \ test/regress/const8.vhd \ test/regress/const9.vhd \ test/regress/conv10.vhd \ test/regress/conv11.vhd \ test/regress/conv12.vhd \ test/regress/conv13.vhd \ test/regress/conv14.vhd \ test/regress/conv15.vhd \ test/regress/conv16.vhd \ test/regress/conv17.vhd \ test/regress/conv18.vhd \ test/regress/conv19.vhd \ test/regress/conv1.vhd \ test/regress/conv20.vhd \ test/regress/conv21.vhd \ test/regress/conv2.vhd \ test/regress/conv3.vhd \ test/regress/conv4.vhd \ test/regress/conv5.vhd \ test/regress/conv6.vhd \ test/regress/conv7.vhd \ test/regress/conv8.vhd \ test/regress/conv9.vhd \ test/regress/counter.vhd \ test/regress/cover10.sh \ test/regress/cover10.vhd \ test/regress/cover11.sh \ test/regress/cover11.vhd \ test/regress/cover12.sh \ test/regress/cover12.vhd \ test/regress/cover13.sh \ test/regress/cover13.vhd \ test/regress/cover14.sh \ test/regress/cover14.vhd \ test/regress/cover15.vhd \ test/regress/cover16.vhd \ test/regress/cover17.vhd \ test/regress/cover18.sh \ test/regress/cover18.vhd \ test/regress/cover19.sh \ test/regress/cover19.vhd \ test/regress/cover1.vhd \ test/regress/cover20.sh \ test/regress/cover20.vhd \ test/regress/cover21.sh \ test/regress/cover21.vhd \ test/regress/cover22.sh \ test/regress/cover22.vhd \ test/regress/cover23.sh \ test/regress/cover23.vhd \ test/regress/cover24.sh \ test/regress/cover24.vhd \ test/regress/cover25.vhd \ test/regress/cover26.sh \ test/regress/cover26.vhd \ test/regress/cover27.sh \ test/regress/cover27.vhd \ test/regress/cover2.vhd \ test/regress/cover3.vhd \ test/regress/cover4.vhd \ test/regress/cover5.sh \ test/regress/cover5.vhd \ test/regress/cover6.sh \ test/regress/cover6.vhd \ test/regress/cover7.vhd \ test/regress/cover8.vhd \ test/regress/cover9.sh \ test/regress/cover9.vhd \ test/regress/data/cover10_ef1.txt \ test/regress/data/cover11_ef1.txt \ test/regress/data/cover13_spec.txt \ test/regress/data/cover14_ef1.txt \ test/regress/data/cover18_ef.txt \ test/regress/data/cover19_spec.txt \ test/regress/data/cover23_ef.txt \ test/regress/data/cover9_ef1.txt \ test/regress/data/cover9_ef2.txt \ test/regress/data/cover9_ef3.txt \ test/regress/data/cover9_ef5.txt \ test/regress/debug1.vhd \ test/regress/debug2.vhd \ test/regress/debug3.vhd \ test/regress/debug4.vhd \ test/regress/default1.vhd \ test/regress/default2.vhd \ test/regress/delay1.vhd \ test/regress/delay2.vhd \ test/regress/delay3.vhd \ test/regress/driver10.vhd \ test/regress/driver11.vhd \ test/regress/driver12.vhd \ test/regress/driver13.vhd \ test/regress/driver14.vhd \ test/regress/driver15.vhd \ test/regress/driver16.vhd \ test/regress/driver17.vhd \ test/regress/driver18.vhd \ test/regress/driver19.vhd \ test/regress/driver1.vhd \ test/regress/driver20.vhd \ test/regress/driver21.vhd \ test/regress/driver22.vhd \ test/regress/driver23.vhd \ test/regress/driver2.vhd \ test/regress/driver3.vhd \ test/regress/driver4.vhd \ test/regress/driver5.vhd \ test/regress/driver6.vhd \ test/regress/driver7.vhd \ test/regress/driver8.vhd \ test/regress/driver9.vhd \ test/regress/elab10.vhd \ test/regress/elab11.vhd \ test/regress/elab12.vhd \ test/regress/elab13.vhd \ test/regress/elab14.vhd \ test/regress/elab15.vhd \ test/regress/elab16.vhd \ test/regress/elab17.vhd \ test/regress/elab18.vhd \ test/regress/elab19.vhd \ test/regress/elab1.vhd \ test/regress/elab20.vhd \ test/regress/elab21.vhd \ test/regress/elab22.vhd \ test/regress/elab23.vhd \ test/regress/elab24.vhd \ test/regress/elab25.vhd \ test/regress/elab26.vhd \ test/regress/elab27.vhd \ test/regress/elab28.vhd \ test/regress/elab29.vhd \ test/regress/elab2.vhd \ test/regress/elab30.vhd \ test/regress/elab31.vhd \ test/regress/elab32.vhd \ test/regress/elab33.vhd \ test/regress/elab34.vhd \ test/regress/elab35.vhd \ test/regress/elab36.vhd \ test/regress/elab37.vhd \ test/regress/elab38.vhd \ test/regress/elab39.sh \ test/regress/elab3.vhd \ test/regress/elab40.vhd \ test/regress/elab4.vhd \ test/regress/elab5.vhd \ test/regress/elab6.vhd \ test/regress/elab7.vhd \ test/regress/elab8.vhd \ test/regress/elab9.vhd \ test/regress/ename10.vhd \ test/regress/ename11.vhd \ test/regress/ename12.vhd \ test/regress/ename13.vhd \ test/regress/ename14.vhd \ test/regress/ename15.vhd \ test/regress/ename16.vhd \ test/regress/ename17.vhd \ test/regress/ename1.vhd \ test/regress/ename2.vhd \ test/regress/ename3.vhd \ test/regress/ename4.vhd \ test/regress/ename5.vhd \ test/regress/ename6.vhd \ test/regress/ename7.vhd \ test/regress/ename8.vhd \ test/regress/ename9.vhd \ test/regress/fact.vhd \ test/regress/file10.vhd \ test/regress/file11.vhd \ test/regress/file12.vhd \ test/regress/file13.vhd \ test/regress/file14.vhd \ test/regress/file15.vhd \ test/regress/file1.vhd \ test/regress/file2.vhd \ test/regress/file3.vhd \ test/regress/file4.vhd \ test/regress/file5.vhd \ test/regress/file6.vhd \ test/regress/file7.vhd \ test/regress/file8.vhd \ test/regress/file9.vhd \ test/regress/for1.vhd \ test/regress/for2.vhd \ test/regress/for3.vhd \ test/regress/for4.vhd \ test/regress/force1.vhd \ test/regress/force2.vhd \ test/regress/force3.vhd \ test/regress/func10.vhd \ test/regress/func11.vhd \ test/regress/func12.vhd \ test/regress/func13.vhd \ test/regress/func14.vhd \ test/regress/func15.vhd \ test/regress/func16.vhd \ test/regress/func17.vhd \ test/regress/func18.vhd \ test/regress/func19.vhd \ test/regress/func1.vhd \ test/regress/func20.vhd \ test/regress/func21.vhd \ test/regress/func22.vhd \ test/regress/func23.vhd \ test/regress/func24.vhd \ test/regress/func25.vhd \ test/regress/func2.vhd \ test/regress/func3.vhd \ test/regress/func4.vhd \ test/regress/func5.vhd \ test/regress/func6.vhd \ test/regress/func7.vhd \ test/regress/func8.vhd \ test/regress/func9.vhd \ test/regress/generic1.vhd \ test/regress/genpack10.vhd \ test/regress/genpack11.vhd \ test/regress/genpack12.vhd \ test/regress/genpack13.vhd \ test/regress/genpack14.vhd \ test/regress/genpack15.vhd \ test/regress/genpack16.vhd \ test/regress/genpack17.vhd \ test/regress/genpack18.vhd \ test/regress/genpack19.vhd \ test/regress/genpack1.vhd \ test/regress/genpack2.vhd \ test/regress/genpack3.vhd \ test/regress/genpack4.vhd \ test/regress/genpack5.vhd \ test/regress/genpack6.vhd \ test/regress/genpack7.vhd \ test/regress/genpack8.vhd \ test/regress/genpack9.vhd \ test/regress/gensub1.vhd \ test/regress/gensub2.vhd \ test/regress/gensub3.vhd \ test/regress/gensub4.vhd \ test/regress/gensub5.vhd \ test/regress/gensub6.vhd \ test/regress/gentype1.vhd \ test/regress/gentype2.vhd \ test/regress/gentype3.vhd \ test/regress/gentype4.vhd \ test/regress/gentype5.vhd \ test/regress/gentype6.vhd \ test/regress/gentype7.vhd \ test/regress/gentype8.vhd \ test/regress/gentype9.vhd \ test/regress/gold/access10.txt \ test/regress/gold/access1.txt \ test/regress/gold/access6.txt \ test/regress/gold/access8.txt \ test/regress/gold/alias12.txt \ test/regress/gold/alias1.txt \ test/regress/gold/alias2.txt \ test/regress/gold/alias5.txt \ test/regress/gold/arith2.txt \ test/regress/gold/arith4.txt \ test/regress/gold/arith5.txt \ test/regress/gold/array15.txt \ test/regress/gold/assert10.txt \ test/regress/gold/assert1.txt \ test/regress/gold/assert2.txt \ test/regress/gold/assert3.txt \ test/regress/gold/assert6.txt \ test/regress/gold/assert7.txt \ test/regress/gold/assert8.txt \ test/regress/gold/assert9.txt \ test/regress/gold/attr12.txt \ test/regress/gold/attr17.txt \ test/regress/gold/attr19.txt \ test/regress/gold/attr21.txt \ test/regress/gold/attr3.txt \ test/regress/gold/bounds10.txt \ test/regress/gold/bounds11.txt \ test/regress/gold/bounds12.txt \ test/regress/gold/bounds13.txt \ test/regress/gold/bounds14.txt \ test/regress/gold/bounds15.txt \ test/regress/gold/bounds16.txt \ test/regress/gold/bounds17.txt \ test/regress/gold/bounds18.txt \ test/regress/gold/bounds19.txt \ test/regress/gold/bounds1.txt \ test/regress/gold/bounds20.txt \ test/regress/gold/bounds21.txt \ test/regress/gold/bounds22.txt \ test/regress/gold/bounds23.txt \ test/regress/gold/bounds24.txt \ test/regress/gold/bounds25.txt \ test/regress/gold/bounds26.txt \ test/regress/gold/bounds27.txt \ test/regress/gold/bounds28.txt \ test/regress/gold/bounds29.txt \ test/regress/gold/bounds2.txt \ test/regress/gold/bounds30.txt \ test/regress/gold/bounds31.txt \ test/regress/gold/bounds32.txt \ test/regress/gold/bounds33.txt \ test/regress/gold/bounds34.txt \ test/regress/gold/bounds35.txt \ test/regress/gold/bounds36.txt \ test/regress/gold/bounds37.txt \ test/regress/gold/bounds38.txt \ test/regress/gold/bounds39.txt \ test/regress/gold/bounds3.txt \ test/regress/gold/bounds40.txt \ test/regress/gold/bounds41.txt \ test/regress/gold/bounds42.txt \ test/regress/gold/bounds43.txt \ test/regress/gold/bounds44.txt \ test/regress/gold/bounds45.txt \ test/regress/gold/bounds4.txt \ test/regress/gold/bounds5.txt \ test/regress/gold/bounds6.txt \ test/regress/gold/bounds7.txt \ test/regress/gold/bounds8.txt \ test/regress/gold/bounds9.txt \ test/regress/gold/case13.txt \ test/regress/gold/case5.txt \ test/regress/gold/cond1.txt \ test/regress/gold/cond2.txt \ test/regress/gold/conf1.txt \ test/regress/gold/conf2.txt \ test/regress/gold/const3.txt \ test/regress/gold/conv10.txt \ test/regress/gold/counter.txt \ test/regress/gold/cover10.txt \ test/regress/gold/cover12.txt \ test/regress/gold/cover13.txt \ test/regress/gold/cover14.txt \ test/regress/gold/cover15.xml \ test/regress/gold/cover16.xml \ test/regress/gold/cover17.xml \ test/regress/gold/cover18.txt \ test/regress/gold/cover19.txt \ test/regress/gold/cover1.txt \ test/regress/gold/cover1.xml \ test/regress/gold/cover20.txt \ test/regress/gold/cover21.txt \ test/regress/gold/cover22.txt \ test/regress/gold/cover23.txt \ test/regress/gold/cover24.txt \ test/regress/gold/cover25.xml \ test/regress/gold/cover26.txt \ test/regress/gold/cover27_a.xml \ test/regress/gold/cover27_b.xml \ test/regress/gold/cover27.txt \ test/regress/gold/cover2.xml \ test/regress/gold/cover3.xml \ test/regress/gold/cover4.xml \ test/regress/gold/cover5.txt \ test/regress/gold/cover6.txt \ test/regress/gold/cover7.xml \ test/regress/gold/cover8.xml \ test/regress/gold/cover9.txt \ test/regress/gold/debug1.txt \ test/regress/gold/debug2.txt \ test/regress/gold/debug3.txt \ test/regress/gold/debug4.txt \ test/regress/gold/delay3.txt \ test/regress/gold/driver15.txt \ test/regress/gold/driver21.txt \ test/regress/gold/driver22.txt \ test/regress/gold/driver7.txt \ test/regress/gold/driver9.txt \ test/regress/gold/elab10.txt \ test/regress/gold/elab13.txt \ test/regress/gold/elab3.txt \ test/regress/gold/elab9.txt \ test/regress/gold/ename10.txt \ test/regress/gold/ename11.txt \ test/regress/gold/ename12.txt \ test/regress/gold/ename13.txt \ test/regress/gold/ename14.txt \ test/regress/gold/ename16.txt \ test/regress/gold/ename17.txt \ test/regress/gold/ename2.txt \ test/regress/gold/ename5.txt \ test/regress/gold/ename9.txt \ test/regress/gold/fact.txt \ test/regress/gold/file13.txt \ test/regress/gold/file14.txt \ test/regress/gold/file8.txt \ test/regress/gold/for1.txt \ test/regress/gold/for2.txt \ test/regress/gold/for3.txt \ test/regress/gold/force3.txt \ test/regress/gold/func19.txt \ test/regress/gold/ieee11.txt \ test/regress/gold/ieee12.txt \ test/regress/gold/ieee13.txt \ test/regress/gold/ieee14.txt \ test/regress/gold/ieee15.txt \ test/regress/gold/ieee18.txt \ test/regress/gold/ieee9.txt \ test/regress/gold/image1.txt \ test/regress/gold/issue101.txt \ test/regress/gold/issue1030.dump \ test/regress/gold/issue103.txt \ test/regress/gold/issue1060.txt \ test/regress/gold/issue1071.dump \ test/regress/gold/issue1079.txt \ test/regress/gold/issue110.txt \ test/regress/gold/issue1231.txt \ test/regress/gold/issue185.txt \ test/regress/gold/issue202.txt \ test/regress/gold/issue225.txt \ test/regress/gold/issue227.txt \ test/regress/gold/issue228.txt \ test/regress/gold/issue234.txt \ test/regress/gold/issue308.txt \ test/regress/gold/issue351.txt \ test/regress/gold/issue377.txt \ test/regress/gold/issue433.txt \ test/regress/gold/issue454.dump \ test/regress/gold/issue45.txt \ test/regress/gold/issue469.txt \ test/regress/gold/issue494.txt \ test/regress/gold/issue521.txt \ test/regress/gold/issue524.dump \ test/regress/gold/issue536.dump \ test/regress/gold/issue586.dump \ test/regress/gold/issue592.txt \ test/regress/gold/issue597.txt \ test/regress/gold/issue615.txt \ test/regress/gold/issue616.txt \ test/regress/gold/issue617.txt \ test/regress/gold/issue668.txt \ test/regress/gold/issue700.txt \ test/regress/gold/issue701.txt \ test/regress/gold/issue703.dump \ test/regress/gold/issue703.gtkw \ test/regress/gold/issue704.dump \ test/regress/gold/issue718.txt \ test/regress/gold/issue730.txt \ test/regress/gold/issue734.txt \ test/regress/gold/issue747.txt \ test/regress/gold/issue801.txt \ test/regress/gold/issue808.txt \ test/regress/gold/issue816.txt \ test/regress/gold/issue817.txt \ test/regress/gold/issue840.dump \ test/regress/gold/issue851.dump \ test/regress/gold/issue852.dump \ test/regress/gold/issue856.dump \ test/regress/gold/issue862.txt \ test/regress/gold/issue878.dump \ test/regress/gold/issue885.txt \ test/regress/gold/issue901.dump \ test/regress/gold/issue903.xml \ test/regress/gold/issue904.dump \ test/regress/gold/issue906.xml \ test/regress/gold/issue907.txt \ test/regress/gold/issue909.txt \ test/regress/gold/issue941.xml \ test/regress/gold/issue957.dump \ test/regress/gold/issue962.dump \ test/regress/gold/issue96.txt \ test/regress/gold/issue970.txt \ test/regress/gold/issue972.dump \ test/regress/gold/issue979.dump \ test/regress/gold/issue985.dump \ test/regress/gold/ivtest2.txt \ test/regress/gold/proc13.txt \ test/regress/gold/proc7.txt \ test/regress/gold/proc8.txt \ test/regress/gold/protected11.txt \ test/regress/gold/psl10.txt \ test/regress/gold/psl11.txt \ test/regress/gold/psl13.txt \ test/regress/gold/psl14.txt \ test/regress/gold/psl15.txt \ test/regress/gold/psl16.txt \ test/regress/gold/psl17.txt \ test/regress/gold/psl18.txt \ test/regress/gold/psl19.txt \ test/regress/gold/psl1.txt \ test/regress/gold/psl20.txt \ test/regress/gold/psl21.txt \ test/regress/gold/psl2.txt \ test/regress/gold/psl3.txt \ test/regress/gold/psl4.txt \ test/regress/gold/psl5.txt \ test/regress/gold/psl6.txt \ test/regress/gold/psl7.txt \ test/regress/gold/psl8.txt \ test/regress/gold/psl9.txt \ test/regress/gold/range1.txt \ test/regress/gold/real1.txt \ test/regress/gold/real3.txt \ test/regress/gold/real4.txt \ test/regress/gold/real7.txt \ test/regress/gold/record38.txt \ test/regress/gold/signal11.txt \ test/regress/gold/signal23.txt \ test/regress/gold/signal29.txt \ test/regress/gold/signal6.txt \ test/regress/gold/stop1.txt \ test/regress/gold/stop2.txt \ test/regress/gold/synopsys2.txt \ test/regress/gold/synopsys3.txt \ test/regress/gold/tcl3.txt \ test/regress/gold/textio1.txt \ test/regress/gold/textio5.txt \ test/regress/gold/value3.txt \ test/regress/gold/value4.txt \ test/regress/gold/vhpi1.txt \ test/regress/gold/vhpi5.txt \ test/regress/gold/vlog20.txt \ test/regress/gold/vlog2.txt \ test/regress/gold/vlog3.txt \ test/regress/gold/vlog4.txt \ test/regress/gold/vlog5.txt \ test/regress/gold/vlog6.txt \ test/regress/gold/vlog7.txt \ test/regress/gold/wait12.txt \ test/regress/gold/wait26.txt \ test/regress/gold/wait28.txt \ test/regress/gold/wait2.txt \ test/regress/gold/wait6.txt \ test/regress/gold/wave10.dump \ test/regress/gold/wave11.dump \ test/regress/gold/wave12.dump \ test/regress/gold/wave1.dump \ test/regress/gold/wave2.dump \ test/regress/gold/wave3.dump \ test/regress/gold/wave3.gtkw \ test/regress/gold/wave4.dump \ test/regress/gold/wave5.dump \ test/regress/gold/wave5.gtkw \ test/regress/gold/wave6.dump \ test/regress/gold/wave7.dump \ test/regress/gold/wave8.dump \ test/regress/gold/wave9.dump \ test/regress/gold/while1.txt \ test/regress/grlib1.vhd \ test/regress/guard1.vhd \ test/regress/guard2.vhd \ test/regress/guard3.vhd \ test/regress/guard4.vhd \ test/regress/guard5.vhd \ test/regress/ieee10.vhd \ test/regress/ieee11.vhd \ test/regress/ieee12.vhd \ test/regress/ieee13.vhd \ test/regress/ieee14.vhd \ test/regress/ieee15.vhd \ test/regress/ieee16.vhd \ test/regress/ieee17.vhd \ test/regress/ieee18.vhd \ test/regress/ieee1.vhd \ test/regress/ieee2.vhd \ test/regress/ieee3.vhd \ test/regress/ieee4.vhd \ test/regress/ieee5.vhd \ test/regress/ieee6.vhd \ test/regress/ieee7.vhd \ test/regress/ieee8.vhd \ test/regress/ieee9.vhd \ test/regress/image1.vhd \ test/regress/image2.vhd \ test/regress/implicit1.vhd \ test/regress/implicit2.vhd \ test/regress/implicit3.vhd \ test/regress/implicit4.vhd \ test/regress/implicit5.vhd \ test/regress/implicit6.vhd \ test/regress/implicit7.vhd \ test/regress/implicit8.vhd \ test/regress/implicit9.vhd \ test/regress/integer1.vhd \ test/regress/integer2.vhd \ test/regress/integer3.vhd \ test/regress/issue101.vhd \ test/regress/issue1030.vhd \ test/regress/issue1035.vhd \ test/regress/issue1036.vhd \ test/regress/issue103.vhd \ test/regress/issue1043.vhd \ test/regress/issue1044.v \ test/regress/issue1044.vhd \ test/regress/issue1045.vhd \ test/regress/issue104.vhd \ test/regress/issue1057.vhd \ test/regress/issue1060.vhd \ test/regress/issue1062.vhd \ test/regress/issue106.vhd \ test/regress/issue1071.vhd \ test/regress/issue1074.vhd \ test/regress/issue1079.vhd \ test/regress/issue1094.vhd \ test/regress/issue109.vhd \ test/regress/issue10.vhd \ test/regress/issue110.vhd \ test/regress/issue1117.vhd \ test/regress/issue111.vhd \ test/regress/issue1125.vhd \ test/regress/issue112.vhd \ test/regress/issue1137.vhd \ test/regress/issue1143.vhd \ test/regress/issue1150.vhd \ test/regress/issue115.vhd \ test/regress/issue1161.vhd \ test/regress/issue1164.vhd \ test/regress/issue116.vhd \ test/regress/issue1171.vhd \ test/regress/issue1175.vhd \ test/regress/issue1177.vhd \ test/regress/issue1185.vhd \ test/regress/issue1186.vhd \ test/regress/issue1192.vhd \ test/regress/issue1208.vhd \ test/regress/issue1213.vhd \ test/regress/issue1218.vhd \ test/regress/issue121.vhd \ test/regress/issue1229.vhd \ test/regress/issue122.vhd \ test/regress/issue1231.vhd \ test/regress/issue1233.vhd \ test/regress/issue123.vhd \ test/regress/issue1240.vhd \ test/regress/issue126.vhd \ test/regress/issue13.vhd \ test/regress/issue141.vhd \ test/regress/issue143.vhd \ test/regress/issue146.vhd \ test/regress/issue148.vhd \ test/regress/issue152.vhd \ test/regress/issue153.vhd \ test/regress/issue163.vhd \ test/regress/issue169.vhd \ test/regress/issue16.vhd \ test/regress/issue183.vhd \ test/regress/issue185.vhd \ test/regress/issue186.vhd \ test/regress/issue187.vhd \ test/regress/issue18.vhd \ test/regress/issue194.vhd \ test/regress/issue196.vhd \ test/regress/issue197.vhd \ test/regress/issue200.vhd \ test/regress/issue201.vhd \ test/regress/issue202.vhd \ test/regress/issue204.vhd \ test/regress/issue206.vhd \ test/regress/issue217.vhd \ test/regress/issue225.vhd \ test/regress/issue227.vhd \ test/regress/issue229.vhd \ test/regress/issue234.vhd \ test/regress/issue262.vhd \ test/regress/issue284.vhd \ test/regress/issue293.vhd \ test/regress/issue29.vhd \ test/regress/issue308.vhd \ test/regress/issue309.vhd \ test/regress/issue315.vhd \ test/regress/issue323.vhd \ test/regress/issue327.vhd \ test/regress/issue335.vhd \ test/regress/issue338b.vhd \ test/regress/issue338.vhd \ test/regress/issue340.vhd \ test/regress/issue348.vhd \ test/regress/issue349.vhd \ test/regress/issue351.vhd \ test/regress/issue352.vhd \ test/regress/issue354.vhd \ test/regress/issue367.vhd \ test/regress/issue369.vhd \ test/regress/issue370.vhd \ test/regress/issue371.vhd \ test/regress/issue376.vhd \ test/regress/issue377.vhd \ test/regress/issue38.vhd \ test/regress/issue397.vhd \ test/regress/issue405.vhd \ test/regress/issue407.vhd \ test/regress/issue412.vhd \ test/regress/issue414.vhd \ test/regress/issue415.vhd \ test/regress/issue420.vhd \ test/regress/issue423.vhd \ test/regress/issue428.vhd \ test/regress/issue429.vhd \ test/regress/issue430.vhd \ test/regress/issue432.vhd \ test/regress/issue433.vhd \ test/regress/issue434.vhd \ test/regress/issue447.vhd \ test/regress/issue454.sh \ test/regress/issue454.vhd \ test/regress/issue45.vhd \ test/regress/issue460.vhd \ test/regress/issue467.vhd \ test/regress/issue469.vhd \ test/regress/issue472.sh \ test/regress/issue481.vhd \ test/regress/issue483.vhd \ test/regress/issue484.vhd \ test/regress/issue493.sh \ test/regress/issue494.vhd \ test/regress/issue497.vhd \ test/regress/issue502.vhd \ test/regress/issue507.sh \ test/regress/issue508.vhd \ test/regress/issue516.vhd \ test/regress/issue519.vhd \ test/regress/issue520.vhd \ test/regress/issue521.vhd \ test/regress/issue524.sh \ test/regress/issue524.vhd \ test/regress/issue527.vhd \ test/regress/issue536.vhd \ test/regress/issue539.vhd \ test/regress/issue53.vhd \ test/regress/issue540.vhd \ test/regress/issue542.vhd \ test/regress/issue543.vhd \ test/regress/issue544.vhd \ test/regress/issue547.vhd \ test/regress/issue548.sh \ test/regress/issue549.vhd \ test/regress/issue550.vhd \ test/regress/issue551.vhd \ test/regress/issue552.vhd \ test/regress/issue560.vhd \ test/regress/issue56.vhd \ test/regress/issue570.vhd \ test/regress/issue571.vhd \ test/regress/issue577.vhd \ test/regress/issue57.vhd \ test/regress/issue586.sh \ test/regress/issue586.vhd \ test/regress/issue589.vhd \ test/regress/issue590.vhd \ test/regress/issue592.vhd \ test/regress/issue595.vhd \ test/regress/issue597.vhd \ test/regress/issue59.vhd \ test/regress/issue603.vhd \ test/regress/issue609.vhd \ test/regress/issue60.vhd \ test/regress/issue610.vhd \ test/regress/issue612.vhd \ test/regress/issue613.vhd \ test/regress/issue615.vhd \ test/regress/issue616.vhd \ test/regress/issue617.vhd \ test/regress/issue618.vhd \ test/regress/issue620.vhd \ test/regress/issue63.vhd \ test/regress/issue640.vhd \ test/regress/issue643.vhd \ test/regress/issue644.vhd \ test/regress/issue646.vhd \ test/regress/issue653.vhd \ test/regress/issue654.vhd \ test/regress/issue655.vhd \ test/regress/issue658.vhd \ test/regress/issue668.vhd \ test/regress/issue670.vhd \ test/regress/issue674.vhd \ test/regress/issue675.vhd \ test/regress/issue676.vhd \ test/regress/issue677.vhd \ test/regress/issue681.vhd \ test/regress/issue690.vhd \ test/regress/issue69.vhd \ test/regress/issue700.vhd \ test/regress/issue701.vhd \ test/regress/issue703.vhd \ test/regress/issue704.vhd \ test/regress/issue705.vhd \ test/regress/issue70.vhd \ test/regress/issue712.vhd \ test/regress/issue714.vhd \ test/regress/issue715.sh \ test/regress/issue718.vhd \ test/regress/issue724.vhd \ test/regress/issue726.vhd \ test/regress/issue72.vhd \ test/regress/issue730.vhd \ test/regress/issue731.vhd \ test/regress/issue732.vhd \ test/regress/issue734.vhd \ test/regress/issue744.vhd \ test/regress/issue747.vhd \ test/regress/issue750.vhd \ test/regress/issue751.vhd \ test/regress/issue752.sh \ test/regress/issue762.vhd \ test/regress/issue766.vhd \ test/regress/issue769.sh \ test/regress/issue787.vhd \ test/regress/issue790.vhd \ test/regress/issue791.vhd \ test/regress/issue794.vhd \ test/regress/issue799.vhd \ test/regress/issue79.vhd \ test/regress/issue801.vhd \ test/regress/issue808.v \ test/regress/issue809.vhd \ test/regress/issue810.vhd \ test/regress/issue815.vhd \ test/regress/issue816.vhd \ test/regress/issue819.vhd \ test/regress/issue820.vhd \ test/regress/issue824.vhd \ test/regress/issue825.vhd \ test/regress/issue826.vhd \ test/regress/issue827.vhd \ test/regress/issue829.vhd \ test/regress/issue82.vhd \ test/regress/issue831.vhd \ test/regress/issue839.vhd \ test/regress/issue83.vhd \ test/regress/issue840.vhd \ test/regress/issue842.vhd \ test/regress/issue843.vhd \ test/regress/issue844.vhd \ test/regress/issue84.vhd \ test/regress/issue850.sh \ test/regress/issue851.vhd \ test/regress/issue852.vhd \ test/regress/issue854.vhd \ test/regress/issue856.vhd \ test/regress/issue858.vhd \ test/regress/issue862.vhd \ test/regress/issue86.vhd \ test/regress/issue873.vhd \ test/regress/issue874.vhd \ test/regress/issue877.vhd \ test/regress/issue878.vhd \ test/regress/issue881.vhd \ test/regress/issue884.vhd \ test/regress/issue885.vhd \ test/regress/issue887.vhd \ test/regress/issue890.vhd \ test/regress/issue894.vhd \ test/regress/issue899.vhd \ test/regress/issue8.vhd \ test/regress/issue901.vhd \ test/regress/issue903.vhd \ test/regress/issue904.vhd \ test/regress/issue906.vhd \ test/regress/issue907.vhd \ test/regress/issue908.vhd \ test/regress/issue909.sh \ test/regress/issue90.vhd \ test/regress/issue91.vhd \ test/regress/issue921.vhd \ test/regress/issue923.vhd \ test/regress/issue924.vhd \ test/regress/issue925.vhd \ test/regress/issue931.vhd \ test/regress/issue932.vhd \ test/regress/issue941.vhd \ test/regress/issue943.vhd \ test/regress/issue946.vhd \ test/regress/issue94.vhd \ test/regress/issue950.vhd \ test/regress/issue954.vhd \ test/regress/issue957.vhd \ test/regress/issue95.vhd \ test/regress/issue960.vhd \ test/regress/issue962.vhd \ test/regress/issue963.vhd \ test/regress/issue968.vhd \ test/regress/issue96.vhd \ test/regress/issue970.vhd \ test/regress/issue971.vhd \ test/regress/issue972.vhd \ test/regress/issue978.vhd \ test/regress/issue979.vhd \ test/regress/issue983.vhd \ test/regress/issue985.vhd \ test/regress/issue988.vhd \ test/regress/issue98.vhd \ test/regress/issue9.vhd \ test/regress/ivtest1.v \ test/regress/ivtest2.v \ test/regress/ivtest3.v \ test/regress/ivtest4.v \ test/regress/ivtest5.v \ test/regress/ivtest6.v \ test/regress/jcore1.vhd \ test/regress/jcore2.vhd \ test/regress/jcore3.vhd \ test/regress/jcore4.vhd \ test/regress/jcore5.vhd \ test/regress/jcore6.vhd \ test/regress/lfsr.vhd \ test/regress/libdir1.sh \ test/regress/libdir2.sh \ test/regress/libdir3.sh \ test/regress/libdir4.sh \ test/regress/link1.vhd \ test/regress/link2.vhd \ test/regress/link3.sh \ test/regress/link3.vhd \ test/regress/link4.vhd \ test/regress/logical1.vhd \ test/regress/logical2.vhd \ test/regress/logical3.vhd \ test/regress/loop1.vhd \ test/regress/mixed1.v \ test/regress/mixed1.vhd \ test/regress/mixed2.v \ test/regress/mixed2.vhd \ test/regress/mixed3.v \ test/regress/mixed3.vhd \ test/regress/mixed4.v \ test/regress/mixed4.vhd \ test/regress/null1.vhd \ test/regress/null2.vhd \ test/regress/null3.vhd \ test/regress/open1.vhd \ test/regress/open2.vhd \ test/regress/operator1.vhd \ test/regress/operator2.vhd \ test/regress/operator3.vhd \ test/regress/operator4.vhd \ test/regress/operator5.vhd \ test/regress/operator6.vhd \ test/regress/order1.vhd \ test/regress/order2.sh \ test/regress/order3.sh \ test/regress/order4.sh \ test/regress/order4.vhd \ test/regress/param1.v \ test/regress/predef1.vhd \ test/regress/predef2.vhd \ test/regress/predef3.vhd \ test/regress/predef4.vhd \ test/regress/predef5.vhd \ test/regress/proc10.vhd \ test/regress/proc11.vhd \ test/regress/proc12.vhd \ test/regress/proc13.vhd \ test/regress/proc1.vhd \ test/regress/proc2.vhd \ test/regress/proc3.vhd \ test/regress/proc4.vhd \ test/regress/proc5.vhd \ test/regress/proc6.vhd \ test/regress/proc7.vhd \ test/regress/proc8.vhd \ test/regress/proc9.vhd \ test/regress/protected10.vhd \ test/regress/protected11.vhd \ test/regress/protected12.vhd \ test/regress/protected13.vhd \ test/regress/protected1.vhd \ test/regress/protected2.vhd \ test/regress/protected3.vhd \ test/regress/protected4.vhd \ test/regress/protected5.vhd \ test/regress/protected6.vhd \ test/regress/protected7.vhd \ test/regress/protected8.vhd \ test/regress/protected9.vhd \ test/regress/psl10.vhd \ test/regress/psl11.vhd \ test/regress/psl12.vhd \ test/regress/psl13.vhd \ test/regress/psl14.vhd \ test/regress/psl15.vhd \ test/regress/psl16.vhd \ test/regress/psl17.vhd \ test/regress/psl18.vhd \ test/regress/psl19.vhd \ test/regress/psl1.vhd \ test/regress/psl20.vhd \ test/regress/psl21.vhd \ test/regress/psl2.vhd \ test/regress/psl3.vhd \ test/regress/psl4.vhd \ test/regress/psl5.vhd \ test/regress/psl6.vhd \ test/regress/psl7.vhd \ test/regress/psl8.vhd \ test/regress/psl9.vhd \ test/regress/ram1.vhd \ test/regress/rand1.vhd \ test/regress/range1.vhd \ test/regress/range2.vhd \ test/regress/range3.vhd \ test/regress/real1.vhd \ test/regress/real2.vhd \ test/regress/real3.vhd \ test/regress/real4.vhd \ test/regress/real5.vhd \ test/regress/real6.vhd \ test/regress/real7.vhd \ test/regress/record10.vhd \ test/regress/record11.vhd \ test/regress/record12.vhd \ test/regress/record13.vhd \ test/regress/record14.vhd \ test/regress/record15.vhd \ test/regress/record16.vhd \ test/regress/record17.vhd \ test/regress/record18.vhd \ test/regress/record19.vhd \ test/regress/record1.vhd \ test/regress/record20.vhd \ test/regress/record21.vhd \ test/regress/record22.vhd \ test/regress/record23.vhd \ test/regress/record24.vhd \ test/regress/record25.vhd \ test/regress/record26.vhd \ test/regress/record27.vhd \ test/regress/record28.vhd \ test/regress/record29.vhd \ test/regress/record2.vhd \ test/regress/record30.vhd \ test/regress/record31.vhd \ test/regress/record32.vhd \ test/regress/record33.vhd \ test/regress/record34.vhd \ test/regress/record35.vhd \ test/regress/record36.vhd \ test/regress/record37.vhd \ test/regress/record38.vhd \ test/regress/record39.vhd \ test/regress/record3.vhd \ test/regress/record4.vhd \ test/regress/record5.vhd \ test/regress/record6.vhd \ test/regress/record7.vhd \ test/regress/record8.vhd \ test/regress/record9.vhd \ test/regress/reflect1.vhd \ test/regress/reflect2.vhd \ test/regress/reflect3.vhd \ test/regress/reflect4.vhd \ test/regress/reflect5.vhd \ test/regress/select1.v \ test/regress/select2.v \ test/regress/select3.v \ test/regress/select4.v \ test/regress/select5.v \ test/regress/select6.v \ test/regress/select7.v \ test/regress/seqblock1.vhd \ test/regress/seqblock2.vhd \ test/regress/shared1.vhd \ test/regress/shared2.vhd \ test/regress/shared3.vhd \ test/regress/shared4.vhd \ test/regress/shift1.vhd \ test/regress/shift2.vhd \ test/regress/shuffle1.vhd \ test/regress/signal10.vhd \ test/regress/signal11.vhd \ test/regress/signal12.vhd \ test/regress/signal13.vhd \ test/regress/signal14.vhd \ test/regress/signal15.vhd \ test/regress/signal16.vhd \ test/regress/signal17.vhd \ test/regress/signal18.vhd \ test/regress/signal19.vhd \ test/regress/signal1.vhd \ test/regress/signal20.vhd \ test/regress/signal21.vhd \ test/regress/signal22.vhd \ test/regress/signal23.vhd \ test/regress/signal24.vhd \ test/regress/signal25.vhd \ test/regress/signal26.vhd \ test/regress/signal27.vhd \ test/regress/signal28.vhd \ test/regress/signal29.vhd \ test/regress/signal2.vhd \ test/regress/signal30.vhd \ test/regress/signal31.vhd \ test/regress/signal32.vhd \ test/regress/signal33.vhd \ test/regress/signal35.vhd \ test/regress/signal36.vhd \ test/regress/signal37.vhd \ test/regress/signal3.vhd \ test/regress/signal4.vhd \ test/regress/signal5.vhd \ test/regress/signal6.vhd \ test/regress/signal7.vhd \ test/regress/signal8.vhd \ test/regress/signal9.vhd \ test/regress/signed1.v \ test/regress/signed1.vhd \ test/regress/slice1.vhd \ test/regress/slice2.vhd \ test/regress/slice3.vhd \ test/regress/slice4.vhd \ test/regress/slice5.vhd \ test/regress/stack1.vhd \ test/regress/stdenv1.vhd \ test/regress/stdenv2.vhd \ test/regress/stdenv3.vhd \ test/regress/stdenv4.vhd \ test/regress/stdenv5.vhd \ test/regress/stdenv6.vhd \ test/regress/stop1.vhd \ test/regress/synopsys1.vhd \ test/regress/synopsys2.vhd \ test/regress/synopsys3.vhd \ test/regress/tcl1.tcl \ test/regress/tcl1.vhd \ test/regress/tcl2.tcl \ test/regress/tcl2.vhd \ test/regress/tcl3.tcl \ test/regress/testlist.txt \ test/regress/textio1.vhd \ test/regress/textio2.vhd \ test/regress/textio3.vhd \ test/regress/textio4.vhd \ test/regress/textio5.vhd \ test/regress/textio6.vhd \ test/regress/textio7.vhd \ test/regress/textio8.vhd \ test/regress/toplevel1.vhd \ test/regress/toplevel2.vhd \ test/regress/toplevel3.vhd \ test/regress/value1.vhd \ test/regress/value2.vhd \ test/regress/value3.vhd \ test/regress/value4.vhd \ test/regress/vecorder1.vhd \ test/regress/vecorder2.vhd \ test/regress/vests10.vhd \ test/regress/vests11.vhd \ test/regress/vests12.vhd \ test/regress/vests13.vhd \ test/regress/vests14.vhd \ test/regress/vests15.vhd \ test/regress/vests16.vhd \ test/regress/vests17.vhd \ test/regress/vests18.vhd \ test/regress/vests19.vhd \ test/regress/vests1.vhd \ test/regress/vests20.vhd \ test/regress/vests21.vhd \ test/regress/vests22.vhd \ test/regress/vests23.vhd \ test/regress/vests24.vhd \ test/regress/vests25.vhd \ test/regress/vests26.vhd \ test/regress/vests27.vhd \ test/regress/vests28.vhd \ test/regress/vests29.vhd \ test/regress/vests2.vhd \ test/regress/vests30.vhd \ test/regress/vests31.vhd \ test/regress/vests32.vhd \ test/regress/vests33.vhd \ test/regress/vests34.vhd \ test/regress/vests35.vhd \ test/regress/vests36.vhd \ test/regress/vests37.vhd \ test/regress/vests38.vhd \ test/regress/vests39.vhd \ test/regress/vests3.vhd \ test/regress/vests40.vhd \ test/regress/vests41.vhd \ test/regress/vests42.vhd \ test/regress/vests43.vhd \ test/regress/vests44.vhd \ test/regress/vests45.vhd \ test/regress/vests46.vhd \ test/regress/vests47.vhd \ test/regress/vests48.vhd \ test/regress/vests49.vhd \ test/regress/vests4.vhd \ test/regress/vests5.vhd \ test/regress/vests6.vhd \ test/regress/vests7.vhd \ test/regress/vests8.vhd \ test/regress/vests9.vhd \ test/regress/vhpi10.vhd \ test/regress/vhpi11.vhd \ test/regress/vhpi12.vhd \ test/regress/vhpi13.vhd \ test/regress/vhpi14.vhd \ test/regress/vhpi15.vhd \ test/regress/vhpi16.vhd \ test/regress/vhpi1.vhd \ test/regress/vhpi2.vhd \ test/regress/vhpi3.vhd \ test/regress/vhpi4.vhd \ test/regress/vhpi5.vhd \ test/regress/vhpi6.vhd \ test/regress/vhpi7.vhd \ test/regress/vhpi8.vhd \ test/regress/vhpi9.vhd \ test/regress/view1.vhd \ test/regress/view2.vhd \ test/regress/view3.vhd \ test/regress/view4.vhd \ test/regress/view5.vhd \ test/regress/view6.vhd \ test/regress/vital1.vhd \ test/regress/vlog10.v \ test/regress/vlog11.v \ test/regress/vlog12.v \ test/regress/vlog13.v \ test/regress/vlog14.v \ test/regress/vlog15.v \ test/regress/vlog16.v \ test/regress/vlog17.v \ test/regress/vlog18.v \ test/regress/vlog19.v \ test/regress/vlog1.v \ test/regress/vlog1.vhd \ test/regress/vlog20.v \ test/regress/vlog2.v \ test/regress/vlog3.v \ test/regress/vlog4.v \ test/regress/vlog5.v \ test/regress/vlog6.v \ test/regress/vlog7.v \ test/regress/vlog8.v \ test/regress/vlog9.v \ test/regress/wait10.vhd \ test/regress/wait11.vhd \ test/regress/wait12.vhd \ test/regress/wait13.vhd \ test/regress/wait14.vhd \ test/regress/wait15.vhd \ test/regress/wait16.vhd \ test/regress/wait17.vhd \ test/regress/wait18.vhd \ test/regress/wait19.vhd \ test/regress/wait1.vhd \ test/regress/wait20.vhd \ test/regress/wait21.vhd \ test/regress/wait22.vhd \ test/regress/wait23.vhd \ test/regress/wait24.vhd \ test/regress/wait25.vhd \ test/regress/wait26.vhd \ test/regress/wait27.vhd \ test/regress/wait28.vhd \ test/regress/wait2.vhd \ test/regress/wait3.vhd \ test/regress/wait4.vhd \ test/regress/wait5.vhd \ test/regress/wait6.vhd \ test/regress/wait7.vhd \ test/regress/wait8.vhd \ test/regress/wait9.vhd \ test/regress/wave10.vhd \ test/regress/wave11.vhd \ test/regress/wave12.vhd \ test/regress/wave1.vhd \ test/regress/wave2.sh \ test/regress/wave2.vhd \ test/regress/wave3.vhd \ test/regress/wave4.vhd \ test/regress/wave5.vhd \ test/regress/wave6.vhd \ test/regress/wave7.sh \ test/regress/wave7.vhd \ test/regress/wave8.vhd \ test/regress/wave9.vhd \ test/regress/while1.vhd \ test/sdf/parse10.sdf \ test/sdf/parse11.sdf \ test/sdf/parse12.sdf \ test/sdf/parse13.sdf \ test/sdf/parse14.sdf \ test/sdf/parse15.sdf \ test/sdf/parse16.sdf \ test/sdf/parse17.sdf \ test/sdf/parse18.sdf \ test/sdf/parse19.sdf \ test/sdf/parse1.sdf \ test/sdf/parse20.sdf \ test/sdf/parse21.sdf \ test/sdf/parse22.sdf \ test/sdf/parse23.sdf \ test/sdf/parse24.sdf \ test/sdf/parse2.sdf \ test/sdf/parse3.sdf \ test/sdf/parse4.sdf \ test/sdf/parse5.sdf \ test/sdf/parse6.sdf \ test/sdf/parse7.sdf \ test/sdf/parse8.sdf \ test/sdf/parse9.sdf \ test/sem/access.vhd \ test/sem/afunc.vhd \ test/sem/agg2008.vhd \ test/sem/alias2.vhd \ test/sem/alias.vhd \ test/sem/altera1.vhd \ test/sem/ambiguous.vhd \ test/sem/array.vhd \ test/sem/assert.vhd \ test/sem/attr.vhd \ test/sem/block.vhd \ test/sem/concat.vhd \ test/sem/conc.vhd \ test/sem/condexpr.vhd \ test/sem/config2.vhd \ test/sem/config.vhd \ test/sem/const2.vhd \ test/sem/const.vhd \ test/sem/context.vhd \ test/sem/conv.vhd \ test/sem/driving.vhd \ test/sem/duplicate.vhd \ test/sem/dwlau.vhd \ test/sem/ename.vhd \ test/sem/entity.vhd \ test/sem/error1.vhd \ test/sem/error2.vhd \ test/sem/error3.vhd \ test/sem/file_and_access.vhd \ test/sem/file.vhd \ test/sem/force.vhd \ test/sem/foreign1.vhd \ test/sem/func.vhd \ test/sem/generate.vhd \ test/sem/generics2008.vhd \ test/sem/generics.vhd \ test/sem/genpack2.vhd \ test/sem/genpack3.vhd \ test/sem/genpack4.vhd \ test/sem/genpack5.vhd \ test/sem/genpack.vhd \ test/sem/gensub2.vhd \ test/sem/gensub.vhd \ test/sem/gentype.vhd \ test/sem/implicit.vhd \ test/sem/incomplete.vhd \ test/sem/integer.vhd \ test/sem/interfaces.vhd \ test/sem/issue1010.vhd \ test/sem/issue1020.vhd \ test/sem/issue1024.vhd \ test/sem/issue1025.vhd \ test/sem/issue102.vhd \ test/sem/issue1038.vhd \ test/sem/issue1057.vhd \ test/sem/issue105.vhd \ test/sem/issue1067.vhd \ test/sem/issue1173.vhd \ test/sem/issue1212.vhd \ test/sem/issue128.vhd \ test/sem/issue130.vhd \ test/sem/issue131.vhd \ test/sem/issue132.vhd \ test/sem/issue133.vhd \ test/sem/issue140.vhd \ test/sem/issue144.vhd \ test/sem/issue151.vhd \ test/sem/issue162.vhd \ test/sem/issue165.vhd \ test/sem/issue173.vhd \ test/sem/issue174.vhd \ test/sem/issue176.vhd \ test/sem/issue177.vhd \ test/sem/issue178.vhd \ test/sem/issue188.vhd \ test/sem/issue197.vhd \ test/sem/issue201.vhd \ test/sem/issue219.vhd \ test/sem/issue220.vhd \ test/sem/issue221.vhd \ test/sem/issue224.vhd \ test/sem/issue225.vhd \ test/sem/issue226.vhd \ test/sem/issue232.vhd \ test/sem/issue236.vhd \ test/sem/issue239.vhd \ test/sem/issue246.vhd \ test/sem/issue264.vhd \ test/sem/issue276.vhd \ test/sem/issue293.vhd \ test/sem/issue311.vhd \ test/sem/issue316.vhd \ test/sem/issue326.vhd \ test/sem/issue340.vhd \ test/sem/issue341.vhd \ test/sem/issue350.vhd \ test/sem/issue356.vhd \ test/sem/issue359a.vhd \ test/sem/issue359.vhd \ test/sem/issue363.vhd \ test/sem/issue368.vhd \ test/sem/issue369.vhd \ test/sem/issue377.vhd \ test/sem/issue386.vhd \ test/sem/issue407.vhd \ test/sem/issue465.vhd \ test/sem/issue482.vhd \ test/sem/issue509.vhd \ test/sem/issue52.vhd \ test/sem/issue53.vhd \ test/sem/issue58.vhd \ test/sem/issue655.vhd \ test/sem/issue659.vhd \ test/sem/issue660.vhd \ test/sem/issue713.vhd \ test/sem/issue770.vhd \ test/sem/issue884.vhd \ test/sem/issue88.vhd \ test/sem/issue89.vhd \ test/sem/issue945.vhd \ test/sem/issue958.vhd \ test/sem/issue965.vhd \ test/sem/issue980.vhd \ test/sem/jcore1.vhd \ test/sem/lcs2016_02.vhd \ test/sem/lcs2016_04.vhd \ test/sem/lcs2016_07.vhd \ test/sem/lcs2016_14a.vhd \ test/sem/lcs2016_16.vhd \ test/sem/lcs2016_18.vhd \ test/sem/lcs2016_19.vhd \ test/sem/lcs2016_23.vhd \ test/sem/lcs2016_33.vhd \ test/sem/lcs2016_41.vhd \ test/sem/lcs2016_45a.vhd \ test/sem/lcs2016_47.vhd \ test/sem/lcs2016_49.vhd \ test/sem/lcs2016_59.vhd \ test/sem/lcs2016_72b.vhd \ test/sem/lcs2016_75.vhd \ test/sem/linkage.vhd \ test/sem/mcase.vhd \ test/sem/missingwait.vhd \ test/sem/murax.vhd \ test/sem/osvvm1.vhd \ test/sem/osvvm2.vhd \ test/sem/osvvm3.vhd \ test/sem/osvvm4.vhd \ test/sem/osvvm5.vhd \ test/sem/physical.vhd \ test/sem/ports.vhd \ test/sem/procedure.vhd \ test/sem/protected2.vhd \ test/sem/protected.vhd \ test/sem/real.vhd \ test/sem/record2008.vhd \ test/sem/record.vhd \ test/sem/resolution.vhd \ test/sem/scope.vhd \ test/sem/seq.vhd \ test/sem/signal.vhd \ test/sem/spec1.vhd \ test/sem/spec2.vhd \ test/sem/static.vhd \ test/sem/std.vhd \ test/sem/subtype.vhd \ test/sem/supersede.vhd \ test/sem/tc251.vhd \ test/sem/tc792.vhd \ test/sem/textio.vhd \ test/sem/universal.vhd \ test/sem/use.vhd \ test/sem/varinit.vhd \ test/sem/vests1.vhd \ test/sem/vhdl2008.vhd \ test/sem/vital1.vhd \ test/sem/wait.vhd \ test/shell/describe1.vhd \ test/shell/examine1.vhd \ test/shell/force1.vhd \ test/shell/wave1.vhd \ test/simp/allsens.vhd \ test/simp/args.vhd \ test/simp/casearray1.vhd \ test/simp/casefold1.vhd \ test/simp/casegen.vhd \ test/simp/cfold.vhd \ test/simp/concat.vhd \ test/simp/condexpr.vhd \ test/simp/condvar.vhd \ test/simp/constarr.vhd \ test/simp/context.vhd \ test/simp/conv1.vhd \ test/simp/copysub.vhd \ test/simp/cpcall.vhd \ test/simp/ffold2.vhd \ test/simp/ffold.vhd \ test/simp/foreign1.vhd \ test/simp/func9.vhd \ test/simp/genmap.vhd \ test/simp/genpack1.vhd \ test/simp/genpack2.vhd \ test/simp/gentype.vhd \ test/simp/grlib1.vhd \ test/simp/guard.vhd \ test/simp/ieee1.vhd \ test/simp/issue1182.vhd \ test/simp/issue1239.vhd \ test/simp/issue155.vhd \ test/simp/issue194.vhd \ test/simp/issue212.vhd \ test/simp/issue309.vhd \ test/simp/issue320.vhd \ test/simp/issue321.vhd \ test/simp/issue322.vhd \ test/simp/issue331.vhd \ test/simp/issue332.vhd \ test/simp/issue344.vhd \ test/simp/issue345.vhd \ test/simp/issue362.vhd \ test/simp/issue425.vhd \ test/simp/issue436.vhd \ test/simp/issue437.vhd \ test/simp/issue438.vhd \ test/simp/issue496.vhd \ test/simp/issue49.vhd \ test/simp/issue574.vhd \ test/simp/issue742.vhd \ test/simp/issue782.vhd \ test/simp/issue812.vhd \ test/simp/issue821.vhd \ test/simp/issue867.vhd \ test/simp/issue882.vhd \ test/simp/length.vhd \ test/simp/order1.vhd \ test/simp/order2.vhd \ test/simp/osvvm4.vhd \ test/simp/packinst1.vhd \ test/simp/physical.vhd \ test/simp/ports2008.vhd \ test/simp/predef.vhd \ test/simp/proc.vhd \ test/simp/protfold1.vhd \ test/simp/protfold2.vhd \ test/simp/recrange.vhd \ test/simp/shift2.vhd \ test/simp/simpif1.vhd \ test/simp/static1.vhd \ test/simp/synth1.vhd \ test/simp/table.vhd \ test/test-osvvm.tcl \ test/tsan-suppress.txt \ test/vlog/attr1.v \ test/vlog/case1.v \ test/vlog/casename.v \ test/vlog/concat1.v \ test/vlog/const1.v \ test/vlog/dff.v \ test/vlog/direct1.v \ test/vlog/enum1.v \ test/vlog/gate1.v \ test/vlog/generate1.v \ test/vlog/implicit1.v \ test/vlog/initial1.v \ test/vlog/nets1.v \ test/vlog/param1.v \ test/vlog/param2.v \ test/vlog/parse1.v \ test/vlog/ports.v \ test/vlog/pp1.v \ test/vlog/pp2.v \ test/vlog/pp3.v \ test/vlog/pp4.v \ test/vlog/simple_sem.v \ test/vlog/specify1.v \ test/vlog/struct1.v \ test/vlog/tfcall1.v \ test/vlog/timescale1.v \ test/vlog/udp1.v \ test/vlog/union1.v nvc-r1.17.1/test/driver/000077500000000000000000000000001504111170000150115ustar00rootroot00000000000000nvc-r1.17.1/test/driver/issue930.vhd000066400000000000000000000014161504111170000171020ustar00rootroot00000000000000entity issue930 is end entity; architecture test of issue930 is signal name : string(1 to 40) := (others=>' '); signal s1, s2, s3, s4 : string(1 to 20); begin p_nvc_bug : process procedure set_name( value : string ) is begin name(1 to value'length) <= value; -- Drives all of value end procedure set_name; procedure test2(value : string) is begin s1(1 to value'left) <= (others => ' '); s2(value'low to value'high) <= (others => ' '); s3(value'range) <= (others => ' '); s4(value'reverse_range) <= (others => ' '); end procedure; begin report "test done"; wait; end process p_nvc_bug; end architecture test; nvc-r1.17.1/test/driver/issue953.vhd000066400000000000000000000005101504111170000171010ustar00rootroot00000000000000entity issue953 is end entity; architecture test of issue953 is signal s : bit_vector(1 to 2); begin -- Crash with unconstrained port in has_unique_driver b: block is port ( p : out bit_vector ); port map ( s ); begin p(1) <= '1'; p(2) <= '0'; end block; end architecture; nvc-r1.17.1/test/driver/sanity1.vhd000066400000000000000000000022331504111170000171040ustar00rootroot00000000000000entity sanity1 is end entity; architecture test of sanity1 is signal x, y : bit; signal z : bit_vector(1 to 3); type t_rec is record x, y : integer; end record; signal r, s : t_rec; component comp is port ( o : out bit ); end component; impure function get_bool return boolean is begin return true; end function; constant k : boolean := get_bool; begin p0: x <= '1'; -- { X } p1: process is -- { Y, Z(2), R.X } procedure proc (signal x : out bit) is begin z(2) <= '1'; x <= '0'; end procedure; begin y <= '1'; y <= '0'; z(2) <= '0'; r.x <= 5; proc(z(1+1)); r.x <= 1; wait; end process; u2: component comp -- { Z(1) } port map ( z(1) ); p3: r.y <= 5; -- { R.Y } b4: block is begin b4p0: s.x <= 6; -- { S.X } end block; g5: if k generate g5p0: (z(1), z(2)) <= bit_vector'("10"); -- { Z(0), Z(1) } end generate; end architecture; nvc-r1.17.1/test/driver/sanity2.vhd000066400000000000000000000011151504111170000171030ustar00rootroot00000000000000entity sanity2 is port ( p : out bit_vector ); end entity; architecture test of sanity2 is signal x, y : bit_vector(7 downto 0); begin p0: process is -- { X(3 downto 0) } begin x(3 downto 0) <= X"0"; x(3 downto 0) <= X"1"; wait; end process; p1: process is -- { Y } begin y <= X"00"; y(3 downto 0) <= X"f"; y(4) <= '1'; wait; end process; p2: p(1) <= '1'; -- { P(1) } p3: p(2 to p'length) <= (others => '0'); end architecture; nvc-r1.17.1/test/driver/unique1.vhd000066400000000000000000000011371504111170000171050ustar00rootroot00000000000000entity unique1 is end entity; architecture test of unique1 is type t_rec is record a, b : integer; c : bit_vector(1 to 3); end record; signal s1 : bit_vector(1 downto 0); signal s2 : bit_vector(2 downto 0); signal s3 : bit_vector(7 downto 3); signal s4 : t_rec; signal s5 : t_rec; begin s1(1) <= '1'; s1(0) <= '0'; s2(1) <= '1'; s2(0) <= '0'; s3(7 downto 7) <= "1"; s3(6 downto 4) <= "101"; s3(3) <= '0'; s4.a <= 5; s4.b <= 7; s4.c <= "101"; s5.a <= 5; s5.b <= 7; s5.c(1 to 2) <= "11"; end architecture; nvc-r1.17.1/test/driver/unique2.vhd000066400000000000000000000005361504111170000171100ustar00rootroot00000000000000entity unique2 is end entity; architecture test of unique2 is signal s1 : bit_vector(1 downto 0); impure function get_limit return integer is begin return s1'length; end function; constant limit : integer := get_limit; begin g: for i in 0 to limit generate s1(i) <= '1'; end generate; end architecture; nvc-r1.17.1/test/driver/unique3.vhd000066400000000000000000000007021504111170000171040ustar00rootroot00000000000000entity unique3 is end entity; architecture test of unique3 is type t_rec is record x, y : bit; end record; view x_in_y_out of t_rec is x : in; y : out; end view; signal s1 : bit; signal s2 : t_rec; begin b1: block is port ( o : out bit; v : view x_in_y_out of t_rec ); port map ( s1, s2 ); begin end block; p1: s1 <= '1'; p2: s2 <= ('1', '0'); end architecture; nvc-r1.17.1/test/dump/000077500000000000000000000000001504111170000144635ustar00rootroot00000000000000nvc-r1.17.1/test/dump/psl1.vhd000066400000000000000000000010431504111170000160430ustar00rootroot00000000000000Library ieee; use ieee.std_logic_1164.all; entity parse3 is end entity; architecture test of parse3 is signal a, b, c, clk : bit; begin -- psl default clock is clk'event and clk = '1'; -- psl assert never b; -- psl assert always (a -> next_a[3 to 5] (b)); -- psl assert {a;b and c}; -- psl assert a -> next [2] (b until! c); -- psl cover {[*]; a[*4]} report "msg"; -- psl assert always (a until_ b) abort c; -- psl assert a before! b; -- psl assert {a} [[signal x : bit; x <= '1';]]; end architecture; nvc-r1.17.1/test/dump/vhdl1.vhd000066400000000000000000000002631504111170000162050ustar00rootroot00000000000000entity vhdl1 is port ( x : in bit; y : out integer ); end entity; architecture test of vhdl1 is signal z : bit; begin z <= x after 1 ns; end architecture; nvc-r1.17.1/test/dump/vhdl2.vhd000066400000000000000000000024251504111170000162100ustar00rootroot00000000000000entity vhdl2 is end entity; architecture test of vhdl2 is signal s1 : bit_vector(1 to 6) := (1 => '1', others => '0'); type t1 is array (natural range <>) of bit; subtype t2 is t1(1 to 99); function f1 (x, y : integer) return bit; procedure proc1 is variable v1 : integer := 5; begin v1 := v1 + 1; end procedure; component c1 is generic ( g1 : integer := 2; type t ); port ( x, y : out bit ); end component; type t3 is record x, y : integer; end record; function fact (n : natural) return natural is begin if n > 1 then return n * fact(n - 1); else return 1; end if; end function; begin b1: block is port ( p : integer ); port map ( p => inertial 1 ); begin end block; u1: component c1 generic map ( t => integer ) port map ( open, y => s1(0) ); p1: process (s1) is begin s1 <= "101010" after 1 ns, (others => '1') after 2 ns; report "hello"; end process; g1: for i in 5 downto 2 generate attribute a : integer; signal r : real := 1.2345; attribute a of r : signal is 5; begin assert r > 0.0; end generate; end architecture; nvc-r1.17.1/test/dump/vhdl3.vhd000066400000000000000000000004431504111170000162070ustar00rootroot00000000000000package vhdl3 is generic (g : integer); constant c1 : bit_vector(1 to g); end package; package body vhdl3 is constant c1 : bit_vector(1 to g) := (others => '1'); constant c2 : integer := << constant .uut.x : integer >>; end package body; package vhdl3_i is new work.vhdl3; nvc-r1.17.1/test/dump/vhdl4.vhd000066400000000000000000000005141504111170000162070ustar00rootroot00000000000000entity E is generic ( type t1 is private; type t2 is <>; type t3 is (<>); type t4 is range <>; type t5 is units <>; type t6 is range <> . <>; type t7 is array (t3 range <>) of t1; type t8 is access type is private; type t9 is file of t1; ); end E; nvc-r1.17.1/test/dump/vhdl5.vhd000066400000000000000000000014151504111170000162110ustar00rootroot00000000000000package vhdl5 is procedure get_it (x : out integer); end package; package body vhdl5 is type pt is protected impure function something return integer; end protected; type pt is protected body variable v : integer := 55; impure function something return integer is begin return v; end function; end protected body; shared variable sv : pt; procedure get_it (x : out integer) is begin x := sv.something; end procedure; procedure attrs is attribute foo : string; attribute foo of attrs [] : procedure is "123"; attribute foo of all : literal is "abcd"; attribute foo of others : procedure is "xxx"; begin end procedure; end package body; nvc-r1.17.1/test/dump/vhdl6.vhd000066400000000000000000000003551504111170000162140ustar00rootroot00000000000000entity vhdl6 is end entity; architecture test of vhdl6 is signal x : integer; default clock is true; begin assert << constant ^.foo : integer >> = 2; -- VHDL assert (x = 1 -> x = 2); -- PSL end architecture; nvc-r1.17.1/test/dump/vhdl7.vhd000066400000000000000000000006151504111170000162140ustar00rootroot00000000000000entity vhdl7 is end entity; architecture test of vhdl7 is type t_rec is record x, y : integer; end record; view source of t_rec is x : in; y : out; end view; signal x, y : t_rec; begin b: block is port ( p1 : view source; p2 : view source'converse ); port map ( x, y ); begin end block; end architecture; nvc-r1.17.1/test/dump/vlog1.v000066400000000000000000000025441504111170000157070ustar00rootroot00000000000000module dff (input d, clk, rstb, output reg q); always @(posedge clk) q <= d; endmodule // dff module mod2; wire [7:0] bus; wire w; reg r; integer i; initial begin $display("hello", $time); if (bus) r <= 1 | r; $finish; r = 1; #1 r <= 0; r = ~w; r = #1 5; r <= #5 1; do w = r && w; while (r); while (1); repeat (5) r = r + 1; for (i = 0; i < 10; i++) r = !r; forever i = ++i; end assign bus = 3; pullup (supply1, supply0) g1 (w); mod #(42) u1 (w), u2(bus[1]); assign bus[2] = 4'b1; parameter [7:0] p1 = 5; localparam bit p2 = 0; reg [7:0] array1 [127:0]; initial casex (w) 1'b0, 1'b1: r = p1[3:0]; default: r = 0; endcase endmodule // mod2 primitive multiplexer (mux, control, dataA, dataB); output mux; input control, dataA, dataB; table // control dataA dataB mux 0 1 ? : 1 ; // ? = 0 1 x 0 0 ? : 0 ; 1 ? 1 : 1 ; 1 ? 0 : 0 ; endtable endprimitive module mod3; // Check operator precedence wire x, y, z; initial begin if (x || y === z); if (x & y | y & z === x + z); if (x == y || y == z); if ((x & y) == z); end real v1 = 1.5; integer v2 = x ? 1 : 2; assign z = {x, y}; assign zz = {5{z}}; endmodule // mod3 nvc-r1.17.1/test/elab/000077500000000000000000000000001504111170000144215ustar00rootroot00000000000000nvc-r1.17.1/test/elab/assert7.vhd000066400000000000000000000007601504111170000165170ustar00rootroot00000000000000entity assert7 is end entity; architecture test of assert7 is impure function func (x : integer) return integer is begin assert x > 0; return -x; end function; function resolved (x : bit_vector) return bit is begin return '1'; end function; subtype rbit is resolved bit; -- Disables init side effects temporarily signal s : rbit; -- Asserts during initialisation constant c : integer := func(-1); begin end architecture; nvc-r1.17.1/test/elab/block1.vhd000066400000000000000000000005131504111170000162760ustar00rootroot00000000000000entity block1 is end entity; architecture test of block1 is signal x, y : integer; begin b1: block is generic ( g1 : integer ); generic map ( g1 => 5 ); port ( i : in integer; o : out integer ); port map ( i => x, o => y ); begin o <= i + g1; end block; end architecture; nvc-r1.17.1/test/elab/block2.vhd000066400000000000000000000007271504111170000163060ustar00rootroot00000000000000entity sub is port ( x : out natural ); end entity; architecture test of sub is begin b: block is port ( x : out natural ); port map ( x => x ); begin x <= 1; end block; end architecture; ------------------------------------------------------------------------------- entity block2 is end entity; architecture test of block2 is signal s : natural; begin u: entity work.sub port map ( s ); end architecture; nvc-r1.17.1/test/elab/body1.vhd000066400000000000000000000004571504111170000161500ustar00rootroot00000000000000package pack is function get_value return integer; end package; ------------------------------------------------------------------------------- entity body1 is end entity; use work.pack.all; architecture test of body1 is constant c : integer := get_value; -- Error begin end architecture; nvc-r1.17.1/test/elab/bounds10.vhd000066400000000000000000000012021504111170000165520ustar00rootroot00000000000000entity UC is port( an_input: in bit_vector; an_output: out bit_vector ); end entity; architecture test of UC is begin an_output <= an_input; end architecture; ------------------------------------------------------------------------------- entity bounds10 is end entity; architecture test of bounds10 is signal an_input: bit_vector( 0 downto 0); signal an_output: bit_vector(100 downto 0); begin UC: entity work.UC port map ( an_input => an_input, an_output => an_output ); TEST: an_input <= "0", "1" after 1 ns; end architecture; nvc-r1.17.1/test/elab/bounds11.vhd000066400000000000000000000013371504111170000165640ustar00rootroot00000000000000package pack is function get_value return integer; end package; package body pack is function get_value return integer is begin return 5; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( G : integer := get_value ); port ( x : bit_vector(1 to G) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity bounds11 is end entity; architecture test of bounds11 is signal s : bit_vector(1 to 3); begin u: entity work.sub port map ( s ); -- Error end architecture; nvc-r1.17.1/test/elab/bounds14.vhd000066400000000000000000000004471504111170000165700ustar00rootroot00000000000000entity bounds14 is end entity; architecture test of bounds14 is function get_bits(x, len : natural) return bit_vector is begin return bit_vector'(1 to len => '0'); end function; signal x : bit_vector(7 downto 0) := get_bits(1, 12); -- Error begin end architecture; nvc-r1.17.1/test/elab/bounds40.vhd000066400000000000000000000011741504111170000165650ustar00rootroot00000000000000package pack is type rec is record f : integer_vector; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( p : out rec(f(1 to 8)) ); end entity; architecture test of sub is begin p.f <= (others => 1); end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity bounds40 is end entity; architecture test of bounds40 is signal s : rec(f(1 to 3)); begin u: entity work.sub port map (s); -- Error end architecture; nvc-r1.17.1/test/elab/bounds41.vhd000066400000000000000000000014261504111170000165660ustar00rootroot00000000000000package pack is type rec is record f : integer_vector; end record; type rec_array is array (natural range <>) of rec; type rec2 is record a : rec_array; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub2 is port ( p : out rec2(a(1 to 2)(f(1 to 3))) ); end entity; architecture test of sub2 is begin p.a(2).f <= (others => 1); end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity bounds41 is end entity; architecture test of bounds41 is signal s2 : rec2(a(1 to 1)(f(1 to 3))); begin u2: entity work.sub2 port map (s2); -- Error end architecture; nvc-r1.17.1/test/elab/bounds42.vhd000066400000000000000000000025431504111170000165700ustar00rootroot00000000000000package pack is type params_t is record width : natural; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( depth : natural; params : params_t ); port ( vec : out bit_vector(1 to params.width) ); end entity; architecture test of sub is constant mid : integer := params.width / 2; begin g1: if depth > 0 generate u1: entity work.sub generic map ( depth - 1, params ) port map ( vec(1 to mid) ); u2: entity work.sub generic map ( depth - 1, params ) port map ( vec(mid + 1 to params.width) ); end generate; g2: if depth = 0 generate signal s : bit_vector(1 to params.width); begin p1: process is begin assert s'length = 5; s <= (others => '1'); wait; end process; p2: vec <= s; end generate; end architecture; ------------------------------------------------------------------------------- entity elab40 is end entity; use work.pack.all; architecture test of elab40 is constant params : params_t := ( width => 5 ); signal vec : bit_vector(1 to 5); begin u: entity work.sub generic map ( 2, params ) port map ( vec ); end architecture; nvc-r1.17.1/test/elab/bounds7.vhd000066400000000000000000000011021504111170000164770ustar00rootroot00000000000000entity bounds7 is end entity; architecture test of bounds7 is type t_rec is record x, y : integer; end record; type t_rec_array is array (natural range <>) of t_rec; function get_value return natural is begin return 3; end function; signal s : t_rec_array(1 to get_value); begin b: block is generic ( A : natural ); generic map ( A => 8 ); port ( t : t_rec_array(1 to A) ); port map ( s ); -- Error begin assert t(A - 1) = (1, 2); end block; end architecture; nvc-r1.17.1/test/elab/comp.vhd000066400000000000000000000033051504111170000160630ustar00rootroot00000000000000entity e1 is generic ( g : integer ); port ( x : in integer; y : out integer ); end entity; architecture test of e1 is begin end architecture; ------------------------------------------------------------------------------- entity e2 is generic ( g : integer ); port ( x : in integer ); end entity; architecture test of e2 is begin end architecture; ------------------------------------------------------------------------------- entity e3 is generic ( g : integer ); port ( x : in integer; y : out integer ); end entity; architecture test of e3 is begin end architecture; ------------------------------------------------------------------------------- entity foo is end entity; architecture test of foo is component e1 is generic ( g : integer); port ( x : in integer; y : out integer); end component; component e2 is generic ( g : integer); port ( y : out integer); end component; component e3 is generic ( g : integer); port ( x : in bit; y : out integer); end component; signal x : integer; signal y : integer; begin e1_1: e1 -- OK generic map ( g => 5 ) port map ( x => x, y => y); e2_1: e2 -- Error generic map ( g => 5 ) port map ( y => y); e3_1: e3 -- Error generic map ( g => 5 ) port map ( x => '1', y => y); end architecture; nvc-r1.17.1/test/elab/comp2.vhd000066400000000000000000000013711504111170000161460ustar00rootroot00000000000000entity sub1 is generic ( x : integer := 4 ); end entity; architecture test of sub1 is constant y : integer := x; begin end architecture; ------------------------------------------------------------------------------- entity sub2 is generic ( x : integer := 5 ; y : boolean := true ); end entity; architecture test of sub2 is begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub1 is end component; component sub2 is generic ( y : boolean := false ; x : integer := 7 ); end component; begin sub1_i: component sub1; sub2_i: component sub2; end architecture; nvc-r1.17.1/test/elab/comp3.vhd000066400000000000000000000014361504111170000161510ustar00rootroot00000000000000entity sub1 is generic ( x : integer ); end entity; architecture test of sub1 is constant y : integer := x; begin end architecture; ------------------------------------------------------------------------------- entity sub2 is generic ( x : integer := 5 ; y : boolean := true ); end entity; architecture test of sub2 is begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub1 is end component; component sub2 is generic ( x : boolean := false ; y : integer := 7 ); end component; begin sub1_i: component sub1; -- Error sub2_i: component sub2; -- Error end architecture; nvc-r1.17.1/test/elab/comp4.vhd000066400000000000000000000007221504111170000161470ustar00rootroot00000000000000entity sub is generic ( g1 : integer; g2 : integer := g1 + 1 ); end entity; architecture test of sub is begin p1: assert g2 = g1 + 1; end architecture; ------------------------------------------------------------------------------- entity comp4 is end entity; architecture test of comp4 is component sub is generic ( g1 : integer; g2 : integer := g1 + 1 ); end component; begin u: component sub generic map ( 5 ); end architecture; nvc-r1.17.1/test/elab/config1.vhd000066400000000000000000000016461504111170000164610ustar00rootroot00000000000000entity top is end entity; architecture test of top is component sub1 is end component; component sub2 is port ( p : integer ); end component; begin u1: component sub1; u2: component sub2 port map ( p => 3 ); end architecture; ------------------------------------------------------------------------------- entity e1 is end entity; architecture test of e1 is begin end architecture; ------------------------------------------------------------------------------- entity e2 is port ( p : in integer ); end entity; architecture test of e2 is begin end architecture; ------------------------------------------------------------------------------- configuration config1 of top is for test for u1 : sub1 use entity work.e1(test); end for; for all : sub2 use entity work.e2(test); end for; end for; end configuration; nvc-r1.17.1/test/elab/const1.vhd000066400000000000000000000022261504111170000163350ustar00rootroot00000000000000package pack is function log2(x : in integer) return integer; end package; package body pack is function log2(x : in integer) return integer is variable r : integer := 0; variable c : integer := 1; begin if x <= 1 then r := 1; else while c < x loop r := r + 1; c := c * 2; end loop; end if; return r; end function; end package body; ------------------------------------------------------------------------------- entity pwm is generic ( CLK_FREQ : real; PWM_FREQ : real ); end entity; use work.pack.all; architecture rtl of pwm is constant DIVIDE : integer := integer(CLK_FREQ / PWM_FREQ); constant BITS : integer := log2(DIVIDE); signal ctr_r : bit_vector(BITS - 1 downto 0) := (others => '0'); begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is begin pwm_1: entity work.pwm generic map ( CLK_FREQ => 24.0e6, PWM_FREQ => 1.0e3 ); end architecture; nvc-r1.17.1/test/elab/copy1.vhd000066400000000000000000000014021504111170000161540ustar00rootroot00000000000000entity sub is port ( x : in integer; y : out integer ); end entity; architecture test of sub is function double(n : integer) return integer is type blah is range 1 to 3; variable r : integer; begin r := n * 2; return r; end function; shared variable global : integer; begin y <= double(x); process (x) begin global := x; end process; end architecture; ------------------------------------------------------------------------------- entity copy1 is end entity; architecture test of copy1 is signal x1, y1, x2, y2 : integer; begin sub1_i: entity work.sub port map ( x1, y1 ); sub2_i: entity work.sub port map ( x2, y2 ); end architecture; nvc-r1.17.1/test/elab/elab1.vhd000066400000000000000000000007451504111170000161160ustar00rootroot00000000000000entity elab1_bot is port ( i : in integer; o : out integer ); end entity; architecture test of elab1_bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity elab1_top is end entity; architecture test of elab1_top is signal x, y : integer; begin uut: entity work.elab1_bot port map ( x, y ); end architecture; nvc-r1.17.1/test/elab/elab2.vhd000066400000000000000000000010451504111170000161110ustar00rootroot00000000000000entity elab2_bot is port ( i : in integer; o : out integer ); end entity; architecture test of elab2_bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity elab2_top is end entity; architecture test of elab2_top is signal a, b, c : integer; begin bot1: entity work.elab2_bot port map ( a, b ); bot2: entity work.elab2_bot port map ( b, c ); end architecture; nvc-r1.17.1/test/elab/elab3.vhd000066400000000000000000000024601504111170000161140ustar00rootroot00000000000000package p is function log2(x : in integer) return integer; end package; package body p is function log2(x : in integer) return integer is variable r : integer := 0; variable c : integer := 1; begin if x <= 1 then r := 1; else while c < x loop r := r + 1; c := c * 2; end loop; end if; return r; end function; end package body; ------------------------------------------------------------------------------- entity sub is generic ( W : integer ); end entity; use work.p.all; architecture test of sub is constant B : integer := log2(W); signal s : bit_vector(B - 1 downto 0); constant C : bit_vector(log2(B) to 1) := (others => '0'); begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is begin s : entity work.sub generic map ( 10 ); end architecture; ------------------------------------------------------------------------------- use work.p.all; entity top2 is end entity; architecture test of top2 is constant W : integer := 10; constant B : integer := log2(W); signal s : bit_vector(B - 1 downto 0); begin end architecture; nvc-r1.17.1/test/elab/ename1.vhd000066400000000000000000000007071504111170000162760ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename1 is end entity; architecture test of ename1 is alias a is <>; -- Error begin uut: entity work.bot; end architecture; nvc-r1.17.1/test/elab/ename2.vhd000066400000000000000000000007401504111170000162740ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is constant k : integer := 5; signal x, y : natural; begin p1: process (y) is begin x <= y + 5; end process; end architecture; ------------------------------------------------------------------------------- entity ename2 is end entity; architecture test of ename2 is constant c : integer := <>; -- Error begin uut: entity work.bot; end architecture; nvc-r1.17.1/test/elab/ename3.vhd000066400000000000000000000005131504111170000162730ustar00rootroot00000000000000package pack is constant kk : integer := <>; -- OK (since 1.16) end package; ------------------------------------------------------------------------------- entity ename3 is end entity; use work.pack.all; architecture test of ename3 is constant k : integer := 42; begin end architecture; nvc-r1.17.1/test/elab/eval1.vhd000066400000000000000000000011241504111170000161320ustar00rootroot00000000000000entity sub is generic ( N : integer ); end entity; architecture test of sub is signal x : integer; constant c : bit_vector(7 downto 0) := X"12"; function func(a : integer) return bit is begin return c(a); end function; begin g: if func(N) = '1' generate -- Error x <= 5; end generate; end architecture; ------------------------------------------------------------------------------- entity eval1 is end entity; architecture test of eval1 is begin sub_i: entity work.sub generic map (-1); end architecture; nvc-r1.17.1/test/elab/fold1.vhd000066400000000000000000000014721504111170000161350ustar00rootroot00000000000000package fold1_pkg is type int_vec_2d is array (natural range <>, natural range <>) of integer; end package; ------------------------------------------------------------------------------- use work.fold1_pkg.all; entity sub is generic ( G : int_vec_2d ); end entity; architecture test of sub is constant k : int_vec_2d := G; begin main: process is begin assert G(1, 2) = 6; wait; end process; end architecture; ------------------------------------------------------------------------------- entity fold1 is end entity; use work.fold1_pkg.all; architecture test of fold1 is function get_vec return int_vec_2d is begin return ( (1, 2, 3), (4, 5, 6) ); end function; begin u: entity work.sub generic map ( get_vec ); end architecture; nvc-r1.17.1/test/elab/fold2.vhd000066400000000000000000000016111504111170000161310ustar00rootroot00000000000000package fold2_pkg is type int_vec_2d is array (natural range <>, natural range <>) of integer; end package; ------------------------------------------------------------------------------- use work.fold2_pkg.all; entity sub is generic ( G : int_vec_2d(1 to 2, 1 to 3) ); end entity; architecture test of sub is constant k : int_vec_2d := G; begin main: process is begin assert G(1, 2) = 2; wait; end process; end architecture; ------------------------------------------------------------------------------- entity fold2 is end entity; use work.fold2_pkg.all; architecture test of fold2 is subtype int_vec_2d_2x3 is int_vec_2d(1 to 2, 1 to 3); function get_vec return int_vec_2d_2x3 is begin return ( (1, 2, 3), (4, 5, 6) ); end function; begin u: entity work.sub generic map ( get_vec ); end architecture; nvc-r1.17.1/test/elab/gbounds.vhd000066400000000000000000000010151504111170000165620ustar00rootroot00000000000000entity sub is generic ( X : integer ); end entity; architecture test of sub is signal s : bit_vector(7 downto 0); begin gen: if x >= s'low and x <= s'high generate s(x) <= '1'; end generate; end architecture; ------------------------------------------------------------------------------- entity gbounds is end entity; architecture test of gbounds is begin sub1: entity work.sub generic map ( 2 ); -- OK sub2: entity work.sub generic map ( 9 ); -- No error end architecture; nvc-r1.17.1/test/elab/genagg.vhd000066400000000000000000000020571504111170000163600ustar00rootroot00000000000000entity genagg_sub_sub is generic ( DEVA : bit_vector(6 downto 0) ); port ( clk : in bit; reset : in bit ); end entity; architecture rtl of genagg_sub_sub is begin end architecture; ------------------------------------------------------------------------------- entity genagg_sub is generic ( DEVA : bit_vector(6 downto 0) ); port ( clk : in bit; reset : in bit ); end entity; architecture rtl of genagg_sub is begin slave_i: entity work.genagg_sub_sub generic map ( DEVA => DEVA ) port map ( clk => clk, reset => reset ); end architecture; ------------------------------------------------------------------------------- entity genagg is end entity; architecture test of genagg is signal clk : bit := '0'; signal reset : bit := '1'; begin uut: entity work.genagg_sub generic map ( DEVA => "0000101" ) port map ( clk => clk, reset => reset ); end architecture; nvc-r1.17.1/test/elab/generate1.vhd000066400000000000000000000006451504111170000170040ustar00rootroot00000000000000entity generate1 is end entity; architecture test of generate1 is constant N : integer := 3; function init_vec return bit_vector is variable r : bit_vector(1 to N); begin return r; end function; constant iv : bit_vector := init_vec; signal vec : bit_vector(iv'range) := iv; begin g: for i in vec'range generate vec(i) <= '1'; end generate; end architecture; nvc-r1.17.1/test/elab/generic1.vhd000066400000000000000000000013551504111170000166250ustar00rootroot00000000000000entity sub is generic (g : integer; m : string; b : boolean; s : severity_level); port (o : out integer); end entity; architecture test of sub is begin p1: o <= g; p2: assert b report m severity s; end architecture; ------------------------------------------------------------------------------- entity generic1 is end entity; architecture test of generic1 is type rec is record x : integer; y : string(1 to 5); end record; function get_rec return rec is begin return (x => 1, y => "hello"); end function; constant c : rec := get_rec; signal s : integer; begin u: entity work.sub generic map ( c.x, c.y, false, error ) port map ( s ); end architecture; nvc-r1.17.1/test/elab/generic2.vhd000066400000000000000000000012711504111170000166230ustar00rootroot00000000000000entity sub is generic (g : integer; b : boolean); port (o : out integer); end entity; architecture test of sub is begin p1: o <= g; p2: assert b; end architecture; ------------------------------------------------------------------------------- entity generic2 is end entity; architecture test of generic2 is type rec is record x : integer; y : string(1 to 5); end record; function get_rec return rec is begin return (x => 1, y => "hello"); end function; constant c : rec := get_rec; signal s : integer; begin u: entity work.sub generic map ( c.x + 1, get_rec.x = 6 ) port map ( s ); end architecture; nvc-r1.17.1/test/elab/generic3.vhd000066400000000000000000000011551504111170000166250ustar00rootroot00000000000000entity sub is generic ( i : integer; s : string; t : time; b : bit_vector; type ty ); end entity; architecture test of sub is signal x : string(1 to 2) := s; -- To trigger error begin end architecture; ------------------------------------------------------------------------------- entity generic3 is end entity; architecture test of generic3 is begin u: entity work.sub generic map ( 42, "hello", 5 ns, ('0', '1', '0'), integer ); end architecture; nvc-r1.17.1/test/elab/genpack1.vhd000066400000000000000000000013461504111170000166210ustar00rootroot00000000000000package pack1 is generic (x : integer := 5; y : integer := 2; z : bit_vector(1 to 3) := "101"); end package; ------------------------------------------------------------------------------- package pack2 is generic (package p is new work.pack1 generic map (x => 2)); end package; ------------------------------------------------------------------------------- package pack3 is generic (package p is new work.pack1 generic map (default)); end package; ------------------------------------------------------------------------------- entity genpack1 is end entity; architecture test of genpack1 is package pack1_def is new work.pack1; package p1 is new work.pack2 generic map ( pack1_def ); begin end architecture; nvc-r1.17.1/test/elab/genpack2.vhd000066400000000000000000000015571504111170000166260ustar00rootroot00000000000000package pack1 is generic (x : integer := 5; y : integer := 2; z : bit_vector(1 to 3) := "101"); end package; ------------------------------------------------------------------------------- package pack2 is generic (package p is new work.pack1 generic map (x => 2)); end package; ------------------------------------------------------------------------------- package pack3 is generic (package p is new work.pack1 generic map (default)); end package; ------------------------------------------------------------------------------- entity genpack2 is end entity; architecture test of genpack2 is package pack1_def is new work.pack1; package pack1_55 is new work.pack1 generic map ( 5, 5 ); package p1 is new work.pack3 generic map ( pack1_def ); -- OK package p2 is new work.pack3 generic map ( pack1_55 ); -- Error begin end architecture; nvc-r1.17.1/test/elab/genpack3.vhd000066400000000000000000000015001504111170000166130ustar00rootroot00000000000000package pack1 is generic (x : integer := 5; y : integer := 2; z : bit_vector(1 to 3) := "101"); end package; ------------------------------------------------------------------------------- package pack2 is generic (package p is new work.pack1 generic map (x => 5, z => "100")); end package; ------------------------------------------------------------------------------- package pack3 is generic (package p is new work.pack1 generic map (default)); end package; ------------------------------------------------------------------------------- entity genpack3 is end entity; architecture test of genpack3 is package pack1_def is new work.pack1; package pack1_111 is new work.pack1 generic map ( z => "111" ); package p2 is new work.pack2 generic map ( pack1_111 ); -- Error begin end architecture; nvc-r1.17.1/test/elab/genpack4.vhd000066400000000000000000000020731504111170000166220ustar00rootroot00000000000000package pack0 is type rec is record x : integer; y : bit_vector(1 to 3); end record; end package; ------------------------------------------------------------------------------- use work.pack0.all; package pack1 is generic (x : rec := (55, "101")); end package; ------------------------------------------------------------------------------- package pack2 is generic (package p is new work.pack1 generic map (x => (12, "010"))); end package; ------------------------------------------------------------------------------- package pack3 is generic (package p is new work.pack1 generic map (default)); end package; ------------------------------------------------------------------------------- entity genpack4 is end entity; architecture test of genpack4 is package pack1_def is new work.pack1; package pack1_111 is new work.pack1 generic map ( x => (12, "111") ); package p1 is new work.pack3 generic map ( pack1_def ); -- OK package p2 is new work.pack2 generic map ( pack1_111 ); -- Error begin end architecture; nvc-r1.17.1/test/elab/genpack5.vhd000066400000000000000000000031611504111170000166220ustar00rootroot00000000000000package adder is generic (type t; function "+" (a, b : t) return t is <>; function to_string (x : t) return string is <>); function add (x, y : t) return t; end package; package body adder is function add (x, y : t) return t is begin return x + y; end function; end package body; ------------------------------------------------------------------------------- entity sub is generic ( package p is new work.adder generic map (<>) ); port ( x, y : in p.t; z : out p.t ); end entity; architecture test of sub is begin z <= p.add(x, y); end architecture; ------------------------------------------------------------------------------- entity sub2 is generic ( p : integer ); port ( x, y : in real; z : out real ); end entity; architecture test of sub2 is begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub is generic ( package p is new work.adder generic map (<>) ); port ( x : in p.t; z : out p.t ); end component; component sub2 is generic ( package p is new work.adder generic map (<>) ); port ( x : in p.t; z : out p.t ); end component; signal xr, zr : real; package real_adder is new work.adder generic map ( real ); begin u1: sub generic map ( real_adder ) port map ( xr, zr ); u2: sub2 generic map ( real_adder ) port map ( xr, zr ); end architecture; nvc-r1.17.1/test/elab/gentype1.vhd000066400000000000000000000005601504111170000166610ustar00rootroot00000000000000entity sub is generic ( type t ); end entity; architecture test of sub is signal s : t; begin end architecture; ------------------------------------------------------------------------------- entity gentype1 is end entity; architecture test of gentype1 is begin u: entity work.sub generic map ( t => bit_vector ); -- Error end architecture; nvc-r1.17.1/test/elab/ifgen.vhd000066400000000000000000000007301504111170000162140ustar00rootroot00000000000000entity sub is generic ( foo : boolean := true ); port ( x : out integer ); end entity; architecture test of sub is begin g: if foo = true generate x <= 5; end generate; end architecture; ------------------------------------------------------------------------------- entity ifgen is end entity; architecture test of ifgen is signal x : integer; begin sub_i: entity work.sub port map ( x ); end architecture; nvc-r1.17.1/test/elab/issue1012.vhd000066400000000000000000000007451504111170000165660ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue1012 is end entity; architecture test of issue1012 is signal addr : std_logic_vector(-1 downto 0); begin i_sub_block : block is generic ( WIDTH : natural ); generic map ( WIDTH => 0 ); port ( addr : in std_logic_vector(WIDTH - 1 downto 0) ); port map ( addr => addr ); -- Error begin -- Should not create toggle coverage for null array end block; end architecture; nvc-r1.17.1/test/elab/issue1017.vhd000066400000000000000000000007661504111170000165760ustar00rootroot00000000000000entity sub is generic (type t is array (natural range <>) of type is private); end entity; architecture test of sub is type data_array is array (natural range <>, natural range <>) of t'element ; signal data : data_array(1 to 2, 2 to 3) ; begin end architecture; ------------------------------------------------------------------------------- entity issue1017 is end entity; architecture test of issue1017 is begin u: entity work.sub generic map (integer_vector); end architecture; nvc-r1.17.1/test/elab/issue1195.vhd000066400000000000000000000010171504111170000165730ustar00rootroot00000000000000entity sub is generic ( name : integer ); port ( BAZ : bit ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity issue1195 is end entity; architecture test of issue1195 is component sub is generic ( NAME : integer ); port ( Baz : bit ); end component; begin u: component sub generic map ( NaMe => 6 ) -- OK port map ( baZ => '1' ); -- OK end architecture; nvc-r1.17.1/test/elab/issue1201.vhd000066400000000000000000000022721504111170000165630ustar00rootroot00000000000000entity Foo is generic ( type DATA_TYPE; type DATA_ARRAY_TYPE is array (natural range <>) of data_type; INPUTS : positive); port ( selector : in bit_vector(INPUTS-1 downto 0); input : in data_array_type(0 to INPUTS-1); output : out data_type); end entity; architecture rtl of Foo is begin end architecture; ------------------------------------------------------------------------------- entity issue1201 is end entity; architecture rtl of issue1201 is constant INPUTS : positive := 3; subtype data_type_1 is bit_vector(7 downto 0); type data_array_type_1 is array (0 to INPUTS - 1) of data_type_1; signal selector : bit_vector(INPUTS - 1 downto 0) := (others => '0'); signal input : data_array_type_1 := (others => (others => '0')); signal output : data_type_1; begin foo_inst : entity work.Foo generic map ( DATA_TYPE => data_type_1, DATA_ARRAY_TYPE => data_array_type_1, INPUTS => INPUTS) port map ( selector => selector, input(0) => input(0), input(1 to 2) => input(1 to 2), output => output); end architecture; nvc-r1.17.1/test/elab/issue1204.vhd000066400000000000000000000014621504111170000165660ustar00rootroot00000000000000package interface is type t_rec is record x, y : integer; end record; view if_view of t_rec is x : in; y : out; end view; end package; ------------------------------------------------------------------------------- use work.interface.all; entity module is port ( module_port : view if_view; ); end entity module; architecture test of module is begin end architecture; ----------------------------------------------------------------------------- use work.interface.all; entity top is port ( top_port : view if_view -- Unconnected at top level ); end entity top; architecture logic of top is begin module_inst : entity work.module port map ( module_port => top_port ); end architecture logic; nvc-r1.17.1/test/elab/issue153.vhd000066400000000000000000000004421504111170000165050ustar00rootroot00000000000000entity issue153 is end entity; architecture test of issue153 is signal s, t : bit_vector(7 downto 0); begin g1: for i in s'range generate s(i) <= s(i - 1); end generate; g2: for i in s'range generate t(i - 1) <= s(i); end generate; end architecture; nvc-r1.17.1/test/elab/issue157.vhd000066400000000000000000000007261504111170000165160ustar00rootroot00000000000000package COMPONENTS is component DUMMY_MODULE port (I : in bit; O : out bit); end component; end package; entity DUMMY_MODULE is port (I: in bit; O: out bit); end entity; architecture RTL of DUMMY_MODULE is begin O <= I; end architecture; use WORK.COMPONENTS.DUMMY_MODULE; entity DUMMY_TOP is port (I : in bit; O : out bit); end entity; architecture RTL of DUMMY_TOP is begin U: DUMMY_MODULE port map(I=>I, O=>O); end architecture; nvc-r1.17.1/test/elab/issue159.vhd000066400000000000000000000010161504111170000165110ustar00rootroot00000000000000-- file dummy.vhd package COMPONENTS is component DUMMY_MODULE port (I : in bit; O : out bit); end component; end package; entity DUMMY_MODULE is port (I: in bit; O: out bit); end entity; architecture RTL of DUMMY_MODULE is begin O <= I; end architecture; -- file dummy_top.vhd library DUMMY; use DUMMY.COMPONENTS.DUMMY_MODULE; entity DUMMY_TOP is port (I : in bit; O : out bit); end entity; architecture RTL of DUMMY_TOP is begin U: DUMMY_MODULE port map(I=>I, O=>O); end architecture; nvc-r1.17.1/test/elab/issue17.vhd000066400000000000000000000011461504111170000164260ustar00rootroot00000000000000entity comp4_bot is port ( x : in bit_vector(7 downto 0); y : out bit_vector(7 downto 0) ); end entity; architecture rtl of comp4_bot is begin y <= x; end architecture; ------------------------------------------------------------------------------- entity issue17 is end entity; architecture rtl of issue17 is signal b: bit_vector(7 downto 0); component comp4_bot is port ( y : out bit_vector(7 downto 0); x : in bit_vector(7 downto 0) ); end component; begin c1: component comp4_bot port map ( x=>x"aa", y=>b ); end architecture; nvc-r1.17.1/test/elab/issue175.vhd000066400000000000000000000007761504111170000165230ustar00rootroot00000000000000-- lib2 package pkg2 is constant const2 : integer := 1; end package; package body pkg2 is end package body; use work.pkg2.all; package pkg is constant const : integer := const2 + 1; end package; package body pkg is end package body; ------------------------------------------------------------------------------- -- lib library lib2; use lib2.pkg.all; entity ent is end entity; architecture a of ent is begin main : process begin assert const = 2; wait; end process; end architecture; nvc-r1.17.1/test/elab/issue184.vhd000066400000000000000000000005311504111170000165100ustar00rootroot00000000000000entity ent is generic ( config : string := "config0"; bits : bit_vector := "10101" ); end entity; architecture a of ent is signal sig : integer; begin gen_cfg1 : if config = "config1" generate bad: sig <= 0; end generate; gen_cfg2 : if bits /= "00000" generate good: sig <= 1; end generate; end architecture; nvc-r1.17.1/test/elab/issue19.vhd000066400000000000000000000036231504111170000164320ustar00rootroot00000000000000entity comp6_bot is generic (num : integer := 2 ); port ( x : in bit_vector(7 downto 0); y : out bit_vector(7 downto 0) ); end entity; architecture rtl of comp6_bot is function cfunc (constant val : integer) return integer is variable tmp : integer; begin tmp := 0; for i in 0 to 3 loop tmp := tmp + val; end loop; return tmp; end function cfunc; function cfunc2 (constant k : integer) return integer is variable tmp : integer; begin tmp := 1; for i in 0 to k loop if tmp > k then return i; end if; tmp := tmp + tmp; end loop; end cfunc2; function my_cfunc2 (constant k: integer) return integer is begin if k > 1 then return cfunc(k); end if; return 1; end my_cfunc2; constant cnum : integer := cfunc(num); type m_a_t is array (cnum-1 downto 0) of bit_vector(num-1 downto 0); signal ma : m_a_t; signal tmp : integer := cnum; constant cnum2 : integer := cfunc2(num); type m_a_t2 is array (cnum2-1 downto 0) of bit_vector(num-1 downto 0); signal ma2 : m_a_t2; signal tmp2 : integer := cnum2; constant cnum3 : integer := my_cfunc2(num); type m_a_t3 is array (cnum3-1 downto 0) of bit_vector(num-1 downto 0); signal ma3 : m_a_t3; signal tmp3 : integer := cnum3; begin y <= x; g1: if cnum /= 32 generate assert false; end generate; g2: if cnum3 /= 32 generate assert false; end generate; end architecture; ------------------------------------------------------------------------------- entity comp6 is end entity; architecture rtl of comp6 is signal b: bit_vector(7 downto 0); component comp6_bot is generic (num : integer := 2 ); port ( y : out bit_vector(7 downto 0); x : in bit_vector(7 downto 0) ); end component; begin c1: component comp6_bot generic map (num => 8) port map ( x=>x"aa", y=>b ); end architecture; nvc-r1.17.1/test/elab/issue228.vhd000066400000000000000000000004051504111170000165070ustar00rootroot00000000000000entity issue228 is generic (G : integer range 0 to 3); end entity issue228; use std.textio.all; architecture test of issue228 is begin process begin write(OUTPUT, integer'image(G) & LF); wait; end process; end architecture test; nvc-r1.17.1/test/elab/issue232.vhd000066400000000000000000000006371504111170000165110ustar00rootroot00000000000000entity subent is port ( a : in string(1 to 2) := "AB"; b : out string(1 to 2) ); end entity subent; architecture test of subent is begin b <= a; end architecture test; entity test is end entity test; architecture test of test is signal b : string(1 to 2); begin e1: entity work.subent port map ( a => open, b => b ); end architecture test; nvc-r1.17.1/test/elab/issue305.vhd000066400000000000000000000024631504111170000165110ustar00rootroot00000000000000-- a_ng.vhd package TEST_TYPES is type WIDTH_TYPE is record DATA : integer; end record; end package; use work.TEST_TYPES.all; entity TEST_SUB is generic ( WIDTH : WIDTH_TYPE ); port ( DATA_I : in bit_vector(WIDTH.DATA-1 downto 0); DATA_O : out bit_vector(WIDTH.DATA-1 downto 0) ); end TEST_SUB; architecture MODEL of TEST_SUB is begin DATA_O <= DATA_I; end MODEL; use work.TEST_TYPES.all; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is constant WIDTH : WIDTH_TYPE := (DATA => 8); -- Could not fold this signal DATA_I : bit_vector(WIDTH.DATA-1 downto 0); signal DATA_O : bit_vector(WIDTH.DATA-1 downto 0); begin DUT: entity WORK.TEST_SUB generic map (WIDTH => WIDTH) port map (DATA_I => DATA_I, DATA_O => DATA_O); process begin DATA_I <= "00000000"; wait for 10 ns; assert(DATA_O /= "00000000") report "OK." severity NOTE; assert(DATA_O = "00000000") report "NG." severity ERROR; DATA_I <= "00000001"; wait for 10 ns; assert(DATA_O /= "00000001") report "OK." severity NOTE; assert(DATA_O = "00000001") report "NG." severity ERROR; assert FALSE report "Simulation complete." severity FAILURE; end process; end MODEL; nvc-r1.17.1/test/elab/issue307.vhd000066400000000000000000000015331504111170000165100ustar00rootroot00000000000000-- test_ng_1.vhd use std.textio.all; entity TEST_NG_1 is generic (TIME_WIDTH : integer := 13); end TEST_NG_1; architecture MODEL of TEST_NG_1 is begin process variable text_line : LINE; procedure p(T:in time;M:in string) is begin if (TIME_WIDTH > 0) then WRITE(text_line, T, RIGHT, TIME_WIDTH); elsif (TIME_WIDTH < 0) then WRITE(text_line, T, LEFT , -TIME_WIDTH); -- Bounds check fail -- here end if; WRITE(text_line, string'(" ") & M); WRITELINE(OUTPUT, text_line); end procedure; begin p(Now, string'("Simulation Start.")); wait for 10 ns; p(Now, string'("Simulation Done.")); wait; end process; end MODEL; nvc-r1.17.1/test/elab/issue315.vhd000066400000000000000000000014471504111170000165130ustar00rootroot00000000000000entity issue315 is generic ( DATA_BITS : integer := 32 ); end entity; architecture test of issue315 is type INFO_TYPE is record DATA_LO : integer; DATA_HI : integer; BITS : integer; end record; function SET_INFO return INFO_TYPE is variable info : INFO_TYPE; variable index : integer; begin index := 0; info.DATA_LO := index; info.DATA_HI := index + DATA_BITS - 1; index := index + DATA_BITS; info.BITS := index; return info; end function; constant INFO : INFO_TYPE := SET_INFO; signal i_info : bit_vector(INFO.BITS-1 downto 0); signal o_info : bit_vector(INFO.BITS-1 downto 0); begin end architecture; nvc-r1.17.1/test/elab/issue325.vhd000066400000000000000000000013071504111170000165070ustar00rootroot00000000000000-- test.vhd entity test is port ( clk : in bit; rst : in bit; val_o : out bit_vector(15 downto 0) ); end entity test; architecture rtl of test is begin -- architecture rtl end architecture rtl; -- test_tb.vhd entity test_tb is end entity test_tb; architecture tb of test_tb is -- component ports signal clk : bit := '1'; signal rst : bit := '1'; signal val_o : bit_vector(15 downto 0); -- signal sim_done : boolean := false; begin -- architecture tb -- component instantiation DUT: entity work.test -- Fails if library is not called "work" port map ( clk => clk, rst => rst, val_o => val_o); end architecture tb; nvc-r1.17.1/test/elab/issue328.vhd000066400000000000000000000035431504111170000165160ustar00rootroot00000000000000-- test_ng.vhd entity TEST_NG is generic ( INFO_BITS : integer := 1 ); port ( I_INFO_0 : in bit_vector(INFO_BITS-1 downto 0); I_INFO_1 : in bit_vector(INFO_BITS-1 downto 0); O_INFO_0 : out bit_vector(INFO_BITS-1 downto 0); O_INFO_1 : out bit_vector(INFO_BITS-1 downto 0) ); end TEST_NG; architecture MODEL of TEST_NG is type INFO_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; end record; type VEC_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; INFO_0 : INFO_RANGE_TYPE; INFO_1 : INFO_RANGE_TYPE; end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable d_pos : integer; variable v : VEC_RANGE_TYPE; procedure SET_INFO_RANGE(INFO_RANGE: inout INFO_RANGE_TYPE; BITS: in integer) is begin INFO_RANGE.DATA_LO := d_pos; INFO_RANGE.DATA_HI := d_pos + BITS-1; d_pos := d_pos + BITS; end procedure; begin d_pos := 0; v.DATA_LO := d_pos; SET_INFO_RANGE(v.INFO_0, INFO_BITS); SET_INFO_RANGE(v.INFO_1, INFO_BITS); v.DATA_HI := d_pos - 1; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal i_data : bit_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); begin i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO) <= I_INFO_0; i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO) <= I_INFO_1; O_INFO_0 <= i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO); O_INFO_1 <= i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO); end MODEL; nvc-r1.17.1/test/elab/issue330.vhd000066400000000000000000000047431504111170000165120ustar00rootroot00000000000000entity DUMMY is generic( BITS: integer := 1 ); port( I: in bit_vector(BITS-1 downto 0); O: out bit_vector(BITS-1 downto 0) ); end DUMMY; architecture MODEL of DUMMY is begin O <= I; end MODEL; -- test_ng_comp.vhd entity TEST_NG_COMP is generic ( INFO_BITS : integer := 1 ); port ( I_INFO_0 : in bit_vector(INFO_BITS-1 downto 0); I_INFO_1 : in bit_vector(INFO_BITS-1 downto 0); O_INFO_0 : out bit_vector(INFO_BITS-1 downto 0); O_INFO_1 : out bit_vector(INFO_BITS-1 downto 0) ); end TEST_NG_COMP; architecture MODEL of TEST_NG_COMP is type INFO_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; end record; type VEC_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; INFO_0 : INFO_RANGE_TYPE; INFO_1 : INFO_RANGE_TYPE; end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable d_pos : integer; variable v : VEC_RANGE_TYPE; procedure SET_INFO_RANGE(INFO_RANGE: inout INFO_RANGE_TYPE; BITS: in integer) is begin INFO_RANGE.DATA_LO := d_pos; INFO_RANGE.DATA_HI := d_pos + BITS-1; d_pos := d_pos + BITS; end procedure; begin d_pos := 0; v.DATA_LO := d_pos; SET_INFO_RANGE(v.INFO_0, INFO_BITS); SET_INFO_RANGE(v.INFO_1, INFO_BITS); v.DATA_HI := d_pos - 1; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal i_data : bit_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); component DUMMY generic( BITS: integer := 1 ); port( I: in bit_vector(BITS-1 downto 0); O: out bit_vector(BITS-1 downto 0) ); end component; begin I0: DUMMY generic map(BITS => INFO_BITS) port map( I => I_INFO_0, O => i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO) ); I1: DUMMY generic map(BITS => INFO_BITS) port map( I => I_INFO_1, O => i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO) ); O_INFO_0 <= i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO); O_INFO_1 <= i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO); end MODEL; nvc-r1.17.1/test/elab/issue336.vhd000066400000000000000000000063011504111170000165100ustar00rootroot00000000000000-- test_ng.vhd entity TEST_REGS is generic ( REGS_BITS : integer := 32 ); port ( CLK : in bit; RST : in bit; REGS_WEN : in bit_vector(REGS_BITS-1 downto 0); REGS_WDATA : in bit_vector(REGS_BITS-1 downto 0); REGS_RDATA : out bit_vector(REGS_BITS-1 downto 0) ); end TEST_REGS; architecture RTL of TEST_REGS is signal curr_value : bit_vector(REGS_BITS-1 downto 0); begin process (CLK, RST) begin if (RST = '1') then curr_value <= (others => '0'); elsif (CLK'event and CLK = '1') then for i in curr_value'range loop if (i >= REGS_WEN'low and i <= REGS_WEN'high) then if (REGS_WEN(i) = '1') then curr_value(i) <= REGS_WDATA(i); end if; end if; end loop; end if; end process; REGS_RDATA(0) <= curr_value(0); REGS_RDATA(REGS_BITS-1 downto 1) <= curr_value(REGS_BITS-1 downto 1); end RTL; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is component TEST_REGS generic ( REGS_BITS : integer := 32 ); port ( CLK : in bit; RST : in bit; REGS_WEN : in bit_vector(REGS_BITS-1 downto 0); REGS_WDATA : in bit_vector(REGS_BITS-1 downto 0); REGS_RDATA : out bit_vector(REGS_BITS-1 downto 0) ); end component; constant CLK_PERIOD : time := 10 ns; constant DELAY : time := 2 ns; signal CLK : bit; signal RST : bit; constant REGS_BITS : integer := 32; signal regs_wen : bit_vector(REGS_BITS-1 downto 0); signal regs_wdata : bit_vector(REGS_BITS-1 downto 0); signal regs_rdata : bit_vector(REGS_BITS-1 downto 0); begin REGS: TEST_REGS -- generic map ( -- REGS_BITS => REGS_BITS -- ) -- port map ( -- CLK => CLK , -- In : RST => RST , -- In : REGS_WEN => regs_wen , -- In : REGS_WDATA => regs_wdata , -- In : REGS_RDATA => open -- Out : NG if open, OK if regs_rdata ); process begin CLK <= '1'; wait for CLK_PERIOD/2; CLK <= '0'; wait for CLK_PERIOD/2; end process; TEST: process begin RST <= '1'; regs_wen <= (others => '0'); regs_wdata <= (others => '0'); wait until (CLK'event and CLK = '1'); RST <= '0' after DELAY; wait until (CLK'event and CLK = '1'); regs_wen <= (others => '1') after DELAY; regs_wdata <= (others => '0') after DELAY; wait until (CLK'event and CLK = '1'); regs_wen <= (others => '0') after DELAY; wait until (CLK'event and CLK = '1'); wait; end process; end MODEL; nvc-r1.17.1/test/elab/issue373.vhd000066400000000000000000000005731504111170000165160ustar00rootroot00000000000000entity SUB is generic (NAME:STRING); end SUB; architecture MODEL of SUB is begin process begin report NAME; wait; end process; end MODEL; entity ISSUE373 is end ISSUE373; architecture MODEL of ISSUE373 is component SUB generic (NAME:STRING); end component; begin UNIT: SUB generic map (NAME => string'("ISSUE373:UNIT")); end MODEL; nvc-r1.17.1/test/elab/issue374.vhd000066400000000000000000000034151504111170000165150ustar00rootroot00000000000000-- test_ng.vhd entity SUB_NG is generic ( DATA_BITS : integer := 32 ); port ( I_DATA : in bit_vector(DATA_BITS-1 downto 0); O_DATA : out bit_vector(DATA_BITS-1 downto 0) ); end SUB_NG; architecture MODEL of SUB_NG is begin T2M: block type INFO_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; BITS : integer; end record; function SET_INFO_RANGE return INFO_RANGE_TYPE is variable param : INFO_RANGE_TYPE; variable index : integer; begin index := 0; param.DATA_LO := index; param.DATA_HI := index + DATA_BITS - 1; index := index + DATA_BITS; param.BITS := index; return param; end function; constant INFO_RANGE : INFO_RANGE_TYPE := SET_INFO_RANGE; signal i_info : bit_vector(INFO_RANGE.BITS-1 downto 0); signal o_info : bit_vector(INFO_RANGE.BITS-1 downto 0); begin i_info(INFO_RANGE.DATA_HI downto INFO_RANGE.DATA_LO) <= I_DATA; o_info <= i_info; O_DATA <= o_info(INFO_RANGE.DATA_HI downto INFO_RANGE.DATA_LO); end block; end MODEL; entity issue374 is end issue374; architecture MODEL of issue374 is signal data_0 : bit_vector(12 downto 0); signal data_1 : bit_vector(13 downto 0); begin U0: entity WORK.SUB_NG generic map ( DATA_BITS => data_0'length ) port map ( I_DATA => data_0 ); U1: entity WORK.SUB_NG generic map ( DATA_BITS => data_1'length ) port map ( I_DATA => data_1 ); end MODEL; nvc-r1.17.1/test/elab/issue404.vhd000066400000000000000000000017361504111170000165130ustar00rootroot00000000000000entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is type ADDR_SIGNALS_TYPE is record ADDR : bit_vector(31 downto 0); end record; constant ADDR_SIGNALS_DONTCARE : ADDR_SIGNALS_TYPE := ( ADDR => (others => '0') ); type DATA_SIGNALS_TYPE is record DATA : bit_vector(31 downto 0); end record; constant DATA_SIGNALS_DONTCARE : DATA_SIGNALS_TYPE := ( DATA => (others => '0') ); type SIGNALS_TYPE is record ADDR : ADDR_SIGNALS_TYPE; DATA : DATA_SIGNALS_TYPE; end record; constant SIGNALS_DONTCARE : SIGNALS_TYPE := ( ADDR => ADDR_SIGNALS_DONTCARE, DATA => DATA_SIGNALS_DONTCARE ); function GEN_INIT_SIGNALS return SIGNALS_TYPE is begin return SIGNALS_DONTCARE; end function; signal signals : SIGNALS_TYPE; begin signals <= GEN_INIT_SIGNALS; -- Crash here in eval_op_copy end MODEL; nvc-r1.17.1/test/elab/issue435.vhd000066400000000000000000000023001504111170000165030ustar00rootroot00000000000000entity SAMPLE is generic ( QUEUE_SIZE : integer := 0 ); end entity; architecture RTL of SAMPLE is begin QUEUE_SIZE_VALID: if (QUEUE_SIZE >= 0) generate end generate; end RTL; entity issue435 is generic ( PORT_DATA_BITS : integer := 32; POOL_DATA_BITS : integer := 32; ALIGNMENT_BITS : integer := 8; QUEUE_SIZE : integer := 1 ); end entity; architecture RTL of issue435 is type SETTING_TYPE is record Q_Q_SIZE : integer; end record; function SET_SETTING return SETTING_TYPE is variable setting : SETTING_TYPE; constant POOL_WORDS : integer := POOL_DATA_BITS / ALIGNMENT_BITS; constant PORT_WORDS : integer := PORT_DATA_BITS / ALIGNMENT_BITS; begin if (PORT_DATA_BITS /= ALIGNMENT_BITS) or (POOL_DATA_BITS /= ALIGNMENT_BITS) then setting.Q_Q_SIZE := POOL_WORDS*(QUEUE_SIZE+1)+PORT_WORDS-1; else setting.Q_Q_SIZE := -1; end if; return setting; end function; constant SET : SETTING_TYPE := SET_SETTING; begin Q: entity WORK.SAMPLE generic map (QUEUE_SIZE => SET.Q_Q_SIZE); end RTL; nvc-r1.17.1/test/elab/issue442.vhd000066400000000000000000000022051504111170000165050ustar00rootroot00000000000000entity SAMPLE is generic ( MIN_NUM : integer := 0; MAX_NUM : integer := 7 ); port ( I_PORT_E : in bit_vector(MIN_NUM to MAX_NUM); O_PORT_E : out bit_vector(MIN_NUM to MAX_NUM) ); end SAMPLE; architecture SAMPLE_ARCH_1 of SAMPLE is begin end SAMPLE_ARCH_1; entity ISSUE442 is end ISSUE442; architecture MODEL of ISSUE442 is signal I_PORT_S : bit_vector(1 to 4); signal O_PORT_S : bit_vector(1 to 4); component SAMPLE generic ( MIN_NUM : integer := 0; MAX_NUM : integer := 7 ); port ( I_PORT_C : in bit_vector(MIN_NUM to MAX_NUM); O_PORT_C : out bit_vector(MIN_NUM to MAX_NUM) ); end component; begin DUT: SAMPLE generic map(MIN_NUM=>1, MAX_NUM=>4) port map(I_PORT_C=>I_PORT_S,O_PORT_C=>O_PORT_S); end MODEL; configuration ISSUE442_1 of ISSUE442 is for MODEL for DUT : SAMPLE use entity WORK.SAMPLE(SAMPLE_ARCH_1) port map (I_PORT_E => I_PORT_C, O_PORT_E => O_PORT_C); end for; end for; end ISSUE442_1; nvc-r1.17.1/test/elab/issue448.vhd000066400000000000000000000041201504111170000165110ustar00rootroot00000000000000entity IMAGE_STREAM_BUFFER_TEST_BENCH is generic ( NAME : STRING := "test"; SCENARIO_FILE : STRING := "test.snr"; ELEMENT_SIZE : integer := 8*1024; LINE_SIZE : integer := 0; BANK_SIZE : integer := 0; FINISH_ABORT : boolean := FALSE ); end IMAGE_STREAM_BUFFER_TEST_BENCH; ----------------------------------------------------------------------------------- -- ----------------------------------------------------------------------------------- architecture MODEL of IMAGE_STREAM_BUFFER_TEST_BENCH is begin assert ELEMENT_SIZE > 0; end MODEL; ----------------------------------------------------------------------------------- -- ELEM_BITS=2bit, CHANNEL_SIZE=0, I.C=32, I.X=1, I.Y=1, O.C=32, O.X=3, O.Y=3 D_SIZE=8 ----------------------------------------------------------------------------------- entity issue448 is generic ( NAME : STRING := "test_0_2_32x1x1_32x4x3x3_bug1"; SCENARIO_FILE : STRING := "test_0_2_32x1x1_32x4x3x3_bug1.snr"; BANK_SIZE : integer := 0; LINE_SIZE : integer := 0; FINISH_ABORT : boolean := FALSE ); end issue448; architecture MODEL of issue448 is component IMAGE_STREAM_BUFFER_TEST_BENCH is generic ( NAME : STRING := "test"; SCENARIO_FILE : STRING := "test.snr"; BANK_SIZE : integer := 0; LINE_SIZE : integer := 0; FINISH_ABORT : boolean := FALSE ); end component; begin TB: IMAGE_STREAM_BUFFER_TEST_BENCH generic map ( NAME => NAME , SCENARIO_FILE => SCENARIO_FILE, BANK_SIZE => BANK_SIZE , LINE_SIZE => LINE_SIZE , FINISH_ABORT => FINISH_ABORT ); end MODEL; nvc-r1.17.1/test/elab/issue459.vhd000066400000000000000000000012251504111170000165160ustar00rootroot00000000000000entity test is generic ( g : integer_vector ); port( sig1 : bit_vector ); end entity test; architecture beh of test is begin g_gen : if sig1'length = 10 generate process begin wait; end process; end generate; g_gen2 : if g'length = 3 generate process begin wait; end process; end generate; end architecture beh; ------------------------------------------------------------------------------- entity issue459 is end entity; architecture test of issue459 is signal x : bit_vector(1 to 10); begin u: entity work.test generic map ( (1, 2, 3 ) ) port map ( x ); end architecture; nvc-r1.17.1/test/elab/issue514.vhd000066400000000000000000000014171504111170000165110ustar00rootroot00000000000000package pack is type params is record x, y : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( p : params ); end entity; architecture test of sub is constant px : integer := p.x; constant py : integer := p.y; begin g: for i in px to py generate end generate; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity issue514 is end entity; architecture test of issue514 is function get_params return params is begin return (x => 4, y => 6); end function; begin u: entity work.sub generic map (p => get_params); end architecture; nvc-r1.17.1/test/elab/issue518.vhd000066400000000000000000000012321504111170000165100ustar00rootroot00000000000000package pack is type unsigned is array (natural range <>) of bit; end package; use work.pack.all; entity test2 is generic ( SLAVE_ADDR : bit_vector(6 downto 0) ); end entity test2; architecture beh of test2 is signal addr_reg : bit_vector(6 downto 0) := (others => '0'); begin addr_reg <= SLAVE_ADDR; end architecture beh; use work.pack.all; entity issue518 is generic ( GC_SLAVE_ADDR : unsigned(6 downto 0) := "0101010" ); end entity; architecture beh of issue518 is begin i_test : entity work.test2 generic map( SLAVE_ADDR => bit_vector(GC_SLAVE_ADDR) ); process begin wait; end process; end architecture; nvc-r1.17.1/test/elab/issue539.vhd000066400000000000000000000012001504111170000165060ustar00rootroot00000000000000package my_package is type my_type_t is record state : bit_vector; aux : bit_vector; end record my_type_t; type my_array_t is array (natural range <>) of my_type_t; end package my_package; ------------------------------------------------------------------------------- entity record38 is end entity; use work.my_package.all; architecture test of record38 is function init return my_array_t is begin return (0 => (state => "101", aux => "1"), 1 => (state => "1", aux => "1")); end function; signal s : my_array_t(0 to 0)(state(1 to 3), aux(1 to 1)) := init; begin end architecture; nvc-r1.17.1/test/elab/issue669.vhd000066400000000000000000000007561504111170000165310ustar00rootroot00000000000000entity d is generic (c : positive); port ( b : in bit ); end d; architecture beh of d is constant g : time := 1 ms / real(c); begin process begin wait until b = '1'; wait for -g; -- Error end process; end architecture; entity e is end e; architecture sim of e is signal a : bit; begin F : entity work.d(beh) generic map( c => 1 ) port map( b => a ); end architecture; nvc-r1.17.1/test/elab/issue707.vhd000066400000000000000000000012061504111170000165110ustar00rootroot00000000000000entity test_module is generic ( CONDITION : string := "true" ); port ( output : out bit_vector ); end entity test_module; architecture rtl of test_module is begin bad_cond : if CONDITION = "true" generate output <= X"12"; else generate output <= X"1234"; -- Should be no error here end generate; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is signal s : bit_vector(7 downto 0); begin u: entity work.test_module port map ( s ); end architecture; nvc-r1.17.1/test/elab/issue759.vhd000066400000000000000000000005001504111170000165140ustar00rootroot00000000000000package pkg is generic ( UNUSED: boolean ); function fun return boolean; end; package body pkg is function fun return boolean is begin return false; end; constant c: boolean := fun; end; entity test is end; architecture test of test is package p is new work.pkg generic map (UNUSED => false); begin end; nvc-r1.17.1/test/elab/issue855.vhd000066400000000000000000000011641504111170000165200ustar00rootroot00000000000000entity B is port ( clk : in bit; f : in bit ); end B; architecture rtl of B is begin end architecture; entity C is port ( clk : in bit; e : in bit ); end C; architecture rtl of C is signal f : bit; begin end architecture; entity issue855 is end issue855; architecture sim of issue855 is signal clk : bit; signal e : bit; begin G : entity work.C(rtl) port map ( clk => clk, e => e ); H : entity work.B(rtl) port map ( clk => clk, f => << signal G.f : bit >> ); end architecture; nvc-r1.17.1/test/elab/issue860.vhd000066400000000000000000000023331504111170000165130ustar00rootroot00000000000000package pack is type t_sbi_if is record addr : bit_vector; wdata : bit_vector; rdata : bit_vector; end record; end package; use work.pack.all; entity ethernet_th is generic( GC_SBI_ADDR_WIDTH : positive := 8; GC_SBI_DATA_WIDTH : positive := 8 ); end entity ethernet_th; architecture struct_sbi of ethernet_th is signal clk : bit; signal i1_sbi_if : t_sbi_if(addr(GC_SBI_ADDR_WIDTH - 1 downto 0), wdata(GC_SBI_DATA_WIDTH - 1 downto 0), rdata(GC_SBI_DATA_WIDTH - 1 downto 0)); begin end architecture struct_sbi; use work.pack.all; entity test is generic( GC_DATA_WIDTH : positive := 8); end entity; architecture tb of test is constant C_ADDR_WIDTH : positive := 8; alias clk is << signal .test.i_test_harness.clk : bit >>; -- Error alias i1_sbi_if is << signal .test.i_test_harness.i1_sbi_if : t_sbi_if(addr(C_ADDR_WIDTH - 1 downto 0), wdata(GC_DATA_WIDTH - 1 downto 0), rdata(GC_DATA_WIDTH - 1 downto 0)) >>; -- Error begin i_test_harness : entity work.ethernet_th(struct_sbi) generic map( GC_SBI_ADDR_WIDTH => C_ADDR_WIDTH, GC_SBI_DATA_WIDTH => GC_DATA_WIDTH ); p_main: process begin wait; end process p_main; end architecture; nvc-r1.17.1/test/elab/issue864.vhd000066400000000000000000000011521504111170000165150ustar00rootroot00000000000000entity issue864 is end entity ; architecture arch of issue864 is impure function from_file(fname : in string) return real is use std.textio.all ; file f : text ; variable s : file_open_status ; variable l : line ; variable r : real ; begin file_open(s, f, fname, READ_MODE) ; if s /= OPEN_OK then report "Could not open: " & fname severity failure ; end if ; readline(f, l) ; read(l, r) ; return r ; end function ; constant r : real := from_file("./nonexistent.txt") ; begin end architecture ; nvc-r1.17.1/test/elab/issue93.vhd000066400000000000000000000012441504111170000164310ustar00rootroot00000000000000entity t is generic( ORDER : integer := 8 ); port( clk : in bit; reset : in bit ); end entity t; architecture RTL of t is function calc_order(i:integer) return integer is begin if i mod 2 = 1 then return i/2+1; else return i/2; end if; end function; constant C_ORDER :integer:=calc_order(ORDER); type t_48 is array (C_ORDER-1 downto 0) of bit_vector(47 downto 0); signal a:t_48; constant zero48 : bit_vector(47 downto 0):=(others=>'0'); begin loop_gen: for i in 0 to C_ORDER-1 generate a(i)<=zero48; end generate; end architecture RTL; nvc-r1.17.1/test/elab/issue969.vhd000066400000000000000000000002561504111170000165270ustar00rootroot00000000000000entity mre_conversion is end entity mre_conversion; architecture arch of mre_conversion is begin mre_conversion_inst: entity work.mre_conversion; end architecture arch; nvc-r1.17.1/test/elab/jcore1.vhd000066400000000000000000000007171504111170000163140ustar00rootroot00000000000000entity sub is port ( x : in bit; y : out bit ); end entity; architecture test of sub is begin y <= x after 1 ns; end architecture; ------------------------------------------------------------------------------- entity jcore1 is end entity; architecture test of jcore1 is type rec is record a, b : bit; end record; signal s : rec; begin sub_i: entity work.sub port map ( s.a, s.b ); end architecture; nvc-r1.17.1/test/elab/jcore2.vhd000066400000000000000000000035211504111170000163110ustar00rootroot00000000000000entity bist_RF1 is generic ( WIDTH : natural range 1 to 32 ); port ( D : in bit_vector(WIDTH-1 downto 0)); begin end bist_RF1; architecture bist of bist_RF1 is begin end bist; configuration bist_rf1_inferred of bist_RF1 is for bist end for; end configuration; ------------------------------------------------------------------------------- entity gpsif_regfile is end gpsif_regfile; architecture beh of gpsif_regfile is component bist_RF1 generic ( WIDTH : natural range 1 to 32 ); port ( D : in bit_vector(WIDTH-1 downto 0) ); end component; signal x : bit_vector(19 downto 0); signal y : bit_vector(29 downto 0); begin sftca_bank : bist_RF1 generic map ( WIDTH => 20 ) port map (D => x); -- OK pnco_bank : bist_RF1 generic map ( WIDTH => 30 ) port map ( D => y); -- OK end beh; ------------------------------------------------------------------------------- entity gpsif is end gpsif; architecture beh of gpsif is component gpsif_regfile is end component; begin regfile : gpsif_regfile; end beh; ------------------------------------------------------------------------------- entity gpsif_top is end entity; architecture arch of gpsif_top is component gpsif is end component; begin g : gpsif; end architecture; ------------------------------------------------------------------------------- configuration gpsif_sim of gpsif is for beh for regfile : gpsif_regfile use entity work.gpsif_regfile(beh); for beh for all : bist_RF1 use configuration work.bist_rf1_inferred; end for; end for; end for; end for; end configuration; configuration gpsif_top_sim of gpsif_top is for arch for g : gpsif use configuration work.gpsif_sim; end for; end for; end configuration; nvc-r1.17.1/test/elab/libbind.vhd000066400000000000000000000007071504111170000165330ustar00rootroot00000000000000entity sub is port ( x : out integer ); end entity; architecture test of sub is begin x <= 4; end architecture; ------------------------------------------------------------------------------- entity top is end entity; library other; architecture test of top is component sub is port ( x : out integer ); end component; signal x : integer; begin sub_i: component sub port map ( x => x ); end architecture; nvc-r1.17.1/test/elab/libbind2.vhd000066400000000000000000000007071504111170000166150ustar00rootroot00000000000000entity sub is port ( x : out integer ); end entity; architecture test of sub is begin x <= 4; end architecture; ------------------------------------------------------------------------------- library other; entity top is end entity; architecture test of top is component sub is port ( x : out integer ); end component; signal x : integer; begin sub_i: component sub port map ( x => x ); end architecture; nvc-r1.17.1/test/elab/libbind3.vhd000066400000000000000000000007411504111170000166140ustar00rootroot00000000000000-- library foo package pack is end package; entity sub2 is end entity; architecture a of sub2 is begin end architecture; use work.pack.all; entity sub1 is end entity; architecture a of sub1 is component sub2 is end component; begin sub_i: component sub2; end architecture; -- library bar library foo; entity binding1 is end entity; architecture test of binding1 is component sub1 is end component; begin sub_i: component sub1; end architecture; nvc-r1.17.1/test/elab/link1.vhd000066400000000000000000000012011504111170000161340ustar00rootroot00000000000000package pack is constant k : integer := 1 / 0; -- Error function is_even (x : integer) return boolean; end package; package body pack is function is_even (x : integer) return boolean is begin return (x rem 2) = 0; end function; end package body; ------------------------------------------------------------------------------- entity link1 is end entity; use work.pack.all; architecture test of link1 is begin g: if is_even(4) generate begin p1: process is begin report "hello"; wait; end process; end generate; end architecture; nvc-r1.17.1/test/elab/mixed1.v000066400000000000000000000001541504111170000157770ustar00rootroot00000000000000module mod1(one, two, three); input one; input two; output three; parameter g1; endmodule // mixed1 nvc-r1.17.1/test/elab/mixed1.vhd000066400000000000000000000043301504111170000163130ustar00rootroot00000000000000entity mixed1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mixed1 is signal x, y, z : std_logic; begin b1: block is component mod1 is generic ( g1 : integer := 0 ); port ( one, two : in std_logic; three : out std_logic ); end component; begin u: component mod1 port map ( x, y, z ); -- OK end block; b2: block is component mod1 is generic ( g1 : integer := 0 ); port ( one : in std_logic; three : out std_logic ); end component; begin u: component mod1 port map ( x, z ); -- Error end block; b3: block is component mod1 is generic ( g1 : integer := 0 ); port ( one, two : in std_logic; three, four : out std_logic ); end component; begin u: component mod1 port map ( x, y, z, z ); -- Error end block; b4: block is component mod1 is generic ( g1 : integer := 0 ); port ( one, two : in std_logic; three : out bit ); end component; begin u: component mod1 port map ( x, y, open ); -- OK end block; b5: block is component mod1 is port ( one, two : in std_logic; three : out std_logic ); end component; begin u: component mod1 port map ( x, y, z ); -- Error end block; b6: block is component mod1 is generic ( g1 : std_logic ); port ( one, two : in std_logic; three : out std_logic ); end component; begin u: component mod1 generic map ( g1 => '1' ) port map ( x, y, z ); -- Error end block; b7: block is component mod1 is generic ( g1, g2 : integer ); port ( one, two : in std_logic; three : out std_logic ); end component; begin u: component mod1 generic map ( 5, 6 ) port map ( x, y, z ); -- Error end block; end architecture; nvc-r1.17.1/test/elab/neorv1.vhd000066400000000000000000000011101504111170000163270ustar00rootroot00000000000000entity fifo is generic ( n : positive ); port ( wdata : bit_vector(1 to n) ); end entity; architecture test of fifo is begin end architecture; ------------------------------------------------------------------------------- entity neorv1 is end entity; architecture test of neorv1 is signal x : bit; signal y : bit_vector(1 to 2); begin g: for i in 0 to 1 generate u: entity work.fifo generic map ( 3 ) port map ( wdata(1) => x, wdata(2 to 3) => y ); end generate; end architecture; nvc-r1.17.1/test/elab/null1.vhd000066400000000000000000000003251504111170000161570ustar00rootroot00000000000000entity null4 is generic (g : integer := -1); end entity; architecture test of null4 is subtype t_null_int is integer range 0 to g; signal x : t_null_int; -- Error begin end architecture; nvc-r1.17.1/test/elab/open.vhd000066400000000000000000000010361504111170000160650ustar00rootroot00000000000000entity open_bot is port ( i : in integer; o : out integer; v : out bit_vector(3 downto 0) := X"f" ); end entity; architecture test of open_bot is begin v(1) <= '0'; process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity open_top is end entity; architecture test of open_top is signal x : integer; begin uut: entity work.open_bot port map ( x, open ); end architecture; nvc-r1.17.1/test/elab/open2.vhd000066400000000000000000000016561504111170000161570ustar00rootroot00000000000000entity sub2 is generic ( WIDTH : integer ); port ( x : in bit_vector(WIDTH - 1 downto 0); y : out bit_vector(WIDTH - 1 downto 0) ); end entity; architecture test of sub2 is begin gen: for i in 0 to WIDTH - 1 generate y(i) <= not x(i); end generate; end architecture; ------------------------------------------------------------------------------- entity sub1 is port ( x : in bit; y : out bit ); end entity; architecture test of sub1 is begin sub2_i: entity work.sub2 generic map ( WIDTH => 1 ) port map ( x(0) => x, y(0) => y ); end architecture; ------------------------------------------------------------------------------- entity elab22 is end entity; architecture test of elab22 is signal a, b : bit; begin sub1_i: entity work.sub1 port map ( x => a ); end architecture; nvc-r1.17.1/test/elab/open3.vhd000066400000000000000000000007231504111170000161520ustar00rootroot00000000000000entity sub is port ( x : in bit_vector(1 downto 0); y : out bit_vector(1 downto 0) ); end entity; architecture test of sub is begin y <= x; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is begin sub_i: entity work.sub port map ( x(0) => '1', x(1) => '0', y => open ); end architecture; nvc-r1.17.1/test/elab/opencase.vhd000066400000000000000000000007111504111170000167200ustar00rootroot00000000000000entity sub is port ( x : in integer; y : out integer ); end entity; architecture test of sub is begin with x select y <= 5 when 1, 7 when 2, 99 when others; end architecture; ------------------------------------------------------------------------------- entity opencase is end entity; architecture test of opencase is signal x : integer; begin uut: entity work.sub port map (x); end architecture; nvc-r1.17.1/test/elab/openinout.vhd000066400000000000000000000022721504111170000171470ustar00rootroot00000000000000package p is function func(x : natural) return natural; end package; package body p is function func(x : natural) return natural is begin return x + 1; end function; end package body; ------------------------------------------------------------------------------- entity sub is port ( x : inout natural; x2 : inout integer := 5; y : out natural; y2 : out integer ); end entity; use work.p.all; architecture test of sub is begin y <= func(x); -- Crash here reading open inout port y2 <= func(x2); end architecture; ------------------------------------------------------------------------------- entity sub2 is port ( x : inout natural; y : out natural ); end entity; architecture test of sub2 is begin sub_i: entity work.sub port map ( x => x, y => y, y2 => open ); end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is signal y, y2, y3 : natural; begin uut: entity work.sub port map ( x => open, y => y, y2 => y2 ); uut2: entity work.sub2 port map ( y => y3 ); end architecture; nvc-r1.17.1/test/elab/record.vhd000066400000000000000000000012571504111170000164070ustar00rootroot00000000000000package pack is type rec is record a, b : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( x : in integer; y : out integer; r : in rec ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity elabr is end entity; use work.pack.all; architecture test of elabr is signal r1, r2 : rec; begin sub_i: entity work.sub port map ( x => r1.a, y => r1.b, r => r2 ); end architecture; nvc-r1.17.1/test/elab/signal34.vhd000066400000000000000000000024761504111170000165610ustar00rootroot00000000000000-- https://github.com/ghdl/ghdl/issues/2052 library ieee; use ieee.numeric_std.all; use ieee.std_logic_1164.all; entity signal34 is generic( width : integer := 8 ); end; architecture test of signal34 is subtype byte is std_logic_vector(width - 1 downto 0); type ram is array(integer range <>) of byte; type bank is array(integer range<>) of ram; signal mem : bank (2**16-1 downto 0) (2**16-1 downto 0); signal index : unsigned(32-1 downto 0) := (others => '0'); function read(memx : bank; indexx : unsigned) return byte is begin return memx (to_integer(indexx(31 downto 16))) (to_integer(indexx(15 downto 0))); end function; procedure write(signal memx : inout bank; indexx : unsigned; value : byte) is begin memx (to_integer(indexx(31 downto 16))) (to_integer(indexx(15 downto 0))) <= value; end procedure; signal clk,rst : std_logic := '1'; constant clk_period : time := 10 ns; begin clk <= not clk after clk_period/2; rst <= '1', '0' after clk_period*5; process (all) is begin if rising_edge(clk) then index <= index + "1"; write(mem, index, std_logic_vector(index(byte'range))); if index > "0" then report "Wrote to memory the value " & to_hstring(read(mem, index - "1")); end if; end if; end process; end; nvc-r1.17.1/test/elab/tc2881.vhd000066400000000000000000000043731504111170000160640ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2881.vhd,v 1.2 2001-10-26 16:29:50 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c02s01b00x00p07n01i02881ent IS function func2(constant flag:in integer) return integer; function func3(constant flag:in integer) return integer; function func2(constant flag:in integer) return integer is begin if (flag = 0) then return 0; else return ((func3(flag-1)) + 1); end if; end func2; function func3(constant flag:in integer) return integer is begin if (flag = 0) then return 0; else return ((func2(flag-1)) + 1); end if; end func3; END c02s01b00x00p07n01i02881ent; ARCHITECTURE c02s01b00x00p07n01i02881arch OF c02s01b00x00p07n01i02881ent IS BEGIN TESTING: PROCESS variable x:integer; BEGIN x:=99; assert (x=99) report "Initialization of integer variables incorrect" severity failure; x:= func2(3); assert NOT( x=3 ) report "***PASSED TEST: c02s01b00x00p07n01i02881" severity NOTE; assert ( x=3 ) report "***FAILED TEST: c02s01b00x00p07n01i02881 - Functions resursion call test incorrect (A-B-A type)." severity ERROR; wait; END PROCESS TESTING; END c02s01b00x00p07n01i02881arch; nvc-r1.17.1/test/elab/tc3138.vhd000066400000000000000000000032061504111170000160520ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3138.vhd,v 1.2 2001-10-26 16:29:52 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c05s02b02x00p02n01i03138ent IS END c05s02b02x00p02n01i03138ent; ARCHITECTURE c05s02b02x00p02n01i03138arch OF c05s02b02x00p02n01i03138ent IS component c05s02b02x00p02n01i03138ent_a end component; for comp1 : c05s02b02x00p02n01i03138ent_a use OPEN; BEGIN comp1 : c05s02b02x00p02n01i03138ent_a; TESTING: PROCESS BEGIN assert FALSE report "***PASSED TEST: c05s02b02x00p02n01i03138" severity NOTE; wait; END PROCESS TESTING; END c05s02b02x00p02n01i03138arch; nvc-r1.17.1/test/elab/tc846.vhd000066400000000000000000000045151504111170000160010ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc846.vhd,v 1.2 2001-10-26 16:30:00 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- entity and2g is end and2g; architecture behavior of and2g is signal x : bit; begin end behavior; architecture another of and2g is begin end another; entity full_adder is end full_adder; architecture structural of full_adder is component and2 end component; begin C1: and2; end structural; ENTITY c01s03b01x00p08n01i00846ent IS END c01s03b01x00p08n01i00846ent; ARCHITECTURE c01s03b01x00p08n01i00846arch OF c01s03b01x00p08n01i00846ent IS component adder end component; BEGIN A1 : adder; TESTING: PROCESS BEGIN assert FALSE report "***PASSED TEST: c01s03b01x00p08n01i00846" severity NOTE; wait; END PROCESS TESTING; END c01s03b01x00p08n01i00846arch; configuration c01s03b01x00p08n01i00846cfg of c01s03b01x00p08n01i00846ent is for c01s03b01x00p08n01i00846arch for A1: adder use -- component configuration entity work.full_adder(structural); for structural -- no_failure_here for C1: and2 use entity work.and2g(behavior); end for; end for; end for; end for; end c01s03b01x00p08n01i00846cfg; nvc-r1.17.1/test/elab/toplevel2.vhd000066400000000000000000000007541504111170000170460ustar00rootroot00000000000000entity toplevel2 is generic ( I : integer; S : string; B : bit; V : bit_vector ); end entity; architecture test of toplevel2 is signal x, y : integer; signal z : bit; begin g1: if I = 4 generate x <= 2; end generate; g2: if I > 10 generate x <= 6; end generate; g3: if S = "hello" generate y <= 1; end generate; g4: if V = "101" generate z <= B; end generate; end architecture; nvc-r1.17.1/test/elab/toplevel3.vhd000066400000000000000000000006651504111170000170500ustar00rootroot00000000000000package toplevel3_pack is type rec is record f : bit_vector; end record; subtype rec4 is rec(f(1 to 4)); end package; ------------------------------------------------------------------------------- use work.toplevel3_pack.all; entity toplevel3 is port ( r1 : inout rec4; -- OK r2 : inout rec ); -- Error end entity; architecture test of toplevel3 is begin end architecture; nvc-r1.17.1/test/elab/toplevel4.vhd000066400000000000000000000003261504111170000170430ustar00rootroot00000000000000entity toplevel4 is generic ( config : string; r : real; t : time ); end entity; architecture test of toplevel4 is begin assert config = "hello"; assert r = 2.5; assert t = 5 ms; end architecture; nvc-r1.17.1/test/elab/toplevel5.vhd000066400000000000000000000005611504111170000170450ustar00rootroot00000000000000entity issue926 is generic (g : integer; type t); end entity; architecture test of issue926 is function f (x : integer) return integer is begin return x; end function; begin b: block is generic (type t); generic map ( t => bit_vector(f(g) - 1 downto 0) ); -- Error begin end block; end architecture; nvc-r1.17.1/test/elab/view1.vhd000066400000000000000000000027101504111170000161570ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; b : bit_vector; end record; view in_view of rec_t is x : in; y : out; b : in; end view; alias out_view is in_view'converse; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view in_view of rec_t(b(1 to 2)); o : view out_view ); end entity; architecture test of sub is begin o.x <= i.x + 1; i.y <= o.y + 5; o.b <= not i.b; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity sub2 is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub2 is begin u: entity work.sub port map ( i, o ); end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view4 is end entity; architecture test of view4 is signal i, o : rec_t(b(1 to 3)); begin u: entity work.sub port map (i, o); check: process is begin assert i = (0, 0, "000"); assert o = (0, 0, "000"); wait for 0 ns; assert i = (0, 5, "000"); assert o = (1, 0, "111"); i.x <= 7; o.y <= 12; i.b <= "101"; wait for 1 ns; assert i = (7, 17, "101"); assert o = (8, 12, "010"); wait; end process; end architecture; nvc-r1.17.1/test/elab/vlog1.v000066400000000000000000000005121504111170000156360ustar00rootroot00000000000000module sub1(x, y); parameter p; input x; output y; endmodule // sub1 module vlog1; wire x, y; sub1 #(1) u1 (x, y); // OK SUB1 #(2) u2 (x, y); // Error sub1 #(3) u3 (x); // Error bad #(4) u4 (x); // Error sub1 u5 (x, y); // Error sub1 #(1, 2) u6 (x, y); // Error endmodule // vlog1 nvc-r1.17.1/test/eopt/000077500000000000000000000000001504111170000144655ustar00rootroot00000000000000nvc-r1.17.1/test/eopt/alias1.vhd000066400000000000000000000010241504111170000163370ustar00rootroot00000000000000-- Was test/regress/alias6.vhd entity alias1 is end entity; architecture test of alias1 is signal x : bit_vector(7 downto 0); alias x_top is x(7); alias x_low is x(3 downto 0); alias x_high is x(7 downto 4); begin process is begin x <= X"80"; wait for 1 ns; x <= X"04"; wait for 1 ns; x_top <= '1'; wait for 1 ns; x_high <= X"f"; wait for 1 ns; x_low <= X"b"; x_high <= X"1"; wait; end process; end architecture; nvc-r1.17.1/test/eopt/array3.vhd000066400000000000000000000010241504111170000163660ustar00rootroot00000000000000entity array3 is end entity; architecture test of array3 is type matrix2x4 is array (1 to 2, 1 to 4) of integer; signal m : matrix2x4; begin process is begin assert m(2, 2) = integer'left; m(2, 2) <= 5; wait for 1 ns; assert m(2, 2) = 5; m(2, 3) <= m(2, 2); wait for 1 ns; assert m(2, 3) = 5; m <= ( (1, 2, 3, 4), (5, 6, 7, 8) ); wait for 1 ns; assert m(2, 4) = 8; wait; end process; end architecture; nvc-r1.17.1/test/eopt/arrayref1.vhd000066400000000000000000000013521504111170000170650ustar00rootroot00000000000000entity arrayref is end entity; architecture test of arrayref is function resolved (x : bit_vector) return bit; subtype r_bit is resolved bit; type r_bit_vector is array (natural range <>) of r_bit; type bv2d is array (integer range <>) of r_bit_vector(1 downto 0); signal x : r_bit_vector(2 downto 0); -- 0..2 signal y : r_bit_vector(1 downto 0); -- 3..4 signal i : integer; -- 5..5 signal p : bv2d(0 to 1); -- 6..9 signal q : bv2d(0 to 2); -- 10..15 signal r : bv2d(0 to 2); -- 16..21 begin x(0) <= '1'; x(1) <= '0'; y(i) <= '1'; p(0)(i) <= '1'; p(1) <= "00"; q(i) <= "10"; r(2)(i) <= '1'; end architecture; nvc-r1.17.1/test/eopt/arrayref2.vhd000066400000000000000000000006541504111170000170720ustar00rootroot00000000000000entity arrayref2 is end entity; architecture test of arrayref2 is type i2d is array (integer range <>, integer range <>) of integer; type bv2d is array (integer range <>, integer range <>) of bit_vector(1 downto 0); signal x : i2d(0 to 2, 0 to 2); -- 0..8 signal y : bv2d(0 to 2, 0 to 2); -- 9..26 begin x(1, 1) <= 1; x(2, 1) <= 1; y(1, 1) <= "00"; y(2, 1) <= "11"; end architecture; nvc-r1.17.1/test/eopt/arrayref3.vhd000066400000000000000000000006011504111170000170630ustar00rootroot00000000000000entity arrayref3 is end entity; architecture test of arrayref3 is type ram_t is array (integer range <>) of bit_vector(3 downto 0); signal ram : ram_t(0 to 3); -- 0..15 signal addr : integer; -- 16 begin process (addr) is begin ram(addr)(1 downto 0) <= "11"; ram(addr)(3 downto 2) <= "00"; end process; end architecture; nvc-r1.17.1/test/eopt/arrayref4.vhd000066400000000000000000000011101504111170000170600ustar00rootroot00000000000000entity arrayref4 is end entity; architecture test of arrayref4 is signal sticky : bit; signal shiftedFracY_d1 : bit_vector(49 downto 0); begin update: sticky <= '0' when (shiftedFracY_d1(23 downto 0)=(23 downto 0 => '0')) else '1'; stim: process is begin wait for 1 ns; assert sticky = '1'; shiftedFracY_d1(19 downto 0) <= X"00000"; wait for 1 ns; assert sticky = '1'; shiftedFracY_d1(24 downto 20) <= "00000"; wait for 1 ns; assert sticky = '0'; wait; end process; end architecture; nvc-r1.17.1/test/eopt/buffer1.vhd000066400000000000000000000007411504111170000165240ustar00rootroot00000000000000package pack is function resolved (x : bit_vector) return bit; subtype rbit is resolved bit; end package; use work.pack.all; entity sub is port ( x : buffer rbit ); end entity; architecture test of sub is begin x <= '1'; x <= '0'; -- Error end architecture; entity buffer1 is end entity; use work.pack.all; architecture test of buffer1 is signal x : rbit; begin uut: entity work.sub port map ( x ); end architecture; nvc-r1.17.1/test/eopt/issue250.vhd000066400000000000000000000013111504111170000165430ustar00rootroot00000000000000entity field is end entity; architecture fum of field is constant cols: natural := 2; constant rows: natural := 2; type inter_cell is record alive_in: bit_vector (0 to 1); alive_out: bit; end record; type field_cell_signals is array (integer range <>, integer range <>) of inter_cell; signal cellio : field_cell_signals(0 to rows - 1, 0 to cols - 1); -- 0..11 signal row: integer range 0 to rows - 1 := 1; -- 12 signal col: integer range 0 to rows - 1 := 1; -- 13 begin cellio(col, row).alive_in <= cellio(col - 1, row - 1).alive_out & '0' when (col > 0 and row > 0) else "00"; end architecture; nvc-r1.17.1/test/eopt/issue371.vhd000066400000000000000000000034551504111170000165620ustar00rootroot00000000000000entity issue371 is end issue371; architecture behav of issue371 is signal clock : bit; signal chip_select_sig : bit; signal address_sig : bit_vector(2 downto 0); signal write_sig : bit; signal host_data_bus_sig : bit_vector(7 downto 0); function rising_edge(signal x : bit) return boolean is begin return x = '1' and x'last_value = '0'; end function; procedure wait_for_ticks (num_clock_cycles : in integer) is begin for i in 1 to num_clock_cycles loop wait until rising_edge(clock); end loop; end procedure wait_for_ticks; procedure host_write (addr: in bit_vector; byte : in bit_vector; signal clock : in bit; signal chip_select : out bit; signal address : out bit_vector; signal write : out bit; signal host_data_bus : out bit_vector; invert_cs_etc : in bit ) is begin wait until rising_edge(clock); write <= '1' xor invert_cs_etc; chip_select <= '1' xor invert_cs_etc; address <= addr; host_data_bus <= byte; wait_for_ticks(1); write <= '0' xor invert_cs_etc; chip_select <= '0' xor invert_cs_etc; for i in address'LOW to address'HIGH loop address(i) <= '0'; end loop; for i in host_data_bus'LOW to host_data_bus'HIGH loop host_data_bus(i) <= '0'; end loop; wait until rising_edge(clock); end procedure host_write; begin process begin for i in 0 to 10 loop clock <= '0'; wait for 1 us; clock <= '1'; wait for 1 us; end loop; wait; end process; process begin host_write("001", X"aa", clock, chip_select_sig, address_sig, write_sig, host_data_bus_sig, '0'); for i in address_sig'LOW to address_sig'HIGH loop assert address_sig(i) = '0'; end loop; for i in host_data_bus_sig'LOW to host_data_bus_sig'HIGH loop assert host_data_bus_sig(i) = '0'; end loop; wait; end process; end behav; nvc-r1.17.1/test/eopt/issue427.vhd000066400000000000000000000053301504111170000165560ustar00rootroot00000000000000package SYNC is type std_ulogic is ('0', '1', 'Z', 'H', 'U'); type std_ulogic_vector is array (natural range <>) of std_ulogic; function resolved (x : in std_ulogic_vector) return std_ulogic; subtype std_logic is resolved std_ulogic; type std_logic_vector is array (natural range <>) of std_logic; constant SYNC_MAX_PLUG_SIZE : integer := 32; subtype SYNC_PLUG_NUM_TYPE is integer range 1 to SYNC_MAX_PLUG_SIZE; alias SYNC_SIG_TYPE is std_logic; subtype SYNC_REQ_TYPE is integer; subtype SYNC_ACK_TYPE is std_logic; type SYNC_REQ_VECTOR is array (INTEGER range <>) of SYNC_REQ_TYPE; type SYNC_ACK_VECTOR is array (INTEGER range <>) of SYNC_ACK_TYPE; component SYNC_SIG_DRIVER generic ( PLUG_NUM : SYNC_PLUG_NUM_TYPE := 1 ); port ( SYNC : inout SYNC_SIG_TYPE; REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end component; end package; package body sync is function resolved (x : in std_ulogic_vector) return std_ulogic is begin return x(x'left); end function; end package body; library WORK; use WORK.SYNC.all; entity SYNC_SIG_DRIVER is generic ( PLUG_NUM : SYNC_PLUG_NUM_TYPE := 1 ); port ( SYNC : inout SYNC_SIG_TYPE; REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end SYNC_SIG_DRIVER; architecture MODEL of SYNC_SIG_DRIVER is begin process begin SYNC <= 'Z'; ACK <= '0'; SYNC_LOOP: loop if (REQ > 0) then SYNC <= 'H'; wait until (SYNC = '1' or SYNC = '0'); SYNC <= '0'; ACK <= '1'; wait until (REQ = 0); ACK <= '0'; elsif (REQ = 0) then SYNC <= '0'; else SYNC <= 'Z'; end if; wait on REQ; end loop; end process; end MODEL; library WORK; use WORK.SYNC.all; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is constant PLUG_SIZE : integer := 2; signal SYNC : SYNC_SIG_TYPE; signal REQ : SYNC_REQ_VECTOR(1 to PLUG_SIZE); signal ACK : SYNC_ACK_VECTOR(1 to PLUG_SIZE); begin PLUG : for i in 1 to PLUG_SIZE generate DRIVER : SYNC_SIG_DRIVER generic map (PLUG_NUM => i) port map (SYNC => SYNC,REQ => REQ(i),ACK => ACK(i)); end generate; process begin REQ(1) <= 0; wait; end process; process begin REQ(2) <= 0; wait; end process; end MODEL; nvc-r1.17.1/test/eopt/issue72.vhd000066400000000000000000000010471504111170000164730ustar00rootroot00000000000000package pack1 is type ma_t is array(1 downto 0) of bit_vector(1 downto 0); end pack1; use work.pack1.all; entity arraysub is generic(par1: bit_vector(3 downto 0) := "1111"); end entity; architecture test of arraysub is signal s1, s2: ma_t; begin s1(1)<=par1(1 downto 0); s1(0)<=par1(3 downto 2); s2(1 downto 1) <= ( 1 => par1(3 downto 2) ); s2(0 downto 0) <= ( 0 => par1(1 downto 0) ); process is begin wait for 1 ns; assert s1 = ( "11", "11" ); wait; end process; end architecture; nvc-r1.17.1/test/eopt/issue73.vhd000066400000000000000000000010341504111170000164700ustar00rootroot00000000000000entity issue73 is end entity; architecture test of issue73 is type ma_t is array (1 downto 0) of bit_vector(3 downto 0); signal x : ma_t; -- 0..7 signal y : ma_t; -- 8..15 begin x(0)(1 downto 0) <= "00"; x(0)(3 downto 2) <= "11"; x(1)(0 downto 0) <= "0"; x(1)(3 downto 1) <= "101"; process (y) is begin for i in x'range loop y(i)(1 downto 0) <= "00"; y(i)(3 downto 2) <= "11"; end loop; end process; end architecture; nvc-r1.17.1/test/eopt/issue95.vhd000066400000000000000000000004411504111170000164750ustar00rootroot00000000000000entity issue95 is end entity; architecture behav of issue95 is type point is record x : integer; z : boolean; end record point; type point_array is array(0 to 2) of point; signal points : point_array := (others => (x => 1, z => true)); begin end behav; nvc-r1.17.1/test/eopt/jcore2.vhd000066400000000000000000000007361504111170000163620ustar00rootroot00000000000000entity jcore2 is end entity; architecture test of jcore2 is constant bits_exp : natural := 5; constant bits : natural := 2**bits_exp; type bus_val_t is record en : bit; d : bit_vector(bits-1 downto 0); end record; type ybus_val_pipeline_t is array (2 downto 0) of bus_val_t; type datapath_reg_t is record pc : bit_vector(bits-1 downto 0); ybus_override : ybus_val_pipeline_t; end record; signal this_c : datapath_reg_t; begin end architecture; nvc-r1.17.1/test/eopt/jcore4.vhd000066400000000000000000000003471504111170000163620ustar00rootroot00000000000000entity jcore4 is end entity; architecture test of jcore4 is type rt is record x : bit_vector(1 to 3); end record; type at is array (integer range <>) of rt; signal a : at(1 to 3); begin end architecture; nvc-r1.17.1/test/eopt/map1.vhd000066400000000000000000000015131504111170000160260ustar00rootroot00000000000000entity sub is port ( i : in bit_vector(7 downto 0); o : out bit_vector(7 downto 0) ); end entity; architecture test of sub is begin o <= not i after 1 ns; end architecture; ------------------------------------------------------------------------------- entity map1 is end entity; architecture test of map1 is signal a : bit_vector(1 downto 0); signal b : bit_vector(5 downto 0); signal c : bit_vector(5 downto 2); signal d : bit_vector(3 downto 0); begin sub1_i: entity work.sub port map ( i(1 downto 0) => a, i(7 downto 2) => b, o(3 downto 0) => c, o(7 downto 4) => d ); sub2_i: entity work.sub port map ( i(1 downto 0) => a, i(7 downto 2) => "000000", o => open ); end architecture; nvc-r1.17.1/test/eopt/map2.vhd000066400000000000000000000012441504111170000160300ustar00rootroot00000000000000entity sub is port ( i : in bit_vector(0 to 7); o : out bit_vector(0 to 7) ); end entity; architecture test of sub is begin o <= not i after 1 ns; end architecture; ------------------------------------------------------------------------------- entity map2 is end entity; architecture test of map2 is signal a : bit_vector(0 to 1); signal b : bit_vector(0 to 5); signal c : bit_vector(2 to 5); signal d : bit_vector(0 to 3); begin sub1_i: entity work.sub port map ( i(7) => '1', i(0 to 1) => a, i(2) => '0', i(3 to 6) => c, o => open ); end architecture; nvc-r1.17.1/test/eopt/nonconst1.vhd000066400000000000000000000006151504111170000171140ustar00rootroot00000000000000entity nonconst1 is end entity; architecture test of nonconst1 is type int_vec is array (natural range <>) of integer; signal s, t : int_vec(8 downto 0); begin process is variable k : integer; begin k := 9; wait for 1 ns; s(k downto 1) <= (others => 1); t(8 downto k) <= (others => 1); wait; end process; end architecture; nvc-r1.17.1/test/eopt/partial1.vhd000066400000000000000000000015631504111170000167120ustar00rootroot00000000000000entity sub is port ( result : out bit_vector(3 downto 0); in1 : in bit_vector(3 downto 0) ); end entity; architecture test of sub is signal in2 : bit_vector(2 downto 0); begin assert in1(1 downto 0) = "00"; in2 <= "001"; result <= '0' & bit_vector(in1 and in2); end architecture; ------------------------------------------------------------------------------- entity partial1 is end entity; architecture test of partial1 is signal result : bit_vector(3 downto 0); signal in1 : bit_vector(1 downto 0); begin uut: entity work.sub port map ( result => result, in1(3 downto 2) => bit_vector(in1), in1(1 downto 0) => "00" ); stim: process is begin in1 <= "01"; wait for 1 ns; assert result = X"5"; wait; end process; end architecture; nvc-r1.17.1/test/eopt/pcall1.vhd000066400000000000000000000014271504111170000163500ustar00rootroot00000000000000entity pcall1 is end entity; architecture behav of pcall1 is type point is record x : integer; y : integer; z : boolean; end record point; type point_array is array (natural range <>) of point; signal points : point_array(1 to 4) := (others => (x => 1, y => 1, z => true)); procedure update(signal pa : out point_array) is begin pa(3).x <= 7; end procedure; begin p1: process begin assert points(3).x = 1; points(2).y <= 4; wait for 2 ns; update(points); wait; end process; p2: process is begin wait for 1 ns; assert points(2) = (1, 4, true); wait for 2 ns; assert points(3) = (7, 1, true); wait; end process; end behav; nvc-r1.17.1/test/eopt/pcall2.vhd000066400000000000000000000015021504111170000163430ustar00rootroot00000000000000entity pcall2 is end entity; architecture test of pcall2 is signal x, y, z, s : bit_vector(1 to 3); procedure proc2(signal x : out bit_vector) is begin x <= "00"; end procedure; begin p1: process is procedure proc1 is begin x(3) <= '1'; end procedure; begin proc1; wait; end process; p2: process is begin proc2(y(1 to 2)); wait; end process; p3: process is procedure proc3(x : in integer) is begin z(x) <= '1'; end procedure; begin proc3(2); end process; p4: process is procedure proc4(signal ss : out bit_vector) is begin ss(1) <= '1'; end procedure; begin proc4(s); end process; end architecture; nvc-r1.17.1/test/eopt/ram1.vhd000066400000000000000000000007721504111170000160360ustar00rootroot00000000000000entity ram1 is end entity; architecture test of ram1 is type byte_array_t is array (natural range <>) of bit_vector(7 downto 0); signal ram : byte_array_t(15 downto 0); signal addr : integer; signal dout : bit_vector(7 downto 0); signal din : bit_vector(7 downto 0); signal we : bit; begin dout_p: dout <= ram(addr); wr_p: process (we, din, addr) is begin if we = '1' then ram(addr) <= din; end if; end process; end architecture; nvc-r1.17.1/test/eopt/recref1.vhd000066400000000000000000000005451504111170000165230ustar00rootroot00000000000000entity recref1 is end entity; architecture test of recref1 is type rec is record x : bit_vector(1 to 3); y : integer; end record; signal s : rec; -- 0..3 signal t : rec; -- 4..7 signal u : rec; -- 8..11 begin s.x <= "101"; s.y <= 4; end architecture; nvc-r1.17.1/test/eopt/recref2.vhd000066400000000000000000000006101504111170000165150ustar00rootroot00000000000000entity recref2 is end entity; architecture test of recref2 is type rec1 is record x, y : bit_vector(1 to 2); end record; type rec2 is record a, b : rec1; end record; type rec3 is record x : integer; end record; type rec4 is record a, b : rec3; end record; signal r : rec2; signal s : rec4; begin end architecture; nvc-r1.17.1/test/eopt/slice1.vhd000066400000000000000000000010361504111170000163500ustar00rootroot00000000000000entity slice1 is end entity; architecture test of slice1 is function resolved (x : bit_vector) return bit; subtype r_bit is resolved bit; type r_bit_vector is array (natural range <>) of r_bit; signal x : r_bit_vector(0 to 7); signal y : r_bit_vector(7 downto 0); begin x(0 to 3) <= "1111"; x(4 to 2) <= (others => '0'); x(4 to 5) <= "00"; x(5 to 7) <= "111"; y(3 downto 0) <= "1111"; y(2 downto 4) <= (others => '0'); y(5 downto 4) <= "00"; y(7 downto 5) <= "111"; end architecture; nvc-r1.17.1/test/eopt/slice2.vhd000066400000000000000000000015261504111170000163550ustar00rootroot00000000000000entity slice2 is end entity; architecture test of slice2 is procedure set_it(signal v : out bit_vector(7 downto 0); x, y : in integer; k : in bit_vector) is begin v(x downto y) <= k; end procedure; procedure set_it2(signal v : out bit_vector; x, y : in integer; k : in bit_vector) is begin v(x downto y) <= k; end procedure; signal vec : bit_vector(7 downto 0); begin process is begin set_it(vec, 3, 0, X"a"); wait for 1 ns; assert vec = X"0a"; set_it(vec, 4, 1, X"f"); wait for 1 ns; assert vec = X"1e"; set_it2(vec, 7, 4, X"f"); wait for 1 ns; assert vec = X"fe"; wait; end process; end architecture; nvc-r1.17.1/test/eopt/source1.vhd000066400000000000000000000011401504111170000165450ustar00rootroot00000000000000entity sub is port ( i : in bit; o : out bit ); end entity; architecture test of sub is begin o <= i; end architecture; ------------------------------------------------------------------------------- entity source1 is end entity; architecture test of source1 is signal x : bit; signal y : bit_vector(1 to 5); begin x <= '1'; foo: x <= '0'; -- Error y <= "10000"; y(2 to 3) <= "11"; -- Error sub1_i: entity work.sub port map ( x, y(4) ); sub2_i: entity work.sub port map ( x, y(2) ); end architecture; nvc-r1.17.1/test/expect.vhd000066400000000000000000000043711504111170000155160ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity memory is generic ( WIDTH : integer ); port ( clk : in std_logic; addr : in unsigned(7 downto 0); din : in std_logic_vector(WIDTH - 1 downto 0); dout : out std_logic_vector(WIDTH - 1 downto 0); we : in std_logic ); end entity; architecture rtl of memory is type ram_t is array (0 to 255) of std_logic_vector(WIDTH - 1 downto 0); signal addr_r : unsigned(7 downto 0) := X"00"; signal ram : ram_t; begin reg: process (clk) is begin if rising_edge(clk) then addr_r <= addr; if we = '1' then ram(to_integer(addr)) <= din; end if; end if; end process; dout <= ram(to_integer(addr_r)); end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity top is end entity; architecture test of top is constant ITERS : integer := 1; constant WIDTH : integer := 8; signal clk : std_logic := '0'; signal addr : unsigned(7 downto 0) := X"00"; signal din : std_logic_vector(WIDTH - 1 downto 0); signal dout : std_logic_vector(WIDTH - 1 downto 0); signal we : std_logic := '0'; signal running : boolean := true; begin clk <= not clk after 5 ns when running else '0'; uut: entity work.memory generic map ( WIDTH => WIDTH ) port map ( clk => clk, addr => addr, din => din, dout => dout, we => we ); stim: process is begin for j in 1 to ITERS loop wait for 20 ns; we <= '1'; for i in 0 to 255 loop addr <= to_unsigned(i, 8); din <= std_logic_vector(to_unsigned((i + j) mod 256, WIDTH)); wait for 10 ns; end loop; we <= '0'; for i in 0 to 255 loop addr <= to_unsigned(i, 8); wait for 10 ns; assert dout = std_logic_vector(to_unsigned((i + j) mod 256, WIDTH)); end loop; end loop; end process; end architecture; nvc-r1.17.1/test/fstdump.c000066400000000000000000000143321504111170000153470ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // // Based on GtkWave fstminer.c // /* * Copyright (c) 2012-2014 Tony Bybell. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include #include #include "fstapi.h" static char **fac_names = NULL; static unsigned int *scope_idx = NULL; static char **scope_names = NULL; long allocated_scopes = 1; FILE *outf; static void extractVarNames(void *xc) { struct fstHier *h; char *s; const char *fst_scope_name = NULL; int fst_scope_name_len = 0; intptr_t snum = 0; intptr_t max_snum = 0; while ((h = fstReaderIterateHier(xc))) { switch(h->htyp) { case FST_HT_SCOPE: snum = ++max_snum; fst_scope_name = fstReaderPushScope(xc, h->u.scope.name, (void *)(snum)); /* fst_scope_name_len = fstReaderGetCurrentScopeLen(xc); scan-build */ if (snum >= allocated_scopes) { long new_allocated_scopes = allocated_scopes * 2; char **scope_names_2 = calloc(new_allocated_scopes, sizeof(char *)); memcpy(scope_names_2, scope_names, allocated_scopes * sizeof(char *)); free(scope_names); scope_names = scope_names_2; allocated_scopes = new_allocated_scopes; } scope_names[snum] = strdup(fst_scope_name); break; case FST_HT_UPSCOPE: /* fst_scope_name = scan-build */ fstReaderPopScope(xc); fst_scope_name_len = fstReaderGetCurrentScopeLen(xc); snum = fst_scope_name_len ? (intptr_t)fstReaderGetCurrentScopeUserInfo(xc) : 0; break; case FST_HT_VAR: if (!h->u.var.is_alias) { scope_idx[h->u.var.handle] = snum; s = fac_names[h->u.var.handle] = malloc(h->u.var.name_length + 1); memcpy(s, h->u.var.name, h->u.var.name_length); s[h->u.var.name_length] = '\0'; } else fprintf(outf, "$comment %s.%.*s is aliased to %s $end\n", scope_names[snum], h->u.var.name_length, h->u.var.name, fac_names[h->u.var.handle]); } } } static char *get_facname(void *ctx, fstHandle pnt_facidx) { if (scope_idx[pnt_facidx] && scope_names[scope_idx[pnt_facidx]]) { char *fst_scope_name = scope_names[scope_idx[pnt_facidx]]; int fst_scope_name_len = strlen(fst_scope_name); int fst_signal_name = strlen(fac_names[pnt_facidx]); char *s = malloc(fst_scope_name_len + 1 + fst_signal_name + 1); memcpy(s, fst_scope_name, fst_scope_name_len); s[fst_scope_name_len] = '.'; memcpy(s + fst_scope_name_len + 1, fac_names[pnt_facidx], fst_signal_name + 1); return s; } else return strdup(fac_names[pnt_facidx]); } static void fst_callback2(void *ctx, uint64_t pnt_time, fstHandle pnt_facidx, const unsigned char *pnt_value, uint32_t plen) { char *fn; fn = get_facname(ctx, pnt_facidx); fprintf(outf, "#%"PRIu64" %s %.*s\n", pnt_time, fn, plen, pnt_value); } static void fst_callback(void *ctx, uint64_t pnt_time, fstHandle pnt_facidx, const unsigned char *pnt_value) { uint32_t plen = 0; if (pnt_value) plen = strlen((const char *)pnt_value); fst_callback2(ctx, pnt_time, pnt_facidx, pnt_value, plen); } int main(int argc, char **argv) { int c; opterr = 0; outf = stdout; while ((c = getopt (argc, argv, "o:")) != -1) { switch (c) { case 'o': if ((outf = fopen(optarg, "w")) == NULL) { fprintf(stderr, "failed to open %s\n", optarg); return 1; } break; case '?': if (optopt == 'o') fprintf(stderr, "option -%c requires an argument\n", optopt); else if (isprint (optopt)) fprintf(stderr, "unknown option `-%c'\n", optopt); else fprintf(stderr, "unknown option character `\\x%x'\n", optopt); return 1; default: abort (); } } if (optind != argc - 1) { fprintf(stderr, "usage: fstdump [-o OUT] FILE\n"); return 1; } void *ctx = fstReaderOpen(argv[optind]); if (ctx == NULL) { fprintf(stderr, "failed to open %s\n", argv[optind]); return 1; } int numfacs = fstReaderGetVarCount(ctx) + 1; fac_names = calloc(numfacs, sizeof(char *)); scope_names = calloc(allocated_scopes, sizeof(char *)); scope_idx = calloc(numfacs, sizeof(unsigned int)); extractVarNames(ctx); fstReaderSetFacProcessMaskAll(ctx); fstReaderIterBlocks2(ctx, fst_callback, fst_callback2, ctx, NULL); fstReaderClose(ctx); return 0; } nvc-r1.17.1/test/ghdl.sh000077500000000000000000000004051504111170000147720ustar00rootroot00000000000000#!/bin/sh -ex std=${STD:-08} mkdir -p .ghdl ghdl -a -fpsl -frelaxed -fsynopsys --std=$std --workdir=.ghdl ../test/regress/$1.vhd ghdl -e -fpsl -frelaxed -fsynopsys --std=$std --workdir=.ghdl -o .ghdl/$1 $1 ghdl -r -fpsl -fsynopsys --std=$std --workdir=.ghdl $1 nvc-r1.17.1/test/ident_perf.c000066400000000000000000000007171504111170000160060ustar00rootroot00000000000000#include "ident.h" #include #include #include int main(int argc, char **argv) { for (int i = 0; i < 10000000; i++) { char buf[16]; size_t len = (random() % (sizeof(buf) - 3)) + 2; for (size_t j = 0; j < len; j++) buf[j] = '0' + (random() % 80); buf[len - 1] = '\0'; ident_t i1 = ident_new(buf); assert(i1 != NULL); assert(strcmp(istr(i1), buf) == 0); } return 0; } nvc-r1.17.1/test/issue746.sh000077500000000000000000000003041504111170000154430ustar00rootroot00000000000000set -e pwd which nvc for i in $(seq 100); do rm -rf testlib nvc --work=testlib --init & nvc --work=testlib --init & nvc --work=testlib --init & nvc --work=testlib --init & wait done nvc-r1.17.1/test/iverilog.sh000077500000000000000000000002001504111170000156650ustar00rootroot00000000000000#!/bin/bash -e root=$(git rev-parse --show-toplevel) regress=$root/test/regress iverilog -o /tmp/$1 $regress/$1.v vvp /tmp/$1 nvc-r1.17.1/test/jit/000077500000000000000000000000001504111170000143045ustar00rootroot00000000000000nvc-r1.17.1/test/jit/access1.vhd000066400000000000000000000023101504111170000163250ustar00rootroot00000000000000package access1 is type int_ptr is access integer; procedure deref (variable p : int_ptr; result : out integer); procedure test1 (variable p : inout int_ptr); procedure oom; procedure gc_a_lot; end package; package body access1 is procedure deref (variable p : int_ptr; result : out integer) is begin result := p.all; end procedure; procedure test1 (variable p : inout int_ptr) is variable i : integer; begin p := new integer; p.all := 5; deref(p, i); assert i = 5; deallocate(p); end procedure; type biglist; type biglist_ptr is access biglist; type biglist is record str : string(1 to 2 ** 10); chain : biglist_ptr; end record; procedure oom is variable head, tail : biglist_ptr; begin head := new biglist; tail := head; while true loop tail.chain := new biglist; tail := tail.chain; end loop; end procedure; procedure gc_a_lot is variable tail : biglist_ptr; begin for i in 1 to 5000 loop tail := new biglist; end loop; end procedure; end package body; nvc-r1.17.1/test/jit/add1.vhd000066400000000000000000000004671504111170000156270ustar00rootroot00000000000000package pack is function add1(x : integer) return integer; end package; package body pack is function add1(x : integer) return integer is begin return x + 1; end function; function add1(x : real) return real is begin return x + 1.0; end function; end package body; nvc-r1.17.1/test/jit/arith1.vhd000066400000000000000000000034741504111170000162070ustar00rootroot00000000000000package arith1 is function div(x, y : integer) return integer; function div(x, y : real) return real; function div(x : integer; y : real) return real; function exp(x : real; y : integer) return real; function exp(x, y : integer) return integer; function neg(x : integer) return integer; function neg(x : real) return real; function cast(x : real) return integer; function abz(x : integer) return integer; function abz(x : real) return real; function modd(x, y : integer) return integer; function remm(x, y : integer) return integer; end package; package body arith1 is function div(x, y : integer) return integer is begin return x / y; end function; function div(x, y : real) return real is begin return x / y; end function; function div(x : integer; y : real) return real is begin return real(x) / y; end function; function exp(x : real; y : integer) return real is begin return x ** y; end function; function exp(x, y : integer) return integer is begin return x ** y; end function; function neg(x : integer) return integer is begin return -x; end function; function neg(x : real) return real is begin return -x; end function; function cast(x : real) return integer is begin return integer(x); end function; function abz(x : integer) return integer is begin return abs x; end function; function abz(x : real) return real is begin return abs x; end function; function modd(x, y : integer) return integer is begin return x mod y; end function; function remm(x, y : integer) return integer is begin return x rem y; end function; end package body; nvc-r1.17.1/test/jit/array1.vhd000066400000000000000000000022611504111170000162070ustar00rootroot00000000000000package array1 is type iv is array (natural range <>) of integer; procedure assign (a : out iv; b : in iv); function get_ints (n, start : integer) return iv; function issue94 (dataw : integer; shiftw : integer) return bit_vector; procedure test2 (value : string); end package; package body array1 is procedure assign (a : out iv; b : in iv) is begin a := b; end procedure; function get_ints (n, start : integer) return iv is variable v : iv(1 to n); begin for i in 1 to n loop v(i) := start + i - 1; end loop; return v; end function; function issue94 (dataw : integer; shiftw : integer) return bit_vector is constant max_shift : integer := shiftw; type bit_vector_array is array (natural range <>) of bit_vector(dataw-1 downto 0); variable y_temp : bit_vector_array (0 to max_shift); begin y_temp(0):=(others=>'1'); y_temp(1):=(others => '0'); return y_temp(0); end function; procedure test2 (value : string) is variable x : string(1 to value'length) := value; begin report x; end procedure; end package body; nvc-r1.17.1/test/jit/assert1.vhd000066400000000000000000000006601504111170000163730ustar00rootroot00000000000000package assert1 is procedure do_report; procedure do_assert(x : integer); end package; package body assert1 is procedure do_report is begin report "hello world"; end procedure; procedure do_assert(x : integer) is begin assert x >= 0 report integer'image(x) & " negative" severity warning; assert x < 100 report "too big" severity failure; end procedure; end package body; nvc-r1.17.1/test/jit/case1.vhd000066400000000000000000000023311504111170000160020ustar00rootroot00000000000000package case1 is type t is (a, b, c); function test1(x : t) return integer; function test2(x : bit_vector(1 to 4)) return integer; end package; package body case1 is function test1(x : t) return integer is begin case x is when a => return 10; when b => return 20; when c => return 30; end case; end function; function test2(x : bit_vector(1 to 4)) return integer is variable result : integer := 0; begin case x is when "0000" => result := 0; when "0001" => result := 1; when "0010" => result := 2; when "0011" => result := 3; when "0100" => result := 4; when "0101" => result := 5; when "0110" => result := 6; when "0111" => result := 7; when "1000" => result := 8; when "1001" => result := 9; when "1010" => result := 10; when "1011" => result := 11; when "1100" => result := 12; when "1101" => result := 13; when "1110" => result := 14; when "1111" => result := 15; end case; return result; end function; end package body; nvc-r1.17.1/test/jit/context1.vhd000066400000000000000000000017301504111170000165550ustar00rootroot00000000000000package pack is function get_elt(index : natural) return integer; function nested_get_elt(index : natural) return integer; procedure read_elt(index : natural; result : out integer); end package; package body pack is type int_vector is array (natural range <>) of integer; constant arr : int_vector(1 to 5) := (10, 20, 30, 40, 50); constant c1 : integer := 40 + 2; function get_elt(index : natural) return integer is begin return arr(index); end function; function nested_get_elt(index : natural) return integer is function inner return integer is begin return arr(index); end function; begin return inner; end function; procedure read_elt(index : natural; result : out integer) is begin if index > 100 then wait for 1 ns; -- Forces heap allocation end if; result := get_elt(index); end procedure; end package body; nvc-r1.17.1/test/jit/fact.vhd000066400000000000000000000010061504111170000157210ustar00rootroot00000000000000package pack is function fact(x : integer) return integer; end package; package body pack is function fact(x : integer) return integer is variable r : integer := 1; begin for i in 1 to x loop r := r * i; end loop; return r; end function; function fact_recur(x : integer) return integer is begin if x <= 1 then return 1; else return x * fact_recur(x - 1); end if; end function; end package body; nvc-r1.17.1/test/jit/ieeewarn.vhd000066400000000000000000000007531504111170000166130ustar00rootroot00000000000000package ieeewarn is constant enabled : boolean; end package; library nvc; use nvc.sim_pkg.all; package body ieeewarn is constant enabled : boolean := not ieee_no_warning; -- Should not be folded end package body; ------------------------------------------------------------------------------- entity ieeewarn_e is end entity; use work.ieeewarn; architecture a of ieeewarn_e is constant e : boolean := ieeewarn.enabled; -- Also shouldn't be folded begin end architecture; nvc-r1.17.1/test/jit/issue496.vhd000066400000000000000000000004331504111170000164020ustar00rootroot00000000000000package genpack is generic ( type t; n : t ); constant k : t := n; end package; package issue496 is constant one : string := "one"; package gen_one is new work.genpack generic map ( t => string, n => one ); constant c : string(1 to 3) := gen_one.k; end package; nvc-r1.17.1/test/jit/issue575.vhd000066400000000000000000000005031504111170000163760ustar00rootroot00000000000000package issue575 is type rec is record x : integer; y : bit_vector(1 to 3); end record; procedure test (x : out rec; val : bit); end package; package body issue575 is procedure test (x : out rec; val : bit) is begin x.y := (others => val); end procedure; end package body; nvc-r1.17.1/test/jit/layout.vhd000066400000000000000000000007161504111170000163300ustar00rootroot00000000000000package layout is type r1 is record x : integer; y : boolean; z : real; end record; type r2 is record x : r1; y : integer; end record; subtype a is string(1 to 5); type t_byte is array (1 to 8) of bit; type t_byte_vector is array (natural range <>) of t_byte; constant c1 : t_byte_vector(1 to 3) := (others => X"00"); type t_array is array (natural range <>) of r2; end package; nvc-r1.17.1/test/jit/overflow.vhd000066400000000000000000000024361504111170000166570ustar00rootroot00000000000000package overflow is function add(x, y : integer) return integer; function sub(x, y : integer) return integer; function mul(x, y : integer) return integer; function exp(x, y : integer) return integer; type uint8 is range 0 to 255; function add(x, y : uint8) return uint8; function sub(x, y : uint8) return uint8; function mul(x, y : uint8) return uint8; function exp(x : uint8; y : integer) return uint8; end package; package body overflow is function add(x, y : integer) return integer is begin return x + y; end function; function sub(x, y : integer) return integer is begin return x - y; end function; function mul(x, y : integer) return integer is begin return x * y; end function; function exp(x, y : integer) return integer is begin return x ** y; end function; function add(x, y : uint8) return uint8 is begin return x + y; end function; function sub(x, y : uint8) return uint8 is begin return x - y; end function; function mul(x, y : uint8) return uint8 is begin return x * y; end function; function exp(x : uint8; y : integer) return uint8 is begin return x ** y; end function; end package body; nvc-r1.17.1/test/jit/proc1.vhd000066400000000000000000000020521504111170000160320ustar00rootroot00000000000000package proc1_pack0 is procedure add_n (x : inout integer; n : in integer); end package; package body proc1_pack0 is procedure add_n (x : inout integer; n : in integer) is begin if x = 10 then wait for 1 ns; else x := x + n; end if; end procedure; end package body; ------------------------------------------------------------------------------- package proc1_pack1 is procedure add1 (x : inout integer); end package; use work.proc1_pack0.all; package body proc1_pack1 is procedure add1 (x : inout integer) is begin add_n(x, 1); end procedure; end package body; ------------------------------------------------------------------------------- package proc1_pack2 is function add2 (x : integer) return integer; end package; use work.proc1_pack1.all; package body proc1_pack2 is function add2 (x : integer) return integer is variable r : integer := x; begin add1(r); add1(r); return r; end function; end package body; nvc-r1.17.1/test/jit/prot1.vhd000066400000000000000000000013741504111170000160610ustar00rootroot00000000000000package prot1 is impure function fetch_and_add (n : integer) return integer; end package; package body prot1 is type pt is protected procedure increment (n : integer); impure function get return integer; end protected; type pt is protected body variable counter : integer := 0; procedure increment (n : integer) is begin counter := counter + n; end procedure; impure function get return integer is begin return counter; end function; end protected body; shared variable p : pt; impure function fetch_and_add (n : integer) return integer is begin p.increment(n); return p.get; end function; end package body; nvc-r1.17.1/test/jit/range1.vhd000066400000000000000000000010161504111170000161620ustar00rootroot00000000000000package range1 is subtype preal is real range 1.0 to real'high; function as_positive (x : integer) return positive; function as_positive (x : real) return preal; end package; package body range1 is function as_positive (x : integer) return positive is variable p : positive; begin p := x; return p; end function; function as_positive (x : real) return preal is variable p : preal; begin p := x; return p; end function; end package body; nvc-r1.17.1/test/jit/real1.vhd000066400000000000000000000004161504111170000160140ustar00rootroot00000000000000package real1 is function approx(x, y : real; t : real := 0.001) return boolean; end package; package body real1 is function approx(x, y : real; t : real := 0.001) return boolean is begin return abs(x - y) < t; end function; end package body; nvc-r1.17.1/test/jit/record1.vhd000066400000000000000000000010431504111170000163440ustar00rootroot00000000000000package pack1 is type rec is record x : integer; y : integer; z : integer; end record; constant r : rec; end package; package body pack1 is constant r : rec := (1, 2, 3); end package body; ------------------------------------------------------------------------------- package pack2 is function sum_fields return integer; end package; use work.pack1.all; package body pack2 is function sum_fields return integer is begin return r.x + r.y + r.z; end function; end package body; nvc-r1.17.1/test/jit/record2.vhd000066400000000000000000000014441504111170000163520ustar00rootroot00000000000000package pack3 is type int_vector is array (natural range <>) of integer; type rec is record x : integer; y : integer; a : int_vector(1 to 3); z : integer; end record; constant r : rec; end package; package body pack3 is constant r : rec := (1, 2, (3, 4, 5), 6); end package body; ------------------------------------------------------------------------------- package pack4 is function sum_fields return integer; end package; use work.pack3.all; package body pack4 is function sum_fields return integer is variable sum : integer := r.x + r.y + r.z; begin --for i in r.a'range loop for i in 1 to 3 loop sum := sum + r.a(i); end loop; return sum; end function; end package body; nvc-r1.17.1/test/jit/record3.vhd000066400000000000000000000022271504111170000163530ustar00rootroot00000000000000package pack5 is type int_vector is array (natural range <>) of integer; type pair is record first : integer; second : integer; end record; type pair_vector is array (natural range <>) of pair; type rec is record x : integer; -- 0 y : integer; -- 4 a : int_vector(1 to 3); -- 8 b : pair_vector(1 to 2); -- 24 z : integer; -- 40 end record; constant r : rec; end package; package body pack5 is constant r : rec := (1, 2, (3, 4, 5), ((6, 7), (8, 9)), 10); end package body; ------------------------------------------------------------------------------- package pack6 is function sum_fields return integer; end package; use work.pack5.all; package body pack6 is function sum_fields return integer is variable sum : integer := r.x + r.y + r.z; begin for i in 1 to 3 loop sum := sum + r.a(i); end loop; for i in 1 to 2 loop sum := sum + r.b(i).first + r.b(i).second; end loop; return sum; end function; end package body; nvc-r1.17.1/test/jit/record4.vhd000066400000000000000000000042541504111170000163560ustar00rootroot00000000000000package pack5 is type int_vector is array (natural range <>) of integer; type pair is record first : integer; second : integer; end record; type pair_ptr is access pair; type pair_vector is array (natural range <>) of pair; type pair_vector_ptr is access pair_vector; function func1 (x : integer) return integer; function func2 (x : integer) return integer; function func3 (x : integer) return integer; function func4 (x : integer) return integer; end package; package body pack5 is function func1 (x : integer) return integer is variable p : pair_vector_ptr; variable result : integer := 0; begin p := new pair_vector(1 to x); for i in 1 to x loop p.all(i).first := i; p.all(i).second := x; end loop; for i in p.all'range loop result := result + p(i).first + p(i).second; end loop; return result; end function; function func2 (x : integer) return integer is variable p : pair_vector(1 to x); variable result : integer := 0; begin for i in 1 to x loop p(i).first := i; p(i).second := x; end loop; for i in p'range loop result := result + p(i).first + p(i).second; end loop; return result; end function; function func3 (x : integer) return integer is variable p : pair_ptr; begin p := new pair; p.first := x; p.second := x * 2; return p.first + p.second; end function; function func4 (x : integer) return integer is type rec is record p : pair_vector(1 to x); end record; type rec_ptr is access rec; variable rp : rec_ptr; variable r : rec; variable result : integer := 0; begin rp := new rec; for i in 1 to x loop rp.all.p(i).first := x; rp.all.p(i).second := x * 2; end loop; r := rp.all; for i in 1 to x loop result := result + r.p(i).first + r.p(i).second; end loop; return result; end function; end package body; nvc-r1.17.1/test/jit/relop1.vhd000066400000000000000000000006451504111170000162160ustar00rootroot00000000000000package relop1 is type uint8 is range 0 to 255; function cmpless (x, y : uint8) return boolean; function cmpless (x, y : real) return boolean; end package; package body relop1 is function cmpless (x, y : uint8) return boolean is begin return x < y; end function; function cmpless (x, y : real) return boolean is begin return x < y; end function; end package body; nvc-r1.17.1/test/jit/sum.vhd000066400000000000000000000016131504111170000156140ustar00rootroot00000000000000package sumpkg is type int_vector is array (natural range <>) of integer; function get_left(a : int_vector) return integer; function get_right(a : int_vector) return integer; function get_length(a : int_vector) return integer; function sum(a : int_vector) return integer; end package; package body sumpkg is function sum(a : int_vector) return integer is variable result : integer := 0; begin for i in a'range loop result := result + a(i); end loop; return result; end function; function get_left(a : int_vector) return integer is begin return a'left; end function; function get_right(a : int_vector) return integer is begin return a'right; end function; function get_length(a : int_vector) return integer is begin return a'length; end function; end package body; nvc-r1.17.1/test/jit/trace1.vhd000066400000000000000000000005721504111170000161720ustar00rootroot00000000000000package trace1 is procedure test1; end package; package body trace1 is procedure test3 is variable x : integer; begin x := 1 / 0; -- Error end procedure; procedure test1 is procedure test2 is begin test3; end procedure; begin test2; end procedure; end package body; nvc-r1.17.1/test/jit/trim1.vhd000066400000000000000000000046741504111170000160560ustar00rootroot00000000000000package trim1 is function func1 return bit_vector; function func2 return bit; function func3(n : integer) return character; impure function func4 return bit_vector; procedure proc1; function func5(n : integer) return integer; impure function func6 return bit; function func7(n : integer) return integer; end package; package body trim1 is -- Returns local variable function func1 return bit_vector is variable v : bit_vector(1 to 3); begin return v; end function; -- Returns scalar but calls func1 which has local allocation function func2 return bit is begin return func1(1); end function; -- Local allocation but returns scalar function func3(n : integer) return character is variable v : bit_vector(1 to n); begin return to_string(v)(n); -- Prevent optimisation end function; -- Inner function returns outer local variable impure function func4 return bit_vector is variable v : bit_vector(1 to 3); impure function inner return bit_vector is begin return v(1 to 2); end function; begin return inner; end function; -- Nested function call has local allocation procedure proc1 is begin assert func1 = "000"; end procedure; function sum(a : integer_vector) return integer is variable cnt : integer := 0; begin for i in a'range loop cnt := cnt + a(i); end loop; return cnt; end function; function iota(n : integer) return integer_vector is variable r : integer_vector(1 to n); begin for i in r'range loop r(i) := i; end loop; return r; end function; -- Multiple calls with local allocations function func5(n : integer) return integer is constant c : integer_vector := iota(n); begin return sum(c); end function; -- Inner function uses outer variable but returns scalar impure function func6 return bit is variable v : bit_vector(1 to 3); impure function inner return bit_vector is begin return v(1 to 2); end function; begin return not inner(1); end function; -- Local non-variable allocation but returns scalar function func7(n : integer) return integer is begin return sum((1 to n => 1)); end function; end package body; nvc-r1.17.1/test/jit/unreachable.vhd000066400000000000000000000004471504111170000172650ustar00rootroot00000000000000package unreachable is function func (x : integer) return integer; end package; package body unreachable is function func (x : integer) return integer is begin if x > 0 then return x * 2; end if; -- Error here end function; end package body; nvc-r1.17.1/test/jit/value1.vhd000066400000000000000000000013461504111170000162100ustar00rootroot00000000000000package value1 is function str_to_int (x : string) return integer; function str_to_real (x : string) return real; function str_to_time (x : string) return time; function str_to_bool (x : string) return boolean; end package; package body value1 is function str_to_int (x : string) return integer is begin return integer'value(x); end function; function str_to_real (x : string) return real is begin return real'value(x); end function; function str_to_time (x : string) return time is begin return time'value(x); end function; function str_to_bool (x : string) return boolean is begin return boolean'value(x); end function; end package body; nvc-r1.17.1/test/jitperf.c000066400000000000000000000157551504111170000153420ustar00rootroot00000000000000// // Copyright (C) 2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "diag.h" #include "eval.h" #include "ident.h" #include "jit/jit.h" #include "jit/jit-llvm.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "object.h" #include "option.h" #include "phase.h" #include "rt/mspace.h" #include "rt/rt.h" #include "scan.h" #include "thread.h" #include #include #include #include #define ITERATIONS 5 const char copy_string[] = ""; const char version_string[] = ""; static double mean(double *arr, int len) { double r = 0.0; for (int i = 0; i < len; i++) r += arr[i]; return r / len; } static void print_result(double ops_sec, double usec_op) { if (usec_op < 1.0) printf("%.1f ops/s; %.1f ns/op\n", ops_sec, usec_op * 1000.0); else printf("%.1f ops/s; %.1f us/op\n", ops_sec, usec_op); } static void run_benchmark(tree_t pack, tree_t proc, unit_registry_t *ur, mir_context_t *mc) { color_printf("$!magenta$## %s$$\n\n", istr(tree_ident(proc))); ident_t name = tree_ident2(proc); jit_t *j = jit_new(ur, mc); #if defined HAVE_LLVM && 1 jit_register_llvm_plugin(j); #elif defined ARCH_X86_64 && 0 jit_register_native_plugin(j); #endif jit_handle_t hpack = jit_compile(j, tree_ident(pack)); jit_scalar_t context = { .pointer = jit_link(j, hpack) }; jit_handle_t hproc = jit_compile(j, name); if (hproc == JIT_HANDLE_INVALID) fatal("cannot compile unit %s", istr(name)); double ops_sec[ITERATIONS + 1], usec_op[ITERATIONS + 1]; tlab_t *tlab = tlab_acquire(jit_get_mspace(j)); for (int trial = 0; trial < ITERATIONS + 1; trial++) { if (trial == 0) printf("Warmup: "); else printf("Iteration %d: ", trial); fflush(stdout); const uint64_t start = get_timestamp_us(); uint64_t now, iters = 0; for (; (now = get_timestamp_us()) < start + 1000000; iters++) { jit_scalar_t result; jit_scalar_t dummy = { .integer = 0 }; if (!jit_fastcall(j, hproc, &result, dummy, context, tlab)) fatal("error in benchmark subprogram"); tlab_reset(tlab); } const double elapsed = (now - start) / 1e6; ops_sec[trial] = iters / elapsed; usec_op[trial] = (double)(now - start) / iters; print_result(ops_sec[trial], usec_op[trial]); fflush(stdout); } tlab_release(tlab); color_printf("\n$!green$--> "); print_result(mean(ops_sec + 1, ITERATIONS), mean(usec_op + 1, ITERATIONS)); color_printf("$$\n"); jit_free(j); } static void find_benchmarks(tree_t pack, const char *filter, unit_registry_t *ur, mir_context_t *mc) { ident_t test_i = ident_new("TEST_"); const int ndecls = tree_decls(pack); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(pack, i); if (!is_subprogram(d)) continue; ident_t id = tree_ident(d); if (ident_starts_with(id, test_i) && (filter == NULL || strcasestr(istr(id), filter) != NULL)) run_benchmark(pack, d, ur, mc); } } static vhdl_standard_t parse_standard(const char *str) { char *eptr = NULL; const int year = strtol(str, &eptr, 10); if ((eptr != NULL) && (*eptr == '\0')) { switch (year) { case 1987: case 87: fatal("VHDL standard 1076-1987 is not supported"); case 1993: case 93: return STD_93; case 2000: case 0: return STD_00; case 2002: case 2: return STD_02; case 2008: case 8: return STD_08; case 2019: case 19: return STD_19; } } fatal("invalid standard revision: %s (allowed 1993, 2000, 2002, " "2008, 2019)", str); } static void usage(void) { printf("Usage: jitperf [OPTION]... [FILE]...\n" "\n" " -f PATTERN\t\t Only run tests matching PATTERN\n" " -L PATH\t\tAdd PATH to library search paths\n" "\n"); LOCAL_TEXT_BUF tb = tb_new(); lib_print_search_paths(tb); printf("Library search paths:%s\n", tb_get(tb)); printf("\nReport bugs to %s\n", PACKAGE_BUGREPORT); } int main(int argc, char **argv) { term_init(); set_default_options(); thread_init(); register_signal_handlers(); mspace_stack_limit(MSPACE_CURRENT_FRAME); intern_strings(); opt_set_str(OPT_GC_VERBOSE, getenv("NVC_GC_VERBOSE")); opt_set_int(OPT_RELAXED, 1); _std_standard_init(); _std_env_init(); _nvc_sim_pkg_init(); static struct option long_options[] = { { "std", required_argument, 0, 's' }, { 0, 0, 0, 0 } }; opterr = 0; const char *filter = NULL; int c, index = 0; const char *spec = "L:hf:i"; while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) { switch (c) { case 0: // Set a flag break; case 'L': lib_add_search_path(optarg); break; case 'h': usage(); return 0; case 's': set_standard(parse_standard(optarg)); break; case 'f': filter = optarg; break; case 'i': opt_set_int(OPT_JIT_THRESHOLD, 0); break; default: if (optopt == 0) fatal("unrecognised option $bold$%s$$", argv[optind - 1]); else fatal("unrecognised option $bold$-%c$$", optopt); } } if (optind == argc) fatal("usage: %s FILE...", argv[0]); lib_t work = lib_tmp("PERF"); lib_set_work(work); mir_context_t *mc = mir_context_new(); unit_registry_t *ur = unit_registry_new(mc); jit_t *jit = jit_new(ur, mc); for (int i = optind; i < argc; i++) { color_printf("$!cyan$--\n-- %s\n--$$\n\n", argv[i]); input_from_file(argv[i]); tree_t unit, pack = NULL; while ((unit = parse())) { if (error_count() > 0) return EXIT_FAILURE; lib_put(work, unit); simplify_local(unit, jit, ur, mc); bounds_check(unit); if (error_count() > 0) return EXIT_FAILURE; if (pack == NULL && tree_kind(unit) == T_PACKAGE) pack = unit; } if (pack == NULL) fatal("no package found in %s", argv[i]); freeze_global_arena(); find_benchmarks(pack, filter, ur, mc); } jit_free(jit); unit_registry_free(ur); return 0; } nvc-r1.17.1/test/lockbench.c000066400000000000000000000104151504111170000156130ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "option.h" #include "thread.h" #include #include #include #include #include #include #include #ifdef __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #else #include #endif #define USE_NVC_LOCK 1 #if USE_NVC_LOCK #define LOCK_TYPE nvc_lock_t #define LOCK_INIT(m) m = 0 #define LOCK(m) nvc_lock(&m); #define UNLOCK(m) nvc_unlock(&m); #elif defined __MINGW32__ #define LOCK_TYPE CRITICAL_SECTION #define LOCK_INIT(m) InitializeCriticalSectionAndSpinCount(&m, 10); #define LOCK(m) EnterCriticalSection(&m) #define UNLOCK(m) LeaveCriticalSection(&m) #else #define LOCK_TYPE pthread_mutex_t #define LOCK_INIT(m) pthread_mutex_init(&m, NULL) #define LOCK(m) pthread_mutex_lock(&m) #define UNLOCK(m) pthread_mutex_unlock(&m) #endif typedef struct { int value; LOCK_TYPE lock; } __attribute__((aligned(64))) counter_t; #define N_COUNTERS 8 const char copy_string[] = ""; const char version_string[] = ""; static counter_t counter[N_COUNTERS]; STATIC_ASSERT(sizeof(counter) == N_COUNTERS * 64); typedef struct { nvc_thread_t *thread; uint32_t rng; uint64_t iters; uint64_t last; int running; } __attribute__((aligned(64))) thread_state_t; STATIC_ASSERT(sizeof(thread_state_t) == 64); static inline uint32_t fast_rand(thread_state_t *t) { uint32_t state = t->rng; state ^= (state << 13); state ^= (state >> 17); state ^= (state << 5); return (t->rng = state); } static void *worker_thread(void *arg) { thread_state_t *t = arg; while (relaxed_load(&(t->running))) { int n = fast_rand(t) % N_COUNTERS; LOCK(counter[n].lock); counter[n].value++; UNLOCK(counter[n].lock); relaxed_add(&(t->iters), 1); } return NULL; } int main(int argc, char **argv) { const int nproc = nvc_nprocs(); srand((unsigned)time(NULL)); term_init(); thread_init(); register_signal_handlers(); set_default_options(); thread_state_t *threads = xcalloc_array(nproc, sizeof(thread_state_t)); for (int i = 0; i < N_COUNTERS; i++) LOCK_INIT(counter[i].lock); for (int i = 0; i < nproc; i++) { threads[i].running = 1; threads[i].rng = rand(); threads[i].thread = thread_create(worker_thread, &(threads[i]), "worker %d", i); } printf("THREADS OPS/MS FAIRNESS\n"); for (int i = 0; i < 10; i++) { const uint64_t start = get_timestamp_ns(); sleep(1); const uint64_t end = get_timestamp_ns(); const double secs = (end - start) / 1.0e9; int total = 0; for (int j = 0; j < N_COUNTERS; j++) { LOCK(counter[j].lock); total += counter[j].value; counter[j].value = 0; UNLOCK(counter[j].lock); } double geo = 1.0, best = 0.0; for (int j = 0; j < nproc; j++) { uint64_t iters = relaxed_load(&(threads[j].iters)); uint64_t delta = iters - threads[j].last; const double result = (double)delta / secs; geo *= result; if (result > best) best = result; threads[j].last = iters; } const double fair = pow(geo, 1.0 / nproc) / best; printf("%-8d %-11.1f %.2f\n", nproc, (total / secs) / 1000.0, fair); } for (int i = 0; i < nproc; i++) relaxed_store(&(threads[i].running), 0); for (int i = 0; i < nproc; i++) thread_join(threads[i].thread); #if USE_NVC_LOCK for (int i = 0; i < N_COUNTERS; i++) assert(counter[i].lock == 0); #endif return 0; } nvc-r1.17.1/test/lower/000077500000000000000000000000001504111170000146465ustar00rootroot00000000000000nvc-r1.17.1/test/lower/access1.vhd000066400000000000000000000006611504111170000166760ustar00rootroot00000000000000entity access1 is end entity; architecture test of access1 is type list; type list_ptr is access list; type list is record link : list_ptr; value : integer; end record; procedure list_add(l : inout list_ptr; v : integer) is variable n : list_ptr; begin n := new list; n.link := l; n.value := v; l := n; end procedure; begin end architecture; nvc-r1.17.1/test/lower/access2.vhd000066400000000000000000000004451504111170000166770ustar00rootroot00000000000000package access2 is type bv_ptr is access bit_vector; function get_fresh(b : bit_vector) return bv_ptr; end package; package body access2 is function get_fresh(b : bit_vector) return bv_ptr is begin return new bit_vector(b'range); end function; end package body; nvc-r1.17.1/test/lower/access_bug.vhd000066400000000000000000000007371504111170000174560ustar00rootroot00000000000000entity access_bug is end entity; architecture test of access_bug is type rec_t is record foo: integer; end record rec_t; type rec_ptr_t is access rec_t; type rec_arr_t is array (integer range <>) of rec_ptr_t; type rec_arr_ptr_t is access rec_arr_t; procedure bug_procedure is variable rec_ptr: rec_arr_ptr_t; begin rec_ptr(0) := new rec_t'(foo => 42); rec_ptr(0).all.foo := 2; -- this works rec_ptr(0).foo := 2; -- <-- bug here end; begin end architecture; nvc-r1.17.1/test/lower/alias1.vhd000066400000000000000000000005041504111170000165220ustar00rootroot00000000000000package pack is constant hello : string := "hello, world"; alias a is hello(1 to 3); end package; ------------------------------------------------------------------------------- entity alias1 is end entity; use work.pack.all; architecture test of alias1 is begin p1: assert false report a; end architecture; nvc-r1.17.1/test/lower/arith1.vhd000066400000000000000000000015271504111170000165460ustar00rootroot00000000000000entity arith1 is end entity; architecture test of arith1 is begin p1: process is variable x, y : integer; begin x := 3; y := 12; wait for 1 ns; assert x + y = 15; assert x - y = -9; assert x * y = 36; assert x / 12 = 0; assert x = 3; assert y = 12; assert x /= y; assert x < y; assert y > x; assert x <= y; assert y >= x; assert (- x) = -3; assert x ** y = 531441; x := -34; assert abs x = 34; assert abs y = 12; assert 5 mod x = 2; assert 5 rem x = 2; assert (-5) rem x = -2; assert (-5) mod x = 2; assert x = +x; assert 0 - x > 0; assert x ** 0 = 1; assert x ** 1 = x; wait; end process; end architecture; nvc-r1.17.1/test/lower/array1.vhd000066400000000000000000000004211504111170000165450ustar00rootroot00000000000000entity array1 is end entity; architecture test of array1 is impure function func return bit_vector is begin return "101"; end function; begin p1: process is begin assert func = "10"; wait; end process; end architecture; nvc-r1.17.1/test/lower/array2.vhd000066400000000000000000000034021504111170000165500ustar00rootroot00000000000000entity array2 is end entity; architecture test of array2 is type int_vec is array (natural range <>) of integer; type int_vec_ptr is access int_vec; type int_vec2x2 is array (natural range <>, natural range <>) of integer; signal s : int_vec(1 to 2); begin p1: process is variable v : int_vec(1 to 2); variable x : integer; begin v := (x, x); wait; end process; p2: process is variable v : int_vec(1 to 2); variable x : integer; begin v := (1 => x, others => 0); wait; end process; p3: process is variable v : int_vec2x2(1 to 2, 1 to 2); variable x, y : integer; begin v := ((x, x), (y, y)); wait; end process; p4: process is variable v : int_vec2x2(1 to 2, 1 to 2); variable x, y : integer; begin v := ((x, x), others => (y, y)); wait; end process; p5: process is variable v : int_vec(1 to 3); variable x : integer; begin v := (1 => 1, 2 => x, 3 => 3); wait; end process; p6: process is variable x : integer; begin s <= (x, x); wait; end process; p7: process is variable p : int_vec_ptr; begin p := new int_vec(1 to 3); wait; end process; p8: process is variable p : int_vec_ptr; variable x : integer; begin p := new int_vec'(x, x); wait; end process; p9: process is function f return int_vec is begin return (1, 2, 3); end function; variable p : int_vec_ptr; variable v : int_vec(1 to 2); begin p := new int_vec'(f, 1); end process; end architecture; nvc-r1.17.1/test/lower/arrayop1.vhd000066400000000000000000000003321504111170000171050ustar00rootroot00000000000000entity arrayop1 is end entity; architecture test of arrayop1 is begin p1: process is variable x : bit_vector(1 to 3); begin assert x < "000"; wait; end process; end architecture; nvc-r1.17.1/test/lower/assert1.vhd000066400000000000000000000004161504111170000167340ustar00rootroot00000000000000entity assert1 is end entity; architecture test of assert1 is begin p1: process is variable b : boolean; begin b := true; assert b; -- Should be optimised in vcode wait; end process; end architecture; nvc-r1.17.1/test/lower/assert2.vhd000066400000000000000000000005501504111170000167340ustar00rootroot00000000000000entity assert2 is end entity; architecture test of assert2 is procedure test(x : integer; s : string) is begin assert x > 0 report "s=" & s; -- Message has allocation side-effect end procedure; begin p1: process is variable x : integer; begin test(-6, "hello"); wait; end process; end architecture; nvc-r1.17.1/test/lower/assign1.vhd000066400000000000000000000007131504111170000167170ustar00rootroot00000000000000entity assign1 is end entity; architecture test of assign1 is begin p1: process is variable x : integer := 64; variable y : integer := -4; begin wait for 4 ns; assert x = 64; assert y = -4; x := y * 2; assert x = -8; x := 5; y := 7; assert x = 5; assert y = 7; wait for 1 ns; assert x + y = 12; wait; end process; end architecture; nvc-r1.17.1/test/lower/assign2.vhd000066400000000000000000000007321504111170000167210ustar00rootroot00000000000000entity assign2 is end entity; architecture test of assign2 is begin p1: process is variable x : bit_vector(7 downto 0) := (1 => '1', others => '0'); subtype myint is integer range 1 to 10; type myint_array is array (integer range <>) of myint; variable y : myint_array(1 to 3); begin assert x(0) = '0'; assert x(4) = x(7); x(2) := '1'; y(1) := y(3); wait; end process; end architecture; nvc-r1.17.1/test/lower/assign3.vhd000066400000000000000000000004261504111170000167220ustar00rootroot00000000000000entity assign3 is end entity; architecture test of assign3 is begin p1: process is variable x : bit_vector(7 downto 0); variable y : bit_vector(7 downto 0); begin x := y; assert x /= y; wait; end process; end architecture; nvc-r1.17.1/test/lower/attr1.vhd000066400000000000000000000007731504111170000164130ustar00rootroot00000000000000entity attr1 is end entity; architecture test of attr1 is type my_int is range 10 downto 0; begin p1: process is variable x : integer := 0; variable y : my_int; variable z : integer := 1; begin assert integer'succ(x) = 1; assert integer'pred(x) = -1; assert integer'leftof(z) = 0; assert integer'rightof(z) = 2; assert my_int'leftof(y) = 2; assert my_int'rightof(y) = 0; wait; end process; end architecture; nvc-r1.17.1/test/lower/attr2.vhd000066400000000000000000000006421504111170000164070ustar00rootroot00000000000000entity attr2 is end entity; architecture test of attr2 is type rec is record f : bit_vector; end record; type rec_array is array (natural range <>) of rec; impure function get_k return integer is begin return 3; end function; constant k : integer := get_k; signal r : rec_array(1 to k)(f(1 to k)); constant l : integer := r(k).f'length; begin end architecture; nvc-r1.17.1/test/lower/bigarray.vhd000066400000000000000000000004771504111170000171610ustar00rootroot00000000000000package bigarray is type int_vec is array (natural range <>) of integer; function get_array return int_vec; end package; package body bigarray is function get_array return int_vec is variable r : int_vec(1 to 2**20) := (others => 2); begin return r; end function; end package body; nvc-r1.17.1/test/lower/bounds1.vhd000066400000000000000000000006411504111170000167250ustar00rootroot00000000000000entity bounds1 is end entity; architecture test of bounds1 is type int_vec is array (natural range <>) of integer; begin p1: process is variable v : int_vec(0 to 9) := (others => 0); variable k : integer range 0 to 9; begin assert v(k) = 1; -- Should elide assert v(k + 1) = 1; -- Cannot elide wait; end process; end architecture; nvc-r1.17.1/test/lower/bounds2.vhd000066400000000000000000000004721504111170000167300ustar00rootroot00000000000000entity bounds2 is generic ( PIXEL_DEPTH : natural := 24 ); end entity; architecture test of bounds2 is signal vid_data_in : bit_vector(PIXEL_DEPTH-1 downto 0); begin p: process is begin vid_data_in <= X"123"; -- Error wait; end process; end architecture; nvc-r1.17.1/test/lower/case1.vhd000066400000000000000000000012131504111170000163420ustar00rootroot00000000000000entity case7 is end entity; architecture test of case7 is constant C1 : bit_vector(3 downto 0) := X"1"; constant C2 : bit_vector(3 downto 0) := X"2"; alias C3 : bit_vector(3 downto 0) is C1; signal x : bit_vector(7 downto 0); signal y : integer; begin testp: process (x) is begin case x is when C1 & X"0" => y <= 5; when C1 & X"8" => y <= 6; when C2 & X"2" => y <= 10; when C3 & X"3" => y <= 5; when others => y <= 0; end case; end process; end architecture; nvc-r1.17.1/test/lower/case2.vhd000066400000000000000000000017261504111170000163540ustar00rootroot00000000000000package pack is type channel_t is (A, B, C, D); end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( channel : in channel_t ); port ( o : out natural ); end entity; architecture test of sub is begin p1: process is begin case channel is when A => o <= 1; when B => o <= 24; when D => o <= 5; when others => o <= 99; end case; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity case2 is end entity; architecture test of case2 is type rec_t is record channel : natural; end record; function get_vals return rec_t is begin return (channel => 3); end function; signal s : natural; begin u: entity work.sub generic map ( C ) port map ( s ); end architecture; nvc-r1.17.1/test/lower/choice1.vhd000066400000000000000000000007101504111170000166620ustar00rootroot00000000000000entity choice1 is end entity; architecture test of choice1 is signal s : integer; begin p1: process is variable x : integer; begin case s is when 1 | 2 => x := 3; when 3 | 4 | 5 => x := 4; when integer'low to 0 => x := -1; when others => x := 5; end case; wait; end process; end architecture; nvc-r1.17.1/test/lower/closefile.vhd000066400000000000000000000004271504111170000173210ustar00rootroot00000000000000package filepack is procedure test; end package; package body filepack is procedure test is type text is file of string; file F: TEXT open write_mode is "f"; begin -- F should be closed before returning end procedure; end package body; nvc-r1.17.1/test/lower/concat.vhd000066400000000000000000000006311504111170000166200ustar00rootroot00000000000000entity concat is end entity; architecture test of concat is type int_vec is array (natural range <>) of integer; signal s : int_vec(1 to 3); begin p1: process is variable v : int_vec(1 to 3); begin v := (1, 2) & 3; wait; end process; p2: process is begin s <= (1, 2) & 3; s <= 4 & 5 & 6; wait; end process; end architecture; nvc-r1.17.1/test/lower/cond1.vhd000066400000000000000000000006151504111170000163570ustar00rootroot00000000000000entity cond1 is end entity; architecture test of cond1 is signal x : integer := 5; begin p1: process is variable y : integer; begin if x = y then y := 2; end if; if x = y + 1 then y := 1; else y := 3; null; end if; report "doo"; wait; end process; end architecture; nvc-r1.17.1/test/lower/cond2.vhd000066400000000000000000000016271504111170000163640ustar00rootroot00000000000000package cond2 is type pt is protected impure function get_idx (s : string) return natural; end protected; procedure dummy_loop (x : bit_vector); end package; package body cond2 is type string_array is array (natural range <>) of string; type string_array_ptr is access string_array; type pt is protected body variable strings : string_array_ptr; impure function get_idx (s : string) return natural is begin for i in strings.all'range loop return i when strings.all(i) = s; end loop; return natural'right; end function; end protected body; procedure dummy_loop (x : bit_vector) is begin for i in x'range loop if x(i) = '1' then return; else return; end if; end loop; end procedure; end package body; nvc-r1.17.1/test/lower/const1.vhd000066400000000000000000000002711504111170000165600ustar00rootroot00000000000000package issueH is constant c : bit_vector; -- Should be extern end package issueH; package body issueH is constant c : bit_vector := "101"; end package body issueH; nvc-r1.17.1/test/lower/const2.vhd000066400000000000000000000004601504111170000165610ustar00rootroot00000000000000package const2pack is constant width : integer; end package; package body const2pack is constant width : integer := 5; end package body; entity const2 is end entity; use work.const2pack.all; architecture test of const2 is signal s : bit_vector(1 to width); -- OK begin end architecture; nvc-r1.17.1/test/lower/const3.vhd000066400000000000000000000007401504111170000165630ustar00rootroot00000000000000entity const3 is end entity; architecture test of const3 is type real_vector is array (natural range <>) of real; function get_reals return real_vector is begin return (1.0, 0.0, 1.0, 0.0, 1.0); end function; begin p1: process is constant c1 : real_vector := get_reals; constant c2 : real_vector(1 to c1'length) := (0.0, 1.0, 0.0, 1.0, 1.0); begin wait for 5 ns; assert false; end process; end architecture; nvc-r1.17.1/test/lower/conv1.vhd000066400000000000000000000005611504111170000164010ustar00rootroot00000000000000package conv1 is type rec is record x : integer; end record; type rec_array is array (natural range <>) of rec; function get(a : rec_array) return real; end package; package body conv1 is function get(a : rec_array) return real is begin return real(a(0).x); -- Must reify a(0).x end function; end package body; nvc-r1.17.1/test/lower/copy1.vhd000066400000000000000000000006301504111170000164030ustar00rootroot00000000000000package copy1 is procedure test_copy; end package; package body copy1 is procedure do_copy (dest : out bit_vector; src : in bit_vector) is begin dest := src; end procedure; procedure test_copy is variable src, dest : bit_vector(1 to 4096); begin for i in 1 to 100 loop do_copy(dest, src); end loop; end procedure; end package body; nvc-r1.17.1/test/lower/cover.vhd000066400000000000000000000013411504111170000164660ustar00rootroot00000000000000Library ieee; use ieee.std_logic_1164.all; entity cover_ent is end entity; architecture test of cover_ent is signal s : integer; signal l : std_logic; signal l_vect : std_logic_vector(7 downto 0); begin p1: process is variable v : integer; begin v := 1; if s = 1 or s > 10 then v := 2; end if; -- coverage off s <= 1; -- coverage on wait; end process; p2: process begin l <= '0'; l_vect <= (others => '0'); wait for 1 ns; l <= '1'; l_vect <= (others => '1'); wait for 1 ns; l <= '0'; l_vect <= (others => '0'); wait; end process; end architecture; nvc-r1.17.1/test/lower/dealloc.vhd000066400000000000000000000005141504111170000167540ustar00rootroot00000000000000package pack is type ptr is access integer; procedure dealloc(p : inout ptr); end package; package body pack is procedure another_proc(p : inout ptr) is begin deallocate(p); end procedure; procedure dealloc(p : inout ptr) is begin another_proc(p); end procedure; end package body; nvc-r1.17.1/test/lower/directmap.vhd000066400000000000000000000012021504111170000173140ustar00rootroot00000000000000entity bot is port ( i : in integer; o : out integer ); end entity; architecture test of bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity directmap is end entity; architecture test of directmap is signal x, y : integer; begin uut: entity work.bot port map ( x, y ); process is begin x <= 0; wait for 1 ns; assert y = 1; x <= 2; wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/lower/directmap2.vhd000066400000000000000000000013761504111170000174120ustar00rootroot00000000000000package directmap2_pack is type rec is record x : integer; y : bit; z : bit_vector(1 to 3); end record; end package; ------------------------------------------------------------------------------- use work.directmap2_pack.all; entity bot is port ( r : in rec ); end entity; architecture test of bot is begin end architecture; ------------------------------------------------------------------------------- use work.directmap2_pack.all; entity directmap2 is end entity; architecture test of directmap2 is signal p : bit; signal q : bit_vector(1 to 3); signal i : integer; begin uut: entity work.bot port map ( r.y => p, r.z => q, r.x => i ); end architecture; nvc-r1.17.1/test/lower/directmap3.vhd000066400000000000000000000010611504111170000174020ustar00rootroot00000000000000entity sub is generic ( W : natural ); port ( o : out bit_vector(1 to 2); p : in bit_vector(1 to W) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity directmap3 is end entity; architecture test of directmap3 is constant K : natural := 4; signal o1, o2 : bit; signal p : bit_vector(1 to 3); begin u: entity work.sub generic map ( K - 1 ) port map ( o(1) => o1, o(2) => o2, p => p ); end architecture; nvc-r1.17.1/test/lower/directmap5.vhd000066400000000000000000000007141504111170000174100ustar00rootroot00000000000000entity directmap5 is end entity; architecture test of directmap5 is type t_rec is record x, y : integer; end record; type t_rec_array is array (natural range <>) of t_rec; function get_value return natural is begin return 3; end function; signal s : t_rec_array(1 to 3); begin b: block is port ( t : t_rec_array(1 to get_value) ); port map ( s ); begin end block; end architecture; nvc-r1.17.1/test/lower/directmap6.vhd000066400000000000000000000010251504111170000174050ustar00rootroot00000000000000entity sub is port ( ii : in bit; oo : out bit ); end entity; architecture test of sub is begin oo <= ii after 1 ps; end architecture; ------------------------------------------------------------------------------- entity directmap6 is end entity; architecture test of directmap6 is component sub is port ( i : in bit; o : out bit ); end component; for u : sub use entity work.sub port map ( ii => i, oo => o ); signal x, y : bit; begin u: sub port map ( x, y ); end architecture; nvc-r1.17.1/test/lower/driver1.vhd000066400000000000000000000014361504111170000167310ustar00rootroot00000000000000package pack is type rec is record x, y : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r : rec ); port ( o : out bit_vector(1 to 3) ); end entity; architecture test of sub is begin p1: o(1 to r.x) <= (others => '1'); end architecture; ------------------------------------------------------------------------------- entity driver1 is end entity; use work.pack.all; architecture test of driver1 is function get_rec return rec is begin return (2, 3); end function; constant c : rec := get_rec; signal s : bit_vector(1 to 3); begin u: entity work.sub generic map ( c ) port map ( s ); end architecture; nvc-r1.17.1/test/lower/event1.vhd000066400000000000000000000003651504111170000165570ustar00rootroot00000000000000entity event1 is end entity; architecture test of event1 is type rec is record f : integer_vector; end record; procedure do_wait(signal s : in rec) is begin wait on s; end procedure; begin end architecture; nvc-r1.17.1/test/lower/extern1.vhd000066400000000000000000000011031504111170000167320ustar00rootroot00000000000000package complex is type COMPLEX is record RE : REAL; -- Real part IM : REAL; -- Imaginary part end record; constant MATH_CBASE_1 : COMPLEX := COMPLEX'(1.0, 0.0); constant MATH_CBASE_J : COMPLEX := COMPLEX'(0.0, 1.0); constant MATH_CZERO : COMPLEX := COMPLEX'(0.0, 0.0); function SQRT(Z: in COMPLEX ) return COMPLEX; end package; package body complex is function SQRT(Z: in COMPLEX ) return COMPLEX is begin return MATH_CZERO; end function; end package body; nvc-r1.17.1/test/lower/func1.vhd000066400000000000000000000004711504111170000163670ustar00rootroot00000000000000entity func1 is end entity; architecture test of func1 is function add1(x : integer) return integer is begin return x + 1; end function; begin p1: process is variable r : integer; begin r := 2; r := add1(r); wait; end process; end architecture; nvc-r1.17.1/test/lower/func5.vhd000066400000000000000000000007151504111170000163740ustar00rootroot00000000000000entity func5 is end entity; architecture test of func5 is function add_one_s(signal s : in integer) return integer is begin return s + 1; end function; function event(signal s : in integer) return boolean is begin return s'event; end function; signal x : integer := 5; begin p1: process is begin assert add_one_s(x) = 6; assert event(x); wait; end process; end architecture; nvc-r1.17.1/test/lower/funcif.vhd000066400000000000000000000004031504111170000166200ustar00rootroot00000000000000entity funcif is end entity; architecture test of funcif is function foo(x : integer) return integer is begin if x > 5 then return 1; else return 0; end if; end function; begin end architecture; nvc-r1.17.1/test/lower/genpack1.vhd000066400000000000000000000006631504111170000170470ustar00rootroot00000000000000package pack is generic ( n : integer ) ; type t is (a, b, c); end package ; ------------------------------------------------------------------------------- package p5 is new work.pack generic map ( 5 ); entity genpack1 is end entity; use work.p5.all; architecture test of genpack1 is signal s : t; begin p1: process is begin assert t'image(s) = "a"; wait; end process; end architecture; nvc-r1.17.1/test/lower/genpack2.vhd000066400000000000000000000007451504111170000170510ustar00rootroot00000000000000package pack1 is type t_rec is record x, y : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack1.all; package genpack is generic ( g : t_rec ); end package; ------------------------------------------------------------------------------- package test is package inst is new work.genpack generic map ( g => (1, 2) ); use inst.all; constant c : integer := g.y; end package; nvc-r1.17.1/test/lower/hintbug.vhd000066400000000000000000000007411504111170000170130ustar00rootroot00000000000000entity hintbug is end entity; architecture test of hintbug is function func(x : bit) return bit_vector is begin return x & '1'; end function; begin p1: process is variable v : bit_vector(1 downto 0); variable x : bit := '1'; begin v := func(x); -- Will create an unused storage hint assert v = x & '0'; -- Will incorrectly use above hint wait; end process; end architecture; nvc-r1.17.1/test/lower/iffold.vhd000066400000000000000000000007761504111170000166260ustar00rootroot00000000000000entity sub is generic ( N : integer ); end entity; architecture test of sub is signal x, y : integer; begin p1: process is begin if N > 3 then x <= 5; else y <= 6; end if; end process; end architecture; ------------------------------------------------------------------------------- entity iffold is end entity; architecture test of iffold is begin sub_i: entity work.sub generic map ( N => 4 ); end architecture; nvc-r1.17.1/test/lower/incomplete.vhd000066400000000000000000000002731504111170000175120ustar00rootroot00000000000000package p is constant cp : integer; end package p; package body p is constant c : integer := 1; alias ca : integer is c; constant cp : integer := ca; end package body p; nvc-r1.17.1/test/lower/instance1.vhd000066400000000000000000000010521504111170000172340ustar00rootroot00000000000000entity sub is generic ( WIDTH : integer ); port ( x : in bit_vector(1 to WIDTH) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity instance1 is end entity; architecture test of instance1 is component sub is generic ( WIDTH : integer ); port ( x : in bit_vector(1 to WIDTH) ); end component; constant WIDTH : integer := 5; begin sub_i: sub generic map ( WIDTH ) port map ( "00000" ); end architecture; nvc-r1.17.1/test/lower/issue1029.vhd000066400000000000000000000004171504111170000170170ustar00rootroot00000000000000entity issue1029 is end entity; architecture test of issue1029 is procedure p (signal x : inout bit) is begin wait for 1 ns; end procedure; signal s : bit; begin call: p(<< signal .issue1029.s : bit >>); -- Crash here end architecture; nvc-r1.17.1/test/lower/issue1080.vhd000066400000000000000000000011111504111170000170040ustar00rootroot00000000000000entity issue1080 is end entity; architecture test of issue1080 is type t_enum is (a, b, c); type t_other is array (natural range <>) of bit; subtype t_nat_sub is natural range 3 downto 0; signal s2 : t_other(3 downto 0); signal s3 : bit_vector(5 downto 0); begin u: block is port ( o : out bit_vector ); port map ( s3 ); type t_array is array (t_enum range a to c) of bit_vector(o'range); signal s1 : t_array; begin p: s1(b) <= (t_nat_sub => bit_vector(s2), others => '0'); end block; end architecture test; nvc-r1.17.1/test/lower/issue1155.vhd000066400000000000000000000020511504111170000170130ustar00rootroot00000000000000entity test is end entity; architecture test of test is type ArrayOfSigned is array (natural range <>) of bit_vector; subtype ArrayOfSigned16 is ArrayOfSigned(open)(15 downto 0); type InterlacedSignal is record Data : ArrayOfSigned; Valid : bit; end record; -- Should not generate a bounds var subtype Interlaced16bSignal is InterlacedSignal(Data(open)(15 downto 0)); type p_rec is record x, y : integer; end record; impure function get_p return p_rec is begin return (x => 8, y => 16); end function; constant p : p_rec := get_p; signal SomeArr : ArrayOfSigned16(0 to p.x - 1); signal Valid : bit; begin b: block is generic ( IN_LANES, IN_WIDTH : integer ); generic map ( IN_LANES => p.x, IN_WIDTH => 16 ); port ( DataIn : in InterlacedSignal(Data(0 to IN_LANES - 1)(IN_WIDTH - 1 downto 0)) ); port map ( DataIn.Data => SomeArr, DataIn.Valid => Valid ); begin end block; end architecture; nvc-r1.17.1/test/lower/issue116.vhd000066400000000000000000000005311504111170000167300ustar00rootroot00000000000000entity issue116 is end issue116; architecture behav of issue116 is signal intstat : BIT_VECTOR (7 DOWNTO 0); ALIAS INT_int : BIT is intstat(7); begin p1: INT_int <= '1' when (intstat(6 downto 0) and "1111111") /= "0000000"; --intstat(7) <= '1' when (intstat(6 downto 0) and "1111111") /= "0000000"; end behav; nvc-r1.17.1/test/lower/issue1191.vhd000066400000000000000000000007771504111170000170300ustar00rootroot00000000000000package test_pkg is generic ( DEPTH : positive := 8 ); type t_test is protected end protected t_test; end package test_pkg; package body test_pkg is type t_test is protected body end protected body; end package body; ------------------------------------------------------------------------------- entity test is end entity; architecture sim of test is package test_pkg_inst is new work.test_pkg; shared variable s_test_pkg_inst : test_pkg_inst.t_test; begin end architecture sim; nvc-r1.17.1/test/lower/issue1194.vhd000066400000000000000000000003451504111170000170220ustar00rootroot00000000000000entity issue1194 is end entity; architecture test of issue1194 is signal x, y : bit; begin b: block is port ( p : in bit ); port map ( p => inertial x or y ); begin end block; end architecture; nvc-r1.17.1/test/lower/issue1196.vhd000066400000000000000000000010411504111170000170160ustar00rootroot00000000000000entity issue1196 is end entity; architecture test of issue1196 is subtype MemoryBaseType is integer; type MemBlockType is array (integer range <>) of MemoryBaseType ; type MemBlockPtrType is access MemBlockType ; type MemArrayType is array (integer range <>) of MemBlockPtrType ; type MemArrayPtrType is access MemArrayType ; begin p1: process is variable ptr : MemArrayPtrType; begin ptr := new MemArrayType(0 to (2**30-1) + 2**30) ; wait; end process; end architecture; nvc-r1.17.1/test/lower/issue1199.vhd000066400000000000000000000006711504111170000170310ustar00rootroot00000000000000entity nvc_bug is end entity nvc_bug; architecture rtl of nvc_bug is type t_slv_array is array (natural range <>) of bit_vector; function get_slv_array return t_slv_array is variable v_data_out : t_slv_array(0 to 1)(7 downto 0) := (others=>x"00"); begin return v_data_out(0 to 1); end function get_slv_array; constant C_CONSTANT : t_slv_array(0 to 2)(7 downto 0) := x"00" & get_slv_array; begin end architecture rtl; nvc-r1.17.1/test/lower/issue1208.vhd000066400000000000000000000054541504111170000170240ustar00rootroot00000000000000--------------------------------------------------------------------------------` -- PACKAGE DECLARATION -------------------------------------------------------------------------------- package axiLite_pkg is -- AxiLite Read Address channel type axiLite_rdAddrCh_t is record -- Handshake signals arvalid : bit; arready : bit; -- Payload signals araddr : bit_vector(7 downto 0); end record axiLite_rdAddrCh_t; view axiLite_rdAddrCh_Host_v of axiLite_rdAddrCh_t is -- Handshake signals arvalid : out; arready : in; -- Payload signals araddr : out; end view axiLite_rdAddrCh_Host_v; alias axiLite_rdAddrCh_Agent_v is axiLite_rdAddrCh_Host_v'converse; ------------------------------------------------------------------------------ -- AxiLite Read type axiLite_t is record rdAddrCh : axiLite_rdAddrCh_t; end record axiLite_t; view axiLite_Host_v of axiLite_t is rdAddrCh : view axiLite_rdAddrCh_Host_v; end view axiLite_Host_v; alias axiLite_Agent_v is axiLite_Host_v'converse; ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ end package axiLite_pkg; -------------------------------------------------------------------------------- use work.axiLite_pkg.all; entity axiLite_reg is port ( i_axil_clk : in bit; -- Main clock i_axil_reset : in bit; -- reset, active high -- AXI4-Lite interface axil_agent : view axiLite_Agent_v of axiLite_t ); end entity axiLite_reg; architecture rtl of axiLite_reg is signal s_axil_agent_if : axiLite_t; begin -- out axil_agent.rdAddrCh.arready <= s_axil_agent_if.rdAddrCh.arready; -- in s_axil_agent_if.rdAddrCh.arvalid <= axil_agent.rdAddrCh.arvalid; s_axil_agent_if.rdAddrCh.araddr <= axil_agent.rdAddrCh.araddr; end architecture rtl; -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- entity issue1208 is port ( -- AXI4Lite s_axil_aclk : in bit; s_axil_areset : in bit; -- s_axil_arvalid : in bit; s_axil_arready : out bit; s_axil_araddr : in bit_vector(7 downto 0); ); end entity issue1208; architecture str of issue1208 is begin -- start of architecture -- axiLite_reg_inst : entity work.axiLite_reg(rtl) port map ( i_axil_clk => s_axil_aclk, i_axil_reset => s_axil_areset, -- axil_agent.rdAddrCh.araddr => s_axil_araddr, axil_agent.rdAddrCh.arvalid => s_axil_arvalid, axil_agent.rdAddrCh.arready => s_axil_arready ); -- end of axiLite_reg_inst end architecture str; -------------------------------------------------------------------------------- nvc-r1.17.1/test/lower/issue122.vhd000066400000000000000000000005221504111170000167250ustar00rootroot00000000000000entity issue122 is end entity; architecture test of issue122 is impure function func(x : integer) return integer is impure function nested return integer is begin return x; end function; variable v : integer := nested; begin return v; end function; begin end architecture; nvc-r1.17.1/test/lower/issue1234.vhd000066400000000000000000000035301504111170000170140ustar00rootroot00000000000000package pkg is type logic_pair_t is record l0 : bit; l1 : bit; end record; type logic_pair_arr_t is array (natural range <>) of logic_pair_t; type bit_arr_params is record init_value : logic_pair_t; len : natural; end record bit_arr_params; function init(params : bit_arr_params) return logic_pair_arr_t; end package pkg; package body pkg is function init(params : bit_arr_params) return logic_pair_arr_t is variable value : logic_pair_arr_t(params.len - 1 downto 0) := (others => params.init_value); begin return value; end function init; end package body pkg; ------------------------------------------------------------------------------- use work.pkg.all; entity ent is generic( params : bit_arr_params ); port( -- Both lines cause a failure rec_out : out logic_pair_arr_t := init(params) -- rec_out : out logic_pair_arr_t := init(( -- len => 5, -- init_value => (l0 => '0', l1 => '1') -- )) -- but this works -- rec_out: out logic_pair_arr_t(params.len - 1 downto 0) := (others => params.init_value) ); end entity ent; architecture RTL of ent is begin end architecture RTL; ------------------------------------------------------------------------------- use work.pkg.all; entity issue1234 is end entity issue1234; architecture RTL of issue1234 is -- signal rec0 : rec_t(rec0(1 downto 0)); constant params : bit_arr_params := ( len => 5, init_value => (l0 => '0', l1 => '1') ); signal rec_out : logic_pair_arr_t(params.len - 1 downto 0); begin ent_inst : entity work.ent generic map( params => params ) port map( rec_out => rec_out ); end architecture RTL; nvc-r1.17.1/test/lower/issue124.vhd000066400000000000000000000011451504111170000167310ustar00rootroot00000000000000package pack is type unsigned is array (integer range <>) of bit; function to_integer (constant value : unsigned) return integer; end package; package body pack is function to_integer (constant value : unsigned) return integer is begin return 0; end function; end package body; entity to_integer_string_bug is end entity; use work.pack.all; architecture test of to_integer_string_bug is function to_integer_string (constant value : unsigned) return string is begin return integer'image(to_integer(value)); -- 'IMAGE is safe in return context end; begin end architecture; nvc-r1.17.1/test/lower/issue125.vhd000066400000000000000000000011121504111170000167240ustar00rootroot00000000000000entity access_bug is end entity; architecture test of access_bug is type integer_access is access integer; type integer_access_access is access integer_access; type integer_access_array is array (natural range <>) of integer_access; type integer_access_array_access is access integer_access_array; procedure bug_procedure is variable arr : integer_access_array_access := null; variable ia : integer_access_access := null; begin ia := new integer_access; -- <-- or here arr := new integer_access_array(0 to 10); -- <--bug here end; begin end architecture; nvc-r1.17.1/test/lower/issue134.vhd000066400000000000000000000003471504111170000167350ustar00rootroot00000000000000entity issue134 is end entity; architecture test of issue134 is function bug_function return string is begin return ""; return ""; -- Used to crash here end function; begin end architecture; nvc-r1.17.1/test/lower/issue135.vhd000066400000000000000000000007511504111170000167350ustar00rootroot00000000000000entity issue135 is end entity; architecture test of issue135 is function bad_performance ( constant a : string; constant b : natural := 0; constant c : character := ','; constant d : time := 0 ns; constant e : string := "i" ) return string is begin return (natural'image(b) & time'image(d) & -- Uncomment this line to increase runtime further c & e & c ); end function; begin end architecture; nvc-r1.17.1/test/lower/issue136.vhd000066400000000000000000000010141504111170000167270ustar00rootroot00000000000000entity cannot_return_safety_check_pkg is end entity; architecture test of cannot_return_safety_check_pkg is type record_t is record element : natural; end record; type record_returner_t is protected impure function return_record return record_t; end protected; type record_returner_t is protected body variable rec : record_t; impure function return_record return record_t is begin return rec; -- Error here end; end protected body; begin end architecture; nvc-r1.17.1/test/lower/issue149.vhd000066400000000000000000000003621504111170000167400ustar00rootroot00000000000000entity issue149 is end entity; architecture test of issue149 is procedure PROC_NG(table: inout bit_vector) is variable i : integer range 0 to table'length-1; begin i := -1; end PROC_NG; begin end architecture; nvc-r1.17.1/test/lower/issue158.vhd000066400000000000000000000007731504111170000167460ustar00rootroot00000000000000package cannot_return_safety_check_pkg is impure function fun return string; end package cannot_return_safety_check_pkg; package body cannot_return_safety_check_pkg is type string_ptr is access string; procedure proc(variable value : inout string_ptr) is begin value := new string'("buggy"); end procedure; impure function fun return string is variable value : string_ptr; begin proc(value); return value.all; -- Could not return safety check end; end package body; nvc-r1.17.1/test/lower/issue164.vhd000066400000000000000000000005471504111170000167420ustar00rootroot00000000000000package issue164 is procedure same_name(variable var : out integer); impure function same_name return integer; end package; package body issue164 is procedure same_name(variable var : out integer) is begin end; impure function same_name return integer is variable var : integer; begin return var; end function; end package body; nvc-r1.17.1/test/lower/issue167.vhd000066400000000000000000000006411504111170000167400ustar00rootroot00000000000000package pkg is type p1 is protected end protected; end package; package body pkg is type p1 is protected body end protected body; end package body; entity e is end entity; use work.pkg.all; architecture a of e is type p2 is protected end protected; type p2 is protected body end protected body; shared variable t : p1; shared variable s : p2; begin end architecture; nvc-r1.17.1/test/lower/issue181.vhd000066400000000000000000000005211504111170000167310ustar00rootroot00000000000000entity issue181 is end entity; architecture a of issue181 is procedure proc is variable str : string(1 to 0); -- Error here variable bitv : bit_vector(1 to 0); -- Works begin -- Index check here should be elided end procedure; begin main : process begin proc; wait; end process; end architecture; nvc-r1.17.1/test/lower/issue203.vhd000066400000000000000000000004311504111170000167240ustar00rootroot00000000000000use std.textio.all; entity issue203 is end entity; architecture a of issue203 is begin main : process procedure proc is begin write(output, string'("hello") & LF); -- Crash here end procedure; begin proc; wait; end process; end architecture; nvc-r1.17.1/test/lower/issue215.vhd000066400000000000000000000014071504111170000167330ustar00rootroot00000000000000entity SUB is port (I:in integer;O:out integer); end SUB; architecture MODEL of SUB is begin process(I) procedure PROC_A(I:in integer;O:out integer) is procedure PROC_B(I:in integer;O:out integer) is begin O := I+1; end procedure; begin PROC_B(I,O); end procedure; variable oo : integer; begin PROC_A(I,oo); O <= oo; end process; end MODEL; entity TOP is end TOP; architecture MODEL of TOP is component SUB is port (I:in integer;O:out integer); end component; signal A_I, A_O : integer; signal B_I, B_O : integer; begin A: SUB port map(I => A_I, O => A_O); B: SUB port map(I => B_I, O => B_O); end MODEL; nvc-r1.17.1/test/lower/issue303.vhd000066400000000000000000000004461504111170000167330ustar00rootroot00000000000000entity TEST_NG is port ( DATA_IN : in bit; DATA_OUT : out bit ); end TEST_NG; architecture MODEL of TEST_NG is procedure wait_on_signals is begin wait on DATA_IN; -- Crash when lowering architecture end procedure; begin end MODEL; nvc-r1.17.1/test/lower/issue324.vhd000066400000000000000000000031451504111170000167350ustar00rootroot00000000000000-- test_ng.vhd entity TEST is generic ( DATA_BITS : integer := 8 ); port ( I_DATA : in bit_vector(8*DATA_BITS-1 downto 0); O_DATA : out bit_vector( DATA_BITS-1 downto 0) ); end TEST; architecture MODEL of TEST is type WORD_VECTOR is array (INTEGER range <>) of bit_vector(DATA_BITS-1 downto 0); function first_word(WORDS: WORD_VECTOR) return bit_vector is alias i_words : WORD_VECTOR(0 to WORDS'length-1) is WORDS; variable result : bit_vector(DATA_BITS-1 downto 0); begin result := i_words(0); return result; end function; begin process (I_DATA) variable in_words : WORD_VECTOR(0 to 7); begin for i in in_words'range loop in_words(i) := I_DATA((i+1)*DATA_BITS-1 downto i*DATA_BITS); end loop; O_DATA <= first_word(in_words); end process; end MODEL; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is component TEST is generic ( DATA_BITS : integer := 8 ); port ( I_DATA : in bit_vector(8*DATA_BITS-1 downto 0); O_DATA : out bit_vector( DATA_BITS-1 downto 0) ); end component; constant DATA_BITS : integer := 8; signal I_DATA : bit_vector(8*DATA_BITS-1 downto 0); signal O_DATA : bit_vector( DATA_BITS-1 downto 0); begin DUT:TEST generic map( DATA_BITS => DATA_BITS ) port map ( I_DATA => I_DATA , O_DATA => O_DATA ); end MODEL; nvc-r1.17.1/test/lower/issue333.vhd000066400000000000000000000006071504111170000167350ustar00rootroot00000000000000entity issue333 is end entity; architecture a of issue333 is type line is access string; procedure proc(l : inout line) is begin report integer'image(l'length); end procedure; begin main : process is variable l : line; begin l := new string'("1"); proc(l); l := new string'("12"); -- Uncomment to make it work wait; end process; end architecture; nvc-r1.17.1/test/lower/issue338.vhd000066400000000000000000000022261504111170000167410ustar00rootroot00000000000000entity e is end entity; package p is function f(x : boolean) return boolean; end package; package body p is function f(x : boolean) return boolean is begin assert false report "do not call this"; return false; end function; end package body; use work.p.all; architecture test of e is function f1(x : boolean) return boolean is begin return x and f(x); end function; function f2(x, y : boolean) return boolean is begin return x and y; end function; function f3(x, y, z : boolean) return boolean is begin return x and (y or z); end function; function f4(x : boolean) return boolean is variable y : boolean; begin y := false; return y and f(x); end function; function f5(x : boolean) return boolean is variable y : boolean; begin y := false; return y nor f(x); end function; function f6(x : boolean) return boolean is begin return x or f(x); end function; function f7(x : boolean) return boolean is begin return x nor f(x); end function; begin end architecture; nvc-r1.17.1/test/lower/issue338b.vhd000066400000000000000000000002551504111170000171030ustar00rootroot00000000000000entity e is end entity; architecture test of e is function f(x : string) return boolean is begin return x = ""; end function; begin end architecture; nvc-r1.17.1/test/lower/issue347.vhd000066400000000000000000000067301504111170000167450ustar00rootroot00000000000000-- test_ng.vhd package my_logic is type std_logic is ('0', '1'); type std_logic_vector is array (natural range <>) of std_logic; type unsigned is array (natural range <>) of std_logic; type signed is array (natural range <>) of std_logic; function to_integer(x : unsigned) return integer; function to_unsigned(x, width : natural) return unsigned; function to_01(x : unsigned) return unsigned; function resize(x : unsigned; width : natural) return unsigned; function "-"(x, y : unsigned) return unsigned; function ">"(x : unsigned; y : integer) return boolean; end package; package body my_logic is function to_integer(x : unsigned) return integer is begin return 0; end function; function to_unsigned(x, width : natural) return unsigned is begin return ""; end function; function to_01(x : unsigned) return unsigned is begin return ""; end function; function resize(x : unsigned; width : natural) return unsigned is begin return ""; end function; function "-"(x, y : unsigned) return unsigned is begin return ""; end function; function ">"(x : unsigned; y : integer) return boolean is begin return false; end function; end package body; use work.my_logic.all; entity TEST_SUB is generic ( SIZE_BITS : integer := 32; COUNT_BITS : integer := 32 ); port ( POOL_SIZE : in std_logic_vector(SIZE_BITS -1 downto 0); READY_SIZE : in std_logic_vector(SIZE_BITS -1 downto 0); COUNT : out std_logic_vector(COUNT_BITS-1 downto 0) ); end TEST_SUB; architecture RTL of TEST_SUB is begin process (POOL_SIZE, READY_SIZE) variable reserve_size : unsigned(SIZE_BITS-1 downto 0); constant MAX_COUNT : integer := 2**(COUNT'high); begin reserve_size := to_01(unsigned(POOL_SIZE)) - to_01(unsigned(READY_SIZE)); if (reserve_size'length > COUNT'length) then if (reserve_size > MAX_COUNT) then COUNT <= std_logic_vector(to_unsigned(MAX_COUNT , COUNT'length)); else COUNT <= std_logic_vector(resize (reserve_size , COUNT'length)); end if; else COUNT <= std_logic_vector(resize (reserve_size , COUNT'length)); end if; end process; end RTL; use work.my_logic.all; entity TEST_NG is end TEST_NG; architecture RTL of TEST_NG is constant SIZE_BITS : integer := 8; constant COUNT_BITS : integer := 8; signal POOL_SIZE : std_logic_vector(SIZE_BITS -1 downto 0); signal READY_SIZE : std_logic_vector(SIZE_BITS -1 downto 0); signal COUNT : std_logic_vector(COUNT_BITS-1 downto 0); component TEST_SUB generic ( SIZE_BITS : integer := 32; COUNT_BITS : integer := 32 ); port ( POOL_SIZE : in std_logic_vector(SIZE_BITS -1 downto 0); READY_SIZE : in std_logic_vector(SIZE_BITS -1 downto 0); COUNT : out std_logic_vector(COUNT_BITS-1 downto 0) ); end component; begin U: TEST_SUB generic map ( SIZE_BITS => SIZE_BITS , COUNT_BITS => COUNT_BITS ) port map ( POOL_SIZE => POOL_SIZE , READY_SIZE => READY_SIZE , -- COUNT => COUNT -- OK when COUNT COUNT => open -- NG when open ); end RTL; nvc-r1.17.1/test/lower/issue351.vhd000066400000000000000000000012461504111170000167350ustar00rootroot00000000000000entity ISSUE351 is end ISSUE351; architecture RTL of ISSUE351 is type WORD_TYPE is record KEY : integer; VALUE : integer; end record; constant WORD_NULL : WORD_TYPE := (KEY => 0, VALUE => 0); type WORD_VECTOR is array (INTEGER range <>) of WORD_TYPE; procedure dump_words(WORDS: in WORD_VECTOR) is begin end procedure; begin p1: process variable curr_queue : WORD_VECTOR(0 to 3); begin loop1: for i in curr_queue'range loop dump_words(curr_queue(i to curr_queue'length-1)); -- Bug? end loop; wait; end process; end RTL; nvc-r1.17.1/test/lower/issue357.vhd000066400000000000000000000006731504111170000167460ustar00rootroot00000000000000entity sub is port ( i : in bit_vector(3 downto 0); o : out bit_vector(3 downto 0) ); end entity; architecture test of sub is begin o(1 downto 0) <= "00"; -- Crash when O not in port map o(3 downto 2) <= i(2 downto 1); end architecture; entity top is end entity; architecture test of top is signal x : bit_vector(3 downto 0); begin sub_i: entity work.sub port map ( x ); end architecture; nvc-r1.17.1/test/lower/issue389.vhd000066400000000000000000000004351504111170000167470ustar00rootroot00000000000000package common is type example_type is record a: bit; b: bit_vector(63 downto 0); c: bit_vector(31 downto 0); end record; constant example_init : example_type := (a => '0', others => (others => '0')); end common; nvc-r1.17.1/test/lower/issue426.vhd000066400000000000000000000012131504111170000167320ustar00rootroot00000000000000package CORE is type STATUS_TYPE is record error_count : integer; end record; end CORE; library WORK; use WORK.CORE.STATUS_TYPE; entity TEST_1 is generic ( EXP_STATUS : STATUS_TYPE ); end TEST_1; architecture MODEL of TEST_1 is begin end MODEL; library WORK; use WORK.CORE.STATUS_TYPE; entity TEST_1_1 is end TEST_1_1; architecture MODEL of TEST_1_1 is constant EXP_STATUS : STATUS_TYPE := (error_count => 0); component TEST_1 generic ( EXP_STATUS : STATUS_TYPE ); end component; begin U: TEST_1 generic map(EXP_STATUS); end MODEL; nvc-r1.17.1/test/lower/issue444.vhd000066400000000000000000000010141504111170000167310ustar00rootroot00000000000000package issue444 is type rec is record x : integer; end record; type rec_array is array (natural range <>) of rec; procedure proc (x : in integer); end package; package body issue444 is procedure proc (x : in integer) is -- This uses a temporary var to initialise the array... variable v : rec_array(1 to x) := (others => (x => x)); -- ...which shouldn't be reused by 'VALUE and 'IMAGE here type t is (FOO, BAR); begin end procedure; end package body; nvc-r1.17.1/test/lower/issue462.vhd000066400000000000000000000004531504111170000167370ustar00rootroot00000000000000entity issue462 is end entity; architecture test of issue462 is type mem_t is array (natural range <>) of bit_vector(0 to 7); signal s : mem_t(1 to 3); function get (m : mem_t; x, y : natural) return bit is begin return m(x)(y); end function; begin end architecture; nvc-r1.17.1/test/lower/issue476.vhd000066400000000000000000000006331504111170000167440ustar00rootroot00000000000000package test_pkg is type t_slv_array is array (natural range <>) of bit_vector; subtype t_word is bit_vector(15 downto 0); subtype t_word_array is t_slv_array(open)(t_word'range); type t_rec is record data : t_word_array(0 to 1); end record; constant C_DEFAULT : t_rec := ( data => (others => (others => '0')) ); end package; nvc-r1.17.1/test/lower/issue478.vhd000066400000000000000000000004651504111170000167510ustar00rootroot00000000000000package test_pkg is type t_slv_array is array (natural range <>) of bit_vector; subtype t_word is bit_vector(15 downto 0); subtype t_word_array is t_slv_array(open)(t_word'range); constant C_NULL_DATA : t_word_array(0 to -1) := (others => (others => '0')); end package; nvc-r1.17.1/test/lower/issue582.vhd000066400000000000000000000006721504111170000167450ustar00rootroot00000000000000entity cover9 is end entity; architecture test of cover9 is type t_mem is array (31 downto 0) of bit_vector(7 downto 0); signal mem : t_mem; signal clk : bit; signal we : bit; signal wdata : bit_vector(7 downto 0); begin mem_gen_row : for row in 0 to 31 generate mem_proc : process(clk) begin mem(row) <= wdata; end process; end generate; end architecture; nvc-r1.17.1/test/lower/issue591.vhd000066400000000000000000000012501504111170000167360ustar00rootroot00000000000000entity test is end entity test; architecture beh of test is type unsigned is array (natural range <>) of bit; begin p1: process variable v_slv_long_min : bit_vector(127 downto 0) := (others => '0'); variable v_slv_long_max : bit_vector(127 downto 0) := (others => '0'); type t_unsigned_vector is array (natural range <>) of unsigned; type t_range_uns_vec is array (natural range <>) of t_unsigned_vector; procedure check_value_long( constant range_vec : in t_range_uns_vec) is begin end procedure; begin check_value_long((0 => (unsigned(v_slv_long_min), unsigned(v_slv_long_max)))); wait; end process; end architecture beh; nvc-r1.17.1/test/lower/issue613.vhd000066400000000000000000000013711504111170000167350ustar00rootroot00000000000000package pack is function get_bits (n : natural) return bit_vector; end package; package body pack is function get_bits (n : natural) return bit_vector is variable result : bit_vector(1 to n); begin return result; end function; end package body; ------------------------------------------------------------------------------- entity sub is port (p, q : bit_vector); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity issue613 is end entity; use work.pack.all; architecture test of issue613 is begin u: entity work.sub port map ( p(1) => '0', q => get_bits(5) ); end architecture; nvc-r1.17.1/test/lower/issue662.vhd000066400000000000000000000011701504111170000167360ustar00rootroot00000000000000package test_pkg is type t1 is record f1 : bit; end record t1; subtype t1_sub is t1; end package; ------------------------------- library work; use work.test_pkg.all; entity test is port ( pin : in t1; pout : out t1_sub ); end entity; architecture test_arch of test is begin pout.f1 <= pin.f1; end architecture; ------------------------------- library work; use work.test_pkg.all; entity sub is end entity; architecture sub_arch of sub is signal a : t1_sub; signal b : t1_sub := (f1 => '0'); begin cmp: entity work.test port map ( pin => b, pout => a ); end architecture; nvc-r1.17.1/test/lower/issue725.vhd000066400000000000000000000005251504111170000167410ustar00rootroot00000000000000package test is type t_slv_array is array (natural range <>) of bit_vector; subtype t_word is bit_vector(15 downto 0); subtype t_word_array is t_slv_array(open)(t_word'range); subtype t_addr is natural range 1 to 30; type t_data is array (t_addr) of t_word_array(0 to 31); -- OK end package test; nvc-r1.17.1/test/lower/issue756.vhd000066400000000000000000000007041504111170000167440ustar00rootroot00000000000000entity issue756 is end entity; architecture test of issue756 is type t_bv_array is array (natural range <>) of bit_vector; type t_bv_array_ptr is access t_bv_array; impure function get_size return integer is begin return 10; end function; begin tb: process is variable ptr : t_bv_array_ptr; begin ptr := new t_bv_array(0 to get_size)(7 downto 0); wait; end process; end architecture; nvc-r1.17.1/test/lower/issue768.vhd000066400000000000000000000010621504111170000167450ustar00rootroot00000000000000package issue768 is type t_slv_arr is array (natural range <>) of bit_vector; --! Array of bit_vector is the primary data type type t_code_word is record word : bit_vector; --! data word code : t_slv_arr; --! code word array end record t_code_word; type t_codec is array(natural range <>) of t_code_word; --! Codec (array of data & code words) constant C_HDLC_CODEC : t_codec(0 to 0)(word(7 downto 0), code(0 to 0)(7 downto 0)) := (0 => (word => x"7e", code => (0 => x"7d"))); end package; nvc-r1.17.1/test/lower/issue791.vhd000066400000000000000000000010001504111170000167310ustar00rootroot00000000000000entity issue791 is end entity; architecture beh of issue791 is type t_slv_array is array (natural range <>) of bit_vector; procedure read_mem is variable v_memory : t_slv_array(0 to 131072-1)(7 downto 0) := (others => x"FF"); variable v_null : t_slv_array(0 to 131072-1)(7 to 0) := (others => x""); variable v_memory2 : t_slv_array(0 to 7)(7 downto 0) := (others => x"FE"); begin end procedure; begin p_proc : process begin read_mem; wait; end process; end architecture; nvc-r1.17.1/test/lower/issue837.vhd000066400000000000000000000014361504111170000167470ustar00rootroot00000000000000package pack is function expensive (x : string) return integer; end package; package body pack is function expensive (x : string) return integer is begin return integer'value(x); end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity issue837 is end entity; architecture test of issue837 is signal x : bit_vector(1 to 12); impure function get_str return string is begin return "12"; end function; constant str : string := get_str; begin b: block is port ( p : in bit_vector(1 to expensive(str)) ); port map ( p => x ); signal s : p'subtype; -- Should not call EXPENSIVE begin end block; end architecture; nvc-r1.17.1/test/lower/issue844.vhd000066400000000000000000000006671504111170000167520ustar00rootroot00000000000000entity sub is generic ( g1 : natural; g2 : natural := g1 ); port ( p : bit_vector(1 to g2) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity issue844 is end entity; architecture test of issue844 is begin u: entity work.sub generic map ( g1 => 4 ) port map ( p => (others => '0') ); end architecture; nvc-r1.17.1/test/lower/issue859.vhd000066400000000000000000000050231504111170000167470ustar00rootroot00000000000000package model_pkg is type t_axilite_rd_slave_in_if is record araddr : bit_vector; arvalid : bit; rready : bit; end record; end package model_pkg; use work.model_pkg.all; entity model is port( rd_port_in : in t_axilite_rd_slave_in_if(araddr(31 downto 0)) ); end entity model; architecture beh of model is begin end architecture beh; entity issue859 is end entity; architecture tb of issue859 is -- AXI-Lite Interface signals type t_axilite_write_address_channel is record --DUT inputs awaddr : bit_vector; awvalid : bit; awprot : bit_vector(2 downto 0); --DUT outputs awready : bit; end record; type t_axilite_write_data_channel is record --DUT inputs wdata : bit_vector; wstrb : bit_vector; wvalid : bit; --DUT outputs wready : bit; end record; type t_axilite_write_response_channel is record --DUT inputs bready : bit; --DUT outputs bresp : bit_vector(1 downto 0); bvalid : bit; end record; type t_axilite_read_address_channel is record --DUT inputs araddr : bit_vector; arvalid : bit; arprot : bit_vector(2 downto 0); --DUT outputs arready : bit; end record; type t_axilite_read_data_channel is record --DUT inputs rready : bit; --DUT outputs rdata : bit_vector; rresp : bit_vector(1 downto 0); rvalid : bit; end record; type t_axilite_if is record write_address_channel : t_axilite_write_address_channel; write_data_channel : t_axilite_write_data_channel; write_response_channel : t_axilite_write_response_channel; read_address_channel : t_axilite_read_address_channel; read_data_channel : t_axilite_read_data_channel; end record; constant C_ADDR_WIDTH_2 : natural := 32; constant C_DATA_WIDTH_2 : natural := 64; signal axilite_if_2 : t_axilite_if(write_address_channel(awaddr(31 downto 0)), write_data_channel(wdata(63 downto 0), wstrb(7 downto 0)), read_address_channel(araddr(31 downto 0)), read_data_channel(rdata(63 downto 0))); begin i_model : entity work.model port map( rd_port_in.araddr => axilite_if_2.read_address_channel.araddr, rd_port_in.arvalid => axilite_if_2.read_address_channel.arvalid, rd_port_in.rready => axilite_if_2.read_data_channel.rready ); p_main: process begin wait; end process p_main; end architecture; nvc-r1.17.1/test/lower/issue934.vhd000066400000000000000000000005221504111170000167400ustar00rootroot00000000000000entity issue934 is end entity; architecture test of issue934 is type t_slv_array is array (natural range <>) of bit_vector; procedure proc (x : t_slv_array) is begin end procedure; begin check: process is begin proc(x => t_slv_array'((x"01", x"02"))); wait; end process; end architecture; nvc-r1.17.1/test/lower/issue94.vhd000066400000000000000000000007471504111170000166660ustar00rootroot00000000000000entity issue94 is end entity; architecture test of issue94 is function func (dataw : integer; shiftw : integer) return bit_vector is constant max_shift : integer := shiftw; type bit_vector_array is array (natural range <>) of bit_vector(dataw-1 downto 0); variable y_temp : bit_vector_array (0 to max_shift); begin y_temp(0):=(others=>'1'); -- Error with LLVM asserts build return y_temp(0); end func; begin end architecture; nvc-r1.17.1/test/lower/issue972.vhd000066400000000000000000000004631504111170000167460ustar00rootroot00000000000000entity issue972 is end entity; architecture test of issue972 is type t_rec is record f : integer; end record; begin b: block is generic ( r : t_rec ); generic map ( r => (f => 5) ); signal s : integer range 1 to r.f; begin end block; end architecture; nvc-r1.17.1/test/lower/link1.vhd000066400000000000000000000010751504111170000163720ustar00rootroot00000000000000package pack is constant k : string; end package; package body pack is constant k : string := "hello, world"; end package body; ------------------------------------------------------------------------------- entity sub is end entity; architecture test of sub is constant c : integer := work.pack.k'length; begin end architecture; ------------------------------------------------------------------------------- entity link1 is end entity; architecture test of link1 is component sub is end component; begin u: component sub; end architecture; nvc-r1.17.1/test/lower/loop1.vhd000066400000000000000000000006311504111170000164030ustar00rootroot00000000000000entity loop1 is end entity; architecture test of loop1 is begin p1: process is variable a, b : integer; begin loop exit when a = 10; a := a + 1; end loop; loop a := a + 1; next when (a mod 2) = 0; b := b + 1; exit when b = 10; end loop; wait; end process; end architecture; nvc-r1.17.1/test/lower/loop2.vhd000066400000000000000000000003741504111170000164100ustar00rootroot00000000000000entity loop2 is end entity; architecture test of loop2 is procedure p3(t : in time) is begin loop if t >= 1 ps then return; end if; end loop; end procedure; begin end architecture; nvc-r1.17.1/test/lower/memset.vhd000066400000000000000000000007101504111170000166410ustar00rootroot00000000000000entity memset is end entity; architecture test of memset is type int_vector is array (integer range <>) of integer; function foo(x : positive) return bit_vector is variable v : bit_vector(1 to x); begin return v; end function; function bar(x : positive) return int_vector is variable v : int_vector(1 to x) := (others => 16#abababab#); begin return v; end function; begin end architecture; nvc-r1.17.1/test/lower/mulphys.vhd000066400000000000000000000003011504111170000170440ustar00rootroot00000000000000entity mulphys is end entity; architecture test of mulphys is function multime(x : in integer) return time is begin return x * ns; end function; begin end architecture; nvc-r1.17.1/test/lower/nest1.vhd000066400000000000000000000010051504111170000163770ustar00rootroot00000000000000entity nest1 is end entity; architecture test of nest1 is begin line_7: process is variable x : integer := 2; variable y : bit_vector(7 downto 0); impure function add_to_x(y : integer) return integer is impure function do_it return integer is begin return x + y; end function; begin return do_it; end function; begin assert add_to_x(5) = 7; wait; end process; end architecture; nvc-r1.17.1/test/lower/nullarray.vhd000066400000000000000000000007701504111170000173660ustar00rootroot00000000000000entity nullarray is end entity; architecture test of nullarray is subtype null_range_type is integer range 1 to -1; type rec is record x, y : integer; z : bit_vector(1 to 3); end record; type rec_array is array (natural range <>) of rec; function get_bits return bit_vector is begin return "010"; end function; constant A : bit_vector := get_bits; constant B : rec_array(null_range_type) := (others => (0, 1, A)); begin end architecture; nvc-r1.17.1/test/lower/osvvm2.vhd000066400000000000000000000007601504111170000166100ustar00rootroot00000000000000entity osvvm2 is end entity; architecture test of osvvm2 is type line is access string; type FieldNameArrayType is array (natural range <>) of Line ; procedure test (Dimensions : in natural) is variable FieldNameArray : FieldNameArrayType(1 to 20); type PtrType is access FieldNameArrayType; variable FieldName : PtrType; begin FieldName := new FieldNameArrayType'(FieldNameArray(1 to Dimensions)); end procedure; begin end architecture; nvc-r1.17.1/test/lower/osvvm3.vhd000066400000000000000000000011151504111170000166040ustar00rootroot00000000000000entity osvvm3 is end entity; architecture test of osvvm3 is type t_rec is record f : integer; end record; type t_rec_array is array (natural range <>) of t_rec; signal s : t_rec_array(1 to 3); begin b1: block is port ( x : t_rec_array ); port map ( s ); procedure proc (signal a : t_rec_array) is begin end procedure; signal t : t_rec_array(1 to x'length); begin p1: process (x) is begin proc(x); proc(t); end process; end block; end architecture; nvc-r1.17.1/test/lower/pack1.vhd000066400000000000000000000003411504111170000163460ustar00rootroot00000000000000package pack1 is function add1(x : in integer) return integer; end package; package body pack1 is function add1(x : in integer) return integer is begin return x + 1; end function; end package body; nvc-r1.17.1/test/lower/predef1.vhd000066400000000000000000000014601504111170000167000ustar00rootroot00000000000000entity sub is end entity; architecture test of sub is begin b1: block is type t_rec is record x, y : integer; end record; begin p1: process is variable v : t_rec; begin assert v = (1, 2); wait; end process; end block; end architecture; ------------------------------------------------------------------------------- entity predef1 is end entity; architecture test of predef1 is function f (a_width, b_width, depth : integer) return integer is type a is array (0 to depth - 1) of bit_vector(a_width + b_width - 1 downto 0); begin return 0; end function; begin u1: entity work.sub; u2: entity work.sub; -- Only one "=" predef generated end architecture; nvc-r1.17.1/test/lower/proc1.vhd000066400000000000000000000005601504111170000163760ustar00rootroot00000000000000entity proc1 is end entity; architecture test of proc1 is procedure add1(x : in integer; y : out integer) is begin y := x + 1; end procedure; begin p1: process is variable a, b : integer; begin add1(a, b); assert b = 3; add1(5, b); assert b = 6; wait; end process; end architecture; nvc-r1.17.1/test/lower/proc3.vhd000066400000000000000000000005011504111170000163730ustar00rootroot00000000000000entity proc3 is end entity; architecture test of proc3 is procedure p1(x : out integer) is begin wait for 10 ns; x := 1; wait for 5 ns; end procedure; begin p2: process is variable x : integer; begin p1(x); wait; end process; end architecture; nvc-r1.17.1/test/lower/proc4.vhd000066400000000000000000000010671504111170000164040ustar00rootroot00000000000000package pack is procedure does_not_wait; attribute never_waits : boolean; attribute never_waits of does_not_wait : procedure is true; end package; package body pack is procedure does_not_wait is begin end procedure; end package body; ------------------------------------------------------------------------------- entity proc4 is end entity; use work.pack.all; architecture test of proc4 is begin p1: process is begin does_not_wait; -- Should use fcall wait; end process; end architecture; nvc-r1.17.1/test/lower/proc7.vhd000066400000000000000000000003301504111170000163770ustar00rootroot00000000000000entity proc7 is end entity; architecture test of proc7 is procedure foo(x : bit_vector) is variable y : bit_vector(x'range); begin wait for 1 ns; end procedure; begin end architecture; nvc-r1.17.1/test/lower/protpcall.vhd000066400000000000000000000014441504111170000173540ustar00rootroot00000000000000entity protected11 is end entity; architecture test of protected11 is procedure do_something; type pt is protected procedure proc; end protected; type pt is protected body variable count : natural; procedure proc(arg : integer); procedure proc is begin count := count + 1; assert count = 1; proc(5); assert count = 2; end procedure; procedure proc(arg : integer) is begin count := count + 1; do_something; end procedure; end protected body; procedure do_something is begin end procedure; shared variable v : pt; begin tb: process is begin v.proc; wait; end process; end architecture; nvc-r1.17.1/test/lower/protupref.vhd000066400000000000000000000053251504111170000174040ustar00rootroot00000000000000package AlertLogPkg is -- type AlertLogIDType is range integer'low to integer'high ; -- next revision subtype AlertLogIDType is integer ; type AlertLogIDVectorType is array (integer range <>) of AlertLogIDType ; type AlertType is (FAILURE, ERROR, WARNING) ; -- NEVER subtype AlertIndexType is AlertType range FAILURE to WARNING ; type AlertCountType is array (AlertIndexType) of integer ; type AlertEnableType is array(AlertIndexType) of boolean ; type LogType is (ALWAYS, DEBUG, FINAL, INFO, PASSED) ; -- NEVER -- See function IsLogEnableType subtype LogIndexType is LogType range DEBUG to PASSED ; type LogEnableType is array (LogIndexType) of boolean ; type AlertLogStructPType is protected ------------------------------------------------------------ procedure alert ( ------------------------------------------------------------ AlertLogID : AlertLogIDType ; message : string ; level : AlertType := ERROR ) ; end protected AlertLogStructPType ; end AlertLogPkg ; --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// package body AlertLogPkg is -- synthesis translate_off -- instead of justify(to_upper(to_string())), just look up the upper case, left justified values type AlertNameType is array(AlertType) of string(1 to 7) ; constant ALERT_NAME : AlertNameType := (WARNING => "WARNING", ERROR => "ERROR ", FAILURE => "FAILURE") ; -- , NEVER => "NEVER " --- /////////////////////////////////////////////////////////////////////////// type AlertLogStructPType is protected body ------------------------------------------------------------ -- Report formatting settings, with defaults variable PrintPassedVar : boolean := TRUE ; variable PrintAffirmationsVar : boolean := FALSE ; variable PrintDisabledAlertsVar : boolean := FALSE ; variable PrintRequirementsVar : boolean := FALSE ; variable HasRequirementsVar : boolean := FALSE ; variable PrintIfHaveRequirementsVar : boolean := TRUE ; variable DefaultPassedGoalVar : integer := 1 ; ------------------------------------------------------------ procedure alert ( ------------------------------------------------------------ AlertLogID : AlertLogIDType ; message : string ; level : AlertType := ERROR ) is begin report ALERT_NAME(Level); -- Lower crash here end procedure alert ; end protected body AlertLogStructPType ; -- synthesis translate_on end package body AlertLogPkg ; nvc-r1.17.1/test/lower/real1.vhd000066400000000000000000000005711504111170000163600ustar00rootroot00000000000000entity real1 is end entity; architecture test of real1 is function get_neg(x : real) return real is variable r : real; begin r := -x; return r; end function; function cast_mul(x : integer) return real is variable z : integer; begin z := x; return real(z) * 0.5; end function; begin end architecture; nvc-r1.17.1/test/lower/record1.vhd000066400000000000000000000005431504111170000167120ustar00rootroot00000000000000entity record1 is end entity; architecture test of record1 is type r1 is record x, y : integer; end record; begin p1: process is variable a, b : r1 := (1, 2); begin assert a.x = 1; a.x := 5; a := b; assert a.x = 1; assert a = b; wait; end process; end architecture; nvc-r1.17.1/test/lower/record2.vhd000066400000000000000000000011031504111170000167040ustar00rootroot00000000000000entity record2 is end entity; architecture test of record2 is type r1 is record x, y : integer; end record; type r1_ptr is access r1; begin p1: process is variable r : r1; variable x : integer; begin r := (x, x); wait; end process; p2: process is variable r : r1_ptr; begin r := new r1; wait; end process; p3: process is variable r : r1_ptr; variable x : integer; begin r := new r1'(x, x); wait; end process; end architecture; nvc-r1.17.1/test/lower/record6.vhd000066400000000000000000000005521504111170000167170ustar00rootroot00000000000000entity record6 is end entity; architecture test of record6 is type rec is record x : bit_vector(1 to 3); y : integer; end record; function make_rec(x : bit_vector(1 to 3); y : integer) return rec is variable r : rec; begin r.x := x; r.y := y; return r; end function; begin end architecture; nvc-r1.17.1/test/lower/recsignal1.vhd000066400000000000000000000003061504111170000174000ustar00rootroot00000000000000entity recsignal1 is end entity; architecture test of recsignal1 is type rec is record x, y : integer; end record; signal p, q : rec; begin p1: p <= q; end architecture; nvc-r1.17.1/test/lower/resfn1.vhd000066400000000000000000000003671504111170000165550ustar00rootroot00000000000000entity resfn1 is end entity; architecture test of resfn1 is function resolved(v : bit_vector) return bit is begin return '1'; end function; subtype rbit is resolved bit; signal x, y : rbit; begin end architecture; nvc-r1.17.1/test/lower/sig2var.vhd000066400000000000000000000005601504111170000167270ustar00rootroot00000000000000entity sig2var is end entity; architecture test of sig2var is function foo(signal x : bit_vector) return bit_vector is variable v : bit_vector(1 to 8) := x; begin return v; end function; function bar(signal x : bit) return bit is variable v : bit := x; begin return v; end function; begin end architecture; nvc-r1.17.1/test/lower/signal1.vhd000066400000000000000000000003301504111170000167030ustar00rootroot00000000000000entity signal1 is end entity; architecture test of signal1 is signal x : integer := 5; begin p1: process is begin assert x = 5; x <= 6; wait; end process; end architecture; nvc-r1.17.1/test/lower/signal11.vhd000066400000000000000000000020171504111170000167700ustar00rootroot00000000000000package pack is signal x : integer := 0; procedure inc(signal s : out integer); end package; package body pack is procedure inc(signal s : out integer) is begin s <= x + 1; end procedure; procedure bar(signal s : in integer) is begin end procedure; procedure foo is begin bar(x); end procedure; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is end entity; architecture test of sub is begin process is begin report x'path_name; report x'instance_name; wait; end process; end architecture; ------------------------------------------------------------------------------- entity signal11 is end entity; use work.pack.all; architecture test of signal11 is begin process is begin assert x = 0; inc(x); wait for 1 ns; assert x = 1; wait; end process; sub_i: entity work.sub; end architecture; nvc-r1.17.1/test/lower/signal2.vhd000066400000000000000000000003411504111170000167060ustar00rootroot00000000000000entity signal2 is end entity; architecture test of signal2 is signal x : bit := '0'; begin p1: process is begin assert x'event; assert x'active; wait; end process; end architecture; nvc-r1.17.1/test/lower/signal4.vhd000066400000000000000000000005171504111170000167150ustar00rootroot00000000000000entity signal4 is end entity; architecture test of signal4 is signal s : bit_vector(3 downto 0) := (1 => '1', others => '0'); begin p1: process is variable v : bit_vector(3 downto 0) := (others => '1'); begin v(2) := s(3); s <= v; v := s; wait; end process; end architecture; nvc-r1.17.1/test/lower/signal5.vhd000066400000000000000000000004211504111170000167100ustar00rootroot00000000000000entity signal5 is end entity; architecture test of signal5 is signal s : bit; begin p1: process is begin -- Should only have one drive signal call s <= '1'; s <= '0'; s <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/lower/sigvar.vhd000066400000000000000000000007271504111170000166520ustar00rootroot00000000000000entity sigvar is end entity; architecture test of sigvar is procedure proc1(signal x : bit_vector) is variable y : bit_vector(x'range); begin y := x; end procedure; procedure proc2(signal x : out bit_vector; signal y : in bit_vector) is begin x <= y; end procedure; procedure proc3(signal x : out bit_vector; signal y : in bit_vector) is begin x <= y & "1"; end procedure; begin end architecture; nvc-r1.17.1/test/lower/slice1.vhd000066400000000000000000000012431504111170000165310ustar00rootroot00000000000000entity slice1 is end entity; architecture test of slice1 is type int_vector is array (integer range <>) of integer; signal x : int_vector(0 to 3); begin p1: process is variable u : int_vector(5 downto 2); variable v : int_vector(0 to 3); begin v := ( 1, 2, 3, 4 ); v(1 to 2) := ( 6, 7 ); assert v(2 to 3) = ( 7, 4 ); wait for 1 ns; x <= ( 1, 2, 3, 4 ); x(1 to 2) <= ( 6, 7 ); assert x(2 to 3) = ( 7, 4 ); wait for 1 ns; u := ( 1, 2, 3, 4); u(4 downto 3) := ( 6, 7 ); assert u(3 downto 2) = ( 7, 4 ); wait; end process; end architecture; nvc-r1.17.1/test/lower/staticwait.vhd000066400000000000000000000002711504111170000175250ustar00rootroot00000000000000entity staticwait is end entity; architecture test of staticwait is signal x : integer; begin p1: process (x) is begin x <= 0; end process; end architecture; nvc-r1.17.1/test/lower/subtype1.vhd000066400000000000000000000006011504111170000171220ustar00rootroot00000000000000entity subtype1 is end entity; architecture test of subtype1 is function get_bv (r : natural) return bit_vector is subtype t_result is bit_vector(1 to r); function helper return bit_vector is variable x : t_result; begin return x; end function; begin return helper; end function; begin end architecture; nvc-r1.17.1/test/lower/subtype2.vhd000066400000000000000000000026241504111170000171320ustar00rootroot00000000000000package pack1 is function expensive(x : integer) return integer; end package; package body pack1 is function expensive(x : integer) return integer is begin return x; end function; end package body; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is subtype t_sub1 is bit_vector(1 to expensive(5)); type t_rec is record f : t_sub1; end record; type t_nest1 is array (natural range <>) of t_sub1; subtype t_integer is integer range 0 to expensive(5); subtype t_real is real range 0.0 to real(expensive(99)); end package; ------------------------------------------------------------------------------- entity subtype2 is end entity; use work.pack2.all; architecture test of subtype2 is begin b1: block is port ( p : in t_sub1 ); port map ( "10101" ); begin end block; -- b2: block is -- port ( p : in t_rec ); -- port map ( ( f => "10101" ) ); -- begin -- end block; p1: process is variable a : t_nest1(1 to 3); begin a(1) := "101"; wait; end process; p2: process is variable x : t_integer; begin x := 5; wait; end process; -- p3: process is -- variable x : t_real; -- begin -- x := 5.0; -- wait; -- end process; end architecture; nvc-r1.17.1/test/lower/sum.vhd000066400000000000000000000006441504111170000161610ustar00rootroot00000000000000package sumpkg is type int_vector is array (natural range <>) of integer; function sum(a : int_vector) return integer; end package; package body sumpkg is function sum(a : int_vector) return integer is variable result : integer := 0; begin sumloop: for i in a'range loop result := result + a(i); end loop; return result; end function; end package body; nvc-r1.17.1/test/lower/synopsys1.vhd000066400000000000000000000016041504111170000173420ustar00rootroot00000000000000package synopsys1 is type std_ulogic_vector is array (natural range <>) of bit; type line is access string; type side is (left, right); subtype width is natural; procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0); end package; package body synopsys1 is type char_indexed_by_MVL9 is array (bit) of character; constant MVL9_to_char: char_indexed_by_MVL9 := "01"; procedure WRITE(L:inout LINE; VALUE:in STD_ULOGIC_VECTOR; JUSTIFIED:in SIDE := RIGHT; FIELD:in WIDTH := 0) is variable s: string(1 to value'length); variable m: STD_ULOGIC_VECTOR(1 to value'length) := value; begin for i in 1 to value'length loop s(i) := MVL9_to_char(m(i)); end loop; --write(l, s, justified, field); end WRITE; end package body; nvc-r1.17.1/test/lower/tag.vhd000066400000000000000000000007771504111170000161370ustar00rootroot00000000000000package p is signal s : bit; end package; entity sub is port ( i : in bit ); end entity; architecture test of sub is begin assert i'last_value = '1'; end architecture; entity tag is end entity; use work.p.all; architecture test of tag is signal p, x, y : bit; begin process (x) is begin assert x'last_value = '1'; end process; process (p) is begin assert p = '1'; end process; sub_i: entity work.sub port map ( y ); end architecture; nvc-r1.17.1/test/lower/thunk.vhd000066400000000000000000000006211504111170000165010ustar00rootroot00000000000000package pack is type rec is record x, y : integer; end record; type rec_vec is array (integer range <>) of rec; constant c : bit_vector(3 downto 0) := X"f"; constant d : rec_vec(1 to 2); end package; entity top is end entity; use work.pack.all; architecture test of top is signal x : bit := not c(1); signal y : integer := d(1).x + 1; begin end architecture; nvc-r1.17.1/test/lower/tounsigned.vhd000066400000000000000000000011231504111170000175250ustar00rootroot00000000000000package p is type UNSIGNED is array (NATURAL range <>) of bit; function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED; end package; package body p is function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED is variable RESULT: UNSIGNED(SIZE-1 downto 0); variable I_VAL: NATURAL := ARG; begin mainloop: for I in 0 to RESULT'LEFT loop if (I_VAL mod 2) = 0 then -- Mod should be replaced with rem RESULT(I) := '0'; else RESULT(I) := '1'; end if; I_VAL := I_VAL/2; end loop; return RESULT; end TO_UNSIGNED; end package body; nvc-r1.17.1/test/lower/transfer1.vhd000066400000000000000000000013431504111170000172570ustar00rootroot00000000000000entity transfer1 is end entity; architecture test of transfer1 is signal a, b, c : integer; signal d, e, f : bit_vector(1 to 3); begin p1: a <= b; p2: d(1 to 2) <= e(2 to 3); p3: process (f) is begin e <= d; end process; p4: d(1) <= reject 2 ns inertial e(2) after 5 ns; issue765: block is type a_rec is record b : bit_vector(1 downto 0); c : bit_vector(7 downto 0); end record a_rec; type a_rec_vect is array (integer range <>) of a_rec; signal s1 : a_rec_vect(1 downto 0); signal s2 : a_rec_vect(1 downto 0); begin p1: s2(1 downto 0) <= s1(1 downto 0); p2: s1 <= s2; end block; end architecture; nvc-r1.17.1/test/lower/trigger1.vhd000066400000000000000000000015771504111170000171070ustar00rootroot00000000000000entity trigger1 is end entity; architecture test of trigger1 is function rising (signal x : bit) return boolean is begin return x'event and x = '1'; end function; function bad (x : bit) return boolean is begin return x = '1'; end function; signal clk, x, y, z, rstn : bit; begin p1: process (clk) is begin if rising(clk) then x <= not x; end if; end process; p2: process (clk) is begin if bad(clk) then x <= not x; end if; end process; p3: process (rstn, clk) is begin if rstn = '0' then y <= '0'; elsif rising(clk) then y <= not y; end if; end process; p4: process (clk) is begin if clk'event and clk = '1' then z <= not z; end if; end process; end architecture; nvc-r1.17.1/test/lower/vital1.vhd000066400000000000000000000012401504111170000165460ustar00rootroot00000000000000package vital_timing is PROCEDURE VitalSetupHoldCheck ( SIGNAL TestSignal : IN bit_vector ); end package; PACKAGE BODY VITAL_Timing IS type line is access string; procedure proc (variable x : line; i : integer) is begin wait for 1 ns; end procedure; --------------------------------------------------------------------------- PROCEDURE VitalSetupHoldCheck ( SIGNAL TestSignal : IN bit_vector ) IS VARIABLE StrPtr1 : LINE; BEGIN l1: FOR i IN TestSignal'RANGE LOOP proc (StrPtr1, i); END LOOP; END VitalSetupHoldCheck; END VITAL_Timing; nvc-r1.17.1/test/lower/vital2.vhd000066400000000000000000000025771504111170000165650ustar00rootroot00000000000000package vital_timing is -- Types for fields of VitalTimingDataType TYPE VitalTimeArrayT IS ARRAY (INTEGER RANGE <>) OF TIME; TYPE VitalTimeArrayPT IS ACCESS VitalTimeArrayT; TYPE VitalBoolArrayT IS ARRAY (INTEGER RANGE <>) OF BOOLEAN; TYPE VitalBoolArrayPT IS ACCESS VitalBoolArrayT; TYPE VitalLogicArrayPT IS ACCESS bit_vector; TYPE VitalTimingDataType IS RECORD NotFirstFlag : BOOLEAN; RefTime : TIME; HoldEn : BOOLEAN; TestLast : bit; TestTime : TIME; SetupEn : BOOLEAN; TestLastA : VitalLogicArrayPT; TestTimeA : VitalTimeArrayPT; HoldEnA : VitalBoolArrayPT; SetupEnA : VitalBoolArrayPT; END RECORD; PROCEDURE VitalSetupHoldCheck ( VARIABLE TimingData : INOUT VitalTimingDataType; SIGNAL TestSignal : IN bit_vector; CONSTANT EnableHoldOnRef : IN BOOLEAN := TRUE --IR252 3/23/98 ); end package; PACKAGE BODY VITAL_Timing IS PROCEDURE VitalSetupHoldCheck ( VARIABLE TimingData : INOUT VitalTimingDataType; SIGNAL TestSignal : IN bit_vector; CONSTANT EnableHoldOnRef : IN BOOLEAN := TRUE --IR252 3/23/98 ) IS BEGIN TimingData.HoldEnA.all := (TestSignal'RANGE => EnableHoldOnRef); --IR252 3/23/98 END VitalSetupHoldCheck; END VITAL_Timing; nvc-r1.17.1/test/lower/vunit1.vhd000066400000000000000000000047461504111170000166120ustar00rootroot00000000000000package string_ptr_pkg is subtype index_t is integer range -1 to integer'high; subtype byte_t is integer range 0 to 255; type storage_mode_t is (internal, extfnc, extacc); type string_access_t is access string; type string_access_vector_t is array (natural range <>) of string_access_t; type string_access_vector_access_t is access string_access_vector_t; type extstring_access_t is access string(1 to integer'high); type extstring_access_vector_t is array (natural range <>) of extstring_access_t; type extstring_access_vector_access_t is access extstring_access_vector_t; type string_ptr_t is record ref : index_t; end record; constant null_string_ptr : string_ptr_t := (ref => -1); alias ptr_t is string_ptr_t; alias val_t is character; alias vec_t is string; alias vav_t is string_access_vector_t; alias evav_t is extstring_access_vector_t; alias vava_t is string_access_vector_access_t; alias evava_t is extstring_access_vector_access_t; procedure set ( ptr : ptr_t; index : positive; value : val_t ); end package; package body string_ptr_pkg is type prot_storage_t is protected procedure set ( ref : natural; index : positive; value : val_t ); end protected; type prot_storage_t is protected body type storage_t is record id : integer; mode : storage_mode_t; length : integer; end record; constant null_storage : storage_t := (integer'low, internal, integer'low); type storage_vector_t is array (natural range <>) of storage_t; type storage_vector_access_t is access storage_vector_t; type ptr_storage is record idx : natural; ptr : natural; eptr : natural; idxs : storage_vector_access_t; ptrs : vava_t; eptrs : evava_t; end record; variable st : ptr_storage := (0, 0, 0, null, null, null); procedure set ( ref : natural; index : positive; value : val_t ) is variable s : storage_t := st.idxs(ref); begin case s.mode is when extfnc => null;--write_char(s.id, index-1, value); when extacc => st.eptrs(s.id)(index) := value; when internal => st.ptrs(s.id)(index) := value; end case; end; end protected body; shared variable vec_ptr_storage : prot_storage_t; procedure set ( ptr : ptr_t; index : positive; value : val_t ) is begin vec_ptr_storage.set(ptr.ref, index, value); end; end package body; nvc-r1.17.1/test/lower/vunit2.vhd000066400000000000000000000006201504111170000165760ustar00rootroot00000000000000package vunit2 is type int_ptr is access integer; type array_of_access is array (natural range <>) of int_ptr; impure function get_one (idx : natural) return int_ptr; end package; package body vunit2 is shared variable a : array_of_access(1 to 5); impure function get_one (idx : natural) return int_ptr is begin return a(idx); end function; end package body; nvc-r1.17.1/test/lower/vunit3.vhd000066400000000000000000000005611504111170000166030ustar00rootroot00000000000000package vunit3 is type rec; type rec_ptr is access rec; impure function alloc_reg return rec_ptr; end package; package body vunit3 is type rec is record x : integer; end record; impure function alloc_reg return rec_ptr is begin return new rec; -- Crash lowering here end function; end package body; nvc-r1.17.1/test/lower/vunit4.vhd000066400000000000000000000007201504111170000166010ustar00rootroot00000000000000package vunit4 is type rec; type int_ptr is access integer; type rec is record x : int_ptr; end record; impure function get_rec(n : natural) return rec; end package; package body vunit4 is type int_ptr_vec is array (natural range <>) of int_ptr; shared variable v : int_ptr_vec(1 to 5); impure function get_rec(n : natural) return rec is begin return rec'(x => v(n)); end function; end package body; nvc-r1.17.1/test/lower/vunit5.vhd000066400000000000000000000004411504111170000166020ustar00rootroot00000000000000entity vunit5 is end entity; architecture test of vunit5 is type rec is record f : bit_vector; end record; procedure proc (f : bit_vector) is variable r : rec(f(f'length - 1 downto 0)); begin r.f := f; end procedure; begin end architecture; nvc-r1.17.1/test/lower/wait1.vhd000066400000000000000000000005271504111170000164020ustar00rootroot00000000000000-- A very basic sanity test of wait statements entity wait1 is end entity; architecture test of wait1 is begin p1: process is begin assert now = 0 ns; wait_1: wait for 1 ns; assert now = 1 ns; wait for 1 fs; assert now = 1000001 fs; end_wait: wait; end process; end architecture; nvc-r1.17.1/test/lower/wait2.vhd000066400000000000000000000004151504111170000163770ustar00rootroot00000000000000entity wait2 is end entity; architecture test of wait2 is type rec is record x, y : bit; end record; signal r : rec; begin p1: process is begin wait until r.x = '1' and r.x'event; wait; end process; end architecture; nvc-r1.17.1/test/lower/while1.vhd000066400000000000000000000003711504111170000165430ustar00rootroot00000000000000entity while1 is end entity; architecture test of while1 is begin p1: process is variable n : integer := 5; begin while n > 0 loop n := n - 1; end loop; wait; end process; end architecture; nvc-r1.17.1/test/misc/000077500000000000000000000000001504111170000144515ustar00rootroot00000000000000nvc-r1.17.1/test/misc/bufr_test.vhd000066400000000000000000000017111504111170000171510ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; library unisim; use unisim.vcomponents.all; entity bufr_test is end entity; architecture test of bufr_test is component BUFR generic ( BUFR_DIVIDE : string := "BYPASS"; SIM_DEVICE : string := "7SERIES"); port ( O : out STD_LOGIC; CE : in STD_LOGIC; CLR : in STD_LOGIC; I : in STD_LOGIC); end component; attribute BOX_TYPE of BUFR : component is "PRIMITIVE"; signal amu_adc_dco_i : std_logic; signal amu_adc_dco : std_logic; begin BUF_DATA_CLK : BUFR generic map ( BUFR_DIVIDE => "BYPASS", SIM_DEVICE => "7SERIES") port map ( O => amu_adc_dco, CE => '1', CLR => '0', I => amu_adc_dco_i); end architecture; nvc-r1.17.1/test/misc/elide.vhd000066400000000000000000000006621504111170000162420ustar00rootroot00000000000000package elide is end package; package body elide is function func1(x : bit_vector) return bit_vector is alias a : bit_vector(x'length - 1 downto 0) is x; variable r : bit_vector(x'length - 1 downto 0); begin for i in r'range loop -- The bounds check for r(i) here should be optimised away r(i) := a(i); end loop; return r; end function; end package body; nvc-r1.17.1/test/misc/kcuart.vhd000066400000000000000000000013241504111170000164450ustar00rootroot00000000000000entity kcuart is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of kcuart is signal clk : std_logic := '0'; signal tx_data : std_logic_vector(7 downto 0); signal tx_full : std_logic; signal tx_wr : std_logic := '0'; signal uart_tx : std_logic; signal en_16_x_baud : std_logic; begin clk <= not clk after 5 ns; tx_i: entity work.uart_tx6 port map ( data_in => tx_data, en_16_x_baud => en_16_x_baud, serial_out => uart_tx, buffer_write => tx_wr, buffer_full => tx_full, buffer_reset => '0', clk => clk ); end architecture; nvc-r1.17.1/test/misc/lut4_test.vhd000066400000000000000000000013161504111170000171040ustar00rootroot00000000000000entity lut4_test is end entity; library unisim; use unisim.vcomponents.all; library ieee; use ieee.std_logic_1164.all; architecture test of lut4_test is signal i : std_logic_vector(3 downto 0); signal o : std_logic; begin uut: LUT4 generic map ( INIT => X"8001" ) port map ( o => o, i0 => i(0), i1 => i(1), i2 => i(2), i3 => i(3) ); process is begin i <= "0000"; wait for 1 ns; assert o = '1'; i <= "0001"; wait for 1 ns; assert o = '0'; i <= "1111"; wait for 1 ns; assert o = '1'; wait; end process; end architecture; nvc-r1.17.1/test/misc/ramb_test.vhd000066400000000000000000000261451504111170000171440ustar00rootroot00000000000000entity ramb_test is end entity; library ieee; use ieee.std_logic_1164.all; library unisim; use unisim.vcomponents.all; architecture test of ramb_test is signal doa : std_logic_vector(31 downto 0); signal dopa : std_logic_vector(3 downto 0); signal dob : std_logic_vector(31 downto 0); signal dopb : std_logic_vector(3 downto 0); signal addra : std_logic_vector(13 downto 0); signal addrb : std_logic_vector(13 downto 0); signal ena : std_logic := '1'; signal enb : std_logic := '1'; signal wea : std_logic_vector(3 downto 0) := X"0"; signal web : std_logic_vector(3 downto 0) := X"0"; signal clka : std_logic := '0'; signal dia : std_logic_vector(31 downto 0); signal dipa : std_logic_vector(3 downto 0); signal clkb : std_logic := '0'; signal rsta : std_logic := '0'; signal rstb : std_logic := '0'; signal regcea : std_logic := '1'; signal regceb : std_logic := '1'; signal dib : std_logic_vector(31 downto 0); signal dipb : std_logic_vector(3 downto 0); begin RAMB16BWER_inst : entity work.RAMB16BWER generic map ( -- DATA_WIDTH_A/DATA_WIDTH_B: 0, 1, 2, 4, 9, 18, or 36 DATA_WIDTH_A => 9, DATA_WIDTH_B => 9, -- DOA_REG/DOB_REG: Optional output register (0 or 1) DOA_REG => 0, DOB_REG => 0, -- EN_RSTRAM_A/EN_RSTRAM_B: Enable/disable RST EN_RSTRAM_A => TRUE, EN_RSTRAM_B => TRUE, -- INITP_00 to INITP_07: Initial memory contents. INITP_00 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_01 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_02 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_03 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_04 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_05 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_06 => X"0000000000000000000000000000000000000000000000000000000000000000", INITP_07 => X"0000000000000000000000000000000000000000000000000000000000000000", -- INIT_00 to INIT_3F: Initial memory contents. INIT_00 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_01 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_02 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_03 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_04 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_05 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_06 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_07 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_08 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_09 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0A => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0B => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0C => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0D => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0E => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0F => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_10 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_11 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_12 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_13 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_14 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_15 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_16 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_17 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_18 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_19 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1A => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1B => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1C => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1D => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1E => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_1F => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_20 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_21 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_22 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_23 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_24 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_25 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_26 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_27 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_28 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_29 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2A => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2B => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2C => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2D => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2E => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_2F => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_30 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_31 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_32 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_33 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_34 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_35 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_36 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_37 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_38 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_39 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3A => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3B => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3C => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3D => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3E => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_3F => X"0000000000000000000000000000000000000000000000000000000000000000", -- INIT_A/INIT_B: Initial values on output port INIT_A => X"000000000", INIT_B => X"000000000", -- INIT_FILE: Optional file used to specify initial RAM contents INIT_FILE => "NONE", -- RSTTYPE: "SYNC" or "ASYNC" RSTTYPE => "SYNC", -- RST_PRIORITY_A/RST_PRIORITY_B: "CE" or "SR" RST_PRIORITY_A => "CE", RST_PRIORITY_B => "CE", -- SIM_COLLISION_CHECK: Collision check enable "ALL", "WARNING_ONLY", "GENERATE_X_ONLY" or "NONE" SIM_COLLISION_CHECK => "ALL", -- SIM_DEVICE: Must be set to "SPARTAN6" for proper simulation behavior SIM_DEVICE => "SPARTAN6", -- SRVAL_A/SRVAL_B: Set/Reset value for RAM output SRVAL_A => X"000000000", SRVAL_B => X"000000000", -- WRITE_MODE_A/WRITE_MODE_B: "WRITE_FIRST", "READ_FIRST", or "NO_CHANGE" WRITE_MODE_A => "WRITE_FIRST", WRITE_MODE_B => "WRITE_FIRST" ) port map ( -- Port A Data: 32-bit (each) output Port A data DOA => DOA, -- 32-bit output A port data output DOPA => DOPA, -- 4-bit output A port parity output -- Port B Data: 32-bit (each) output Port B data DOB => DOB, -- 32-bit output B port data output DOPB => DOPB, -- 4-bit output B port parity output -- Port A Address/Control Signals: 14-bit (each) input Port A address and control signals ADDRA => ADDRA, -- 14-bit input A port address input CLKA => CLKA, -- 1-bit input A port clock input ENA => ENA, -- 1-bit input A port enable input REGCEA => REGCEA, -- 1-bit input A port register clock enable input RSTA => RSTA, -- 1-bit input A port register set/reset input WEA => WEA, -- 4-bit input Port A byte-wide write enable input -- Port A Data: 32-bit (each) input Port A data DIA => DIA, -- 32-bit input A port data input DIPA => DIPA, -- 4-bit input A port parity input -- Port B Address/Control Signals: 14-bit (each) input Port B address and control signals ADDRB => ADDRB, -- 14-bit input B port address input CLKB => CLKB, -- 1-bit input B port clock input ENB => ENB, -- 1-bit input B port enable input REGCEB => REGCEB, -- 1-bit input B port register clock enable input RSTB => RSTB, -- 1-bit input B port register set/reset input WEB => WEB, -- 4-bit input Port B byte-wide write enable input -- Port B Data: 32-bit (each) input Port B data DIB => DIB, -- 32-bit input B port data input DIPB => DIPB -- 4-bit input B port parity input ); end architecture; nvc-r1.17.1/test/model/000077500000000000000000000000001504111170000146165ustar00rootroot00000000000000nvc-r1.17.1/test/model/alias1.vhd000066400000000000000000000017311504111170000164750ustar00rootroot00000000000000entity alias1 is end entity; architecture test of alias1 is signal x : bit_vector(7 downto 0); alias x_top is x(7); alias x_low is x(3 downto 0); alias x_high is x(7 downto 4); begin process is begin x <= X"80"; wait for 1 ns; assert x_top = '1'; assert x_low = X"0"; assert x_high = X"8"; x <= X"04"; wait for 1 ns; assert x_top = '0'; assert x_low = X"4"; assert x_high = X"0"; x_top <= '1'; wait for 1 ns; assert x_top = '1'; assert x_low = X"4"; assert x_high = X"8"; x_high <= X"f"; wait for 1 ns; assert x_top = '1'; assert x_low = X"4"; assert x_high = X"f"; x_low <= X"b"; x_high <= X"1"; wait for 1 ns; assert x_top = '0'; assert x_low = X"b"; assert x_high = X"1"; assert x = X"1b"; wait; end process; end architecture; nvc-r1.17.1/test/model/basic1.vhd000066400000000000000000000003401504111170000164600ustar00rootroot00000000000000entity basic1 is end entity; architecture test of basic1 is signal x : integer := 42; signal y : bit := '1'; begin p1: process is begin x <= x + 1; wait; end process; end architecture; nvc-r1.17.1/test/model/event1.vhd000066400000000000000000000004721504111170000165260ustar00rootroot00000000000000entity event1 is end entity; architecture test of event1 is signal s : bit; signal t : bit_vector(1 to 2); begin process is begin assert not s'event; assert not t'event; s <= '1'; t <= "11"; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/model/fast1.vhd000066400000000000000000000003531504111170000163400ustar00rootroot00000000000000entity fast1 is end entity; architecture test of fast1 is signal x : natural; begin p1: process is begin x <= 1; wait for 0 ns; x <= 2 after 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/model/fast2.vhd000066400000000000000000000012131504111170000163350ustar00rootroot00000000000000entity fast2 is end entity; architecture test of fast2 is signal x : bit_vector(1 to 8); begin p1: process is variable n : integer := 2; begin x <= X"ff"; for i in 1 to 8 loop x(i) <= '0'; end loop; wait for 1 ns; x <= X"ff"; wait for 1 ns; x(n) <= '0'; -- assert s = X"ff"; -- s(4) <= '0' after 0 ns, '1' after 2 ns; -- s(1 to 3) <= "111"; -- wait for 1 ns; -- assert s = "11101111"; -- s(5 to 8) <= X"f"; -- wait for 1 ns; -- assert s = X"ff"; wait; end process; end architecture; nvc-r1.17.1/test/model/index1.vhd000066400000000000000000000007331504111170000165140ustar00rootroot00000000000000entity index1 is end entity; architecture test of index1 is type mem1_t is array (natural range <>) of bit_vector(7 downto 0); signal s1 : mem1_t(1 to 100); type mem2_t is array (natural range <>) of bit_vector(9 downto 0); signal s2 : mem2_t(1 to 50); begin p1: process is begin for i in 1 to 20 loop s1(i) <= X"f0"; s2(i * 2) <= (others => '1'); end loop; wait; end process; end architecture; nvc-r1.17.1/test/model/pending1.vhd000066400000000000000000000012231504111170000170240ustar00rootroot00000000000000entity pending1 is end entity; architecture test of pending1 is signal state : integer := 0; signal x : integer := 0; begin wakeup: process is begin wait until x = 1; state <= 1; wait until x = 5; state <= 2; wait until x > 10; state <= 3; wait; end process; stim: process is begin x <= -1; wait for 1 ns; x <= 6; wait for 1 ns; x <= 1; wait for 1 ns; x <= 0; wait for 1 ns; x <= 5; wait for 1 ns; x <= 50; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/model/process1.vhd000066400000000000000000000004551504111170000170640ustar00rootroot00000000000000entity process1 is end entity; architecture test of process1 is begin p1: process is variable x : integer; begin report "hello, world"; x := 42; wait for 1 ns; report "after 1 ns"; x := x + 1; wait; end process; end architecture; nvc-r1.17.1/test/model/stateless1.vhd000066400000000000000000000004341504111170000174120ustar00rootroot00000000000000entity stateless1 is end entity; architecture test of stateless1 is signal x, y : integer; begin p1: x <= y; p2: process is variable z : integer; begin z := x; wait for 1 ns; y <= z; wait; end process; end architecture; nvc-r1.17.1/test/mtstress.c000066400000000000000000000202601504111170000155460ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "hash.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "option.h" #include "rt/mspace.h" #include "thread.h" #include #include #include #include #include #include #define CHECK(expr) do { \ if (unlikely(!(expr))) \ fatal_trace("check " #expr " failed"); \ } while (0) const char copy_string[] = ""; const char version_string[] = ""; static volatile int start = 0; static void run_test(thread_fn_t fn, void *arg) { const int nproc = MIN(nvc_nprocs(), MAX_THREADS - 1); nvc_thread_t *handles[MAX_THREADS]; full_barrier(); for (int i = 0; i < nproc; i++) handles[i] = thread_create(fn, arg, "test thread %d", i); store_release(&start, 1); for (int i = 0; i < nproc; i++) thread_join(handles[i]); store_release(&start, 0); } static uint32_t fast_rand(uint32_t *state) { uint32_t tmp = *state; tmp ^= (tmp << 13); tmp ^= (tmp >> 17); tmp ^= (tmp << 5); return (*state = tmp); } //////////////////////////////////////////////////////////////////////////////// // Concurrent calls to ident_new #define NWORDS 1000000 static char *words[NWORDS]; static ident_t idents[NWORDS]; static void *test_ident_thread(void *arg) { const int nproc = nvc_nprocs(); uint32_t rng = rand(); while (load_acquire(&start) == 0) spin_wait(); for (int i = 0; i < NWORDS / 2 / nproc; i++) { const int pos = fast_rand(&rng) % NWORDS; ident_t id = ident_new(words[pos]), exist; again: exist = load_acquire(&(idents[pos])); if (exist != NULL) ck_assert_ptr_eq(exist, id); else if (!atomic_cas(&(idents[pos]), NULL, id)) goto again; } return NULL; } START_TEST(test_ident_new) { FILE *f = fopen("/usr/share/dict/words", "r"); ck_assert_ptr_nonnull(f); char *line LOCAL = NULL; size_t bufsz = 0; int pos = 0; for (; pos < NWORDS; ) { int nchars = getline(&line, &bufsz, f); if (nchars == -1) break; ck_assert_int_ge(nchars, 2); if (islower(line[0]) && nchars > 2 && line[nchars - 3] != '\'') { line[nchars - 1] = '\0'; words[pos++] = line; line = NULL; bufsz = 0; } } for (; pos < NWORDS; pos++) words[pos] = words[rand() % pos]; fclose(f); run_test(test_ident_thread, NULL); } END_TEST //////////////////////////////////////////////////////////////////////////////// // Concurrent hash table updates #define CHASH_NVALUES 1024 #define CHASH_ITERS 1000000 static void *chash_keys[CHASH_NVALUES]; static void *chash_values[CHASH_NVALUES]; #define VOIDP(x) ((void *)(uintptr_t)x) static void *test_chash_thread(void *arg) { chash_t *h = arg; uint32_t rng = rand(); while (load_acquire(&start) == 0) spin_wait(); for (int i = 0; i < CHASH_ITERS; i++) { uint32_t randval = fast_rand(&rng); int nth = randval % CHASH_NVALUES; if ((randval >> 16) % 3 == 0) chash_put(h, chash_keys[nth], chash_values[nth]); else { void *value = chash_get(h, chash_keys[nth]); if (value != NULL) CHECK(value == chash_values[nth]); } } return NULL; } START_TEST(test_chash_rand) { for (int i = 0; i < CHASH_NVALUES; i++) { do { chash_keys[i] = VOIDP(((i << 20) | (rand() & 0xffff0))); } while (chash_keys[i] == NULL); chash_values[i] = VOIDP(rand()); } chash_t *h = chash_new(4); run_test(test_chash_thread, h); chash_free(h); } END_TEST //////////////////////////////////////////////////////////////////////////////// // Stop/start world static void stop_world_cb(int thread_id, struct cpu_state *cpu, void *arg) { } static void *stop_world_thread_fn(void *__arg) { while (load_acquire(&start) == 0) spin_wait(); for (int i = 0; i < 10000; i++) { stop_world(stop_world_cb, NULL); start_world(); } return NULL; } START_TEST(test_stop_world) { run_test(stop_world_thread_fn, NULL); } END_TEST //////////////////////////////////////////////////////////////////////////////// // Concurrent GC __attribute__((noinline)) static void gc_alloc_loop(mspace_t *m) { int32_t *saved[5]; int nsaved = 0; uint32_t rng = rand(); for (int i = 0; i < 100000; i++) { int32_t *mem = mspace_alloc(m, 4 + (fast_rand(&rng) % 1000)); CHECK(mem != NULL); if (nsaved < ARRAY_LEN(saved) && (fast_rand(&rng) % 2 == 0)) { saved[nsaved++] = mem; *mem = nsaved | (thread_id() << 16); } } for (int i = 0; i < ARRAY_LEN(saved); i++) CHECK(*saved[i] == ((i + 1) | (thread_id() << 16))); } static void *test_gc_thread(void *arg) { mspace_t *m = arg; mspace_stack_limit(MSPACE_CURRENT_FRAME); gc_alloc_loop(m); return NULL; } START_TEST(test_gc) { mspace_t *m = mspace_new(0x100000); run_test(test_gc_thread, m); mspace_destroy(m); } END_TEST //////////////////////////////////////////////////////////////////////////////// // MIR concurrent access static void *test_mir_types_thread(void *arg) { mir_context_t *mc = arg; const uint32_t rng_init = knuth_hash(thread_id()); while (load_acquire(&start) == 0) spin_wait(); ident_t name = ident_sprintf("func%d", thread_id()); mir_unit_t *mu = mir_unit_new(mc, name, NULL, MIR_UNIT_FUNCTION, NULL); uint32_t rng = rng_init; mir_type_t types[4000]; for (int i = 0; i < ARRAY_LEN(types); i++) { types[i] = mir_int_type(mu, 0, fast_rand(&rng) % (i + 1)); CHECK(!mir_is_null(types[i])); } rng = rng_init; for (int i = 0; i < ARRAY_LEN(types); i++) { const uint32_t max = fast_rand(&rng) % (i + 1); const mir_repr_t repr = mir_get_repr(mu, types[i]); CHECK(mir_get_class(mu, types[i]) == MIR_TYPE_INT); if (max <= 1) CHECK(repr == MIR_REPR_U1); else if (max <= UINT8_MAX) CHECK(repr == MIR_REPR_U8); else if (max <= UINT16_MAX) CHECK(repr == MIR_REPR_U16); } mir_unit_free(mu); return NULL; } START_TEST(test_mir_types) { mir_context_t *mc = mir_context_new(); run_test(test_mir_types_thread, mc); mir_context_free(mc); } END_TEST //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { srand((unsigned)time(NULL)); term_init(); thread_init(); register_signal_handlers(); set_default_options(); mspace_stack_limit(MSPACE_CURRENT_FRAME); setenv("NVC_LIBPATH", "./lib", 1); Suite *s = suite_create("mtstress"); TCase *tc_ident = tcase_create("ident"); tcase_add_test(tc_ident, test_ident_new); suite_add_tcase(s, tc_ident); TCase *tc_chash = tcase_create("chash"); tcase_add_test(tc_chash, test_chash_rand); tcase_set_timeout(tc_chash, 10.0); suite_add_tcase(s, tc_chash); #ifndef __SANITIZE_THREAD__ TCase *tc_gc = tcase_create("gc"); tcase_add_test(tc_gc, test_gc); tcase_set_timeout(tc_gc, 20.0); suite_add_tcase(s, tc_gc); TCase *tc_stop_world = tcase_create("stop_world"); tcase_add_test(tc_stop_world, test_stop_world); tcase_set_timeout(tc_stop_world, 20.0); suite_add_tcase(s, tc_stop_world); #endif TCase *tc_mir = tcase_create("mir"); tcase_add_test(tc_mir, test_mir_types); tcase_set_timeout(tc_mir, 20.0); suite_add_tcase(s, tc_mir); SRunner *sr = srunner_create(s); srunner_run_all(sr, CK_NORMAL); return srunner_ntests_failed(sr) == 0 ? EXIT_SUCCESS : EXIT_FAILURE; } nvc-r1.17.1/test/parse/000077500000000000000000000000001504111170000146305ustar00rootroot00000000000000nvc-r1.17.1/test/parse/access.vhd000066400000000000000000000007311504111170000165750ustar00rootroot00000000000000entity ee is end entity; architecture aa of ee is type int_ptr is access integer; type bv_ptr is access bit_vector; begin process is variable x, p : int_ptr; variable v : integer; variable a : bv_ptr; variable q : bit_vector(1 to 3); variable r : bit; begin x.all := 1; v := x.all + 5; p := new integer; q := a.all(1 to 3); r := a.all(3); end process; end architecture; nvc-r1.17.1/test/parse/aggregate.vhd000066400000000000000000000012221504111170000172560ustar00rootroot00000000000000package aggregate is type int_vec_up is array (natural range <>) of integer; type down_natural is range 100 downto 0; type int_vec_down is array (down_natural range <>) of integer; constant c1 : int_vec_up(1 to 2) := (1, 2); -- (1 to 2); constant c2 : int_vec_up(7 to 8) := (1 => 1, 2 => 2); -- (1 to 2); constant c3 : int_vec_up := (1, 2); -- (0 to 1); constant c4 : int_vec_down := (1, 2, 3); -- (100 downto 98) constant c5 : int_vec_down(7 downto 6) := (1 => 1, 2 => 2); -- (2 downto 1) constant c6 : int_vec_up := (c1, c1); -- (0 to 3) constant c7 : int_vec_up := (1, c1); -- (0 to 2) end package; nvc-r1.17.1/test/parse/aggregate2.vhd000066400000000000000000000011151504111170000173410ustar00rootroot00000000000000package tick is type t_data_segment is record end record; constant C_SEGMENT_RECORDS : t_data_segment := ( data'last => (others => '0') -- Error ); end package; package brack is type t_data_segment is record end record; constant C_SEGMENT_RECORDS : t_data_segment := ( data[word => (others => '0') -- Error ); end package; -------------------------------------------------------------------------------- package pkg is type narr is array (t_direction range <>) of natural; -- Error constant C : narr := (others => 0); -- Error end package; nvc-r1.17.1/test/parse/alias.vhd000066400000000000000000000007341504111170000164300ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal bar, boo : integer; function func (x : integer; b : boolean) return boolean; function func return integer; procedure proc (x : integer); procedure proc; alias foo is bar; alias blah : integer is boo; alias funci is func [integer, boolean return boolean]; alias proci is proc [integer]; alias proce is proc []; alias funce is func [return integer]; begin end architecture; nvc-r1.17.1/test/parse/alias2.vhd000066400000000000000000000011101504111170000164770ustar00rootroot00000000000000package pack1 is procedure read ( x : out integer ); end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is alias read is work.pack1.read [integer]; end package; ------------------------------------------------------------------------------- use work.pack1.all; use work.pack2.all; entity test is end entity; architecture test of test is begin process is variable x : integer; begin read(x); -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/alias3.vhd000066400000000000000000000010641504111170000165100ustar00rootroot00000000000000package pack1 is type t is (foo, bar); end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is alias foo is work.pack1.foo [return t]; procedure foo; procedure bar(arg : t); end package; ------------------------------------------------------------------------------- entity e is end entity; use work.pack2.all; architecture test of e is begin p1: process is begin bar(foo); -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/alias4.vhd000066400000000000000000000010311504111170000165030ustar00rootroot00000000000000package pack1 is type t_foo is (a, b, c); function to_hstring (x : t_foo) return string; alias to_hex_string is to_hstring [t_foo return string]; end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is alias t_foo2 is t_foo; end package; ------------------------------------------------------------------------------- use work.pack1.all; use work.pack2.all; package pack3 is constant s : string := to_hex_string(a); -- OK end package; nvc-r1.17.1/test/parse/alias5.vhd000066400000000000000000000003361504111170000165130ustar00rootroot00000000000000package test_pkg is alias alias_t is type_t; alias alias_t is type_t; constant c : alias_t; end package; package pack is procedure proc; alias proc_alias is x; alias proc_alias is proc [integer]; end package; nvc-r1.17.1/test/parse/arch.vhd000066400000000000000000000003261504111170000162510ustar00rootroot00000000000000entity one is end entity; architecture a of one is signal x : integer; signal y, z : integer := 7; begin end architecture; architecture b of one is begin end b; architecture c of one is begin end; nvc-r1.17.1/test/parse/array.vhd000066400000000000000000000027441504111170000164600ustar00rootroot00000000000000package p is type int_array is array (integer range <>) of integer; type ten_ints is array (1 to 10) of integer; type chars is (A, B, C); type char_counts is array (chars) of integer; type two_d is array (1 to 3, 4 to 6) of integer; type ab_chars is array (chars range A to B) of integer; type it is array (integer range ten_ints'range) of bit; end package; entity e is end entity; use work.p.all; architecture a of e is signal x : int_array(1 to 5); signal y : ten_ints; signal z : int_array(1 to 3) := ( 0, 1, 2 ); signal n : int_array(1 to 3) := ( 0, 1 => 1, others => 2 ); signal m : int_array(1 to 3) := ( 1 to 3 => 0 ); signal c : char_counts; signal t : two_d; signal u : ten_ints := ( 1 | 2 | 3 => 4, others => 2); signal v : ten_ints := ( 1 ! 2 ! 3 => 4, others => 2); begin process is variable k : int_array(1 to 5); begin x(0) <= 1; y(2) <= n(2); y(3)(5) <= n(2)(1); x(1 to 3) <= z(1 to 3); k := (x'range => 5); k := (x'reverse_range => 3); end process; process is type bv2d is array (natural range <>, positive range <>) of bit; variable v : bv2d(0 to 1) := ( ('0', '0'), ('1', '1'), -- Error ('0', '1'), ('1', '1'), ('0', '1'), ('0', '1'), ('1', '0'), ('1', '0') ); begin end process; end architecture; nvc-r1.17.1/test/parse/attr.vhd000066400000000000000000000010231504111170000163010ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x : integer; component c is end component; attribute foo : integer; attribute foo of x : signal is 5; attribute foo of c : component is 5; type t is ('0', '1'); attribute foo of '1' : literal is 6; attribute foo of t : type is 4; attribute foo of integer : type is 4; -- Error attribute foo of a1 : label is 6; attribute foo of e : label is 6; -- Error begin a1: assert x'foo = 5; a2: assert a1'foo = 6; end architecture; nvc-r1.17.1/test/parse/badprimary.vhd000066400000000000000000000010061504111170000174620ustar00rootroot00000000000000entity top is end entity; architecture a of top is component foo is end component; begin sub_i: component foo; end architecture; ------------------------------------------------------------------------------- architecture bad of not_here is -- Error begin end architecture; ------------------------------------------------------------------------------- configuration cfg of top is for a for sub_i: foo use entity work.not_here(bad); end for; end for; end configuration; nvc-r1.17.1/test/parse/based.vhd000066400000000000000000000012711504111170000164120ustar00rootroot00000000000000PACKAGE pp IS CONSTANT a : INTEGER := 2#1101#; CONSTANT b : INTEGER := 3#20#; CONSTANT c : INTEGER := 8#7#; CONSTANT d : INTEGER := 10#1234#; CONSTANT e : INTEGER := 16#beef01#; CONSTANT f : INTEGER := 2#1_0#; CONSTANT g : INTEGER := 2:1_0:; CONSTANT h : INTEGER := 16#abababab#; CONSTANT i : INTEGER := 16#1A#; CONSTANT j : INTEGER := 2#1111_1111#; CONSTANT k : INTEGER := 16#FF#; CONSTANT l : INTEGER := 016#0FF#; CONSTANT m : INTEGER := 16#E#E1; CONSTANT n : INTEGER := 2#1110_0000#; CONSTANT o : REAL := 16#F.FF#E+2; CONSTANT p : REAL := 2#1.1111_1111_111#E11; CONSTANT x : INTEGER := 2:1110_0000:; CONSTANT y : REAL := 16:F.FF:E+2; END PACKAGE; nvc-r1.17.1/test/parse/basic_identifier.vhd000066400000000000000000000007451504111170000206240ustar00rootroot00000000000000entity ee_ is end entity; -- ERROR expecting is (after ee) entity e__e is end entity; -- ERROR expecting is (after e) entity _e is end entity; -- ERROR expecting identifier (instead of _e) entity e_e is end entity; -- OK entity e_ee_e is end entity; -- OK architecture aa_ of e_e is -- ERROR expecting of (after aa) begin end architecture; architecture a__a of e_e is -- ERROR expecting of (after a) begin end architecture; architecture a_a of e_e is -- OK begin end architecture; nvc-r1.17.1/test/parse/bitstring.vhd000066400000000000000000000016111504111170000173370ustar00rootroot00000000000000PACKAGE bitstring IS CONSTANT x : bit_vector := X"1234"; CONSTANT y : bit_vector := O"1234"; CONSTANT z : bit_vector := X"ab"; CONSTANT b : bit_vector := B"101"; CONSTANT c : bit_vector := x"f"; CONSTANT d : bit_vector := X"a_b"; CONSTANT e : bit_vector := B"1111_1111_1111"; CONSTANT f : bit_vector := X"FFF"; CONSTANT g : bit_vector := O"777"; CONSTANT h : bit_vector := X"777"; CONSTANT i : bit_vector := B%1111_1111_1111%; CONSTANT j : bit_vector := X%FFF%; CONSTANT k : bit_vector := O%777%; CONSTANT l : bit_vector := X%777%; END PACKAGE; PACKAGE bitstring_error IS CONSTANT e1 : bit_vector := O"9"; -- Error constant e2 : bit_vector := X"_1"; -- Error constant e3 : bit_vector := X"1_"; -- Error constant e4 : bit_vector := X"1__2"; -- Error constant e99 : bit_vector := x"1 23"; -- Error END PACKAGE; nvc-r1.17.1/test/parse/block.vhd000066400000000000000000000003531504111170000164260ustar00rootroot00000000000000entity e is end entity; architecture a of e is begin b: block is begin end block; c: block is signal x : integer; signal y : real; begin x <= integer(y); end block; end architecture; nvc-r1.17.1/test/parse/comp.vhd000066400000000000000000000003231504111170000162670ustar00rootroot00000000000000package p is component c is generic ( X : integer ); port ( o : out integer ); end component; component foo port ( x : inout integer ); end component foo; end package; nvc-r1.17.1/test/parse/conc.vhd000066400000000000000000000013221504111170000162530ustar00rootroot00000000000000entity ee is end entity; architecture aa of ee is signal x, a, b, c : bit; signal foo, bar : boolean; signal y : integer; signal v : bit_vector(1 to 2); procedure pcall(x : in bit; y : in integer); procedure xxx; begin x <= a or b; postponed x <= '1' when foo else '1' when bar else '0'; with y select x <= '0' when 6, '1' when 5, '1' when others; pcall(x, y); assert y = 5; (a, b) <= v; xxx; b1: block is generic ( g1 : integer; g2 : bit := '1' ); generic map ( g1 => 5 ); port ( p1 : integer ); port map ( p1 => y ); begin end block; end architecture; nvc-r1.17.1/test/parse/concat.vhd000066400000000000000000000005211504111170000166000ustar00rootroot00000000000000entity b is end entity; architecture a of b is signal x : bit_vector(1 to 3); signal y : bit_vector(1 to 2); signal p : bit_vector(1 to 3); signal q, g : bit; begin x <= y & '0'; process is variable c : bit_vector(1 to 4); begin c := q & g & ('1', '1'); end process; end architecture; nvc-r1.17.1/test/parse/cond1.vhd000066400000000000000000000012431504111170000163370ustar00rootroot00000000000000package cond1 is `if TOOL_NAME = "false" then `error "Should not be here" constant d : integer := 1; `else constant c : integer := 1; `end if `warning "this is a warning" `if TOOL_NAME = "nvc" then `warning "Using nvc" `end if `if not (TOOL_TYPE = "SIMULATION") then `error "Should not be here" `end if `if TOOL_TYPE /= "SYNTHESIS" and TOOL_NAME = "nvc" then `warning "correct" `end if `if VHDL_VERSION = "1993" then `warning "VHDL version is correct" `end if end package; package cond2 is `if FOO = "bar" then `end `if TOOL_NAME = "ghdl" then -- Unterminated end package; nvc-r1.17.1/test/parse/config.vhd000066400000000000000000000034351504111170000166050ustar00rootroot00000000000000entity ent is end entity; entity foo is attribute x : integer; end entity; architecture arch of foo is begin end architecture; architecture arch of ent is component comp is end component; component moo is end component; begin blah: component moo; p: process is begin end process; end architecture; configuration conf2 of foo is for arch end for; end configuration; configuration conf of ent is use work.foo; attribute x of 'A' : literal is 5; for arch for all : comp use entity work.foo(arch); end for; for blah : moo use configuration work.conf2; end for; end for; end configuration; configuration bad1 of conf is -- Error for arch for x : y use configuration work.conf; end for; -- Suppressed error end for; end configuration; configuration bad2 of ent is for bad -- Error for x : y use configuration work.conf; end for; -- Suppressed error end for; end configuration; configuration bad3 of ent is for arch for p -- Error for x : y use configuration work.conf; end for; -- Suppressed error end for; for p : comp use configuration work.conf; end for; -- Error end for; end configuration; package pack is component pack_comp is end component; end package; use work.pack.all; architecture use_pack of ent is begin sub: component pack_comp; end architecture; configuration use_pack_ent of ent is for use_pack for all : pack_comp use entity work.foo; end for; end for; end configuration; entity b is end entity b; architecture rtl of b is component ent end component; for ent0 : ent; -- Error begin ent0: ent; end architecture rtl; nvc-r1.17.1/test/parse/context.vhd000066400000000000000000000007431504111170000170230ustar00rootroot00000000000000package widget_defs is end package; package widget_comps is end package; context widget_context is use widget_lib.widget_defs.all; use widget_lib.widget_comps.all; end context; ------------------------------------------------------------------------------- context dongle_context is library widget_lib; context widget_lib.widget_context; end context; library widget_lib; use widget_lib.widget_defs; context bad is -- Error end context; nvc-r1.17.1/test/parse/defer1.vhd000066400000000000000000000010561504111170000165030ustar00rootroot00000000000000package defer1 is function func1 return integer; constant c1 : integer := func1; -- Error constant c2 : integer; constant c3 : integer := c2 + 1; -- Error function func2 (x : integer := c2) return integer; -- OK end package; ------------------------------------------------------------------------------- entity e is end entity; architecture a of e is type pt1 is protected end protected; shared variable v1 : pt1; -- Error type pt1 is protected body end protected body; begin end architecture; nvc-r1.17.1/test/parse/empty.vhd000066400000000000000000000000001504111170000164570ustar00rootroot00000000000000nvc-r1.17.1/test/parse/entity.vhd000066400000000000000000000013041504111170000166450ustar00rootroot00000000000000entity one is end entity; entity two is end two; entity three is end entity three; entity four is port ( a : in integer := 4; b, bee : out bit; c : inout integer; d : buffer bit ); end entity; entity five is generic ( X : boolean; Y : integer := 2 * 5); port ( signal p : out bit ); end entity; entity six is attribute a : integer; attribute a of six : entity is 1; end entity; entity seven is begin assert (true ) report "should not assert" severity note; assert (false) report "should assert" severity note; end entity seven; entity eight is generic ( signal x : integer ); end entity; nvc-r1.17.1/test/parse/enum.vhd000066400000000000000000000001531504111170000162760ustar00rootroot00000000000000package p is type a is (x, y, z); type b is ('x', 'y', Z); type c is (FOO); end package; nvc-r1.17.1/test/parse/error.vhd000066400000000000000000000032521504111170000164660ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x : integer; begin bad syntax; x <= 2; x <= 1 + 2; -- Recovery some more bad syntax; x <= 2; x <= 1 + 2; -- Recovery process begin end; -- Missing "process" x <= 2; x <= 1 + 2; -- Recovery foo: process is begin end process bar; -- Label does not match process is begin end process bar; -- No initial label b: block is impure function "+" (p : bit) return boolean is begin my_if: if x > 5 then null; end if blah; -- Label does not match x <= 2; x <= 1 + 2; -- Recovery end function "-"; -- Label does not match begin end block; end architecture; architecture a2 of e is signal x : integer; begin p1: process is begin end process; p1: process is begin end process; -- Error, duplicate label a1: assert x = 1; a1: assert x = 2; -- Error, duplicate label s1: x <= 5; s1: x <= 6; -- Error, duplicate label b1: block is begin end block; b1: block is begin end block; -- Error, duplicate label b2: block is procedure proc(x : integer) is begin end procedure; begin c1: proc(1); c1: proc(2); -- Error, duplicate label end block; c1: not_a_library -- Error port map ( x => 1 ); end architecture; architecture bad of not_here is -- Error begin end architecture; nvc-r1.17.1/test/parse/error10.vhd000066400000000000000000000002241504111170000166230ustar00rootroot00000000000000entity error10 is end entity; architecture test of error10 is begin g: for in 1 to 10 generate -- Error end generate; end architecture; nvc-r1.17.1/test/parse/error11.vhd000066400000000000000000000016371504111170000166350ustar00rootroot00000000000000package generic_sb_pkg is generic(type t_element; function element_match(received_element : t_element; expected_element : t_element) return boolean; function to_string_element(element : t_element) return string); type t_generic_sb is protected end protected; end package generic_sb_pkg; package body generic_sb_pkg is type t_generic_sb is protected body end protected body; end package body; ------------------------------------------------------------------------------- entity issue858 is end entity; architecture tb of issue858 is package slv_sb_pkg is new work.generic_sb_pkg generic map(t_element => bit_vector(7 downto 0), element_match => std_match, -- Error to_string_element => to_string); use slv_sb_pkg.all; shared variable sb_under_test : slv_sb_pkg.t_generic_sb; begin end architecture; nvc-r1.17.1/test/parse/error12.vhd000066400000000000000000000023661504111170000166360ustar00rootroot00000000000000package generic_queue_pkg is generic(type t_generic_element; GC_QUEUE_COUNT_MAX : natural := 1000; GC_QUEUE_COUNT_THRESHOLD : natural := 950); end package generic_queue_pkg; ------------------------------------------------------------------------------- package generic_sb_pkg is generic(type t_element; function element_match(received_element : t_element; expected_element : t_element) return boolean; function to_string_element(element : t_element) return string; constant GC_QUEUE_COUNT_MAX : natural := 1000; constant GC_QUEUE_COUNT_THRESHOLD : natural := 950); end package generic_sb_pkg; package body generic_sb_pkg is type t_sb_entry is record expected_element : t_element; source : string(1 to 5); tag : string(1 to 5); entry_time : time; end record; package sb_queue_pkg is new work.generic_queue_pkg generic map( t_generic_element => t_sb_entry, scope => "SB_queue", GC_QUEUE_COUNT_MAX => GC_QUEUE_COUNT_MAX, GC_QUEUE_COUNT_THRESHOLD => GC_QUEUE_COUNT_THRESHOLD); use sb_queue_pkg.all; end package body generic_sb_pkg; nvc-r1.17.1/test/parse/error13.vhd000066400000000000000000000006161504111170000166330ustar00rootroot00000000000000package components is component sub is port ( x : in real; z : out real ); end component; end package; ------------------------------------------------------------------------------- entity top is end entity; use work.components.all; architecture test of top is signal xr, zr : real := 0.0; begin u1: sub port map ( xr, zr ); end architecture; nvc-r1.17.1/test/parse/error2.vhd000066400000000000000000000025111504111170000165450ustar00rootroot00000000000000package body dunno is type foo is array (bar) of character; -- Error type goo is array (bar range '1' to '2') of character; -- Error (suppressed) function func(x : sdff) return boolean is begin return false; end function; function func(x : sghbbx) return boolean is begin return true; end function; procedure proc is begin std.nothere.bang(4); -- Error end procedure; procedure proc2 is begin for foo in integer range blah blah loop -- Error end loop; end procedure; type badunits is range 1 to 30 units blah; end units spork; type badrecord is record x : integer; end record wrong; function func2 return integer is begin return 1; end procedure; -- Error procedure proc3 is begin end function; -- Error type other is protected end protected wrong; -- Error subtype weird is bit_vector 1 to 3; -- Error procedure proc4 is type ft is file of integer; file f : ft; begin f(0) := 1; -- Error end procedure; procedure proc5 is variable v : now; -- Error begin end procedure; end package body; nvc-r1.17.1/test/parse/error3.vhd000066400000000000000000000055321504111170000165540ustar00rootroot00000000000000package AlertLogPkg is -- type AlertLogIDType is range integer'low to integer'high ; -- next revision subtype AlertLogIDType is integer ; type AlertLogIDVectorType is array (integer range <>) of AlertLogIDType ; type AlertType is (FAILURE, ERROR, WARNING) ; -- NEVER subtype AlertIndexType is AlertType range FAILURE to WARNING ; type AlertCountType is array (AlertIndexType) of integer ; type AlertEnableType is array(AlertIndexType) of boolean ; type LogType is (ALWAYS, DEBUG, FINAL, INFO, PASSED) ; -- NEVER -- See function IsLogEnableType subtype LogIndexType is LogType range DEBUG to PASSED ; type LogEnableType is array (LogIndexType) of boolean ; type AlertLogStructPType is protected ------------------------------------------------------------ procedure alert ( ------------------------------------------------------------ AlertLogID : AlertLogIDType ; message : string ; level : AlertType := ERROR ) ; end protected AlertLogStructPType ; end AlertLogPkg ; --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// package body AlertLogPkg is -- synthesis translate_off -- instead of justify(to_upper(to_string())), just look up the upper case, left justified values type AlertNameType is array(AlertType) of string(1 to 7) ; constant ALERT_NAME : AlertNameType := (WARNING => "WARNING", ERROR => "ERROR ", FAILURE => "FAILURE") ; -- , NEVER => "NEVER " --- /////////////////////////////////////////////////////////////////////////// type AlertLogStructPType is protected body ------------------------------------------------------------ -- Report formatting settings, with defaults variable PrintPassedVar : boolean := TRUE ; variable PrintAffirmationsVar : boolean := FALSE ; variable PrintDisabledAlertsVar : boolean := FALSE ; variable PrintRequirementsVar : boolean := FALSE ; variable HasRequirementsVar : boolean := FALSE ; variable PrintIfHaveRequirementsVar : boolean := TRUE ; variable DefaultPassedGoalVar : integer := 1 ; ------------------------------------------------------------ procedure alert ( ------------------------------------------------------------ AlertLogID : AlertLogIDType ; message : string ; level : AlertType := ERROR ) is begin report ALERT_NAME(Level); -- Lower crash here end procedure alert ; end protected body AlertLogStructPType ; end package body AlertLogPkg ; ------------------------------------------------------------------------------- -- "GC removed all objects from arena ???" crash here entity e is end entity; nvc-r1.17.1/test/parse/error4.vhd000066400000000000000000000002301504111170000165430ustar00rootroot00000000000000-- Missing "library ieee;" use ieee.math_real.all ; package RandomPkg is end RandomPkg ; package body RandomPkg is -- Was crash here end RandomPkg ; nvc-r1.17.1/test/parse/error5.vhd000066400000000000000000000004011504111170000165440ustar00rootroot00000000000000-- Errors in context use work.nothere.all; -- Error package p is constant k : mytype := myfunc; -- Error (suppressed) end package; package body p is constant y : mytype := myfunc; -- Error (suppressed) end package body; nvc-r1.17.1/test/parse/error6.vhd000066400000000000000000000004011504111170000165450ustar00rootroot00000000000000package axil_generic_pkg is generic( ADDR_WIDTH : natural ); type mosi_t is record valid : bit; addr : bit_vector(ADDR_WIDTH-1 downto 0); end record; type miso_t is record ready : bit; end record; nvc-r1.17.1/test/parse/error7.vhd000066400000000000000000000007301504111170000165530ustar00rootroot00000000000000package error7 is type foo is (a, b, c); function "=" (l, r : foo) return boolean; constant foo : integer := 1; -- Error end package; package body error7 is -- Error constant k : boolean := a = b; -- Error (suppressed) end package body; use work.error7.all; -- Error package other is constant x : integer := bad; -- Error (suppressed) end package; use work; -- Error nvc-r1.17.1/test/parse/error8.vhd000066400000000000000000000014251504111170000165560ustar00rootroot00000000000000package pack is type rec is record x : integer; end record; type pt is protected impure function next_id return integer; end protected; impure function get_rec return rec; function get_id (r : rec) return integer; end package; package body pack is type pt is protected body variable ctr : integer := 0; impure function next_id return integer is begin ctr := ctr + 1; return ctr; end function; end protected body; shared variable p : pt; impure function get_rec return rec is begin return (id => pt.next_id); -- Error end function; function get_id (r : rec) return integer is begin return r.x; end function; end package body; nvc-r1.17.1/test/parse/error9.vhd000066400000000000000000000010611504111170000165530ustar00rootroot00000000000000-- Test case from Brian Padalino -- entity line_issue is end entity ; architecture arch of line_issue is type line is access string; begin tb : process variable fmt : line := new string'("{>8f}") ; constant s : string := "abcd" ; -- Note length should be an attribute 'length constant len : natural := fmt.length ; constant slen : natural := s'length ; begin report "fmt len: " & integer'image(len) ; report "s len: " & integer'image(slen) ; end process ; end architecture ; nvc-r1.17.1/test/parse/explicit.vhd000066400000000000000000000007661504111170000171650ustar00rootroot00000000000000package p1 is type my_type is (a, b, c); type my_vec is array (natural range <>) of my_type; -- Implicit <= declared here end package; use work.p1.all; package p2 is function "<=" (l, r : my_vec) return boolean; end package; entity e is end entity; use work.p1.all; use work.p2.all; architecture a of e is begin process is variable x, y : my_vec(1 to 3); begin assert x <= y; -- OK (2008), Error (1993) end process; end architecture; nvc-r1.17.1/test/parse/expr.vhd000066400000000000000000000016631504111170000163170ustar00rootroot00000000000000entity e is end entity; package foo is function "and"(x, y : integer) return bit; end package; architecture a of e is signal v : bit_vector(1 to 3); type rec is record z : integer; end record; function f(x : integer) return rec; begin process is variable x, y, z : integer; variable b : boolean; variable q : bit_vector(1 to 3); begin b := not (x > y); x := abs (-5); x := y ** z; x := f(4).z; q := q sll 1; q := q srl 1; q := q sla 1; q := q sra 1; q := q rol 1; q := q ror 1; q(1) := work.foo."and"(1, 2); q(q'range) := q; q := (1 => '1', v'range => '0'); x := -3 * 4 + 2; end process; process is variable x, y, z : integer; begin x := y/+z; -- Error x := y**-z; -- Error end process; end architecture; nvc-r1.17.1/test/parse/extended.vhd000066400000000000000000000006251504111170000171360ustar00rootroot00000000000000-- Test extended identifiers entity bar is end entity; architecture foo of bar is signal \foo bar\ : integer; signal \a\\b\ : integer; signal \Thing!!! \ : integer; signal \name\ : integer; signal name : integer; signal \foo.bar.baz\ : integer; signal \hello\ : integer; signal x\y : integer; -- Error begin \foo.bar.baz\ <= \hello\; end architecture; nvc-r1.17.1/test/parse/external.vhd000066400000000000000000000013061504111170000171550ustar00rootroot00000000000000entity external is end entity; architecture test of external is begin main: process is variable i : integer; begin i := <>; -- OK i := << constant x.y.z : integer >>; -- OK i := <>; -- OK i := << constant .x.y.z : integer>>; -- OK i := << constant ^.^.foo : integer >>; -- OK i := << constant @work.pack.foo : integer >>; -- OK i := << signal g(0).x(1).baz : integer >>; -- OK end process; p2: process is alias sig is <>; begin sig(0) <= '1'; -- OK end process; end architecture; nvc-r1.17.1/test/parse/func.vhd000066400000000000000000000006671504111170000162770ustar00rootroot00000000000000package func is function add(x, y : integer; z : in integer) return integer; impure function naughty return integer; function "+"(x, y : integer) return integer; pure function purefunc return integer; end package; package body func is function "+"(x, y : integer) return integer is begin return 42; end function "+"; function "blah"(x : integer) return integer; -- Error end package body; nvc-r1.17.1/test/parse/generate.vhd000066400000000000000000000020631504111170000171260ustar00rootroot00000000000000entity gg is end entity; architecture aa of gg is constant foo, bar : boolean := false; signal x, g, f : integer; constant h : integer := 6; type text is file of string; file output : text open WRITE_MODE is "STD_OUTPUT"; begin g1: if foo generate signal x : integer; begin x <= 5; end generate; g2: if bar generate g2a: if h < 5 generate g <= 7; end generate; end generate; g3: for i in 1 to 40 generate signal x : integer; begin f <= h; end generate; g4: for i in natural'range generate end generate; g5: for i in integer'range generate begin end generate; g6: for i in 1 to 3 generate component sub_ent is port (val: out natural); end component sub_ent; -- OK begin end generate; g7: if true generate procedure doit is -- OK begin write(OUTPUT, "OK." & LF); end procedure doit; begin end generate g7; end architecture; nvc-r1.17.1/test/parse/gensub.vhd000066400000000000000000000005051504111170000166160ustar00rootroot00000000000000package pack1 is procedure foo is new bar.all; -- Error end package; package pack2 is end package; package body pack2 is procedure adder generic (type t) is type fnat is file of natural; begin end procedure; procedure addi is new adder generic map (t => integer); -- OK end package body; nvc-r1.17.1/test/parse/group.vhd000066400000000000000000000005561504111170000164750ustar00rootroot00000000000000entity test is end entity; architecture test of test is group local_ports is (signal <>); -- OK signal s : bit; group local_sigs : local_ports ( s ); -- OK begin process is group some_var is (variable); -- OK variable v : integer; group g : some_var (v); -- OK begin end process; end architecture; nvc-r1.17.1/test/parse/guarded.vhd000066400000000000000000000013021504111170000167420ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x, y, z, q, b : bit; begin x <= guarded y; -- Error with b select z <= guarded q when others; -- Error b1: block (b = '1') is begin x <= guarded y; -- OK with b select z <= guarded q when others; -- OK assert guard; -- OK end block; b2: block is signal guard : boolean := true; -- OK signal q : bit; disconnect q : bit after 0 ns; -- OK (sem failure) begin x <= guarded y; -- OK with b select z <= guarded q when others; -- OK end block; end architecture; nvc-r1.17.1/test/parse/hang.vhd000066400000000000000000000007461504111170000162570ustar00rootroot00000000000000entity ent is begin end entity ent; architecture arch of ent is constant i : integer := 0e100000000000; -- used to hang here begin end architecture arch; -------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; package hang is constant c0 : std_logic_vector (31 downto 0) := 32sb"1"; -- ok -- used to hang on line below constant c1 : std_logic_vector (31 downto 0) := 32222222222sb"1"; end package; nvc-r1.17.1/test/parse/homograph.vhd000066400000000000000000000011071504111170000173160ustar00rootroot00000000000000package pack is constant x : integer := 10; end package; entity e is end entity; architecture a of e is procedure test1 is constant x : integer := 5; use work.pack.x; -- OK (work.pack.x is potentially visible and hidden -- by local x above) begin assert x = 5; -- OK end procedure; procedure test2 is use work.pack.x; constant x : integer := 5; begin assert x = 5; -- OK end procedure; begin end architecture; nvc-r1.17.1/test/parse/implicit.vhd000066400000000000000000000005031504111170000171430ustar00rootroot00000000000000package implicit is type unsigned is array (natural range <>) of bit; function ">="(x, y : unsigned) return boolean; end package; package body implicit is procedure test is variable a, b : unsigned(1 to 5); begin assert a >= b; -- OK end procedure; end package body; nvc-r1.17.1/test/parse/instance.vhd000066400000000000000000000023351504111170000171420ustar00rootroot00000000000000entity instance is end entity; entity foo is port ( a, b, c : in integer := 0; x : out integer ); end entity; architecture goo of foo is begin end architecture; configuration bar of foo is use work.foo; for goo end for; end configuration; package p is component c is port ( x : bit ); end component; end package; entity something is port ( a : in bit := '0' ) ; end entity ; use work.p; use work.something; architecture test of instance is component foo is end component; signal x, c : integer; signal s1, s2, s3 : integer; signal v : bit_vector(1 to 3); begin a: foo; b: entity work.foo; b1: entity work.foo(goo); c1: configuration work.bar; d: component foo; e: entity work.foo port map ( s1, s2, s3 ); f: entity work.foo port map ( s1, s2, x => s3 ); g: entity work.foo generic map ( X => 1 ) port map ( s1, s2 ); h: entity work.foo port map ( a => open ); i: foo port map ( x ); j: work.p.c port map ( '1' ); k: v(1) port map ( x ); l: entity something; m: component something; -- Error n: configuration something; -- Error end architecture; nvc-r1.17.1/test/parse/interface.vhd000066400000000000000000000005731504111170000173000ustar00rootroot00000000000000package pack045c is type rec_t is record a : integer ; b : string ; c : bit_vector(7 downto 0) ; d : bit_vector(0 to -1) ; end record ; view master of rec_t is a : in ; b : out ; c : out ; d : inout ; end view ; alias slave is master'converse ; end package ; nvc-r1.17.1/test/parse/ir1045.vhd000066400000000000000000000004301504111170000162540ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x : bit_vector(1 to 3); signal y : bit; begin -- Test corner case in lexer -- http://www.eda-stds.org/isac/IRs-VHDL-93/IR1045.txt x <= bit_vector'('1','0','1'); y <= bit'('1'); end architecture; nvc-r1.17.1/test/parse/issue1038.vhd000066400000000000000000000122011504111170000167730ustar00rootroot00000000000000package foo_pkg is signal sig: integer; end foo_pkg; package body foo_pkg is package bar_pkg is signal sig: integer; end bar_pkg; package body bar_pkg is end package body bar_pkg; end package body foo_pkg; -------------------------------------------------------------------------------- package foo is alias TO_OCTAL_STRING is ns; end package foo; -------------------------------------------------------------------------------- ENTITY psl_func_in_primary IS END psl_func_in_primary; ARCHITECTURE arch OF psl_func_in_primary IS TYPE integer_array IS ARRAY (NATURAL RANGE <>) OF INTEGER; FUNCTION func1(ia: integer_array := (1,2,3,next)) RETURN BOOLEAN IS BEGIN RETURN false; END FUNCTION func1; BEGIN END ARCHITECTURE arch; -------------------------------------------------------------------------------- package long_pkg is end package; package body long_pkg is procedure bar is begin report "" ; natural ; end procedure; end package body; -------------------------------------------------------------------------------- package resolution_fn_err is constant c : positive; subtype sub is c'active positive; end package; nvc-r1.17.1/test/parse/issue1055.vhd000066400000000000000000000006371504111170000170040ustar00rootroot00000000000000package pack1 is type t_int_vec is array (natural range <>) of integer; type t_real_vec is array (natural range <>) of real; function resolved (x : t_int_vec) return integer; function resolved (x : t_real_vec) return real; end package; ------------------------------------------------------------------------------- package pack2 is subtype t_int is work.pack1.resolved integer; end package; nvc-r1.17.1/test/parse/issue1090.vhd000066400000000000000000000003101504111170000167670ustar00rootroot00000000000000package p1 is end p1; use work.p1.all; -- Error package p1 is constant c : natural := 5; end p1; use work.p1.all; -- Error entity p1 is end entity; nvc-r1.17.1/test/parse/issue1091.vhd000066400000000000000000000013171504111170000170000ustar00rootroot00000000000000entity adderN is port(addend: in boolean); end; architecture struct_adderN of adderN is component adder is port(addend: in boolean); end component; begin u: adder port map(addend'last_value => addend); end; -------------------------------------------------------------------------------- PACKAGE Vital_Memory IS END PACKAGE Vital_Memory; PACKAGE BODY Vital_Memory IS PROCEDURE InternalTimingCheck (CONSTANT SetupHigh : IN TIME := 0 ns) IS BEGIN END InternalTimingCheck; PROCEDURE VitalMemorySetupHoldCheck (SIGNAL TestSignal : IN time) IS BEGIN InternalTimingCheck (WORK.SetupHigh => TestSignal); END VitalMemorySetupHoldCheck; END PACKAGE BODY Vital_Memory; nvc-r1.17.1/test/parse/issue1091b.vhd000066400000000000000000000007621504111170000171450ustar00rootroot00000000000000PACKAGE Vital_Memory IS END Vital_Memory; PACKAGE BODY Vital_Memory IS PROCEDURE MemoryTableCorruptMask ( VARIABLE CorruptMask : OUT INTEGER ) IS BEGIN END; PROCEDURE MemoryTableLookUp ( VARIABLE DataCorruptMask : OUT INTEGER; CONSTANT EnableIndex : IN INTEGER ) IS BEGIN MemoryTableCorruptMask ( CorruptMask => DataCorruptMask, EnableIndex => EnableIndex ); END; END PACKAGE BODY Vital_Memory; nvc-r1.17.1/test/parse/issue1096.vhd000066400000000000000000000012371504111170000170060ustar00rootroot00000000000000entity ent is generic (A: integer := 0); end entity ent; -------------------------------------------------------------------------------- entity top is end entity top; architecture arch of top is component ent is generic (A: integer := 1); end component ent; for inst : ent use entity work.ent generic map (A => 2); begin inst : component ent generic map (A => 3); end architecture arch; -------------------------------------------------------------------------------- configuration conf of top is for arch for others : ent -- OK (not yet supported) generic map (A => 4); end for; end for; end configuration conf; nvc-r1.17.1/test/parse/issue1124.vhd000066400000000000000000000010771504111170000170000ustar00rootroot00000000000000entity issue1124 is end entity; architecture test of issue1124 is type t_logic is ('U', 'X', '1', '0'); type t_logic_vector is array (natural range <>) of t_logic; function or_reduce(arg: t_logic_vector) return t_logic is begin return '1'; end function; function "??" (l : t_logic) return boolean is begin return false; end function; signal s : t_logic_vector(7 downto 0); begin process is begin if or_reduce(s(3 downto 0)) then -- OK end if; wait; end process; end architecture; nvc-r1.17.1/test/parse/issue1129.vhd000066400000000000000000000010171504111170000167770ustar00rootroot00000000000000entity pragma_test is end pragma_test; architecture dummy of pragma_test is -- OK begin synerror: assert false -- pragma translate_off or true -- pragma translate_on report "dummy model found during synthesis" severity failure; end architecture dummy; architecture dummy2 of pragma_test is -- generates parsing error begin synerror: assert false -- pragma translate_off or true -- pragma translate_on report "dummy model found during synthesis" severity failure; end architecture dummy2; nvc-r1.17.1/test/parse/issue1138.vhd000066400000000000000000000010201504111170000167710ustar00rootroot00000000000000entity test is end entity test; architecture rtl of test is subtype slv64_type is bit_vector(0 to 63); type slv64_array_type is array (natural range <>) of slv64_type; constant zeroes : bit_vector(0 to 31) := x"00000000"; constant more_zeroes : bit_vector(0 to 31) := x"00000000"; -- doesn't work in nvc 1.15.0, works in nvc 1.14.2 -- error: ambiguous use of operator "&" constant test_constant : slv64_array_type := (zeroes & more_zeroes, zeroes & more_zeroes); begin end architecture rtl; nvc-r1.17.1/test/parse/issue1152.vhd000066400000000000000000000011321504111170000167710ustar00rootroot00000000000000package p1 is constant c1 : integer := 5; end package; ------------------------------------------------------------------------------- use work.p1.all; package p2 is constant c2 : integer := c1; end package; ------------------------------------------------------------------------------- package p1 is constant c1 : integer := 6; end package; ------------------------------------------------------------------------------- entity order4 is end entity; use work.p1.all; use work.p2.all; architecture test of order4 is begin assert c1 = 6; assert c2 = 6; end architecture; nvc-r1.17.1/test/parse/issue1174.vhd000066400000000000000000000014041504111170000167770ustar00rootroot00000000000000package Test_P is type Test_R_t is record s_1 : bit_vector; s_2 : bit_vector; end record Test_R_t; type Test_A_t is array(natural range <>) of Test_R_t; function clog2 (val: integer) return integer; end package; ------------------------------------------------------------------------------- use work.Test_p.all; entity Test is generic( g_Test_1 : integer; g_Test_2 : integer ); port( clk : in bit; test : out Test_A_t(0 to g_Test_1)( s_1(clog2(g_Test_2)-1 downto 0), s_2(clog2(g_Test_2)-1 downto 0) ) ); end entity Test; architecture Behavioral of Test is begin process(all) is variable v_test : test'subtype; -- OK (should not call clog2) begin end process; end architecture; nvc-r1.17.1/test/parse/issue1188.vhd000066400000000000000000000016051504111170000170070ustar00rootroot00000000000000package pkg is function f_gen( use_id : boolean; id : bit_vector(15 downto 0) := x"1234" ) return bit_vector; end pkg; package body pkg is constant C_ID : bit_vector(15 downto 0) := x"0110"; function f_if(c : boolean; t : bit; f : bit) return bit is variable r : bit; begin r := t when c else f; return r; end; function f_if(c : boolean; t : bit_vector; f : bit_vector) return bit_vector is variable r : bit_vector(t'range); begin r := t when c else f; return r; end; function f_gen( use_id : boolean; id : bit_vector(15 downto 0) := x"1234" ) return bit_vector is variable ret : bit_vector(31 downto 0); begin ret := ( 31 downto 16 => C_ID, 15 downto 0 => f_if(use_id, t=> id, f=> C_ID) -- OK ); return ret; end; end package body pkg; nvc-r1.17.1/test/parse/issue1202.vhd000066400000000000000000000003511504111170000167670ustar00rootroot00000000000000package my_package is generic ( x : integer ); end package; entity foo is generic ( package pkg is work.my_package generic map (<>)); end entity; architecture rtl of foo is use pkg.all; begin end architecture; nvc-r1.17.1/test/parse/issue1249.vhd000066400000000000000000000011161504111170000170020ustar00rootroot00000000000000entity issue1249 is end entity; architecture test of issue1249 is type int_ptr is access integer; procedure test (x : string; variable y : int_ptr) is begin end procedure; procedure test (x : string; y : bit_vector) is begin end procedure; begin process is type line is access string; type line_vector is array (0 to 1) of line; variable multiple_strings : line_vector := (new string'("file.txt"), new string'("file12.txt")); begin test(to_string(1), new integer'(1)); wait; end process; end architecture; nvc-r1.17.1/test/parse/issue205.vhd000066400000000000000000000002211504111170000167050ustar00rootroot00000000000000entity ent is end entity; architecture a of ent is begin main : process begin report """"""; wait; end process; end architecture; nvc-r1.17.1/test/parse/issue222.vhd000066400000000000000000000021241504111170000167100ustar00rootroot00000000000000entity sub_ent is end entity; architecture a of sub_ent is begin end architecture a; entity test is end entity; architecture test1 of test is begin entity work.sub_ent; -- unlabeled entity instantiation end architecture; architecture test2 of test is begin fg1: for ii in 0 to 0 generate begin end generate; block -- unlabeled block begin end block; end architecture; architecture test3 of test is component comp is port (a: boolean); end component; signal s_ok: boolean; begin comp port map (a => s_ok); -- unlabeled component instantiation end architecture; architecture test5 of test is begin if true generate -- unlabeled if-generate begin end generate; end architecture; architecture test6 of test is component comp is port (a: boolean); end component; signal s_ok: boolean; begin -- include labeled testcases to make sure they are ok e1: entity work.sub_ent; b1: block begin end block; c1: comp port map (a => s_ok); ig1: if true generate begin end generate; for ii in 0 to 0 generate -- unlabeled for-generate begin end generate; end architecture; nvc-r1.17.1/test/parse/issue360.vhd000066400000000000000000000002321504111170000167110ustar00rootroot00000000000000entity bug is end entity; architecture a of bug is begin main : process is begin end; end; -- Used to hang here nvc-r1.17.1/test/parse/issue367.vhd000066400000000000000000000005761504111170000167330ustar00rootroot00000000000000package r is function r1(a:bit_vector) return bit_vector; end package; package body r is function r1(a:bit_vector) return bit_vector is variable ret : bit_vector(a'range); variable i : integer range a'range; -- Error here begin for i in a'range loop ret(i) := not a(i); end loop; return ret; end r1; end r; nvc-r1.17.1/test/parse/issue369.vhd000066400000000000000000000007661504111170000167360ustar00rootroot00000000000000entity ir1045 is end entity; architecture foo of ir1045 is begin THIS_PROCESS: process type twovalue is ('0', '1'); subtype string4 is string(1 to 4); attribute a: string4; attribute a of '1' : literal is "TRUE"; begin assert THIS_PROCESS.'1''a /= "TRUE" report "'1''a /= ""TRUE"" is FALSE"; report "THIS_PROCESS.'1''a'RIGHT = " & integer'image(THIS_PROCESS.'1''a'RIGHT); wait; end process; end architecture; nvc-r1.17.1/test/parse/issue388.vhd000066400000000000000000000005271504111170000167320ustar00rootroot00000000000000entity e is port ( input : in bit_vector(7 downto 0); output : out bit_vector(7 downto 0) ); end entity; architecture a of e is begin x: entity work.e port map ( input(7 downto 0 => blah, output(7 downto 0) => q ); call(x, y, z); -- Crash here after earlier error end architecture; nvc-r1.17.1/test/parse/issue416.vhd000066400000000000000000000001601504111170000167130ustar00rootroot00000000000000entity e is port ( x : in bit_vector(8+23+2 downto 0) ); -- Error with prefer-explicit end entity; nvc-r1.17.1/test/parse/issue443.vhd000066400000000000000000000027621504111170000167250ustar00rootroot00000000000000package TYPES is type SHAPE_TYPE is record ELEM_BITS : integer; X : integer; Y : integer; end record; function NEW_SHAPE(ELEM_BITS,X,Y: integer) return SHAPE_TYPE; type STRIDE_TYPE is record X : integer; Y : integer; end record; function NEW_STRIDE(X,Y:integer) return STRIDE_TYPE; type PARAM_TYPE is record ELEM_BITS : integer; INFO_BITS : integer; STRIDE : STRIDE_TYPE; SHAPE : SHAPE_TYPE; end record; function NEW_PARAM( ELEM_BITS : integer; INFO_BITS : integer := 0; SHAPE : SHAPE_TYPE; STRIDE : STRIDE_TYPE) return PARAM_TYPE; function NEW_PARAM( ELEM_BITS : integer; INFO_BITS : integer := 0; SHAPE : SHAPE_TYPE) return PARAM_TYPE; end TYPES; use WORK.TYPES.all; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is constant ELEM_BITS : integer := 8; constant PARAM : PARAM_TYPE := NEW_PARAM( ELEM_BITS => ELEM_BITS, SHAPE => NEW_SHAPE(ELEM_BITS,3,3) ); begin end MODEL; nvc-r1.17.1/test/parse/issue457.vhd000066400000000000000000000003371504111170000167260ustar00rootroot00000000000000context test_context is end context; ------------------------------------------------------------------------------- library test_context; use test_context.test_context.all; -- Error entity test is end entity test; nvc-r1.17.1/test/parse/issue458.vhd000066400000000000000000000006131504111170000167240ustar00rootroot00000000000000package test is constant C_ZERO : bit_vector(4 downto 0) := 5d"0"; constant C_ONE : bit_vector(4 downto 0) := 5d"1"; constant C_TWO : bit_vector(4 downto 0) := 5d"2"; constant C_THREE : bit_vector(4 downto 0) := 5d"3"; constant C_TWENTY : bit_vector(4 downto 0) := 5d"20"; end package test; nvc-r1.17.1/test/parse/issue461.vhd000066400000000000000000000004101504111170000167110ustar00rootroot00000000000000package test_pkg is type t_test is (ONE, TWO); end package; package test2_pkg is alias t_test is work.test_pkg.t_test; end package; use work.test_pkg.all; use work.test2_pkg.all; entity test is generic( test_type : t_test := ONE ); end entity test; nvc-r1.17.1/test/parse/issue464.vhd000066400000000000000000000011051504111170000167160ustar00rootroot00000000000000entity test is end entity test; architecture beh of test is type t_alert_level is (NO_ALERT, NOTE, TB_NOTE, WARNING, TB_WARNING, MANUAL_CHECK, ERROR, TB_ERROR, FAILURE, TB_FAILURE); function f_test return boolean is begin for i in NOTE to t_alert_level'right loop null; end loop; return false; end function; type t1 is (a,b); type t2 is (b,c); type t3 is (c,d); BEGIN -- Was vests tc1551 TESTING: PROCESS variable k : integer := 0; BEGIN for i in c downto b loop k := 5; end loop; end process; end architecture beh; nvc-r1.17.1/test/parse/issue468.vhd000066400000000000000000000001201504111170000167160ustar00rootroot00000000000000package test2 is shared variable shared_var : work.test3.t_prot; end package; nvc-r1.17.1/test/parse/issue479.vhd000066400000000000000000000012731504111170000167320ustar00rootroot00000000000000package prot_pkg is type t_prot is protected impure function get return natural; end protected t_prot; end package prot_pkg; package body prot_pkg is type t_prot is protected body impure function get return natural is begin return 1; end function get; end protected body t_prot; end package body prot_pkg; ---------- use work.prot_pkg.all; package shared_pkg is shared variable shared_var_prot : t_prot; end package shared_pkg; ---------- package test_pkg is alias shared_var_prot is work.shared_pkg.shared_var_prot; constant C_CONST : natural := shared_var_prot.get; constant C_CONST2 : natural := work.shared_pkg.shared_var_prot.get; -- Works end package; nvc-r1.17.1/test/parse/issue532.vhd000066400000000000000000000013641504111170000167210ustar00rootroot00000000000000package test_pkg is type t_test_rec is record a : bit_vector; b : bit_vector; end record t_test_rec; -- first declaration procedure test_proc( t : in t_test_rec ); -- overload procedure test_proc( a : in bit_vector; b : in bit_vector ); end package test_pkg; package body test_pkg is -- first declaration procedure test_proc( t : in t_test_rec ) is begin -- do something end procedure test_proc; -- overload procedure test_proc( a : in bit_vector; b : in bit_vector ) is begin test_proc( t.a => a, t.b => b ); end procedure test_proc; end package body test_pkg; nvc-r1.17.1/test/parse/issue539.vhd000066400000000000000000000010761504111170000167300ustar00rootroot00000000000000package my_package is type slv_1_t is array (natural range <>) of bit_vector; function addslvreg_f(arg0 : slv_1_t; arg1 : bit_vector) return slv_1_t; end package my_package; package body my_package is function addslvreg_f(arg0 : slv_1_t; arg1 : bit_vector) return slv_1_t is variable cb_v : bit_vector(0 downto 0); variable arg_v,retval : arg0'subtype; -- OK variable foo : slv_1_t(arg0'range); -- Error constant W : integer := arg0(0)'length-1; begin return retval; end function addslvreg_f; end package body; nvc-r1.17.1/test/parse/issue541.vhd000066400000000000000000000012231504111170000167130ustar00rootroot00000000000000entity test is end entity; architecture beh of test is type t_integer_array is array (natural range <>) of integer; procedure check_val( constant values : in t_integer_array; constant name : in string := "" ) is begin end procedure; procedure check_val( constant values_1 : in integer_vector; constant values_2 : in integer_vector; constant name : in string := "" ) is begin end procedure; begin p_proc : process begin check_val(((0 => 1),(0 => 200),(0 => 300)), name => "bin_"); wait; end process; end architecture; nvc-r1.17.1/test/parse/issue568.vhd000066400000000000000000000004151504111170000167260ustar00rootroot00000000000000package pack is function "=" (L: bit; R: bit) return bit; end package; use work.pack.all; entity issue568 is generic (x : boolean); end entity; architecture test of issue568 is signal y : bit; begin p1: assert (y = '1') or (not x); end architecture; nvc-r1.17.1/test/parse/issue569.vhd000066400000000000000000000004371504111170000167330ustar00rootroot00000000000000-- library foo package pack is component comp is port ( p : in bit ); end component; end package; -- library bar library foo; entity e is end entity; architecture a of e is begin u: component foo.pack.comp -- OK port map ( '1' ); end architecture; nvc-r1.17.1/test/parse/issue580.vhd000066400000000000000000000005671504111170000167300ustar00rootroot00000000000000entity issue580 is end entity; architecture test of issue580 is type rec_t is record bits : bit_vector; end record; type rec_array_t is array (natural range <>) of rec_t; subtype sub_t is rec_array_t(open)(bits(1 to 3)); -- OK signal s1 : sub_t(1 to 4); -- OK signal s2 : sub_t; -- Error begin end architecture; nvc-r1.17.1/test/parse/issue604.vhd000066400000000000000000000015561504111170000167240ustar00rootroot00000000000000package issue604 is `if TOOL_NAME = "nvc" then constant CHECK1 : string := "NVC" ; `else constant CHECK1 : string := "UNDEFINED" ; `end `if TOOL_NAME = "ghdl" then `warning "Tool is GHDL" `elsif TOOL_NAME = "nvc" then `warning "Tool is NVC" `elsif TOOL_NAME = "foobar" then `error "error" `else `error "Should not reach here" `end if `elsif TOOL_VERSION >= "3000" then `end if `if TOOL_TYPE = "SYNTHESIS" then `if TOOL_NAME = "Vivado" then constant CHECK : string := "x" ; `else constant CHECK : string := "UNDEFINED_SYNTH" ; `end `else `if TOOL_NAME = "Riviera-PRO" then constant CHECK : string := "y" ; `elsif TOOL_NAME = "nvc" then constant CHECK : string := "z" ; `else constant CHECK : string := "UNDEFINED_SIM" ; `end `end end package; nvc-r1.17.1/test/parse/issue644.vhd000066400000000000000000000026431504111170000167260ustar00rootroot00000000000000package mux is generic ( MUX_DATA_SIZE : natural ); subtype mux_data is bit_vector(MUX_DATA_SIZE-1 downto 0); type mux_data_array is array (natural range <>) of mux_data; end package; entity multiplexer is generic ( MUX_DATA_SIZE : natural; MUX_CTRL_SIZE : natural; --package mux_g is new work.mux generic map(MUX_DATA_SIZE => MUX_DATA_SIZE) package mux_g is new work.mux generic map(<>) ); port ( MUX_CTRL : in bit_vector(MUX_CTRL_SIZE-1 downto 0); MUX_IN : in mux_g.mux_data_array(0 to 2**MUX_CTRL_SIZE-1); MUX_OUT : out mux_g.mux_data ); end entity; architecture multiplexer_arch of multiplexer is begin MUX_OUT <= MUX_IN(MUX_CTRL_SIZE - 1); end architecture; entity issue644 is end entity ; architecture arch of issue644 is constant MUX_DATA_SIZE : natural := 2 ; constant MUX_CTRL_SIZE : natural := 2 ; package mux_g is new work.mux generic map(MUX_DATA_SIZE => MUX_DATA_SIZE) ; signal MUX_CTRL : bit_vector(MUX_CTRL_SIZE-1 downto 0) ; signal MUX_IN : mux_g.mux_data_array(0 to 2**MUX_CTRL_SIZE-1) ; signal MUX_OUT : mux_g.mux_data ; begin U_multiplexer : entity work.multiplexer generic map ( MUX_DATA_SIZE => MUX_DATA_SIZE, MUX_CTRL_SIZE => MUX_CTRL_SIZE, mux_g => mux_g ) port map ( MUX_CTRL => MUX_CTRL, MUX_IN => MUX_IN, MUX_OUT => MUX_OUT ) ; end architecture ; nvc-r1.17.1/test/parse/issue653.vhd000066400000000000000000000023541504111170000167250ustar00rootroot00000000000000package axi4s is type axis_t is record data : bit_vector ; dest : bit_vector ; id : bit_vector ; strb : bit_vector ; keep : bit_vector ; user : bit_vector ; last : bit ; valid : bit ; ready : bit ; end record ; type axis_array_t is array(natural range <>) of axis_t ; package make is generic ( DATA_BYTES : positive := 4 ; DEST_WIDTH : natural := 0 ; ID_WIDTH : natural := 0 ; USER_WIDTH : natural := 0 ) ; subtype DATA_RANGE is natural range DATA_BYTES*8-1 downto 0 ; subtype DEST_RANGE is natural range DEST_WIDTH-1 downto 0 ; subtype ID_RANGE is natural range ID_WIDTH-1 downto 0 ; subtype KEEP_RANGE is natural range DATA_BYTES-1 downto 0 ; subtype USER_RANGE is natural range USER_WIDTH-1 downto 0 ; subtype axis_t is axi4s.axis_t( data(DATA_RANGE), dest(DEST_RANGE), id(ID_RANGE), keep(KEEP_RANGE), strb(KEEP_RANGE), user(USER_RANGE) ) ; end package ; end package ; package axis32 is new work.axi4s.make ; nvc-r1.17.1/test/parse/issue654.vhd000066400000000000000000000022421504111170000167220ustar00rootroot00000000000000package frequency is type frequency is range 0 to 2e9 units Hz ; kHz = 1000 Hz ; MHz = 1000 kHz ; GHz = 1000 MHz ; THz = 1000 GHz ; end units ; function half_period(freq : frequency) return time ; function period(freq : frequency) return time ; procedure generate_clock generic ( type t ; function "not"(x : t) return t is <> ) parameter (signal clock : inout t ; freq : frequency ; count : natural := 0) ; procedure generate_clock is new generate_clock -- OK generic map(t => bit) ; procedure bad1 is new generate_clock [return integer]; -- Error procedure bad2 is new "+"; -- Error procedure generate_clock generic ( type t ; function "not"(x : t) return t is <> ) parameter (signal clock : inout t) ; procedure bad3 is new generate_clock; -- Error procedure test1 generic (type t) (x : t); procedure test1 is new test1 generic map (integer); -- OK end package ; package body frequency is procedure test1 generic (type t) (x : t) is begin generate_clock(bit, 1 Hz); -- Error end procedure; end package body; nvc-r1.17.1/test/parse/issue663.vhd000066400000000000000000000017341504111170000167270ustar00rootroot00000000000000entity issue663 is end entity; architecture test of issue663 is function get_data return bit_vector is begin return "10"; end function; function get_data return bit is begin return '1'; end function; function get_zeros(n : integer) return bit_vector is begin return (1 to n => '0'); end function; function get_zeros(n : integer) return bit is begin assert n = 1; return '0'; end function; signal x, y : bit; begin p1: process is variable a, b : bit; begin (a, b) := get_data; -- OK a := get_data; -- OK (a, b) := get_zeros(2); -- OK a := get_zeros(1); -- OK (x, y) <= get_data; -- OK x <= get_data; -- OK (x, y) <= get_zeros(2); -- OK x <= get_zeros(1); -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/issue686.vhd000066400000000000000000000005261504111170000167320ustar00rootroot00000000000000package pack1 is type t is (a, b); end package; ------------------------------------------------------------------------------- package pack2 is generic (type g); end package; ------------------------------------------------------------------------------- use work.pack1; package pack3 is new work.pack2 generic map ( pack1.t ); nvc-r1.17.1/test/parse/issue687.vhd000066400000000000000000000006761504111170000167410ustar00rootroot00000000000000entity record_name is end entity record_name; architecture rtl of record_name is subtype byte is bit_vector(7 downto 0); type byte_vector is array (natural range <>) of byte; type my_record is record my_record : byte_vector(0 to 4); end record my_record; constant MY_CONST : my_record := (my_record => (others => x"00")); -- OK constant test2 : my_record := (integer => 1); -- Error begin end architecture rtl; nvc-r1.17.1/test/parse/issue688.vhd000066400000000000000000000007151504111170000167340ustar00rootroot00000000000000-- compile to library "test" package pkg is procedure reset; end package pkg; ------------------------------------------------------------------------------- library test; use test.pkg; entity ent is end entity ent; architecture test of ent is -- Change the architecture to anything but "test" to make it work begin p : process is begin pkg.reset; wait; end process p; end architecture test; nvc-r1.17.1/test/parse/issue701.vhd000066400000000000000000000004621504111170000167150ustar00rootroot00000000000000entity samples is end entity; architecture test of samples is type sample is array (natural range <>) of integer; type dozen_samples is array (1 to 12) of sample; subtype dozen_short_samples is dozen_samples(open)(0 to 9); signal my_dozen: dozen_short_samples; -- OK begin end architecture; nvc-r1.17.1/test/parse/issue708.vhd000066400000000000000000000006651504111170000167310ustar00rootroot00000000000000package ScoreboardGenericPkg is generic ( type ExpectedType ; type ActualType ; function Match(Actual : ActualType ; -- defaults Expected : ExpectedType) return boolean ; -- is "=" ; function expected_to_string(A : ExpectedType) return string ; -- is to_string ; function actual_to_string (A : ActualType) return string -- is to_string ; ) ; end package; nvc-r1.17.1/test/parse/issue727.vhd000066400000000000000000000033221504111170000167230ustar00rootroot00000000000000package types_pkg is type t_slv_array is array (natural range <>) of bit_vector; subtype t_word is bit_vector(15 downto 0); subtype t_word_array is t_slv_array(open)(t_word'range); subtype t_addr is natural range 1 to 30; type t_data is array (t_addr) of t_word_array(0 to 31); end package types_pkg; use work.types_pkg.all; package protected_pkg is type t_config_interface is protected impure function get_val return t_data; end protected t_config_interface; end package protected_pkg; package body protected_pkg is type t_config_interface is protected body variable v_data : t_data := (others => (others => (others => '0'))); impure function get_val return t_data is begin return v_data; end function get_val; end protected body t_config_interface; end package body; use work.protected_pkg.all; package shared_variables_pkg is shared variable shared_config : t_config_interface; end package shared_variables_pkg; use work.types_pkg.all; use work.shared_variables_pkg.all; package test_pkg is impure function randomize(constant val : t_word_array) return t_word_array; impure function randomize(constant sub_address : bit_vector) return t_word_array; end package test_pkg; package body test_pkg is impure function randomize(constant val : t_word_array) return t_word_array is begin return val; end function; impure function randomize(constant sub_address : bit_vector) return t_word_array is variable v_test : t_word_array(0 to 31); begin v_test := shared_config.get_val(14); -- OK v_test := randomize(v_test); -- OK return randomize(shared_config.get_val(12)); -- OK end function randomize; end package body; nvc-r1.17.1/test/parse/issue751.vhd000066400000000000000000000010651504111170000167220ustar00rootroot00000000000000entity issue751 is end entity; architecture test of issue751 is begin -- No Label on this process process is -- _P0 function outer return integer is -- WORK.ISSUE751-TEST._P0.OUTER function inner return integer is -- WORK.ISSUE751-TEST._P0.OUTER.INNER begin return 42; end function; begin return inner; end function; type abc is (A, B, C); -- WORK.ISSUE751-TEST._P0.ABC begin wait; end process; end architecture; nvc-r1.17.1/test/parse/issue753.vhd000066400000000000000000000005251504111170000167240ustar00rootroot00000000000000entity dummy_unit is port( -- coverage off clk : in bit; -- slow clk o_port : out bit_vector(1 downto 0) ); end entity dummy_unit; architecture rtl of dummy_unit is begin -- pragma translate_off o_port(0) <= clk; -- synthesis translate_off o_port(1) <= clk; end architecture rtl; nvc-r1.17.1/test/parse/issue760.vhd000066400000000000000000000004401504111170000167160ustar00rootroot00000000000000package issue760 is type t_array is array (natural range <>) of integer; end package; package body issue760 is -- Hides predef defined in package header impure function to_string (x : t_array) return string is begin return ""; end function; end package body; nvc-r1.17.1/test/parse/issue761.vhd000066400000000000000000000013131504111170000167170ustar00rootroot00000000000000entity issue761 is end entity; architecture test of issue761 is procedure test1 (id : natural; arg1, arg2 : integer; msg : string) is begin end procedure; procedure test1 (id : natural; arg1, arg2 : real; msg : string) is begin end procedure; function get (x : string; i : integer) return integer is begin return 0; end function; function get (x : string; i : integer) return real is begin return 0.0; end function; begin p1: process is constant param : string := "foo"; begin for i in 1 to 5 loop test1(5, get(param, i), -i, "blah"); -- OK end loop; wait; end process; end architecture; nvc-r1.17.1/test/parse/issue776.vhd000066400000000000000000000015061504111170000167310ustar00rootroot00000000000000package test_pkg is type t_type is (ONE, TWO, THREE); type t_phys is range 1 to 1000000 units thing; kilothing = 1000 thing; end units; subtype t_sub is t_type range TWO to THREE; end package test_pkg; ------------------------------------------------------------------------------- entity test is end entity; architecture beh of test is alias t_type is work.test_pkg.t_type; alias t_phys is work.test_pkg.t_phys; alias t_sub is work.test_pkg.t_sub; begin p_proc : process constant const : t_type := ONE; constant const2 : t_phys := 5 kilothing; begin report to_string(const); -- OK assert const = ONE; -- OK report to_string(const2); -- OK assert const2 * 2.0 = const2; -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/issue783.vhd000066400000000000000000000003041504111170000167220ustar00rootroot00000000000000-- Compile into library "foo" -- entity foo is port ( i: in bit; o: out bit ); end; architecture bar of foo is begin o <= i; end; configuration foo_bar of foo is for bar end for; end; nvc-r1.17.1/test/parse/issue789.vhd000066400000000000000000000010121504111170000167250ustar00rootroot00000000000000package test_pkg is type t_test is (GL, RTL); end package; use work.test_pkg.all; entity test1 is generic ( GC_TEST_TYPE : t_test ); end entity; architecture rtl of test1 is begin g_test : if GC_TEST_TYPE = RTL generate p_proc : process begin wait; end process; end generate g_test; end architecture; use work.test_pkg.all; entity test is end entity; architecture rtl of test is signal sig : bit; begin i_test1 : work.test1 generic map (GC_TEST_TYPE => RTL); end architecture; nvc-r1.17.1/test/parse/issue792.vhd000066400000000000000000000013021504111170000167210ustar00rootroot00000000000000package com_if_pkg is constant C_NOM_IDX : natural := 1; constant C_RED_IDX : natural := 2; type t_com_if is (NOM, RED); type t_com_type is (UART); type t_com_interface is protected procedure set(constant value : t_com_if); impure function get return natural; end protected t_com_interface; end package com_if_pkg; use work.com_if_pkg.all; package com_if_shared_pkg is shared variable protected_com_if : t_com_interface; end package com_if_shared_pkg; use work.com_if_pkg.all; use work.com_if_shared_pkg.all; package com_pkg is alias t_com_if is work.com_if_pkg.t_com_if; -- Crash here alias protected_com_if is work.com_if_shared_pkg.protected_com_if; end package; nvc-r1.17.1/test/parse/issue793.vhd000066400000000000000000000023241504111170000167270ustar00rootroot00000000000000entity issue793 is end entity; architecture test of issue793 is procedure check_setup( name : in string; t : in time; clk : in bit; data : in bit_vector; -- v4p ignore never-read pol : in bit := '1' -- clock edge: 1 = rising, 0 = falling ) is variable ti : time; begin end procedure check_setup; procedure check_setup( name : in string; t : in time; clk : in bit; data : in bit; pol : in bit := '1' -- clock edge: 1 = rising, 0 = falling ) is begin check_setup( name => name, t => t, clk => clk, data(0) => data, pol => pol ); -- OK check_setup( name => name, t => t, clk => clk, data(1 to 1) => data & '0', pol => pol ); -- OK check_setup( name => name, t => t, clk => clk, data(0) => data, pol1 => pol ); -- Error end procedure check_setup; begin end architecture; nvc-r1.17.1/test/parse/issue802.vhd000066400000000000000000000022041504111170000167130ustar00rootroot00000000000000package my_logic is type STD_ULOGIC is ( 'U', -- Uninitialized 'X', -- Forcing Unknown '0', -- Forcing 0 '1', -- Forcing 1 'Z', -- High Impedance 'W', -- Weak Unknown 'L', -- Weak 0 'H', -- Weak 1 '-' -- Don't care ); function "??" (x : std_ulogic) return boolean; subtype std_logic is std_ulogic; end package; -- types use work.my_logic.all; package fifo_types is alias logic is std_ulogic; alias "??" is "??" [std_ulogic return boolean]; -- alias logic_vec is std_ulogic_vector; end package; use work.fifo_types.all; -- fifo entity fifo is generic (constant DEPTH_W : positive := 8); port (ireset, irclk, rd_en, iwclk, wr_en : in logic); end entity; architecture rtl of fifo is begin write_proc : process (iwclk, ireset) is begin if ireset then end if; end process; end architecture; nvc-r1.17.1/test/parse/issue805.vhd000066400000000000000000000003121504111170000167140ustar00rootroot00000000000000entity bug is end entity; architecture mixed of bug is begin log: process is variable x : real; variable y : time; begin x := 2.0; y := abs(x*5.0)**2 * 1.0 ns; end process; end architecture; nvc-r1.17.1/test/parse/issue837.vhd000066400000000000000000000003201504111170000167200ustar00rootroot00000000000000entity issue837 is generic ( g : integer ); port ( p : in bit_vector(1 to g - 1) ); end entity; architecture test of issue837 is signal s : p'subtype; -- OK begin end architecture; nvc-r1.17.1/test/parse/issue845.vhd000066400000000000000000000006521504111170000167270ustar00rootroot00000000000000entity AliasRangeExample is end entity AliasRangeExample; architecture Bhv of AliasRangeExample is signal A: bit_vector(31 downto 0); signal B,C,D: bit_vector(7 downto 0); subtype aRange is natural range 7 downto 0; alias aRangeAlias is aRange; begin B <= A(aRange); -- okay C <= A(aRangeAlias'range); -- okay D <= A(aRangeAlias); -- ** Error: invalid use of alias ARANGEALIAS end architecture; nvc-r1.17.1/test/parse/issue848.vhd000066400000000000000000000021301504111170000167230ustar00rootroot00000000000000package test_pkg is shared variable v_test : natural; impure function func return natural; procedure proc(var : out natural); pure function test return natural; procedure proc2(var : out natural); pure function test2 return natural; procedure proc3(var : out natural); pure function test3 return natural; end package test_pkg; package body test_pkg is impure function func return natural is begin return v_test; end function; procedure proc(var : out natural) is begin var := func; end procedure; procedure proc2(var : out natural) is begin var := v_test; end procedure; procedure proc3(var : out natural) is begin proc2(var); end procedure; pure function test return natural is variable v_var : natural; begin proc(v_var); return v_var; end function; pure function test2 return natural is variable v_var : natural; begin proc2(v_var); return v_var; end function; pure function test3 return natural is variable v_var : natural; begin proc3(v_var); return v_var; end function; end package body; nvc-r1.17.1/test/parse/issue870.vhd000066400000000000000000000004111504111170000167160ustar00rootroot00000000000000entity ent is generic ( SEED1 : natural := 500 ); port ( clk : in bit ); end entity ent; architecture arch of ent is begin process(clk) variable seed1 : natural := SEED1; -- OK (relaxed rules) begin end process; end architecture arch; nvc-r1.17.1/test/parse/issue875.vhd000066400000000000000000000007271504111170000167350ustar00rootroot00000000000000package repro is subtype instruction32_t is bit_vector(31 downto 0); subtype opcode32_t is bit_vector(6 downto 0); function has_rd(op : opcode32_t) return boolean; function has_rd(ins : instruction32_t) return boolean; end; package body repro is function has_rd(op : opcode32_t) return boolean is begin return false; end function; function has_rd(ins : instruction32_t) return boolean is begin return true; end function; end package body; nvc-r1.17.1/test/parse/issue889.vhd000066400000000000000000000004671504111170000167430ustar00rootroot00000000000000entity issue889 is end entity; architecture test of issue889 is signal x, y : bit; attribute mark_debug : string; attribute mark_debug of all : signal is "True"; -- OK begin process is begin report x'mark_debug; -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/issue892.vhd000066400000000000000000000013101504111170000167210ustar00rootroot00000000000000entity issue892 is end entity; architecture test of issue892 is function foo (x : integer) return boolean is begin return true; end function; function foo (y : bit) return string is begin return "hello"; end function; type my_enum is ('1', '2'); attribute test : string; attribute test of '1' [return my_enum] : literal is "hello"; begin p: process is begin report foo [integer return boolean]'instance_name; -- OK report foo [bit return string]'instance_name; -- OK report p [integer return bit]'instance_name; -- Error report '1' [return my_enum]'test; -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/issue893.vhd000066400000000000000000000006121504111170000167260ustar00rootroot00000000000000package inner is constant a : integer := 42 ; end package ; package outer is alias inner is work.inner ; constant b : integer := inner.a; -- OK end package ; use work.outer.all ; entity test is end entity ; architecture arch of test is constant c : integer := inner.a; -- OK use inner.all; constant d : integer := a; -- OK begin end architecture ; nvc-r1.17.1/test/parse/issue905.vhd000066400000000000000000000021331504111170000167200ustar00rootroot00000000000000entity const_hides is port ( rst : in bit; clk : in bit; i_part : in bit; o_result : out bit ); end entity const_hides; architecture rtl of const_hides is constant C_NB : positive := 4; signal partA : bit_vector(C_NB downto 0); signal partB : bit_vector(C_NB downto 0); begin partA(0) <= i_part; gen_i : for i in 0 to C_NB-1 generate proc_i : process(clk, rst) begin if (rst = '1') then partA(i+1) <= '0'; elsif clk = '1' and clk'event then partA(i+1) <= partA(i); --loop_part : for k in 0 to i loop loop_part : for i in 0 to i loop -- reusing the same generate loop index by accident if (partA(i) = '1') then --partB(k+1) <= partB(k); partB(i+1) <= partB(i); end if; end loop loop_part; end if; end process proc_i; end generate gen_i; o_result <= partB(C_NB); end architecture rtl; nvc-r1.17.1/test/parse/issue917.vhd000066400000000000000000000022261504111170000167260ustar00rootroot00000000000000entity issue917 is end entity; architecture test of issue917 is function add (x, y : integer) return integer is begin return x + y; end function; impure function impure_func (x : integer) return integer is begin return x + 1; end function; begin b1: block is generic ( pure function f1 (x, y : integer) return integer ); -- OK generic map ( f1 => add ); -- OK begin end block; b2: block is generic ( impure function f1 (x : integer) return integer ); -- OK generic map ( f1 => impure_func ); -- OK begin end block; b3: block is generic ( function f1 (x : integer) return integer ); -- OK generic map ( f1 => impure_func ); -- Error begin end block; b4: block is generic ( pure function f1 (x, y : integer) return integer is add; -- OK impure function f1 (x : integer) return integer is add ); -- Error begin end block; b5: block is generic ( pure function f1 (x, y : integer) return integer is <> ); -- Error begin end block; end architecture; nvc-r1.17.1/test/parse/issue942.vhd000066400000000000000000000004171504111170000167240ustar00rootroot00000000000000entity test is end entity test; architecture rtl of test is begin process(all) procedure test_func ( ) is -- Crash after error here begin end procedure test_func ; begin wait; end process; end architecture rtl; nvc-r1.17.1/test/parse/issue952.vhd000066400000000000000000000005531504111170000167260ustar00rootroot00000000000000entity issue952 is end entity; architecture test of issue952 is signal x : integer; default clock is true; begin assert << constant ^.foo : integer >> = 2; -- VHDL assert (x = 1 -> x = 2); -- PSL assert x = 1 -> next x = 2; -- PSL assert (<< signal issue952.x : integer >> = 4 -> next x =2); -- PSL end architecture; nvc-r1.17.1/test/parse/issue956.vhd000066400000000000000000000012461504111170000167320ustar00rootroot00000000000000entity test_mod is generic ( size : integer ); end entity test_mod; architecture test of test_mod is signal x : bit; begin assert size mod 4 = 0; -- OK assert (size mod 4) = 0; -- OK assert (size+1) mod 4 = 0; -- OK assert (size mod 4 = 0); -- OK assert (size + 1) rem 2 = 0; -- OK assert (size + 1) + 2 = 0; -- OK assert (size + 1) - 2 = 0; -- OK assert (size + 1) * 2 = 0; -- OK assert (size + 1) / 2 = 0; -- OK assert (size + 1) ** 2 = 0; -- OK assert (x or '1') ?= '0'; -- OK assert (x or '1') ?/= '0'; -- OK assert (x or '1') ?<= '0'; -- OK assert (x or '1') ?> '0'; -- OK end test; nvc-r1.17.1/test/parse/issue961.vhd000066400000000000000000000012251504111170000167230ustar00rootroot00000000000000entity issue961 is end entity; architecture test of issue961 is function get_val return real is begin return 1.234; end function; function get_val return integer is begin return 1234; end function; function rand_val(n : integer) return real is begin return 1.234; end function; function rand_val(n : integer) return integer is begin return 1234; end function; begin process is begin for i in 0 to 5 + get_val loop -- OK end loop; for i in 0 to 2**5 + rand_val(1) loop -- OK end loop; wait; end process; end architecture; nvc-r1.17.1/test/parse/issue977.vhd000066400000000000000000000004051504111170000167310ustar00rootroot00000000000000entity issue977 is end entity; architecture test of issue977 is procedure foo is begin end procedure; attribute foreign of foo : procedure is "abc"; -- OK attribute foreign of foo : procedure is "123"; -- Error begin end architecture; nvc-r1.17.1/test/parse/issue991.vhd000066400000000000000000000004431504111170000167270ustar00rootroot00000000000000package pack is type t_enum is (a, b, c); end package; ------------------------------------------------------------------------------- entity issue991 is end entity; architecture test of issue991 is constant c : work.pack.t_enum := work.pack.a; -- OK begin end architecture; nvc-r1.17.1/test/parse/lcs2016_i03.vhd000066400000000000000000000022261504111170000171020ustar00rootroot00000000000000entity lcs2016_i03 is end entity; architecture test of lcs2016_i03 is function get return integer is begin return 42; end function; function get return real is begin return 42.0; end function; begin b1: block is generic ( function f1 return integer; function f1 return real ); generic map ( f1 [return integer] => get, -- OK f1 [return real] => get ); -- OK begin end block; b2: block is port ( x : integer ); port map ( x [return integer] => 1 ); -- Error begin end block; b3: block is generic ( function f1 return integer ); generic map ( f1 [return boolean] => get ); -- Error begin end block; b4: block is generic ( g : integer ); generic map ( g [return integer] => 4 ); -- Error begin end block; b5: block is generic ( function f1 return integer; function f2 return real ); generic map ( f1 => get, -- OK f2 => get ); -- OK begin end block; end architecture; nvc-r1.17.1/test/parse/literal.vhd000066400000000000000000000025401504111170000167700ustar00rootroot00000000000000-- -*- coding: latin-1 -*- entity ee is end entity; ARCHITECTURE aa OF ee IS SIGNAL pos : INTEGER := 64; SIGNAL neg : INTEGER := -265; CONSTANT c : INTEGER := 523; CONSTANT a : STRING := "hel""lo"; CONSTANT b : STRING := """quote"""; CONSTANT d : INTEGER := 1E3; -- Integer not real CONSTANT e : REAL := 1.234; CONSTANT f : REAL := 0.21712; CONSTANT g : REAL := 1.4e6; CONSTANT h : REAL := 235.1e-2; CONSTANT i : INTEGER := 1_2_3_4; CONSTANT j : REAL := 5_6_7.12_3; type ptr is access integer; shared variable k : ptr := NULL; CONSTANT l : STRING := "Setup time is too short"; CONSTANT m : STRING := ""; CONSTANT n : STRING := " "; CONSTANT o : STRING := "A"; CONSTANT p : STRING := """"; CONSTANT q : STRING := %Setup time is too short%; CONSTANT r : STRING := %%; CONSTANT s : STRING := % %; CONSTANT t : STRING := %A%; CONSTANT u : STRING := %%%%; constant v : string := "©"; subtype lowercase is character range 'a' to 'z'; type my_string is array (lowercase range <>) of character; constant w : my_string := "hello"; constant too_big : integer := 9223372036854775808; -- Error constant way_too_big : integer := 235423414124e124124; -- Error constant u1 : integer := 1__; -- Error constant u2 : integer := 1__2; -- Error BEGIN END ARCHITECTURE; nvc-r1.17.1/test/parse/loc.vhd000066400000000000000000000002511504111170000161060ustar00rootroot00000000000000entity e is end entity; architecture a of e is procedure f(x, y, z : integer); signal x : bit; begin f(1, 2, 3 + 5); assert x'active; end architecture; nvc-r1.17.1/test/parse/names.vhd000066400000000000000000000242611504111170000164430ustar00rootroot00000000000000entity ee is end entity; architecture aa of ee is function func1(x : integer) return integer; function func2(x : integer) return integer; function func2(x : bit) return integer; function func3(x : character) return integer; function func3(x : bit) return integer; function func4(x : integer) return integer; function func4(y : integer) return integer; -- Error function func5(x : character) return integer; function func5(y : bit) return integer; type bool_vector is array (natural range <>) of boolean; function func6(x : bit_vector) return integer; function func6(x : bool_vector) return integer; type my_int is range 1 to 100; function func7(x : integer) return integer; function func7(x : my_int) return integer; function func8(x : bit_vector) return integer; function func8(x : string) return integer; begin p1: process is variable x : integer; begin x := func1(1); -- OK x := func2(1); -- OK x := func2('1'); -- OK x := func3('a'); -- OK x := func3('1'); -- Error x := func5(x => '1'); -- OK x := func5(y => '1'); -- OK x := func5(z => '1'); -- Error x := func5("101"); -- Error x := func6("101"); -- OK x := func6(('1', '0')); -- Error x := func6((true, false)); -- Error x := func6(bit_vector'(('1', '0'))); -- OK x := func7(5); -- Error x := func8("101"); -- Error end process; p2: process is procedure proc1(x : integer); procedure proc2(x : integer); procedure proc2(x : bit); procedure proc3(x : character); procedure proc3(x : bit); procedure proc4(x : integer); procedure proc4(y : integer); -- Error procedure proc5(x : character); procedure proc5(y : bit); procedure proc6(x : bit_vector); procedure proc6(x : bool_vector); procedure proc7(x : integer); procedure proc7(x : my_int); procedure proc8(x : bit_vector); procedure proc8(x : string); variable v : bit_vector(1 to 3); variable proc8 : bit_vector(3 to 5); -- Error begin proc1(1); -- OK proc2(1); -- OK proc2('1'); -- OK proc3('a'); -- OK proc3('1'); -- Error proc5(x => '1'); -- OK proc5(y => '1'); -- OK proc5(z => '1'); -- Error proc5("101"); -- Error proc6("101"); -- OK proc6(('1', '0')); -- Error proc6((true, false)); -- Error proc6(bit_vector'(('1', '0'))); -- OK proc7(5); -- Error proc8("101"); -- Error v(1); -- Error foo(1, 2); -- Error end process; p3: process is type line is access string; variable l : line; begin assert now = 0 ns; -- OK assert l = null; -- OK end process; p4: process is type my_other_int is range 1 to 100; variable x : my_int; begin x := 5 * (2 + 4); -- OK end process; p5: process is type table_t is array (bit) of character; constant table : table_t := ( '0' => '0', '1' => '1' ); -- OK begin end process; p6: process is constant FPO_LOG_MAX_ITERATIONS : integer := 9; type T_FPO_LOG_ALPHA is array (0 to FPO_LOG_MAX_ITERATIONS-1) of integer; variable alpha : T_FPO_LOG_ALPHA; begin end process; b7: block is constant WIDTH : integer := 5; begin gen: for i in 0 to WIDTH - 1 generate end generate; end block; b8: block is impure function get_foo return integer; attribute foreign of get_foo : function is "_get_foo"; begin end block; p9: process is type unsigned is array (natural range <>) of bit; function "<"(x, y : unsigned) return boolean is -- OK begin return x(0) = '0'; end function; variable a, b : unsigned(1 to 3); begin assert a < b; -- OK (should be user-defined) end process; p10: process is procedure finish; procedure stop_impl(finish, have_status : boolean; status : integer) is begin end procedure; procedure stop(status : integer) is begin -- OK stop_impl(finish => false, have_status => true, status => status); end procedure; begin end process; p11: process is function foo return bit is begin return '1'; end function; function foo return bit_vector is begin return "11"; end function; variable x : bit_vector(1 to 2); variable y : bit; begin x := foo; -- OK y := foo; -- OK end process; b12: block is signal x : bit_vector(3 downto 0); signal y : integer; begin decode_y: with x select y <= -- OK 0 when X"0", 1 when X"1", 2 when X"2", 3 when X"3"; end block; p13: process is begin assert integer'value("5") = 5; -- OK end process; b14: block is function foo return integer is begin return 1; end function; procedure check is type mytype is (foo); begin assert foo = foo; -- Error end procedure; begin end block; b15: block is type mytype is (a, b); function "+"(x, y : mytype) return mytype is variable d : integer; begin d := "+".d; -- OK d := "+".x; -- Error return a; end function; begin end block; b16: block is -- From VESTS tc290.vhd type mytime is range 1 to 30 units fs; end units; begin testing: process variable t,a :mytime; variable b :integer; begin a:=30 fs; b := 10; t:= a/b; end process; end block; p17: assert nothere(1) = 5; -- Error p18: process is type myrec is record x, y : bit; end record; variable r : myrec; begin assert r.x = '1'; -- OK end process; p19: process is procedure p19_proc(x : in integer; y : out integer); function p19_func(x : integer) return integer; begin -- p19_proc(5, p19_func(y) => 4); -- OK (not supported by sem) end process; p20: process is type bit_ptr is access bit; variable b : bit_ptr; begin assert b.all = '1'; -- OK end process; p21: process is subtype my_int is integer range 1 to 20; begin assert my_int'base'left = 1; -- OK end process; p22: process is subtype my_int is integer range 1 to 5; constant c : bit_vector(1 to 10) := ( my_int => '1', others => '0' ); -- OK begin end process; p23: process is type typ; --function p23_func(x : typ) return integer; (used to be OK) type typ is (a, b, c); function p23_func(x : typ) return integer is -- OK begin return 5; end function; begin end process; p24: process is variable v : bit_vector(8+23+2 downto 0); -- OK begin end process; p25: process is variable b : bit; begin b := fnork(b, '1'); -- Error ("fnork" undeclared) end process; p26: process is type my_bit_vector is array (natural range <>) of bit; procedure p26_1(x : integer; y : bit_vector); procedure p26_1(x : integer; y : my_bit_vector); variable v : my_bit_vector(1 to 3); begin p26_1(x => 1, y => v); -- OK p26_1(x => 1, y => 2); -- Error end process; p27: process is type my_bit_vector is array (natural range <>) of bit; function "="(l, r : my_bit_vector) return boolean; variable v : my_bit_vector(1 to 3); variable b : bit; begin assert b and v = "101"; -- Error end process; p28: process is function p28_1 (x : integer; y : boolean) return boolean; procedure p28_1 (x : integer; y : boolean); function p28_2 return boolean; procedure p28_2; begin assert p28_1(x => 1, y => true); -- OK p28_1(x => 1, y => true); -- OK assert p28_2; -- OK p28_2; -- OK end process; p29: process is type unsigned is array (natural range <>) of bit; variable mult : bit_vector(1 downto 0); variable p : unsigned(1 downto 0); variable u : bit_vector(4 downto 0); begin u := bit_vector('1' & (unsigned(mult) & p)); -- OK end process; p30: process is variable x : integer; variable c : character; begin x := x.y + 1; -- Error c := std.standard.'.'; -- OK foo.bar.p(1, 2, 3); -- Error end process; p31: process is type list; type list_ptr is access list; type list is record f : integer; end record; procedure p is type list is range 1 to 10; variable x : list_ptr; -- OK begin x.all.f := 1; -- OK end procedure; begin p; end process; p32: process is begin assert std.standard.bit_vector'("101") = "101"; -- OK assert std.standard.true'(1) = 1; -- Error end process; end architecture; nvc-r1.17.1/test/parse/names2.vhd000066400000000000000000000016211504111170000165200ustar00rootroot00000000000000entity names2 is end entity; architecture test of names2 is type array1 is array (natural range <>) of integer; type array2 is array (natural range <>) of array1(1 to 10); type array3 is array (natural range <>) of array2(1 to 10); type rec is record x : array1(1 to 3); y : integer; end record; function get_array3(n : integer) return array3; function get_array2 return array2; procedure do_rec(x : in rec); type pt is protected function get_array1(n : integer) return array1; end protected; begin p1: process is variable p : pt; begin assert get_array3(1)(2)(2)(3) = 1; -- OK --assert get_array2(2)(3) = 1; -- OK (not yet) assert p.get_array1(1)(2) = 1; -- OK end process; p2: process is begin do_rec(x.x => (1, 2, 3), x.y => 5); -- OK end process; end architecture; nvc-r1.17.1/test/parse/names3.vhd000066400000000000000000000025521504111170000165250ustar00rootroot00000000000000package pack is type t is (foo, bar, baz); procedure foo(x : integer); procedure bar; procedure baz(x : t); end package; ------------------------------------------------------------------------------- entity names3 is end entity; use work.pack; architecture test of names3 is begin p1: process is begin bar; -- Error pack.bar; -- OK pack.foo(1); -- OK pack.baz(pack.baz); -- OK wait; end process; p2: process is function f1(x : real) return string; function f1 return string; function f1(x : integer) return string; begin report f1; -- OK end process; p3: process is type byte_vector is array (1 to 8) of bit_vector(1 to 8); variable v : bit_vector(7 downto 0); begin if v(7 downto 3) & "000" = X"12" then -- OK end if; end process; b1: block is type t_logic is ('X', 'Z', '0', '1'); type t_logic_array is array (natural range <>) of t_logic; function "and" (l, r : t_logic) return t_logic; function "<" (l, r : t_logic_array) return t_logic is begin return l(0) = '0' and r(0) = '1'; -- Error end function; begin end block; end architecture; nvc-r1.17.1/test/parse/osvvm6.vhd000066400000000000000000000032021504111170000165700ustar00rootroot00000000000000package RandomBasePkg is subtype NULL_RANGE_TYPE is integer range 0 downto 1 ; type RandomSeedType is array (1 to 2) of integer ; procedure Uniform (Result : out real ; Seed : inout RandomSeedType) ; type RandomDistType is (NONE, UNIFORM, FAVOR_SMALL, FAVOR_BIG, NORMAL, POISSON) ; type RandomParmType is record Distribution : RandomDistType ; Mean : Real ; -- also used as probability of success StdDeviation : Real ; -- also used as number of trials for binomial end record ; function Scale (A, Min, Max : real) return real ; function Scale (A : real ; Min, Max : integer) return integer ; end RandomBasePkg ; ------------------------------------------------------------------------------- use work.RandomBasePkg.all ; package RandomPkg is type NaturalVBoolType is array (boolean range <>) of natural; type NaturalVBitType is array (bit range <>) of natural; type RandomPType is protected impure function Uniform (Min, Max : in real) return real ; impure function Uniform (Min, Max : integer) return integer ; impure function Uniform (Min, Max : integer ; Exclude : integer_vector) return integer ; end protected RandomPType ; end RandomPkg ; package body RandomPkg is type RandomPType is protected body impure function Uniform return real; impure function Uniform return real is variable rRandom : real ; begin return rRandom ; end function Uniform ; impure function LocalUniform (Min, Max : in real) return real is begin return scale(Uniform, Min, Max) ; -- OK end function LocalUniform ; end protected body RandomPType ; end RandomPkg ; nvc-r1.17.1/test/parse/osvvm7.vhd000066400000000000000000000032561504111170000166020ustar00rootroot00000000000000package ScoreboardGenericPkg1 is generic ( type ExpectedType ; type ActualType ) ; type ScoreboardIdType is record Id : integer ; end record ScoreboardIdType ; impure function NewID ( Name : String ) return ScoreboardIDType ; end ScoreboardGenericPkg1 ; package body ScoreboardGenericPkg1 is impure function NewID ( Name : String ) return ScoreboardIDType is begin return (id => 0); end function NewID ; end ScoreboardGenericPkg1 ; ------------------------------------------------------------------------------- package ScoreBoardPkg_slv1 is new work.ScoreboardGenericPkg1 generic map ( ExpectedType => bit_vector, ActualType => bit_vector ) ; ------------------------------------------------------------------------------- package ScoreBoardPkg_int1 is new work.ScoreboardGenericPkg1 generic map ( ExpectedType => integer, ActualType => integer ) ; ------------------------------------------------------------------------------- use work.ScoreboardPkg_slv1.all ; use work.ScoreboardPkg_int1.all ; entity xMiiPhyRxTransmitter is end entity xMiiPhyRxTransmitter ; architecture behavioral of xMiiPhyRxTransmitter is signal DataFifo : work.ScoreboardPkg_slv1.ScoreboardIDType ; signal MetaFifo : work.ScoreboardPkg_int1.ScoreboardIDType ; begin ------------------------------------------------------------ -- Initialize alerts ------------------------------------------------------------ Initialize : process begin DataFifo <= NewID("DataFifo") ; MetaFifo <= NewID("MetaFifo") ; wait ; end process Initialize ; end architecture behavioral ; nvc-r1.17.1/test/parse/package.vhd000066400000000000000000000015241504111170000167300ustar00rootroot00000000000000package one is type my_int is range 0 to 100; function add_one(x : my_int) return my_int; end package; ------------------------------------------------------------------------------- use work.one.all; package two is subtype my_int2 is work.one.my_int range 10 to 50; end package two; ------------------------------------------------------------------------------- package body one is function add_one(x : my_int) return my_int is variable y : integer; begin null; end function add_one; shared variable x : integer; function foo return boolean; attribute foreign of foo : function is "_foo"; -- Error end package body; ------------------------------------------------------------------------------- library foo; package three is signal s : integer; alias sa is s; end package; nvc-r1.17.1/test/parse/pkgindecl.vhd000066400000000000000000000003021504111170000172660ustar00rootroot00000000000000entity pkg_in_decl is begin end entity; architecture arch of pkg_in_decl is function test( package inner_pkg is end package; -- error ) is begin end function; begin end architecture; nvc-r1.17.1/test/parse/procedure.vhd000066400000000000000000000015041504111170000173230ustar00rootroot00000000000000package p is procedure foo(x : in integer; y : out integer); type text_file is file of string; end package; package body p is procedure foo(x : in integer; y : out integer) is variable i : integer; begin y := x + 1; end procedure; procedure bar(file x : text_file); procedure baz is variable y : integer; type foo; alias x is y; constant k : integer := 2; begin end procedure; procedure tralala is use work.p; begin end procedure; -- Parse errors below this point pure procedure notpure is -- Error begin end procedure; procedure testxxx is variable x : integer; begin x := ?? x; -- Error, parsed as pcall in 93 end procedure; end package body; nvc-r1.17.1/test/parse/process.vhd000066400000000000000000000006041504111170000170110ustar00rootroot00000000000000entity b is end entity; architecture a of b is signal x : integer := 0; begin p: process is begin end process; process variable y : integer := 5; begin x <= y; end process; process (x) is begin x <= x + 1; end process; postponed process is begin end process; postponed assert x = 1; end architecture; nvc-r1.17.1/test/parse/protected.vhd000066400000000000000000000021271504111170000173260ustar00rootroot00000000000000package p is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; type SharedCounter is protected body variable counter: Integer := 0; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; procedure add10 is begin increment(10); end procedure; end protected body; procedure proc_1 (x : integer); type pt2 is protected procedure proc_1 (y : integer); end protected; type pt2 is protected body procedure proc_2 is begin proc_1(y => 5); -- OK end procedure; end protected body; end package; nvc-r1.17.1/test/parse/protected2.vhd000066400000000000000000000056041504111170000174130ustar00rootroot00000000000000package RandomPkg is -- Weight vectors not indexed by integers type NaturalVBoolType is array (boolean range <>) of natural; type NaturalVBitType is array (bit range <>) of natural; function Scale (A : real ; Min, Max : integer) return integer ; function Scale (A, Min, Max : real) return real ; --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// --- --- RandomPType --- --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// type RandomPType is protected ------------------------------------------------------------ -- -- Uniform -- Generate a random number with a Uniform distribution -- ------------------------------------------------------------ impure function Uniform (Min, Max : in real) return real ; impure function Uniform (Min, Max : integer) return integer ; impure function Uniform (Min, Max : integer ; Exclude : integer_vector) return integer ; end protected RandomPType ; end RandomPkg ; --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// package body RandomPkg is --- /////////////////////////////////////////////////////////////////////////// --- RandomPType Body --- /////////////////////////////////////////////////////////////////////////// type RandomPType is protected body --- /////////////////////////////////////////////////////////////////////////// --- --- Base Call to Uniform. Use this one rather than RandomBasePkg --- --- /////////////////////////////////////////////////////////////////////////// ----------------------------------------------------------------- impure function Uniform return real is ----------------------------------------------------------------- variable rRandom : real ; begin return rRandom ; end function Uniform ; --- /////////////////////////////////////////////////////////////////////////// --- --- Base Randomization Distributions --- --- /////////////////////////////////////////////////////////////////////////// ------------------------------------------------------------ -- -- Uniform -- Generate a random number with a Uniform distribution -- ------------------------------------------------------------ impure function LocalUniform (Min, Max : in real) return real is ------------------------------------------------------------ begin return scale(Uniform, Min, Max) ; -- No error here end function LocalUniform ; end protected body RandomPType ; end RandomPkg ; nvc-r1.17.1/test/parse/protected3.vhd000066400000000000000000000006711504111170000174130ustar00rootroot00000000000000package fred4 is type fred4_t is protected impure function is_empty return boolean; impure function hi_there return is_empty; -- error end protected; end package fred4; -------------------------------------------------------------------------------- package pkg is type SharedCounter is protected body -- first body, but incomplete type SharedCounter is protected body -- duplicated body end protected body; end package; nvc-r1.17.1/test/parse/qual.vhd000066400000000000000000000004561504111170000163020ustar00rootroot00000000000000-- Type qualified expressions entity bar is end entity; architecture foo of bar is type foo is (a, b, 'c'); type bar is (a, b, c); signal x : foo; begin process is begin x <= foo'(b); --x <= foo'('c'); x <= foo'( 'c' ); end process; end architecture; nvc-r1.17.1/test/parse/range1.vhd000066400000000000000000000015511504111170000165120ustar00rootroot00000000000000entity range1 is end entity; architecture test of range1 is begin p1: process is variable x : character; variable y : integer; begin for i in 1 to 3 loop -- OK end loop; for i in character'range loop -- OK end loop; for i in character loop -- OK end loop; for i in x'range loop -- Error end loop; for i in x loop -- Error end loop; for i in 4 loop -- Error end loop; for i in integer range 1 to 3 loop -- OK end loop; for i in x range 'a' to 'b' loop -- Error end loop; for i in -1 downto integer'low loop -- OK end loop; for i in 0 to 2*(1-y) loop -- OK end loop; wait; end process; end architecture; nvc-r1.17.1/test/parse/seq.vhd000066400000000000000000000075471504111170000161400ustar00rootroot00000000000000entity bb is end entity; architecture aa of bb is signal x, y, z : integer; signal w : bit_vector(1 to 3); begin -- Wait statements process is begin wait for 1 ns; block_forever: wait; wait on x; wait on x, y, z(1 downto 0); wait on w(1) for 2 ns; wait until x = 3; wait until y = x for 5 ns; wait on x until x = 2 for 1 ns; end process; -- Blocking assignment process is variable a : integer; begin a := 2; a := a + (a * 3); end process; -- Assert and report process is begin assert true; assert false severity note; assert 1 > 2 report "oh no" severity failure; report "hello"; report "boo" severity error; end process; -- Function calls process is variable a, b : integer; function foo (x, y, z : integer) return integer; begin x := foo(1, 2, 3); a := "abs"(b); end process; -- If process is variable x, y : integer; begin if true then x := 1; end if; test: if true then x := y; end if test; if x > 2 then x := 5; else y := 2; end if; if x > 3 then null; elsif x > 5 then null; elsif true then null; else x := 2; end if; end process; -- Null process is begin null; end process; -- Return process is begin return 4 * 4; end process; -- While process is variable n : integer; begin while n > 0 loop n := n - 1; end loop; loop null; end loop; end process; -- Delayed assignment process is begin x <= 4 after 5 ns; x <= 5 after 1 ns, 7 after 8 ns; x <= 5, 7 after 8 ns; x <= inertial 5; x <= transport 4 after 2 ns; x <= reject 4 ns inertial 6 after 10 ns; end process; -- For process is type foo is (A, B, C); begin for i in 0 to 10 loop null; end loop; for i in foo'range loop null; end loop; end process; -- Exit process is begin exit; exit when x = 1; end process; -- Procedure call process is procedure foo (a, b, c : integer); procedure bar; begin foo(x, y, 1); bar; foo(a => 1, b => 2, 3); end process; -- Case process is begin case x is when 1 => null; when 2 => null; when 3 | 4 => null; when others => null; end case; end process; -- Next process is begin next; next when x = 5; end process; -- Signal assignment to aggregate process is type int_vec is array (natural range <>) of integer; constant foo : int_vec := (1, 2, 3); begin ( x, y, z ) <= foo; end process; -- Case statement range bug process is begin case y is when 1 => for i in integer'range loop end loop; end case; end process; -- 2008: all-sensitive process process (all) is begin x <= y; end process; -- Variable assignment with aggregate target process is type int_vec is array (natural range <>) of integer; variable v : int_vec(1 to 2); variable a, b : integer; begin (a, b) := v; -- OK end process; -- Signal assignment with null transaction process is begin x <= 1, null after 2 ns; -- OK end process; end architecture; nvc-r1.17.1/test/parse/slow1.vhd000066400000000000000000000103331504111170000164000ustar00rootroot00000000000000entity slow1 is end entity; architecture test of slow1 is signal finalAdderIn1_bh119 : bit_vector(60 downto 0); signal heap_bh119_w60_3_d1 : bit; signal heap_bh119_w61_2_d1 : bit; signal heap_bh119_w62_1_d1 : bit; signal heap_bh119_w58_3_d1 : bit; signal heap_bh119_w59_2_d1 : bit; signal heap_bh119_w54_4_d2 : bit; signal heap_bh119_w55_3_d2 : bit; signal heap_bh119_w52_4_d2 : bit; signal heap_bh119_w53_3_d2 : bit; signal heap_bh119_w54_3_d2 : bit; signal heap_bh119_w50_4_d2 : bit; signal heap_bh119_w51_3_d2 : bit; signal heap_bh119_w52_3_d2 : bit; signal heap_bh119_w48_4_d2 : bit; signal heap_bh119_w49_3_d2 : bit; signal heap_bh119_w50_3_d2 : bit; signal heap_bh119_w46_4_d2 : bit; signal heap_bh119_w47_3_d2 : bit; signal heap_bh119_w48_3_d2 : bit; signal heap_bh119_w44_4_d2 : bit; signal heap_bh119_w45_3_d2 : bit; signal heap_bh119_w46_3_d2 : bit; signal heap_bh119_w42_4_d2 : bit; signal heap_bh119_w43_3_d2 : bit; signal heap_bh119_w44_3_d2 : bit; signal heap_bh119_w40_4_d2 : bit; signal heap_bh119_w41_3_d2 : bit; signal heap_bh119_w42_3_d2 : bit; signal heap_bh119_w38_4_d2 : bit; signal heap_bh119_w39_3_d2 : bit; signal heap_bh119_w40_3_d2 : bit; signal heap_bh119_w36_4_d2 : bit; signal heap_bh119_w37_3_d2 : bit; signal heap_bh119_w38_3_d2 : bit; signal heap_bh119_w34_4_d2 : bit; signal heap_bh119_w35_3_d2 : bit; signal heap_bh119_w36_3_d2 : bit; signal heap_bh119_w32_4_d2 : bit; signal heap_bh119_w33_3_d2 : bit; signal heap_bh119_w34_3_d2 : bit; signal heap_bh119_w30_4_d2 : bit; signal heap_bh119_w31_3_d2 : bit; signal heap_bh119_w32_3_d2 : bit; signal heap_bh119_w28_4_d2 : bit; signal heap_bh119_w29_3_d2 : bit; signal heap_bh119_w30_3_d2 : bit; signal heap_bh119_w26_4_d2 : bit; signal heap_bh119_w27_3_d2 : bit; signal heap_bh119_w28_3_d2 : bit; signal heap_bh119_w24_4_d2 : bit; signal heap_bh119_w25_3_d2 : bit; signal heap_bh119_w26_3_d2 : bit; signal heap_bh119_w22_4_d2 : bit; signal heap_bh119_w23_3_d2 : bit; signal heap_bh119_w24_3_d2 : bit; signal heap_bh119_w20_4_d2 : bit; signal heap_bh119_w21_3_d2 : bit; signal heap_bh119_w22_3_d2 : bit; signal heap_bh119_w18_4_d2 : bit; signal heap_bh119_w19_3_d2 : bit; signal heap_bh119_w20_3_d2 : bit; signal heap_bh119_w14_4_d2 : bit; signal heap_bh119_w15_3_d2 : bit; signal heap_bh119_w16_3_d2 : bit; signal heap_bh119_w12_3_d2 : bit; signal heap_bh119_w13_3_d2 : bit; signal heap_bh119_w14_3_d2 : bit; signal heap_bh119_w16_4_d2 : bit; signal heap_bh119_w17_3_d2 : bit; signal heap_bh119_w18_3_d2 : bit; signal heap_bh119_w6_0_d2 : bit; signal heap_bh119_w7_0_d2 : bit; signal heap_bh119_w8_0_d2 : bit; signal heap_bh119_w9_0_d2 : bit; signal heap_bh119_w10_0_d2 : bit; signal heap_bh119_w11_0_d2 : bit; begin -- From flopoco.vhdl finalAdderIn1_bh119 <= "0" & '0' & '0' & '0' & heap_bh119_w62_1_d1 & '0' & '0' & '0' & '0' & '0' & '0' & heap_bh119_w55_3_d2 & heap_bh119_w54_3_d2 & heap_bh119_w53_3_d2 & heap_bh119_w52_3_d2 & heap_bh119_w51_3_d2 & heap_bh119_w50_3_d2 & heap_bh119_w49_3_d2 & heap_bh119_w48_3_d2 & heap_bh119_w47_3_d2 & heap_bh119_w46_3_d2 & heap_bh119_w45_3_d2 & heap_bh119_w44_3_d2 & heap_bh119_w43_3_d2 & heap_bh119_w42_3_d2 & heap_bh119_w41_3_d2 & heap_bh119_w40_3_d2 & heap_bh119_w39_3_d2 & heap_bh119_w38_3_d2 & heap_bh119_w37_3_d2 & heap_bh119_w36_3_d2 & heap_bh119_w35_3_d2 & heap_bh119_w34_3_d2 & heap_bh119_w33_3_d2 & heap_bh119_w32_3_d2 & heap_bh119_w31_3_d2 & heap_bh119_w30_3_d2 & heap_bh119_w29_3_d2 & heap_bh119_w28_3_d2 & heap_bh119_w27_3_d2 & heap_bh119_w26_3_d2 & heap_bh119_w25_3_d2 & heap_bh119_w24_3_d2 & heap_bh119_w23_3_d2 & heap_bh119_w22_3_d2 & heap_bh119_w21_3_d2 & heap_bh119_w20_3_d2 & heap_bh119_w19_3_d2 & heap_bh119_w18_3_d2 & heap_bh119_w17_3_d2 & heap_bh119_w16_3_d2 & heap_bh119_w15_3_d2 & heap_bh119_w14_3_d2 & heap_bh119_w13_3_d2 & '0' & heap_bh119_w11_0_d2 & heap_bh119_w10_0_d2 & heap_bh119_w9_0_d2 & heap_bh119_w8_0_d2 & heap_bh119_w7_0_d2 & heap_bh119_w6_0_d2; end architecture; nvc-r1.17.1/test/parse/spec.vhd000066400000000000000000000014211504111170000162630ustar00rootroot00000000000000entity b is end entity; entity foo is generic ( a : integer := 2 ); port ( b : in integer := 5 ); end entity; architecture arch of foo is begin end architecture; configuration yah of foo is use work.foo; for arch end for; end configuration; architecture a of b is component y is end component; component p is end component; for x : y use entity work.foo; for x1, x2 : y use entity work.foo; for x3 : y use entity work.foo(arch); for x4 : y use entity work.foo(arch) generic map ( a => 1 ) port map ( b => 6 ); for all : p use configuration work.yah; for others : y use open; begin x: component y; x1: component y; x2: component y; x3: component y; x4: component y; end architecture; nvc-r1.17.1/test/parse/subtype2008.vhd000066400000000000000000000033641504111170000173460ustar00rootroot00000000000000package subtype2008 is subtype sub1 is integer_vector; -- array (open) of integer subtype sub2 is integer_vector(open); -- array (open) of integer subtype sub3 is sub1; -- array (open) of integer type int2d is array (natural range <>) of integer_vector; subtype sub4 is int2d; -- array (open) of array (open) of integer subtype sub5 is int2d(1 to 2); -- array (1 to 2) of array (open) of integer subtype sub6 is sub5(open)(1 to 3); -- array (1 to 2) of array (1 to 3) of integer subtype sub7 is sub6; -- array (1 to 2) of array (1 to 3) of integer type rec is record f : integer_vector; g : int2d; end record; subtype sub8 is rec; -- rec(f(open), g(open)(open)) subtype sub9 is rec(g(1 to 3)); -- rec(f(open), g(1 to 3)(open)) subtype sub10 is sub9(g(open)(1 to 5)); -- rec(f(open), g(1 to 3)(1 to 5)) type rec_array is array (natural range <>) of rec; subtype sub11 is rec_array(1 to 9); -- array (1 to 9) of rec(f(open), g(open)(open)) -- Cases from issue #1161 type ArrayOfSigned is array (natural range <>) of bit_vector; type InterlacedSignal is record Data : ArrayOfSigned; Valid : bit; end record; type ArrayOfInterlacedSignals is array (natural range <>) of InterlacedSignal; subtype ArrayOfInterlaced16bSignals is ArrayOfInterlacedSignals(open)(Data(open)(15 downto 0)); -- OK subtype sub12 is ArrayOfSigned(open)(15 downto 0); -- OK subtype sub13 is ArrayOfInterlaced16bSignals(0 to 7)(Data(0 to 7)(open)); -- OK subtype sub14 is sub12(0 to 7)(open); -- OK subtype sub15 is ArrayOfInterlaced16bSignals(0 to 7)(Data(0 to 7)); -- OK end package; nvc-r1.17.1/test/parse/synth.vhd000066400000000000000000000007621504111170000165050ustar00rootroot00000000000000entity synth is end entity; architecture test of synth is -- synthesis translate_off signal x : integer; -- Should ignore -- synthesis translate_on signal y : bit; begin process is begin -- synthesis translate_off should ignore this trailing comment x <= 5; end process; process is begin -- synthesis translate_on -- Should only get one process here y <= '1'; end process; end architecture; nvc-r1.17.1/test/parse/tc1012.vhd000066400000000000000000000030651504111170000162510ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1012.vhd,v 1.2 2001-10-26 16:29:38 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c06s03b00x00p10n01i01012ent IS port (p,q: in bit); END c06s03b00x00p10n01i01012ent; ARCHITECTURE c06s03b00x00p10n01i01012arch OF c06s03b00x00p10n01i01012ent IS BEGIN TESTING: PROCESS(c06s03b00x00p10n01i01012ent.p, c06s03b00x00p10n01i01012ent.q) BEGIN assert FALSE report "***PASSED TEST: c06s03b00x00p10n01i01012" severity NOTE; END PROCESS TESTING; END c06s03b00x00p10n01i01012arch; nvc-r1.17.1/test/parse/types.vhd000066400000000000000000000023361504111170000165030ustar00rootroot00000000000000entity b is end entity; architecture a of b is type my_int is range 0 to 100; signal x : my_int := 2; type resistance is range 0 to 10000000 units ohm; kohm = 1000 ohm; Mohm = 1000 kohm; end units; signal r : resistance := 100 ohm; subtype big_r is resistance range 1000 to 2000; subtype my_small_int is my_int range 0 to 5; subtype foo is my_int range 2 to my_int'high; type my_int_vec is array (natural range <>) of my_int; function resolved (x : my_int_vec) return my_int; subtype rint is resolved my_int; type p is access my_int; type f is file of my_int; file f1 : f open READ_MODE is "foo"; file f2 : f is "bar"; file f3 : f; type r1 is record a : integer; b : integer; c : foo(1 to 5); end record; file f4 : f is out "bar"; -- VHDL-87 compat file f5 : f is in "bar"; -- VHDL-87 compat type r2 is record x : integer; end record r2; subtype my_real is real; subtype my_real2 is real range 0.0 to 10.0; constant var : some_array(1 to 3); -- Error type t1 is ('a', 'b', 'a'); -- Error begin end architecture; nvc-r1.17.1/test/parse/typo.vhd000066400000000000000000000022611504111170000163270ustar00rootroot00000000000000entity typo is end entity; architecture test of typo is signal areset, reset : bit; constant k : bolean; -- Error type rec is record foo, bar : integer; end record; type pt is protected procedure one; procedure two; end protected; type pt is protected body procedure one is begin end procedure; procedure two is begin end procedure; end protected body; begin assert rset; -- Error p1: process is function myfunc(x : integer) return integer is begin return x * 2; end function; begin assert noew = 45 ns; -- Error assert my_func(4) = 8; -- Error end process; p2: process is variable r : rec; begin r.frodo := 1; end process; p3: process is variable p : pt; begin p.onn; -- Error end process; p4: process is function myfunc return integer is begin return 2; end function; begin assert myfunc(x => 4) = 1; -- Error (no typo hint) end process; end architecture; nvc-r1.17.1/test/parse/uvvm1.vhd000066400000000000000000000027201504111170000164120ustar00rootroot00000000000000-- From UVVM ti_vvc_framework_support_pkg.vhd -- License: Apache 2.0 -- package uvvm1 is type unsigned is array (natural range <>) of bit; type t_direction is (TRANSMIT, RECEIVE); type t_dut_if_field_config is record dut_address : unsigned; -- Address of the DUT IF field dut_address_increment : integer; -- Incrementation of the address on each access data_width : positive; -- Width of the data per transfer use_field : boolean; -- Used by the HVVC to send/request fields to/from the bridge or ignore them when not applicable field_description : string; -- Description of the DUT IF field end record; constant C_DUT_IF_FIELD_CONFIG_DEFAULT : t_dut_if_field_config(dut_address(0 downto 0)) := ( dut_address => (others => '0'), dut_address_increment => 0, data_width => 8, use_field => true, field_description => "default"); type t_dut_if_field_config_array is array (natural range <>) of t_dut_if_field_config; type t_dut_if_field_config_direction_array is array (t_direction range <>) of t_dut_if_field_config_array; constant C_DUT_IF_FIELD_CONFIG_DIRECTION_ARRAY_DEFAULT : t_dut_if_field_config_direction_array(t_direction'low to t_direction'high)(0 to 0)(dut_address(0 downto 0), field_description(1 to 7)) -- OK := (others => (others => C_DUT_IF_FIELD_CONFIG_DEFAULT)); end package; nvc-r1.17.1/test/parse/uvvm2.vhd000066400000000000000000000007171504111170000164170ustar00rootroot00000000000000-- Alias of enum in another package -- package pack1 is type t is (foo, bar, baz); end package; use work.pack1.all; package pack2 is alias t is work.pack1.t; -- OK end package; use work.pack2.all; package pack3 is constant c1 : t := foo; -- OK end package; use work.pack1.all; use work.pack2.all; package pack4 is constant c2 : t := bar; -- OK constant c3 : integer := foo; -- Error end package; nvc-r1.17.1/test/parse/vests1.vhd000066400000000000000000000040631504111170000165630ustar00rootroot00000000000000entity something is port( sigin1 : in boolean := false; sigout1 : out boolean ; sigin2 : in bit := '0'; sigout2 : out bit ; sigin4 : in severity_level := note ; sigout4 : out severity_level ; sigin5 : in integer := 0 ; sigout5 : out integer ; sigin6 : in real := 0.0; sigout6 : out real ; sigin7 : in time := 0 fs; sigout7 : out time ; sigin8 : in natural := 0 ; sigout8 : out natural ; sigin9 : in positive := 1 ; sigout9 : out positive ); end entity; architecture arch of something is begin end architecture; configuration testbench of something is for arch end for; end; entity c01s03b01x00p12n01i00863ent is end entity; architecture c01s03b01x00p12n01i00863arch of c01s03b01x00p12n01i00863ent is begin K:block component test port( sigin1 : in boolean := false; sigout1 : out boolean ; sigin2 : in bit := '0'; sigout2 : out bit ; sigin4 : in severity_level := note ; sigout4 : out severity_level ; sigin5 : in integer := 0 ; sigout5 : out integer ; sigin6 : in real := 0.0; sigout6 : out real ; sigin7 : in time := 0 fs; sigout7 : out time ; sigin8 : in natural := 0 ; sigout8 : out natural ; sigin9 : in positive := 1 ; sigout9 : out positive ); end component; BEGIN T5: component test; G: for i in 0 to 3 generate T1: component test; end generate; end block; end architecture; configuration c01s03b01x00p12n01i00863cfg of c01s03b01x00p12n01i00863ent is for c01s03b01x00p12n01i00863arch for K for T5:test use configuration work.testbench; end for; for G(3) for T1:test use configuration work.testbench; end for; end for; for G(0 to 2) for all:test use configuration work.testbench; end for; end for; end for; end for; end; nvc-r1.17.1/test/parse/vests2.vhd000066400000000000000000000035711504111170000165670ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3064.vhd,v 1.2 2001-10-26 16:30:25 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c12s03b02x02p05n01i03064ent IS port (C : out bit); END c12s03b02x02p05n01i03064ent; ARCHITECTURE c12s03b02x02p05n01i03064arch OF c12s03b02x02p05n01i03064ent IS component c12s03b02x02p05n01i03064ent_aa port(con : in bit:='1'; clk : out bit); end component; for all: c12s03b02x02p05n01i03064ent_aa use entity work.fail(c12s03b02x02p05n01i03064arch_a); -- Failure_here BEGIN T1: test port map(open,C); TESTING: PROCESS BEGIN assert false report "***FAILED TEST: c12s03b02x02p05n01i03064 - Entity declaration and the corresponding body implied by the binding indication do not exist within the specified library." severity ERROR; wait; END PROCESS TESTING; END c12s03b02x02p05n01i03064arch; nvc-r1.17.1/test/parse/vests3.vhd000066400000000000000000000031661504111170000165700ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2858.vhd,v 1.2 2001-10-26 16:30:23 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c13s10b00x00p04n01i02858ent IS END c13s10b00x00p04n01i02858ent; ARCHITECTURE c13s10b00x00p04n01i02858arch OF c13s10b00x00p04n01i02858ent IS BEGIN TESTING: PROCESS variable bit_str : bit_vector(0 to 7) := "01010101%; BEGIN assert FALSE report "***FAILED TEST: c13s10b00x00p04n01i02858 - Only right hand side quotation mark ("") is replaced by percent character (%)." severity ERROR; wait; END PROCESS TESTING; END c13s10b00x00p04n01i02858arch; nvc-r1.17.1/test/parse/vests4.vhd000066400000000000000000000036061504111170000165700ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1892.vhd,v 1.2 2001-10-26 16:30:14 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c07s01b00x00p08n01i01892ent IS END c07s01b00x00p08n01i01892ent; ARCHITECTURE c07s01b00x00p08n01i01892arch OF c07s01b00x00p08n01i01892ent IS type small_int is range 0 to 7; type cmd_bus is array (small_int range <>) of small_int; signal ibus : cmd_bus(small_int); signal s_int : small_int; BEGIN sig : s_int <= 0; TESTING : PROCESS BEGIN s_int <= ibus'right(small_int'(sig)) after 5 ns; -- signal assignment label illegal here wait for 5 ns; assert FALSE report "***FAILED TEST: c07s01b00x00p08n01i01892 - Signal assignment labels are not permitted as primaries in a qualified expression." severity ERROR; wait; END PROCESS TESTING; END c07s01b00x00p08n01i01892arch; nvc-r1.17.1/test/parse/vests5.vhd000066400000000000000000000033431504111170000165670ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc937.vhd,v 1.2 2001-10-26 16:30:28 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c10s04b00x00p06n01i00937pkg_a is type MC is (LOW,HIGH,RISING); end c10s04b00x00p06n01i00937pkg_a; package c10s04b00x00p06n01i00937pkg is function MC return boolean; end c10s04b00x00p06n01i00937pkg; use work.c10s04b00x00p06n01i00937pkg_a.all,work.c10s04b00x00p06n01i00937pkg.all; ENTITY c10s04b00x00p06n01i00937ent IS END c10s04b00x00p06n01i00937ent; ARCHITECTURE c10s04b00x00p06n01i00937arch OF c10s04b00x00p06n01i00937ent IS BEGIN TESTING : PROCESS variable S1: MC; -- Failure_here. BEGIN S1 := Low; wait; END PROCESS; END c10s04b00x00p06n01i00937arch; nvc-r1.17.1/test/parse/vests6.vhd000066400000000000000000000032451504111170000165710ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc877.vhd,v 1.2 2001-10-26 16:30:01 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c01s03b02x00p02n01i00877ent IS END c01s03b02x00p02n01i00877ent; ARCHITECTURE c01s03b02x00p02n01i00877arch OF c01s03b02x00p02n01i00877ent IS BEGIN BB : block component LOCAL end component; begin CIS : LOCAL; end block BB; END c01s03b02x00p02n01i00877arch; configuration c01s03b02x00p02n01i00877cfg of c01s03b02x00p02n01i00877ent is for c01s03b02x00p02n01i00877arch for BB for CIS : LOCAL -- Success_here end for; end for; end for ; end c01s03b02x00p02n01i00877cfg; nvc-r1.17.1/test/parse/vhdl2008.vhd000066400000000000000000000220401504111170000166000ustar00rootroot00000000000000-- -- Grab bag of miscellaneous VHDL-2008 syntax -- entity vhdl2008 is end entity; package genpack is generic ( x : integer := 5; y : boolean ); -- OK generic map ( x => 5, y => false ); -- OK constant c : bit_vector(1 to x) := (1 to x => '1'); end package; package genpack2 is generic ( x : integer := 5; y : boolean ); -- OK function add_x_if_y ( arg : integer ) return integer; end package; package body genpack2 is function add_x_if_y ( arg : integer ) return integer is begin if y then return arg + x; else return arg; end if; end function; end package body; package primary_genpack2 is new work.genpack2 generic map (4, false); -- OK architecture test of vhdl2008 is type my_utype is (a, b, c); type my_utype_vector is array (natural range <>) of my_utype; function resolved (s : my_utype_vector) return my_utype; subtype my_type is resolved my_utype; subtype my_type_vector is (resolved) my_utype_vector; -- OK type my_logical_vec is array (natural range <>) of bit; type my_bool is (true, false); package my_genpack2 is new work.genpack2 generic map (1, true); -- OK begin process is variable b : bit; variable v : my_logical_vec(1 to 3); begin b := or v; -- OK if or v = '1' then end if; -- OK b := and v; -- OK b := xor v; -- OK b := xnor v; -- OK b := nand v; -- OK b := nor v; -- OK end process; process is variable b : bit; variable v : my_logical_vec(1 to 3); begin b := b ?= '1'; -- OK b := b ?/= '1'; -- OK b := b ?< '0'; -- OK b := b ?> '0'; -- OK b := b ?<= '1'; -- OK b := b ?>= '1'; -- OK b := v ?= "101"; -- OK b := v ?/= "111"; -- OK end process; process is variable b : bit; variable i : integer; function "??"(x : integer) return boolean; begin if b then end if; -- OK if b xor '1' then end if; -- OK while b and '1' loop end loop; -- OK if i + 1 then end if; -- OK if now + 1 ns then end if; -- Error while true loop exit when b or '1'; -- OK next when b or '1'; -- OK end loop; wait until b xor '0'; -- OK assert b nor '1'; -- OK assert ?? 1; -- OK assert b and b and (not b); -- OK end process; /* This is a comment */ /* Comments /* do not nest */ process is variable x, y : integer; begin x := 1 when y > 2 else 5; -- OK end process; process is variable x : string(7 downto 0); begin x := 8x"0"; -- OK x := 6x"a"; -- OK x := 4x"4"; -- OK x := 2x"4"; -- Error x := 0x"5"; -- Error x := 18x"383fe"; -- OK x := 0b"0000"; -- OK x := d"5"; -- OK x := 5d"25"; -- OK x := 120d"83298148949012041209428481024019511"; -- Error x := uo"5"; -- OK x := 5sb"11"; -- OK x := 2sb"1111110"; -- OK x := 2sb"10110101"; -- Error x := 4x"0f"; -- OK x := Uo"2C"; -- OK x := d"C4"; -- Error x := 8x"-"; -- OK x := 12d"13"; -- OK x := 3d"13"; -- Error end process; b2: block is signal s : integer; begin process is begin s <= 1 when s < 0 else 5; -- OK end process; end block; process is type int_vec2 is array (natural range <>) of integer_vector; -- OK constant a : int_vec2(1 to 3)(1 to 2) := ( -- OK (1, 2), (3, 4), (5, 6) ); begin assert a(1)(1) = 1; -- OK end process; b3: block is signal s : integer; begin process is begin s <= force 1; -- OK s <= force out 1; -- OK s <= force in 2; -- OK s <= release; -- OK s <= release out; -- OK end process; end block; process is variable x : bit_vector(1 to 3); begin case? x is -- OK when "010" => null; when others => null; end case?; case? x is when others => null; end case; -- Error case x is when others => null; end case ?; -- Error end process; b4: block is procedure foo (x : integer_vector; y : integer) is variable a : x'subtype; -- OK variable b : integer'subtype; -- OK variable c : b4'subtype; -- Error variable d : x'element; -- OK variable e : y'element; -- Error variable f : b4'element; -- Error begin end procedure; begin end block; b5: block is function gen1 generic (n : integer) (x : integer) return integer is begin -- OK return 1; end function; function gen2 generic (n : integer) -- OK parameter (x : integer) return integer; function gen3 generic (type t; p : t) (x : t) return integer; -- Ok function my_gen1 is new gen1 generic map (5); -- OK begin end block; b6: block is constant c1 : string := to_string(100); -- OK begin end block; b7: block is signal s : integer; signal b : bit; begin s <= 1 when b else 2; -- OK s <= 2 when '1' else 6; -- OK process is variable v : integer; begin v := 1 when b else 5; -- OK s <= 5 when b else 7; -- OK end process; end block; g1: if g1a: true generate -- OK elsif g2: false generate begin end g2; else generate end generate; g1: if true generate end g1; -- Error else foo: generate end bar; -- Error end generate; g2: case integer'(5) generate -- OK when 1 => signal s : bit; begin s <= '1'; end; when 2 => begin end; when others => begin end; end generate; g3: case integer'(5) generate -- OK when foo: 1 => begin end; when 2 => begin end; when bar: others => begin end; end generate g5; -- Error /* a delimited comment -- Check that write burst was received correctly */ b8: block is signal s : bit; begin g: block (s) is -- OK begin end block; end block; b9: block is constant x : bit_vector(3 downto 0) := 4sx""; -- Error constant y : bit_vector(0 downto 0) := 4x""; -- OK begin end block; b10: block is type t_rec is record x : integer_vector; end record; type t_rec_array is array (natural range <>) of t_rec; function f return t_rec_array; constant c1 : t_rec_array := f; -- OK constant c2 : c1'subtype := c1; -- OK begin end block; b11: block is generic ( g : in integer ); generic map ( g => inertial 5 + 1 ); -- Error port ( x : in integer ); port map ( x => inertial 3 + 4 ); -- OK procedure proc ( signal x : integer ) is begin end procedure; begin proc(x => inertial x); -- Error end block; b12: block is function fact generic ( function foo( type t ) return natural -- Error ) return natural is begin end function; begin end block; b13: block is type t_rec is record f : bit; end record; signal s : t_rec; subtype ft1 is s.g'element; -- Error (once) subtype ft2 is s.g'element; -- Error (suppressed) subtype ft3 is s.h'subtype; -- Error begin end block; b14: block is port ( p : in bit_vector); port map (p => (1 to 3 => '0')); constant k1 : data_in(data_in'low)'subtype := (others => '0'); -- Error constant k2 : p(p'low)'subtype := (others => '0'); -- Error constant k3 : p(p'low)'subtype := '0'; -- OK begin end block; end architecture; nvc-r1.17.1/test/parse/vhdl2019.vhd000066400000000000000000000041261504111170000166070ustar00rootroot00000000000000-- LCS-2016-006f package pack006f is procedure info ; end package; package body pack006f is use std.env.all ; procedure info is begin report VHDL_VERSION ; report TOOL_TYPE ; report TOOL_VENDOR ; report TOOL_NAME ; report TOOL_EDITION ; report TOOL_VERSION ; end procedure ; end package body ; -- LCS-2016-055a: Syntax Regularization for endings package pack055a is component silly is port ( a : bit_vector ) ; end ; end package ; -- LCS-2016-071a: Trailing semicolion entity ent is port ( a : in boolean ; b : out boolean ; ) ; end entity ; -- LCS-2016-072b: Function Knows Vector Size package pack072b is function to_bitvector(x : natural) return rv_t of bit_vector ; end package ; package body pack072b is function to_bitvector(x : natural) return rv_t of bit_vector is variable rv : rv_t := (others =>'0') ; variable leftover : natural := x ; begin assert x < 2**rv'length report "overflow" severity warning ; for pow in 0 to rv'high loop if leftover mod 2 = 1 then rv(pow) := '1' ; end if ; leftover := leftover / 2 ; end loop ; return rv; end function ; end package body; -- LCS-2016-082: Empty record package pack082 is type rec is record end record ; end package; -- LCS-2016-086 entity E is generic (G1: INTEGER; G2: INTEGER := G1; G3, G4, G5, G6: INTEGER;G7:G6'SUBTYPE); port (P1: STRING(G3 to G4); P2: STRING(P1'RANGE); P3: P1'SUBTYPE); procedure X (Y1, Y2: INTEGER; Y3: INTEGER range Y1 to Y2; Y4: Y1'SUBTYPE); end E; -- LCS-2016-059 entity E is generic ( type t1 is private; type t2 is <>; type t3 is (<>); type t4 is range <>; type t5 is units <>; type t6 is range <> . <>; type t7 is array (t3 range <>) of t1; type t8 is access type is private; type t9 is file of t1; ); end E; -- LCS-2015-016 entity E is port ( p : type is private ); end entity; nvc-r1.17.1/test/parse/visibility1.vhd000066400000000000000000000010251504111170000176010ustar00rootroot00000000000000package p1 is constant k : integer := 1; constant j : integer := 5; type t is (FOO, BAR); end package; package p2 is constant k : integer := 2; constant j : integer := 7; type t is (BAR, BAZ); end package; use work.p1.all; use work.p2.all; package p3 is constant x : integer := k; -- Error constant j : integer := 2; -- OK constant y : integer := j; -- OK constant z : t := FOO; -- Error constant b : boolean := BAR; -- Error end package; nvc-r1.17.1/test/parse/visibility10.vhd000066400000000000000000000010071504111170000176610ustar00rootroot00000000000000package pack1 is type t_type is (foo, bar, baz); end package; ------------------------------------------------------------------------------- package pack2 is alias t_type is work.pack1.t_type; alias octet is character; function foo (x : t_type) return integer; end package; ------------------------------------------------------------------------------- use work.pack2.all; package pack3 is constant k : integer := foo(foo); -- OK constant s : string := "hello"; -- OK end package; nvc-r1.17.1/test/parse/visibility11.vhd000066400000000000000000000010501504111170000176600ustar00rootroot00000000000000package pack is generic ( g : integer ); end package; ------------------------------------------------------------------------------- entity e is end entity; architecture test of e is package inst is new work.pack generic map ( 4 ); use inst.all; constant c1 : integer := inst.g; -- OK constant c2 : integer := g; -- OK constant c3 : integer := work.pack.g; -- Error begin b: block is signal s : integer; begin end block; b.s <= 3; -- Error end architecture; nvc-r1.17.1/test/parse/visibility12.vhd000066400000000000000000000007551504111170000176740ustar00rootroot00000000000000-- work library is mylib package mylib is constant C_CONSTANT : integer := 2; end package; entity cntr is port ( x : in integer ); end entity; library mylib; use mylib.mylib.all; entity e1 is end entity; architecture a1 of e1 is begin u: entity mylib.cntr port map ( C_CONSTANT); -- OK end architecture; library mylib; use mylib.mylib; entity e2 is end entity; architecture a2 of e2 is begin u: entity mylib.cntr port map ( mylib.C_CONSTANT); -- Error end architecture; nvc-r1.17.1/test/parse/visibility2.vhd000066400000000000000000000005631504111170000176100ustar00rootroot00000000000000package pack1 is procedure p (x : integer); end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is procedure p (y : integer); -- OK, hides pack1.p end package; package body pack2 is procedure p (y : integer) is -- OK begin end procedure; end package body; nvc-r1.17.1/test/parse/visibility3.vhd000066400000000000000000000010311504111170000176000ustar00rootroot00000000000000package pack1 is type t is (foo, bar, baz); alias a is t; end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is constant k : t := foo; -- OK procedure test1; end package; package body pack2 is function height (height : integer) return integer is begin return height * 2; end function; procedure test1 is begin assert height ( height => 1 ) = 2; -- OK end procedure; end package body; nvc-r1.17.1/test/parse/visibility4.vhd000066400000000000000000000005771504111170000176170ustar00rootroot00000000000000-- Library foo package foo is constant c : integer := 1; end package; -- Library bar library foo; use foo.foo.all; package barpack is constant c : integer := 2; end package; -- Library baz library foo; use foo.all; library bar; use bar.all; use bar.*; -- Error package bazpack is constant c : integer := foo.foo.c + barpack.c; end package; nvc-r1.17.1/test/parse/visibility5.vhd000066400000000000000000000004751504111170000176150ustar00rootroot00000000000000package string_list is type string_list; type string_list is record f : integer; end record; end package; ------------------------------------------------------------------------------- use work.string_list.all; package pack2 is procedure test (x : inout string_list); -- OK end package; nvc-r1.17.1/test/parse/visibility6.vhd000066400000000000000000000005061504111170000176110ustar00rootroot00000000000000package pack1 is type t is (foo, bar, baz); type p is range 0 to 100 units one; ten = 10 one; end units; end package; use work.pack1.t; use work.pack1.p; package pack2 is constant c : t := foo; -- OK constant k : p := 5 one; -- Ok end package; nvc-r1.17.1/test/parse/visibility7.vhd000066400000000000000000000004501504111170000176100ustar00rootroot00000000000000package pack is component foo is end component; end package; ------------------------------------------------------------------------------- use work.pack.all; entity top is end entity; architecture test of top is begin u1: foo; -- OK end architecture; nvc-r1.17.1/test/parse/visibility8.vhd000066400000000000000000000014541504111170000176160ustar00rootroot00000000000000entity visibility8 is end entity; architecture test of visibility8 is constant c1 : integer := 1; subtype t1 is integer; type t2 is range 1 to 3; signal s1 : bit_vector(1 to 6); shared variable v1 : integer; alias a1 is c1; constant f1 : file_open_kind := READ_MODE; type ft is file of character; begin b1: block is signal s1 : bit_vector(1 to s1'length); -- Error begin end block; p1: process is constant c1 : integer := c1; -- Error subtype t1 is t1; -- Error type t2 is range t2'left to 5; -- Error variable v1 : integer := v1; -- Error alias a1 is a1; -- Error file f1 : ft open f1 is "x"; -- Error begin wait; end process; end architecture; nvc-r1.17.1/test/parse/visibility9.vhd000066400000000000000000000010261504111170000176120ustar00rootroot00000000000000package pack is type t_abc is (a, b, c); subtype t_ab is t_abc range a to b; function "=" (x, y : t_abc) return boolean; type t_xyz is (x, y, z); end package; ------------------------------------------------------------------------------- use work.pack.t_ab; use work.pack.x; entity visibility9 is end entity; architecture test of visibility9 is constant c1 : t_ab := a; -- OK constant c2 : boolean := c1 = a; -- OK constant c3 : boolean := x = x; -- Error begin end architecture; nvc-r1.17.1/test/parse/vunit10.vhd000066400000000000000000000005301504111170000166370ustar00rootroot00000000000000package pack1 is type t is (foo, bar, baz); function "=" (x, y : t) return boolean; end package; entity e is end entity; use work.pack1.all; architecture a of e is function "=" (x, y : work.pack1.t) return boolean is begin return work.pack1."="(x, y); -- OK (even in 93) end function; begin end architecture; nvc-r1.17.1/test/parse/vunit5.vhd000066400000000000000000000003001504111170000165560ustar00rootroot00000000000000entity vunit5 is generic ( vunit5 : integer ); -- OK (hides entity) end entity; architecture test of vunit5 is signal x : integer := vunit5; -- OK begin end architecture; nvc-r1.17.1/test/parse/vunit6.vhd000066400000000000000000000003771504111170000165750ustar00rootroot00000000000000-- library foo package pack is function func(x : integer) return integer; end package; context foo_ctx is use foo.pack.all; end context; use work.pack.all; context foo.foo_ctx; entity ent is generic ( g : integer := func(2) ); end entity; nvc-r1.17.1/test/parse/vunit7.vhd000066400000000000000000000010341504111170000165650ustar00rootroot00000000000000entity vunit7 is end entity; architecture test of vunit7 is type log_level_t is (trace, info, error, failure); impure function trace (l : log_level_t; x : string) return integer is begin return 1; end function; procedure trace (l : log_level_t; x : string) is begin end procedure; begin p: process is begin for log_level in trace to failure loop -- OK end loop; for log_level in error to failure loop -- Error end loop; end process; end architecture; nvc-r1.17.1/test/parse/vunit8.vhd000066400000000000000000000162421504111170000165750ustar00rootroot00000000000000package my_logic is type STD_ULOGIC is ( 'U', -- Uninitialized 'X', -- Forcing Unknown '0', -- Forcing 0 '1', -- Forcing 1 'Z', -- High Impedance 'W', -- Weak Unknown 'L', -- Weak 0 'H', -- Weak 1 '-' -- Don't care ); subtype std_logic is std_ulogic; end package; use work.my_logic.all; package check_pkg is type log_level_t is ( null_log_level, trace, debug, pass, info, warning, error, failure, custom_level1, custom_level2, custom_level3, custom_level4, custom_level5, custom_level6, custom_level7, custom_level8); constant check_result_tag : string := "<+/->"; function result (msg : string := "") return string; type edge_t is (rising_edge, falling_edge, both_edges); type trigger_event_t is (first_pipe, first_no_pipe, penultimate); ----------------------------------------------------------------------------- -- check_equal ----------------------------------------------------------------------------- procedure check_equal( constant got : in integer; constant expected : in integer; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in integer; constant expected : in integer; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( constant got : in std_logic; constant expected : in std_logic; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in std_logic; constant expected : in std_logic; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( constant got : in std_logic; constant expected : in boolean; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in std_logic; constant expected : in boolean; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( constant got : in boolean; constant expected : in std_logic; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in boolean; constant expected : in std_logic; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( constant got : in boolean; constant expected : in boolean; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in boolean; constant expected : in boolean; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in string; constant expected : in string; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( constant got : in character; constant expected : in character; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in character; constant expected : in character; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); procedure check_equal( variable pass : out boolean; constant got : in time; constant expected : in time; constant msg : in string := check_result_tag; constant level : in log_level_t := null_log_level; constant path_offset : in natural := 0; constant line_num : in natural := 0; constant file_name : in string := ""); ----------------------------------------------------------------------------- end package; entity vunit8 is end entity; use work.check_pkg.all; use work.my_logic.all; architecture test of vunit8 is begin p1: process is variable b : boolean; begin check_equal(true, '1', ""); -- OK check_equal(b, '1', ""); -- OK wait; end process; end architecture; nvc-r1.17.1/test/parse/vunit9.vhd000066400000000000000000000007131504111170000165720ustar00rootroot00000000000000package pack is procedure proc(address : bit_vector(7 downto 0); value : integer); alias proc_alias is proc [bit_vector, integer]; end package; ------------------------------------------------------------------------------- entity vunit9 is end entity; use work.pack; architecture test of vunit9 is begin p1: process is begin pack.proc_alias(value => 5, address => X"01"); -- OK wait; end process; end architecture; nvc-r1.17.1/test/perf/000077500000000000000000000000001504111170000144525ustar00rootroot00000000000000nvc-r1.17.1/test/perf/alloc.vhd000066400000000000000000000031271504111170000162520ustar00rootroot00000000000000package alloc is procedure test_rand_small; procedure test_rand_large; end package; library ieee; use ieee.math_real.all; package body alloc is shared variable seed1 : positive := 12456; shared variable seed2 : positive := 626256; type bv_ptr is access bit_vector; type list; type list_ptr is access list; type list is record chain : list_ptr; data : bv_ptr; end record; type bv_ptr_array is array (natural range <>) of bv_ptr; type bv_ptr_array_ptr is access bv_ptr_array; shared variable global, delete : list_ptr; shared variable count : natural := 0; procedure do_rand_test (max_size : real; max_count : positive) is variable r : real; variable p : list_ptr; variable n : natural; begin for i in 1 to 10 loop p := new list; p.chain := global; uniform(seed1, seed2, r); p.data := new bit_vector(1 to integer(r * max_size)); global := p; count := count + 1; if count > max_count then n := integer(r * real(max_count - 1)); p := global; for j in 1 to n loop p := p.chain; end loop; p.chain := p.chain.chain; count := count - 1; end if; end loop; end procedure; procedure test_rand_small is begin do_rand_test(1000.0, 500); end procedure; procedure test_rand_large is begin do_rand_test(100000.0, 100); end procedure; end package body; nvc-r1.17.1/test/perf/arraycase.vhd000066400000000000000000000026501504111170000171320ustar00rootroot00000000000000entity arraycase is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of arraycase is constant LOOPS : integer := 100; begin process is variable vec : unsigned(15 downto 0) := (others => '0'); variable a, b, c, d, e, f : natural; begin for l in 1 to LOOPS loop for i in 0 to integer'((2 ** 16) - 1) loop vec := vec + X"0001"; case vec is when X"0005" | X"ac3d" | X"9141" | X"2562" | X"0001" => a := a + 1; when X"5101" | X"bbbb" | X"cccc" | X"dddd" => b := b + 1; when X"0000" | X"ffff" => c := c + 1; when X"2510" | X"1510" | X"babc" | X"aaad" | X"1591" => d := d + 1; when X"9151" | X"abfd" | X"ab41" => e := e + 1; when X"1111" | X"9150" => f := f + 1; when others => null; end case; wait for 1 ns; end loop; end loop; report integer'image(a) & " " & integer'image(b) & " " & integer'image(c) & " " & integer'image(d) & " " & integer'image(e) & " " & integer'image(f); wait; end process; end architecture; nvc-r1.17.1/test/perf/bigcase.vhd000066400000000000000000003110351504111170000165550ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; library work; entity LogTable_0_10_74_F400_uid60 is port ( clk, rst : in std_logic; X : in std_logic_vector(9 downto 0); Y : out std_logic_vector(73 downto 0) ); end entity; architecture arch of LogTable_0_10_74_F400_uid60 is signal TableOut, TableOut_d1 : std_logic_vector(73 downto 0); begin process(clk) begin if clk'event and clk = '1' then TableOut_d1 <= TableOut; end if; end process; with X select TableOut <= "11111111111111101111111111111100000000000000000000000000000000000000000000" when "0000000000", "11111111111111101111111111111100000000000000000000000000000000000000000000" when "0000000001", "00000000001111110000011111111101010101011001010101100010001001001100110101" when "0000000010", "00000000011111110010000000000110101011101010110001000100111011110011100001" when "0000000011", "00000000101111110100100000100000000101000100110000101110000000110100101101" when "0000000100", "00000000111111111000000001010001100101011000100010110011010101111110010110" when "0000000101", "00000001001111111100100010100011010001111000011110001110000111000111011111" when "0000000110", "00000001100000000010000100011101010001011000011010110101010000001110000011" when "0000000111", "00000001110000001000100111000111101100001110001001111111101010101110110111" when "0000001000", "00000010000000010000001010101010101100010001101111001110001001010001100110" when "0000001001", "00000010010000011000101111001110011100111101111000111101000100100011100011" when "0000001010", "00000010100000100010010100111011001011010000011001011101111100011101010110" when "0000001011", "00000010110000101100111011111001000101101010011111111000110000010001010100" when "0000001100", "00000011000000111000100100010000011100010001010001010101010001000001001011" when "0000001101", "00000011010001000101001110001001100000101110000010001100010000111011001010" when "0000001110", "00000011100001010010111001101100100110001110101111100000110011000000001100" when "0000001111", "00000011110001100001100111000010000001100110011000100001011101110101110001" when "0000010000", "00000100000001110001010110010010001001001101011000010001110100100111110010" when "0000010001", "00000100010010000010000111100101010101000001111111011011111001011111111011" when "0000010010", "00000100100010010011111011000011111110101000101110001001111100011001010001" when "0000010011", "00000100110010100110110000110110100001001100101110001000011001011000100110" when "0000010100", "00000101000010111010101001000101011001100000001100110000001001110011001001" when "0000010101", "00000101010011001111100011111001000101111100110101011001001011001110100110" when "0000010110", "00000101100011100101100001011010000110100100001011110101011111100111000101" when "0000010111", "00000101110011111100100001110000111101000000000110110100101001101001000100" when "0000011000", "00000110000100010100100101000110001100100011001010101111101000101110011011" when "0000011001", "00000110010100101101101011100010011010001001000100011101010111101111100110" when "0000011010", "00000110100101000111110101001110001100010111000100001111110001111011000010" when "0000011011", "00000110110101100011000010010010001011011100011000111001100001000110111001" when "0000011100", "00000111000101111111010010110111000001010010101010111100011000110001111111" when "0000011101", "00000111010110011100100111000101011001011110011000000000100001001010111101" when "0000011110", "00000111100110111010111111000110000001001111001110010100010101110101101101" when "0000011111", "00000111110111011010011011000001100111100000101000010101011011001001001110" when "0000100000", "00000111110111011010011011000001100111100000101000010101011011001001001110" when "0000100001", "00001000000111111010111011000000111100111010001000100010001110000000101110" when "0000100010", "00001000011000011100011111001100110011101111110101010100110001011101010100" when "0000100011", "00001000101000111111000111101110000000000010110101000110011101010110010111" when "0000100100", "00001000111001100010110100101101010111100001101010011100110001111000110110" when "0000100101", "00001001001010000111100110010011110001101000110000011111010011010111000000" when "0000100110", "00001001011010101101011100101010000111100010110111010110110001101011101010" when "0000100111", "00001001101011010100010111111001010100001001100000110101011111010101111100" when "0000101000", "00001001111011111100011000001010010100000101011101001000111011010011111110" when "0000101001", "00001010001100100101011101100110000101101111000111110100110001100100010100" when "0000101010", "00001010011101001111101000010101101001001111000100110111010101111000010010" when "0000101011", "00001010101101111010111000100010000000011110011101110111011100100010000001" when "0000101100", "00001010111110100111001110010100001111000111011111011011110100101100000000" when "0000101101", "00001011001111010100101001110101011010100101110110101100001000001000001010" when "0000101110", "00001011001111010100101001110101011010100101110110101100001000001000001010" when "0000101111", "00001011100000000011001011001110101010000111001110111011100100000111011100" when "0000110000", "00001011110000110010110010101001000110101011101111011101001111001011111000" when "0000110001", "00001100000001100011100000001101111011000110011001100010001111101001000011" when "0000110010", "00001100010010010101010100000110010011111101100110100001100110101000110000" when "0000110011", "00001100100011001000001110011011011111101011100110001010000011101011000001" when "0000110100", "00001100110011111100001111010110101110011110111100111101110100011011000101" when "0000110101", "00001101000100110001010111000001010010011011000010111000010100110011111110" when "0000110110", "00001101010101100111100101100100011111011000100001111110000011010001101010" when "0000110111", "00001101100110011110111011001001101011000101110101010110011101001101011011" when "0000111000", "00001101100110011110111011001001101011000101110101010110011101001101011011" when "0000111001", "00001101110111010111010111111010001101000111101000010000000111100101110100" when "0000111010", "00001110001000010000111011111111011110111001010101001111000111110100100110" when "0000111011", "00001110011001001011100111100010111011101101100101100101110000110110111000" when "0000111100", "00001110101010000111011010101110000000101110110000110111101000101101010111" when "0000111101", "00001110111011000100010101101010001100111111011100100111001010011100110110" when "0000111110", "00001111001100000010011000100001000001011010111100001101101000111000101110" when "0000111111", "00001111011101000001100011011100000000110101110000111101110110000011011000" when "0001000000", "00001111101110000001110110100100101111111110001010010001010011110010001011" when "0001000001", "00001111111111000011010010000100110101011100100110000000010001100100110000" when "0001000010", "00001111111111000011010010000100110101011100100110000000010001100100110000" when "0001000011", "00010000010000000101110110000101111001110100010001000100011100000001011101" when "0001000100", "00010000100001001001100010110001100111100011101000000110100010001010010000" when "0001000101", "00010000110010001110011000010001101011000100111000010110110101000000010011" when "0001000110", "00010001000011010100010110101111110010101110100000110000100101101101011111" when "0001000111", "00010001010100011011011110010101101110110011110011001000100110101101111100" when "0001001000", "00010001100101100011101111001101010001100101010101100110110100010101010100" when "0001001001", "00010001110110101101001001100000001111010001100100001011001001001101100110" when "0001001010", "00010001110110101101001001100000001111010001100100001011001001001101100110" when "0001001011", "00010010000111110111101101011000011110000101010010011101100011001111110000" when "0001001100", "00010010011001000011011010111111110110001100001101101001011101011000000101" when "0001001101", "00010010101010010000010010100000010001110001011110100100100010111010100011" when "0001001110", "00010010111011011110010100000011101101000000001100000001000000111101101111" when "0001001111", "00010011001100101101011111110100000110000011111101001011011010100100101011" when "0001010000", "00010011011101111101110101111011011101001001011100010100000100010010100100" when "0001010001", "00010011011101111101110101111011011101001001011100010100000100010010100100" when "0001010010", "00010011101111001111010110100011110100011110111001100100001011110101001100" when "0001010011", "00010100000000100010000001110111010000010100101101111110110000100101010101" when "0001010100", "00010100010001110101110111111111110110111101111110101101010001101110100011" when "0001010101", "00010100100011001010111001000111110000110001000000011000010110110010000010" when "0001010110", "00010100110100100001000101011001001000000111111010101100010111011010011111" when "0001010111", "00010101000101111000011100111110001001100001001100001010000111011001011001" when "0001011000", "00010101000101111000011100111110001001100001001100001010000111011001011001" when "0001011001", "00010101010111010001000000000001000011100000001110000011101011101000000110" when "0001011010", "00010101101000101010101110101100000110101101111000100101011101001001111010" when "0001011011", "00010101111010000101101001001001100101111001000111001011011111001110000111" when "0001011100", "00010110001011100001101111100011110101110111011101000011001101010100000010" when "0001011101", "00010110011100111111000010000101001101100101101001111001100110010100110010" when "0001011110", "00010110011100111111000010000101001101100101101001111001100110010100110010" when "0001011111", "00010110101110011101100000111000000110001000001110110101111001111001100000" when "0001100000", "00010110111111111101001100000110111010101100000011100000111101000110110101" when "0001100001", "00010111010001011110000011111100001000100110111011011001001011101001001000" when "0001100010", "00010111100011000000001000100010001111011000001011010011011010101111001010" when "0001100011", "00010111110100100011011010000011110000101001001111001000100011000011111010" when "0001100100", "00010111110100100011011010000011110000101001001111001000100011000011111010" when "0001100101", "00011000000110000111111000101011010000001110001111110000000110111001111101" when "0001100110", "00011000010111101101100100100011010100000110101001000111111001111110011010" when "0001100111", "00011000101001010100011101110110100100011101110000101000110000001010111110" when "0001101000", "00011000111010111100100100101111101011101011011011101000011000110010000011" when "0001101001", "00011001001100100101111001011001010110010100100110001000101011100001110110" when "0001101010", "00011001001100100101111001011001010110010100100110001000101011100001110110" when "0001101011", "00011001011110010000011011111110010011001011111001110100001100111110100011" when "0001101100", "00011001101111111100001100101001010011010010010101001000001111110110000110" when "0001101101", "00011010000001101001001011100101001001110111110010101100011000110010011011" when "0001101110", "00011010010011010111011000111100101100011011110000110111101010010010100011" when "0001101111", "00011010010011010111011000111100101100011011110000110111101010010010100011" when "0001110000", "00011010100101000110110100111010110010101101111001100011011110010100110000" when "0001110001", "00011010110110110111011111101010010110101110101010001100010011011111011001" when "0001110010", "00011011001000101001011001010110010100101111111100000000010011011000100011" when "0001110011", "00011011011010011100100010001001101011010101101100011011110111111111010100" when "0001110100", "00011011101100010000111010001111011011010110100101110100010101111100101011" when "0001110101", "00011011101100010000111010001111011011010110100101110100010101111100101011" when "0001110110", "00011011111110000110100001110010100111111100101000010000110001100100011011" when "0001110111", "00011100001111111101011000111110010110100101110010110001000100100001110100" when "0001111000", "00011100100001110101011111111101101111000100101100100011011010001110001101" when "0001111001", "00011100110011101110110110111011111011100001001110101000001000110011000000" when "0001111010", "00011100110011101110110110111011111011100001001110101000001000110011000000" when "0001111011", "00011101000101101001011110000100001000011001001101100100001100111011011000" when "0001111100", "00011101010111100101010101100001100100100001000011100010001110011100110000" when "0001111101", "00011101101001100010011101011111100001000100011010100010010100000000100000" when "0001111110", "00011101101001100010011101011111100001000100011010100010010100000000100000" when "0001111111", "00011101111011100000110110001001010001100110110110111000101011111011111011" when "0010000000", "00011110001101100000011111101010001100000100100001111011010000100111001101" when "0010000001", "00011110011111100001011010001101101000110010110100111110001110100110010001" when "0010000010", "00011110110001100011100101111111000010100001000100011111110010111010100000" when "0010000011", "00011110110001100011100101111111000010100001000100011111110010111010100000" when "0010000100", "00011111000011100111000011001001110110011001001011100011000111110110110001" when "0010000101", "00011111010101101011110001111001100100000000010111011010100110110010011111" when "0010000110", "00011111100111110001110010011001101101010111110011100001100101011100000011" when "0010000111", "00011111111001111001000100110101110110111101010101100101100101001101100001" when "0010001000", "00011111111001111001000100110101110110111101010101100101100101001101100001" when "0010001001", "00100000001100000001101001011001100111101100001001111111001011001010001110" when "0010001010", "00100000011110001011100000010000101000111101100000011010100111001111000110" when "0010001011", "00100000110000010110101001100110100110101001011000110000010001100010100001" when "0010001100", "00100000110000010110101001100110100110101001011000110000010001100010100001" when "0010001101", "00100001000010100011000101100111001111000111010000001101000100010100100000" when "0010001110", "00100001010100110000110100011110010011001110101110101010111001100010100100" when "0010001111", "00100001100110111111110110010111100110011000010100011001010010110110101100" when "0010010000", "00100001111001010000001011011110111110011110000111110110010010111011111001" when "0010010001", "00100001111001010000001011011110111110011110000111110110010010111011111001" when "0010010010", "00100010001011100001110100000000010011111100100011110111101111000110011100" when "0010010011", "00100010011101110100110000000111100001110011000110000101000000010001001110" when "0010010100", "00100010110000001001000000000000100101100100111101100001011010010101010010" when "0010010101", "00100010110000001001000000000000100101100100111101100001011010010101010010" when "0010010110", "00100011000010011110100011110111011111011001111001100111010001000100010111" when "0010010111", "00100011010100110101011011111000010001111110111001010011110001110010001000" when "0010011000", "00100011100111001101101000001111000010100110111010100011111000111100011100" when "0010011001", "00100011100111001101101000001111000010100110111010100011111000111100011100" when "0010011010", "00100011111001100111001001000111111001001011101010000010001011000101100101" when "0010011011", "00100100001100000001111110101111000000001110010011000101111000011000000011" when "0010011100", "00100100011110011110001001010000100100111000010000000011010010001110010000" when "0010011101", "00100100011110011110001001010000100100111000010000000011010010001110010000" when "0010011110", "00100100110000111011101000111000110110111011111010101101011010011101000100" when "0010011111", "00100101000011011010011101110100001000110101011101001001010011100011010110" when "0010100000", "00100101010101111010101000001110101111101011100010110010111001100100101111" when "0010100001", "00100101010101111010101000001110101111101011100010110010111001100100101111" when "0010100010", "00100101101000011100001000010101000011010000001001110011101011011001100110" when "0010100011", "00100101111010111110111110010011011110000001010100101011001100000010000110" when "0010100100", "00100110001101100011001010010110011101001001111100001001100011101110001110" when "0010100101", "00100110001101100011001010010110011101001001111100001001100011101110001110" when "0010100110", "00100110100000001000101100101010100000100010100001011100001000110000100000" when "0010100111", "00100110110010101111100101011100001010110010000000101100010111110101000001" when "0010101000", "00100111000101010111110100111000000001001110100011110001000011111010101110" when "0010101001", "00100111000101010111110100111000000001001110100011110001000011111010101110" when "0010101010", "00100111011000000001011011001010101011111110010101010010000101110000110110" when "0010101011", "00100111101010101100011000100000110101111000010011111110110010111110000101" when "0010101100", "00100111101010101100011000100000110101111000010011111110110010111110000101" when "0010101101", "00100111111101011000101101000111001100100101000110010111000100111100000011" when "0010101110", "00101000010000000110011001001010100000011111101110100111010111110100111000" when "0010101111", "00101000100010110101011100110111100100110110011110110111101001110101100100" when "0010110000", "00101000100010110101011100110111100100110110011110110111101001110101100100" when "0010110001", "00101000110101100101111000011011001111101011101101101101100011001011111000" when "0010110010", "00101001001000010111101100000010011001110110101011000001101111001010101010" when "0010110011", "00101001011011001010110111111001111111000100010101001000101110110011110110" when "0010110100", "00101001011011001010110111111001111111000100010101001000101110110011110110" when "0010110101", "00101001101101111111011100001110111101111000001110001111001101101100000110" when "0010110110", "00101010000000110101011001001110010111101101010010001010000001011111111101" when "0010110111", "00101010000000110101011001001110010111101101010010001010000001011111111101" when "0010111000", "00101010010011101100101111000101010000110110101100011001111101000111001011" when "0010111001", "00101010100110100101011110000000110000100000101110100011011111110111001100" when "0010111010", "00101010111001011111100110001110000000110001100110111010101001111010011011" when "0010111011", "00101010111001011111100110001110000000110001100110111010101001111010011011" when "0010111100", "00101011001100011011000111111010001110101010010111100010111110100110100010" when "0010111101", "00101011011111011000000011010010101010000111101101100011111101110000010100" when "0010111110", "00101011011111011000000011010010101010000111101101100011111101110000010100" when "0010111111", "00101011110010010110011000100100100110000010111000110001111101000000110001" when "0011000000", "00101100000101010110000111111101011000010010100011101011101010010011011010" when "0011000001", "00101100011000010111010001101010011001101011101011101100100000101010110001" when "0011000010", "00101100011000010111010001101010011001101011101011101100100000101010110001" when "0011000011", "00101100101011011001110101111001000110000010011001110011111000101100101100" when "0011000100", "00101100111110011101110100110110111100001010111011100001011101111100111110" when "0011000101", "00101100111110011101110100110110111100001010111011100001011101111100111110" when "0011000110", "00101101010001100011001110110001011101111010011100000110110010110001100110" when "0011000111", "00101101100100101010000011110110010000000111111110001110001100000001010000" when "0011001000", "00101101110111110010010100010010111010101101010101110111001110010000110101" when "0011001001", "00101101110111110010010100010010111010101101010101110111001110010000110101" when "0011001010", "00101110001010111100000000010101001000101000000010101000110110001010110000" when "0011001011", "00101110011110000111001000001010100111111010001010011001010101101111001100" when "0011001100", "00101110011110000111001000001010100111111010001010011001010101101111001100" when "0011001101", "00101110110001010011101100000001001001101011010100001100010000010001110000" when "0011001110", "00101111000100100001101100000110100010001001100011100110011110111110010000" when "0011001111", "00101111000100100001101100000110100010001001100011100110011110111110010000" when "0011010000", "00101111010111110001001000101000101000101010010100011000101000000011010100" when "0011010001", "00101111101011000010000001110101010111101011010110011111110010100111010000" when "0011010010", "00101111101011000010000001110101010111101011010110011111110010100111010000" when "0011010011", "00101111111110010100010111111010101100110011101010011101000001010000001100" when "0011010100", "00110000010001101000001011000110101000110100011110000011011101101110011010" when "0011010101", "00110000100100111101011011100111001111101010001001011101011111111101010100" when "0011010110", "00110000100100111101011011100111001111101010001001011101011111111101010100" when "0011010111", "00110000111000010100001001101010101000011101001100101000111010110100001100" when "0011011000", "00110001001011101100010101011110111101100011001101001010011001000110010000" when "0011011001", "00110001001011101100010101011110111101100011001101001010011001000110010000" when "0011011010", "00110001011111000101111111010010011100011111110100011000010101010110101010" when "0011011011", "00110001110010100001000111010011010110000101101101111101010111001010101101" when "0011011100", "00110001110010100001000111010011010110000101101101111101010111001010101101" when "0011011101", "00110010000101111101101101101111111110010111100110110010100000101010001001" when "0011011110", "00110010011001011011110010110110101100101001001100010001010111000011101011" when "0011011111", "00110010011001011011110010110110101100101001001100010001010111000011101011" when "0011100000", "00110010101100111011010110110101111011100000001011111110010001010000101100" when "0011100001", "00110011000000011100011001111100001000110101010011101010110111011001111010" when "0011100010", "00110011000000011100011001111100001000110101010011101010110111011001111010" when "0011100011", "00110011010011111110111100010111110101110101010001110000111110100011111100" when "0011100100", "00110011100111100010111110010111100111000001110110000110001011110001000011" when "0011100101", "00110011100111100010111110010111100111000001110110000110001011110001000011" when "0011100110", "00110011111011001000100000001010000100010010110011001000001001101011010001" when "0011100111", "00110100001110101111100001111101111000110110111111100001111100001111111111" when "0011101000", "00110100001110101111100001111101111000110110111111100001111100001111111111" when "0011101001", "00110100100010011000000100000001110011010101011000001010011101111100100000" when "0011101010", "00110100110110000010000110100100100101101110000010011100010010000000111111" when "0011101011", "00110100110110000010000110100100100101101110000010011100010010000000111111" when "0011101100", "00110101001001101101101001110101000101011011001111000110110111100101011111" when "0011101101", "00110101011101011010101110000010001011010010011101011001101001010011010100" when "0011101110", "00110101011101011010101110000010001011010010011101011001101001010011010100" when "0011101111", "00110101110001001001010011011010110011100101011110101000110101011010111001" when "0011110000", "00110110000100111001011010001101111110000011011010001100011010010101001000" when "0011110001", "00110110000100111001011010001101111110000011011010001100011010010101001000" when "0011110010", "00110110011000101011000010101010101101111001110001111001010011100101011001" when "0011110011", "00110110101100011110001101000000001001110101100110110101000011101000001111" when "0011110100", "00110110101100011110001101000000001001110101100110110101000011101000001111" when "0011110101", "00110111000000010010111001011101011100000100011110100100000110100000111100" when "0011110110", "00110111000000010010111001011101011100000100011110100100000110100000111100" when "0011110111", "00110111010100001001001000010001110010010101101000110010111001111111010001" when "0011111000", "00110111101000000000111001101100011101111011000101011010000111011101001101" when "0011111001", "00110111101000000000111001101100011101111011000101011010000111011101001101" when "0011111010", "00110111111011111010001101111100110011101010101010111101111100011011010000" when "0011111011", "00111000001111110101000101010010001011111111001101101000111110001000110101" when "0011111100", "00111000001111110101000101010010001011111111001101101000111110001000110101" when "0011111101", "00111000100011110001011111111100000010111001100110100010100101001101011000" when "0011111110", "00111000110111101111011110001001111000000001111011100001001110001101001110" when "0011111111", "00111000110111101111011110001001111000000001111011100001001110001101001110" when "0100000000", "00111001001011101111000000001011001110101000100111011000101100001101010010" when "0100000001", "00111001011111110000000110001111101101100111100010100100101010011110100011" when "0100000010", "00111001011111110000000110001111101101100111100010100100101010011110100011" when "0100000011", "00111001110011110010110000100110111111100011001100001111101010100010111100" when "0100000100", "00111001110011110010110000100110111111100011001100001111101010100010111100" when "0100000101", "00111010000111110110111111100000110010101011110011110110101100000011000101" when "0100000110", "00111010011011111100110011001100111000111110100011001001101011110100110010" when "0100000111", "00111010011011111100110011001100111000111110100011001001101011110100110010" when "0100001000", "00111010110000000100001011111011001000000110101000101001000111111001000001" when "0100001001", "00111011000100001101001001111011011001011110100010100000110101111111110111" when "0100001010", "00111011000100001101001001111011011001011110100010100000110101111111110111" when "0100001011", "00111011011000010111101101011101101010010001001010000000011010101000010010" when "0100001100", "00111011101100100011110110110001111011011010111111010001001110011001011001" when "0100001101", "00111011101100100011110110110001111011011010111111010001001110011001011001" when "0100001110", "00111100000000110001100110001000010001101011010101101010011111111010100100" when "0100001111", "00111100000000110001100110001000010001101011010101101010011111111010100100" when "0100010000", "00111100010101000000111011110000110101100101100000100011100000010111011110" when "0100010001", "00111100101001010001110111111011110011100010000000100100001001000100111011" when "0100010010", "00111100101001010001110111111011110011100010000000100100001001000100111011" when "0100010011", "00111100111101100100011010111001011011101111110001010100001000100011101110" when "0100010100", "00111101010001111000100100111010000010010101010111101001000101100110001110" when "0100010101", "00111101010001111000100100111010000010010101010111101001000101100110001110" when "0100010110", "00111101100110001110010110001101111111010010010000010011100111000101110000" when "0100010111", "00111101100110001110010110001101111111010010010000010011100111000101110000" when "0100011000", "00111101111010100101101111000101101110011111111111001011101111011101010101" when "0100011001", "00111110001110111110101111110001101111110011011110111100111010100110110100" when "0100011010", "00111110001110111110101111110001101111110011011110111100111010100110110100" when "0100011011", "00111110100011011001011000100010100110111110010001010001101101100000111000" when "0100011100", "00111110100011011001011000100010100110111110010001010001101101100000111000" when "0100011101", "00111110110111110101101001101000111011101111101111011111100110101011101010" when "0100011110", "00111111001100010011100011010101011001110110011011110010111110110011001010" when "0100011111", "00111111001100010011100011010101011001110110011011110010111110110011001010" when "0100100000", "00111111100000110011000101111000110001000001010010111011101001000110111100" when "0100100001", "00111111100000110011000101111000110001000001010010111011101001000110111100" when "0100100010", "00111111110101010100010001100011110101000000111110011010000011000110111100" when "0100100011", "01000000001001110111000110100111011101101001000111001101100011010110100010" when "0100100100", "01000000001001110111000110100111011101101001000111001101100011010110100010" when "0100100101", "01000000011110011011100101010100100110110001101001000011110111001111101100" when "0100100110", "01000000110011000001101101111100010000011000000110001001111111111000101010" when "0100100111", "01000000110011000001101101111100010000011000000110001001111111111000101010" when "0100101000", "01000001000111101001100000101111011110100000111011011110111110001000011010" when "0100101001", "01000001000111101001100000101111011110100000111011011110111110001000011010" when "0100101010", "01000001011100010010111101111111011001011000110101101000011110001110001111" when "0100101011", "01000001110000111110000101111101001101010110000110001001110011011011000110" when "0100101100", "01000001110000111110000101111101001101010110000110001001110011011011000110" when "0100101101", "01000010000101101010111000111010001010111001111001011101010100010011111101" when "0100101110", "01000010000101101010111000111010001010111001111001011101010100010011111101" when "0100101111", "01000010011010011001010111000111100110110001101101010000101000011110000110" when "0100110000", "01000010101111001001100000110110111001111000100111100011111000011111101010" when "0100110001", "01000010101111001001100000110110111001111000100111100011111000011111101010" when "0100110010", "01000011000011111011010110011001100001011000101110001100010001011000101100" when "0100110011", "01000011000011111011010110011001100001011000101110001100010001011000101100" when "0100110100", "01000011011000101110111000000000111110101100011110111010001100100010001000" when "0100110101", "01000011011000101110111000000000111110101100011110111010001100100010001000" when "0100110110", "01000011101101100100000101111110110111100000001000000011001101101010010111" when "0100110111", "01000100000010011011000000100100110101110011000001110000001000010001000000" when "0100111000", "01000100000010011011000000100100110101110011000001110000001000010001000000" when "0100111001", "01000100010111010011101000000100100111111001000111101111011110001100111000" when "0100111010", "01000100010111010011101000000100100111111001000111101111011110001100111000" when "0100111011", "01000100101100001101111100110000000000011100010011101100101001010010001010" when "0100111100", "01000101000001001001111110111000110110011101111000001100000001111000001001" when "0100111101", "01000101000001001001111110111000110110011101111000001100000001111000001001" when "0100111110", "01000101010110000111101110110001000101010111111100001100010100101001000000" when "0100111111", "01000101010110000111101110110001000101010111111100001100010100101001000000" when "0101000000", "01000101101011000111001100101010101100111110110111001101011001101111110000" when "0101000001", "01000101101011000111001100101010101100111110110111001101011001101111110000" when "0101000010", "01000110000000001000011000110111110001100010101101111101000000000011011110" when "0101000011", "01000110010101001011010011101010011011110000101111101001011110111001110110" when "0101000100", "01000110010101001011010011101010011011110000101111101001011110111001110110" when "0101000101", "01000110101010001111111101010100111000110100110011111011000001010100101100" when "0101000110", "01000110101010001111111101010100111000110100110011111011000001010100101100" when "0101000111", "01000110111111010110010110001001011010011010111001010011011101101010100010" when "0101001000", "01000110111111010110010110001001011010011010111001010011011101101010100010" when "0101001001", "01000111010100011110011110011010010110110000100100010101001100110011111000" when "0101001010", "01000111101001101000010110011010001000100110011111010001010100010010110001" when "0101001011", "01000111101001101000010110011010001000100110011111010001010100010010110001" when "0101001100", "01000111111110110011111110011011001111010001111010011101010110110101000101" when "0101001101", "01000111111110110011111110011011001111010001111010011101010110110101000101" when "0101001110", "01001000010100000001010110110000001110101110001101010000111110111101011101" when "0101001111", "01001000010100000001010110110000001110101110001101010000111110111101011101" when "0101010000", "01001000101001010000011111101011101111011110010111101011110111101001111110" when "0101010001", "01001000111110100001011001100000011110101110100100100100000110111011011110" when "0101010010", "01001000111110100001011001100000011110101110100100100100000110111011011110" when "0101010011", "01001001010011110100000100100001001110010101101100011101011110101100000100" when "0101010100", "01001001010011110100000100100001001110010101101100011101011110101100000100" when "0101010101", "01001001101001001000100001000000110100110110111001001001111000001110111110" when "0101010110", "01001001101001001000100001000000110100110110111001001001111000001110111110" when "0101010111", "01001001111110011110101111010010001101100011001001110011001110111111111110" when "0101011000", "01001010010011110110101111101000011000011010110111101111001111010100100011" when "0101011001", "01001010010011110110101111101000011000011010110111101111001111010100100011" when "0101011010", "01001010101001010000100010010110011010001111011011111101001110001101010101" when "0101011011", "01001010101001010000100010010110011010001111011011111101001110001101010101" when "0101011100", "01001010111110101100000111101111011100100100110101001110011111010010010100" when "0101011101", "01001010111110101100000111101111011100100100110101001110011111010010010100" when "0101011110", "01001011010100001001100000000110101101110011001110111001011110010001000110" when "0101011111", "01001011010100001001100000000110101101110011001110111001011110010001000110" when "0101100000", "01001011101001101000101011101111100001001000101000011000000001100000100101" when "0101100001", "01001011111111001001101010111101001110101010011101010001001011011010110000" when "0101100010", "01001011111111001001101010111101001110101010011101010001001011011010110000" when "0101100011", "01001100010100101100011110000011010011010111001110001110110000101001011010" when "0101100100", "01001100010100101100011110000011010011010111001110001110110000101001011010" when "0101100101", "01001100101010010001000101010101010001001000001010011111001001010000001010" when "0101100110", "01001100101010010001000101010101010001001000001010011111001001010000001010" when "0101100111", "01001100111111110111100001000110101110110010111010000011100011001010101010" when "0101101000", "01001100111111110111100001000110101110110010111010000011100011001010101010" when "0101101001", "01001101010101011111110001101011011000001011001000101011001100100011101101" when "0101101010", "01001101010101011111110001101011011000001011001000101011001100100011101101" when "0101101011", "01001101101011001001110111010110111110000100010001011011101100110110110001" when "0101101100", "01001110000000110101110010011101010110010011001011000111000011011011011000" when "0101101101", "01001110000000110101110010011101010110010011001011000111000011011011011000" when "0101101110", "01001110010110100011100011010010011011101111110101001111100011000111010101" when "0101101111", "01001110010110100011100011010010011011101111110101001111100011000111010101" when "0101110000", "01001110101100010011001010001010001110010111000101111010000010000010001000" when "0101110001", "01001110101100010011001010001010001110010111000101111010000010000010001000" when "0101110010", "01001111000010000100100111011000110011001100011000001110110101010010110110" when "0101110011", "01001111000010000100100111011000110011001100011000001110110101010010110110" when "0101110100", "01001111010111110111111011010010010100011011011011101001110000011110101011" when "0101110101", "01001111010111110111111011010010010100011011011011101001110000011110101011" when "0101110110", "01001111101101101101000110001011000001011010000011111001100000111101011010" when "0101110111", "01010000000011100100001000010111001110101001111001101110111101010111010001" when "0101111000", "01010000000011100100001000010111001110101001111001101110111101010111010001" when "0101111001", "01010000011001011101000010001011010101111010001100011100100001101101110110" when "0101111010", "01010000011001011101000010001011010101111010001100011100100001101101110110" when "0101111011", "01010000101111010111110011111011110110001001100100000110010001000000111110" when "0101111100", "01010000101111010111110011111011110110001001100100000110010001000000111110" when "0101111101", "01010001000101010100011101111101010011100111110100100010110101001110110110" when "0101111110", "01010001000101010100011101111101010011100111110100100010110101001110110110" when "0101111111", "01010001011011010011000000100100010111110111110001001101110110111110001100" when "0110000000", "01010001011011010011000000100100010111110111110001001101110110111110001100" when "0110000001", "01010001110001010011011100000101110001110001000001101100000110001111101101" when "0110000010", "01010001110001010011011100000101110001110001000001101100000110001111101101" when "0110000011", "01010010000111010101110000110110010101100001110111000001101110000100011010" when "0110000100", "01010010000111010101110000110110010101100001110111000001101110000100011010" when "0110000101", "01010010011101011001111111001010111100110001000001111011001100110100110110" when "0110000110", "01010010011101011001111111001010111100110001000001111011001100110100110110" when "0110000111", "01010010110011100000000111011000100110011111101001101001001011100101111111" when "0110001000", "01010011001001101000001001110100010111001011000011101111101110110111001010" when "0110001001", "01010011001001101000001001110100010111001011000011101111101110110111001010" when "0110001010", "01010011011111110010000110110011011000101110101100101001011011010101111000" when "0110001011", "01010011011111110010000110110011011000101110101100101001011011010101111000" when "0110001100", "01010011110101111101111110101010111010100110000000111110101001110011010011" when "0110001101", "01010011110101111101111110101010111010100110000000111110101001110011010011" when "0110001110", "01010100001100001011110001110000010001101110010111110001100101001000000110" when "0110001111", "01010100001100001011110001110000010001101110010111110001100101001000000110" when "0110010000", "01010100100010011011100000011000111000101000111101011111001110000100000011" when "0110010001", "01010100100010011011100000011000111000101000111101011111001110000100000011" when "0110010010", "01010100111000101101001010111010001111011100101111110110000000010111001000" when "0110010011", "01010100111000101101001010111010001111011100101111110110000000010111001000" when "0110010100", "01010101001111000000110001101001111011111000011010100010010101010011000000" when "0110010101", "01010101001111000000110001101001111011111000011010100010010101010011000000" when "0110010110", "01010101100101010110010100111101101001010100010100110001011111110100101100" when "0110010111", "01010101100101010110010100111101101001010100010100110001011111110100101100" when "0110011000", "01010101111011101101110101001011001000110100011111101011011110110111101110" when "0110011001", "01010101111011101101110101001011001000110100011111101011011110110111101110" when "0110011010", "01010110010010000111010010101000010001001010100101100100000010100101100010" when "0110011011", "01010110010010000111010010101000010001001010100101100100000010100101100010" when "0110011100", "01010110101000100010101101101010111110110111111010000011100001100100111110" when "0110011101", "01010110101000100010101101101010111110110111111010000011100001100100111110" when "0110011110", "01010110111111000000000110101001010100001111011011000111111011100000101001" when "0110011111", "01010110111111000000000110101001010100001111011011000111111011100000101001" when "0110100000", "01010111010101011111011101111001011001010111110010111110100110101011111100" when "0110100001", "01010111010101011111011101111001011001010111110010111110100110101011111100" when "0110100010", "01010111101100000000110011110001011100001101011010110111000110100001001000" when "0110100011", "01010111101100000000110011110001011100001101011010110111000110100001001000" when "0110100100", "01011000000010100100001000100111110000100100011110101111101001000101110111" when "0110100101", "01011000000010100100001000100111110000100100011110101111101001000101110111" when "0110100110", "01011000011001001001011100110010110000001011000001111011101010010101000000" when "0110100111", "01011000011001001001011100110010110000001011000001111011101010010101000000" when "0110101000", "01011000101111110000110000101000111010101011000100100100111011100000110010" when "0110101001", "01011000101111110000110000101000111010101011000100100100111011100000110010" when "0110101010", "01011001000110011010000100100000110101101100101010000111101110010010010111" when "0110101011", "01011001000110011010000100100000110101101100101010000111101110010010010111" when "0110101100", "01011001011101000101011000110001001100111000000000101010100010011111101010" when "0110101101", "01011001011101000101011000110001001100111000000000101010100010011111101010" when "0110101110", "01011001110011110010101101110000110001110111101001010001110110100011101010" when "0110101111", "01011001110011110010101101110000110001110111101001010001110110100011101010" when "0110110000", "01011010001010100010000011110110011100011010100001010000011010011001001110" when "0110110001", "01011010001010100010000011110110011100011010100001010000011010011001001110" when "0110110010", "01011010100001010011011011011001001010010110001100010100100101001100001010" when "0110110011", "01011010100001010011011011011001001010010110001100010100100101001100001010" when "0110110100", "01011010111000000110110100101111111111101000111111110011001110101000011010" when "0110110101", "01011010111000000110110100101111111111101000111111110011001110101000011010" when "0110110110", "01011011001110111100010000010010000110011100001110110000101100100100010010" when "0110110111", "01011011001110111100010000010010000110011100001110110000101100100100010010" when "0110111000", "01011011100101110011101110010110101111000110010111001000010110010101111100" when "0110111001", "01011011100101110011101110010110101111000110010111001000010110010101111100" when "0110111010", "01011011111100101101001111010101010000001101001111110011001111011010100000" when "0110111011", "01011011111100101101001111010101010000001101001111110011001111011010100000" when "0110111100", "01011100010011101000110011100101000110101000010111101110011011001001100010" when "0110111101", "01011100010011101000110011100101000110101000010111101110011011001001100010" when "0110111110", "01011100101010100110011011011101110101100011000110000001011100000100110010" when "0110111111", "01011100101010100110011011011101110101100011000110000001011100000100110010" when "0111000000", "01011101000001100110000111010111000110011110111011000101100001001010010100" when "0111000001", "01011101000001100110000111010111000110011110111011000101100001001010010100" when "0111000010", "01011101011000100111110111101000101001010101110010101110000100000100001010" when "0111000011", "01011101011000100111110111101000101001010101110010101110000100000100001010" when "0111000100", "01011101101111101011101100101010010100011100010111010010111011100111001010" when "0111000101", "01011101101111101011101100101010010100011100010111010010111011100111001010" when "0111000110", "01011110000110110001100110110100000100100100010101111101000110001000101000" when "0111000111", "01011110000110110001100110110100000100100100010101111101000110001000101000" when "0111001000", "01011110000110110001100110110100000100100100010101111101000110001000101000" when "0111001001", "01011110011101111001100110011101111100111110110011110110001111101001011110" when "0111001010", "01011110011101111001100110011101111100111110110011110110001111101001011110" when "0111001011", "01011110110101000011101100000000000111011110100100011011111000001011011000" when "0111001100", "01011110110101000011101100000000000111011110100100011011111000001011011000" when "0111001101", "01011111001100001111110111110010110100011010100000110110011110111100100000" when "0111001110", "01011111001100001111110111110010110100011010100000110110011110111100100000" when "0111001111", "01011111100011011110001010001110011010110000000000010101010111011101000110" when "0111010000", "01011111100011011110001010001110011010110000000000010101010111011101000110" when "0111010001", "01011111111010101110100011101011011000000101010001101111101101111001110000" when "0111010010", "01011111111010101110100011101011011000000101010001101111101101111001110000" when "0111010011", "01100000010010000001000100100010010000101011110110001011100000101101011010" when "0111010100", "01100000010010000001000100100010010000101011110110001011100000101101011010" when "0111010101", "01100000101001010101101101001011101111100010111100101010110101010101110100" when "0111010110", "01100000101001010101101101001011101111100010111100101010110101010101110100" when "0111010111", "01100001000000101100011110000000100110011001111111000000001110111101110111" when "0111011000", "01100001000000101100011110000000100110011001111111000000001110111101110111" when "0111011001", "01100001011000000101010111011001101101110010111111101010101101111001100110" when "0111011010", "01100001011000000101010111011001101101110010111111101010101101111001100110" when "0111011011", "01100001011000000101010111011001101101110010111111101010101101111001100110" when "0111011100", "01100001101111100000011001110000000101000101001000111001111111001000111100" when "0111011101", "01100001101111100000011001110000000101000101001000111001111111001000111100" when "0111011110", "01100010000110111101100101011100110010011111001100111011100011101111000001" when "0111011111", "01100010000110111101100101011100110010011111001100111011100011101111000001" when "0111100000", "01100010011110011100111010111001000011001010000111010001011000000110000100" when "0111100001", "01100010011110011100111010111001000011001010000111010001011000000110000100" when "0111100010", "01100010110101111110011010011110001011001011011111010010100011110000110100" when "0111100011", "01100010110101111110011010011110001011001011011111010010100011110000110100" when "0111100100", "01100011001101100010000100100101100101101000001011110110111010100101011010" when "0111100101", "01100011001101100010000100100101100101101000001011110110111010100101011010" when "0111100110", "01100011100101000111111001101000110100100110111000001101111000100111011001" when "0111100111", "01100011100101000111111001101000110100100110111000001101111000100111011001" when "0111101000", "01100011100101000111111001101000110100100110111000001101111000100111011001" when "0111101001", "01100011111100101111111010000001100001010010101010000001100010100001100010" when "0111101010", "01100011111100101111111010000001100001010010101010000001100010100001100010" when "0111101011", "01100100010100011010000110001001011011111101101000100110010100101011010001" when "0111101100", "01100100010100011010000110001001011011111101101000100110010100101011010001" when "0111101101", "01100100101100000110011110011010011100000011100101011000001011100000011101" when "0111101110", "01100100101100000110011110011010011100000011100101011000001011100000011101" when "0111101111", "01100101000011110101000011001110100000001100100101100101110000001110010010" when "0111110000", "01100101000011110101000011001110100000001100100101100101110000001110010010" when "0111110001", "01100101011011100101110100111111101110001111101101001010010101010011111010" when "0111110010", "01100101011011100101110100111111101110001111101101001010010101010011111010" when "0111110011", "01100101011011100101110100111111101110001111101101001010010101010011111010" when "0111110100", "01100101110011011000110100001000010011010101101010110111001110110001011011" when "0111110101", "01100101110011011000110100001000010011010101101010110111001110110001011011" when "0111110110", "01100110001011001110000001000010100011111011100101101101010010011101001100" when "0111110111", "01100110001011001110000001000010100011111011100101101101010010011101001100" when "0111111000", "01100110100011000101011100001000111011110101101011100111001101010011010101" when "0111111001", "01100110100011000101011100001000111011110101101011100111001101010011010101" when "0111111010", "01100110111010111111000101110101111110010010000001010101011010110001110000" when "0111111011", "01100110111010111111000101110101111110010010000001010101011010110001110000" when "0111111100", "01100110111010111111000101110101111110010010000001010101011010110001110000" when "0111111101", "01100111010010111010111110100100010101111011010011101100001100001111011110" when "0111111110", "01100111010010111010111110100100010101111011010011101100001100001111011110" when "0111111111", "10110110001110010111100110110111000000011110101100001011000011100000101000" when "1000000000", "10110110011010010111100000110111001100011110011101001011011101111001100100" when "1000000001", "10110110100110010111111110111000100000100010011100011000010000111101110111" when "1000000010", "10110110110010011001000000111110010101000100000000011101110101111000000100" when "1000000011", "10110110111110011010100111001100000010111010111111110000000000001100111000" when "1000000100", "10110111001010011100110001100101000011011101110101111000111011010000011000" when "1000000101", "10110111001010011100110001100101000011011101110101111000111011010000011000" when "1000000110", "10110111010110011111100000001100110000100001101001101001011101101111011000" when "1000000111", "10110111100010100010110011000110100100011010010010101010110100000100110110" when "1000001000", "10110111101110100110101010010101111001111010011111010001100001110100011000" when "1000001001", "10110111111010101011000101111110001100010011111010010001111010100001111010" when "1000001010", "10111000000110110000000110000010110111010111010000110101110010011111111000" when "1000001011", "10111000010010110101101010100111010111010100011000010011100111101100001010" when "1000001100", "10111000011110111011110011101111001000111010010100000111000011010101011001" when "1000001101", "10111000011110111011110011101111001000111010010100000111000011010101011001" when "1000001110", "10111000101011000010100001011101101001010111011011101010110100100001011101" when "1000001111", "10111000110111001001110011110110010110011001100000010100000100001110010111" when "1000010000", "10111001000011010001101010111100101110001101110011001111000011000111010010" when "1000010001", "10111001001111011010000110110100001111100001001011011101010001100110110111" when "1000010010", "10111001011011100011000111100000011001100000001011110101000010100000110010" when "1000010011", "10111001100111101100101101000100101011110111001001000010011000101100001100" when "1000010100", "10111001110011110110110111100100100110110010001111101001100000001001000011" when "1000010101", "10111001110011110110110111100100100110110010001111101001100000001001000011" when "1000010110", "10111010000000000001100111000011101010111101101010001010100010111010011101" when "1000010111", "10111010001100001100111011100101011001100101100111000110111010010000000001" when "1000011000", "10111010011000011000110101001101010100010110011111000111111100011000110100" when "1000011001", "10111010100100100101010011111110111101011100111011000111000111011010010100" when "1000011010", "10111010110000110010010111111101110111100101111010010111101001100101111000" when "1000011011", "10111010111101000000000001001101100101111110111000110001100111100111101001" when "1000011100", "10111010111101000000000001001101100101111110111000110001100111100111101001" when "1000011101", "10111011001001001110001111110001101100010101110100111110100001001001101000" when "1000011110", "10111011010101011101000011101101101110111001010110100111010100000110000101" when "1000011111", "10111011100001101100011101000101010010011000110100100011111111000100100000" when "1000100000", "10111011101101111100011011111011111100000100011011001100100011011100001010" when "1000100001", "10111011111010001101000000010101010001101101010010101011100111011000000110" when "1000100010", "10111100000110011110001010010100111001100101100101010010011000010111111100" when "1000100011", "10111100000110011110001010010100111001100101100101010010011000010111111100" when "1000100100", "10111100010010101111111001111110011010100000100101101110001110101001010000" when "1000100101", "10111100011111000010001111010101011011110010110101011111110001110101100010" when "1000100110", "10111100101011010101001010011101100101010010001011010011011111100000100111" when "1000100111", "10111100110111101000101011011010011111010101111001011011110011110100000000" when "1000101000", "10111101000011111100110010001111110010110110110100001100110100110011001110" when "1000101001", "10111101010000010001011111000001001001001111011000011001100000110101101110" when "1000101010", "10111101010000010001011111000001001001001111011000011001100000110101101110" when "1000101011", "10111101011100100110110001110010001100011011110001110010100000100011000000" when "1000101100", "10111101101000111100101010100110100110111010000001100110011100101101111110" when "1000101101", "10111101110101010011001001100010000011101010000101000011111000101011111101" when "1000101110", "10111110000001101010001110101000001110001101111011111100110001100100111101" when "1000101111", "10111110001110000001111001111100110010101001101111001011100010111010010000" when "1000110000", "10111110001110000001111001111100110010101001101111001011100010111010010000" when "1000110001", "10111110011010011010001011100011011101100011110111011001110001000000100110" when "1000110010", "10111110100110110011000011011111111100000101000011101000011001101011110100" when "1000110011", "10111110110011001100100001110101111011111000011111111001101011101001010001" when "1000110100", "10111110111111100110100110101001001011001011111011111100100101000111011000" when "1000110101", "10111111001100000001010001111101011000101111110001111001111010000111110110" when "1000110110", "10111111001100000001010001111101011000101111110001111001111010000111110110" when "1000110111", "10111111011000011100100011110110010011110111001101000011000010111011000110" when "1000111000", "10111111100100111000011100010111101100011000010000100010010011000011001101" when "1000111001", "10111111110001010100111011100101010010101011111110001100111001011100101011" when "1000111010", "10111111111101110010000001100010110111101110011101010110101010001011111101" when "1000111011", "10111111111101110010000001100010110111101110011101010110101010001011111101" when "1000111100", "11000000001010001111101110010100001100111111000001100111010010001110011010" when "1000111101", "11000000010110101110000001111101000100100000010001110001010101101101110011" when "1000111110", "11000000100011001100111100100001010000111000001110101010111001010101010110" when "1000111111", "11000000101111101100011110000100100101010000011010000111110111000111111011" when "1001000000", "11000000111100001100100110101010110101010101111101110101111111010110101001" when "1001000001", "11000000111100001100100110101010110101010101111101110101111111010110101001" when "1001000010", "11000001001000101101010110010111110101011001110010011010100101110111101011" when "1001000011", "11000001010101001110101101001111011010010000100110010001111100011101000001" when "1001000100", "11000001100001110000101011010101011001010011000100110000011010101011011001" when "1001000101", "11000001101110010011010000101101101000011101111101000101010011110001010000" when "1001000110", "11000001101110010011010000101101101000011101111101000101010011110001010000" when "1001000111", "11000001111010110110011101011011111110010010001001011111011010111110011100" when "1001001000", "11000010000111011010010001100100010001110100110110010011010110111100111001" when "1001001001", "11000010010011111110101101001010011010101111101001000011100100101011001000" when "1001001010", "11000010100000100011110000010010010001010000100111101010001010011001100010" when "1001001011", "11000010101101001001011010111111101110001010011111100100011011001011001110" when "1001001100", "11000010101101001001011010111111101110001010011111100100011011001011001110" when "1001001101", "11000010111001101111101101010110101010110100101101000000001011011100000010" when "1001001110", "11000011000110010110100111011011000001001011100010001010110111001100110010" when "1001001111", "11000011010010111110001001010000101011110000001110100010011010010111101000" when "1001010000", "11000011011111100110010010111011100101101001000110000111111011101110000010" when "1001010001", "11000011011111100110010010111011100101101001000110000111111011101110000010" when "1001010010", "11000011101100001111000100011111101010100001101000110100001011000010101100" when "1001010011", "11000011111000111000011110000000110110101010101001101101110011000000111111" when "1001010100", "11000100000101100010011111100011000110111010010110100001011111010100111101" when "1001010101", "11000100010010001101001001001010011000101100011110111011110111100101110001" when "1001010110", "11000100010010001101001001001010011000101100011110111011110111100101110001" when "1001010111", "11000100011110111000011010111010101010000010011100000101001111100101100111" when "1001011000", "11000100101011100100010100110111111001100011010111111111001101011001111101" when "1001011001", "11000100111000010000110111000110000110011100010101000100000101111111000100" when "1001011010", "11000101000100111110000001101001010000100000010101101000010000101010001011" when "1001011011", "11000101000100111110000001101001010000100000010101101000010000101010001011" when "1001011100", "11000101010001101011110100100101011000001000100011011101010010001101111000" when "1001011101", "11000101011110011010001111111110011110010100010111010111000000000011111110" when "1001011110", "11000101101011001001010011111000100100101001100000110010011100000001001010" when "1001011111", "11000101101011001001010011111000100100101001100000110010011100000001001010" when "1001100000", "11000101110111111001000000010111101101010100001101011110101001010110010000" when "1001100001", "11000110000100101001010101011111111011000111010001000111011011100011001100" when "1001100010", "11000110010001011010010011010101010001011100001101000001111111100000011010" when "1001100011", "11000110011110001011111001111011110100010011010111111011011111100011001011" when "1001100100", "11000110011110001011111001111011110100010011010111111011011111100011001011" when "1001100101", "11000110101010111110001001010111101000010100000101101001100011000001100011" when "1001100110", "11000110110111110001000001101100110010101100101110111100101001111011010001" when "1001100111", "11000111000100100100100010111111011001010010111001010100100101001100100110" when "1001101000", "11000111010001011000101101010011100010100011011110110110101100010000100110" when "1001101001", "11000111010001011000101101010011100010100011011110110110101100010000100110" when "1001101010", "11000111011110001101100000101101010101100010110110000110010000011000101101" when "1001101011", "11000111101011000010111101010000111001111100111001111110101110011110111110" when "1001101100", "11000111110111111001000011000010011000000101010001101111111111111001101000" when "1001101101", "11000111110111111001000011000010011000000101010001101111111111111001101000" when "1001101110", "11001000000100101111110010000101111000110111011000111100101010110101110000" when "1001101111", "11001000010001100111001010011111100101110110100111011010010010111111110111" when "1001110000", "11001000011110011111001100010011101001001110011001010011101011000000110010" when "1001110001", "11001000011110011111001100010011101001001110011001010011101011000000110010" when "1001110010", "11001000101011010111110111100110001101110010010111001101000111010110000100" when "1001110011", "11001000111000010001001100011011011110111110011110001010110011001100111000" when "1001110100", "11001001000101001011001010110111101000110111000111111001001000000110100011" when "1001110101", "11001001010010000101110010111110111000001001010010110111001000101110110000" when "1001110110", "11001001010010000101110010111110111000001001010010110111001000101110110000" when "1001110111", "11001001011111000001000100110101011010001010101010100010111111101010100110" when "1001111000", "11001001101011111101000000011111011100111001101111101000100010101001000010" when "1001111001", "11001001111000111001100110000001001110111110000000010001111010111100011100" when "1001111010", "11001001111000111001100110000001001110111110000000010001111010111100011100" when "1001111011", "11001010000101110110110101011110111111101000000000011010010011100110001101" when "1001111100", "11001010010010110100101110111100111110110001100010000010101101111100100000" when "1001111101", "11001010011111110011010010011111011100111101101101101000111101010011100110" when "1001111110", "11001010011111110011010010011111011100111101101101101000111101010011100110" when "1001111111", "11001010101100110010100000001010101011011001001010100000101010010011011010" when "1010000000", "11001010111001110010011000000010111011111010000111001110011110100011000100" when "1010000001", "11001011000110110010111010001100100001000000100010000101011001010011011110" when "1010000010", "11001011000110110010111010001100100001000000100010000101011001010011011110" when "1010000011", "11001011010011110100000110101011101101110110010001100110001101110011011000" when "1010000100", "11001011100000110101111101100100110110001111001101000001001011110110010011" when "1010000101", "11001011101101111000011110111100001110101001010100111001110011011001001000" when "1010000110", "11001011101101111000011110111100001110101001010100111001110011011001001000" when "1010000111", "11001011111010111011101010110110001100001100111011101100110011101110011010" when "1010001000", "11001100000111111111100001010111000100101100101110011000010110111101101000" when "1010001001", "11001100010101000100000010100011001110100101111101000110011010011111110001" when "1010001010", "11001100010101000100000010100011001110100101111101000110011010011111110001" when "1010001011", "11001100100010001001001110011111000001000000100011111001010101000101000100" when "1010001100", "11001100101111001111000101001110110011101111010011011010101011001110111000" when "1010001101", "11001100111100010101100110110110111111001111111001101100010010101001101100" when "1010001110", "11001100111100010101100110110110111111001111111001101100010010101001101100" when "1010001111", "11001101001001011100110011011011111100101011001010111011100101010011000110" when "1010010000", "11001101010110100100101011000010000101110101001010010111000100110111110110" when "1010010001", "11001101100011101101001101101101110101001101010011000110001111010110101001" when "1010010010", "11001101100011101101001101101101110101001101010011000110001111010110101001" when "1010010011", "11001101110000110110011011100011100101111110100001000011100101010100001000" when "1010010100", "11001101111110000000010100100111110011111111011001111001000010101101010000" when "1010010101", "11001110001011001010111000111110111011110010010101111110101010110100111011" when "1010010110", "11001110001011001010111000111110111011110010010101111110101010110100111011" when "1010010111", "11001110011000010110001000101101011010100101101001011011101000001010101001" when "1010011000", "11001110100101100010000011110111101110010011101101001001100000110111110000" when "1010011001", "11001110110010101110101010100010010101100011000111111010000000100001001011" when "1010011010", "11001110110010101110101010100010010101100011000111111010000000100001001011" when "1010011011", "11001110111111111011111100110001101111100110110111011110110111111100000000" when "1010011100", "11001111001101001001111010101010011100011110011001110100010011110011010011" when "1010011101", "11001111011010011000100100010000111100110101110110001101101010101101111101" when "1010011110", "11001111011010011000100100010000111100110101110110001101101010101101111101" when "1010011111", "11001111100111100111111001101001110010000110000110100100100011100011100100" when "1010100000", "11001111110100110111111010111001011110010101000000101010010100101111100100" when "1010100001", "11001111110100110111111010111001011110010101000000101010010100101111100100" when "1010100010", "11010000000010001000101000000100100100010101011111011011111101010010010010" when "1010100011", "11010000001111011010000001001111100111100111101100011000011000001111100010" when "1010100100", "11010000011100101100000110011111001100011001001000111001001011011011001100" when "1010100101", "11010000011100101100000110011111001100011001001000111001001011011011001100" when "1010100110", "11010000101001111110110111110111110111100100110111101101110010000011100101" when "1010100111", "11010000110111010010010101011110001110110011100110011001000100001010110010" when "1010101000", "11010000110111010010010101011110001110110011100110011001000100001010110010" when "1010101001", "11010001000100100110011111010110111000011011110110110001011011011111100110" when "1010101010", "11010001010001111011010101100110011011100010001000100011010110100111010001" when "1010101011", "11010001011111010000111000010001011111111001000010110110011011001001100100" when "1010101100", "11010001011111010000111000010001011111111001000010110110011011001001100100" when "1010101101", "11010001101100100111000111011100101110000001011101110100110111110000111010" when "1010101110", "11010001111001111110000011001100101111001010101100010101100110110000100101" when "1010101111", "11010010000111010101101011100110001101010010100101101000110010000011011011" when "1010110000", "11010010000111010101101011100110001101010010100101101000110010000011011011" when "1010110001", "11010010010100101110000000101101110011000101101111000110111001010101011100" when "1010110010", "11010010100010000111000010101000001011111111100110000010011011001011011100" when "1010110011", "11010010100010000111000010101000001011111111100110000010011011001011011100" when "1010110100", "11010010101111100000110001011010000100001010101001011100000001111011101110" when "1010110101", "11010010111100111011001101001000001000100000100011111001010101001011011000" when "1010110110", "11010011001010010110010101110111000110101010010101011110010000100100000001" when "1010110111", "11010011001010010110010101110111000110101010010101011110010000100100000001" when "1010111000", "11010011010111110010001011101011101101000000011101101001000000110101110110" when "1010111001", "11010011100101001110101110101010101010101011000101010000100111111010101001" when "1010111010", "11010011100101001110101110101010101010101011000101010000100111111010101001" when "1010111011", "11010011110010101011111110111000101111100010001000100110001000101110010000" when "1010111100", "11010100000000001001111100011010101100001101100001011000011011110001100001" when "1010111101", "11010100000000001001111100011010101100001101100001011000011011110001100001" when "1010111110", "11010100001101101000100111010101010010000101010000111010101101001100111100" when "1010111111", "11010100011011000111111111101101010011010001101010001101100101001000110011" when "1011000000", "11010100101000101000000101100111100010101011011100001010111011010000100000" when "1011000001", "11010100101000101000000101100111100010101011011100001010111011010000100000" when "1011000010", "11010100110110001000111001001000110011111011111011110100010110010111010010" when "1011000011", "11010101000011101010011010010101111011011101001110100100011000110101000110" when "1011000100", "11010101000011101010011010010101111011011101001110100100011000110101000110" when "1011000101", "11010101010001001100101001010011101110011010010100100010011010110010001010" when "1011000110", "11010101011110101111100110000111000010101111010010111001010010111000100101" when "1011000111", "11010101011110101111100110000111000010101111010010111001010010111000100101" when "1011001000", "11010101101100010011010000110100101111001001011110010000101110100011100000" when "1011001001", "11010101111001110111101001100001101011000111100101001001011010100011010111" when "1011001010", "11010110000111011100110000010010101110111001111010011011111100101111101100" when "1011001011", "11010110000111011100110000010010101110111001111010011011111100101111101100" when "1011001100", "11010110010101000010100101001100110011100010011111111010011111111110101001" when "1011001101", "11010110100010101001001000010100110010110101010000110101010010111011010000" when "1011001110", "11010110100010101001001000010100110010110101010000110101010010111011010000" when "1011001111", "11010110110000010000011001101111100111011000001100100001111010110011010000" when "1011010000", "11010110111101111000011001100010001100100011100001000101011010110110001110" when "1011010001", "11010110111101111000011001100010001100100011100001000101011010110110001110" when "1011010010", "11010111001011100001000111110001011110100001110110000001010001011111100011" when "1011010011", "11010111011001001010100100100010011010010000010111000011001100000101100001" when "1011010100", "11010111011001001010100100100010011010010000010111000011001100000101100001" when "1011010101", "11010111100110110100101111111001111101011110111110110111110010000111110010" when "1011010110", "11010111110100011111101001111101000110110000100010000000001000111000010000" when "1011010111", "11010111110100011111101001111101000110110000100010000000001000111000010000" when "1011011000", "11011000000010001011010010110000110101011010111001101010010000011001010011" when "1011011001", "11011000001111110111101010011010001001100111001110101100011010101100111010" when "1011011010", "11011000011101100100110000111110000100010010000100100011011110010000100101" when "1011011011", "11011000011101100100110000111110000100010010000100100011011110010000100101" when "1011011100", "11011000101011010010100110100001100111001011100100010100000100100010000011" when "1011011101", "11011000111001000001001011001001110100110111100111101110110101101001100010" when "1011011110", "11011000111001000001001011001001110100110111100111101110110101101001100010" when "1011011111", "11011001000110110000011110111011110000101110000100010111100010000110010011" when "1011100000", "11011001010100100000100001111100011110111010110110101111001011011010110010" when "1011100001", "11011001010100100000100001111100011110111010110110101111001011011010110010" when "1011100010", "11011001100010010001010100010001000100011110001101100001001100110101110100" when "1011100011", "11011001110000000010110101111110100111001100110100110011100100110111001011" when "1011100100", "11011001110000000010110101111110100111001100110100110011100100110111001011" when "1011100101", "11011001111101110101000111001010001101110000000001011010000000101101011101" when "1011100110", "11011010001011101000000111111000111111100101111100001100001010101100001010" when "1011100111", "11011010001011101000000111111000111111100101111100001100001010101100001010" when "1011101000", "11011010011001011011111000010000000101000001101101011110111100011001000111" when "1011101001", "11011010100111010000011000010100100111001011101000100000110101110000011101" when "1011101010", "11011010100111010000011000010100100111001011101000100000110101110000011101" when "1011101011", "11011010110101000101101000001011110000000001010110111001011001111111010001" when "1011101100", "11011011000010111011100111111010101010010110000100001011110011010100110100" when "1011101101", "11011011000010111011100111111010101010010110000100001011110011010100110100" when "1011101110", "11011011010000110010010111100110100001110010101001011100011110101011000100" when "1011101111", "11011011011110101001110111010100100010110101111000111010000000000111100100" when "1011110000", "11011011011110101001110111010100100010110101111000111010000000000111100100" when "1011110001", "11011011101100100010000111001001111010110100101001101001000001010101110000" when "1011110010", "11011011111010011011000111001011110111111010000011010011011010111100101110" when "1011110011", "11011011111010011011000111001011110111111010000011010011011010111100101110" when "1011110100", "11011100001000010100110111011111101001000111101001111010101001110010010000" when "1011110101", "11011100010110001111011000001010011110010101101001101101010001001101111101" when "1011110110", "11011100010110001111011000001010011110010101101001101101010001001101111101" when "1011110111", "11011100100100001010101001010001101000010011000010111111101011011111010000" when "1011111000", "11011100110010000110101010111010011000100101110110001000001001001001011000" when "1011111001", "11011100110010000110101010111010011000100101110110001000001001001001011000" when "1011111010", "11011101000000000011011101001010000001101011001111011110000000101001011111" when "1011111011", "11011101001110000001000000000101110110110111110011011100001111001010100000" when "1011111100", "11011101001110000001000000000101110110110111110011011100001111001010100000" when "1011111101", "11011101011011111111010011110011001100010111101010100111001011101011110000" when "1011111110", "11011101101001111110011000010111010111001110101101110101101101011110110001" when "1011111111", "11011101101001111110011000010111010111001110101101110101101101011110110001" when "1100000000", "11011101110111111110001101110111101101011000110010011101100111000010000110" when "1100000001", "11011110000101111110110100011001100101101001110110100011010110011110100010" when "1100000010", "11011110000101111110110100011001100101101001110110100011010110011110100010" when "1100000011", "11011110010100000000001100000010010111101110001101001101001100101101000100" when "1100000100", "11011110010100000000001100000010010111101110001101001101001100101101000100" when "1100000101", "11011110100010000010010100110111011100001010101010111001101100001100001101" when "1100000110", "11011110110000000101001110111110001100011100110001111001100000101011100011" when "1100000111", "11011110110000000101001110111110001100011100110001111001100000101011100011" when "1100001000", "11011110111110001000111010011100000010111010111110101100110000110101001110" when "1100001001", "11011111001100001101010111010110011010110100110100100011101010111100111010" when "1100001010", "11011111001100001101010111010110011010110100110100100011101010111100111010" when "1100001011", "11011111011010010010100101110010110000010011001010000010101101111100110100" when "1100001100", "11011111101000011000100101110110100000011000010101101010001111101001011101" when "1100001101", "11011111101000011000100101110110100000011000010101101010001111101001011101" when "1100001110", "11011111110110011111010111100111001001000000011010100001100001100101001000" when "1100001111", "11100000000100100110111011001010001001000001010101000101010101011101000111" when "1100010000", "11100000000100100110111011001010001001000001010101000101010101011101000111" when "1100010001", "11100000010010101111010000100101000000001011000111111010000010011010010001" when "1100010010", "11100000010010101111010000100101000000001011000111111010000010011010010001" when "1100010011", "11100000100000111000010111111101001111001000001000100001001100001111110100" when "1100010100", "11100000101111000010010001011000010111011101001100010010101101110011001100" when "1100010101", "11100000101111000010010001011000010111011101001100010010101101110011001100" when "1100010110", "11100000111101001100111100111011111011101001110101011001100111101000001101" when "1100010111", "11100001001011011000011010101101011111001000011111110100010100001101110101" when "1100011000", "11100001001011011000011010101101011111001000011111110100010100001101110101" when "1100011001", "11100001011001100100101010110010100110001110101110011000100010110111011001" when "1100011010", "11100001100111110001101101010000110110001101010111111010111010011111011101" when "1100011011", "11100001100111110001101101010000110110001101010111111010111010011111011101" when "1100011100", "11100001110101111111100010001101110101010000110100011010000101100001010110" when "1100011101", "11100001110101111111100010001101110101010000110100011010000101100001010110" when "1100011110", "11100010000100001110001001101111001010100001001010001101101000000111001010" when "1100011111", "11100010010010011101100011111010011110000010011011011000100001111010100101" when "1100100000", "11100010010010011101100011111010011110000010011011011000100001111010100101" when "1100100001", "11100010100000101101110000110101011000110100110010111111011100100110111010" when "1100100010", "11100010101110111110110000100101100100110100110010100010101000011011110010" when "1100100011", "11100010101110111110110000100101100100110100110010100010101000011011110010" when "1100100100", "11100010111101010000100011010000101100111011011111011011101000000000000000" when "1100100101", "11100011001011100011001000111100011100111110110000011110101100100100101100" when "1100100110", "11100011001011100011001000111100011100111110110000011110101100100100101100" when "1100100111", "11100011011001110110100001101110100001110001011011100000000100001001011110" when "1100101000", "11100011011001110110100001101110100001110001011011100000000100001001011110" when "1100101001", "11100011101000001010101101101100101001000011100010111100111010100010101000" when "1100101010", "11100011110110011111101100111100100001100010100011101000001110110010111100" when "1100101011", "11100011110110011111101100111100100001100010100011101000001110110010111100" when "1100101100", "11100100000100110101011111100011111010111001100010011011011110001011011100" when "1100101101", "11100100010011001100000101101000100101110001011010001011000110000011010101" when "1100101110", "11100100010011001100000101101000100101110001011010001011000110000011010101" when "1100101111", "11100100100001100011011111010000010011110001001001011110111101111011110001" when "1100110000", "11100100100001100011011111010000010011110001001001011110111101111011110001" when "1100110001", "11100100101111111011101100100000110111011110000000101110101011000010011100" when "1100110010", "11100100111110010100101101100000000100011011110000000001101110100111110100" when "1100110011", "11100100111110010100101101100000000100011011110000000001101110100111110100" when "1100110100", "11100101001100101110100010010011101111001100110101010011110000011101000001" when "1100110101", "11100101001100101110100010010011101111001100110101010011110000011101000001" when "1100110110", "11100101011011001001001011000001101101010010101010011100100110101111010001" when "1100110111", "11100101101001100100100111101111110101001101110011011100011100110101110010" when "1100111000", "11100101101001100100100111101111110101001101110011011100011100110101110010" when "1100111001", "11100101111000000000111000100011111110011110001100101011111010001001001000" when "1100111010", "11100110000110011101111101100100000001100011011001010000001010011010010110" when "1100111011", "11100110000110011101111101100100000001100011011001010000001010011010010110" when "1100111100", "11100110010100111011110110110101110111111100110001010011001001000001001101" when "1100111101", "11100110010100111011110110110101110111111100110001010011001001000001001101" when "1100111110", "11100110100011011010100100011111011100001001110000011111110000011001101100" when "1100111111", "11100110110001111010000110100110101001101010000100100010001111001000110010" when "1101000000", "11100110110001111010000110100110101001101010000100100010001111001000110010" when "1101000001", "11100111000000011010011101010001011100111101111011101100100100000001101111" when "1101000010", "11100111000000011010011101010001011100111101111011101100100100000001101111" when "1101000011", "11100111001110111011101000100101110011100110010011011111000010100101001101" when "1101000100", "11100111011101011101101000101001101100000101000111010101000001010100010100" when "1101000101", "11100111011101011101101000101001101100000101000111010101000001010100010100" when "1101000110", "11100111101100000000011101100011000101111101011111010101110011010010010010" when "1101000111", "11100111101100000000011101100011000101111101011111010101110011010010010010" when "1101001000", "11100111111010100100000111011000000001110011111111001001101110001111110001" when "1101001001", "11101000001001001000100110001110100001001110110100110011011110111011101110" when "1101001010", "11101000001001001000100110001110100001001110110100110011011110111011101110" when "1101001011", "11101000010111101101111010001100100110110110000111101101101100110101111010" when "1101001100", "11101000010111101101111010001100100110110110000111101101101100110101111010" when "1101001101", "11101000100110010100000011011000010110010100000111101100101111000000001110" when "1101001110", "11101000110100111011000001110111110100010101011100000100110011001100000000" when "1101001111", "11101000110100111011000001110111110100010101011100000100110011001100000000" when "1101010000", "11101001000011100010110101110001000110101001010010110100011001000001101110" when "1101010001", "11101001000011100010110101110001000110101001010010110100011001000001101110" when "1101010010", "11101001010010001011011111001010010100000001101111110011000010100001001110" when "1101010011", "11101001100000110100111110001001100100010011111100000100011011011010010011" when "1101010100", "11101001100000110100111110001001100100010011111100000100011011011010010011" when "1101010101", "11101001101111011111010010110101000000011000010101001111111000111100111101" when "1101010110", "11101001101111011111010010110101000000011000010101001111111000111100111101" when "1101010111", "11101001111110001010011101010010110010001010111100111100010011100010000100" when "1101011000", "11101010001100110110011101101001000100101011101000010000011011101101011010" when "1101011001", "11101010001100110110011101101001000100101011101000010000011011101101011010" when "1101011010", "11101010011011100011010011111110000011111110001111010111101100001010100100" when "1101011011", "11101010011011100011010011111110000011111110001111010111101100001010100100" when "1101011100", "11101010101010010001000000010111111101001010111101001011011010000111001110" when "1101011101", "11101010111000111111100010111100111110011110011111000000100101101101100010" when "1101011110", "11101010111000111111100010111100111110011110011111000000100101101101100010" when "1101011111", "11101011000111101110111011110011010111001010010100011010001100000010000011" when "1101100000", "11101011000111101110111011110011010111001010010100011010001100000010000011" when "1101100001", "11101011010110011111001011000001010111100100111110111111111100001001100001" when "1101100010", "11101011010110011111001011000001010111100100111110111111111100001001100001" when "1101100011", "11101011100101010000010000101101010001001010010010011001110000111011000011" when "1101100100", "11101011110100000010001100111101010110011011100100001111110001000100010110" when "1101100101", "11101011110100000010001100111101010110011011100100001111110001000100010110" when "1101100110", "11101100000010110100111111110111111010111111111100001110110111000101101010" when "1101100111", "11101100000010110100111111110111111010111111111100001110110111000101101010" when "1101101000", "11101100010001101000101001100011010011100100100100010010000010101100101001" when "1101101001", "11101100100000011101001010000101110101111100111000110000010101010100110111" when "1101101010", "11101100100000011101001010000101110101111100111000110000010101010100110111" when "1101101011", "11101100101111010010100001100101111001000010111000101111011011010110011010" when "1101101100", "11101100101111010010100001100101111001000010111000101111011011010110011010" when "1101101101", "11101100111110001000110000001001110100110111010110011011000011101011000100" when "1101101110", "11101100111110001000110000001001110100110111010110011011000011101011000100" when "1101101111", "11101101001100111111110101111000000010100010000111100001000111010011010110" when "1101110000", "11101101011011110111110010110110111100010010010101110010100010100101011000" when "1101110001", "11101101011011110111110010110110111100010010010101110010100010100101011000" when "1101110010", "11101101101010110000100111001100111101011110101111101001000001110000010010" when "1101110011", "11101101101010110000100111001100111101011110101111101001000001110000010010" when "1101110100", "11101101111001101010010011000000100010100101111000110001100010011111100100" when "1101110101", "11101110001000100100110110011000001001001110011010111011101100001010000110" when "1101110110", "11101110001000100100110110011000001001001110011010111011101100001010000110" when "1101110111", "11101110010111100000010001011010010000000111010110101110000000011001111010" when "1101111000", "11101110010111100000010001011010010000000111010110101110000000011001111010" when "1101111001", "11101110100110011100100100001101010111001000010100011111000101111001110110" when "1101111010", "11101110100110011100100100001101010111001000010100011111000101111001110110" when "1101111011", "11101110110101011001101110110111111111010001110101010011101110110111010100" when "1101111100", "11101111000100010111110001100000101010101101100100000001111101000110110101" when "1101111101", "11101111000100010111110001100000101010101101100100000001111101000110110101" when "1101111110", "11101111010011010110101100001101111100101110100110011001000101011011000010" when "1101111111", "11101111010011010110101100001101111100101110100110011001000101011011000010" when "1110000000", "11101111100010010110011111000110011001110001101110001110110011111110010011" when "1110000001", "11101111100010010110011111000110011001110001101110001110110011111110010011" when "1110000010", "11101111110001010111001010010000100111011101101010110001010011011111110011" when "1110000011", "11110000000000011000101101110011001100100011011001111110011001000101111011" when "1110000100", "11110000000000011000101101110011001100100011011001111110011001000101111011" when "1110000101", "11110000001111011011001001110100110000111110011001111111110110011000001110" when "1110000110", "11110000001111011011001001110100110000111110011001111111110110011000001110" when "1110000111", "11110000011110011110011110011011111101110100111010101100110011110100000110" when "1110001000", "11110000011110011110011110011011111101110100111010101100110011110100000110" when "1110001001", "11110000101101100010101011101111011101011000001111010000010101000000001111" when "1110001010", "11110000101101100010101011101111011101011000001111010000010101000000001111" when "1110001011", "11110000111100100111110001110101111011000100111111110101001000110011001001" when "1110001100", "11110001001011101101110000110110000011100011011011010110100111000010011100" when "1110001101", "11110001001011101101110000110110000011100011011011010110100111000010011100" when "1110001110", "11110001011010110100101000110110100100100111101001010110111101110000111000" when "1110001111", "11110001011010110100101000110110100100100111101001010110111101110000111000" when "1110010000", "11110001101001111100011001111110001101010001111011111010101111110010000001" when "1110010001", "11110001101001111100011001111110001101010001111011111010101111110010000001" when "1110010010", "11110001111001000101000100010011101101101111000001101001100110011011001010" when "1110010011", "11110001111001000101000100010011101101101111000001101001100110011011001010" when "1110010100", "11110010001000001110100111111101110111011000010111110100011000011010010001" when "1110010101", "11110010010111011001000101000011011100110100011100100000100111101011100110" when "1110010110", "11110010010111011001000101000011011100110100011100100000100111101011100110" when "1110010111", "11110010100110100100011011101011010001110111000000111001011000001000100000" when "1110011000", "11110010100110100100011011101011010001110111000000111001011000001000100000" when "1110011001", "11110010110101110000101011111100001011100001011011100101100001001010000001" when "1110011010", "11110010110101110000101011111100001011100001011011100101100001001010000001" when "1110011011", "11110011000100111101110101111101000000000010111011000011011011111010110010" when "1110011100", "11110011000100111101110101111101000000000010111011000011011011111010110010" when "1110011101", "11110011010100001011111001110100100110111000111000001010010000010100110000" when "1110011110", "11110011100011011010110111101001111000101111001000110000100010100111111110" when "1110011111", "11110011100011011010110111101001111000101111001000110000100010100111111110" when "1110100000", "11110011110010101010101111100011101111100000010010011000100011101000010011" when "1110100001", "11110011110010101010101111100011101111100000010010011000100011101000010011" when "1110100010", "11110100000001111011100001101001000110010101111101000010000101100001000111" when "1110100011", "11110100000001111011100001101001000110010101111101000010000101100001000111" when "1110100100", "11110100010001001101001110000000111001101001000110000001110111001110010110" when "1110100101", "11110100010001001101001110000000111001101001000110000001110111001110010110" when "1110100110", "11110100100000011111110100110010000111000010010010111110101000011011111001" when "1110100111", "11110100101111110011010110000011101101011010000100110011111000001100000110" when "1110101000", "11110100101111110011010110000011101101011010000100110011111000001100000110" when "1110101001", "11110100111111000111110001111100101100111001001010111010010000001000000110" when "1110101010", "11110100111111000111110001111100101100111001001010111010010000001000000110" when "1110101011", "11110101001110011101001000100100000110111000110110010101101110011100101011" when "1110101100", "11110101001110011101001000100100000110111000110110010101101110011100101011" when "1110101101", "11110101011101110011011010000000111110000011001101001001100000100111101011" when "1110101110", "11110101011101110011011010000000111110000011001101001001100000100111101011" when "1110101111", "11110101101101001010100110011010010110010011011101110001110000111010110101" when "1110110000", "11110101101101001010100110011010010110010011011101110001110000111010110101" when "1110110001", "11110101111100100010101101110111010100110110010010100011001000111001100001" when "1110110010", "11110101111100100010101101110111010100110110010010100011001000111001100001" when "1110110011", "11110110001011111011110000011111000000001010000101010000001010110111111101" when "1110110100", "11110110011011010101101110011000011111111111010010110100100100100011011111" when "1110110101", "11110110011011010101101110011000011111111111010010110100100100100011011111" when "1110110110", "11110110101010110000100111101010111101011000101111000110011100111011110101" when "1110110111", "11110110101010110000100111101010111101011000101111000110011100111011110101" when "1110111000", "11110110111010001100011100011101100010101011111000101101011111100111000010" when "1110111001", "11110110111010001100011100011101100010101011111000101101011111100111000010" when "1110111010", "11110111001001101001001100110111011011100001001101000000000111101001101100" when "1110111011", "11110111001001101001001100110111011011100001001101000000000111101001101100" when "1110111100", "11110111011001000110111000111111110100110100011100000110101100001110110111" when "1110111101", "11110111011001000110111000111111110100110100011100000110101100001110110111" when "1110111110", "11110111101000100101100000111101111100110100111101000100110001001011011110" when "1110111111", "11110111101000100101100000111101111100110100111101000100110001001011011110" when "1111000000", "11110111111000000101000100111001000011000110000010001000011101101001111100" when "1111000001", "11111000000111100101100100111000011000011111001100111111111011001100000111" when "1111000010", "11111000000111100101100100111000011000011111001100111111111011001100000111" when "1111000011", "11111000010111000111000001000011001111001100100011010100111111010001111100" when "1111000100", "11111000010111000111000001000011001111001100100011010100111111010001111100" when "1111000101", "11111000100110101001011001100000111010101111000011001111000001110100110101" when "1111000110", "11111000100110101001011001100000111010101111000011001111000001110100110101" when "1111000111", "11111000110110001100101110011000101111111100110111111011000010101000001011" when "1111001000", "11111000110110001100101110011000101111111100110111111011000010101000001011" when "1111001001", "11111001000101110000111111110010000101000001101110011010000000010000101100" when "1111001010", "11111001000101110000111111110010000101000001101110011010000000010000101100" when "1111001011", "11111001010101010110001101110100010001011111001010010101100010100101000111" when "1111001100", "11111001010101010110001101110100010001011111001010010101100010100101000111" when "1111001101", "11111001100100111100011000100110101110001100111010111010111011001011111110" when "1111001110", "11111001100100111100011000100110101110001100111010111010111011001011111110" when "1111001111", "11111001110100100011100000010000110101011001001111111100011110001010100110" when "1111010000", "11111001110100100011100000010000110101011001001111111100011110001010100110" when "1111010001", "11111010000100001011100100111010000010101001001110111001010101011011011000" when "1111010010", "11111010000100001011100100111010000010101001001110111001010101011011011000" when "1111010011", "11111010010011110100100110101001110010111001001000001011110001000001011000" when "1111010100", "11111010100011011110100101100111100100011100101100011101110110110001000011" when "1111010101", "11111010100011011110100101100111100100011100101100011101110110110001000011" when "1111010110", "11111010110011001001100001111010110110111111100010000100110011100110100010" when "1111010111", "11111010110011001001100001111010110110111111100010000100110011100110100010" when "1111011000", "11111011000010110101011011101011001011100101011010100010110001000011001011" when "1111011001", "11111011000010110101011011101011001011100101011010100010110001000011001011" when "1111011010", "11111011010010100010010011000000000100101010101000001111010001001100110000" when "1111011011", "11111011010010100010010011000000000100101010101000001111010001001100110000" when "1111011100", "11111011100010010000001000000001000110000100010100000110010011101010000100" when "1111011101", "11111011100010010000001000000001000110000100010100000110010011101010000100" when "1111011110", "11111011110001111110111010110101110101000000110011011110000101111001110000" when "1111011111", "11111011110001111110111010110101110101000000110011011110000101111001110000" when "1111100000", "11111100000001101110101011100101111000000111111110000011100001100000110001" when "1111100001", "11111100000001101110101011100101111000000111111110000011100001100000110001" when "1111100010", "11111100010001011111011010011000110111011011100011111101011010101111100010" when "1111100011", "11111100010001011111011010011000110111011011100011111101011010101111100010" when "1111100100", "11111100100001010001000111010110011100010111100011110110100001111101101000" when "1111100101", "11111100100001010001000111010110011100010111100011110110100001111101101000" when "1111100110", "11111100110001000011110010100110010001110010100001001110011010011100110110" when "1111100111", "11111100110001000011110010100110010001110010100001001110011010011100110110" when "1111101000", "11111101000000110111011100010000000011111101111010110001001001000101101101" when "1111101001", "11111101000000110111011100010000000011111101111010110001001001000101101101" when "1111101010", "11111101010000101100000100011011100000100110100000110101111101100000101010" when "1111101011", "11111101010000101100000100011011100000100110100000110101111101100000101010" when "1111101100", "11111101100000100001101011010000010110110100101100000100111000001111111110" when "1111101101", "11111101100000100001101011010000010110110100101100000100111000001111111110" when "1111101110", "11111101110000011000010000110110010111001100110100000011010000011111111111" when "1111101111", "11111101110000011000010000110110010111001100110100000011010000011111111111" when "1111110000", "11111110000000001111110101010101010011101111100110000111011100000011110010" when "1111110001", "11111110000000001111110101010101010011101111100110000111011100000011110010" when "1111110010", "11111110010000001000011000110100111111111010011100010011011100000110010110" when "1111110011", "11111110010000001000011000110100111111111010011100010011011100000110010110" when "1111110100", "11111110100000000001111011011101010000100111110100010110110001011000011111" when "1111110101", "11111110100000000001111011011101010000100111110100010110110001011000011111" when "1111110110", "11111110101111111100011101010101111100001111100110110111011010100101101100" when "1111110111", "11111110101111111100011101010101111100001111100110110111011010100101101100" when "1111111000", "11111110111111110111111110100110111010100111011110100001111111011010111111" when "1111111001", "11111110111111110111111110100110111010100111011110100001111111011010111111" when "1111111010", "11111111001111110100011111011000000101000011001111100001001011001011101100" when "1111111011", "11111111001111110100011111011000000101000011001111100001001011001011101100" when "1111111100", "11111111011111110001111111110001010110010101001110111100011001100001110110" when "1111111101", "11111111011111110001111111110001010110010101001110111100011001100001110110" when "1111111110", "11111111101111110000011111111010101010101110101010011101111000001000100000" when "1111111111", "--------------------------------------------------------------------------" when others; Y <= TableOut_d1; end architecture; ------------------------------------------------------------------------------- entity bigcase is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of bigcase is signal clk, rst : std_logic; signal X : std_logic_vector(9 downto 0); signal Y : std_logic_vector(73 downto 0); begin LogTable_0_10_74_F400_uid60_1: entity work.LogTable_0_10_74_F400_uid60 port map ( clk => clk, rst => rst, X => X, Y => Y ); p1: process is variable ctr : unsigned(9 downto 0); begin for rep in 1 to 10000 loop for i in 1 to 2**9 - 1 loop X <= std_logic_vector(ctr); ctr := ctr + 1; wait for 1 ns; end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/perf/bigram.vhd000066400000000000000000000060321504111170000164170ustar00rootroot00000000000000package util is function log2(x : in integer) return integer; end package; package body util is function log2(x : in integer) return integer is variable r : integer := 0; variable c : integer := 1; begin if x <= 1 then r := 1; else while c < x loop r := r + 1; c := c * 2; end loop; end if; return r; end function; end package body; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.util.all; entity memory is generic ( WIDTH : integer; DEPTH : integer ); port ( clk : in std_logic; addr : in unsigned(log2(DEPTH) - 1 downto 0); din : in std_logic_vector(WIDTH - 1 downto 0); dout : out std_logic_vector(WIDTH - 1 downto 0); we : in std_logic ); end entity; architecture rtl of memory is type ram_t is array (0 to DEPTH - 1) of std_logic_vector(WIDTH - 1 downto 0); signal addr_r : unsigned(log2(DEPTH) - 1 downto 0); signal ram : ram_t; begin reg: process (clk) is begin if rising_edge(clk) then addr_r <= addr; if we = '1' then ram(to_integer(addr)) <= din; end if; end if; end process; dout <= ram(to_integer(addr_r)); end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.util.all; entity bigram is end entity; architecture test of bigram is constant ITERS : integer := 100; constant WIDTH : integer := 1024; constant DEPTH : integer := 1024; signal clk : std_logic := '0'; signal addr : unsigned(log2(DEPTH) - 1 downto 0); signal din : std_logic_vector(WIDTH - 1 downto 0); signal dout : std_logic_vector(WIDTH - 1 downto 0); signal we : std_logic := '1'; signal running : boolean := true; begin clk <= not clk after 5 ns when running else '0'; uut: entity work.memory generic map ( WIDTH => WIDTH, DEPTH => DEPTH ) port map ( clk => clk, addr => addr, din => din, dout => dout, we => we ); stim: process is begin for j in 1 to ITERS loop wait for 20 ns; we <= '1'; for i in 0 to DEPTH - 1 loop addr <= to_unsigned(i, addr'length); din <= std_logic_vector(to_unsigned((i + j) mod DEPTH, WIDTH)); wait for 10 ns; end loop; we <= '0'; for i in 0 to DEPTH - 1 loop addr <= to_unsigned(i, addr'length); wait for 10 ns; assert dout = std_logic_vector(to_unsigned((i + j) mod DEPTH, WIDTH)); end loop; end loop; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/perf/binarytrees.vhd000066400000000000000000000066731504111170000175200ustar00rootroot00000000000000package binarytrees is procedure test_binarytrees; end package; package body binarytrees is type treeNode; type treeNodePtr is access treeNode; type treeNode is record left, right : treeNodePtr; end record; procedure NewTreeNode (variable left, right : in treeNodePtr; result : out treeNodePtr) is begin result := new TreeNode'(left, right); end procedure; procedure ItemCheck (variable tree : in treeNodePtr; result : out integer) is variable left_sum, right_sum : integer; begin if tree.left = null then result := 1; else ItemCheck(tree.left, left_sum); ItemCheck(tree.right, right_sum); result := 1 + left_sum + right_sum; end if; end procedure; procedure BottomUpTree (depth : in integer; result : out treeNodePtr) is variable left, right : treeNodePtr; begin if depth > 0 then BottomUpTree(depth - 1, left); BottomUpTree(depth - 1, right); end if; NewTreeNode(left, right, result); end procedure; procedure DeleteTree (tree : inout treeNodePtr) is begin if tree.left /= null then DeleteTree(tree.left); DeleteTree(tree.right); end if; deallocate(tree); end procedure; procedure test_binarytrees is constant VERBOSE : boolean := false; constant N : integer := 10; variable minDepth : integer; variable maxDepth : integer; variable stretchDepth : integer; variable check : integer; variable depth : integer; variable iterations : integer; variable sum : integer; variable stretchTree : treeNodePtr; variable longLivedTree : treeNodePtr; variable tempTree : treeNodePtr; begin minDepth := 4; if minDepth + 2 > N then maxDepth := minDepth + 2; else maxDepth := N; end if; stretchDepth := maxDepth + 1; BottomUpTree(stretchDepth, stretchTree); ItemCheck(stretchTree, check); assert not VERBOSE report "stretch tree of depth " & integer'image(stretchDepth) & HT & " check: " & integer'image(check) severity note; DeleteTree(stretchTree); BottomUpTree(maxDepth, longLivedTree); depth := minDepth; while depth <= maxDepth loop iterations := 2 ** (maxDepth - depth + minDepth); check := 0; for i in 1 to iterations loop BottomUpTree(depth, temptree); ItemCheck(tempTree, sum); check := check + sum; DeleteTree(tempTree); end loop; assert not VERBOSE report integer'image(iterations) & HT & " trees of depth " & integer'image(depth) & HT & " check: " & integer'image(check) severity note; depth := depth + 2; end loop; ItemCheck(longLivedTree, check); assert not VERBOSE report "long lived tree of depth " & integer'image(maxDepth) & HT & " check: " & integer'image(check) severity note; end procedure; end package body; nvc-r1.17.1/test/perf/dyn_agg.vhd000066400000000000000000000011121504111170000165600ustar00rootroot00000000000000entity dyn_agg is end entity; architecture test of dyn_agg is constant WIDTH : integer := 20; constant ITERS : integer := 14; signal s : bit_vector(WIDTH - 1 downto 0); function func(constant W : integer) return bit_vector is variable r : bit_vector(W - 1 downto 0); begin return r; end function; begin process is begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s <= func(WIDTH); end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/perf/ename.vhd000066400000000000000000000003711504111170000162430ustar00rootroot00000000000000package ename is procedure test_lookup; end package; package body ename is constant c : integer := 42; procedure test_lookup is begin assert << constant @work.ename.c : integer >> = 42; end procedure; end package body; nvc-r1.17.1/test/perf/grind.vhd000066400000000000000000000131631504111170000162640ustar00rootroot00000000000000-- Courtesy of Brian Padalino -- library ieee ; use ieee.std_logic_1164.all ; entity memory is generic ( DEPTH : positive ) ; port ( clock : in std_logic ; write_addr : in natural range 0 to DEPTH-1 ; write_data : in std_logic_vector ; write_valid : in std_logic ; read_addr : in natural range 0 to DEPTH-1 ; read_data : out std_logic_vector ; read_valid : in std_logic ) ; end entity ; architecture arch of memory is type mem_t is array(natural range 0 to DEPTH-1) of std_logic_vector(write_data'range) ; signal mem : mem_t := (others =>(others =>'0')) ; begin process(all) begin if( rising_edge(clock) ) then if( write_valid = '1' ) then mem(write_addr) <= write_data ; end if ; if( read_valid = '1' ) then read_data <= mem(read_addr) ; end if ; end if ; end process ; end architecture ; library ieee ; use ieee.std_logic_1164.all ; use ieee.math_real.all ; entity traffic_gen is generic ( WIDTH : positive ; DEPTH : positive ; SEED : positive ) ; port ( clock : in std_logic ; write_addr : out natural range 0 to DEPTH-1 ; write_data : out std_logic_vector(WIDTH-1 downto 0) ; write_valid : out std_logic ; read_addr : out natural range 0 to DEPTH-1 ; read_valid : out std_logic ) ; end entity ; architecture arch of traffic_gen is type rng_t is record s1 : positive ; s2 : positive ; end record ; procedure rand_std_logic(variable rng : inout rng_t ; signal y : out std_logic) is variable r : real ; begin uniform(rng.s1, rng.s2, r) ; y <= '1' when r > 0.5 else '0' ; end procedure ; procedure rand_slv(variable rng : inout rng_t ; signal y : out std_logic_vector) is variable r : real ; begin for i in y'range loop uniform(rng.s1, rng.s2, r) ; y(i) <= '1' when r > 0.5 else '0' ; end loop ; end procedure ; procedure rand_natural(variable rng : inout rng_t ; max : in positive ; signal y : out natural) is variable r : real ; begin uniform(rng.s1, rng.s2, r) ; y <= natural(real(max) * r) ; end procedure ; procedure randomize_write(variable rng : inout rng_t ; signal addr : out natural range 0 to DEPTH-1 ; signal data : out std_logic_vector(WIDTH-1 downto 0) ; signal valid : out std_logic ) is begin rand_natural(rng, DEPTH-1, addr) ; rand_slv(rng, data) ; rand_std_logic(rng, valid) ; end procedure ; procedure randomize_read(variable rng : inout rng_t ; signal addr : out natural range 0 to DEPTH-1 ; signal valid : out std_logic ) is begin rand_natural(rng, DEPTH-1, addr) ; rand_std_logic(rng, valid) ; end procedure ; function create_rng(s1, s2 : in positive) return rng_t is variable rv : rng_t ; begin rv.s1 := s1 ; rv.s2 := s2 ; return rv ; end function ; begin process(all) variable write_rng : rng_t := create_rng(SEED+WIDTH+DEPTH, SEED*WIDTH*DEPTH) ; variable read_rng : rng_t := create_rng(SEED+WIDTH*DEPTH, SEED*WIDTH+DEPTH) ; begin if( rising_edge(clock) ) then randomize_write(write_rng, write_addr, write_data, write_valid) ; randomize_read(read_rng, read_addr, read_valid) ; end if ; end process ; end architecture ; library ieee ; use ieee.std_logic_1164.all ; entity grind is generic ( MEMORY_WIDTH : positive := 256 ; MEMORY_DEPTH : positive := 32768 ; NUM_INSTANCES : positive := 128 ) ; end entity ; architecture arch of grind is subtype data_t is std_logic_vector(MEMORY_WIDTH-1 downto 0) ; subtype addr_t is natural range 0 to MEMORY_DEPTH-1 ; type datas_t is array(natural range 0 to NUM_INSTANCES-1) of data_t ; type addrs_t is array(natural range 0 to NUM_INSTANCES-1) of addr_t ; signal clock : std_logic := '0' ; signal write_addrs : addrs_t ; signal write_datas : datas_t ; signal write_valids : std_logic_vector(0 to NUM_INSTANCES-1) ; signal read_addrs : addrs_t ; signal read_datas : datas_t ; signal read_valids : std_logic_vector(0 to NUM_INSTANCES-1) ; begin clock <= not clock after 1 ns ; create_memories : for i in write_addrs'range generate U_traffic_gen : entity work.traffic_gen generic map ( WIDTH => data_t'length, DEPTH => MEMORY_DEPTH, SEED => i+1 ) port map ( clock => clock, write_addr => write_addrs(i), write_data => write_datas(i), write_valid => write_valids(i), read_addr => read_addrs(i), read_valid => read_valids(i) ) ; U_mem : entity work.memory generic map ( DEPTH => MEMORY_DEPTH ) port map ( clock => clock, write_addr => write_addrs(i), write_data => write_datas(i), write_valid => write_valids(i), read_addr => read_addrs(i), read_data => read_datas(i), read_valid => read_valids(i) ) ; end generate ; tb : process variable t : time := 35 us ; begin report "Starting testbench for " & time'image(t) ; wait for t ; report "Finished" ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/perf/math_real.vhd000066400000000000000000000012351504111170000171120ustar00rootroot00000000000000package math_real_perf is function test_sin return real; function test_cos return real; end package; library ieee; use ieee.math_real.all; package body math_real_perf is function test_sin return real is variable r, accum : real := 0.0; begin while r < 100.0 loop accum := accum + sin(r); r := r + 0.1; end loop; return r; end function; function test_cos return real is variable r, accum : real := 0.0; begin while r < 100.0 loop accum := accum + cos(r); r := r + 0.1; end loop; return r; end function; end package body; nvc-r1.17.1/test/perf/numeric_std.vhd000066400000000000000000000174051504111170000175000ustar00rootroot00000000000000package numeric_std_perf is procedure test_to_unsigned; procedure test_add_unsigned; procedure test_add_signed; procedure test_to_01; procedure test_resize; procedure test_to_signed; procedure test_mul_unsigned; procedure test_mul_signed; procedure test_sub_unsigned; procedure test_sub_signed; procedure test_add_one; procedure test_add_zero; procedure test_less_unsigned; procedure test_geq_unsigned; procedure test_div_unsigned; procedure test_big_div_unsigned; end package; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package body numeric_std_perf is procedure test_to_unsigned is constant WIDTH : integer := 8; constant ITERS : integer := 1; variable s : unsigned(WIDTH - 1 downto 0); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s := to_unsigned(j, WIDTH); end loop; end loop; end procedure; procedure test_add_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (others => '0'); constant one : unsigned(WIDTH - 1 downto 0) := to_unsigned(1, WIDTH); begin for i in 1 to ITERS loop accum := accum + one; end loop; assert accum = to_unsigned(ITERS, WIDTH); end procedure; procedure test_add_signed is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : signed(WIDTH - 1 downto 0) := (others => '0'); constant one : signed(WIDTH - 1 downto 0) := to_signed(1, WIDTH); begin for i in 1 to ITERS loop accum := accum + one; end loop; assert accum = to_signed(ITERS, WIDTH); end procedure; procedure test_to_01 is constant ITERS : integer := 100; variable s : unsigned(31 downto 0); begin for i in 1 to ITERS loop s := "Z10-H01U10101L00Z10-H01U10101L00"; s := to_01(s, '0'); assert s = (31 downto 0 => '0'); s := "01010100100101000100101111100010"; s := to_01(s, '-'); assert s = "01010100100101000100101111100010"; end loop; end procedure; procedure test_resize is constant ITERS : integer := 100; variable u1 : unsigned(31 downto 0); variable u2 : unsigned(39 downto 0); variable s1 : signed(31 downto 0); variable s2 : signed(7 downto 0); begin for i in 1 to ITERS loop u2 := resize(u1, 40); s2 := resize(s1, 8); end loop; end procedure; procedure test_to_signed is constant WIDTH : integer := 16; constant ITERS : integer := 1; variable s : signed(WIDTH - 1 downto 0); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** (WIDTH/2) - 1) loop s := to_signed(j - 100, WIDTH); end loop; end loop; end procedure; procedure test_mul_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 15; constant two : unsigned(WIDTH - 1 downto 0) := to_unsigned(2, WIDTH); variable accum : unsigned(WIDTH - 1 downto 0) := to_unsigned(1, WIDTH); begin for i in 1 to ITERS loop accum := resize(accum * two, WIDTH); end loop; assert accum = to_unsigned(2 ** ITERS, WIDTH); end procedure; procedure test_mul_signed is constant WIDTH : integer := 17; constant ITERS : integer := 15; constant two : signed(WIDTH - 1 downto 0) := to_signed(2, WIDTH); variable accum : signed(WIDTH - 1 downto 0) := to_signed(1, WIDTH); begin for i in 1 to ITERS loop accum := resize(accum * two, WIDTH); end loop; assert accum = to_signed(2 ** ITERS, WIDTH); end procedure; procedure test_sub_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (others => '0'); constant one : unsigned(WIDTH - 1 downto 0) := to_unsigned(1, WIDTH); begin for i in 1 to ITERS loop accum := accum - one; end loop; assert accum = to_unsigned(2**WIDTH - ITERS, WIDTH); end procedure; procedure test_sub_signed is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : signed(WIDTH - 1 downto 0) := (others => '0'); constant one : signed(WIDTH - 1 downto 0) := to_signed(1, WIDTH); begin for i in 1 to ITERS loop accum := accum - one; end loop; assert accum = to_signed(-ITERS, WIDTH); end procedure; procedure test_add_one is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS/2 loop accum := accum + 1; end loop; for i in 1 to ITERS/2 loop accum := 1 + accum; end loop; assert accum = to_unsigned(ITERS, WIDTH); end procedure; procedure test_add_zero is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS/2 loop accum := accum + 0; end loop; for i in 1 to ITERS/2 loop accum := 0 + accum; end loop; assert accum = X"0"; end procedure; procedure test_less_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable value : unsigned(WIDTH - 1 downto 0) := (others => '0'); constant mid : unsigned(WIDTH - 1 downto 0) := to_unsigned(ITERS / 2, WIDTH); constant one : unsigned(WIDTH - 1 downto 0) := to_unsigned(1, WIDTH); variable accum : integer := 0; begin for i in 1 to ITERS loop if value < mid then accum := accum + 1; end if; value := value + one; end loop; assert accum = ITERS / 2; end procedure; procedure test_geq_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable value : unsigned(WIDTH - 1 downto 0) := (others => '0'); constant mid : unsigned(WIDTH - 1 downto 0) := to_unsigned(ITERS / 2, WIDTH); constant one : unsigned(WIDTH - 1 downto 0) := to_unsigned(1, WIDTH); variable accum : integer := 0; begin for i in 1 to ITERS loop if value >= mid then accum := accum + 1; end if; value := value + one; end loop; assert accum = ITERS / 2; end procedure; procedure test_div_unsigned is constant WIDTH : integer := 16; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (WIDTH - 1 => '1', others => '0'); constant two : unsigned(0 to WIDTH - 1) := to_unsigned(2, WIDTH); begin for i in 1 to ITERS loop accum := accum / two; end loop; assert accum = to_unsigned(0, WIDTH); end procedure; procedure test_big_div_unsigned is constant WIDTH : integer := 140; constant ITERS : integer := 500; variable accum : unsigned(WIDTH - 1 downto 0) := (WIDTH - 1 => '1', others => '0'); constant two : unsigned(0 to WIDTH - 1) := to_unsigned(2, WIDTH); begin for i in 1 to ITERS loop accum := accum / two; end loop; assert accum = to_unsigned(0, WIDTH); end procedure; end package body; nvc-r1.17.1/test/perf/simple.vhd000066400000000000000000000060051504111170000164470ustar00rootroot00000000000000package simple is procedure test_add2; procedure test_fact; procedure test_sum; procedure test_int_image; procedure test_sqrt; procedure test_copy; end package; package body simple is function add2 (n : integer) return integer is begin return n + 2; end function; procedure test_add2 is variable sum : integer := 0; begin for i in 1 to 100 loop sum := sum + add2(i); end loop; assert sum = 5250; end procedure; --------------------------------------------------------------------------- function fact (n : integer) return integer is variable r : integer := 1; begin for i in 1 to n loop r := r * i; end loop; return r; end function; procedure test_fact is variable sum : integer := 0; begin for i in 1 to 12 loop sum := sum + fact(i); end loop; assert sum = 522956313; end procedure; --------------------------------------------------------------------------- type int_vector is array (natural range <>) of integer; function sum(a : int_vector) return integer is variable result : integer := 0; begin for i in a'range loop result := result + a(i); end loop; return result; end function; procedure test_sum is variable dummy : integer; variable arr : int_vector(1 to 1000); begin for i in 1 to arr'length loop arr(i) := i; end loop; for i in 1 to 100 loop dummy := dummy + sum(arr); end loop; end procedure; --------------------------------------------------------------------------- procedure test_int_image is variable s : string(1 to 3); begin assert integer'image(4) = "4"; for i in 1 to 100 loop assert integer'image(i)'length <= 3; end loop; end procedure; --------------------------------------------------------------------------- function sqrt (n, limit : real) return real is variable x : real := n; variable root : real; begin loop root := 0.5 * (x + (n / x)); exit when abs(root - x) < limit; x := root; end loop; return root; end function; procedure test_sqrt is variable sum : real := 0.0; begin assert abs(sqrt(4.0, 0.0001) - 2.0) < 0.0001; for i in 1 to 100 loop sum := sum + sqrt(real(i), 0.0001); end loop; assert integer(sum) = 671; end procedure; --------------------------------------------------------------------------- procedure do_copy (dest : out bit_vector; src : in bit_vector) is begin dest := src; end procedure; procedure test_copy is variable src, dest : bit_vector(1 to 4096); begin for i in 1 to 100 loop do_copy(dest, src); end loop; end procedure; end package body; nvc-r1.17.1/test/perf/std_logic.vhd000066400000000000000000000044051504111170000171270ustar00rootroot00000000000000package std_logic_perf is procedure test_to_x01; procedure test_and; procedure test_or; procedure test_xor; procedure test_equal; procedure test_not_equal; end package; library ieee; use ieee.std_logic_1164.all; package body std_logic_perf is procedure test_to_x01 is constant ITERS : integer := 100; variable s : std_logic_vector(31 downto 0); begin for i in 1 to ITERS loop s := "Z10-H01U10101L00Z10-H01U10101L00"; s := to_x01(s); assert s = "X10X101X10101000X10X101X10101000"; end loop; end procedure; procedure test_and is constant ITERS : integer := 100; variable x, y : std_logic_vector(32 downto 0); begin y := '0' & X"12345678"; for i in 1 to ITERS loop x(i rem 33) := '1'; x := x and y; end loop; end procedure; procedure test_or is constant ITERS : integer := 100; variable x, y : std_logic_vector(32 downto 0); begin y := '0' & X"12345678"; for i in 1 to ITERS loop x(i rem 33) := '1'; x := x or y; end loop; end procedure; procedure test_xor is constant ITERS : integer := 100; variable s : std_logic_vector(32 downto 0) := (others => '0'); begin for i in 1 to ITERS loop s(31 downto 0) := s(32 downto 1) xor X"deadbeef"; s(32) := '1'; end loop; end procedure; procedure test_equal is constant ITERS : integer := 500; variable x, y : std_logic_vector(32 downto 0); variable count : natural; begin for i in 1 to ITERS loop if x = y then count := count + 1; x(i rem 32) := y(0); end if; end loop; assert count = ITERS; end procedure; procedure test_not_equal is constant ITERS : integer := 500; variable x, y : std_logic_vector(6 downto 0); variable count : natural; begin for i in 1 to ITERS loop if x /= y then count := count + 1; x(i rem 32) := y(0); end if; end loop; assert count = 0; end procedure; end package body; nvc-r1.17.1/test/perf/synopsys.vhd000066400000000000000000000060471504111170000170730ustar00rootroot00000000000000package synopsys_perf is procedure test_unsigned_plus; procedure test_signed_plus; procedure test_slv_plus; procedure test_std_logic_plus; procedure test_mul_signed; procedure test_mul_unsigned; end package; library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; package body synopsys_perf is procedure test_unsigned_plus is constant WIDTH : integer := 8; constant ITERS : integer := 1; constant ONE : unsigned(WIDTH - 1 downto 0) := conv_unsigned(1, WIDTH); variable s : unsigned(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s := s + ONE; end loop; end loop; end procedure; procedure test_signed_plus is constant WIDTH : integer := 8; constant ITERS : integer := 1; constant ONE : signed(WIDTH - 1 downto 0) := conv_signed(1, WIDTH); variable s : signed(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s := s + ONE; end loop; end loop; end procedure; procedure test_slv_plus is constant WIDTH : integer := 8; constant ITERS : integer := 1; constant ONE : std_logic_vector(WIDTH - 1 downto 0) := (0 => '1', others => '0'); variable s : std_logic_vector(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s := s + ONE; end loop; end loop; end procedure; procedure test_std_logic_plus is constant WIDTH : integer := 8; constant ITERS : integer := 1; variable s : unsigned(WIDTH - 1 downto 0) := (others => '0'); begin for i in 1 to ITERS loop for j in 0 to integer'(2 ** WIDTH - 1) loop s := s + '1'; s := '1' + s; end loop; end loop; end procedure; procedure test_mul_unsigned is constant WIDTH : integer := 17; constant ITERS : integer := 15; constant two : unsigned(WIDTH - 1 downto 0) := conv_unsigned(2, WIDTH); variable accum : unsigned(WIDTH - 1 downto 0) := conv_unsigned(1, WIDTH); begin for i in 1 to ITERS loop accum := conv_unsigned(accum * two, WIDTH); end loop; assert accum = conv_unsigned(2 ** ITERS, WIDTH); end procedure; procedure test_mul_signed is constant WIDTH : integer := 17; constant ITERS : integer := 15; constant two : signed(WIDTH - 1 downto 0) := conv_signed(2, WIDTH); variable accum : signed(WIDTH - 1 downto 0) := conv_signed(1, WIDTH); begin for i in 1 to ITERS loop accum := conv_signed(accum * two, WIDTH); end loop; assert accum = conv_signed(2 ** ITERS, WIDTH); end procedure; end package body; nvc-r1.17.1/test/perf/textio.vhd000066400000000000000000000017271504111170000165000ustar00rootroot00000000000000package textio_perf is procedure test_write; procedure test_read; end package; use std.textio.all; package body textio_perf is procedure test_write is constant ITERS : integer := 10; variable l : line; begin for i in 1 to ITERS loop l := null; write(l, string'("hello, world")); write(l, true); write(l, bit'( '1' )); write(l, 5 ns, field => 10); end loop; end procedure; procedure test_read is constant ITERS : integer := 10; variable l : line; variable n : integer; variable g : boolean; begin for i in 1 to ITERS loop l := new string'("1234 5 145 14 123 52 1 2 14 1 512 12 5 14 1 5 10 5 1414 12341 -1 55 11 55"); for j in 1 to 24 loop read(l, n); end loop; read(l, n, g); assert not g; end loop; end procedure; end package body; nvc-r1.17.1/test/perf/toggle_cov.vhd000066400000000000000000000022561504111170000173120ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; entity toggle_cov is end entity; architecture tb of toggle_cov is constant C_MEM_DEPTH : natural := 2 ** 18; type t_large_mem is array (0 to C_MEM_DEPTH - 1) of std_logic_vector(31 downto 0); signal large_mem : t_large_mem := (others => (others => '0')); begin process begin wait for 1 ns; for j in 1 to 500 loop report "Iteration: " & integer'image(j); for i in 0 to C_MEM_DEPTH - 1 loop large_mem(i) <= "00000000000000000000000000000000"; end loop; wait for 1 ns; for i in 0 to C_MEM_DEPTH - 1 loop large_mem(i) <= "11111111111111111111111111111111"; end loop; wait for 1 ns; for i in 0 to C_MEM_DEPTH - 1 loop large_mem(i) <= "00000000000000000000000000000000"; end loop; wait for 1 ns; for i in 0 to C_MEM_DEPTH - 1 loop large_mem(i) <= "11111111111111111111111111111111"; end loop; wait for 1 ns; end loop; wait; end process; end architecture; nvc-r1.17.1/test/perf/value.vhd000066400000000000000000000013631504111170000162740ustar00rootroot00000000000000package value is impure function test_string2int return integer; impure function test_string2real return real; impure function test_string2phys return time; end package; package body value is impure function test_string2int return integer is variable s : string(1 to 10); begin s := "1234567890"; return integer'value(s); end function; impure function test_string2real return real is variable s : string(1 to 11); begin s := "15.12511e-7"; return real'value(s); end function; impure function test_string2phys return time is variable s : string(1 to 8); begin s := "16231 ns"; return time'value(s); end function; end package body; nvc-r1.17.1/test/perf/vital.vhd000066400000000000000000000023031504111170000162720ustar00rootroot00000000000000package vital is procedure test_statetable; end package; library ieee; use ieee.vital_timing.all; use ieee.vital_primitives.all; use ieee.std_logic_1164.all; package body vital is constant DFFTable: VitalStateTableType := -- RESET D CLK State Q (( '0', '-', '-', '-', '0'), ( '1', '1', '/', '-', '1'), ( '1', '0', '/', '-', '0'), ( '1', 'X', '/', '-', 'X'), ( '1', '-', '-', '-', 'S')); procedure test_statetable is variable d, q : std_logic := '0'; variable clk : std_logic := '0'; variable reset : std_logic := '0'; variable prev : std_logic_vector(1 to 3); variable result : std_logic; begin vitalstatetable(result, prev, dfftable, (reset, d, clk)); clk := '1'; vitalstatetable(result, prev, dfftable, (reset, d, clk)); clk := '0'; for i in 1 to 1000 loop clk := '1'; vitalstatetable(result, prev, dfftable, (reset, d, clk)); clk := '0'; vitalstatetable(result, prev, dfftable, (reset, d, clk)); d := not q; end loop; assert q = '0'; end procedure; end package body; nvc-r1.17.1/test/psl/000077500000000000000000000000001504111170000143145ustar00rootroot00000000000000nvc-r1.17.1/test/psl/clock1.vhd000066400000000000000000000006071504111170000161760ustar00rootroot00000000000000entity clock1 is end entity; architecture test of clock1 is signal x, y, clk : bit; begin -- psl assert (x -> next y)@clk'event; -- OK -- psl assert always x -> y; -- Error -- psl cover {x;y}; -- Error -- psl assert (x -> (next y)@x'event)@clk'event; -- Error -- psl assert x@(1); -- Error end architecture; nvc-r1.17.1/test/psl/issue1001.vhd000066400000000000000000000005411504111170000164510ustar00rootroot00000000000000entity issue1001 is end entity; architecture test of issue1001 is signal x, y, clk : bit; default clock is clk'event; function f (v : bit_vector) return bit is begin return v(v'left); end function; begin assert always onehot(x); -- Error assert always x -> f(y); -- Error end architecture; nvc-r1.17.1/test/psl/issue910.vhd000066400000000000000000000004651504111170000164060ustar00rootroot00000000000000entity psl_multiline is end entity; architecture tb of psl_multiline is signal a,b,c,clk : bit; -- psl default clock is clk'event; begin -- psl cov_1 : cover -- {a = '1' and -- b = '1' and -- c = '1'}; -- psl cov_2 : cover -- {a = '1' and b = '0'}; end architecture; nvc-r1.17.1/test/psl/parse1.vhd000066400000000000000000000042041504111170000162120ustar00rootroot00000000000000entity parse1 is end entity; architecture test of parse1 is signal x, y, clk : bit; -- psl default clock is clk'event and clk = '1'; -- OK begin -- psl assert always x -> y ; -- OK -- psl assert always x or y -> not y; -- OK -- psl assert always e or y -> x; -- Error -- psl assert always 5 > 2; -- OK -- psl assert not x; -- OK -- psl assert x -> (not y or x); -- OK -- psl assert always (x or y) -> -- (y xor x) = '1'; -- OK -- psl assert always (x or y) -> -- A comment inside PSL -- (y xor fff) = x; -- Error -- psl assert -- Also OK -- psl x -> y; -- OK -- psl assert x -> next y; -- OK -- psl assert x -> next! y; -- OK -- psl assert never x and y; -- OK -- psl assert eventually! x and y; -- OK -- psl foo: assert x; -- OK -- psl foo: assert not x; -- Error -- psl assert x -> (x until y); -- OK -- psl assert x -> (x until_ y); -- OK -- psl assert x -> (x until! y); -- OK -- psl assert x -> (x until_! y); -- OK -- psl assert ((x = '1') and (xxxx = '1')); -- Error (issue #911) -- psl assert always (x -> next x) abort y; -- OK -- psl assert always (x -> (y or next x)); -- OK -- psl assert (x or y) or (next x); -- OK -- psl -- assert always xxx; -- Error (issue #1135) -- psl1111 assert assert assert; -- Not PSL -- psl assert always x = prev(x); -- OK -- psl assert always prev(y) = '1'; -- OK -- psl assert x union y; -- OK -- psl assert not (x union y); -- OK -- psl assert not ('1' union '0'); -- OK -- psl assert not ('1' union '1' union '0'); -- OK end architecture; nvc-r1.17.1/test/psl/parse2.vhd000066400000000000000000000007261504111170000162200ustar00rootroot00000000000000entity parse2 is end entity; architecture test of parse2 is signal x, y, clk : bit; default clock is clk'event and clk = '1'; -- OK begin assert always x -> y ; -- OK (PSL) assert always x or y -> not y; -- OK assert always e or y -> x; -- Error assert x = '1' report "ok" severity note; -- OK (VHDL) cov_0: cover {x}; -- OK cover {y; x}; -- OK end architecture; nvc-r1.17.1/test/psl/parse3.vhd000066400000000000000000000055261504111170000162240ustar00rootroot00000000000000entity parse3 is end entity; architecture test of parse3 is signal a, b, c, clk : bit; signal global_int : integer; signal global_vect : bit_vector(3 downto 0); signal global_string : string(1 to 10); signal global_bool : boolean; begin -- psl default clock is clk'event and clk = '1'; -- psl assert never b; -- psl assert always (a -> next_a[3 to 5] (b)); -- psl assert always (a -> next[3] (b)); -- psl assert always (a -> next_event(b)[4](c)); -- psl assert {a}; -- psl assert {a;b and c}; -- psl cover {a ; b;c }; -- psl named_cover : cover {c} report "'c' is covered"; -- psl assume b; -- psl named_assume : assume (a -> b); -- psl assume_guarantee ( b -> c) report "assume_guarantee met"; -- psl restrict {c ;b ; c; b}; -- psl named_restrict : restrict {c}; -- psl restrict_guarantee {b; b} report "restrict_guarantee met"; -- psl fairness (b = '1'); -- psl named_fairness : fairness (a = '1'); -- psl strong fairness (a = '1'), (b = '1'); -- psl property my_prop_1 is (a='1'); -- psl sequence my_seq_1 is {b}; -- psl property p_const_1(const i) is {global_int=i}; -- psl property p_const_2(const numeric i) is {global_int=i}; -- psl property p_const_numeric(const numeric i) is {global_int=i}; -- psl property p_const_bit(const bit i) is {a=i}; -- psl property p_const_bitvector(const bitvector i) is {global_vect=i}; -- psl property p_const_string(const string i) is {global_string=i}; -- psl property p_const_boolean(const boolean i) is {global_bool=i}; -- psl property p_mutable_numeric(mutable numeric i) is {global_int=i}; -- psl property p_mutable_bit(mutable bit i) is {a=i}; -- psl property p_mutable_bitvector(mutable bitvector i) is {global_vect=i}; -- psl property p_mutable_string(mutable string i) is {global_string=i}; -- psl property p_mutable_boolean(mutable boolean i) is {global_bool=i}; -- psl property p_hdltype_1(hdltype integer i) is {a}; -- psl property p_hdltype_2(hdltype bit_vector i) is {a}; -- psl property p_hdltype_3(hdltype bit_vector(5 downto 0) i) is {a}; -- psl property p_hdltype_4(const hdltype integer i; hdltype integer j) is {global_int=(i+j)}; -- psl property p_hdltype_5(const hdltype integer i; mutable hdltype integer j) is {global_int=(i+j)}; -- psl property p_property_1(property x) is {a}; -- psl property p_sequence_1(sequence x) is {a}; -- psl assert {a} |=> {b;c}; -- psl assert {a} |-> {b}; -- psl assert {a} |=> {{b[->3]} && {(a and not c)[+]}; not c and b}; -- psl assert {global_vect(1)}; -- OK (issue #1115) -- psl -- OK (issue #1135) -- assert always ( -- { -- a = '1'; -- true -- } |-> c = '0' -- ) abort c = '1'; end architecture; nvc-r1.17.1/test/psl/parse4.vhd000066400000000000000000000025201504111170000162140ustar00rootroot00000000000000entity parse4 is end entity; architecture test of parse4 is signal a, b, c, clk : bit; begin -- psl default clock is clk'event and clk = '1'; -- psl sequence seq_a is {a;b;c}; -- psl sequence seq_b(const rpt) is a[*rpt]; -- Sequence_Instance -- psl cover seq_a; -- Sequence_Instance(Actual_Parameter_List) -- psl cover seq_b(5); -- psl cover seq_b(4, {a;b;c}); -- Boolean [* [ Count ] ] -- psl cover a[*10]; -- psl cover a='1'[*1][*2][*3]; -- Sequence [* [ Count ] ] -- psl cover seq_b(4)[*2]; -- psl cover seq_b(4)[*2][*3]; -- [* [ Count ] ] -- psl cover [*5]; -- psl cover [*5 to 10]; -- [+] -- psl cover [+]; -- Boolean [= Count ] -- psl cover c[=10]; -- psl cover c[=5 to 6]; -- psl cover c[=10][*3]; -- Boolean [-> [ positive_Count ] ] -- psl cover b[->4]; -- Boolean Proc_Block -- psl cover a[[signal sig : bit; sig <= '1';]]; -- Sequence Proc_Block -- psl cover {a;b} [[signal sig : bit_vector(3 downto 0); sig <= "0000";]]; -- psl foo: cover {a;b;c} @ (clk'event and clk = '1'); -- psl property p1 is {a; a}; -- psl cover p1(a); -- Error -- Paramterized SERE -- psl cover {for i in {1 to 3}: && {seq_b(i)}}; -- Garbage after PSL directive -- psl asfasfa; end architecture; nvc-r1.17.1/test/psl/parse5.vhd000066400000000000000000000007741504111170000162260ustar00rootroot00000000000000entity parse5 is end entity; architecture test of parse5 is signal a, b, c, d, e, f, clk : bit; -- psl default clock is clk'event and clk = '1'; begin -- psl cover {a:b:c:d}; -- psl cover {a;b:c}; -- psl cover {{a}|{b}}; -- psl cover {a[*5]|b[+]}; -- psl cover {{a;b}|{c;d}|{d;a}}; -- psl cover {{a;b} within {c;d;e;f}}; -- psl cover {{a;b;c} && {d;e;f}}; -- psl cover {{a;b;c} & {d;e}}; -- psl cover {{a:b} & {c;d} && {e;f} | {d;e}}; end architecture; nvc-r1.17.1/test/psl/sem1.vhd000066400000000000000000000034771504111170000156770ustar00rootroot00000000000000entity sem1 is end entity; architecture test of sem1 is signal x, y, clk : bit; signal i : integer; constant c : integer := 5; -- psl default clock is clk'event and clk = '1'; -- OK begin -- psl assert always i; -- Error -- psl assert x -> next[5] (y); -- OK -- psl assert x -> next[-1] (y); -- OK (during parse/sem) -- psl assert x -> next[x] (y); -- Error -- psl assert x -> next[i] (y); -- Error -- psl assert x -> next[c] (y); -- OK -- psl assert x -> next i; -- Error -- psl assert (next x) -> not x; -- Error -- psl assert x until_ (next x); -- Error -- psl assert (next x) until y; -- Error -- psl assert always next_e [1 to 3] (y -> next x); -- Error -- psl assert always x <-> y; -- OK -- psl assert always (next x) <-> y; -- Error -- psl assert always x <-> (next y); -- Error -- psl assert eventually! (x -> next y); -- Error -- psl assert never (x -> next y); -- Error -- psl assume bad; -- Error -- psl restrict {x; bad}; -- Error -- psl sequence seq1 is {not(x); x}; -- OK -- psl sequence seq2 is {not(f); x}; -- Error -- psl assert (x -> next y) before x; -- Error -- psl assert x before (x -> next y); -- Error -- psl assert (x -> next y) |=> {y}; -- Error -- psl assert (x -> next y) or (y -> next x); -- Error -- psl assert {x[*]}[=2]; -- Error -- psl assert {x[*]}[->1]; -- Error -- psl assert {x[*1 to clk]}; -- Error -- psl assert {z [[foo <= 1;]]}; -- Error -- psl endpoint e1 is {x; y}; -- Not supported end architecture; nvc-r1.17.1/test/psl/sem2.vhd000066400000000000000000000010361504111170000156650ustar00rootroot00000000000000entity sem1 is end entity; architecture test of sem1 is signal x, y, clk : bit; signal i : integer; constant c : integer := 5; -- psl default clock is clk'event and clk = '1'; -- OK begin -- psl assert always prev(x); -- OK -- psl assert rose(i); -- Error -- psl assert rose(x); -- OK -- psl assert ended({x;y}); -- OK -- psl cover prev(x, i); -- Error -- psl cover {x union c}; -- Error -- psl cover {x union xxxx}; -- Error end architecture; nvc-r1.17.1/test/questa.sh000077500000000000000000000010141504111170000153530ustar00rootroot00000000000000#!/bin/bash -e vlib work root=$(git rev-parse --show-toplevel) regress=$root/test/regress plusopt=+acc vsimopt="-t fs" cover=false if $cover; then plusopt+=" +cover" vsimopt+=" -coverage" fi if [ -f $regress/$1.v ]; then vlog $plusopt $regress/$1.v fi if [ -f $regress/$1.vhd ]; then vcom $plusopt -2008 $regress/$1.vhd fi rm -f /tmp/questa.do if $cover; then echo "coverage save -onexit $1.ucdb" >>/tmp/questa.do fi cat >>/tmp/questa.do <) of integer; type int_vec_ptr is access int_vec; subtype int_vec10 is int_vec(1 to 10); type int_vec10_ptr is access int_vec10; subtype one_to_3 is integer range 1 to 3; begin process is variable p : int_vec_ptr; variable q : int_vec10_ptr; variable r : int_vec_ptr; begin p := new int_vec(1 to 5); p(1) := 2; assert p(1) = 2; deallocate(p); assert p = null; q := new int_vec10; q(3) := 5; assert q(3) = 5; deallocate(q); r := new int_vec(one_to_3'range); deallocate(r); wait; end process; end architecture; nvc-r1.17.1/test/regress/access3.vhd000066400000000000000000000012101504111170000172110ustar00rootroot00000000000000entity access3 is end entity; architecture test of access3 is type int_ptr is access integer; type string_ptr is access string; begin process is variable i : int_ptr; variable s : string_ptr; begin i := new integer; assert i.all = integer'left; deallocate(i); i := new integer'(3); assert i.all = 3; deallocate(i); s := new string'(""); assert s.all = ""; assert s'length = 0; deallocate(s); s := new string'("hello"); assert s.all = "hello"; deallocate(s); wait; end process; end architecture; nvc-r1.17.1/test/regress/access4.vhd000066400000000000000000000010541504111170000172200ustar00rootroot00000000000000entity access4 is end entity; architecture test of access4 is type int_vec is array (integer range <>) of integer; type int_vec_ptr is access int_vec; begin process is variable p : int_vec_ptr; begin p := new int_vec(1 to 10); p(1 to 3) := (1, 2, 3); assert p(1 to 3) = (1, 2, 3); assert p(2) = 2; p.all(4 to 6) := (4, 5, 6); assert p.all(4) = 4; assert p'length = 10; assert p.all'low = 1; deallocate(p); wait; end process; end architecture; nvc-r1.17.1/test/regress/access5.vhd000066400000000000000000000007231504111170000172230ustar00rootroot00000000000000entity access5 is end entity; architecture test of access5 is type int_array is array (natural range <>) of integer; type int_array_ptr is access int_array; begin process is variable a, b : int_array_ptr; begin a := new int_array(1 to 3); a.all := (1, 2, 3); b := new int_array'(a.all); assert b.all = (1, 2, 3); deallocate(a); deallocate(b); wait; end process; end architecture; nvc-r1.17.1/test/regress/access6.vhd000066400000000000000000000003471504111170000172260ustar00rootroot00000000000000entity access6 is end entity; architecture test of access6 is type int_ptr is access integer; begin process is variable p : int_ptr; begin p.all := 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/access7.vhd000066400000000000000000000017601504111170000172270ustar00rootroot00000000000000entity access7 is end entity; architecture test of access7 is type int_ptr is access integer; type int_ptr_ptr is access int_ptr; type int_ptr_array is array (integer range <>) of int_ptr; type int_ptr_array_ptr is access int_ptr_array; procedure alloc_ptr(x : out int_ptr_ptr) is begin x := new int_ptr; end procedure; procedure alloc_ptr_array(x : out int_ptr_array_ptr) is begin x := new int_ptr_array(1 to 3); end procedure; begin process is variable pp : int_ptr_ptr; variable pa : int_ptr_array_ptr; begin alloc_ptr(pp); assert pp.all = null; pp.all := new integer'(4); assert pp.all.all = 4; deallocate(pp.all); deallocate(pp); alloc_ptr_array(pa); assert pa.all = (null, null, null); pa(1) := new integer'(6); assert pa(1).all = 6; deallocate(pa(1)); deallocate(pa); wait; end process; end architecture; nvc-r1.17.1/test/regress/access8.vhd000066400000000000000000000007501504111170000172260ustar00rootroot00000000000000entity access8 is end entity; architecture test of access8 is type int_vector is array (natural range <>) of integer; type rec is record f : int_vector(1 to 1000); end record; type big_array is array (natural range <>) of rec; type p_big_array is access big_array; signal n : integer := 10000000; begin p1: process is variable p : p_big_array; begin p := new big_array(1 to n); wait; end process; end architecture; nvc-r1.17.1/test/regress/access9.vhd000066400000000000000000000013551504111170000172310ustar00rootroot00000000000000-- Test garbage collection entity access9 is end entity; architecture test of access9 is type int_vec is array (natural range <>) of integer; type int_vec_ptr is access int_vec; type rec is record s : string(1 to 50); i : integer; p : int_vec_ptr; end record; type rec_ptr is access rec; procedure do_test (p : inout rec_ptr) is begin p := new rec; p.p := new int_vec(1 to 1000); end procedure; begin p1: process is variable p : rec_ptr; begin for i in 1 to 1000 loop for j in 1 to 100 loop do_test(p); end loop; wait for 1 ns; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg1.vhd000066400000000000000000000006351504111170000165160ustar00rootroot00000000000000entity agg1 is end entity; architecture test of agg1 is type int_array is array (integer range <>) of integer; begin process is variable x : integer; variable v : int_array(1 to 3); begin x := 5; v := ( 1, x, 2 ); assert v = ( 1, 5, 2 ); v := ( v(3), v(2), v(1) ); assert v = ( 2, 5, 1 ); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg10.vhd000066400000000000000000000007061504111170000165750ustar00rootroot00000000000000entity agg10 is end entity; architecture test of agg10 is signal s : bit_vector(15 downto 0); signal t : bit_vector(11 downto 0); begin s <= (15 downto 12 => '0', 11 downto 0 => t); process is begin assert s = X"0000"; t <= X"fff"; wait for 1 ns; assert s = X"0fff"; t(0) <= '0'; wait for 1 ns; assert s = X"0ffe"; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg11.vhd000066400000000000000000000006361504111170000166000ustar00rootroot00000000000000entity agg11 is end entity; architecture test of agg11 is type mem_type is array (2 downto 0) of bit_vector(7 downto 0); begin test: process is variable m : mem_type := ( X"03", X"02", X"01" ); variable b : bit_vector(7 downto 0); begin b := X"ff"; m := (m(1 downto 0), b); assert m = ( X"02", X"01", X"ff" ); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg12.vhd000066400000000000000000000056031504111170000166000ustar00rootroot00000000000000entity agg12 is end entity; architecture test of agg12 is -- Examples from LRM 93 section 7.2.5 (converted from concatenations) type R1 is range 0 to 7; type R2 is range 7 downto 0; type T1 is array (R1 range <>) of Bit; type T2 is array (R2 range <>) of Bit; subtype S1 is T1(R1); subtype S2 is T2(R2); constant K1: S1 := (others => '0'); constant K2: T1 := (K1(1 to 3), K1(3 to 4)); -- K2'Left = 0 and K2'Right = 4 constant K3: T1 := (K1(5 to 7), K1(1 to 2)); -- K3'Left = 0 and K3'Right = 4 constant K4: T1 := (K1(2 to 1), K1(1 to 2)); -- K4'Left = 0 and K4'Right = 1 constant K5: S2 := (others => '0'); constant K6: T2 := (K5(3 downto 1), K5(4 downto 3)); -- K6'Left = 7 and K6'Right = 3 constant K7: T2 := (K5(7 downto 5), K5(2 downto 1)); -- K7'Left = 7 and K7'Right = 3 constant K8: T2 := (K5(1 downto 2), K5(2 downto 1)); -- K8'Left = 7 and K8'Right = 6 function get_left(x : T1) return R1 is begin return x'left; end function; function get_left(x : T2) return R2 is begin return x'left; end function; function get_right(x : T1) return R1 is begin return x'right; end function; function get_right(x : T2) return R2 is begin return x'right; end function; begin main: process is begin assert K2'left = 0 report R1'image(K2'left); assert get_left(K2) = 0 report R1'image(K2'left); assert K2'right = 4 report R1'image(K2'right); assert get_right(K2) = 4 report R1'image(K2'right); assert K2'ascending; assert K3'left = 0 report R1'image(K3'left); assert get_left(K3) = 0 report R1'image(K3'left); assert K3'right = 4 report R1'image(K3'right); assert get_right(K3) = 4 report R1'image(K3'right); assert K3'ascending; assert K4'left = 0 report R1'image(K4'left); assert get_left(K4) = 0 report R1'image(K4'left); assert K4'right = 1 report R1'image(K4'right); assert get_right(K4) = 1 report R1'image(K4'right); assert K4'ascending; assert K6'left = 7 report R2'image(K6'left); assert get_left(K6) = 7 report R2'image(K6'left); assert K6'right = 3 report R2'image(K6'right); assert get_right(K6) = 3 report R2'image(K6'right); assert not K6'ascending; assert K7'left = 7 report R2'image(K7'left); assert get_left(K7) = 7 report R2'image(K7'left); assert K7'right = 3 report R2'image(K7'right); assert get_right(K7) = 3 report R2'image(K7'right); assert not K6'ascending; assert K8'left = 7 report R2'image(K8'left); assert get_left(K8) = 7 report R2'image(K8'left); assert K8'right = 6 report R2'image(K8'right); assert get_right(K8) = 6 report R2'image(K8'right); assert not K6'ascending; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg13.vhd000066400000000000000000000006231504111170000165760ustar00rootroot00000000000000entity agg13 is end entity; architecture test of agg13 is impure function color_start return string is begin return ('[', integer'image(1), ';', integer'image(2), ';', integer'image(3), 'm'); end; begin process is begin report color_start; assert color_start = "[1;2;3m"; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg14.vhd000066400000000000000000000015361504111170000166030ustar00rootroot00000000000000entity agg14 is end entity; architecture test of agg14 is signal s, t : bit_vector(7 downto 0); begin b: block is port ( i : in bit_vector; o : out bit_vector ); port map ( s, t ); type sample_reg is array (1 to 3) of bit_vector(i'range); signal samples : sample_reg; begin samples <= (i, samples(1 to 2)); o <= samples(3); end block; check: process is begin s <= X"01"; wait for 0 ns; s <= X"02"; wait for 0 ns; s <= X"03"; assert t = X"00"; wait for 0 ns; assert t = X"00"; wait for 0 ns; assert t = X"00"; wait for 0 ns; assert t = X"01"; wait for 0 ns; assert t = X"02"; wait for 0 ns; assert t = X"03"; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg2.vhd000066400000000000000000000007751504111170000165240ustar00rootroot00000000000000entity agg2 is end entity; architecture test of agg2 is type int_array is array (integer range <>) of integer; function all_ones(x : int_array) return int_array is variable y : int_array(1 to x'length) := (others => 0); begin y := (others => 1); return y; end function; begin process is variable x : int_array(1 to 3) := (others => 5); begin assert all_ones(x) = (1, 1, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg3.vhd000066400000000000000000000010141504111170000165100ustar00rootroot00000000000000entity agg3 is end entity; architecture test of agg3 is type int_array is array (integer range <>) of integer; function get_array return int_array is begin return (4 => 4, 3 => 3, 5 => 5); end function; begin process is variable x : int_array(1 to 3) := (others => 5); variable y : integer; begin x := (6 => 7) & (6 => 2, 7 => 9); assert x = (7, 2, 9); x := get_array; assert x = (3, 4, 5); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg4.vhd000066400000000000000000000014751504111170000165240ustar00rootroot00000000000000entity agg4 is end entity; architecture test of agg4 is type int_array is array (integer range <>) of integer; procedure fill(a : out int_array; x : in integer) is alias aa : int_array(1 to a'length) is a; begin aa := (1 to a'length => x); end procedure; procedure fill2(a : out int_array; y : in integer) is begin assert a'length = 1; a := (a'left => y); end procedure; begin process is variable v : int_array(1 to 3); variable w : int_array(5 to 5); begin v := (1 to 3 => 7); assert v = (7, 7, 7); v := (1 => 6, 2 to 3 => 5); assert v = (6, 5, 5); fill(v, 8); assert v = (8, 8, 8); fill2(w, 6); assert w = (5 => 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg5.vhd000066400000000000000000000007711504111170000165230ustar00rootroot00000000000000entity agg5 is end entity; architecture test of agg5 is signal vec : bit_vector(4 downto 1); signal a, b : bit; begin vec <= ( 1 => a, 2 => b, others => '0' ); process is begin wait for 1 ns; assert vec = X"0"; a <= '1'; wait for 1 ns; assert vec = X"1"; b <= '1'; wait for 1 ns; assert vec = X"3"; a <= '0'; wait for 1 ns; assert vec = X"2"; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg6.vhd000066400000000000000000000010541504111170000165170ustar00rootroot00000000000000entity agg6 is end entity; architecture test of agg6 is type int_vec is array (natural range <>) of integer; type int_vec4x2 is array (1 to 4) of int_vec(1 to 2); begin process is variable a : int_vec4x2; variable b : int_vec(1 to 8); begin b := (1, 2, 3, 4, 5, 6, 7, 8); a := int_vec4x2'(b(1 to 2), b(3 to 4), b(5 to 6), b(7 to 8)); assert a(1) = (1, 2); assert a(2) = (3, 4); assert a(3) = (5, 6); assert a(4) = (7, 8); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg7.vhd000066400000000000000000000013151504111170000165200ustar00rootroot00000000000000entity agg7 is end entity; architecture test of agg7 is begin main: process is variable x : integer_vector(1 to 4); variable y, z : integer_vector(1 to 2); begin x := ( integer_vector'(1, 2), integer_vector'(3, 4) ); assert x = (1, 2, 3, 4); y := (5, 6); z := (7, 8); x := ( y, z ); assert x = (5, 6, 7, 8); x := ( 1 to 2 => z, 3 to 4 => integer_vector'(1, 2) ); assert x = (7, 8, 1, 2); x := ( 4 downto 1 => x ); assert x = (7, 8, 1, 2); x := ( y, 9, 8 ); assert x = (5, 6, 9, 8); x := (9, 8, (1, 2 )); assert x = (9, 8, 1, 2); wait; end process; end architecture; nvc-r1.17.1/test/regress/agg8.vhd000066400000000000000000000013371504111170000165250ustar00rootroot00000000000000entity agg8 is end entity; architecture test of agg8 is type rec is record x : integer; y : bit_vector; end record; type rec_array is array (natural range <>) of rec; signal s : rec(y(1 to 3)) := ( 1, "101" ); signal t : rec_array(1 to 2)(y(1 to 3)); begin p1: process is variable v : t'subtype; begin t <= (others => s); wait for 1 ns; assert t(2).x = 1; assert t(1).y = "101"; t(2) <= (2, "110"); wait for 1 ns; v := t; assert v(1).x = 1; assert v(2).y = "110"; v(1 to 2) := t(1 to 2); assert v(1).x = 1; assert v(2).y = "110"; wait; end process; end architecture; nvc-r1.17.1/test/regress/agg9.vhd000066400000000000000000000010421504111170000165170ustar00rootroot00000000000000entity agg9 is end entity; architecture test of agg9 is type rec is record x, y : natural; end record; type rec_array is array (natural range <>) of rec; signal s : rec_array(1 to 2); signal r1, r2 : rec; begin s <= (1 => r1, 2 => r2); process is begin assert s = ((0, 0), (0, 0)); r2 <= (2, 4); wait for 1 ns; assert s = ((0, 0), (2, 4)); r1.x <= 7; wait for 1 ns; assert s = ((7, 0), (2, 4)); wait; end process; end architecture; nvc-r1.17.1/test/regress/alias1.vhd000066400000000000000000000024001504111170000170410ustar00rootroot00000000000000entity alias1 is end entity; architecture test of alias1 is type int_array is array (integer range <>) of integer; begin process is variable x : int_array(7 downto 4) := (1, 2, 3, 4); alias y : int_array(1 to 4) is x; alias z : int_array(5 downto 2) is x; begin report "--- X1 ---"; for i in x'range loop report integer'image(x(i)); end loop; report "--- Y1 ---"; for i in y'range loop report integer'image(y(i)); end loop; report "--- Z1 ---"; for i in z'range loop report integer'image(z(i)); end loop; wait; end process; process is variable x : int_array(4 to 7) := (1, 2, 3, 4); alias y : int_array(4 downto 1) is x; alias z : int_array(2 to 5) is x; begin wait for 1 ns; report "--- X2 ---"; for i in x'range loop report integer'image(x(i)); end loop; report "--- Y2 ---"; for i in y'range loop report integer'image(y(i)); end loop; report "--- Z2 ---"; for i in z'range loop report integer'image(z(i)); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias10.vhd000066400000000000000000000017521504111170000171320ustar00rootroot00000000000000entity alias10 is end entity; package p is signal s : bit_vector(1 to 3); alias t : bit_vector(3 downto 1) is s; end package; use work.p.all; architecture test of alias10 is function XSLL (ARG : BIT_VECTOR; COUNT : NATURAL) return BIT_VECTOR is constant ARG_L : INTEGER := ARG'length-1; alias XARG : BIT_VECTOR(ARG_L downto 0) is ARG; variable RESULT : BIT_VECTOR(ARG_L downto 0) := (others => '0'); begin if COUNT <= ARG_L then RESULT(ARG_L downto COUNT) := XARG(ARG_L-COUNT downto 0); end if; return RESULT; end function XSLL; begin process is variable v : bit_vector(3 downto 0); begin v := "0101"; assert XSLL(v, 1) = "1010"; wait for 1 ns; v := "0011"; assert XSLL(v, 2) = "1100"; s <= "001"; wait for 1 ns; assert t = "001"; t <= "101"; wait for 1 ns; assert s = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias11.vhd000066400000000000000000000017471504111170000171370ustar00rootroot00000000000000entity sub is port ( p : in bit_vector(7 downto 0) ); end entity; architecture test of sub is alias a1 : bit_vector(3 downto 0) is p(7 downto 4); alias a2 : bit_vector(3 downto 0) is p(3 downto 0); begin process is begin wait for 2 ns; assert a1 = "1111"; assert a2 = "0000"; wait; end process; end architecture; ------------------------------------------------------------------------------- entity alias11 is end entity; architecture test of alias11 is signal s : bit_vector(7 downto 0); alias a1 : bit_vector(3 downto 0) is s(7 downto 4); alias a2 : bit_vector(3 downto 0) is s(3 downto 0); begin sub_i: entity work.sub port map (s); process is begin s <= "10100011"; wait for 1 ns; assert a1 = "1010"; assert a2 = "0011"; a1 <= "1111"; a2 <= "0000"; wait for 1 ns; assert s = "11110000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias12.vhd000066400000000000000000000013151504111170000171270ustar00rootroot00000000000000entity alias12 is end entity; architecture test of alias12 is function get (x : in bit_vector; n : in natural range 1 to 3) return bit is alias a : bit_vector(1 to 3) is x; begin return a(n); end function; begin main: process is variable v1 : bit_vector(1 to 3); variable v2 : bit_vector(4 to 6); variable v3 : bit_vector(2 to 3); begin v1 := "101"; v2 := "101"; v3 := "01"; wait for 1 ns; assert get(v1, 1) = '1'; assert get(v1, 3) = '1'; assert get(v2, 1) = '1'; assert get(v2, 2) = '0'; assert get(v3, 1) = '0'; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/alias13.vhd000066400000000000000000000010111504111170000171210ustar00rootroot00000000000000entity alias13 is end entity; architecture test of alias13 is type mat2d is array (natural range <>, natural range <>) of integer; signal s1 : mat2d(1 to 2, 1 to 2); alias a : mat2d is s1; -- OK (2008) begin main: process is begin s1 <= ((1, 2), (3, 4)); wait for 1 ns; assert a = ((1, 2), (3, 4)); assert a(1, 1) = 1; a(2, 2) <= 66; wait for 1 ns; assert s1 = ((1, 2), (3, 66)); wait; end process; end architecture; nvc-r1.17.1/test/regress/alias14.vhd000066400000000000000000000016141504111170000171330ustar00rootroot00000000000000entity alias14 is end entity; architecture test of alias14 is type point is record x, y : integer; end record; type point_vec is array (natural range <>) of point; type sig_type is record points : point_vec; end record; signal s1 : sig_type(points(1 to 4)); alias s1p1x is s1.points(1).x; type nest_type is record sub : sig_type; end record; signal s2 : nest_type(sub(points(1 to 2))); alias s2p is s2.sub.points; begin p1: process is begin s1.points <= ((1, 2), (3, 4), (5, 6), (7, 8)); wait for 1 ns; assert s1p1x = 1; s1p1x <= 5; wait for 1 ns; assert s1.points = ((5, 2), (3, 4), (5, 6), (7, 8)); s2p <= ((1, 2), (3, 4)); wait for 1 ns; assert s2p(1).x = 1; assert s2.sub.points(2).y = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias15.vhd000066400000000000000000000013671504111170000171410ustar00rootroot00000000000000entity alias15 is end entity; architecture test of alias15 is type t_test is protected procedure increment; impure function get return natural; end protected; type t_test is protected body variable count : natural; procedure increment is begin count := count + 1; end procedure; impure function get return natural is begin return count; end function; end protected body; shared variable pt : t_test; alias inc is pt.increment []; alias get is pt.get [return natural]; begin tb: process is begin inc; assert get = 1; inc; assert get = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias2.vhd000066400000000000000000000020611504111170000170450ustar00rootroot00000000000000entity alias2 is end entity; architecture test of alias2 is type int_array is array (integer range <>) of integer; function print(x : int_array) return integer is alias y : int_array(1 to x'length) is x; alias z : int_array(x'length downto 1) is x; begin report "--- X ---"; for i in x'range loop report integer'image(x(i)); end loop; report "--- Y ---"; for i in y'range loop report integer'image(y(i)); end loop; report "--- Z ---"; for i in z'range loop report integer'image(z(i)); end loop; return 0; end function; begin process is variable x : int_array(7 downto 4) := (1, 2, 3, 4); variable dummy : integer; begin dummy := print(x); wait; end process; process is variable x : int_array(4 to 7) := (1, 2, 3, 4); variable dummy : integer; begin wait for 1 ns; dummy := print(x); wait; end process; end architecture; nvc-r1.17.1/test/regress/alias3.vhd000066400000000000000000000013731504111170000170530ustar00rootroot00000000000000entity alias3 is end entity; architecture test of alias3 is type int_array is array (integer range <>) of integer; function cut(x : int_array; low, high: integer) return int_array is alias a : int_array(1 to x'length) is x; begin return a(low to high); end function; signal s : int_array(1 to 5) := (1, 2, 3, 4, 5); begin process is variable x : int_array(1 to 5) := (1, 2, 3, 4, 5); variable y : int_array(4 downto 0) := (4, 3, 2, 1, 0); alias sa : int_array(4 downto 0) is x; begin assert x(2 to 4) = (2, 3, 4); assert sa(3 downto 1) = (2, 3, 4); assert cut(x, 2, 3) = (2, 3); assert cut(y, 1, 2) = (4, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/alias4.vhd000066400000000000000000000006341504111170000170530ustar00rootroot00000000000000entity alias4 is end entity; architecture test of alias4 is function func(x : bit_vector(7 downto 0); k : bit_vector) return bit is alias y : bit_vector(k'range) is x; begin return y(1); end function; begin process is variable x : bit_vector(7 downto 0); begin x := X"ab"; assert func(x, x) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias5.vhd000066400000000000000000000023061504111170000170520ustar00rootroot00000000000000entity alias5 is end entity; architecture test of alias5 is subtype bit_vector4 is bit_vector(3 downto 0); type footype is ( tr01, tr10, tr0z, trz1, tr1z, trz0, tr0x, trx1, tr1x, trx0, trxz, trzx); type bartype01 is array (footype range tr01 to tr10) of time; type yahtype01 is array (natural range <>) of bartype01; procedure bufpath ( constant tpd : in yahtype01 ) is begin report "tpd'left=" & integer'image(tpd'left); report "tpd'right=" & integer'image(tpd'right); end; procedure vitalmux4 ( variable data : in bit_vector4; constant tpd_data_q : in yahtype01 ) is alias atpd_data_q : yahtype01(data'range) is tpd_data_q; begin bufpath ( atpd_data_q ); assert atpd_data_q(data'left)(tr01) = 1 ns; assert atpd_data_q(3 downto 3)(3)(tr01) = 1 ns; end; begin process is variable data : bit_vector4; variable yah : yahtype01(5 downto 2); begin data := X"1"; yah := (others => (others => 1 ns ) ); vitalmux4(data, yah); wait; end process; end architecture; nvc-r1.17.1/test/regress/alias6.vhd000066400000000000000000000017311504111170000170540ustar00rootroot00000000000000entity alias6 is end entity; architecture test of alias6 is signal x : bit_vector(7 downto 0); alias x_top is x(7); alias x_low is x(3 downto 0); alias x_high is x(7 downto 4); begin process is begin x <= X"80"; wait for 1 ns; assert x_top = '1'; assert x_low = X"0"; assert x_high = X"8"; x <= X"04"; wait for 1 ns; assert x_top = '0'; assert x_low = X"4"; assert x_high = X"0"; x_top <= '1'; wait for 1 ns; assert x_top = '1'; assert x_low = X"4"; assert x_high = X"8"; x_high <= X"f"; wait for 1 ns; assert x_top = '1'; assert x_low = X"4"; assert x_high = X"f"; x_low <= X"b"; x_high <= X"1"; wait for 1 ns; assert x_top = '0'; assert x_low = X"b"; assert x_high = X"1"; assert x = X"1b"; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias7.vhd000066400000000000000000000012111504111170000170460ustar00rootroot00000000000000entity alias7 is end entity; architecture test of alias7 is signal x : bit_vector(7 downto 0); alias top is x(7); signal ctr : integer := 0; begin process (top) is begin if top = '1' then ctr <= ctr + 1; end if; end process; process is begin assert ctr = 0; x <= X"3f"; wait for 1 ns; assert ctr = 0; x <= X"80"; wait for 1 ns; assert ctr = 1; x <= X"00"; wait for 1 ns; assert ctr = 1; x <= X"ff"; wait for 1 ns; assert ctr = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/alias8.vhd000066400000000000000000000005561504111170000170620ustar00rootroot00000000000000package p is constant cp : integer; end package p; package body p is constant c : integer := 1; alias ca : integer is c; constant cp : integer := ca; end package body p; use work.p.all; entity alias8 is begin assert (cp = 1) report "should not assert" severity failure; end entity; architecture test of alias8 is begin end architecture test; nvc-r1.17.1/test/regress/alias9.vhd000066400000000000000000000017461504111170000170650ustar00rootroot00000000000000entity alias9 is end entity; architecture test of alias9 is function to_i(x : bit) return integer is begin if x = '1' then return 1; else return 0; end if; end function; function to_i(x : character) return integer is begin if x = '1' then return 1; elsif x = '0' then return 0; else return -1; end if; end function; alias bit_to_i is to_i [bit return integer]; alias char_to_i is to_i [character return integer]; procedure test(x : in bit) is begin assert false; end procedure; procedure test(x : in character) is begin assert x = '1'; end procedure; begin process is alias test_ok is test [character]; begin assert bit_to_i('1') = 1; assert char_to_i('0') = 0; assert char_to_i('x') = -1; test_ok('1'); wait; end process; end architecture; nvc-r1.17.1/test/regress/arith1.vhd000066400000000000000000000020331504111170000170610ustar00rootroot00000000000000entity arith1 is end entity; architecture test of arith1 is begin proc1: process is variable x, y : integer; begin x := 3; y := 12; wait for 1 ns; assert x + y = 15; assert x - y = -9; assert x * y = 36; assert x / 12 = 0; assert x = 3; assert y = 12; assert x /= y; assert x < y; assert y > x; assert x <= y; assert y >= x; assert (- x) = -3; assert x ** y = 531441; x := -34; wait for 1 ns; assert abs x = 34; assert abs y = 12; y := 3; wait for 1 ns; assert 5 mod y = 2; assert 5 rem y = 2; assert (-5) rem y = -2; assert (-5) mod 3 = 1; assert (-5) mod y = 1; y := -8; wait for 1 ns; assert (-512) mod (-8) = 0; assert (-512) mod y = 0; assert (-510) mod (-8) = -6; assert (-510) mod y = -6; assert x = +x; wait; end process; end architecture; nvc-r1.17.1/test/regress/arith2.vhd000066400000000000000000000003731504111170000170670ustar00rootroot00000000000000entity arith2 is end entity; architecture test of arith2 is begin process is variable x, y : integer; begin x := 5; y := 0; wait for 1 ns; x := x / y; wait; end process; end architecture; nvc-r1.17.1/test/regress/arith3.vhd000066400000000000000000000004601504111170000170650ustar00rootroot00000000000000entity arith3 is end entity; architecture test of arith3 is begin process is variable t : time; variable i : integer; begin t := 120 ns; i := sec / t; report integer'image(i); assert i = 8333333; wait; end process; end architecture; nvc-r1.17.1/test/regress/arith4.vhd000066400000000000000000000006721504111170000170730ustar00rootroot00000000000000entity arith4 is end entity; architecture test of arith4 is type my_uint16 is range 0 to (2 ** 16) - 1; begin p1: process is variable x, y : my_uint16 := 0; begin assert x ** 5 = 0; x := 2; wait for 1 ns; assert x ** 9 = 512; -- OK assert x ** 15 = 32768; -- OK y := x ** 16; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/arith5.vhd000066400000000000000000000005371504111170000170740ustar00rootroot00000000000000entity arith5 is end entity; architecture test of arith5 is begin p1: process is variable x, y : integer; begin x := 5; y := 2; wait for 1 ns; assert x mod y = 1; y := 0; wait for 1 ns; assert x mod y = 0; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/array1.vhd000066400000000000000000000013131504111170000170700ustar00rootroot00000000000000entity array1 is end entity; architecture test of array1 is type matrix_t is array (integer range <>, integer range <>) of integer; constant c : matrix_t(0 to 1, 0 to 1) := ( ( 1, 2 ), ( 3, 4 ) ); begin process is variable m : matrix_t(1 to 3, 1 to 3) := ( ( 1, 2, 3 ), ( 4, 5, 6 ), ( 7, 8, 9 ) ); begin report integer'image(m(1, 3)); report integer'image(m(2, 2)); assert m(2, 2) = 5; assert m(3, 1) = 7; report integer'image(c(1, 0)); assert c(1, 0) = 3; assert c = ( (1, 2), (3, 4) ); assert c /= ( (1, 2), (3, 5) ); wait; end process; end architecture; nvc-r1.17.1/test/regress/array10.vhd000066400000000000000000000015271504111170000171570ustar00rootroot00000000000000entity array10 is end entity; architecture test of array10 is type int_vec is array (natural range <>) of integer; type int_vec_ptr is access int_vec; procedure do_stuff (variable p : inout int_vec_ptr; variable r : inout integer) is constant orig : int_vec(1 to p'length) := p.all; constant len : integer := p'length; begin deallocate(p); p := new int_vec'(1, 2, 3); -- Changes p'length r := 0; for i in 1 to len loop r := r + orig(i); end loop; end procedure; begin p1: process is variable p : int_vec_ptr; variable r : integer; begin p := new int_vec'(1, 2, 3, 4, 5); do_stuff(p, r); assert r = 15; assert p.all = (1, 2, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/array11.vhd000066400000000000000000000014651504111170000171610ustar00rootroot00000000000000entity array11 is end entity; architecture test of array11 is type rec is record x : integer_vector; end record; type rec_vec is array (natural range <>) of rec; function sum_all (r : rec_vec) return integer is variable result : integer := 0; begin for i in r'range loop for j in r(i).x'range loop result := result + r(i).x(j); end loop; end loop; return result; end function; signal s : rec_vec(1 to 2)(x(1 to 3)); begin p1: process is begin s <= ( ( x => (1, 2, 3) ), ( x => (4, 5, 6) ) ); wait for 1 ns; assert sum_all(s) = 21; s(1).x(1) <= 5; wait for 1 ns; assert sum_all(s) = 25; wait; end process; end architecture; nvc-r1.17.1/test/regress/array12.vhd000066400000000000000000000017441504111170000171620ustar00rootroot00000000000000entity array12 is end entity; architecture test of array12 is type rec is record x : integer_vector; end record; type rec_vec is array (natural range <>) of rec; type rec_vec_vec is array (natural range <>) of rec_vec; function sum_all (r : rec_vec_vec) return integer is variable result : integer := 0; begin for i in r'range loop for j in r(i)'range loop for k in r(i)(j).x'range loop result := result + r(i)(j).x(k); end loop; end loop; end loop; return result; end function; signal s : rec_vec_vec(1 to 2)(1 to 1)(x(1 to 3)); begin p1: process is begin s <= ( ( 1 => ( x => (1, 2, 3) ) ), ( 1 => ( x => (4, 5, 6) ) ) ); wait for 1 ns; assert sum_all(s) = 21; s(1)(1).x(1) <= 5; wait for 1 ns; assert sum_all(s) = 25; wait; end process; end architecture; nvc-r1.17.1/test/regress/array13.vhd000066400000000000000000000030311504111170000171520ustar00rootroot00000000000000package pack is constant LENGTH : natural; constant C_MAX_VVC_INSTANCE_NUM : natural; end package; package body pack is constant LENGTH : natural := 8; constant C_MAX_VVC_INSTANCE_NUM : natural := 8; end package body; ------------------------------------------------------------------------------- entity array13 is end entity; use work.pack.all; architecture a of array13 is -- Reduced from crash in UVVM type t_channel is ( NA, ALL_CHANNELS, RX, TX ); subtype t_sub_channel is t_channel range RX to TX; type t_base_transaction is record x : integer; y : bit_vector(1 to LENGTH); end record; constant C_BASE_TRANSACTION_SET_DEFAULT : t_base_transaction := ( x => 1, y => (others => '0') ); type t_transaction_group is record bt : t_base_transaction; end record; constant C_TRANSACTION_GROUP_DEFAULT : t_transaction_group := ( bt => C_BASE_TRANSACTION_SET_DEFAULT ); type t_uart_transaction_group_array is array (t_sub_channel range <>, natural range <>) of t_transaction_group; shared variable sv : t_uart_transaction_group_array(t_sub_channel'left to t_sub_channel'right, 0 to C_MAX_VVC_INSTANCE_NUM-1) := (others => (others => C_TRANSACTION_GROUP_DEFAULT)); begin check: process is begin assert sv(RX, 1).bt.x = 1; sv(RX, 1).bt.y := X"ab"; wait for 1 ns; assert sv(RX, 1).bt.x = 1; assert sv(RX, 1).bt.y = X"ab"; wait; end process; end architecture; nvc-r1.17.1/test/regress/array14.vhd000066400000000000000000000034221504111170000171570ustar00rootroot00000000000000entity array14 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use std.textio.all; architecture test of array14 is -- Reduced from UVVM string_methods_pkg.vhd function pos_of_leftmost_non_zero( vector : string; result_if_not_found : natural := 1 ) return natural is alias a_vector : string(1 to vector'length) is vector; begin for i in a_vector'left to a_vector'right loop if (a_vector(i) /= '0' and a_vector(i) /= ' ') then return i; end if; end loop; return result_if_not_found; end; function adjust_leading_0( val : string ) return string is alias a_val : string(1 to val'length) is val; constant leftmost_non_zero : natural := pos_of_leftmost_non_zero(a_val, 1); begin if val'length <= 1 then return val; end if; return a_val(leftmost_non_zero to val'length); end function; function to_string( val : std_logic_vector) return string is variable v_line : line; alias a_val : std_logic_vector(val'length - 1 downto 0) is val; variable v_result : string(1 to 10 + 2 * val'length); -- variable v_width : natural; variable v_use_end_char : boolean := false; begin if val'length = 0 then -- Value length is zero, -- return empty string. return ""; end if; write(v_line, adjust_leading_0(to_string(to_integer(unsigned(val))))); v_width := v_line'length; v_result(1 to v_width) := v_line.all; deallocate(v_line); return v_result(1 to v_width); end; begin p1: process is variable v : std_logic_vector(1 to 8) := X"42"; begin assert to_string(v) = "66"; wait; end process; end architecture; nvc-r1.17.1/test/regress/array15.vhd000066400000000000000000000013421504111170000171570ustar00rootroot00000000000000entity array15 is end entity; architecture test of array15 is function get_bits (n : natural) return bit_vector is begin return (1 to n => '0'); end function; type bvv is array (natural range <>) of bit_vector; procedure do_test (a, b : in natural) is constant k : bvv := ( 1 => get_bits(a), 2 => get_bits(b) ); begin report to_string(k(1)'length); report to_string(k(2)'length); assert a = b report "should have failed" severity failure; end procedure; begin p1: process is begin do_test(2, 2); -- OK do_test(3, 5); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/array16.vhd000066400000000000000000000017651504111170000171710ustar00rootroot00000000000000entity array16 is end entity; architecture test of array16 is subtype MemoryBaseType is integer_vector; function InitMemoryBaseType(Size : integer) return integer_vector is constant BaseU : integer_vector(0 to Size-1) := (others => -1) ; begin return BaseU ; end function InitMemoryBaseType ; type MemBlockType is array (integer range <>) of MemoryBaseType ; function InitMemoryBlockType(BlockWidth, BaseWidth : integer) return MemBlockType is constant BaseU : MemoryBaseType(BaseWidth-1 downto 0) := InitMemoryBaseType(BaseWidth) ; begin return MemBlockType'(0 to 2**BlockWidth-1 => BaseU) ; end function InitMemoryBlockType ; signal s : MemBlockType(1 to 16)(1 to 3) := InitMemoryBlockType(4, 3); begin p1: process is begin for i in s'range loop for j in s'element'range loop assert s(i)(j) = -1; end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/array17.vhd000066400000000000000000000042441504111170000171650ustar00rootroot00000000000000entity array17 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of array17 is type t_slv_array is array (natural range <>) of std_logic_vector; subtype t_byte_array is t_slv_array(open)(7 downto 0); type t_byte_endianness is (LOWER_BYTE_LEFT, LOWER_BYTE_RIGHT, LOWER_WORD_LEFT, LOWER_WORD_RIGHT, FIRST_BYTE_LEFT, FIRST_BYTE_RIGHT); -- From UVVM methods_pkg.vhd function convert_slv_to_byte_array( constant slv : std_logic_vector; constant byte_endianness : t_byte_endianness ) return t_byte_array is variable v_num_bytes : integer := slv'length / 8 + 1; -- +1 in case there's a division remainder alias normalized_slv : std_logic_vector(slv'length-1 downto 0) is slv; variable v_byte_array : t_byte_array(0 to v_num_bytes - 1); variable v_slv_idx : integer := normalized_slv'high; variable v_slv_idx_min : integer; begin -- Adjust value if there was no remainder if (slv'length rem 8) = 0 then v_num_bytes := v_num_bytes - 1; end if; for byte_idx in 0 to v_num_bytes - 1 loop for bit_idx in 7 downto 0 loop if v_slv_idx = -1 then v_byte_array(byte_idx)(bit_idx) := 'Z'; -- Pads 'Z' else if (byte_endianness = LOWER_BYTE_LEFT) or (byte_endianness = FIRST_BYTE_LEFT) then v_byte_array(byte_idx)(bit_idx) := normalized_slv(v_slv_idx); else -- LOWER_BYTE_RIGHT or FIRST_BYTE_RIGHT v_slv_idx_min := MINIMUM(8 * byte_idx + bit_idx, normalized_slv'high); -- avoid indexing outside the slv v_byte_array(byte_idx)(bit_idx) := normalized_slv(v_slv_idx_min); end if; v_slv_idx := v_slv_idx - 1; end if; end loop; end loop; return v_byte_array(0 to v_num_bytes - 1); end function; begin p1: process is variable v : std_logic_vector(31 downto 0) := X"12345678"; begin assert convert_slv_to_byte_array(v, LOWER_BYTE_LEFT) = (X"12", X"34", X"56", X"78"); assert convert_slv_to_byte_array(v, LOWER_BYTE_RIGHT) = (X"78", X"56", X"34", X"12"); wait; end process; end architecture; nvc-r1.17.1/test/regress/array18.vhd000066400000000000000000000031701504111170000171630ustar00rootroot00000000000000package pack1 is constant k : natural; end package; package body pack1 is constant k : natural := 4; end package body; ------------------------------------------------------------------------------- package counter is type p is protected procedure inc; impure function get return natural; end protected; end package; package body counter is type p is protected body variable v : natural; procedure inc is begin v := v + 1; end procedure; impure function get return natural is begin return v; end function; end protected body; end package body; ------------------------------------------------------------------------------- use work.pack1.all; use work.counter.all; package pack2 is shared variable c : p; impure function f (x : integer) return integer; end package; package body pack2 is impure function f (x : integer) return integer is begin report "F called!"; c.inc; return x - 1; end function; end package body; ------------------------------------------------------------------------------- entity array18 is end entity; use work.pack1.all; use work.pack2.all; architecture test of array18 is type t is array (1 to k + 1) of bit_vector(f(k) downto 0); signal s : t; begin p1: process is variable v : integer := 5; variable v2 : t; constant c2 : t := (others => (others => '0')); begin v2(v)(1) := '1'; wait for 1 ns; s(v)(2) <= '1'; assert c.get = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/array19.vhd000066400000000000000000000013741504111170000171700ustar00rootroot00000000000000entity array19 is generic ( N : integer := 2 ); end entity; architecture test of array19 is subtype t_two is integer range 1 to N; type t_enum is (a, b); type t_table is array (t_two, t_two, t_enum) of boolean; constant table : t_table := ( 1 => ( 1 => (others => true), 2 => (others => false) ), 2 => ( 1 => (others => false), 2 => (others => true ) ) ); begin check: process is variable v : bit_vector(31 downto 0); variable i : integer := 3; begin assert table(2, 1, a) = false; assert table(1, 1, b) = true; v(i*8+7 downto i*8) := (i*8+7 downto i*8 => '1'); assert v = X"FF000000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/array2.vhd000066400000000000000000000007711504111170000171000ustar00rootroot00000000000000entity array2 is end entity; architecture test of array2 is type int_array is array (integer range <>) of integer; type int_array_Nx4 is array (integer range <>) of int_array(1 to 4); begin process is variable a : int_array_Nx4(1 to 4); variable b : int_array(1 to 4); begin a(1)(2) := 2; assert a(1)(2) = 2; a := ( others => ( 1, 2, 3, 4 ) ); b := a(1); assert b = ( 1, 2, 3, 4); wait; end process; end architecture; nvc-r1.17.1/test/regress/array3.vhd000066400000000000000000000010221504111170000170670ustar00rootroot00000000000000entity array3 is end entity; architecture test of array3 is type matrix2x4 is array (1 to 2, 1 to 4) of integer; signal m : matrix2x4; begin process is begin assert m(2, 2) = integer'left; m(2, 2) <= 5; wait for 1 ns; assert m(2, 2) = 5; m(2, 3) <= m(2, 2); wait for 1 ns; assert m(2, 3) = 5; m <= ( (1, 2, 3, 4), (5, 6, 7, 8) ); wait for 1 ns; assert m(2, 4) = 8; wait; end process; end architecture; nvc-r1.17.1/test/regress/array4.vhd000066400000000000000000000005371504111170000171020ustar00rootroot00000000000000entity array4 is end entity; architecture test of array4 is type ma_t is array (1 downto 0, 7 downto 0) of bit_vector(7 downto 0); signal ma : ma_t; begin process is begin ma <= (others => (others => (others => '0'))); wait for 1 ns; assert ma(1, 2) = X"00"; wait; end process; end architecture; nvc-r1.17.1/test/regress/array5.vhd000066400000000000000000000010411504111170000170720ustar00rootroot00000000000000entity array5 is end entity; architecture test of array5 is type int_vec is array (integer range <>) of integer; procedure negative_range (x : out int_vec; y : in int_vec) is begin x(0 downto -x'length + 1) := y; end procedure; begin main: process is variable a : int_vec(0 downto -3); variable b : int_vec(0 to 3); begin b := (1, 2, 3, 4); negative_range(a, b); assert a = (1, 2, 3, 4); wait; end process; end architecture; nvc-r1.17.1/test/regress/array6.vhd000066400000000000000000000012321504111170000170750ustar00rootroot00000000000000entity array6 is end entity; architecture test of array6 is type int_vec2 is array (natural range <>) of integer_vector; constant a : int_vec2(1 to 3)(1 to 2) := ( (1, 2), (3, 4), (5, 6) ); begin main: process is variable v : a'subtype := a; begin assert a(1)(1) = 1; assert a(3)(2) = 6; wait for 1 ns; assert v(1)(1) = 1; assert v(3)(2) = 6; assert v = a; v(1)(2) := 99; assert v /= a; assert v(1) = (1, 99); v(2) := (55, 666); assert v(2)(2) = 666; assert v(2 to 3) = ((55, 666), (5, 6)); wait; end process; end architecture; nvc-r1.17.1/test/regress/array7.vhd000066400000000000000000000010161504111170000170760ustar00rootroot00000000000000entity array7 is end entity; architecture test of array7 is type t_bv_array is array (natural range <>) of bit_vector; subtype t_byte_array is t_bv_array(open)(7 downto 0); signal s : t_byte_array(1 to 3); begin p1: process is begin assert s(1) = X"00"; s(2) <= X"ab"; wait for 1 ns; assert s = (X"00", X"ab", X"00"); s(1 to 2) <= (X"01", X"02"); wait for 1 ns; assert s = (X"01", X"02", X"00"); wait; end process; end architecture; nvc-r1.17.1/test/regress/array8.vhd000066400000000000000000000042021504111170000170770ustar00rootroot00000000000000-- Test case from Brian Padalino -- package p1 is type t_byte_endianness is (LOWER_BYTE_LEFT, FIRST_BYTE_LEFT, LOWER_BYTE_RIGHT, FIRST_BYTE_RIGHT) ; type t_slv_array is array(natural range <>) of bit_vector ; subtype t_byte_array is t_slv_array(open)(7 downto 0) ; function convert_byte_array_to_slv( constant byte_array : t_byte_array ; constant byte_endianness : t_byte_endianness ) return bit_vector ; end package ; package body p1 is -- example taken directly from uvvm: -- https://github.com/UVVM/UVVM/blob/92cb1495afa007f74ed79fb9935282196420add0/uvvm_util/src/methods_pkg.vhd#L6801 function convert_byte_array_to_slv( constant byte_array : t_byte_array; constant byte_endianness : t_byte_endianness ) return bit_vector is constant c_num_bytes : integer := byte_array'length; alias normalized_byte_array : t_byte_array(0 to c_num_bytes-1) is byte_array; variable v_slv : bit_vector(8*c_num_bytes-1 downto 0); begin assert byte_array'ascending report "byte_array must be ascending" severity error; for byte_idx in 0 to c_num_bytes-1 loop if (byte_endianness = LOWER_BYTE_LEFT) or (byte_endianness = FIRST_BYTE_LEFT) then v_slv(8*(c_num_bytes-byte_idx)-1 downto 8*(c_num_bytes-1-byte_idx)) := normalized_byte_array(byte_idx); else -- LOWER_BYTE_RIGHT or FIRST_BYTE_RIGHT v_slv(8*(byte_idx+1)-1 downto 8*byte_idx) := normalized_byte_array(byte_idx); end if; end loop; return v_slv; end function; end package body ; entity array8 is end entity ; use work.p1.all; architecture arch of array8 is signal s : t_byte_array(0 to 2) := ( X"44", X"55", X"66" ); begin process begin assert convert_byte_array_to_slv((X"01", X"02", X"03"), LOWER_BYTE_LEFT) = X"010203"; assert convert_byte_array_to_slv((X"01", X"02", X"03"), LOWER_BYTE_RIGHT) = X"030201"; assert convert_byte_array_to_slv(s, LOWER_BYTE_LEFT) = X"445566"; assert convert_byte_array_to_slv(s, LOWER_BYTE_RIGHT) = X"665544"; std.env.stop ; end process; end architecture ; nvc-r1.17.1/test/regress/array9.vhd000066400000000000000000000056431504111170000171120ustar00rootroot00000000000000-- From UVVM uvvm_util/src/methods_pkg.vhd -- License: Apache 2.0 -- package p1 is type t_byte_endianness is (LOWER_BYTE_LEFT, FIRST_BYTE_LEFT, LOWER_BYTE_RIGHT, FIRST_BYTE_RIGHT) ; type t_slv_array is array(natural range <>) of bit_vector ; subtype t_byte_array is t_slv_array(open)(7 downto 0) ; function convert_byte_array_to_slv_array( constant byte_array : t_byte_array; constant bytes_in_word : natural; constant byte_endianness : t_byte_endianness := LOWER_BYTE_LEFT ) return t_slv_array; end package ; package body p1 is -- Converts a t_byte_array (any direction) to a t_slv_array (same direction) function convert_byte_array_to_slv_array( constant byte_array : t_byte_array; constant bytes_in_word : natural; constant byte_endianness : t_byte_endianness := LOWER_BYTE_LEFT ) return t_slv_array is constant c_num_words : integer := byte_array'length/bytes_in_word; variable v_ascending_array : t_slv_array(0 to c_num_words-1)((8*bytes_in_word)-1 downto 0); variable v_descending_array : t_slv_array(c_num_words-1 downto 0)((8*bytes_in_word)-1 downto 0); variable v_byte_idx : integer := 0; begin for slv_idx in 0 to c_num_words-1 loop if (byte_endianness = LOWER_BYTE_LEFT) or (byte_endianness = FIRST_BYTE_LEFT) then for byte_in_word in bytes_in_word downto 1 loop v_ascending_array(slv_idx)((8*byte_in_word)-1 downto (byte_in_word-1)*8) := byte_array(v_byte_idx); v_descending_array(slv_idx)((8*byte_in_word)-1 downto (byte_in_word-1)*8) := byte_array(v_byte_idx); v_byte_idx := v_byte_idx + 1; end loop; else -- LOWER_BYTE_RIGHT or FIRST_BYTE_RIGHT for byte_in_word in 1 to bytes_in_word loop v_ascending_array(slv_idx)((8*byte_in_word)-1 downto (byte_in_word-1)*8) := byte_array(v_byte_idx); v_descending_array(slv_idx)((8*byte_in_word)-1 downto (byte_in_word-1)*8) := byte_array(v_byte_idx); v_byte_idx := v_byte_idx + 1; end loop; end if; end loop; if byte_array'ascending then return v_ascending_array; else -- byte array is descending return v_descending_array; end if; end function; end package body ; entity array9 is end entity ; use work.p1.all; architecture arch of array9 is signal s : t_byte_array(0 to 3) := ( X"44", X"55", X"66", X"77" ); begin process begin report to_string(convert_byte_array_to_slv_array(s, 1)(0)); assert convert_byte_array_to_slv_array(s, 1) = s; assert convert_byte_array_to_slv_array(s, 2) = (X"4455", X"6677"); assert convert_byte_array_to_slv_array(s, 4) = (0 => X"44556677"); std.env.stop ; end process; end architecture ; nvc-r1.17.1/test/regress/assert1.vhd000066400000000000000000000005031504111170000172530ustar00rootroot00000000000000entity assert1 is end entity; architecture a of assert1 is begin process is begin assert true report "failed"; report "hello world"; assert false report "not important" severity note; assert false severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/assert10.vhd000066400000000000000000000021401504111170000173320ustar00rootroot00000000000000entity assert10 is end entity; use std.env.all; architecture test of assert10 is begin process is variable valid : boolean; begin SetVhdlAssertFormat(error, "{t} foo {s} bar {r:#<10} {r:#>10} {r:#^10}", valid); assert valid; assert false report "message"; assert false report "long message"; -- This doesn't exactly match assert GetVhdlAssertFormat(error) = "{t: >} foo {s: <} bar {r:#<10} {r:#>10} {r:#^10}"; assert GetVhdlAssertFormat(note) = ""; SetVhdlAssertFormat(error, "foo {Q} bar", valid); assert not valid; wait for 5 ps; SetVhdlAssertFormat(error, "** {S}: {r: <10} at {t:.ns} : {i}", valid); assert valid; assert false report "message"; assert false report "message" severity warning; SetVhdlAssertFormat(error, "{t:.foobar}", valid); assert not valid; report "report" severity error; SetVhdlAssertFormat(warning, "{s:.sec}"); -- Aborts report "should not reach here" severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/assert11.vhd000066400000000000000000000010111504111170000173270ustar00rootroot00000000000000entity assert11 is end entity; use std.env.all; use std.textio.all; architecture test of assert11 is begin process is variable l : line; variable i : integer; begin assert GetVhdlReadSeverity = error; SetVhdlReadSeverity(warning); l := new string'("hello"); assert GetVhdlReadSeverity = warning; assert GetVhdlAssertCount(warning) = 0; read(l, i); assert GetVhdlAssertCount(warning) = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/assert12.vhd000066400000000000000000000006731504111170000173450ustar00rootroot00000000000000entity assert12 is end entity; architecture test of assert12 is impure function bang (n : integer) return severity_level is begin if 10 / n > 2 then return error; else return warning; end if; end function; signal s : bit := '1'; begin process is begin wait for 1 ns; assert s = '1' severity bang(0); wait; end process; end architecture; nvc-r1.17.1/test/regress/assert13.vhd000066400000000000000000000014441504111170000173430ustar00rootroot00000000000000package pack is function func (x : integer) return integer; end package; package body pack is function func (x : integer) return integer is begin assert x > 0 severity failure; return x + 1; end function; end package body; ------------------------------------------------------------------------------- entity assert13 is generic ( g : integer := -1 ); end entity; use work.pack.all; architecture test of assert13 is signal s : bit; signal t : integer; begin process (s) is begin if s = '1' then t <= func(g); -- This is globally static and triggers -- an assertion failure if evaluated else t <= 0; end if; end process; end architecture; nvc-r1.17.1/test/regress/assert2.vhd000066400000000000000000000004561504111170000172630ustar00rootroot00000000000000entity assert2 is end entity; architecture test of assert2 is signal x : integer; begin process is begin x <= 5; wait for 1 ns; x <= 12; wait for 1 ns; wait; end process; assert x < 10 report "x >= 10" severity warning; end architecture; nvc-r1.17.1/test/regress/assert3.vhd000066400000000000000000000002611504111170000172560ustar00rootroot00000000000000entity assert3 is begin l : assert (false) report "should assert" severity note; end entity assert3; architecture a of assert3 is begin end architecture a; nvc-r1.17.1/test/regress/assert4.vhd000066400000000000000000000004121504111170000172550ustar00rootroot00000000000000entity assert4 is end entity; architecture test of assert4 is begin process is variable n : integer; begin n := 0; wait for 1 ns; assert n = 0 report integer'image(100 / n); wait; end process; end architecture; nvc-r1.17.1/test/regress/assert5.vhd000066400000000000000000000005161504111170000172630ustar00rootroot00000000000000entity assert5 is end entity; architecture test of assert5 is signal x : integer; begin postponed assert x < 10; process is begin x <= 5; wait for 1 ns; x <= 11; wait for 0 ns; x <= 20; wait for 0 ns; x <= 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/assert6.vhd000066400000000000000000000015401504111170000172620ustar00rootroot00000000000000entity assert6 is end entity; architecture test of assert6 is signal x : integer; signal y : real; begin main: process is type int_ptr is access integer; variable p : int_ptr; begin x <= 0; y <= 3.142; p := new integer'(5); wait for 1 ns; assert x = 5 severity warning; assert x < -1 severity warning; assert character'val(x) /= NUL severity warning; x <= 512; wait for 1 ns; assert x > 1000 severity warning; assert x <= 2 severity warning; assert x >= 2000 severity warning; assert y = 4.56 severity warning; -- This can't print a hint because "and" short-circuits assert (x < 0) and (x / 0 < 0) severity warning; assert p = null severity warning; wait; end process; end architecture; nvc-r1.17.1/test/regress/assert7.vhd000066400000000000000000000005401504111170000172620ustar00rootroot00000000000000entity assert7 is end entity; use std.env.all; architecture test of assert7 is begin p1: process is begin for i in 1 to 30 loop assert false report "this is error " & integer'image(i); end loop; finish; -- Should preserve exit status wait; end process; end architecture; nvc-r1.17.1/test/regress/assert8.vhd000066400000000000000000000121711504111170000172660ustar00rootroot00000000000000entity assert8 is end entity; use std.env.all; architecture test of assert8 is begin process is begin assert (IsVhdlAssertFailed = false); assert (IsVhdlAssertFailed(note) = false); assert (IsVhdlAssertFailed(warning) = false); assert (IsVhdlAssertFailed(error) = false); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 0); assert (GetVhdlAssertCount(note) = 0); assert (GetVhdlAssertCount(warning) = 0); assert (GetVhdlAssertCount(error) = 0); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "First note" severity note; assert (IsVhdlAssertFailed = false); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = false); assert (IsVhdlAssertFailed(error) = false); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 0); assert (GetVhdlAssertCount(note) = 1); assert (GetVhdlAssertCount(warning) = 0); assert (GetVhdlAssertCount(error) = 0); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "First warning" severity warning; assert (IsVhdlAssertFailed = true); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = true); assert (IsVhdlAssertFailed(error) = false); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 1); assert (GetVhdlAssertCount(note) = 1); assert (GetVhdlAssertCount(warning) = 1); assert (GetVhdlAssertCount(error) = 0); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "First error" severity error; assert (IsVhdlAssertFailed = true); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = true); assert (IsVhdlAssertFailed(error) = true); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 2); assert (GetVhdlAssertCount(note) = 1); assert (GetVhdlAssertCount(warning) = 1); assert (GetVhdlAssertCount(error) = 1); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "Second note" severity note; assert (IsVhdlAssertFailed = true); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = true); assert (IsVhdlAssertFailed(error) = true); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 2); assert (GetVhdlAssertCount(note) = 2); assert (GetVhdlAssertCount(warning) = 1); assert (GetVhdlAssertCount(error) = 1); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "Second warning" severity warning; assert (IsVhdlAssertFailed = true); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = true); assert (IsVhdlAssertFailed(error) = true); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 3); assert (GetVhdlAssertCount(note) = 2); assert (GetVhdlAssertCount(warning) = 2); assert (GetVhdlAssertCount(error) = 1); assert (GetVhdlAssertCount(failure) = 0); assert (False) report "Second error" severity error; assert (IsVhdlAssertFailed = true); assert (IsVhdlAssertFailed(note) = true); assert (IsVhdlAssertFailed(warning) = true); assert (IsVhdlAssertFailed(error) = true); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 4); assert (GetVhdlAssertCount(note) = 2); assert (GetVhdlAssertCount(warning) = 2); assert (GetVhdlAssertCount(error) = 2); assert (GetVhdlAssertCount(failure) = 0); report "Clearing VHDL asserts"; ClearVhdlAssert; assert (IsVhdlAssertFailed = false); assert (IsVhdlAssertFailed(note) = false); assert (IsVhdlAssertFailed(warning) = false); assert (IsVhdlAssertFailed(error) = false); assert (IsVhdlAssertFailed(failure) = false); assert (GetVhdlAssertCount = 0); assert (GetVhdlAssertCount(note) = 0); assert (GetVhdlAssertCount(warning) = 0); assert (GetVhdlAssertCount(error) = 0); assert (GetVhdlAssertCount(failure) = 0); report "Note report" severity note; report "Warning report" severity warning; report "Error report" severity error; assert (GetVhdlAssertCount = 2); assert (GetVhdlAssertCount(note) = 1); assert (GetVhdlAssertCount(warning) = 1); assert (GetVhdlAssertCount(error) = 1); assert (GetVhdlAssertCount(failure) = 0); -- TODO: How to test failure severity when it always stops simulation? finish; end process; end architecture; nvc-r1.17.1/test/regress/assert9.vhd000066400000000000000000000062021504111170000172650ustar00rootroot00000000000000entity assert9 is end entity; use std.env.all; architecture test of assert9 is begin process is begin assert (GetVhdlAssertEnable(note)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(warning)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(error)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(failure)) report "FAIL" severity error; wait for 1 ns; -- Try disabling step by step SetVhdlAssertEnable(note, false); assert (not GetVhdlAssertEnable(note)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(warning)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(error)) report "FAIL" severity failure; wait for 1 ns; SetVhdlAssertEnable(warning, false); assert (not GetVhdlAssertEnable(note)) report "FAIL" severity failure; assert (not GetVhdlAssertEnable(warning)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(error)) report "FAIL" severity failure; wait for 1 ns; SetVhdlAssertEnable(error, false); assert (not GetVhdlAssertEnable(note)) report "FAIL" severity failure; assert (not GetVhdlAssertEnable(warning)) report "FAIL" severity failure; assert (not GetVhdlAssertEnable(error)) report "FAIL" severity failure; wait for 1 ns; -- Try Re-enabling everything SetVhdlAssertEnable(true); assert (GetVhdlAssertEnable(note)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(warning)) report "FAIL" severity failure; assert (GetVhdlAssertEnable(error)) report "FAIL" severity failure; wait for 1 ns; -- Check all reports but failure are thrown SetVhdlAssertEnable(failure, false); report "EXAMPLE NOTE" severity note; report "EXAMPLE WARNING" severity warning; report "EXAMPLE ERROR" severity error; report "EXAMPLE FAILURE" severity failure; wait for 1 ns; -- Disable one-by-one and make sure it is the only one not shown SetVhdlAssertEnable(note, false); report "EXAMPLE NOTE" severity note; report "EXAMPLE WARNING" severity warning; report "EXAMPLE ERROR" severity error; report "EXAMPLE FAILURE" severity failure; wait for 1 ns; SetVhdlAssertEnable(warning, false); report "EXAMPLE NOTE" severity note; report "EXAMPLE WARNING" severity warning; report "EXAMPLE ERROR" severity error; report "EXAMPLE FAILURE" severity failure; wait for 1 ns; SetVhdlAssertEnable(error, false); report "EXAMPLE NOTE" severity note; report "EXAMPLE WARNING" severity warning; report "EXAMPLE ERROR" severity error; report "EXAMPLE FAILURE" severity failure; wait for 1 ns; -- Re-enable just failure to kill the test and check it SetVhdlAssertEnable(failure, true); report "END THE TEST" severity failure; end process; end architecture; nvc-r1.17.1/test/regress/assign1.vhd000066400000000000000000000011111504111170000172320ustar00rootroot00000000000000entity assign1 is end entity; architecture test of assign1 is begin process is variable x, y : integer; begin x := 5; y := 7; assert x = 5; assert y = 7; wait for 1 ns; assert x + y = 12; wait; end process; process is variable x : integer := 64; variable y : integer := -4; begin wait for 4 ns; assert x = 64 report "x not 64"; assert y = -4 report "y not -4"; x := y * 2; assert x = -8; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign2.vhd000066400000000000000000000005411504111170000172410ustar00rootroot00000000000000entity assign2 is end entity; architecture test of assign2 is begin process is variable x : bit_vector(7 downto 0) := (1 => '1', others => '0'); begin assert x(0) = '0'; assert x(1) = '1'; assert x(4) = x(5); x(2) := '1'; assert x(2) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign3.vhd000066400000000000000000000011551504111170000172440ustar00rootroot00000000000000entity assign3 is end entity; architecture test of assign3 is begin process is variable x : bit_vector(7 downto 0); variable y : bit_vector(7 downto 0) := ( 0 => '1', 2 => '1', 4 => '1', 6 => '1', others => '0' ); begin assert x(0) = '0'; x := (others => '1'); assert x(0) = '1'; assert x(5) = '1'; x := y; assert x(0) = '1'; assert x(5) = '0'; assert x(6) = '1'; assert x(7) = '0'; assert x = y; y(4) := '0'; assert x /= y; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign4.vhd000066400000000000000000000007521504111170000172470ustar00rootroot00000000000000entity assign4 is end entity; architecture test of assign4 is type int_vec is array (natural range <>) of integer; begin check: process is variable v : int_vec(1 to 2); variable a, b : integer; begin v := (1, 2); wait for 1 ns; (a, b) := v; wait for 1 ns; assert a = 1; assert b = 2; (a, b) := int_vec'(5, 7); assert a = 5; assert b = 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign5.vhd000066400000000000000000000023371504111170000172510ustar00rootroot00000000000000entity assign5 is end entity; architecture test of assign5 is type rec1 is record x : bit; y : bit_vector(1 to 3); z : integer; end record; type rec2 is record x : rec1; y : character; end record; type bv2d is array (natural range <>) of bit_vector(1 to 2); begin p1: process is variable a : bit; variable b : bit_vector(1 to 3); variable c : integer; variable d : character; variable p, q, r : bit; variable r1 : rec1; variable r2 : rec2; begin r1 := ('1', "010", 42); (a, b, c) := r1; wait for 1 ns; assert a = '1'; assert b = "010"; assert c = 42; r2 := (('0', "100", 72), 'Z'); ((a, b, c), d) := r2; wait for 1 ns; assert a = '0'; assert b = "100"; assert c = 72; assert d = 'Z'; (a, (p, q, r), c) := r1; wait for 1 ns; assert a = '1'; assert p = '0'; assert q = '1'; assert r = '0'; assert c = 42; (b(1 to 2), (q, r)) := bv2d'( "10", "01" ); wait for 1 ns; assert b = "100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign6.vhd000066400000000000000000000011011504111170000172360ustar00rootroot00000000000000entity assign6 is end entity; architecture test of assign6 is signal x : bit := '1'; begin main: process is type int_ptr is access integer; type int_ptr_vec is array (natural range <>) of int_ptr; variable a, b : bit; variable p, q : int_ptr; begin wait for 1 ns; (a, b) := bit_vector'(x, not x); assert a = '1'; assert b = '0'; p := new integer'(5); (p, q) := int_ptr_vec'(q, p); assert q.all = 5; assert p = null; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign7.vhd000066400000000000000000000010371504111170000172470ustar00rootroot00000000000000entity assign7 is end entity; architecture test of assign7 is begin main: process is variable x : integer_vector(4 downto 0); variable y : integer_vector(1 downto 0); variable z : integer_vector(2 downto 0); variable i0, i1 : integer; begin x := (1, 2, 3, 4, 5); (y, z) := x; assert y = (1, 2); assert z = (3, 4, 5); (i0, z, i1) := x; assert i0 = 1; assert z = (2, 3, 4); assert i1 = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/assign8.vhd000066400000000000000000000015231504111170000172500ustar00rootroot00000000000000entity assign8 is end entity; architecture test of assign8 is function get_ints(count : natural) return integer_vector is variable result : integer_vector(1 to count); begin for i in 1 to count loop result(i) := i; end loop; return result; end function; procedure proc (xl, yl : natural) is variable x : integer_vector(1 to xl); variable y : integer_vector(1 to yl); begin (x, y) := get_ints(5); for i in 1 to xl loop assert x(i) = i; end loop; for i in 1 to yl loop assert y(i) = xl + i; end loop; end procedure; begin p1: process is begin proc(2, 3); proc(1, 4); proc(0, 5); proc(5, 0); proc(4, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/assign9.vhd000066400000000000000000000017711504111170000172560ustar00rootroot00000000000000entity assign9 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of assign9 is signal s : integer := 0; signal t : std_logic_vector(1 to 2); begin t <= "10"; p1: process is variable v : integer; variable b1, b2 : std_logic; begin v := 1 when s = 0 else 5 when s = 2 else 6; assert v = 1; s <= 5; wait for 1 ns; with s select v := 10 when 0, 22 when 5, 2 when others; assert v = 22; s <= 6; wait for 1 ns; with s select (b1, b2) := std_logic_vector'("01") when 2, "10" when others; assert b1 = '1'; assert b2 = '0'; with t select? v := 2 when "-1", 3 when "1-", 4 when others; assert v = 3; with t select? s <= 5 when "-0", 8 when "1-", 4 when others; wait for 0 ns; assert s = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr1.vhd000066400000000000000000000015451504111170000167330ustar00rootroot00000000000000entity attr1 is end entity; architecture test of attr1 is type my_int is range 10 downto 0; begin process is variable x : integer; variable y : my_int; begin assert integer'left = -2147483648; x := integer'right; wait for 1 ns; assert x = 2147483647; assert positive'left = 1; assert natural'high = integer'high; assert integer'ascending; assert not my_int'ascending; x := 0; wait for 1 ns; assert integer'succ(x) = 1; assert integer'pred(x) = -1; x := 1; y := 1; wait for 1 ns; assert integer'leftof(x) = 0; assert integer'rightof(x) = 2; assert my_int'leftof(y) = 2; assert my_int'rightof(y) = 0; assert my_int'base'left = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr10.vhd000066400000000000000000000005631504111170000170120ustar00rootroot00000000000000entity attr10 is end entity; architecture test of attr10 is begin process is constant s : string := "1234"; constant n : integer := 1234; begin for i in 1 to 4 loop report character'image(integer'image(n)(i)); assert integer'image(n)(i) = s(i); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr11.vhd000066400000000000000000000005771504111170000170200ustar00rootroot00000000000000entity attr11 is end entity; architecture test of attr11 is begin process is variable i : integer; attribute a : bit_vector; attribute a of i : variable is "101"; attribute b : integer; attribute b of i : variable is 4; begin assert i'a(1) = '0'; assert i'a = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr12.vhd000066400000000000000000000010211504111170000170020ustar00rootroot00000000000000package pack is constant iname : string := pack'instance_name; procedure proc; end package; package body pack is procedure proc is begin report pack'instance_name & " <--"; report iname & " <--"; end procedure; end package body; ------------------------------------------------------------------------------- entity attr12 is end entity; use work.pack.all; architecture test of attr12 is begin process is begin proc; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr13.vhd000066400000000000000000000154011504111170000170120ustar00rootroot00000000000000-- -- Example from LRM 00 page 197 -- package P is -- P'PATH_NAME = ":lib:p:" procedure Proc (F: inout INTEGER); -- P'INSTANCE_NAME = ":lib:p:" constant C: INTEGER := 42; -- Proc'PATH_NAME = ":lib:p:proc" end package P; -- Proc'INSTANCE_NAME = ":lib:p:proc" package body P is -- C'PATH_NAME = ":lib:p:c" procedure Proc (F: inout INTEGER) is -- C'INSTANCE_NAME = ":lib:p:c" variable x: INTEGER; -- x'PATH_NAME = ":lib:p:proc:x" begin -- x'INSTANCE_NAME = ":lib:p:proc:x" assert P'PATH_NAME = ":lib:p:"; assert P'INSTANCE_NAME = ":lib:p:"; assert Proc'PATH_NAME = ":lib:p:proc:"; assert Proc'INSTANCE_NAME = ":lib:p:proc:"; assert C'PATH_NAME = ":lib:p:c"; assert C'INSTANCE_NAME = ":lib:p:c"; assert x'PATH_NAME = ":lib:p:proc:x" report x'path_name; assert x'INSTANCE_NAME = ":lib:p:proc:x"; end; end; library lib; use Lib.P.all; entity E is -- E is the top-level design entity: -- E'PATH_NAME = ":e:" -- E'INSTANCE_NAME = ":e(a):" generic (G: INTEGER); -- G'PATH_NAME = ":e:g" -- G'INSTANCE_NAME = ":e(a):g" port (P: in INTEGER); -- P'PATH_NAME = ":e:p" -- P'INSTANCE_NAME = ":e(a):p" begin assert E'PATH_NAME = ":top:e:"; end entity E; architecture A of E is signal S: BIT_VECTOR (1 to G); -- S'PATH_NAME = ":e:s" -- S'INSTANCE_NAME = ":e(a):s" procedure Proc1 (signal sp1: NATURAL; C: out INTEGER) is -- Proc1'PATH_NAME = ":e:proc1:" -- Proc1'INSTANCE_NAME =:e(a):proc1:" -- C'PATH_NAME = ":e:proc1:c" -- C'INSTANCE_NAME = ":e(a):proc1:c" variable max: DELAY_LENGTH; -- max'PATH_NAME = ":e:proc1:max" -- max'INSTANCE_NAME = ":e(a):proc1:max" begin max := sp1 * ns; wait on sp1 for max; c := sp1; end procedure Proc1; begin p1: process -- T'PATH_NAME = ":e:p1:t" variable T: INTEGER := 12; -- T'INSTANCE_NAME = ":e(a):p1:t" begin assert lib.P'PATH_NAME = ":lib:p:"; assert lib.P'INSTANCE_NAME = ":lib:p:"; proc(t); assert s'path_name = ":top:e:s"; assert s'instance_name = ":top(top):e@e(a):s"; assert t'path_name = ":top:e:p1:t"; assert t'instance_name = ":top(top):e@e(a):p1:t"; wait; end process p1; process variable T: INTEGER := 12; -- T'PATH_NAME = ":e::t" begin -- T'INSTANCE_NAME = ":e(a)::t" assert t'path_name = ":top:e::t" report t'path_name; assert t'instance_name = ":top(top):e@e(a)::t"; wait; end process; end architecture; entity Bottom is generic (GBottom : INTEGER); port (PBottom : INTEGER); end entity Bottom; architecture BottomArch of Bottom is signal SBottom : INTEGER; begin ProcessBottom : process variable V : INTEGER; begin if GBottom = 4 then assert V'Simple_Name = "v" and V'Path_Name = ":top:b1:b2:g1(4):b3:l1:processbottom:v" and V'Instance_Name = ":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):processbottom:v"; assert GBottom'Simple_Name = "gbottom" and GBottom'Path_Name = ":top:b1:b2:g1(4):b3:l1:gbottom" and GBottom'Instance_Name = ":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):gbottom"; elsif GBottom = -1 then assert V'Simple_Name = "v" and V'Path_Name = ":top:l2:processbottom:v" and V'Instance_Name = ":top(top):l2@bottom(bottomarch):processbottom:v"; assert GBottom'Simple_Name = "gbottom" and GBottom'Path_Name = ":top:l2:gbottom" and GBottom'Instance_Name = ":top(top):l2@bottom(bottomarch):gbottom"; end if; wait; end process ProcessBottom; end architecture BottomArch; entity top is end entity; architecture top of top is component BComp is generic (GComp : INTEGER); port (PComp : INTEGER); end component BComp; signal S : INTEGER; begin B1 : block signal S : INTEGER; begin B2 : block signal S : INTEGER; begin G1 : for I in 1 to 10 generate B3 : block signal S : INTEGER; for L1 : BComp use entity Work.Bottom(BottomArch) generic map (GBottom => GComp) port map (PBottom => PComp); begin L1 : BComp generic map (I) port map (S); P1 : process variable V : INTEGER; begin if I = 7 then assert V'Simple_Name = "v" and V'Path_Name = ":top:b1:b2:g1(7):b3:p1:v" and V'Instance_Name=":top(top):b1:b2:g1(7):b3:p1:v"; assert P1'Simple_Name = "p1" and P1'Path_Name = ":top:b1:b2:g1(7):b3:p1:" and P1'Instance_Name = ":top(top):b1:b2:g1(7):b3:p1:"; assert S'Simple_Name = "s" and S'Path_Name = ":top:b1:b2:g1(7):b3:s" and S'Instance_Name = ":top(top):b1:b2:g1(7):b3:s"; assert B1.S'Simple_Name = "s" and B1.S'Path_Name = ":top:b1:s" and B1.S'Instance_Name = ":top(top):b1:s"; end if; wait; end process P1; end block B3; end generate; end block B2; end block B1; L2 : BComp generic map (-1) port map (S); E: entity work.E(A) generic map (1) port map (2); end architecture top; configuration attr13 of Top is for Top for L2 : BComp use entity Work.Bottom(BottomArch) generic map (GBottom => GComp) port map (PBottom => PComp); end for; end for; end configuration attr13; nvc-r1.17.1/test/regress/attr14.vhd000066400000000000000000000014411504111170000170120ustar00rootroot00000000000000entity attr14 is end entity; architecture test of attr14 is type rec is record x : bit_vector(7 downto 0); end record; signal s : rec; signal t : bit_vector(3 downto 0); begin p1: process is begin wait for 1 ns; s.x(4) <= '1'; wait for 1 ns; s.x(4) <= '1'; wait; end process; p2: process is begin wait on s.x; assert now = 1 ns; assert s.x'event; assert s.x'last_event = 0 ns; assert s.x'last_active = 0 ns; assert s.x(4) = '1'; wait on s.x; assert s.x'active; assert not s.x'event; assert s.x'last_event = 1 ns; assert s.x'last_active = 0 ns; assert s.x(4) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr15.vhd000066400000000000000000000022361504111170000170160ustar00rootroot00000000000000entity attr15 is end entity; architecture test of attr15 is function double (x : in integer_vector) return integer_vector is variable result : x'subtype; begin for i in result'range loop result(i) := x(i) * 2; end loop; return result; end function; type int_vec_2d is array (natural range <>, natural range <>) of integer; function double (x : in int_vec_2d) return int_vec_2d is variable result : x'subtype; begin for i in result'range(1) loop for j in result'range(2) loop result(i, j) := x(i, j) * 2; end loop; end loop; return result; end function; signal s1, s2 : integer_vector(1 to 5) := (others => 0); signal s3, s4 : int_vec_2d(1 to 2, 5 to 5) := (others => (others => 0)); begin p1: s2 <= double(s1); p2: s4 <= double(s3); check: process is begin s1 <= (1, 2, 3, 4, 5); wait for 1 ns; assert s2 = (2, 4, 6, 8, 10); s3 <= ( (5 => 1), (5 => 2) ); wait for 1 ns; assert s4 = ( (5 => 2), (5 => 4) ); wait; end process; end architecture; nvc-r1.17.1/test/regress/attr16.vhd000066400000000000000000000010521504111170000170120ustar00rootroot00000000000000entity attr16 is end entity; architecture test of attr16 is type int_vec_2d is array (natural range <>, natural range <>) of integer; signal s1, s2 : integer_vector(1 to 5) := (others => 0); signal s3, s4 : int_vec_2d(1 to 2, 5 to 5) := (others => (others => 0)); begin check: process is begin assert s1'range(1)'low = 1; assert s1'range(1)'right = 5; assert s3'range(1)'left = 1; assert s3'range(2)'left = 5; assert s3'range(2)'right = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr17.vhd000066400000000000000000000014741504111170000170230ustar00rootroot00000000000000package pack is impure function func (x : integer) return integer; end package; package body pack is impure function func (x : integer) return integer is begin report "A ~ " & x'instance_name; report "B ~ " & func'instance_name; return x + 1; end function; end package body; ------------------------------------------------------------------------------- entity attr17 is end entity ; use work.pack.all; architecture arch of attr17 is procedure report_instance_name(x : in string) is constant val : integer := 0 ; begin report "C ~ " & val'instance_name ; end procedure ; begin tb : process variable x : integer; begin x := func(x); report_instance_name("something"); wait; end process ; end architecture ; nvc-r1.17.1/test/regress/attr18.vhd000066400000000000000000000006701504111170000170210ustar00rootroot00000000000000entity attr18 is end entity; architecture test of attr18 is begin process is type t_abc is (a, b, c); type t_small is range 1 to 10; variable x : integer := 42; variable y : t_abc; begin assert x'image = "42"; assert x'leftof(5) = 4; assert t_abc'length = 3; assert y'length = 3; assert t_small'length = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr19.vhd000066400000000000000000000020331504111170000170150ustar00rootroot00000000000000entity attr19 is end entity ; architecture arch of attr19 is type record_t is record a : integer ; b : bit ; end record ; function to_string(x : in record_t) return string is begin return "(a => " & integer'image(x.a) & ", b => " & bit'image(x.b) & ")" ; end function ; procedure monitor generic(type t ; function to_string(x : in t) return string is <>) parameter(x : in t) is procedure sub is begin std.textio.write(std.textio.output, monitor'instance_name & "/" & time'image(now) & ": " & to_string(x) & LF) ; end procedure; begin sub; end procedure ; procedure monitor is new monitor generic map(t => record_t) ; signal r : record_t ; begin monitor(r) ; tb : process begin r.a <= 10 ; r.b <= '0' ; wait for 10 ns ; r.a <= 11 ; wait for 15 ns ; r.b <= '1' ; wait for 30 ns ; report "Done"; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/attr2.vhd000066400000000000000000000013121504111170000167240ustar00rootroot00000000000000entity attr2 is end entity; architecture test of attr2 is type int3d is array (natural range <>, natural range <>, natural range <>) of integer; procedure foo(x : in int3d) is begin assert x'length(1) = 2; assert x'length(2) = 2; assert x'length(3) = 10; end procedure; begin process is variable v : int3d(1 to 2, 1 downto 0, 10 to 19); begin assert v'length(1) = 2; assert v'length(2) = 2; assert v'length(3) = 10; assert v'ascending(1); assert not v'ascending(2); assert v'ascending(3); foo(v); wait; end process; end architecture; nvc-r1.17.1/test/regress/attr20.vhd000066400000000000000000000237641504111170000170230ustar00rootroot00000000000000-- -- Example from LRM 19 page 282 -- package P is -- P'PATH_NAME = ":lib:p:" procedure Proc (F: inout INTEGER); -- P'INSTANCE_NAME = ":lib:p:" constant C: INTEGER := 42; -- Proc'PATH_NAME = ":lib:p:proc[integer]:" type IncPt1 is protected procedure increment; impure function get return INTEGER; procedure check (p, i, s : string); end protected IncPt1; end package P; -- Proc'INSTANCE_NAME = ":lib:p:proc[integer]:" package body P is -- C'PATH_NAME = ":lib:p:c" procedure Proc (F: inout INTEGER) is -- C'INSTANCE_NAME = ":lib:p:c" variable x: INTEGER; -- x'PATH_NAME = ":lib:p:proc[integer]:x" begin -- x'INSTANCE_NAME = ":lib:p:proc[integer]:x" assert P'PATH_NAME = ":lib:p:"; assert P'INSTANCE_NAME = ":lib:p:"; assert Proc'PATH_NAME = ":lib:p:proc[integer]:"; assert Proc'INSTANCE_NAME = ":lib:p:proc[integer]:"; assert C'PATH_NAME = ":lib:p:c"; assert C'INSTANCE_NAME = ":lib:p:c"; assert x'PATH_NAME = ":lib:p:proc[integer]:x" report x'path_name; assert x'INSTANCE_NAME = ":lib:p:proc[integer]:x"; end; type IncPt1 is protected body variable IncCounter : INTEGER := 0; -- For shared variable ArchInc -- IncCounter'PATH_NAME = "e:ArchInc:IncCounter" -- IncCounter'INSTANCE_NAME = "e(a):ArchInc:IncCounter" -- For variable ProcInc -- IncCounter'PATH_NAME = "e:p1:ProcInc:IncCounter" -- IncCounter'INSTANCE_NAME = "e(a):p1:ProcInc:IncCounter" procedure increment is begin -- For shared variable ArchInc -- increment'PATH_NAME = "e:ArchInc:increment" -- increment'INSTANCE_NAME = "e(a):ArchInc:increment" -- For variable ProcInc -- increment'PATH_NAME = "e:p1:ProcInc:increment" -- increment'INSTANCE_NAME = "e(a):p1:ProcInc:increment" IncCounter := IncCounter + 1; report IncCounter'PATH_NAME; report IncCounter'INSTANCE_NAME; end procedure increment; impure function get return INTEGER is begin -- For shared variable ArchInc -- get'PATH_NAME = "e:ArchInc:get" -- get'INSTANCE_NAME = "e(a):ArchInc:get" -- For variable ProcInc -- get'PATH_NAME = "e:p1:ProcInc:get" -- get'INSTANCE_NAME = "e(a):p1:ProcInc:get" return IncCounter; end function get; procedure check (p, i, s : string) is begin assert IncCounter'path_name = p report IncCounter'path_name & " != " & p; assert IncCounter'instance_name = i report IncCounter'instance_name & " != " & i; assert IncPt1'path_name = s report IncPt1'path_name & " != " & s; end procedure; end protected body IncPt1; end; library lib; use Lib.P.all; entity E is -- E is the top-level design entity: -- E'PATH_NAME = ":e:" -- E'INSTANCE_NAME = ":e(a):" generic (G: INTEGER); -- G'PATH_NAME = ":e:g" -- G'INSTANCE_NAME = ":e(a):g" port (P: in INTEGER); -- P'PATH_NAME = ":e:p" -- P'INSTANCE_NAME = ":e(a):p" begin assert E'PATH_NAME = ":top:e:"; end entity E; architecture A of E is signal S: BIT_VECTOR (1 to G); -- S'PATH_NAME = ":e:s" -- S'INSTANCE_NAME = ":e(a):s" signal tmp : natural; procedure Proc1 (signal sp1: NATURAL; C: out INTEGER) is -- Proc1'PATH_NAME = ":e:proc1[natural,integer]:" -- Proc1'INSTANCE_NAME =:e(a):proc1[natural,integer]:" -- C'PATH_NAME = ":e:proc1[natural,integer]:c" -- C'INSTANCE_NAME = ":e(a):proc1[natural,integer]:c" variable max: DELAY_LENGTH; -- max'PATH_NAME = ":e:proc1[natural,integer]:max" -- max'INSTANCE_NAME = ":e(a):proc1[natural,integer]:max" begin assert Proc1'PATH_NAME = ":top:e:proc1[natural, integer]:"; assert Proc1'INSTANCE_NAME = ":top(top):e@e(a):proc1[natural, integer]:"; assert c'PATH_NAME = ":top:e:proc1[natural, integer]:c"; assert c'INSTANCE_NAME = ":top(top):e@e(a):proc1[natural, integer]:c"; assert max'PATH_NAME = ":top:e:proc1[natural, integer]:max"; assert max'INSTANCE_NAME = ":top(top):e@e(a):proc1[natural, integer]:max"; -- max := sp1 * ns; -- wait on sp1 for max; -- c := sp1; end procedure Proc1; shared variable ArchInc : IncPt1; -- ArchInc'PATH_NAME = ":e:ArchInc" -- ArchInc'INSTANCE_NAME = ":e(a):ArchInc" begin p1: process -- T'PATH_NAME = ":e:p1:t" variable T: INTEGER := 12; -- T'INSTANCE_NAME = ":e(a):p1:t" variable ProcInc : IncPt1; -- ProcInc'PATH_NAME = ":e:p1:ProcInc" -- ProcInc'INSTANCE_NAME = ":e(a):p1:ProcInc" begin assert lib.P'PATH_NAME = ":lib:p:"; assert lib.P'INSTANCE_NAME = ":lib:p:"; proc(t); assert s'path_name = ":top:e:s"; assert s'instance_name = ":top(top):e@e(a):s"; assert t'path_name = ":top:e:p1:t"; assert t'instance_name = ":top(top):e@e(a):p1:t"; proc1(tmp, t); ProcInc.increment; assert ProcInc.get = 1; procinc.check(":top:e:p1:procinc:inccounter", ":top(top):e@e(a):p1:procinc:inccounter", ":top:e:p1:procinc:"); archinc.check(":top:e:archinc:inccounter", ":top(top):e@e(a):archinc:inccounter", ":top:e:archinc:"); wait; end process p1; process variable T: INTEGER := 12; -- T'PATH_NAME = ":e::t" begin -- T'INSTANCE_NAME = ":e(a)::t" assert t'path_name = ":top:e::t" report t'path_name; assert t'instance_name = ":top(top):e@e(a)::t"; wait; end process; end architecture; entity Bottom is generic (GBottom : INTEGER); port (PBottom : INTEGER); end entity Bottom; architecture BottomArch of Bottom is signal SBottom : INTEGER; begin ProcessBottom : process variable V : INTEGER; begin if GBottom = 4 then assert V'Simple_Name = "v" and V'Path_Name = ":top:b1:b2:g1(4):b3:l1:processbottom:v" and V'Instance_Name = ":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):processbottom:v"; assert GBottom'Simple_Name = "gbottom" and GBottom'Path_Name = ":top:b1:b2:g1(4):b3:l1:gbottom" and GBottom'Instance_Name = ":top(top):b1:b2:g1(4):b3:l1@bottom(bottomarch):gbottom"; elsif GBottom = -1 then assert V'Simple_Name = "v" and V'Path_Name = ":top:l2:processbottom:v" and V'Instance_Name = ":top(top):l2@bottom(bottomarch):processbottom:v"; assert GBottom'Simple_Name = "gbottom" and GBottom'Path_Name = ":top:l2:gbottom" and GBottom'Instance_Name = ":top(top):l2@bottom(bottomarch):gbottom"; end if; wait; end process ProcessBottom; end architecture BottomArch; entity top is end entity; architecture top of top is component BComp is generic (GComp : INTEGER); port (PComp : INTEGER); end component BComp; signal S : INTEGER; begin B1 : block signal S : INTEGER; begin B2 : block signal S : INTEGER; begin G1 : for I in 1 to 10 generate B3 : block signal S : INTEGER; for L1 : BComp use entity Work.Bottom(BottomArch) generic map (GBottom => GComp) port map (PBottom => PComp); begin L1 : BComp generic map (I) port map (S); P1 : process variable V : INTEGER; begin if I = 7 then assert V'Simple_Name = "v" and V'Path_Name = ":top:b1:b2:g1(7):b3:p1:v" and V'Instance_Name=":top(top):b1:b2:g1(7):b3:p1:v"; assert P1'Simple_Name = "p1" and P1'Path_Name = ":top:b1:b2:g1(7):b3:p1:" and P1'Instance_Name = ":top(top):b1:b2:g1(7):b3:p1:"; assert S'Simple_Name = "s" and S'Path_Name = ":top:b1:b2:g1(7):b3:s" and S'Instance_Name = ":top(top):b1:b2:g1(7):b3:s"; assert B1.S'Simple_Name = "s" and B1.S'Path_Name = ":top:b1:s" and B1.S'Instance_Name = ":top(top):b1:s"; end if; wait; end process P1; end block B3; end generate; end block B2; end block B1; L2 : BComp generic map (-1) port map (S); E: entity work.E(A) generic map (1) port map (2); end architecture top; configuration attr20 of Top is for Top for L2 : BComp use entity Work.Bottom(BottomArch) generic map (GBottom => GComp) port map (PBottom => PComp); end for; end for; end configuration attr20; nvc-r1.17.1/test/regress/attr21.vhd000066400000000000000000000012051504111170000170060ustar00rootroot00000000000000entity attr21 is end entity; architecture test of attr21 is function foo (x : integer) return boolean is begin return true; end function; function foo (y : bit) return string is begin return "hello"; end function; type my_enum is ('1', '2'); attribute test : string; attribute test of '1' [return my_enum] : literal is "hello"; begin p: process is begin report foo [integer return boolean]'instance_name; -- OK report foo [bit return string]'instance_name; -- OK report '1' [return my_enum]'test; -- OK wait; end process; end architecture; nvc-r1.17.1/test/regress/attr3.vhd000066400000000000000000000007731504111170000167370ustar00rootroot00000000000000entity attr3 is end entity; architecture test of attr3 is type int_vec is array (integer range <>) of integer; procedure foo(x : in int_vec) is begin for i in x'reverse_range loop report integer'image(i); end loop; end procedure; begin process is variable a : int_vec(1 to 5); begin for i in a'reverse_range loop report integer'image(i); end loop; foo(a); wait; end process; end architecture; nvc-r1.17.1/test/regress/attr4.vhd000066400000000000000000000006151504111170000167330ustar00rootroot00000000000000entity attr4 is end entity; architecture test of attr4 is begin process is variable b : boolean; begin assert boolean'pos(false) = 0; assert boolean'pos(true) = 1; b := true; wait for 1 ns; assert boolean'pos(b) = 1; assert boolean'val(0) = false; assert bit'val(1) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr5.vhd000066400000000000000000000010041504111170000167250ustar00rootroot00000000000000entity attr5 is end entity; architecture test of attr5 is type int_vec is array (integer range <>) of integer; type int_vec_ptr is access int_vec; begin process is variable p : int_vec_ptr; begin p := new int_vec(1 to 10); report integer'image(p.all'length); assert p.all'length = 10; deallocate(p); p := new int_vec(1 to 20); report integer'image(p'length); assert p'length = 20; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr6.vhd000066400000000000000000000017361504111170000167420ustar00rootroot00000000000000entity attr6 is end entity; architecture test of attr6 is signal x : integer := 5; signal y : bit_vector(0 to 3); signal z : bit; -- No drivers begin process is begin assert x'last_event = time'high; assert z'last_event = time'high; x <= 0; assert x'last_value = x; assert x'last_value = 5; wait for 1 ns; assert x'last_value = 5; assert x'last_event = 1 ns; x <= 2; wait for 1 ns; assert x = 2; assert x'last_value = 0; assert x'last_event = 1 ns; assert y'last_value = y; y <= ( '0', '1', '0', '1' ); wait for 1 ns; assert y'last_value = ( '0', '0', '0', '0' ); y(1) <= '1'; wait for 1 ns; assert y'last_value = ( '0', '0', '0', '0' ); y(1) <= '0'; wait for 1 ns; assert y'last_value = ( '0', '1', '0', '0' ); wait; end process; end architecture; nvc-r1.17.1/test/regress/attr7.vhd000066400000000000000000000010071504111170000167320ustar00rootroot00000000000000entity attr7 is end entity; architecture test of attr7 is signal vec : bit_vector(1 downto 0); begin process (vec(0)) is begin report "wakeup " & bit'image(vec(0)); if now > 0 ns then assert vec(0)'event; assert now = 3 ns; end if; end process; process is begin wait for 1 ns; vec <= "10"; wait for 1 ns; vec <= "00"; wait for 1 ns; vec <= "01"; wait; end process; end architecture; nvc-r1.17.1/test/regress/attr8.vhd000066400000000000000000000012101504111170000167270ustar00rootroot00000000000000entity attr8 is end entity; architecture test of attr8 is begin process is type myint is range 1 to 3; subtype myint_sub is myint range 1 to 2; variable x : integer; begin assert myint'val(1) = 1; assert myint'val(2) = 2; x := 1; assert myint'val(x) = 1; x := 2; assert myint'val(x) = 2; assert myint_sub'val(2) = 2; assert myint_sub'val(x) = 2; assert myint'pos(myint(x)) = x; assert myint_sub'pos(myint(x)) = x; assert myint'pos(1) = 1; assert myint_sub'pos(1) = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/bitstr1.vhd000066400000000000000000000027741504111170000172750ustar00rootroot00000000000000entity bitstr1 is end entity; architecture test of bitstr1 is begin main: process is begin -- Examples from LRM assert B"1111_1111_1111" = string'("111111111111"); assert X"FFF" = string'(b"1111_1111_1111"); assert O"777" = string'(b"111_111_111"); assert X"777" = string'(b"0111_0111_0111"); assert B"XXXX_01LH" = string'("XXXX01LH"); assert UO"27" = string'(b"010_111"); assert UO"2C" = string'("010CCC"); assert SX"3W" = string'("0011WWWW"); assert D"35" = string'("100011"); assert 12UB"X1" = string'("0000000000X1"); assert 12SB"X1" = string'("XXXXXXXXXXX1"); assert 12UX"F-" = string'("00001111----"); assert 12SX"F-" = string'("11111111----"); assert 12D"13" = string'(b"0000_0000_1101"); assert 12UX"000WWW" = string'("WWWWWWWWWWWW"); assert 12SX"FFFC00" = string'("110000000000"); assert 12SX"XXXX00" = string'("XXXX00000000"); -- Empty bit strings should be allowed assert 4x"" = string'("0000"); assert d"" = string'(""); wait; end process; p2: process is constant c1: STRING := B"1111_1111_1111"; constant c2: BIT_VECTOR := X"FFF"; type MVL is ('X', '0', '1', 'Z'); type MVL_VECTOR is array (NATURAL range <>) of MVL; constant c3: MVL_VECTOR := O"777"; begin assert c1'LENGTH = 12 and c2'LENGTH = 12 and c3 = "111111111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/bitvec.vhd000066400000000000000000000013541504111170000171520ustar00rootroot00000000000000entity bitvec is end entity; architecture test of bitvec is function get_bitvec(x, y : integer) return bit_vector is variable r : bit_vector(x to y) := "00"; begin return r; end function; begin process is variable b : bit_vector(3 downto 0); variable n : integer; begin b := "1101"; n := 2; wait for 1 ns; assert not b = "0010"; assert (b and "1010") = "1000"; assert (b or "0110") = "1111"; assert (b xor "0111") = "1010"; assert (b xnor "0111") = "0101"; assert (b nand "1010") = "0111"; assert (b nor "0110") = "0000"; assert get_bitvec(1, n) = "00"; wait; end process; end architecture; nvc-r1.17.1/test/regress/block1.vhd000066400000000000000000000011171504111170000170460ustar00rootroot00000000000000entity block1 is end entity; architecture test of block1 is signal u, v, w: integer; begin process is begin u <= 1; wait for 1 ns; u <= 2; wait; end process; a: block is signal x : integer; begin x <= u + 2; v <= x; end block; b: block is signal x : integer; begin x <= v + 6; w <= x; end block; process is begin wait for 1 ns; assert w = 9; wait for 1 ns; assert w = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/block2.vhd000066400000000000000000000010061504111170000170440ustar00rootroot00000000000000entity block2 is end entity; architecture test of block2 is signal x, y : integer; begin b1: block is generic ( g1 : integer ); generic map ( g1 => 5 ); port ( i : in integer; o : out integer ); port map ( i => x, o => y ); begin o <= i + g1; end block; stim: process is begin x <= 1; wait for 1 ns; assert y = 6; x <= 10; wait for 1 ns; assert y = 15; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds1.vhd000066400000000000000000000005301504111170000172440ustar00rootroot00000000000000entity bounds1 is end entity; architecture test of bounds1 is type int_vec is array (natural range <>) of integer; begin process is variable v : int_vec(1 to 10) := (others => 0); variable k : integer; begin k := 602; report integer'image(v(k)); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds10.vhd000066400000000000000000000005161504111170000173300ustar00rootroot00000000000000entity bounds10 is end entity; architecture test of bounds10 is begin process is variable n : integer; variable a : bit_vector(3 downto 0); variable b : bit_vector(7 downto 0); begin n := 7; wait for 1 ns; a := b(n downto 0); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds11.vhd000066400000000000000000000002651504111170000173320ustar00rootroot00000000000000entity bounds11 is end entity; architecture test of bounds11 is type my_int is range 0 to 100; signal i : my_int; begin p1: i <= i + 1 after 10 ns; end architecture; nvc-r1.17.1/test/regress/bounds12.vhd000066400000000000000000000002761504111170000173350ustar00rootroot00000000000000entity bounds12 is end entity; architecture test of bounds12 is begin process is begin assert integer'value("hello") = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds13.vhd000066400000000000000000000004231504111170000173300ustar00rootroot00000000000000entity bounds13 is end entity; architecture test of bounds13 is begin process is type myint is range 1 to 3; begin assert myint'value(" 3 ") = 3; assert myint'value("4") = 1; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds15.vhd000066400000000000000000000010421504111170000173300ustar00rootroot00000000000000entity bounds15 is end entity; architecture test of bounds15 is function fact(n : natural) return positive is begin if n = 0 then return 1; else return n * fact(n - 1); end if; end function; begin p1: process is variable x : integer; begin x := 5; report integer'image(fact(x)); x := 0; report integer'image(fact(x)); x := -1; report integer'image(fact(x)); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds16.vhd000066400000000000000000000007701504111170000173400ustar00rootroot00000000000000entity bounds16 is end entity; architecture test of bounds16 is function add_nat(x : in integer) return natural is variable r : natural := x; begin return r + 1; end function; begin process is variable x : integer; begin x := 5; report integer'image(add_nat(x)); x := 0; report integer'image(add_nat(x)); x := -1; report integer'image(add_nat(x)); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds17.vhd000066400000000000000000000005661504111170000173440ustar00rootroot00000000000000entity bounds17 is end entity; architecture test of bounds17 is function get_bits(n : natural) return bit_vector is begin return (n - 1 downto 0 => '0'); end function; begin process is variable x : bit_vector(7 downto 0) := get_bits(12); begin report "should not print this"; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds18.vhd000066400000000000000000000011411504111170000173330ustar00rootroot00000000000000entity bounds18 is end entity; architecture test of bounds18 is function func(x : bit_vector(1 to 5)) return bit is begin return x(1) and x(5); end function; procedure proc(n : positive) is variable v : bit_vector(1 to n); begin assert func(v) = '0'; end procedure; begin process is variable v : bit_vector(1 to 4); begin --assert func(v) = '0'; -- Caught during analysis proc(5); -- OK proc(3); -- Failure here wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds19.vhd000066400000000000000000000012671504111170000173450ustar00rootroot00000000000000entity bounds19 is end entity; architecture test of bounds19 is type bv2d is array (positive range <>, positive range <>) of bit; function func(x : bv2d(1 to 5, 1 to 3)) return bit is begin return x(1, 2) and x(5, 1); end function; procedure proc(x, y : positive) is variable v : bv2d(1 to x, 1 to y); begin assert func(v) = '0'; end procedure; begin process is variable v : bv2d(1 to 5, 1 to 2); begin --assert func(v) = '0'; -- Caught during analysis proc(5, 3); -- OK proc(5, 2); -- Failure here wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds2.vhd000066400000000000000000000004761504111170000172560ustar00rootroot00000000000000entity bounds2 is end entity; architecture test of bounds2 is type int_vec is array (natural range <>) of integer; begin process is variable v : int_vec(1 to 10) := (others => 0); variable k : integer := 51761; begin v(k) := 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds20.vhd000066400000000000000000000006521504111170000173320ustar00rootroot00000000000000entity bounds20 is end entity; architecture test of bounds20 is type rec1 is record x : bit; y : bit_vector(1 to 3); z : integer; end record; signal a : bit; signal b : bit_vector(1 to 2); signal c : integer; begin p1: process is variable r1 : rec1; begin r1 := ('1', "010", 42); (a, b, c) <= r1; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds22.vhd000066400000000000000000000034701504111170000173350ustar00rootroot00000000000000package pack is type int_vector is array (natural range <>) of natural; function spread_ints (x : integer) return int_vector; end package; package body pack is function spread_ints (x : integer) return int_vector is variable r : int_vector(1 to 6); begin for i in r'range loop r(i) := x; end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o1 : out int_vector(1 to 5); i1 : in integer; i2 : in int_vector(1 to 5) ); end entity; architecture test of sub is begin p1: process is begin assert i1 = 0; assert i2 = (1 to 5 => 0); o1 <= (1, 2, 3, 4, 5); wait for 1 ns; assert i1 = 150; assert i2 = (1 to 5 => 42); o1(1) <= 10; wait; end process; end architecture; ------------------------------------------------------------------------------- entity bounds22 is end entity; use work.pack.all; architecture test of bounds22 is signal x : integer; signal y : int_vector(1 to 5); signal q : natural; function sum_ints(v : in int_vector) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; begin uut: entity work.sub port map ( sum_ints(o1) => x, i1 => sum_ints(y), i2 => spread_ints(q) ); -- Error p2: process is begin assert x = 0; y <= (10, 20, 30, 40, 50); q <= 42; wait for 1 ns; assert x = 15; wait for 1 ns; assert x = 24; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds23.vhd000066400000000000000000000020261504111170000173320ustar00rootroot00000000000000package pack is type int_vector is array (natural range <>) of natural; function spread_ints (x : integer) return int_vector; end package; package body pack is function spread_ints (x : integer) return int_vector is variable r : int_vector(1 to 5); begin for i in r'range loop r(i) := x; end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o : out integer := 0 ); end entity; architecture test of sub is begin p1: process is begin o <= 1; wait for 1 ns; o <= 2; wait; end process; end architecture; ------------------------------------------------------------------------------- entity bounds23 is end entity; use work.pack.all; architecture test of bounds23 is signal x : int_vector(1 to 3); begin uut: entity work.sub port map ( spread_ints(o) => x ); -- Error end architecture; nvc-r1.17.1/test/regress/bounds24.vhd000066400000000000000000000010271504111170000173330ustar00rootroot00000000000000entity bounds24 is end entity; architecture test of bounds24 is function func (n : natural) return bit is variable r : bit_vector(1 to 3) := (1 to n => '1'); begin return r(1) xor r(2) xor r(3); end function; signal n : integer := 3; begin main: process is begin assert func(3) = '1'; -- OK assert func(n) = '1'; -- OK n <= 1000; wait for 1 ns; assert func(n) = '1'; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds25.vhd000066400000000000000000000006451504111170000173410ustar00rootroot00000000000000entity bounds25 is end entity; architecture test of bounds25 is procedure proc (x : out bit_vector; b : bit) is begin x := (b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b); end procedure; begin main: process is variable v : bit_vector(1 to 2); begin wait for 1 ns; proc(v, '1'); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds26.vhd000066400000000000000000000012031504111170000173310ustar00rootroot00000000000000entity bounds26 is end entity; architecture test of bounds26 is type char_map is array (character range <>) of integer; function func (right : character) return integer is subtype a_to_c_map is char_map('a' to 'c'); variable r : a_to_c_map := ('a' to right => 1); begin return r('a') + r('b') + r('c'); end function; signal n : character := 'c'; begin main: process is begin assert func('c') = 3; -- OK assert func(n) = 3; -- OK n <= DEL; wait for 1 ns; assert func(n) = 3; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds27.vhd000066400000000000000000000006731504111170000173440ustar00rootroot00000000000000entity bounds27 is end entity; architecture test of bounds27 is procedure proc (x : out bit_vector) is variable a : bit_vector(x'range); -- OK variable b : bit_vector(5 to x'right - 100); -- OK begin x(1) := '1'; -- Error end procedure; begin main: process is variable v : bit_vector(1 to 0); begin proc(v); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds28.vhd000066400000000000000000000006021504111170000173350ustar00rootroot00000000000000entity bounds28 is end entity; architecture test of bounds28 is signal n : integer; begin main: process is variable t : delay_length; begin n <= 1; wait for 1 ns; t := n * ms; -- OK n <= -5; wait for 1 ns; t := n * fs; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds29.vhd000066400000000000000000000013051504111170000173370ustar00rootroot00000000000000entity bounds29 is end entity; architecture test of bounds29 is subtype my_real is real range 0.0 to 10.0; constant MATH_PI : REAL := 3.14159_26535_89793_23846; subtype PRINCIPAL_VALUE is REAL range -MATH_PI to MATH_PI; begin main: process is variable p1, p2 : principal_value; variable r : my_real; begin p1 := -0.78539815744037; -- OK wait for 1 ns; p2 := p1; -- OK r := 5.0; -- OK wait for 1 ns; r := r * 2.0; -- OK wait for 1 ns; r := r + 0.00001; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds3.vhd000066400000000000000000000003341504111170000172500ustar00rootroot00000000000000entity bounds3 is end entity; architecture test of bounds3 is type int_vec is array (natural range <>) of integer; signal s : int_vec(5 to 7); signal k : integer; begin s(k) <= 61; end architecture; nvc-r1.17.1/test/regress/bounds30.vhd000066400000000000000000000004221504111170000173260ustar00rootroot00000000000000entity bounds30 is end entity; architecture test of bounds30 is signal s : integer := -1; begin main: process is begin wait for 1 ns; assert 2 ** s = 0; -- Error, negative exponent wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds31.vhd000066400000000000000000000014531504111170000173340ustar00rootroot00000000000000package config is constant width : integer; end package; ------------------------------------------------------------------------------- use work.config.all; package types is type rec is record x : bit_vector(1 to width); -- OK end record; end package; ------------------------------------------------------------------------------- package body config is constant width : integer := 6; end package body; ------------------------------------------------------------------------------- entity bounds31 is end entity; use work.types.all; architecture test of bounds31 is signal r : rec; begin main: process is begin assert r.x'length = 6; assert r = ( x => "000" ) severity warning; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds32.vhd000066400000000000000000000010761504111170000173360ustar00rootroot00000000000000entity bounds32 is end entity; architecture test of bounds32 is type rec is record x : bit_vector; end record; signal s : rec(x(1 to 3)); signal n : integer := 4; signal v : bit_vector(1 to 10) := (others => '1'); begin main: process is begin assert s.x = "000"; assert s = (x => "000"); s.x <= "101"; wait for 1 ns; assert s.x = "101"; assert s = (x => "101"); s <= (x => v(1 to n)); -- Error wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds33.vhd000066400000000000000000000012161504111170000173330ustar00rootroot00000000000000entity bounds33 is end entity; architecture test of bounds33 is type rec is record x : bit_vector; end record; procedure assign (p : out rec) is begin p := (x => "1111111111111111"); end procedure; begin main: process is variable s : rec(x(1 to 3)); begin assert s.x = "000"; assert s = (x => "000"); s.x := "101"; assert s.x = "101"; assert s = (x => "101"); assign(s); -- Error report to_string(s.x'length); assert s.x = "111"; assert s = (x => "111"); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds34.vhd000066400000000000000000000007341504111170000173400ustar00rootroot00000000000000entity bounds34 is end entity; architecture test of bounds34 is begin main: process is variable x : integer_vector(1 to 4); variable y, z : integer_vector(1 to 2); begin x := ( integer_vector'(1, 2), integer_vector'(3, 4) ); assert x = (1, 2, 3, 4); y := (5, 6); z := (7, 8); x := ( y, 0, integer_vector'(1, 2, 3) ); -- Error assert x = (5, 6, 7, 8); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds35.vhd000066400000000000000000000007211504111170000173350ustar00rootroot00000000000000entity bounds35 is end entity; architecture test of bounds35 is begin main: process is variable x : integer_vector(4 downto 0); variable y : integer_vector(1 downto 0); variable z : integer_vector(2 downto 0); variable i0, i1 : integer; begin x := (1, 2, 3, 4, 5); i1 := 1; wait for 1 ns; (i1, i0) := x(4 downto i1); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds36.vhd000066400000000000000000000007201504111170000173350ustar00rootroot00000000000000entity bounds36 is end entity; architecture test of bounds36 is begin main: process is variable x : integer_vector(4 downto 0); variable y : integer_vector(1 downto 0); variable z : integer_vector(2 downto 0); variable i0, i1 : integer; begin x := (1, 2, 3, 4, 5); i1 := 1; wait for 1 ns; (i1, y) := x(4 downto i1); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds37.vhd000066400000000000000000000007171504111170000173440ustar00rootroot00000000000000entity bounds37 is end entity; architecture test of bounds37 is signal x : integer_vector(4 downto 0); signal y : integer_vector(1 downto 0); signal z : integer_vector(2 downto 0); signal i0, i1 : integer; begin main: process is begin x <= (1, 2, 3, 4, 5); wait for 1 ns; i1 <= 1; wait for 1 ns; (i1, y) <= x(4 downto i1); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds38.vhd000066400000000000000000000012201504111170000173330ustar00rootroot00000000000000entity bounds38 is end entity; architecture test of bounds38 is type int_vec_2d is array (natural range <>, natural range <>) of integer; function double (x : in int_vec_2d) return int_vec_2d is variable result : int_vec_2d(x'range(2), x'range(1)); variable sum : integer; begin for i in result'range(1) loop for j in result'range(2) loop result(i, j) := x(i, j) * 2; -- Error end loop; end loop; return result; end function; signal s3, s4 : int_vec_2d(1 to 2, 5 to 7) := (others => (others => 0)); begin p2: s4 <= double(s3); end architecture; nvc-r1.17.1/test/regress/bounds39.vhd000066400000000000000000000006211504111170000173400ustar00rootroot00000000000000entity bounds39 is end entity; architecture test of bounds39 is type bv10 is array (1 to 10) of bit; begin p1: process is variable a : bit_vector(1 to 10); variable b : bv10; variable n : integer; begin n := 9; wait for 1 ns; b := bv10(a); b := bv10(a(1 to n)); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds4.vhd000066400000000000000000000006071504111170000172540ustar00rootroot00000000000000entity bounds4 is end entity; architecture test of bounds4 is type int_vec is array (natural range <>) of integer; procedure check(x : in int_vec) is begin assert x(5 to 15) = (5 to 15 => 0); end procedure; begin process is variable v : int_vec(1 to 10) := (others => 0); begin check(v); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds40.vhd000066400000000000000000000007721504111170000173370ustar00rootroot00000000000000entity bounds40 is end entity; architecture test of bounds40 is type real_vector is array (natural range <>) of real; function get_reals return real_vector is begin return (1.0, 0.0, 1.0, 0.0, 1.0); end function; begin p1: process is constant c1 : real_vector := get_reals; constant c2 : real_vector(1 to c1'length) := (0.0, 1.0, 0.0, 1.0, 1.0, 0.0); -- Error begin wait for 5 ns; assert false; end process; end architecture; nvc-r1.17.1/test/regress/bounds41.vhd000066400000000000000000000007741504111170000173420ustar00rootroot00000000000000entity bounds41 is end entity; architecture test of bounds41 is type real_vector is array (natural range <>) of real; function get_reals return real_vector is begin return (1.0, 0.0, 1.0, 0.0, 1.0); end function; begin p1: process is constant c1 : real_vector := get_reals; constant c2 : real_vector(1 to c1'length) := (0.0, 1.0, 0.0, 1.0, c1(2), 0.0); -- Error begin wait for 5 ns; assert false; end process; end architecture; nvc-r1.17.1/test/regress/bounds42.vhd000066400000000000000000000010031504111170000173250ustar00rootroot00000000000000entity bounds42 is end entity; architecture test of bounds42 is constant c1 : bit_vector(1 to 3) := "111"; constant c2 : bit_vector(1 to 8) := X"00"; begin p1: process is procedure test (x : bit_vector) is begin report to_string( bit_vector'(x'range => (3 downto 0 => '0', 7 downto 4 => '1'))); end procedure; begin test(c2); -- OK test(c1); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds43.vhd000066400000000000000000000003711504111170000173350ustar00rootroot00000000000000entity bounds43 is end entity; architecture test of bounds43 is signal s : integer := 0; begin b1: block is port ( p : inout real ); port map ( integer(p) => real(s) ); -- Error begin end block; end architecture; nvc-r1.17.1/test/regress/bounds44.vhd000066400000000000000000000005401504111170000173340ustar00rootroot00000000000000entity bounds44 is end entity; architecture test of bounds44 is function get_bits(b : bit; n : natural) return bit_vector is begin return (1 to n => b); end function; begin b: block is port ( p : in bit_vector(1 to 2) ); port map ( p => inertial get_bits('1', 5) ); begin end block; end architecture; nvc-r1.17.1/test/regress/bounds45.vhd000066400000000000000000000015631504111170000173430ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity bounds45 is end entity; architecture test of bounds45 is type t_slv_array is array(natural range <>) of std_logic_vector; function get_first_element ( slv_array : t_slv_array ) return std_logic_vector is constant slv_array_normalized : t_slv_array(0 to slv_array'length*2) := slv_array; -- alias slv_array_normalized : t_slv_array(0 to slv_array'length*2) is slv_array; -- Error begin return slv_array_normalized(slv_array'length*2 - 1); end function get_first_element; begin p_nvc_bug : process variable v_slv_array : t_slv_array(0 to 3)(7 downto 0) := (others=>(others=>'0')); begin report "SLV array element 0 (const): " & to_hstring(get_first_element(v_slv_array(1 to 3))); wait; end process p_nvc_bug; end architecture test; nvc-r1.17.1/test/regress/bounds5.vhd000066400000000000000000000005361504111170000172560ustar00rootroot00000000000000entity bounds5 is end entity; architecture test of bounds5 is type int_vec is array (natural range <>) of integer; signal s : int_vec(8 downto 0); begin process is variable k : integer; begin k := 9; wait for 1 ns; s(k downto 1) <= (others => 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds6.vhd000066400000000000000000000005721504111170000172570ustar00rootroot00000000000000entity bounds6 is end entity; architecture test of bounds6 is begin process is variable i : integer; variable c : character; begin i := 32; wait for 1 ns; c := character'val(i); assert c = ' '; i := 1517262; wait for 1 ns; c := character'val(i); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds7.vhd000066400000000000000000000004741504111170000172610ustar00rootroot00000000000000entity bounds7 is end entity; architecture test of bounds7 is type my_int is range 1 to 10; begin process is variable x : my_int; variable y : integer; begin x := 6; y := integer(x); x := 10; x := x + 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds8.vhd000066400000000000000000000005211504111170000172530ustar00rootroot00000000000000entity bounds8 is end entity; architecture test of bounds8 is signal a : bit_vector(3 downto 0); signal b : bit_vector(7 downto 0); begin b <= X"10"; process is variable n : integer; begin n := 7; wait for 1 ns; a <= b(n downto 0); wait; end process; end architecture; nvc-r1.17.1/test/regress/bounds9.vhd000066400000000000000000000005551504111170000172630ustar00rootroot00000000000000entity bounds9 is end entity; architecture test of bounds9 is procedure foo(x : bit_vector) is variable s : string(x'range); begin report "should not print this" severity failure; end procedure; begin process is variable v : bit_vector(0 to 3); begin foo(v); wait; end process; end architecture; nvc-r1.17.1/test/regress/buffer1.vhd000066400000000000000000000011361504111170000172260ustar00rootroot00000000000000entity sub is port ( x : buffer natural ); end entity; architecture test of sub is begin test: process is begin x <= 1; wait for 1 ns; x <= 2; wait for 1 ns; assert x = 2; wait; end process; end architecture; entity buffer1 is end entity; architecture test of buffer1 is signal x : natural; begin uut: entity work.sub port map ( x ); main: process is begin assert x = 0; wait for 1 ns; assert x = 1; wait for 1 ns; assert x = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/case1.vhd000066400000000000000000000006311504111170000166670ustar00rootroot00000000000000entity case1 is end entity; architecture test of case1 is begin process is variable x : integer; begin x := 5; wait for 1 ns; case x is when 1 => assert false; when 5 => report "five!"; when others => assert false; end case; wait; end process; end architecture; nvc-r1.17.1/test/regress/case10.vhd000066400000000000000000000011341504111170000167460ustar00rootroot00000000000000entity case10 is end entity; architecture test of case10 is type my_enum is (a, b, c); signal e : my_enum; signal i : natural; begin update: process (i) is begin case i is when my_enum'pos(a) => e <= a; when my_enum'pos(b) => e <= b; when my_enum'pos(c) => e <= c; when others => null; end case; end process; main: process is begin i <= 0; wait for 1 ns; assert e = a; i <= 2; wait for 1 ns; assert e = c; wait; end process; end architecture; nvc-r1.17.1/test/regress/case11.vhd000066400000000000000000000032621504111170000167530ustar00rootroot00000000000000entity case11 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of case11 is signal x : std_logic_vector(1 to 3); signal y : natural; signal p : std_logic; signal q : natural; signal r : bit_vector(1 to 3); signal s : natural; begin p1: process (x) is begin y <= 0; case? x is when "111" => y <= 1; when "000" => y <= 2; when "1--" => y <= 3; when "0--" => y <= 4; when "--0" => y <= 5; when others => y <= 6; end case?; end process; p2: process is begin x <= "000"; wait for 1 ns; assert y = 2; x <= "XXX"; wait for 1 ns; assert y = 6; x <= "110"; wait for 1 ns; assert y = 3; x <= "U10"; wait for 1 ns; assert y = 5; p <= '0'; wait for 1 ns; assert q = 99; p <= '1'; wait for 1 ns; assert q = 99; p <= 'X'; wait for 1 ns; assert q = 3; p <= 'U'; wait for 1 ns; assert q = 3; r <= "010"; wait for 1 ns; assert s = 6; r <= "111"; wait for 1 ns; assert s = 1; wait; end process; p3: process (p) is begin q <= 0; case? p is when '0' to '1' => q <= 99; when '-' => q <= 3; end case?; end process; p4: process (r) is begin s <= 0; case? r is when "111" => s <= 1; when "000" => s <= 2; when others => s <= 6; end case?; end process; end architecture; nvc-r1.17.1/test/regress/case13.vhd000066400000000000000000000013461504111170000167560ustar00rootroot00000000000000entity case13 is end entity; architecture test of case13 is function get_bits (n : natural; b : bit) return bit_vector is variable v : bit_vector(1 to n); begin v := (others => b); return v; end function; signal n : natural := 3; signal b : bit; begin p1: process (n, b) is begin case get_bits(n, b) is when "111" => report "ones"; when "000" => report "zeros"; when others => assert false; end case; end process; stim: process is begin b <= '1'; wait for 0 ns; n <= 5; wait for 1 ns; assert false report "should not reach here!"; wait; end process; end architecture; nvc-r1.17.1/test/regress/case14.vhd000066400000000000000000000030121504111170000167470ustar00rootroot00000000000000package my_package is type slv_1_t is array (natural range <>) of bit_vector; type slv_2_t is array (natural range <>,natural range <>) of bit_vector; subtype my_mat_t is slv_2_t(0 to 4-1,0 to 4-1)(8-1 downto 0); function my_function_f(arg0 : my_mat_t; constant arg2 : natural range 0 to 4-1) return slv_2_t; end package my_package; package body my_package is function my_function_f(arg0 : my_mat_t; constant arg2 : natural range 0 to 4-1) return slv_2_t is variable retval : arg0'subtype; variable my_var_v : slv_1_t(0 to 4-1)(8-1+3 downto 0); begin L1: for indI in retval'range(1) loop L2: for indJ in retval'range(2) loop case indJ=arg2 is when false => null; when true => L3: for indK in 8 to 10 loop -- Crash here due to control flow in case expression case my_var_v(indI)(indK downto indK) is when B"0" => report "zero"; when B"1" => report "one"; when others => NULL; end case; end loop; when others => NULL; end case; end loop; end loop; return retval; end function my_function_f; end package body; ------------------------------------------------------------------------------- entity case14 is end entity; use work.my_package.all; architecture test of case14 is begin p1: process is variable v : my_mat_t; begin wait for 1 ns; assert my_function_f(v, 0) = v; wait; end process; end architecture; nvc-r1.17.1/test/regress/case15.vhd000066400000000000000000000017351504111170000167620ustar00rootroot00000000000000entity sub is generic (g : bit_vector); port (o : out integer); end entity; architecture test of sub is begin gg: case g generate when "101" => o <= 1; when "100" => o <= 2; when "001" => o <= 3; when others => assert false report "invalid G" severity failure; end generate; end architecture; ------------------------------------------------------------------------------- entity case15 is end entity; architecture test of case15 is signal o1, o2, o3 : integer; begin u1: entity work.sub generic map ( "101" ) port map ( o1 ); u2: entity work.sub generic map ( "100" ) port map ( o2 ); u3: entity work.sub generic map ( "001" ) port map ( o3 ); check: process is begin wait for 1 ns; assert o1 = 1; assert o2 = 2; assert o3 = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/case2.vhd000066400000000000000000000027551504111170000167010ustar00rootroot00000000000000entity case2 is end entity; architecture test of case2 is function toint4(b : bit_vector(3 downto 0)) return integer is begin case b is when X"0" => return 0; when X"1" => return 1; when X"2" => return 2; when X"3" => return 3; when X"4" => return 4; when X"5" => return 5; when X"6" => return 6; when X"7" => return 7; when X"8" => return 8; when X"9" => return 9; when X"a" => return 10; when X"b" => return 11; when X"c" => return 12; when X"d" => return 13; when X"e" => return 14; when X"f" => return 15; end case; end function; function toint3(b : bit_vector(3 downto 0)) return integer is begin case b is when X"0" => return 0; when X"1" => return 1; when X"2" => return 2; when X"3" => return 3; when X"4" => return 4; when X"5" => return 5; when X"6" => return 6; when X"7" => return 7; when others => return -1; end case; end function; begin process is variable b : bit_vector(3 downto 0); begin assert toint4(X"4") = 4; b := X"a"; assert toint4(b) = 10; assert toint4(X"f") = 15; assert toint3(X"5") = 5; assert toint3(X"c") = -1; wait; end process; end architecture; nvc-r1.17.1/test/regress/case3.vhd000066400000000000000000000023171504111170000166740ustar00rootroot00000000000000entity case3 is end entity; architecture test of case3 is signal x : bit_vector(3 downto 0); signal y, z, q : integer; begin decode_y: with x select y <= 0 when X"0", 1 when X"1", 2 when X"2", 3 when X"3", 4 when X"4", 5 when X"5", 6 when X"6", 7 when X"7", 8 when X"8", 9 when X"9", 10 when X"a", 11 when X"b", 12 when X"c", 13 when X"d", 14 when X"e", 15 when X"f"; decode_z: with x(3 downto 0) select z <= 0 when X"0", 1 when X"1", 2 when X"2", 3 when X"3", 4 when X"4", 5 when X"5", 6 when X"6", 7 when X"7", 8 when X"8", 9 when X"9", 10 when X"a", 11 when X"b", 12 when X"c", 13 when X"d", 14 when X"e", 15 when X"f"; stim: process is begin wait for 0 ns; assert y = 0; assert z = 0; x <= X"4"; wait for 1 ns; assert y = 4; assert y = 4; x <= X"f"; wait for 1 ns; assert y = 15; assert z = 15; wait; end process; end architecture; nvc-r1.17.1/test/regress/case4.vhd000066400000000000000000000017141504111170000166750ustar00rootroot00000000000000entity case4 is end entity; architecture test of case4 is constant c1 : bit_vector(7 downto 0) := X"ab"; constant c2 : bit_vector(7 downto 0) := X"62"; signal s : bit_vector(7 downto 0); signal x, y : natural; begin process (s) is begin case s is when c1 => x <= x + 1; when c2 | X"50" => y <= y + 1; when others => null; end case; end process; process is variable v : bit_vector(1 to 6); begin s <= c1; wait for 1 ns; s <= c2; wait for 1 ns; s <= X"63"; wait for 1 ns; s <= X"50"; wait for 1 ns; assert x = 1; assert y = 2; v := "000100"; case v is when "000100" => null; when others => assert false; end case; wait; end process; end architecture; nvc-r1.17.1/test/regress/case5.vhd000066400000000000000000000011211504111170000166660ustar00rootroot00000000000000entity case5 is end entity; architecture test of case5 is begin process type modcount is range 0 to 7; variable a: modcount := 5; constant b: natural := 4; variable c: natural; begin case modcount(integer(a) + b) is when 0 | 1 | 2 | 3 | 4 => c := c + 1; when 5 | 6 | 7 => c := c + 42; end case; report "integer(a) + b = " & integer'image(natural'VAL(integer(a)+b)); report "c = " & natural'image(natural'VAL(c)); wait; end process; end architecture; nvc-r1.17.1/test/regress/case6.vhd000066400000000000000000000011531504111170000166740ustar00rootroot00000000000000entity case6 is end entity; architecture test of case6 is signal x, y : integer; begin process (x) is begin case x is when 1 to 5 => y <= 1; when 6 => y <= 2; when 7 to 10 => y <= 3; when others => y <= 4; end case; end process; process is begin wait for 1 ns; assert y = 4; x <= 2; wait for 1 ns; assert y = 1; x <= 10; wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/case7.vhd000066400000000000000000000021631504111170000166770ustar00rootroot00000000000000entity case7 is end entity; architecture test of case7 is constant C1 : bit_vector(3 downto 0) := X"1"; constant C2 : bit_vector(3 downto 0) := X"2"; signal x : bit_vector(7 downto 0); signal y : integer; begin process (x) is begin case x is when C1 & X"0" => y <= 5; when C1 & X"8" => y <= 6; when C2 & X"0" => y <= 10; when (C2, X"5") => y <= 11; when (7 downto 4 => C1, 3 downto 0 => C2) => y <= 12; when others => y <= 0; end case; end process; process is begin x <= X"10"; wait for 1 ns; assert y = 5; x <= X"18"; wait for 1 ns; assert y = 6; x <= X"20"; wait for 1 ns; assert y = 10; x <= X"21"; wait for 1 ns; assert y = 0; x <= X"25"; wait for 1 ns; assert y = 11; x <= X"12"; wait for 1 ns; assert y = 12; wait; end process; end architecture; nvc-r1.17.1/test/regress/case8.vhd000066400000000000000000000036751504111170000167110ustar00rootroot00000000000000entity case8 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of case8 is function toint32(b : std_logic_vector(31 downto 0)) return integer is begin -- This uses a non-exact case map as 4*32 > 64 case b is when X"00000000" => return 0; when X"00000100" => return 1; when X"00000101" => return 2; when X"00000011" => return 3; when X"00001001" => return 4; when X"00004141" => return 5; when X"00002521" => return 6; when X"10005211" => return 7; when X"ffff0001" => return 8; when X"ffff1000" => return 9; when X"ffff52af" => return 10; when X"ffffffff" => return 11; when X"ffffabcd" => return 12; when X"ffffabed" => return 13; when X"ffff1415" => return 14; when X"ffff5252" => return 15; -- These two have hash collisions when "LHH-HWUL-LHZ0UHH01WXXWXUUZX-WXUU" => return 555; when "0X0L0WWUHLX0Z1Z-L---L-LXZ0UHZ-0Z" => return 666; when others => return -1; end case; end function; begin process is variable b : std_logic_vector(31 downto 0); begin assert toint32(X"00000000") = 0; b := X"00004141"; assert toint32(b) = 5; b := X"00001001"; assert toint32(b) = 4; b := X"00000101"; assert toint32(b) = 2; b := X"abab1101"; assert toint32(b) = -1; b := X"ffff52af"; assert toint32(b) = 10; b := X"ffff52ae"; assert toint32(b) = -1; -- The following three cases all hash to the same value b := "LHH-HWUL-LHZ0UHH01WXXWXUUZX-WXUU"; assert toint32(b) = 555; b := "0X0L0WWUHLX0Z1Z-L---L-LXZ0UHZ-0Z"; assert toint32(b) = 666; b := "Z-LXHW0XH-0W1111ZXWW1XLLZULX-HU1"; assert toint32(b) = -1; wait; end process; end architecture; nvc-r1.17.1/test/regress/case9.vhd000066400000000000000000000013701504111170000167000ustar00rootroot00000000000000entity case9 is end entity; architecture test of case9 is type rec is record b : bit_vector(1 to 3); end record; signal x : rec; signal y : integer; begin p1: process (x) is begin case x.b is when "100" => y <= 1; when "101" => y <= 2; when "111" => y <= 3; when others => y <= -1; end case; end process; p2: process is begin wait for 0 ns; assert y = -1; x <= ( b => "100" ); wait for 1 ns; assert y = 1; x <= ( b => "101" ); wait for 1 ns; assert y = 2; x <= ( b => "111" ); wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/cmdline1.sh000066400000000000000000000004011504111170000172130ustar00rootroot00000000000000set -xe pwd which nvc nvc --work=foolib --init [ -f foolib/_NVC_LIB ] || (echo "missing _NVC_LIB marker"; exit 1) [ -f foolib/_index ] || (echo "missing _index"; exit 1) if nvc --init foo bar; then echo "missing error for extra arguments" exit 1 fi nvc-r1.17.1/test/regress/cmdline11.sh000066400000000000000000000001311504111170000172740ustar00rootroot00000000000000set -xe pwd which nvc ! nvc -e - 2>err grep "'-' is not a valid design unit name" err nvc-r1.17.1/test/regress/cmdline12.sh000066400000000000000000000001361504111170000173020ustar00rootroot00000000000000set -xe pwd which nvc nvc -a --no-save $TESTDIR/regress/wait1.vhd ! [ -f work/WORK.WAIT1 ] nvc-r1.17.1/test/regress/cmdline13.sh000066400000000000000000000011231504111170000173000ustar00rootroot00000000000000set -xe pwd which nvc cat >file1.v <file2.v <expect.v < 'X'); x <= to_integer(y); end architecture; EOF nvc --ieee-warnings=on -e cmdline14 --jit --no-save -r cmdline14 2>err grep "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0" err nvc --ieee-warnings=off -e cmdline14 --jit --no-save -r cmdline14 2>err ! grep "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0" err nvc-r1.17.1/test/regress/cmdline15.sh000066400000000000000000000002041504111170000173010ustar00rootroot00000000000000set -xe nvc -a $TESTDIR/regress/tcl1.vhd -e tcl1 nvc --do tcl1 $TESTDIR/regress/tcl1.tcl nvc -i tcl1 < $TESTDIR/regress/tcl1.tcl nvc-r1.17.1/test/regress/cmdline16.sh000066400000000000000000000010231504111170000173020ustar00rootroot00000000000000set -xe nvc --std=2019 -a - </dev/null >msgs; then echo "expected failure" exit 1 fi if ! grep "Error" msgs ; then echo "error messages not printed to stdout" exit 1 fi nvc-r1.17.1/test/regress/cmdline4.sh000066400000000000000000000007331504111170000172260ustar00rootroot00000000000000set -xe pwd which nvc rm -rf tmpwork nvc --work=tmpwork --std=2008 -a - <out diff -u - out <err ! nvc -r -x 2>>err ! nvc -r -w --format 2>>err cat err diff -u - err <compile_list.txt <out; then echo "expected failure" exit 1 fi grep -- '--stop-delta argument must be greater than zero' out || exit 1 nvc -r signal1 --stop-delta=1000000 2>out grep -- 'the maxmimum number of supported delta cycles is 65535' out || exit 1 nvc-r1.17.1/test/regress/cmdline9.sh000066400000000000000000000010241504111170000172250ustar00rootroot00000000000000set -xe nvc -a - < 1 ns); CONSTANT UnitDelay01ZX : VitalDelayType01ZX := (others => 1 ns); end package; ------------------------------------------------------------------------------- LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; USE IEEE.vital_timing.ALL; use work.pack.all; -------------------------------------------------------------------------------- -- ENTITY DECLARATION -------------------------------------------------------------------------------- ENTITY sram1k8 IS GENERIC ( -- tipd delays: interconnect path delays tipd_OENeg : VitalDelayType01 := VitalZeroDelay01; tipd_WENeg : VitalDelayType01 := VitalZeroDelay01; tipd_CENeg : VitalDelayType01 := VitalZeroDelay01; tipd_CE : VitalDelayType01 := VitalZeroDelay01; tipd_D0 : VitalDelayType01 := VitalZeroDelay01; tipd_D1 : VitalDelayType01 := VitalZeroDelay01; tipd_D2 : VitalDelayType01 := VitalZeroDelay01; tipd_D3 : VitalDelayType01 := VitalZeroDelay01; tipd_D4 : VitalDelayType01 := VitalZeroDelay01; tipd_D5 : VitalDelayType01 := VitalZeroDelay01; tipd_D6 : VitalDelayType01 := VitalZeroDelay01; tipd_D7 : VitalDelayType01 := VitalZeroDelay01; tipd_A0 : VitalDelayType01 := VitalZeroDelay01; tipd_A1 : VitalDelayType01 := VitalZeroDelay01; tipd_A2 : VitalDelayType01 := VitalZeroDelay01; tipd_A3 : VitalDelayType01 := VitalZeroDelay01; tipd_A4 : VitalDelayType01 := VitalZeroDelay01; tipd_A5 : VitalDelayType01 := VitalZeroDelay01; tipd_A6 : VitalDelayType01 := VitalZeroDelay01; tipd_A7 : VitalDelayType01 := VitalZeroDelay01; tipd_A8 : VitalDelayType01 := VitalZeroDelay01; tipd_A9 : VitalDelayType01 := VitalZeroDelay01; -- tpd delays tpd_OENeg_D0 : VitalDelayType01Z := UnitDelay01Z; tpd_CENeg_D0 : VitalDelayType01Z := UnitDelay01Z; tpd_A0_D0 : VitalDelayType01 := UnitDelay01; -- tpw values: pulse widths tpw_WENeg_negedge : VitalDelayType := UnitDelay; tpw_WENeg_posedge : VitalDelayType := UnitDelay; -- tsetup values: setup times tsetup_D0_WENeg : VitalDelayType := UnitDelay; tsetup_D0_CENeg : VitalDelayType := UnitDelay; -- thold values: hold times thold_D0_WENeg : VitalDelayType := UnitDelay; thold_D0_CENeg : VitalDelayType := UnitDelay; -- generic control parameters InstancePath : STRING := DefaultInstancePath; TimingChecksOn : BOOLEAN := DefaultTimingChecks; MsgOn : BOOLEAN := DefaultMsgOn; XOn : BOOLEAN := DefaultXOn; SeverityMode : SEVERITY_LEVEL := WARNING; -- For FMF SDF technology file usage TimingModel : STRING := DefaultTimingModel ); PORT ( A0 : IN std_logic := 'X'; A1 : IN std_logic := 'X'; A2 : IN std_logic := 'X'; A3 : IN std_logic := 'X'; A4 : IN std_logic := 'X'; A5 : IN std_logic := 'X'; A6 : IN std_logic := 'X'; A7 : IN std_logic := 'X'; A8 : IN std_logic := 'X'; A9 : IN std_logic := 'X'; D0 : INOUT std_logic := 'X'; D1 : INOUT std_logic := 'X'; D2 : INOUT std_logic := 'X'; D3 : INOUT std_logic := 'X'; D4 : INOUT std_logic := 'X'; D5 : INOUT std_logic := 'X'; D6 : INOUT std_logic := 'X'; D7 : INOUT std_logic := 'X'; OENeg : IN std_logic := 'X'; WENeg : IN std_logic := 'X'; CENeg : IN std_logic := 'X'; CE : IN std_logic := 'X' ); ATTRIBUTE VITAL_LEVEL0 of sram1k8 : ENTITY IS TRUE; END sram1k8; -------------------------------------------------------------------------------- -- ARCHITECTURE DECLARATION -------------------------------------------------------------------------------- ARCHITECTURE vhdl_behavioral of sram1k8 IS BEGIN check: process is begin wait for 1 ns; assert instancepath = "*"; assert tipd_D7 = VitalZeroDelay01; wait; end process; END vhdl_behavioral; ------------------------------------------------------------------------------- LIBRARY IEEE; USE IEEE.std_logic_1164.ALL; USE IEEE.VITAL_timing.ALL; use work.pack.all; ENTITY comp3 IS END; ARCHITECTURE test_1 of comp3 IS COMPONENT sram1k8 GENERIC ( -- tipd delays: interconnect path delays tipd_OENeg : VitalDelayType01 := VitalZeroDelay01; tipd_WENeg : VitalDelayType01 := VitalZeroDelay01; tipd_CENeg : VitalDelayType01 := (2 ns, 2 ns); tipd_CE : VitalDelayType01 := VitalZeroDelay01; tipd_D0 : VitalDelayType01 := VitalZeroDelay01; tipd_A0 : VitalDelayType01 := VitalZeroDelay01; tipd_A1 : VitalDelayType01 := VitalZeroDelay01; tipd_A2 : VitalDelayType01 := VitalZeroDelay01; tipd_A3 : VitalDelayType01 := VitalZeroDelay01; tipd_A4 : VitalDelayType01 := VitalZeroDelay01; tipd_A5 : VitalDelayType01 := VitalZeroDelay01; tipd_A6 : VitalDelayType01 := VitalZeroDelay01; tipd_A7 : VitalDelayType01 := VitalZeroDelay01; tipd_A8 : VitalDelayType01 := VitalZeroDelay01; tipd_A9 : VitalDelayType01 := VitalZeroDelay01; -- tpd delays tpd_OENeg_D0 : VitalDelayType01Z := UnitDelay01Z; tpd_CENeg_D0 : VitalDelayType01Z := UnitDelay01Z; tpd_A0_D0 : VitalDelayType01 := UnitDelay01; -- tpw values: pulse widths tpw_WENeg_negedge : VitalDelayType := UnitDelay; tpw_WENeg_posedge : VitalDelayType := UnitDelay; -- tsetup values: setup times tsetup_D0_WENeg : VitalDelayType := UnitDelay; tsetup_D0_CENeg : VitalDelayType := UnitDelay; -- thold values: hold times thold_D0_WENeg : VitalDelayType := UnitDelay; thold_D0_CENeg : VitalDelayType := UnitDelay; -- generic control parameters InstancePath : STRING := DefaultInstancePath; TimingChecksOn : BOOLEAN := DefaultTimingChecks; MsgOn : BOOLEAN := DefaultMsgOn; XOn : BOOLEAN := DefaultXOn; SeverityMode : SEVERITY_LEVEL := WARNING; -- For FMF SDF technology file usage TimingModel : STRING := DefaultTimingModel ); PORT ( A0 : IN std_logic := 'X'; A1 : IN std_logic := 'X'; A2 : IN std_logic := 'X'; A3 : IN std_logic := 'X'; A4 : IN std_logic := 'X'; A5 : IN std_logic := 'X'; A6 : IN std_logic := 'X'; A7 : IN std_logic := 'X'; A8 : IN std_logic := 'X'; A9 : IN std_logic := 'X'; D0 : INOUT std_logic := 'X'; D1 : INOUT std_logic := 'X'; D2 : INOUT std_logic := 'X'; D3 : INOUT std_logic := 'X'; D4 : INOUT std_logic := 'X'; D5 : INOUT std_logic := 'X'; D6 : INOUT std_logic := 'X'; D7 : INOUT std_logic := 'X'; OENeg : IN std_logic := 'X'; WENeg : IN std_logic := 'X'; CENeg : IN std_logic := 'X'; CE : IN std_logic := 'X' ); END COMPONENT; for all : sram1k8 use entity WORK.sram1k8(VHDL_BEHAVIORAL); SIGNAL T_CLKIN : std_logic := 'X'; SIGNAL T_CLKOUT2 : std_logic := 'X'; SIGNAL T_CLKOUT3 : std_logic := 'X'; SIGNAL T_CLKMODE0 : std_logic := 'X'; SIGNAL T_TMS : std_logic := 'X'; SIGNAL T_TDO : std_logic := 'X'; SIGNAL T_TDI : std_logic := 'X'; SIGNAL T_TCK : std_logic := 'X'; SIGNAL T_TRSTNeg : std_logic := 'X'; SIGNAL T_EMU5 : std_logic := 'X'; SIGNAL T_EMU4 : std_logic := 'X'; SIGNAL T_EMU3 : std_logic := 'X'; SIGNAL T_EMU2 : std_logic := 'X'; SIGNAL T_HCNTL1 : std_logic := 'H'; SIGNAL T_HCNTL0 : std_logic := 'H'; SIGNAL T_HHWIL : std_logic := 'Z'; SIGNAL T_HR : std_logic := 'Z'; SIGNAL T_HASNeg : std_logic := 'H'; SIGNAL T_HCSNeg : std_logic := 'H'; SIGNAL T_HDS1Neg : std_logic := 'H'; SIGNAL T_HDS2Neg : std_logic := 'H'; SIGNAL T_HRDYNeg : std_logic := 'Z'; SIGNAL T_HD : std_logic_vector(15 downto 0) := (others => 'Z'); SIGNAL T_CE0Neg : std_logic := 'X'; SIGNAL T_BE0Neg : std_logic := 'X'; SIGNAL T_BE1Neg : std_logic := 'X'; SIGNAL T_HOLDANeg : std_logic := 'X'; SIGNAL T_HOLDNeg : std_logic := 'X'; SIGNAL T_BUSREQ : std_logic := 'X'; SIGNAL T_ECLKIN : std_logic := 'X'; SIGNAL T_ECLKOUT : std_logic := 'X'; SIGNAL T_SDCASNeg : std_logic := 'X'; SIGNAL T_SDRASNeg : std_logic := 'X'; SIGNAL T_SDWENeg : std_logic := 'X'; SIGNAL T_ARDY : std_logic := '1'; SIGNAL T_EA : std_logic_vector(21 downto 2) := (others => 'Z'); SIGNAL T_ED : std_logic_vector(31 downto 0) := (others => 'Z'); SIGNAL T_ROM8 : std_logic := '0'; BEGIN sram_1 : sram1k8 PORT MAP( A0 => T_EA(2), A1 => T_EA(3), A2 => T_EA(4), A3 => T_EA(5), A4 => T_EA(6), A5 => T_EA(7), A6 => T_EA(8), A7 => T_EA(9), A8 => T_EA(10), A9 => T_EA(11), D0 => T_ED(0), D1 => T_ED(1), D2 => T_ED(2), D3 => T_ED(3), D4 => T_ED(4), D5 => T_ED(5), D6 => T_ED(6), D7 => T_ED(7), OENeg => T_SDRASNeg, WENeg => T_SDWENeg, CENeg => T_CE0Neg, CE => T_ROM8 ); END test_1; nvc-r1.17.1/test/regress/concat1.vhd000066400000000000000000000012701504111170000172230ustar00rootroot00000000000000entity concat1 is end entity; architecture test of concat1 is type int_array is array (integer range <>) of integer; begin -- See LRM 93 section 9.2.5 process is variable x : int_array(1 to 5); variable y : int_array(1 to 2); variable z : int_array(1 to 3); variable s : string(1 to 5); begin y := (1, 2); z := (3, 4, 5); x := y & z; assert x = (1, 2, 3, 4, 5); s := "ab" & "cde"; assert s = "abcde"; z := 0 & y; assert z = (0, 1, 2); z := y & 3; assert z = (1, 2, 3); y := 8 & 9; assert y = (8, 9); wait; end process; end architecture; nvc-r1.17.1/test/regress/concat2.vhd000066400000000000000000000014231504111170000172240ustar00rootroot00000000000000entity concat2 is end entity; architecture test of concat2 is type int_array is array (integer range <>) of integer; -- Dummy argument is to prevent constant folding; function get_array(dummy : in integer) return int_array is begin return (1, 2, 3); end function; function pad(a : in int_array; dummy : in integer) return int_array is begin return (0, 0) & a; end function; begin process is variable x : int_array(0 to 3); variable d : integer; begin x := get_array(d) & ( 0 => 4 ); assert x = (1, 2, 3, 4); x := get_array(d) & ( 6 => 8 ); assert x = (1, 2, 3, 8); x := pad((1, 2), d); assert x = (0, 0, 1, 2); wait; end process; end architecture; nvc-r1.17.1/test/regress/concat3.vhd000066400000000000000000000041541504111170000172310ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity shift_reg is generic ( WIDTH : positive ); port ( clk : in std_logic; reset : in std_logic; shift : in std_logic; din : in std_logic; dout : out std_logic ); end entity; architecture rtl of shift_reg is signal shift_r : std_logic_vector(WIDTH - 1 downto 0); begin shift_p: process (clk) is begin if rising_edge(clk) then if reset = '1' then shift_r <= (others => '-'); elsif shift = '1' then shift_r <= shift_r(WIDTH - 2 downto 0) & din; end if; end if; end process; dout <= shift_r(WIDTH - 1); end architecture; ------------------------------------------------------------------------------- entity concat3 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of concat3 is signal clk : std_logic := '1'; signal reset : std_logic := '1'; signal shift : std_logic; signal din : std_logic; signal dout : std_logic; signal running : boolean := true; begin clk <= not clk after 10 ns when running; reset <= '0' after 30 ns; uut: entity work.shift_reg generic map ( WIDTH => 4 ) port map ( clk => clk, reset => reset, shift => shift, din => din, dout => dout ); process is begin shift <= '0'; wait until reset = '0'; wait until falling_edge(clk); shift <= '1'; din <= '0'; wait until falling_edge(clk); wait until falling_edge(clk); wait until falling_edge(clk); wait until falling_edge(clk); assert dout = '0'; din <= '1'; wait until falling_edge(clk); assert dout = '0'; wait until falling_edge(clk); assert dout = '0'; wait until falling_edge(clk); assert dout = '0'; wait until falling_edge(clk); assert dout = '1'; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/concat4.vhd000066400000000000000000000006331504111170000172300ustar00rootroot00000000000000entity concat4 is end entity; architecture test of concat4 is type mem_type is array (2 downto 0) of bit_vector(7 downto 0); begin process is variable m : mem_type := ( X"03", X"02", X"01" ); variable b : bit_vector(7 downto 0); begin b := X"ff"; m := m(1 downto 0) & b; assert m = ( X"02", X"01", X"ff" ); wait; end process; end architecture; nvc-r1.17.1/test/regress/concat5.vhd000066400000000000000000000011671504111170000172340ustar00rootroot00000000000000entity concat5 is end entity; architecture test of concat5 is function count_as(x : string) return integer is variable r : integer := 0; begin for i in 1 to x'length loop if x(i) = 'a' then r := r + 1; end if; end loop; return r; end function; begin process is variable x : string(1 to 3) := "aba"; begin assert count_as(x & "baa") = 4; assert count_as("baa" & x) = 4; assert count_as("baa" & 'a') = 3; assert count_as(('b', 'a', 'a') & x) = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/concat6.vhd000066400000000000000000000055411504111170000172350ustar00rootroot00000000000000entity concat6 is end entity; architecture test of concat6 is -- Examples from LRM 93 section 7.2.5 type R1 is range 0 to 7; type R2 is range 7 downto 0; type T1 is array (R1 range <>) of Bit; type T2 is array (R2 range <>) of Bit; subtype S1 is T1(R1); subtype S2 is T2(R2); constant K1: S1 := (others => '0'); constant K2: T1 := K1(1 to 3) & K1(3 to 4); -- K2'Left = 0 and K2'Right = 4 constant K3: T1 := K1(5 to 7) & K1(1 to 2); -- K3'Left = 0 and K3'Right = 4 constant K4: T1 := K1(2 to 1) & K1(1 to 2); -- K4'Left = 0 and K4'Right = 1 constant K5: S2 := (others => '0'); constant K6: T2 := K5(3 downto 1) & K5(4 downto 3); -- K6'Left = 7 and K6'Right = 3 constant K7: T2 := K5(7 downto 5) & K5(2 downto 1); -- K7'Left = 7 and K7'Right = 3 constant K8: T2 := K5(1 downto 2) & K5(2 downto 1); -- K8'Left = 7 and K8'Right = 6 function get_left(x : T1) return R1 is begin return x'left; end function; function get_left(x : T2) return R2 is begin return x'left; end function; function get_right(x : T1) return R1 is begin return x'right; end function; function get_right(x : T2) return R2 is begin return x'right; end function; begin main: process is begin assert K2'left = 0 report R1'image(K2'left); assert get_left(K2) = 0 report R1'image(K2'left); assert K2'right = 4 report R1'image(K2'right); assert get_right(K2) = 4 report R1'image(K2'right); assert K2'ascending; assert K3'left = 0 report R1'image(K3'left); assert get_left(K3) = 0 report R1'image(K3'left); assert K3'right = 4 report R1'image(K3'right); assert get_right(K3) = 4 report R1'image(K3'right); assert K3'ascending; assert K4'left = 0 report R1'image(K4'left); assert get_left(K4) = 0 report R1'image(K4'left); assert K4'right = 1 report R1'image(K4'right); assert get_right(K4) = 1 report R1'image(K4'right); assert K4'ascending; assert K6'left = 7 report R2'image(K6'left); assert get_left(K6) = 7 report R2'image(K6'left); assert K6'right = 3 report R2'image(K6'right); assert get_right(K6) = 3 report R2'image(K6'right); assert not K6'ascending; assert K7'left = 7 report R2'image(K7'left); assert get_left(K7) = 7 report R2'image(K7'left); assert K7'right = 3 report R2'image(K7'right); assert get_right(K7) = 3 report R2'image(K7'right); assert not K6'ascending; assert K8'left = 7 report R2'image(K8'left); assert get_left(K8) = 7 report R2'image(K8'left); assert K8'right = 6 report R2'image(K8'right); assert get_right(K8) = 6 report R2'image(K8'right); assert not K6'ascending; wait; end process; end architecture; nvc-r1.17.1/test/regress/concat7.vhd000066400000000000000000000006451504111170000172360ustar00rootroot00000000000000entity concat7 is end entity; architecture test of concat7 is type rec is record f : string; end record; constant c1 : rec := ( f => ('a' & "bc") ); begin p: process is variable v : string(1 to 4); begin report "c1.f = " & c1.f; v := ' ' & c1.f; wait for 1 ns; report v; assert v = " abc"; wait; end process; end architecture; nvc-r1.17.1/test/regress/cond1.vhd000066400000000000000000000012551504111170000167020ustar00rootroot00000000000000entity cond1 is end entity; architecture test of cond1 is signal x : integer := 5; begin process is variable y : integer; begin y := 5; if x = y then report "x = y"; x <= 4; end if; if x = y + 1 then report "x = y + 1" severity failure; else null; report "x /= y + 1"; end if; if x = y - 1 then report "x = y - 1" severity failure; elsif x = y then report "x = y still"; else report "x /= y - 1 and x /= y" severity failure; end if; wait; end process; end architecture; nvc-r1.17.1/test/regress/cond2.vhd000066400000000000000000000012031504111170000166740ustar00rootroot00000000000000entity cond2 is end entity; architecture test of cond2 is signal x, y : integer; begin process is begin x <= 5; y <= 2; wait for 1 ns; if x = 5 then if y = 2 then report "y = 2"; if x = 4 then report "x = 4" severity failure; else report "x /= 4"; end if; else report "y /= 2" severity failure; end if; else report "x /= 5" severity failure; end if; wait; end process; end architecture; nvc-r1.17.1/test/regress/cond3.vhd000066400000000000000000000012351504111170000167020ustar00rootroot00000000000000entity cond3 is end entity; architecture test of cond3 is signal x, y, z : integer := 0; begin x <= y + 1, y + 2 after 2 ns when z > 0 else 0; process is begin wait for 1 ns; assert x = 0; z <= 1; wait for 1 ns; assert x = 1; wait for 2 ns; assert x = 2; y <= 2; z <= 1; wait for 1 ns; assert x = 3; wait for 2 ns; assert x = 4; y <= 5; wait for 1 ns; assert x = 6; wait for 2 ns; assert x = 7; z <= 0; wait for 1 ns; assert x = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/cond4.vhd000066400000000000000000000004771504111170000167120ustar00rootroot00000000000000entity cond4 is end entity; architecture test of cond4 is begin process is begin wait for 1 ns; `if USER_DIRECTIVE = "VALID_VALUE" then wait for 1 ns; `else report "FIRST DIRECTIVE WAS NOT DEFINED OK!" severity failure; `end wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cond5.vhd000066400000000000000000000011371504111170000167050ustar00rootroot00000000000000entity cond5 is end entity; architecture test of cond5 is type rec is record x, y : integer; end record; constant c0 : integer := 10 when cond5'path_name = ":cond5:" else 5; constant c1 : bit_vector(1 to 3) := "101" when cond5'path_name = ":cond5:" else "111"; constant c2 : rec := (1, 2) when cond5'path_name = ":cond5:xxxx" else (5, 6) when cond5'path_name = ":cond5:yyy" else (7, 8); begin p1: process is begin assert c0 = 10; assert c1 = "101"; assert c2 = (7, 8); wait; end process; end architecture; nvc-r1.17.1/test/regress/cond6.vhd000066400000000000000000000006351504111170000167100ustar00rootroot00000000000000entity cond6 is end entity; architecture test of cond6 is begin p1: process is type small_int is range 0 to 1000; variable v : small_int := 5; begin v := 1 when now = 5 ns else unaffected; assert v = 5; wait for 1 ns; v := 5 when now = 0 ns else unaffected when now = 2 ns else 66; assert v = 66; wait; end process; end architecture; nvc-r1.17.1/test/regress/conf1.vhd000066400000000000000000000050041504111170000167000ustar00rootroot00000000000000entity comparison is port ( a : in integer; b : in integer; q : out boolean ); end comparison; architecture rtl of comparison is begin q <= a = b; end architecture; ------------------------------------------------------------------------------- entity comparison_tb is generic ( delay : delay_length ); end entity; architecture sim of comparison_tb is signal a : integer; signal b : integer; signal q : boolean; component comparison port ( a : in integer; b : in integer; q : out boolean ); end component; procedure result(a, b : in integer; q : in boolean) is begin report integer'image(a) & " <=> " & integer'image(b) & " = " & boolean'image(q); end procedure; begin DUT: component comparison port map ( a => a, b => b, q => q ); SEQUENCER_PROC: process begin wait for delay; a <= 4; b <= 2; wait for 1 ns; result(a, b, q); b <= 7; wait for 1 ns; result(a, b, q); wait; end process; end architecture; ------------------------------------------------------------------------------- entity greater_than is port ( a : in integer; b : in integer; q : out boolean ); end greater_than; architecture rtl of greater_than is begin q <= a > b; end architecture; ------------------------------------------------------------------------------- configuration eq of comparison_tb is for sim end for; end configuration; ------------------------------------------------------------------------------- configuration gt of comparison_tb is for sim for DUT : comparison use entity work.greater_than(rtl); end for; end for; end configuration; ------------------------------------------------------------------------------- configuration lt of comparison_tb is for sim for DUT : comparison use entity work.greater_than(rtl) port map ( a => b, b => a, q => q ); end for; end for; end configuration; ------------------------------------------------------------------------------- entity conf1 is end entity; architecture test of conf1 is begin uut1: configuration work.lt generic map ( delay => 0 ns ); uut2: configuration work.gt generic map ( delay => 10 ns ); end architecture; nvc-r1.17.1/test/regress/conf2.vhd000066400000000000000000000046071504111170000167110ustar00rootroot00000000000000entity comparison is port ( a : in integer; b : in integer; q : out boolean ); end comparison; architecture rtl of comparison is begin q <= a = b; end architecture; ------------------------------------------------------------------------------- entity comparison_tb is generic ( delay : delay_length ); end entity; architecture sim of comparison_tb is signal a : integer; signal b : integer; signal q : boolean; component comparison port ( a : in integer; b : in integer; q : out boolean ); end component; procedure result(a, b : in integer; q : in boolean) is begin report integer'image(a) & " <=> " & integer'image(b) & " = " & boolean'image(q); end procedure; begin DUT: component comparison port map ( a, b, q ); SEQUENCER_PROC: process begin wait for delay; a <= 4; b <= 2; wait for 1 ns; result(a, b, q); b <= 7; wait for 1 ns; result(a, b, q); wait; end process; end architecture; ------------------------------------------------------------------------------- entity greater_than is port ( a : in integer; b : in integer; q : out boolean ); end greater_than; architecture rtl of greater_than is begin q <= a > b; end architecture; ------------------------------------------------------------------------------- configuration eq of comparison_tb is for sim end for; end configuration; ------------------------------------------------------------------------------- configuration gt of comparison_tb is for sim for DUT : comparison use entity work.greater_than(rtl); end for; end for; end configuration; ------------------------------------------------------------------------------- configuration lt of comparison_tb is for sim for DUT : comparison use entity work.greater_than(rtl) port map ( b, a, q ); end for; end for; end configuration; ------------------------------------------------------------------------------- entity conf2 is end entity; architecture test of conf2 is begin uut1: configuration work.lt generic map ( delay => 0 ns ); uut2: configuration work.gt generic map ( delay => 10 ns ); end architecture; nvc-r1.17.1/test/regress/conf3.vhd000066400000000000000000000015251504111170000167060ustar00rootroot00000000000000package pack is type my_enum is (A, B, C); end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( x, y : my_enum ); end entity; architecture test of sub is begin testp: process is begin assert x = B; assert y = C; wait; end process; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture arch of top is component comp is end component; begin uut: component comp; end architecture; use work.pack.all; configuration conf3 of top is for arch for all : comp use entity work.sub(test) generic map ( x => B, y => C ); end for; end for; end configuration; nvc-r1.17.1/test/regress/conf4.vhd000066400000000000000000000045421504111170000167110ustar00rootroot00000000000000package pack is type t_nat_vec is array (natural range <>) of natural; function resolved (arg : t_nat_vec) return natural; subtype t_summer is resolved natural; end package; package body pack is function resolved (arg : t_nat_vec) return natural is variable sum : natural := 0; begin for i in arg'range loop sum := sum + arg(i); end loop; return sum; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( g : natural ); port ( p : out natural ); end entity; architecture test of sub is begin p <= g; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity top is end entity; architecture arch of top is component comp is port ( x : out t_summer ); end component; function get_true return boolean is begin return true; end function; signal r : t_summer; begin u1: component comp port map ( r ); g1: for i in 1 to 3 generate u2: component comp port map ( r ); end generate; b1: block is begin u3: component comp port map ( r ); end block; g2: if get_true generate u4: component comp port map ( r ); end generate; check: process is begin wait for 1 ns; assert r = 117; wait; end process; end architecture; use work.pack.all; configuration conf4 of top is for arch for u1 : comp use entity work.sub(test) generic map ( g => 1 ) port map ( p => x ); end for; for g1(1 to 3) -- XXX: bug here with (1 to 2) for u2 : comp use entity work.sub(test) generic map ( g => 2 ) port map ( p => x ); end for; end for; for b1 for u3 : comp use entity work.sub(test) generic map ( g => 10 ) port map ( p => x ); end for; end for; for g2 for u4 : comp use entity work.sub(test) generic map ( g => 100 ) port map ( p => x ); end for; end for; end for; end configuration; nvc-r1.17.1/test/regress/conf5.vhd000066400000000000000000000027751504111170000167200ustar00rootroot00000000000000entity sub is generic ( type t; function "+" (a, b : t) return t is <> ); port ( x, y : in t; z : out t ); end entity; architecture test of sub is begin z <= x + y; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub_r is port ( x : in real; z : out real ); end component; component sub_i is port ( x : in integer; z : out integer ); end component; signal xr, zr : real := 0.0; signal xi, zi : integer := 0; begin u1: sub_r port map ( xr, zr ); u2: sub_i port map ( xi, zi ); check: process is begin xr <= 1.0; wait for 1 ns; assert zr = 2.0; xr <= 5.0; wait for 1 ns; assert zr = 10.0; xi <= 8; wait for 1 ns; assert zi = 16; xi <= 100; wait for 1 ns; assert zi = 200; wait; end process; end architecture; ------------------------------------------------------------------------------- configuration conf5 of top is for test for u1 : sub_r use entity work.sub generic map ( real ) port map ( x => x, y => x, z => z ); end for; for u2 : sub_i use entity work.sub generic map ( integer ) port map ( x => x, y => x, z => z ); end for; end for; end configuration; nvc-r1.17.1/test/regress/const1.vhd000066400000000000000000000007321504111170000171040ustar00rootroot00000000000000entity const1 is end entity; architecture test of const1 is type int_vector is array (integer range <>) of integer; constant c : int_vector(1 to 5) := (1, 2, 3, 4, 5); begin process is variable v : int_vector(1 to 2); variable i : integer; begin i := c(3); assert i = 3; v := c(1 to 2); assert v = (1, 2); v := c(3 to 4); assert v = (3, 4); wait; end process; end architecture; nvc-r1.17.1/test/regress/const10.vhd000066400000000000000000000011511504111170000171600ustar00rootroot00000000000000entity const10 is end entity; architecture test of const10 is shared variable count : integer := 0; impure function get_id return integer is begin count := count + 1; return count; end function; type int_vec is array (natural range <>) of integer; constant list : int_vec(1 to 2) := (get_id, get_id); begin p1: process is begin -- GET_ID should only be called twice assert list(1) = 1; assert list(1) = 1; assert list(2) = 2; assert list(1) = 1; assert list(2) = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/const2.vhd000066400000000000000000000024521504111170000171060ustar00rootroot00000000000000package pack is function foo(x : in integer) return real; end package; package body pack is type real_vector is array (integer range <>) of real; function get_results return real_vector is begin return ( 52.6, 16.7, 1.832, 0.623, 762.236 ); end function; constant results : real_vector := get_results; function foo(x : in integer) return real is begin return results(x); end function; type int_vector is array (integer range <>) of integer; subtype int_vector4 is int_vector(1 to 4); constant blah : int_vector4 := ( 0, 1, 6, 6 ); constant blah2 : int_vector4 := blah; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity const2 is end entity; architecture test of const2 is function get_it return integer is begin return integer(foo(integer'left + 1)); end function; function get_bits return bit_vector is begin return "110101"; end function; constant some_bits : bit_vector := get_bits; constant a_bit : bit := some_bits(2); begin process is begin assert get_it = 17; assert some_bits(some_bits'right) = '1'; assert a_bit = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/const3.vhd000066400000000000000000000004671504111170000171130ustar00rootroot00000000000000entity const3 is end entity; architecture test of const3 is type bit_str_map is array (bit) of string(1 to 4); constant const : bit_str_map := ( "zero", "one " ); begin process is begin report const('0'); report const('1'); wait; end process; end architecture; nvc-r1.17.1/test/regress/const4.vhd000066400000000000000000000010211504111170000170770ustar00rootroot00000000000000entity const4 is end entity; architecture test of const4 is type int2d is array (natural range <>, natural range <>) of integer; constant c : int2d := ( ( 0, 3, 4, 5 ), ( 6, 7, 8, 9 ) ); begin process is begin assert c'length(1) = 2; assert c'length(2) = 4; assert c(0, 0) = 0; assert c(0, 1) = 3; assert c(0, 3) = 5; assert c(1, 0) = 6; assert c(1, 1) = 7; assert c(1, 2) = 8; wait; end process; end architecture; nvc-r1.17.1/test/regress/const5.vhd000066400000000000000000000014441504111170000171110ustar00rootroot00000000000000entity const5 is end entity; architecture test of const5 is subtype byte_t is bit_vector(7 downto 0); type byte_array_t is array (natural range <>) of byte_t; procedure popcount_assert ( value : in byte_t; pop : in integer ) is variable cnt : natural := 0; begin for i in value'range loop if value(i) = '1' then cnt := cnt + 1; end if; end loop; report integer'image(cnt); assert cnt = pop; end procedure; begin stim_p: process is constant COME_ADDRS : byte_array_t := ( X"08", X"10", X"20" ); begin for i in 0 to 2 loop popcount_assert(value => COME_ADDRS(i), pop => 1); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/const6.vhd000066400000000000000000000013671504111170000171160ustar00rootroot00000000000000entity const6 is end entity; architecture test of const6 is function min(x, y : integer) return integer is begin if x > y then return y; else return x; end if; end function; function get_left(x : bit_vector) return bit is constant l : integer := x'left; variable v : bit_vector(1 to x'right); constant m : integer := min(x'length, v'length) + 1; begin report integer'image(m); return x(l); end function; begin process is variable x : bit_vector(3 downto 0) := "1010"; begin wait for 0 ns; -- Prevent constant folding assert get_left(x) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/const7.vhd000066400000000000000000000010451504111170000171100ustar00rootroot00000000000000entity const7 is end entity; architecture test of const7 is function get_bits(x, len : natural) return bit_vector is begin if x = 1 then return bit_vector'(1 to len => '1'); else return bit_vector'(1 to len => '0'); end if; end function; signal x : bit_vector(7 downto 0) := get_bits(1, 8); signal y : bit_vector(3 downto 0) := get_bits(5, 4); begin process is begin assert x = X"ff"; assert y = X"0"; wait; end process; end architecture; nvc-r1.17.1/test/regress/const8.vhd000066400000000000000000000007001504111170000171060ustar00rootroot00000000000000entity const8 is end entity; architecture test of const8 is begin p1: process is variable s : string(1 to 12); begin s := (1 to 11 => "some string", others => NUL); wait for 1 ns; assert s = "some string" & NUL; s := ("foo", "bar", "baz", others => NUL); wait for 1 ns; report s; assert s = "foobarbaz" & NUL & NUL & NUL; wait; end process; end architecture; nvc-r1.17.1/test/regress/const9.vhd000066400000000000000000000003671504111170000171200ustar00rootroot00000000000000entity const9 is constant str : string := const9'path_name; end entity; architecture test of const9 is begin p1: process is begin report str; assert str = ":const9:"; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv1.vhd000066400000000000000000000006401504111170000167210ustar00rootroot00000000000000entity conv1 is end entity; architecture test of conv1 is type my_bit_vector is array (natural range <>) of bit; signal x : bit_vector(7 downto 0); signal y : my_bit_vector(3 downto 0); begin process is begin x <= X"ab"; wait for 1 ns; y <= my_bit_vector(x(3 downto 0)); wait for 1 ns; assert y = X"b"; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv10.vhd000066400000000000000000000010301504111170000167730ustar00rootroot00000000000000entity conv10 is end entity; architecture test of conv10 is begin p1: process is variable i : integer_vector(1 to 3); variable r : real_vector(1 to 3); begin i := (1, 2, 3); r := real_vector(i); assert r = (1.0, 2.0, 3.0) severity failure; r := (4.2, 5.9, 7.1); i := integer_vector(r); assert i = (4, 6, 7) severity failure; r := (1.0, real'left, 5.3); i := integer_vector(r); -- Range error wait; end process; end architecture; nvc-r1.17.1/test/regress/conv11.vhd000066400000000000000000000021561504111170000170060ustar00rootroot00000000000000entity conv11 is end entity; architecture test of conv11 is type t_int is record x, y : integer; end record; type t_real is record x, y : real; end record; function to_int (r : t_real) return t_int is begin report "(" & real'image(r.x) & ", " & real'image(r.y) & ")"; return (integer(r.x), integer(r.y)); end function; signal si : t_int := (0, 0); signal sr : t_real := (0.0, 0.0); begin b: block is port ( i : in t_int; o : out t_real := (0.0, 0.0) ); port map ( i => to_int(sr), to_int(o) => si ); begin check_inner: process is begin assert i = (0, 0); wait for 0 ns; assert i = (1, 2); o <= (5.6, 7.2); wait; end process; end block; check_outer: process is begin assert si = (0, 0); assert sr = (0.0, 0.0); sr <= (1.0, 2.0); wait for 0 ns; assert si = (0, 0); wait for 0 ns; assert si = (6, 7); wait; end process; end architecture; nvc-r1.17.1/test/regress/conv12.vhd000066400000000000000000000017551504111170000170130ustar00rootroot00000000000000entity conv12 is end entity; architecture test of conv12 is function half (x : integer) return integer is begin return x / 2; end function; function double (x : integer) return integer is begin return x * 2; end function; signal s : integer := 0; begin b1: block is port ( p : in integer ); port map ( p => half(s) ); begin check: process is begin assert p = 0; wait for 1 ns; assert p = 0; wait for 2 ns; assert p = 5; wait; end process; end block; b2: block is port ( p : in integer ); port map ( p => double(s) ); begin check: process is begin assert p = 0; wait for 1 ns; assert p = 2; wait for 2 ns; assert p = 20; wait; end process; end block; s <= 1 after 1 ns, 10 after 2 ns; end architecture; nvc-r1.17.1/test/regress/conv13.vhd000066400000000000000000000011651504111170000170070ustar00rootroot00000000000000entity conv13 is end entity; architecture test of conv13 is signal s : integer := 0; begin b1: block is port ( p : inout real := 0.0 ); port map ( integer(p) => real(s) ); begin inner: process is begin p <= 1.0; wait for 0 ns; assert p = 1.0; p <= 1.5; wait for 0 ns; assert p = 2.0; wait; end process; end block; outer: process is begin wait for 0 ns; assert s = 1; wait for 0 ns; assert s = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv14.vhd000066400000000000000000000015611504111170000170100ustar00rootroot00000000000000entity conv14 is end entity; architecture test of conv14 is type t_bv_array is array (natural range <>) of bit_vector; function "not" (x : t_bv_array) return t_bv_array is variable r : x'subtype; begin for i in x'range loop for j in x(x'left)'range loop r(i)(j) := not x(i)(j); end loop; end loop; return r; end function; signal s : t_bv_array(1 to 2)(1 to 2); begin b: block is port ( p : t_bv_array(1 to 2)(1 to 2) ); port map ( p => "not"(s) ); begin check: process is begin assert p = ("11", "11"); wait for 0 ns; assert p = ("01", "10"); wait; end process; end block; stim: process is begin s <= ("10", "01"); wait; end process; end architecture; nvc-r1.17.1/test/regress/conv15.vhd000066400000000000000000000014101504111170000170020ustar00rootroot00000000000000entity conv15 is end entity; architecture test of conv15 is type uint8 is range 0 to 255; signal s : uint8; signal t : bit; function to_bit (x : uint8) return bit is begin assert uint8'pos(x) >= 0; if x > 127 then return '1'; else return '0'; end if; end function; begin b: block is port ( i : in bit; o : out bit ); port map ( i => to_bit(s), o => t ); begin o <= i; end block; stim: process is begin s <= 200; wait for 1 ns; assert t = '1'; s <= 100; wait for 1 ns; assert t = '0'; s <= 255; wait for 1 ns; assert t = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv16.vhd000066400000000000000000000024711504111170000170130ustar00rootroot00000000000000package pack is type t_conf is record width : natural; end record; function init return t_conf; end package; package body pack is function init return t_conf is begin return (width => 5); end function; end package body; ------------------------------------------------------------------------------- entity sub is generic ( g : integer ); end entity; use work.pack.all; architecture test of sub is signal s : bit_vector(1 to g) := (others => '1'); constant conf : t_conf := init; type t_int_array is array (1 to conf.width) of integer; type t_real_array is array (1 to conf.width) of real; signal t : t_int_array := (others => 0); begin t <= (3 => 1, others => 5) after 1 ns; b: block is port ( i : in t_real_array ); port map ( i => t_real_array(t) ); begin check: process is begin assert i(3) = 0.0; wait for 1 ns; assert i(3) = 1.0; wait; end process; end block; end architecture; ------------------------------------------------------------------------------- entity conv16 is end entity; architecture test of conv16 is begin u1: entity work.sub generic map ( 10 ); u2: entity work.sub generic map ( 100 ); end architecture; nvc-r1.17.1/test/regress/conv17.vhd000066400000000000000000000017711504111170000170160ustar00rootroot00000000000000entity conv17 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of conv17 is function to_logic (x : real) return std_logic is begin if x <= -1.0 then return '0'; elsif x >= 1.0 then return '1'; else return 'Z'; end if; end function; signal s : std_logic := 'Z'; begin b1: block is port (p : out real := 0.0); port map (to_logic(p) => s); begin p <= 5.0 after 1 ns, 0.0 after 4 ns; end block; b2: block is port (p : out real := 0.0); port map (to_logic(p) => s); begin p <= 7.0 after 2 ns, -4.0 after 3 ns, -12.5 after 4 ns; end block; check: process is begin assert s = 'Z'; wait for 1 ns; assert s = '1'; wait for 1 ns; assert s = '1'; wait for 1 ns; assert s = 'X'; wait for 1 ns; assert s = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv18.vhd000066400000000000000000000022761504111170000170200ustar00rootroot00000000000000entity conv18 is end entity; architecture test of conv18 is function count_ones(x : bit_vector) return natural is variable sum : natural := 0; begin for i in x'range loop if x(i) = '1' then sum := sum + 1; end if; end loop; return sum; end function; signal s : natural; begin b: block is port (p : out bit_vector(7 downto 0)); port map (count_ones(p) => s); begin stim: process is begin p <= X"14" after 1 ns; wait for 1 ns; p <= X"ff" after 2 ns; wait for 2 ns; p(5) <= '1'; wait; end process; end block; check: process is begin wait for 1 ns; assert s'active; assert s'last_active = 0 ns; assert s = 2; wait for 1 ns; assert not s'active; assert s'last_active = 1 ns; wait for 1 ns; assert s'active; assert s'last_active = 0 ns; assert s = 8; wait for 0 ns; assert s'active; assert s'last_active = 0 ns; assert s = 8; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv19.vhd000066400000000000000000000021031504111170000170060ustar00rootroot00000000000000entity conv19 is end entity; architecture test of conv19 is type t_rec is record x : integer; y : bit; end record; function popcount (v : bit_vector) return natural is variable result : natural; begin for i in v'range loop if v(i) = '1' then result := result + 1; end if; end loop; return result; end function; signal s : bit_vector(1 to 3); signal t : bit; begin b: block is port ( r : t_rec ); port map ( r.x => popcount(s), r.y => inertial t ); begin check: process is begin assert r = (0, '0'); wait for 0 ns; assert r = (2, '0'); wait for 0 ns; assert r = (2, '1'); wait for 1 ns; assert r = (1, '1'); wait; end process; end block; stim: process is begin s <= "101"; t <= '1'; s <= transport "001" after 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv2.vhd000066400000000000000000000054301504111170000167240ustar00rootroot00000000000000entity sub is port ( o1 : out bit; o2 : out real := 0.0; i1 : in bit ); end entity; architecture test of sub is begin p1: process is begin o1 <= '1'; o2 <= 1.0; wait for 1 ns; o1 <= '0'; o2 <= 0.0; assert i1 = '1'; wait; end process; end architecture; ------------------------------------------------------------------------------- entity conv2 is end entity; architecture test of conv2 is type t is (zero, one); signal x : real; signal y : bit; signal z : integer := 0; signal p : real; signal q : real := 0.0; signal r : t; type tmap_t is array (t) of bit; constant tmap : tmap_t := (zero => '0', one => '1'); function table_to_bit(x : t) return bit is begin report "table_to_bit " & t'image(x); return tmap(x); end function; function bit_to_real(b : bit) return real is begin report "bit_to_real " & bit'image(b); if b = '1' then return 1.0; else return 0.0; end if; end function; function real_to_bit(r : real) return bit is begin report "real_to_bit " & real'image(r); if r = 1.0 then return '1'; elsif r = 0.0 then return '0'; else report "invalid real value " & real'image(r) severity failure; end if; end function; function bit_to_int(b : bit) return integer is begin report "bit_to_int " & bit'image(b); if b = '1' then return integer'high; else return integer'low; end if; end function; function real_to_limit(r : real) return real is begin report "real_to_limit " & real'image(r); if r = 1.0 then return real'high; elsif r = 0.0 then return real'low; else report "invalid real value " & real'image(r) severity failure; end if; end function; begin uut1: entity work.sub port map ( bit_to_real(o1) => x, real_to_bit(o2) => y, i1 => real_to_bit(q) ); uut2: entity work.sub port map ( bit_to_int(o1) => z, real_to_limit(o2) => p, i1 => table_to_bit(r) ); p2: process is begin assert x = 0.0; assert y = '0'; assert z = integer'low; assert p = real'low; wait for 0 ns; q <= 1.0; r <= one; assert x = 1.0; assert y = '1'; assert z = integer'high; assert p = real'high; wait for 2 ns; assert x = 0.0; assert y = '0'; assert z = integer'low; assert p = real'low; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv20.vhd000066400000000000000000000032711504111170000170050ustar00rootroot00000000000000entity conv20 is end entity; architecture test of conv20 is subtype real_vector_30 is real_vector(1 to 30); subtype integer_vector_30 is integer_vector(1 to 30); function to_real3 (x : integer_vector) return real_vector_30 is variable r : real_vector(1 to 30); alias xx : integer_vector(1 to 30) is x; begin for i in 1 to 30 loop r(i) := real(xx(i)); end loop; return r; end function; function to_int3 (x : real_vector) return integer_vector_30 is variable r : integer_vector(1 to 30); alias xx : real_vector(1 to 30) is x; begin for i in 1 to 30 loop if xx(i) < real(integer'left) then r(i) := integer'left; elsif xx(i) > real(integer'right) then r(i) := integer'right; else r(i) := integer(xx(i)); end if; end loop; return r; end function; signal si, so : integer_vector(1 to 30) := (others => 0); begin b: block is port ( pi : in real_vector; po : out real_vector ); port map ( pi => to_real3(si), to_int3(po) => so ); begin process (pi) is begin for i in pi'range loop if pi(i) > 0.0 then po(i) <= 1.0; end if; end loop; end process; end block; check: process is variable idx : integer; begin idx := 3; wait for 1 ns; si(idx) <= 5; wait on so(2); -- Splits SO wait for 1 ns; assert so(3) = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv21.vhd000066400000000000000000000031471504111170000170100ustar00rootroot00000000000000entity conv21 is end entity; architecture test of conv21 is subtype real_vector_30 is real_vector(1 to 30); subtype integer_vector_30 is integer_vector(1 to 30); function to_real3 (x : integer_vector) return real_vector_30 is variable r : real_vector(1 to 30); alias xx : integer_vector(1 to 30) is x; begin for i in 1 to 30 loop r(i) := real(xx(i)); end loop; return r; end function; function to_int3 (x : real_vector) return integer_vector_30 is variable r : integer_vector(1 to 30); alias xx : real_vector(1 to 30) is x; begin for i in 1 to 30 loop if xx(i) < real(integer'left) then r(i) := integer'left; elsif xx(i) > real(integer'right) then r(i) := integer'right; else r(i) := integer(xx(i)); end if; end loop; return r; end function; signal si, so : integer_vector(1 to 30) := (others => 0); begin b: block is port ( pi : in real_vector; po : out real_vector ); port map ( pi => to_real3(si), to_int3(po) => so ); begin po(1) <= pi(1) * 3.0; po(2 to po'length) <= pi(2 to pi'length); end block; check: process is variable idx : integer; begin si <= (1, others => 0); wait for 1 ns; assert so = (1 => 3, 2 to 30 => 0); si <= (20 => 6, others => 1); wait for 1 ns; assert so(1) = 3; assert so(20) = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv3.vhd000066400000000000000000000014501504111170000167230ustar00rootroot00000000000000entity sub is port ( o1 : out integer; i1 : in real ); end entity; architecture test of sub is begin p1: process is begin o1 <= 1; wait for 1 ns; o1 <= 2; assert i1 = real(5); wait; end process; end architecture; ------------------------------------------------------------------------------- entity conv3 is end entity; architecture test of conv3 is signal x : real; signal y : integer; begin uut: entity work.sub port map ( real(o1) => x, i1 => real(y) ); p2: process is begin assert x = real(integer'left); wait for 0 ns; assert x = real(1); y <= 5; wait for 2 ns; assert x = real(2); wait; end process; end architecture; nvc-r1.17.1/test/regress/conv4.vhd000066400000000000000000000034471504111170000167340ustar00rootroot00000000000000package pack is type int_vector is array (natural range <>) of natural; function spread_ints (x : integer) return int_vector; end package; package body pack is function spread_ints (x : integer) return int_vector is variable r : int_vector(1 to 5); begin for i in 1 to 5 loop r(i) := x; end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o1 : out int_vector(1 to 5); i1 : in integer; i2 : in int_vector(1 to 5) ); end entity; architecture test of sub is begin p1: process is begin assert i1 = 0; assert i2 = (1 to 5 => 0); o1 <= (1, 2, 3, 4, 5); wait for 1 ns; assert i1 = 150; assert i2 = (1 to 5 => 42); o1(1) <= 10; wait; end process; end architecture; ------------------------------------------------------------------------------- entity conv4 is end entity; use work.pack.all; architecture test of conv4 is signal x : integer; signal y : int_vector(1 to 5); signal q : natural; function sum_ints(v : in int_vector) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; begin uut: entity work.sub port map ( sum_ints(o1) => x, i1 => sum_ints(y), i2 => spread_ints(q) ); p2: process is begin assert x = 0; y <= (10, 20, 30, 40, 50); q <= 42; wait for 1 ns; assert x = 15; wait for 1 ns; assert x = 24; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv5.vhd000066400000000000000000000032211504111170000167230ustar00rootroot00000000000000package pack is type int_vector is array (natural range <>) of natural; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( size : natural ); port ( o1 : out int_vector(1 to size); o2 : out int_vector(1 to 3); i1 : in integer ); end entity; architecture test of sub is begin p1: process is variable tmp : int_vector(1 to size); begin assert i1 = 0; for i in 1 to size loop tmp(i) := i; end loop; o1 <= tmp; o2 <= (5, 6, 7); wait for 1 ns; assert i1 = 150; o1(1) <= 10; wait; end process; end architecture; ------------------------------------------------------------------------------- entity conv5 is end entity; use work.pack.all; architecture test of conv5 is signal x1 : integer; signal x2 : integer; signal y : int_vector(1 to 5); function sum_ints(v : in int_vector) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; begin uut1: entity work.sub generic map ( size => 5) port map ( sum_ints(o1) => x1, sum_ints(o2) => x2, i1 => sum_ints(y) ); p2: process is begin assert x1 = 0; assert x2 = 0; y <= (10, 20, 30, 40, 50); wait for 1 ns; assert x1 = 15; assert x2 = 18; wait for 1 ns; assert x1 = 24; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv6.vhd000066400000000000000000000036061504111170000167330ustar00rootroot00000000000000package pack is type int_vector is array (natural range <>) of natural; function spread_ints (x : integer) return int_vector; end package; package body pack is function spread_ints (x : integer) return int_vector is variable r : int_vector(1 to 5); begin for i in 1 to 5 loop r(i) := x; end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o1 : out int_vector(1 to 5); i1 : in integer; i2 : in int_vector(1 to 5) ); end entity; architecture test of sub is begin p1a: process is begin assert i1 = 0; assert i2 = (1 to 5 => 0); o1(1 to 3) <= (1, 2, 3); wait for 1 ns; assert i1 = 150; assert i2 = (1 to 5 => 42); o1(1) <= 10; wait; end process; p1b: process is begin o1(4 to 5) <= (4, 5); wait; end process; end architecture; ------------------------------------------------------------------------------- entity conv6 is end entity; use work.pack.all; architecture test of conv6 is signal x : integer; signal y : int_vector(1 to 5); signal q : natural; function sum_ints(v : in int_vector) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; begin uut: entity work.sub port map ( sum_ints(o1) => x, i1 => sum_ints(y), i2 => spread_ints(q) ); p2: process is begin assert x = 0; y <= (10, 20, 30, 40, 50); q <= 42; wait for 1 ns; assert x = 15; wait for 1 ns; assert x = 24; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv7.vhd000066400000000000000000000026141504111170000167320ustar00rootroot00000000000000package pack is type rec is record x, y : natural; end record; function rec_to_int (r : rec) return natural; function int_to_rec (x : natural) return rec; end package; package body pack is function rec_to_int (r : rec) return natural is begin return r.x + r.y; end function; function int_to_rec (x : natural) return rec is begin return (x / 2, x * 2); end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i1 : in rec; i2 : in natural ); end entity; architecture test of sub is begin p1: process is begin assert i1 = ( 0, 0 ); assert i2 = 0; wait for 0 ns; assert i1 = ( 3, 12 ); assert i2 = 5; wait for 2 ns; assert i2 = 8; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity conv7 is end entity; architecture test of conv7 is signal s1 : natural; signal s2 : rec; begin uut: entity work.sub port map ( i1 => int_to_rec(s1), i2 => rec_to_int(s2) ); main: process is begin s1 <= 6; s2 <= (2, 3); wait for 1 ns; s2.y <= 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv8.vhd000066400000000000000000000035111504111170000167300ustar00rootroot00000000000000package pack is type rec is record x, y : natural; end record; type rec_array is array (natural range <>) of rec; function rec_array_to_int (r : rec_array) return natural; function int_to_rec_array (x : natural) return rec_array; end package; package body pack is function rec_array_to_int (r : rec_array) return natural is variable sum : natural; begin for i in r'range loop sum := sum + r(i).x + r(i).y; end loop; return sum; end function; function int_to_rec_array (x : natural) return rec_array is variable r : rec_array(1 to 3); begin for i in 1 to 3 loop r(i).x := x / i; r(i).y := x * i; end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i1 : in rec_array(1 to 3); i2 : in natural ); end entity; architecture test of sub is begin p1: process is begin assert i1 = (1 to 3 => (0, 0)); assert i2 = 0; wait for 0 ns; assert i1 = ((10, 10), (5, 20), (3, 30)); assert i2 = 21; wait for 2 ns; assert i2 = 22; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity conv8 is end entity; architecture test of conv8 is signal s1 : natural; signal s2 : rec_array(1 to 3); begin uut: entity work.sub port map ( i1 => int_to_rec_array(s1), i2 => rec_array_to_int(s2) ); main: process is begin s2 <= ((1, 2), (3, 4), (5, 6)); s1 <= 10; wait for 1 ns; s2(2).y <= 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/conv9.vhd000066400000000000000000000020161504111170000167300ustar00rootroot00000000000000entity conv9 is end entity; architecture test of conv9 is type t_rec1 is record x, y : integer; end record; type t_rec2 is record y, x : integer; end record; type t_rec3 is record x : t_rec1; y : integer_vector(1 to 3); z : integer; end record; type t_rec4 is record y : integer_vector; x : t_rec2; z : real; end record; begin p1: process is variable r1 : t_rec1; variable r2 : t_rec2; variable r3 : t_rec3; variable r4 : t_rec4(y(1 to 3)); begin r1 := (1, 2); r2 := t_rec2(r1); assert r2 = (2, 1); r3 := (x => (4, 5), y => (1, 2, 3), z => 9); r4 := t_rec4(r3); assert r4.x = (5, 4); assert r4.y = (1, 2, 3); assert r4.z = 9.0; r4 := ((7, 8, 9), (6, 5), 1.0); r3 := t_rec3(r4); assert r3.x = (5, 6); assert r3.y = (7, 8, 9); assert r3.z = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/counter.vhd000066400000000000000000000016301504111170000173520ustar00rootroot00000000000000entity counter_bot is port ( clk : in bit; count : out integer ); end entity; architecture behav of counter_bot is begin process (clk) is variable count_var : integer := 0; begin if clk'event and clk = '1' then count_var := count_var + 1; count <= count_var; end if; end process; end architecture; ------------------------------------------------------------------------------- entity counter is end entity; architecture test of counter is signal clk : bit := '0'; signal count : integer := 0; begin clkgen: process is begin wait for 5 ns; clk <= not clk; end process; uut: entity work.counter_bot port map ( clk => clk, count => count ); process (count) is begin report integer'image(count); end process; end architecture; nvc-r1.17.1/test/regress/cover1.vhd000066400000000000000000000056721504111170000171040ustar00rootroot00000000000000entity cover1 is end entity; architecture test of cover1 is signal my_signal : integer; procedure my_global_procedure is begin rpt1: report "Report within GLOBAL procedure"; end procedure; function my_global_function(i : integer) return boolean is begin rpt2: report "Report within GLOBAL function"; if (i mod 2 = 0) then return true; else return false; end if; end function; begin test_proc : process variable cnt : integer := 0; variable rv : boolean; procedure my_local_procedure is begin rpt3: report "Report within LOCAL procedure"; end procedure; function my_local_function(i : integer) return boolean is begin rpt4: report "Report within LOCAL function"; if (i mod 2 = 0) then return true; else return false; end if; end function; begin -- T_IF, T_FOR, T_CASE loop1: for i in 0 to 4 loop if_cond_1: if (i = 0) then report "T_IF, i = 0"; elsif (i = 1) then report "T_IF, i = 1"; elsif (i = 2) then report "T_IF, i = 2"; elsif (i = 3) then report "T_IF, i = 3"; elsif (i = 4) then report "T_IF, i = 4"; elsif (i = 10) then -- Some unreachable statement to get also some uncovered statements. assert (False); else -- coverage off assert_false_off: assert (False) report "PRAGMA COVER OFF statement"; -- coverage on end if; case_cond_1: case i is when 0 => report "T_CASE, i = 0"; when 1 => report "T_CASE, i = 1"; when others => report "T_CASE, i = others"; end case; end loop; -- T_VAR_ASSIGN, T_WHILE, T_NEXT, T_EXIT cnt := 0; while_loop: while (true) loop cnt := cnt + 1; if (cnt = 1) then next; end if; if (cnt = 10) then exit; end if; report "T_WHILE, i = " & integer'image(cnt); end loop; -- T_SIGNAL_ASSIGN, T_ASSERT, T_WAIT sign_assign_1: my_signal <= 1; wait_1: wait for 0 ns; sign_assign_2: my_signal <= 0; wait_2: wait for 0 ns; assert_1: assert(my_signal = 0); -- T_PROC_CALL, T_FUNC_CALL, T_RETURN proc_call_global: my_global_procedure; rv := my_global_function(cnt); rv := my_global_function(cnt + 3); proc_call_local: my_local_procedure; rv := my_local_function(cnt + 2); rv := my_local_function(cnt + 5); wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover10.sh000077500000000000000000000022611504111170000170070ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover10.vhd -e --cover=all cover10 -r # Print only covered nvc --cover-report \ --exclude-file $TESTDIR/regress/data/cover10_ef1.txt \ --dont-print uncovered,excluded \ -o html cover10.ncdb 2>&1 | tee out.txt # Check nothing uncovered or excluded is there if grep SIGNAL_WHICH_IS_UNCOVERED html/hier/*; then exit 1 fi if grep SIGNAL_WHICH_IS_EXCLUDED html/hier/*; then exit 1 fi # Print only uncovered nvc --cover-report \ --exclude-file $TESTDIR/regress/data/cover10_ef1.txt \ --dont-print covered,excluded \ -o html cover10.ncdb 2>&1 | tee -a out.txt if grep SIGNAL_WHICH_IS_COVERED html/hier/*; then exit 1 fi if grep SIGNAL_WHICH_IS_EXCLUDED html/hier/*; then exit 1 fi # Print only excluded nvc --cover-report \ --exclude-file $TESTDIR/regress/data/cover10_ef1.txt \ --dont-print covered,uncovered \ -o html cover10.ncdb 2>&1 | tee -a out.txt if grep SIGNAL_WHICH_IS_COVERED html/hier/*; then exit 1 fi if grep SIGNAL_WHICH_IS_UNCOVERED html/hier/*; then exit 1 fi # Replace absolute paths sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover10.txt out.txt nvc-r1.17.1/test/regress/cover10.vhd000066400000000000000000000011241504111170000171500ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; entity cover10 is end entity; architecture test of cover10 is -- This signal will be for sure covered signal SIGNAL_WHICH_IS_COVERED : std_logic; signal SIGNAL_WHICH_IS_EXCLUDED : std_logic; signal SIGNAL_WHICH_IS_UNCOVERED : std_logic; begin process begin wait for 1 ns; SIGNAL_WHICH_IS_COVERED <= '0'; wait for 1 ns; SIGNAL_WHICH_IS_COVERED <= '1'; wait for 1 ns; SIGNAL_WHICH_IS_COVERED <= '0'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover11.sh000077500000000000000000000006001504111170000170030ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover11.vhd -e --cover=toggle cover11 -r nvc -c --item-limit=2000 \ --exclude-file=$TESTDIR/regress/data/cover11_ef1.txt \ --report html cover11.ncdb # Check just items until 2000 are printed if grep -e "EXAMPLE_ARRAY(1001)" html/hier/*; then exit 1 fi if ! grep -e "EXAMPLE_ARRAY(1000)" html/hier/*; then exit 1 fi nvc-r1.17.1/test/regress/cover11.vhd000066400000000000000000000014401504111170000171520ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; library ieee; use ieee.std_logic_1164.all; entity cover11 is end entity; architecture test of cover11 is -- To test the report limit -- Covers realloc code of misses signal EXAMPLE_ARRAY : std_logic_vector(0 to 4000); -- To cover realloc code for hits and excludes! signal ARR_A : std_logic_vector(1500 downto 0); signal ARR_B : std_logic_vector(1500 downto 0); begin test_ctrl_proc: process begin wait for 1 ns; EXAMPLE_ARRAY(0) <= '1'; wait for 1 ns; EXAMPLE_ARRAY(0) <= '0'; wait for 1 ns; ARR_A <= (others => '0'); wait for 1 ns; ARR_A <= (others => '1'); wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover12.sh000077500000000000000000000005331504111170000170110ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover12.vhd -e --cover=toggle,exclude-unreachable cover12 -r nvc --cover-report -o html cover12.ncdb 2>&1 | tee out.txt nvc -a $TESTDIR/regress/cover12.vhd -e --cover=toggle cover12 -r nvc --cover-report -o html cover12.ncdb 2>&1 | tee -a out.txt diff -u $TESTDIR/regress/gold/cover12.txt out.txt nvc-r1.17.1/test/regress/cover12.vhd000066400000000000000000000033401504111170000171540ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity clk_gate is port ( clk_in : in std_logic; clk_en : in std_logic; scan_enable : in std_logic; vector_input : in std_logic_vector(3 downto 0); clk_out : out std_logic ); end clk_gate; architecture rtl of clk_gate is signal clk_en_q : std_logic; begin -- Latch process(clk_in, scan_enable, clk_en) begin if (clk_in = '0') then clk_en_q <= (clk_en or scan_enable); end if; end process; clk_out <= clk_in and clk_en_q; end architecture; library ieee; use ieee.std_logic_1164.all; entity cover12 is end entity; architecture test of cover12 is signal clk : std_logic; signal my_clock_gate_signal : std_logic := '0'; signal clk_gated : std_logic; begin i_clk_gate : entity work.clk_gate port map ( clk_in => clk, clk_en => my_clock_gate_signal, scan_enable => '0', vector_input => "0000", clk_out => clk_gated ); clk_gen_proc : process begin for i in 0 to 10 loop clk <= '0'; wait for 5 ns; clk <= '1'; wait for 5 ns; end loop; wait; end process; test_ctrl_proc: process begin wait for 1 ns; wait until rising_edge(clk); wait for 1 ns; my_clock_gate_signal <= '1'; wait until rising_edge(clk); wait until rising_edge(clk); my_clock_gate_signal <= '0'; wait until rising_edge(clk); wait; end process; end architecture; nvc-r1.17.1/test/regress/cover13.sh000077500000000000000000000005361504111170000170150ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover13.vhd -e --cover=all --cover-spec=$TESTDIR/regress/data/cover13_spec.txt cover13 -r nvc --cover-report -V -o html cover13.ncdb 2>&1 | tee out.txt # Filter out info lines with verbose that throw amount of allocated memory sed -i -e 1,3d out.txt diff -u $TESTDIR/regress/gold/cover13.txt out.txt nvc-r1.17.1/test/regress/cover13.vhd000066400000000000000000000056171504111170000171660ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- entity leaf_entity is port ( a : in std_logic; b : out std_logic ); end leaf_entity; architecture test of leaf_entity is begin inv : process (a) begin b <= not a; end process; process begin wait for 1 ns; report "HALOO"; wait for 1 ns; report "NEXT HALOO"; wait for 1 ns; wait; end process; end architecture; ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity not_interesting_entity is port ( a : in std_logic; b : out std_logic ); end not_interesting_entity; architecture test of not_interesting_entity is begin b <= not a; end architecture; ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity level_2 is end entity; architecture test of level_2 is begin process begin wait for 1 ns; report "Message from level_2"; wait for 1 ns; wait; end process; end architecture; ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity level_1 is end entity; architecture test of level_1 is begin level_2_inst : entity work.level_2; not_interesting_entity_inst : entity work.not_interesting_entity port map ( a => '1', b => open ); process begin wait for 1 ns; report "Message from level_1"; wait for 1 ns; wait; end process; end architecture; ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity cover13 is end cover13; architecture test of cover13 is signal a : std_logic; signal b : std_logic; begin leaf_entity_inst : entity work.leaf_entity port map ( a => a, b => b ); not_interesting_entity_inst : entity work.not_interesting_entity port map ( a => a, b => open ); level_1_inst : entity work.level_1; process begin wait for 1 ns; a <= '1'; wait for 1 ns; a <= '0'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover14.sh000077500000000000000000000005671504111170000170220ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover14.vhd -e --cover=expression,exclude-unreachable cover14 -r nvc --cover-report -o html cover14.ncdb --exclude-file $TESTDIR/regress/data/cover14_ef1.txt 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover14.txt out.txt nvc-r1.17.1/test/regress/cover14.vhd000066400000000000000000000010251504111170000171540ustar00rootroot00000000000000entity cover14 is end cover14; architecture test of cover14 is signal x : integer := 10; signal y : integer := 0; signal res : boolean; signal res_2 : boolean; begin res <= (y /= 0) and ((x / y) = 1); -- Should not execute div by zero if the first condition is met -- if not, then it is not div by zero res_2 <= (y = 0) or ((x / y) = 1); process begin x <= 10; wait for 1 ns; y <= 5; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover15.vhd000066400000000000000000000013221504111170000171550ustar00rootroot00000000000000entity cover15 is end cover15; architecture test of cover15 is begin process function crop_and_saturate_time(p : in time) return integer is begin return 0 when (p < 10 ns) else 10 when (p < 20 ns) else 20 when (p < 30 ns) else 30 when (p < 40 ns) else 40; end function; begin wait for 1 ns; report integer'image(crop_and_saturate_time(now)); wait for 10 ns; report integer'image(crop_and_saturate_time(now)); wait for 10 ns; report integer'image(crop_and_saturate_time(now)); wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover16.vhd000066400000000000000000000010261504111170000171570ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity cover16 is end cover16; architecture test of cover16 is signal a, b: std_logic := '0'; signal c, d: std_logic_vector(7 downto 0) := X"00"; begin process begin c <= d and d; wait for 1 ns; c <= b and d; wait for 1 ns; c <= d and b; wait for 1 ns; a <= and d; wait for 1 ns; -- Ensure we have at least one covered expression a <= '1' and b; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover17.vhd000066400000000000000000000016351504111170000171660ustar00rootroot00000000000000entity sub is port ( i : integer ); end entity; architecture test of sub is begin process (i) is begin if i > 0 then -- Taken in U1 report "> 0"; else -- Taken in U1 and U2 report "< 0"; end if; end process; end architecture; ------------------------------------------------------------------------------- entity cover17 is end entity; architecture test of cover17 is signal x, y : integer; begin u1: entity work.sub port map ( x ); u2: entity work.sub port map ( y ); tb: process is begin x <= 0; wait for 1 ns; if x = 0 then y <= 600; end if; wait for 1 ns; if x < 0 then -- Never taken assert false; -- Not covered end if; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover18.sh000077500000000000000000000005551504111170000170230ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover18.vhd -e --cover=fsm-state cover18 -r nvc --cover-report -o html work/_WORK.COVER18.elab.covdb --exclude=$TESTDIR/regress/data/cover18_ef.txt 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover18.txt out.txt nvc-r1.17.1/test/regress/cover18.vhd000066400000000000000000000061661504111170000171730ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity cover18 is end cover18; architecture test of cover18 is -- Example of simple FSM that fits into one byte type t_fsm_state is ( ST_IDLE, ST_ONE, ST_TWO, ST_THREE, ST_WAITING, ST_DONE ); -- Example of FSM that fits into two bytes type t_larger_fsm_state is ( S_1 ,S_2 ,S_3 ,S_4 ,S_5 ,S_6 ,S_7 ,S_8 ,S_9 ,S_10 ,S_11 ,S_12 ,S_13 ,S_14 ,S_15 ,S_16 ,S_17 ,S_18 ,S_19 ,S_20 ,S_21 ,S_22 ,S_23 ,S_24 ,S_25 ,S_26 ,S_27 ,S_28 ,S_29 ,S_30 ,S_31 ,S_32 ,S_33 ,S_34 ,S_35 ,S_36 ,S_37 ,S_38 ,S_39 ,S_40 ,S_41 ,S_42 ,S_43 ,S_44 ,S_45 ,S_46 ,S_47 ,S_48 ,S_49 ,S_50 ,S_51 ,S_52 ,S_53 ,S_54 ,S_55 ,S_56 ,S_57 ,S_58 ,S_59 ,S_60 ,S_61 ,S_62 ,S_63 ,S_64 ,S_65 ,S_66 ,S_67 ,S_68 ,S_69 ,S_70 ,S_71 ,S_72 ,S_73 ,S_74 ,S_75 ,S_76 ,S_77 ,S_78 ,S_79 ,S_80 ,S_81 ,S_82 ,S_83 ,S_84 ,S_85 ,S_86 ,S_87 ,S_88 ,S_89 ,S_90 ,S_91 ,S_92 ,S_93 ,S_94 ,S_95 ,S_96 ,S_97 ,S_98 ,S_99 ,S_100 ,S_101 ,S_102 ,S_103 ,S_104 ,S_105 ,S_106 ,S_107 ,S_108 ,S_109 ,S_110 ,S_111 ,S_112 ,S_113 ,S_114 ,S_115 ,S_116 ,S_117 ,S_118 ,S_119 ,S_120 ,S_121 ,S_122 ,S_123 ,S_124 ,S_125 ,S_126 ,S_127 ,S_128 ,S_129 ,S_130 ,S_131 ,S_132 ,S_133 ,S_134 ,S_135 ,S_136 ,S_137 ,S_138 ,S_139 ,S_140 ,S_141 ,S_142 ,S_143 ,S_144 ,S_145 ,S_146 ,S_147 ,S_148 ,S_149 ,S_150 ,S_151 ,S_152 ,S_153 ,S_154 ,S_155 ,S_156 ,S_157 ,S_158 ,S_159 ,S_160 ,S_161 ,S_162 ,S_163 ,S_164 ,S_165 ,S_166 ,S_167 ,S_168 ,S_169 ,S_170 ,S_171 ,S_172 ,S_173 ,S_174 ,S_175 ,S_176 ,S_177 ,S_178 ,S_179 ,S_180 ,S_181 ,S_182 ,S_183 ,S_184 ,S_185 ,S_186 ,S_187 ,S_188 ,S_189 ,S_190 ,S_191 ,S_192 ,S_193 ,S_194 ,S_195 ,S_196 ,S_197 ,S_198 ,S_199 ,S_200 ,S_201 ,S_202 ,S_203 ,S_204 ,S_205 ,S_206 ,S_207 ,S_208 ,S_209 ,S_210 ,S_211 ,S_212 ,S_213 ,S_214 ,S_215 ,S_216 ,S_217 ,S_218 ,S_219 ,S_220 ,S_221 ,S_222 ,S_223 ,S_224 ,S_225 ,S_226 ,S_227 ,S_228 ,S_229 ,S_230 ,S_231 ,S_232 ,S_233 ,S_234 ,S_235 ,S_236 ,S_237 ,S_238 ,S_239 ,S_240 ,S_241 ,S_242 ,S_243 ,S_244 ,S_245 ,S_246 ,S_247 ,S_248 ,S_249 ,S_250 ,S_251 ,S_252 ,S_253 ,S_254 ,S_255 ,S_256 ,S_257 ,S_258 ,S_259 ,S_260 ,S_261 ,S_262 ,S_263 ,S_264 ,S_265 ,S_266 ,S_267 ,S_268 ,S_269 ,S_270 ,S_271 ,S_272 ); signal curr_state : t_fsm_state; signal state_reg : t_larger_fsm_state; -- To check coverage for built-in enums is not emmited signal my_sig : STD_LOGIC; signal my_bool : boolean; begin process begin curr_state <= ST_TWO; wait for 5 ns; curr_state <= ST_WAITING; wait for 5 ns; curr_state <= ST_DONE; wait for 5 ns; state_reg <= S_4; wait for 5 ns; state_reg <= S_8; wait for 5 ns; state_reg <= S_16; wait for 5 ns; state_reg <= S_32; wait for 5 ns; state_reg <= S_64; wait for 5 ns; state_reg <= S_128; wait for 5 ns; state_reg <= S_256; wait for 5 ns; state_reg <= S_264; wait for 5 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover19.sh000077500000000000000000000006071504111170000170220ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover19.vhd -e --cover=fsm-state,fsm-no-default-enums --cover-spec=$TESTDIR/regress/data/cover19_spec.txt cover19 -r nvc --cover-report -o html work/_WORK.COVER19.elab.covdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover19.txt out.txt nvc-r1.17.1/test/regress/cover19.vhd000066400000000000000000000016521504111170000171670ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity cover19 is end cover19; architecture test of cover19 is -- FSM that is taken int account type t_fsm_state is ( ST_IDLE, ST_ONE, ST_TWO, ST_THREE, ST_WAITING, ST_DONE ); -- FSM that is left out type t_second_fsm is ( S_1 ,S_2 ,S_3 ,S_4 ,S_5 ); subtype t_subset_fsm is t_fsm_state range ST_TWO to ST_WAITING; signal curr_state : t_fsm_state; signal state_reg : t_second_fsm; signal sub_fsm : t_subset_fsm; begin process begin curr_state <= ST_TWO; wait for 5 ns; curr_state <= ST_WAITING; wait for 5 ns; curr_state <= ST_DONE; wait for 5 ns; state_reg <= S_4; wait for 5 ns; -- Subset FSM sub_fsm <= ST_WAITING; wait for 5 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover2.vhd000066400000000000000000000106771504111170000171060ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub_module is port ( a : in std_logic; b : in std_logic; c : out std_logic ); end entity; architecture test of sub_module is type t_record_in_submodule is record elem : std_logic; end record; signal record_in_submodule : t_record_in_submodule; begin tgl_proc : process (a,b) begin c <= a xor b; end process; end architecture; library ieee; use ieee.std_logic_1164.all; entity cover2 is end entity; architecture test of cover2 is -- Full toggle signal t1_a : std_logic := '0'; signal t1_b : std_logic := '0'; signal t1_c : std_logic; -- Toggle only 0 -> 1 signal t2_a : std_logic := '0'; signal t2_b : std_logic := '0'; signal t2_c : std_logic := '0'; -- Toggle only 1 -> 0 signal t3_a : std_logic := '1'; signal t3_b : std_logic := '0'; signal t3_c : std_logic; -- Toggle on multi-dimensional array type t_tensor is array (natural range <>, natural range <>, natural range <>) of std_logic; signal tensor : t_tensor(0 to 2, 2 downto 0, 2 downto 0) := (others => (others => ('1','0','1'))); -- Toggle on nested array type t_memory_2d is array (2 downto 0) of std_logic_vector(0 to 3); signal memory_2d : t_memory_2d := (others => x"A"); type t_memory_3d is array (2 downto 0) of t_memory_2d; signal memory_3d : t_memory_3d := (others => (others => x"5")); -- Toggle on signals within record and nested record type t_nested_record is record a : natural; b : std_logic; c : std_logic_vector(2 downto 0); end record; type t_record is record x : std_logic; y : std_logic_vector(3 downto 0); z : t_nested_record; end record; signal my_rec : t_record := ('0', "0000", (0, '0', "000")); -- coverage off signal my_ignored_signal : std_logic := '0'; -- coverage on begin -- Toggle on ports - Full sub_module_inst : entity work.sub_module port map ( a => t1_a, b => t1_b, c => t1_c ); -- Toggle on ports - 0 -> 1 only sub_module_inst_2 : entity work.sub_module port map ( a => t2_a, b => t2_b, c => t2_c ); -- Toggle on ports - 1 -> 0 only sub_module_inst_3 : entity work.sub_module port map ( a => t3_a, b => t3_b, c => t3_c ); test_proc : process begin -- Toggle 0 -> 1 and 1 -> 0 on both inputs and outputs wait for 1 ns; t1_a <= '1'; wait for 1 ns; t1_b <= '1'; wait for 1 ns; t1_a <= '0'; wait for 1 ns; t1_b <= '0'; -- Toggle 0 -> 1 only wait for 1 ns; t2_a <= '1'; wait for 1 ns; -- Toggle 1 -> 0 only wait for 1 ns; t3_a <= '0'; wait for 1 ns; -- Mixed toggle on multi-dimensional array for i in 0 to 2 loop for j in 0 to 2 loop for k in 0 to 2 loop tensor(i,j,k) <= not tensor(i,j,k); wait for 1 ns; end loop; end loop; end loop; -- Mixed toggle on nested array for i in 0 to 2 loop for j in 0 to 3 loop if (i = j) then memory_2d(i)(j) <= not memory_2d(i)(j); wait for 1 ns; end if; end loop; end loop; for i in 0 to 2 loop for j in 0 to 3 loop for k in 0 to 3 loop if (i = j and j = k and k = i) then memory_3d(i)(j)(k) <= not memory_3d(i)(j)(k); wait for 1 ns; end if; end loop; end loop; end loop; -- Toggle 0 -> 1 on signals within record my_rec.x <= '1'; my_rec.y <= "0101"; wait for 1 ns; my_rec.z.b <= '1'; my_rec.z.c <= "101"; wait for 1 ns; wait; end process; -- Toggle on the process just to make sure that toggle callback -- is truly not called and does not mess something up. process begin wait for 1 ns; my_ignored_signal <= '1'; wait for 1 ns; my_ignored_signal <= '0'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover20.sh000077500000000000000000000007221504111170000170100ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover20.vhd \ -e -gG_VAL=0 --cover=statement,toggle --cover-file=DB1.ncdb cover20 -r nvc -a $TESTDIR/regress/cover20.vhd \ -e -gG_VAL=1 --cover=statement,toggle --cover-file=DB2.ncdb cover20 -r nvc --cover-report -o html DB1.ncdb DB2.ncdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover20.txt out.txt nvc-r1.17.1/test/regress/cover20.vhd000066400000000000000000000021351504111170000171540ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity cover20 is generic ( G_VAL : integer ); end cover20; architecture test of cover20 is signal a : std_logic; signal b : std_logic; -- Toggle is within the same scope. -- This tests that merging puts tgl(1) from second run -- to the merged DB signal tgl : std_logic_vector(G_VAL downto 0); begin gen_zero: if (G_VAL = 0) generate begin process begin a <= '1'; wait for 1 ns; a <= '0'; wait for 1 ns; tgl(0) <= '1'; wait for 1 ns; tgl(0) <= '0'; wait for 1 ns; tgl(0) <= '1'; wait for 1 ns; wait; end process; end generate; -- Generate causes new coverage scope -> Merge of whole scope is tested. gen_one: if (G_VAL = 1) generate begin process begin b <= '1'; wait for 1 ns; b <= '0'; wait for 1 ns; wait; end process; end generate; end architecture; nvc-r1.17.1/test/regress/cover21.sh000077500000000000000000000004731504111170000170140ustar00rootroot00000000000000set -xe pwd which nvc nvc -a --psl $TESTDIR/regress/cover21.vhd -e --cover cover21 -r nvc --cover-report -o html work/_WORK.COVER21.elab.covdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover21.txt out.txt nvc-r1.17.1/test/regress/cover21.vhd000066400000000000000000000013371504111170000171600ustar00rootroot00000000000000entity cover21 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of cover21 is signal clk : std_logic := '0'; signal x, y : std_logic; -- psl default clock is rising_edge(clk); begin -- psl one: cover {x and y}; -- psl two: cover {[*]; x and y}; -- psl three: cover {x; not x and not y; y}; -- psl four: cover {x; not x; x and y}; clkgen: clk <= not clk after 5 ns when now < 50 ns; seq: process is begin x <= '1'; wait for 1 ns; y <= '1'; wait for 6 ns; y <= '0'; wait for 10 ns; x <= '0'; wait for 10 ns; y <= '1'; wait for 10 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover22.sh000077500000000000000000000007731504111170000170200ustar00rootroot00000000000000set -xe pwd which nvc nvc -a --psl $TESTDIR/regress/cover22.vhd \ -e --cover=statement --cover-file=a.ncdb cover22_a -r nvc --work=SECOND_LIB:work -a --psl $TESTDIR/regress/cover22.vhd \ -e --cover=statement --cover-file=b.ncdb cover22_b -r # Using -c to check deprecated command still works nvc -c --report html a.ncdb b.ncdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover22.txt out.txt nvc-r1.17.1/test/regress/cover22.vhd000066400000000000000000000007601504111170000171600ustar00rootroot00000000000000entity cover22_a is end entity; architecture test of cover22_a is begin process begin wait for 1 ns; report "Dummy statement in TOP hierarchy A!"; wait for 1 ns; wait; end process; end architecture; entity cover22_b is end entity; architecture test of cover22_b is begin process begin wait for 2 ns; report "Dummy statement in TOP hierarchy B!"; wait for 2 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover23.sh000077500000000000000000000014021504111170000170070ustar00rootroot00000000000000set -xe pwd which nvc nvc --work=WORK_A -a $TESTDIR/regress/cover23.vhd \ -e --cover=statement --cover-file=a.ncdb cover23_top_tb -r nvc --work=WORK_B -a $TESTDIR/regress/cover23.vhd \ -e --cover=statement --cover-file=b.ncdb cover23_unit_tb -r nvc --cover-merge -o merged.ncdb a.ncdb b.ncdb # Report on merged covdb without folding nvc --cover-report -o html merged.ncdb 2>&1 | tee out.txt # Report with folding -> Statement coverage is higher since case choices for 3 and 4 were folded nvc --cover-report -o html --exclude-file $TESTDIR/regress/data/cover23_ef.txt \ merged.ncdb 2>&1 | tee -a out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover23.txt out.txt nvc-r1.17.1/test/regress/cover23.vhd000066400000000000000000000101201504111170000171500ustar00rootroot00000000000000------------------------------------------------------------------------------- -- Simple MUX sub-block ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity sub_block is port ( sel : in natural; output : out std_logic_vector(7 downto 0) ); end entity; architecture rtl of sub_block is begin process (sel) begin case (sel) is when 0 => output <= x"AA"; when 1 => output <= x"BB"; when 2 => output <= x"CC"; when 3 => output <= x"DD"; when 4 => output <= x"00"; when 5 => output <= x"11"; when others => output <= x"EE"; end case; end process; end architecture; ------------------------------------------------------------------------------- -- DUT TOP ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity dut_top is port ( clk : in std_logic; rst : in std_logic; start : in std_logic; done : out std_logic; output : out std_logic_vector(7 downto 0) ); end entity; architecture rtl of dut_top is type t_fsm is ( S_IDLE, S_1, S_2, S_DONE ); signal curr_state : t_fsm; signal sel : natural; begin process (rst, clk) begin if (rst) then curr_state <= S_IDLE; elsif (rising_edge(clk)) then case (curr_state) is when S_IDLE => if (start = '1') then curr_state <= S_1; end if; when S_1 => curr_state <= S_2; when S_2 => curr_state <= S_DONE; when S_DONE => curr_state <= S_IDLE; end case; end if; end process; process (curr_state) begin sel <= 0; done <= '0'; case (curr_state) is when S_IDLE => sel <= 255; when S_1 => sel <= 1; when S_2 => sel <= 2; when S_DONE => done <= '1'; end case; end process; sub_block_inst : entity work.sub_block port map ( sel => sel, output => output ); end architecture; ------------------------------------------------------------------------------- -- TB for DUT ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity cover23_top_tb is end entity; architecture tb of cover23_top_tb is signal clk : std_logic; signal rst : std_logic; signal start : std_logic := '0'; signal done : std_logic := '0'; signal output : std_logic_vector(7 downto 0); begin dut_top_inst : entity work.dut_top port map ( clk => clk, rst => rst, start => start, done => done, output => output ); process begin clk <= '1'; wait for 5 ns; clk <= '0'; wait for 5 ns; end process; process begin rst <= '1'; wait for 5 ns; rst <= '0'; wait for 10 ns; start <= '1'; wait for 10 ns; start <= '0'; wait for 100 ns; std.env.finish; end process; end architecture; ------------------------------------------------------------------------------- -- TB for SUB-BLOCK ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity cover23_unit_tb is end entity; architecture tb of cover23_unit_tb is signal sel : natural := 254; signal output : std_logic_vector(7 downto 0); begin sub_block_inst : entity work.sub_block port map ( sel => sel, output => output ); test_proc : process begin wait for 5 ns; sel <= 3; wait for 5 ns; sel <= 4; wait for 5 ns; std.env.finish; end process; end architecture; nvc-r1.17.1/test/regress/cover24.sh000077500000000000000000000005231504111170000170130ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover24.vhd -e --cover cover24 -r # Report per-file nvc --cover-report --per-file -o html work/_WORK.COVER24.elab.covdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover24.txt out.txt nvc-r1.17.1/test/regress/cover24.vhd000066400000000000000000000010331504111170000171540ustar00rootroot00000000000000entity cover24 is end entity; architecture test of cover24 is signal a,b,c : integer := 0; signal bool : boolean; begin -- Conditional statement is used since the trailing "c" -- was causing a bug in the implementation. After fixing this -- bug, a "per-file" vs. "per-hierarchy" report numbers matched -- on larget project. a <= b when (bool) else c+b when (not bool) else c; process begin wait for 1 ns; report "Running"; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover25.vhd000066400000000000000000000036031504111170000171620ustar00rootroot00000000000000entity sub is generic ( count : natural ); end entity; library nvc; use nvc.cover_pkg.all; architecture test of sub is begin p1: process is variable handle : t_scope_handle; variable item : t_item_handle; begin create_cover_scope(handle, "dummy_name"); set_cover_scope_name(handle, "sub_scope"); add_cover_item(handle, item, "item", 1, (0 => (min => 0, max => 0))); wait for 5 ns; for i in 1 to count loop increment_cover_item(handle, item); end loop; wait; end process; end architecture; ------------------------------------------------------------------------------- entity cover25 is end entity; library nvc; use nvc.cover_pkg.all; architecture test of cover25 is component sub5 is end component; for all : sub5 use entity work.sub generic map (5); begin sub1_i: entity work.sub generic map (10); sub2_i: component sub5; p2: process is variable handle : t_scope_handle; variable item1, item2 : t_item_handle; begin create_cover_scope(handle, "top_scope"); add_cover_item(handle, item1, "item1", 1, (0 => (min => 0, max => 0))); add_cover_item(handle, item2, "item2", 1, (0 => (min => 0, max => 0))); wait for 1 ns; increment_cover_item(handle, item1); increment_cover_item(handle, item2); wait for 1 ns; increment_cover_item(handle, item2); wait; end process; p3: process is variable handle : t_scope_handle; variable item1, item2 : t_item_handle; begin create_cover_scope(handle, "top_scope"); for i in 1 to 3 loop add_cover_item(handle, item1, "dup", 1, (0 => (min => 0, max => 0))); end loop; add_cover_item(handle, item2, " **.x~", 1, (0 => (min => 0, max => 0))); wait; end process; end architecture; nvc-r1.17.1/test/regress/cover26.sh000077500000000000000000000005221504111170000170140ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover26.vhd -e --cover cover26 -r # Report per-file # This used to crash before nvc --cover-report -o html cover26.ncdb 2>&1 | tee out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt diff -u $TESTDIR/regress/gold/cover26.txt out.txt nvc-r1.17.1/test/regress/cover26.vhd000066400000000000000000000012561504111170000171650ustar00rootroot00000000000000entity sub is generic ( nest : natural ); end entity; architecture test of sub is begin sub_hier_gen : if (nest > 0) generate sub_inst_long_path : entity work.sub generic map ( nest => nest - 1 ); end generate; leaf_hier_gen : if (nest = 0) generate process begin wait for 1 ns; report "I am at leaf level"; wait for 1 ns; wait; end process; end generate; end architecture; entity cover26 is end entity; architecture test of cover26 is begin sub_inst_long_path : entity work.sub generic map ( nest => 60 ); end architecture; nvc-r1.17.1/test/regress/cover27.sh000077500000000000000000000013251504111170000170170ustar00rootroot00000000000000set -xe nvc -a $TESTDIR/regress/cover27.vhd -e -gG_PAR=0 --cover=statement --cover-file=cover27_a.ncdb cover27 -r nvc --cover-export --format=xml -o cover27_a.xml cover27_a.ncdb sed -i -e "s/[^ ]*regress//g" cover27_a.xml nvc -a $TESTDIR/regress/cover27.vhd -e -gG_PAR=1 --cover=statement --cover-file=cover27_b.ncdb cover27 -r nvc --cover-export --format=xml -o cover27_b.xml cover27_b.ncdb sed -i -e "s/[^ ]*regress//g" cover27_b.xml nvc --cover-merge cover27*.ncdb --output=merged.covdb nvc --cover-report --output=html merged.covdb 2>&1 | tee out.txt diff -u $TESTDIR/regress/gold/cover27.txt out.txt diff -u $TESTDIR/regress/gold/cover27_a.xml cover27_a.xml diff -u $TESTDIR/regress/gold/cover27_b.xml cover27_b.xml nvc-r1.17.1/test/regress/cover27.vhd000066400000000000000000000013051504111170000171610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity cover27 is generic ( G_PAR : integer ); end entity; architecture test of cover27 is signal a,b,c,d,e,f : std_logic; signal vec : std_logic_vector(3 downto 0); begin G_IF_GEN : if (G_PAR = 0) generate a <= '0'; elsif G_IF_GEN_1: (G_PAR = 1) generate b <= '0'; end generate; T_FOR_GEN : for i in 0 to 3 generate vec(i) <= a when (i = 0) else b when (i = 1) else c when (i = 2) else d; end generate; G_CASE_GEN : case (G_PAR) generate when G_CASE_0: 0 => c <= '1'; when G_CASE_1: 1 => d <= '0'; end generate; end architecture; nvc-r1.17.1/test/regress/cover3.vhd000066400000000000000000000072471504111170000171060ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity cover3 is end entity; architecture test of cover3 is signal cnt : integer := 0; signal cnt2 : integer := 0; signal cnt3 : unsigned(3 downto 0) := "0000"; begin -- Test control process begin wait for 1 ns; if (cnt < 20) then cnt <= cnt + 1; else wait for 1 ns; wait; end if; end process; process begin cnt2 <= 1; wait for 1 ns; cnt2 <= 2; wait for 1 ns; cnt2 <= 3; wait for 1 ns; wait; end process; -- IF / ELSE process(cnt) begin l_if_1: if (cnt = 0) then report "IF1: CNT = 0"; elsif (cnt = 1) then report "IF1: CNT = 1"; -- coverage off elsif (cnt = 10) then report "IF1: CNT = 10"; -- coverage on else report "IF1: CNT other"; end if; -- With implicit else, only counts due to "false of" with last valued branch l_if_2: if (cnt = 10) then report "IF2: CNT = 10"; elsif (cnt = 11) then report "IF2: CNT = 11"; end if; -- With some branches uncovered l_if_3: if (cnt = 100) then assert (False); elsif (cnt = 19) then report "IF3: CNT = 19"; elsif (cnt = 70) then assert (False); end if; end process; -- T_CASE with scalar process(cnt) begin -- Case with all options covered l_case_1: case (cnt) is when 0 => report "CASE1: CNT = 0"; -- coverage off when 1 => report "CASE1: CNT = 1"; -- coverage on when 2 => report "CASE1: CNT = 2"; when 3 => report "CASE1: CNT = 3"; when others => report "CASE1: CNT = OTHERS"; end case; -- Case with some explicit branches uncovered l_case_1: case (cnt) is when 28 => assert (False); when 29 => assert (False); when 7 => report "CASE2: CNT = 7"; when 8 => report "CASE2: CNT = 8"; when others => report "CASE2: CNT = OTHERS"; end case; end process; process(cnt2) begin -- Case with only others uncovered l_case_3: case (cnt2) is when 0 => report "CASE3: CNT2 = 0"; when 1 => report "CASE3: CNT2 = 1"; when 2 => report "CASE3: CNT2 = 2"; when 3 => report "CASE3: CNT2 = 3"; when others => assert (False); end case; end process; process begin wait for 1 ns; if (cnt3 < "0111") then cnt3 <= cnt3 + "0001"; else wait; end if; end process; process(cnt3) begin -- Case on array, others covered, some options uncovered l_case_4: case (cnt3) is when "0000" => report "CASE4: 0000"; when "0001" => report "CASE4: 0001"; when "0010" => report "CASE4: 0010"; when "0ZZ1" => assert(False); when "0011" => report "CASE4: 0011"; when "0101" | "0110" | "0111" => report "CASE4: 5-7"; when "1000" => assert(False); when others => report "CASE4: others (hit by 4)"; end case; end process; process(cnt3) begin -- Case on array, only others uncovered l_case_4: case (cnt3) is when "0000" | "0001" | "0010" | "0011" | "0100" | "0101" | "0110" | "0111" => report "CASE5: Coverable"; when others => assert(False); end case; end process; process begin -- Loop without condition (should not be included) forever: loop exit; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover4.vhd000066400000000000000000000021611504111170000170750ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity cover4 is end entity; architecture test of cover4 is signal cnt : integer := 0; signal res_1 : std_logic_vector(3 downto 0); signal res_2 : std_logic_vector(3 downto 0); begin -- Test control process begin wait for 1 ns; if (cnt < 20) then cnt <= cnt + 1; else wait for 1 ns; wait; end if; end process; -- When else res_1 <= "0000" when (cnt = 0) else "0001" when (cnt = 1) else -- coverage off "0010" when (cnt = 2) else -- coverage on "0011" when (cnt = 3) else "0100" when (cnt = 4) else "0101" when (cnt = 5) else "0111" when (cnt = 6) else "XXXX"; -- With select with (cnt) select res_2 <= "0000" when 0, "0001" when 1, "0010" when 2, "0011" when 3, -- coverage off "0100" when 4, -- coverage on "0101" when 5, "0111" when 6, "XXXX" when others; end architecture; nvc-r1.17.1/test/regress/cover5.sh000077500000000000000000000016331504111170000167350ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/cover5.vhd \ -e -gG_VAL=1 --cover=all --cover-file=DB1.ncdb cover5 -r nvc --cover-report -o html DB1.ncdb 2>&1 | tee out.txt nvc -a $TESTDIR/regress/cover5.vhd \ -e -gG_VAL=2 --cover=all --cover-file=DB2.ncdb cover5 -r nvc --cover-report -o html DB2.ncdb 2>&1 | tee -a out.txt nvc -a $TESTDIR/regress/cover5.vhd \ -e -gG_VAL=3 --cover=all --cover-file=DB3.ncdb cover5 -r nvc --cover-report -o html DB3.ncdb 2>&1 | tee -a out.txt nvc -a $TESTDIR/regress/cover5.vhd \ -e -gG_VAL=4 --cover=all --cover-file=DB4.ncdb cover5 -r nvc --cover-report -o html DB4.ncdb 2>&1 | tee -a out.txt nvc --cover-merge -o DB_MERGED.ncdb DB1.ncdb DB2.ncdb DB3.ncdb DB4.ncdb \ --cover-report -o html DB_MERGED.ncdb \ 2>&1 | tee -a out.txt if [ ! -f html/index.html ]; then echo "missing coverage report" exit 1 fi diff -u $TESTDIR/regress/gold/cover5.txt out.txt nvc-r1.17.1/test/regress/cover5.vhd000066400000000000000000000031401504111170000170740ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity cover5 is generic ( G_VAL : integer ); end entity; architecture test of cover5 is signal vect : std_logic_vector(15 downto 0) := x"AAAA"; -- Needed to pass via signal to avoid optimizing out parts of -- the if/else conditions. signal cnt : integer := G_VAL; begin -- Check on statements and branches process(cnt) begin l_if1: if (cnt = 1) then report "IF1: cnt = 1"; elsif (cnt = 2) then report "IF1: cnt = 2"; elsif (cnt = 3) then report "IF1: cnt = 3"; else report "IF1: cnt = others"; end if; end process; -- Check on toggles process begin wait for 1 ns; for i in 1 to G_VAL loop vect(i * G_VAL - 1) <= not vect(i * G_VAL - 1); end loop; wait for 1 ns; wait; end process; -- Check with different amount of statements in each branch -- to get different coverage results for each run! process(cnt) begin l_if2: if (cnt = 1) then report "IF2: cnt = 1/1"; elsif (cnt = 2) then report "IF2: cnt = 1/2"; report "IF2: cnt = 2/2"; elsif (cnt = 3) then report "IF2: cnt = 1/3"; report "IF2: cnt = 2/3"; report "IF2: cnt = 3/3"; elsif (cnt = 4) then report "IF2: cnt = 1/4"; report "IF2: cnt = 2/4"; report "IF2: cnt = 3/4"; report "IF2: cnt = 4/4"; end if; end process; end architecture; nvc-r1.17.1/test/regress/cover6.sh000077500000000000000000000012171504111170000167340ustar00rootroot00000000000000set -xe pwd which nvc # Track only from U nvc -a $TESTDIR/regress/cover6.vhd -e --cover=toggle,count-from-undefined cover6 -r nvc --cover-report -o html cover6.ncdb 2>&1 | tee out.txt # Track only from/to Z nvc -a $TESTDIR/regress/cover6.vhd -e --cover=toggle,count-from-to-z cover6 -r nvc --cover-report -o html cover6.ncdb 2>&1 | tee -a out.txt # Track both nvc -a $TESTDIR/regress/cover6.vhd -e --cover=toggle,count-from-undefined,count-from-to-z cover6 -r nvc --cover-report -o html cover6.ncdb 2>&1 | tee -a out.txt if [ ! -f html/index.html ]; then echo "missing coverage report" exit 1 fi diff -u $TESTDIR/regress/gold/cover6.txt out.txt nvc-r1.17.1/test/regress/cover6.vhd000066400000000000000000000016331504111170000171020ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity cover6 is end entity; architecture test of cover6 is signal from_u_to_1 : std_logic := 'U'; signal from_u_to_0 : std_logic := 'U'; signal from_z_to_1 : std_logic := 'Z'; signal from_z_to_0 : std_logic := 'Z'; signal from_1_to_z : std_logic := '1'; signal from_0_to_z : std_logic := '0'; begin process begin wait for 1 ns; -- U -> 1 from_u_to_1 <= '1'; wait for 1 ns; -- U -> 0 from_u_to_0 <= '0'; wait for 1 ns; -- Z -> 1 from_z_to_1 <= '1'; wait for 1 ns; -- Z -> 0 from_z_to_0 <= '0'; wait for 1 ns; -- 1 -> Z from_1_to_z <= 'Z'; wait for 1 ns; -- 0 -> Z from_0_to_z <= 'Z'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover7.vhd000066400000000000000000000077041504111170000171100ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity cover7 is end entity; architecture test of cover7 is -- OR / NOR signal lhs_or_1 : std_logic := '0'; signal rhs_or_1 : std_logic := '0'; signal res_or_1 : std_logic; signal res_nor_1 : std_logic; signal lhs_or_2 : std_logic := '0'; signal rhs_or_2 : std_logic := '0'; signal res_or_2 : std_logic; signal res_nor_2 : std_logic; signal res_or_3 : std_logic; signal res_nor_3 : std_logic; -- AND / NAND signal lhs_and_1 : std_logic := '0'; signal rhs_and_1 : std_logic := '0'; signal res_and_1 : std_logic; signal res_nand_1 : std_logic; signal lhs_and_2 : std_logic := '1'; signal rhs_and_2 : std_logic := '1'; signal res_and_2 : std_logic; signal res_nand_2 : std_logic; signal res_and_3 : std_logic; signal res_nand_3 : std_logic; -- XOR / XNOR signal lhs_xor_1 : std_logic := '0'; signal rhs_xor_1 : std_logic := '0'; signal res_xor_1 : std_logic; signal res_xnor_1 : std_logic; signal lhs_xor_2 : std_logic := '0'; signal rhs_xor_2 : std_logic := '0'; signal res_xor_2 : std_logic; signal res_xnor_2 : std_logic; signal res_xor_3 : std_logic; signal res_xnor_3 : std_logic; begin --------------------------------------------------------------------------- -- Logic ops on std_logic --------------------------------------------------------------------------- -- OR / NOR gate_or_1: res_or_1 <= lhs_or_1 or rhs_or_1; gate_nor_1: res_nor_1 <= lhs_or_1 nor rhs_or_1; gate_or_2: res_or_2 <= lhs_or_2 or rhs_or_2; gate_nor_2: res_nor_2 <= lhs_or_2 nor rhs_or_2; gate_or_3: res_or_3 <= lhs_or_1 or rhs_or_2; gate_nor_3: res_nor_3 <= lhs_or_1 nor rhs_or_2; -- AND / NAND gate_and_1: res_and_1 <= lhs_and_1 and rhs_and_1; gate_nand_1: res_nand_1 <= lhs_and_1 nand rhs_and_1; gate_and_2: res_and_2 <= lhs_and_2 and rhs_and_2; gate_nand_2: res_nand_2 <= lhs_and_2 nand rhs_and_2; gate_and_3: res_and_3 <= lhs_and_1 and rhs_and_2; gate_nand_3: res_nand_3 <= lhs_and_1 nand rhs_and_2; -- XOR / XNOR gate_xor_1: res_xor_1 <= lhs_xor_1 xor rhs_xor_1; gate_xnor_1: res_xnor_1 <= lhs_xor_1 xnor rhs_xor_1; gate_xor_2: res_xor_2 <= lhs_xor_2 xor rhs_xor_2; gate_xnor_2: res_xnor_2 <= lhs_xor_2 xnor rhs_xor_2; gate_xor_3: res_xor_3 <= lhs_xor_1 xor rhs_xor_2; gate_xnor_3: res_xnor_3 <= lhs_xor_1 xnor rhs_xor_2; test_ctrl_proc: process begin wait for 1 ns; ----------------------------------------------------------------------- -- OR / NOR ----------------------------------------------------------------------- lhs_or_1 <= '1'; wait for 1 ns; rhs_or_2 <= '1'; wait for 1 ns; -- Reset back lhs_or_1 <= '0'; wait for 1 ns; rhs_or_2 <= '0'; wait for 1 ns; ----------------------------------------------------------------------- -- AND / NAND ----------------------------------------------------------------------- lhs_and_1 <= '1'; wait for 1 ns; rhs_and_2 <= '1'; wait for 1 ns; -- Reset back lhs_and_1 <= '0'; wait for 1 ns; rhs_and_2 <= '0'; wait for 1 ns; ----------------------------------------------------------------------- -- XOR / XNOR ----------------------------------------------------------------------- lhs_xor_1 <= '1'; wait for 1 ns; rhs_xor_2 <= '1'; wait for 1 ns; -- Reset back lhs_xor_1 <= '0'; wait for 1 ns; rhs_xor_2 <= '0'; wait for 1 ns; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover8.vhd000066400000000000000000000204771504111170000171130ustar00rootroot00000000000000 library ieee; use ieee.numeric_std.all; entity cover8 is end entity; architecture test of cover8 is -- OR / NOR signal lhs_or_1 : boolean := false; signal rhs_or_1 : boolean := false; signal res_or_1 : boolean; signal res_nor_1 : boolean; signal lhs_or_2 : boolean := false; signal rhs_or_2 : boolean := false; signal res_or_2 : boolean; signal res_nor_2 : boolean; signal res_or_3 : boolean; signal res_nor_3 : boolean; -- AND / NAND signal lhs_and_1 : boolean := false; signal rhs_and_1 : boolean := false; signal res_and_1 : boolean; signal res_nand_1 : boolean; signal lhs_and_2 : boolean := true; signal rhs_and_2 : boolean := true; signal res_and_2 : boolean; signal res_nand_2 : boolean; signal res_and_3 : boolean; signal res_nand_3 : boolean; -- XOR / XNOR signal lhs_xor_1 : boolean := false; signal rhs_xor_1 : boolean := false; signal res_xor_1 : boolean; signal res_xnor_1 : boolean; signal lhs_xor_2 : boolean := false; signal rhs_xor_2 : boolean := false; signal res_xor_2 : boolean; signal res_xnor_2 : boolean; signal res_xor_3 : boolean; signal res_xnor_3 : boolean; -- EQ / NEQ signal lhs_eq_1 : boolean := false; signal rhs_eq_1 : boolean := false; signal res_eq_1 : boolean; signal res_neq_1 : boolean; signal lhs_eq_2 : boolean := false; signal rhs_eq_2 : boolean := true; signal res_eq_2 : boolean; signal res_neq_2 : boolean; signal lhs_eq_3 : boolean := true; signal rhs_eq_3 : boolean := true; signal res_eq_3 : boolean; signal res_neq_3 : boolean; -- LT / GT signal lhs_lt_1 : integer := 0; signal rhs_lt_1 : integer := 0; signal res_lt_1 : boolean; signal res_gt_1 : boolean; signal lhs_lt_2 : integer := 10; signal rhs_lt_2 : integer := 5; signal res_lt_2 : boolean; signal res_gt_2 : boolean; signal lhs_lt_3 : integer := 7; signal rhs_lt_3 : integer := 20; signal res_lt_3 : boolean; signal res_gt_3 : boolean; signal lhs_lt_4 : integer := 0; signal rhs_lt_4 : integer := 0; signal res_lt_4 : boolean; signal res_gt_4 : boolean; -- LEQ / GEQ signal lhs_leq_1 : integer := 0; signal rhs_leq_1 : integer := 0; signal res_leq_1 : boolean; signal res_geq_1 : boolean; signal lhs_leq_2 : integer := 1; signal rhs_leq_2 : integer := 0; signal res_leq_2 : boolean; signal res_geq_2 : boolean; signal lhs_leq_3 : integer := 5; signal rhs_leq_3 : integer := 20; signal res_leq_3 : boolean; signal res_geq_3 : boolean; signal lhs_leq_4 : integer := 5; signal rhs_leq_4 : integer := 20; signal res_leq_4 : boolean; signal res_geq_4 : boolean; begin --------------------------------------------------------------------------- -- Logic ops on boolean --------------------------------------------------------------------------- -- OR / NOR gate_or_1: res_or_1 <= lhs_or_1 or rhs_or_1; gate_nor_1: res_nor_1 <= lhs_or_1 nor rhs_or_1; gate_or_2: res_or_2 <= lhs_or_2 or rhs_or_2; gate_nor_2: res_nor_2 <= lhs_or_2 nor rhs_or_2; gate_or_3: res_or_3 <= lhs_or_1 or rhs_or_2; gate_nor_3: res_nor_3 <= lhs_or_1 nor rhs_or_2; -- AND / NAND gate_and_1: res_and_1 <= lhs_and_1 and rhs_and_1; gate_nand_1: res_nand_1 <= lhs_and_1 nand rhs_and_1; gate_and_2: res_and_2 <= lhs_and_2 and rhs_and_2; gate_nand_2: res_nand_2 <= lhs_and_2 nand rhs_and_2; gate_and_3: res_and_3 <= lhs_and_1 and rhs_and_2; gate_nand_3: res_nand_3 <= lhs_and_1 nand rhs_and_2; -- XOR / XNOR gate_xor_1: res_xor_1 <= lhs_xor_1 xor rhs_xor_1; gate_xnor_1: res_xnor_1 <= lhs_xor_1 xnor rhs_xor_1; gate_xor_2: res_xor_2 <= lhs_xor_2 xor rhs_xor_2; gate_xnor_2: res_xnor_2 <= lhs_xor_2 xnor rhs_xor_2; gate_xor_3: res_xor_3 <= lhs_xor_1 xor rhs_xor_2; gate_xnor_3: res_xnor_3 <= lhs_xor_1 xnor rhs_xor_2; -- EQ / NEQ gate_eq_1: res_eq_1 <= true when (lhs_eq_1 = rhs_eq_1) else false; gate_neq_1: res_neq_1 <= true when (lhs_eq_1 /= rhs_eq_1) else false; gate_eq_2: res_eq_2 <= true when (lhs_eq_2 = rhs_eq_2) else false; gate_neq_2: res_neq_2 <= true when (lhs_eq_2 /= rhs_eq_2) else false; gate_eq_3: res_eq_3 <= true when (lhs_eq_3 = rhs_eq_3) else false; gate_neq_3: res_neq_3 <= true when (lhs_eq_3 /= rhs_eq_3) else false; -- LT / GT gate_lt_1: res_lt_1 <= true when (lhs_lt_1 < rhs_lt_1) else false; gate_gt_1: res_gt_1 <= true when (lhs_lt_1 > rhs_lt_1) else false; gate_lt_2: res_lt_2 <= true when (lhs_lt_2 < rhs_lt_2) else false; gate_gt_2: res_gt_2 <= true when (lhs_lt_2 > rhs_lt_2) else false; gate_lt_3: res_lt_3 <= true when (lhs_lt_3 < rhs_lt_3) else false; gate_gt_3: res_gt_3 <= true when (lhs_lt_3 > rhs_lt_3) else false; gate_lt_4: res_lt_4 <= true when (lhs_lt_4 < rhs_lt_4) else false; gate_gt_4: res_gt_4 <= true when (lhs_lt_4 > rhs_lt_4) else false; -- LEQ / GEQ gate_leq_1: res_leq_1 <= true when (lhs_leq_1 <= rhs_leq_1) else false; gate_geq_1: res_geq_1 <= true when (lhs_leq_1 >= rhs_leq_1) else false; gate_leq_2: res_leq_2 <= true when (lhs_leq_2 <= rhs_leq_2) else false; gate_geq_2: res_geq_2 <= true when (lhs_leq_2 >= rhs_leq_2) else false; gate_leq_3: res_leq_3 <= true when (lhs_leq_3 <= rhs_leq_3) else false; gate_geq_3: res_geq_3 <= true when (lhs_leq_3 >= rhs_leq_3) else false; gate_leq_4: res_leq_4 <= true when (lhs_leq_4 <= rhs_leq_4) else false; gate_geq_4: res_geq_4 <= true when (lhs_leq_4 >= rhs_leq_4) else false; test_ctrl_proc: process begin wait for 1 ns; ----------------------------------------------------------------------- -- OR / NOR ----------------------------------------------------------------------- lhs_or_1 <= true; wait for 1 ns; rhs_or_2 <= true; wait for 1 ns; -- Reset back lhs_or_1 <= false; wait for 1 ns; rhs_or_2 <= false; wait for 1 ns; ----------------------------------------------------------------------- -- AND / NAND ----------------------------------------------------------------------- lhs_and_1 <= true; wait for 1 ns; rhs_and_2 <= true; wait for 1 ns; -- Reset back lhs_and_1 <= false; wait for 1 ns; rhs_and_2 <= false; wait for 1 ns; ----------------------------------------------------------------------- -- XOR / XNOR ----------------------------------------------------------------------- lhs_xor_1 <= true; wait for 1 ns; rhs_xor_2 <= true; wait for 1 ns; -- Reset back lhs_xor_1 <= false; wait for 1 ns; rhs_xor_2 <= false; wait for 1 ns; ----------------------------------------------------------------------- -- EQ / NEQ ----------------------------------------------------------------------- -- EQ1 and EQ2 only init value covers 50 % of bins lhs_eq_3 <= true; wait for 1 ns; lhs_eq_3 <= false; wait for 1 ns; ----------------------------------------------------------------------- -- LT / GT ----------------------------------------------------------------------- lhs_lt_4 <= 1; wait for 1 ns; rhs_lt_4 <= 1; wait for 1 ns; lhs_lt_4 <= 5; wait for 1 ns; rhs_lt_4 <= 8; ----------------------------------------------------------------------- -- LEQ / GEQ ----------------------------------------------------------------------- lhs_leq_4 <= 1; wait for 1 ns; rhs_leq_4 <= 1; wait for 1 ns; lhs_leq_4 <= 5; wait for 1 ns; rhs_leq_4 <= 8; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/cover9.sh000077500000000000000000000016451504111170000167440ustar00rootroot00000000000000set -xe pwd which nvc # Exclude all uncovered things -> Test valid exclude file nvc -a $TESTDIR/regress/cover9.vhd -e --cover=all cover9 -r nvc --cover-report --exclude-file $TESTDIR/regress/data/cover9_ef1.txt \ -o html cover9.ncdb 2>&1 | tee out.txt # Test invalid command in exclude file nvc --cover-report --exclude-file $TESTDIR/regress/data/cover9_ef2.txt \ -o html1 cover9.ncdb 2>&1 | tee -a out.txt # Test invalid bin name nvc --cover-report --exclude-file $TESTDIR/regress/data/cover9_ef3.txt \ -o html2 cover9.ncdb 2>&1 | tee -a out.txt # Hierarchy missing nvc --cover-report --exclude-file $TESTDIR/regress/data/cover9_ef5.txt \ -o html4 cover9.ncdb 2>&1 | tee -a out.txt # Adjust output to be work directory relative sed -i -e "s/[^ ]*regress\/data\//data\//g" out.txt if [ ! -f html/index.html ]; then echo "missing coverage report" exit 1 fi diff -u $TESTDIR/regress/gold/cover9.txt out.txt nvc-r1.17.1/test/regress/cover9.vhd000066400000000000000000000076211504111170000171100ustar00rootroot00000000000000 library ieee; use ieee.std_logic_1164.all; entity sub_block is port ( a : in std_logic; b : in std_logic; y : out std_logic_vector(2 downto 0) ); end entity sub_block; architecture test of sub_block is begin xor_gate: y(0) <= a xor b; and_gate: process(a, b) begin if (a = '1' and b = '1') then y(1) <= '1'; else y(1) <= '0'; end if; end process; y(2) <= '0'; end architecture; library ieee; use ieee.std_logic_1164.all; entity cover9 is end entity; architecture test of cover9 is signal s_a : std_logic; signal s_b : std_logic; signal s_y : std_logic_vector(2 downto 0); signal a : std_logic := 'X'; signal b : std_logic := 'X'; signal y : std_logic; signal a1 : std_logic; signal b1 : std_logic; signal y1 : std_logic; signal sel : natural := 0; signal a2 : std_logic := '0'; begin ----------------------------------------------------------------------- -- Test control ----------------------------------------------------------------------- test_ctrl_proc: process begin ----------------------------------------------------------------------- -- Leaves out uncovered in sub_block: -- - single bin from XOR -- - expression in "if" condition evaluated to true -- - Branch evalueated to true -- - Statement in "else" -- - Toggle on y[2]. ----------------------------------------------------------------------- s_a <= '1'; wait for 1 ns; s_a <= '0'; wait for 1 ns; s_b <= '1'; wait for 1 ns; sel <= 1; wait for 1 ns; sel <= 2; wait for 1 ns; ----------------------------------------------------------------------- -- Tests that excluding toggles works ----------------------------------------------------------------------- a2 <= '1'; wait for 1 ns; wait; end process; --------------------------------------------------------------------------- -- Tests that wildcard completion for the hierarchy: -- - Excludes everything in the hierarchy -- - Warns and does not exclude already covered items --------------------------------------------------------------------------- sub_block_inst : entity work.sub_block port map ( a => s_a, b => s_b, y => s_y ); --------------------------------------------------------------------------- -- Tests that excluding bins 00,01,10,11 works --------------------------------------------------------------------------- P0: y <= a xor b; --------------------------------------------------------------------------- -- Tests that excluding statement and evaluated to True works --------------------------------------------------------------------------- and_gate: process(a1, b1) begin if (a1 = '1' and b1 = '1') then a: y1 <= '1'; else b: y1 <= '0'; end if; end process; --------------------------------------------------------------------------- -- Tests that excluding case choices bins and whole case choice works --------------------------------------------------------------------------- P1: process(sel) begin case_stmt: case sel is when 0 => rpt1: report "Selector is 0"; when 1 => rpt2: report "Selector is 1"; when 2 => rpt3: report "Selector is 2"; when 3 => rpt4: report "Selector is 3"; when 4 => rpt5: report "Selector is 4"; when others => rpt6: report "Selector is OTHERS"; end case; end process; end architecture; nvc-r1.17.1/test/regress/data/000077500000000000000000000000001504111170000161015ustar00rootroot00000000000000nvc-r1.17.1/test/regress/data/cover10_ef1.txt000066400000000000000000000000611504111170000206510ustar00rootroot00000000000000 exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* nvc-r1.17.1/test/regress/data/cover11_ef1.txt000066400000000000000000000000351504111170000206530ustar00rootroot00000000000000 exclude WORK.COVER11.ARR_B* nvc-r1.17.1/test/regress/data/cover13_spec.txt000066400000000000000000000002161504111170000211350ustar00rootroot00000000000000 +block leaf_entity -block not_interesting_entity +hierarchy WORK.COVER13.level_1_inst.* -hierarchy WORK.COVER13.level_1_inst.LEVEL_2_INST.* nvc-r1.17.1/test/regress/data/cover14_ef1.txt000066400000000000000000000001221504111170000206530ustar00rootroot00000000000000exclude WORK.COVER14._P0._S0._E6.BIN_1_1 exclude WORK.COVER14._P1._S0._E5.BIN_0_1 nvc-r1.17.1/test/regress/data/cover18_ef.txt000066400000000000000000000004411504111170000206020ustar00rootroot00000000000000exclude WORK.COVER18.CURR_STATE.BIN_STATE.ST_ONE exclude WORK.COVER18.CURR_STATE.BIN_STATE.ST_WAITING exclude WORK.COVER18.STATE_REG.BIN_STATE.S_10 exclude WORK.COVER18.STATE_REG.BIN_STATE.S_100 exclude WORK.COVER18.STATE_REG.BIN_STATE.S_200 exclude WORK.COVER18.STATE_REG.BIN_STATE.S_270nvc-r1.17.1/test/regress/data/cover19_spec.txt000066400000000000000000000000721504111170000211430ustar00rootroot00000000000000 +hierarchy * +fsm_type t_fsm_state +fsm_type t_subset_fsmnvc-r1.17.1/test/regress/data/cover23_ef.txt000066400000000000000000000001351504111170000205760ustar00rootroot00000000000000fold WORK_A.COVER23_TOP_TB.DUT_TOP_INST.SUB_BLOCK_INST WORK_B.COVER23_UNIT_TB.SUB_BLOCK_INST nvc-r1.17.1/test/regress/data/cover9_ef1.txt000066400000000000000000000037741504111170000206170ustar00rootroot00000000000000 ############################################################################### # Test wildcard exclude ############################################################################### exclude WORK.COVER9.SUB_BLOCK_INST.* ############################################################################### # Test statement excluding ############################################################################### exclude WORK.COVER9.AND_GATE._S0._B0.A exclude WORK.COVER9.P1.CASE_STMT.RPT4 exclude WORK.COVER9.p1.CASE_STMT.RPT5 exclude WORK.COVER9.P1.CASE_STMT.RPT6 ############################################################################### # Test branch excluding ############################################################################### # Bin evaluated to true exclude WORK.COVER9.AND_GATE._S0._B0.BIN_TRUE # Choice excluded with exact bin name exclude WORK.COVER9.P1.CASE_STMT._B3.BIN_CHOICE # All choices excluded exclude WORK.COVER9.P1.case_stmt._B4.* exclude WORK.COVER9.P1.CASE_STMT._B_OTHERS.* ############################################################################### # Test expression excluding ############################################################################### exclude WORK.COVER9.P0._S0._E0.BIN_0_0 exclude WORK.cover9.P0._S0._E1.BIN_0_1 exclude WORK.COVER9.P0._S0._E2.BIN_1_0 exclude WORK.COVER9.P0._S0._E3.BIN_1_1 exclude WORK.COVER9.AND_GATE._S0._B0._E4.* exclude WORK.COVER9.AND_GATE._S0._B0._E5.* exclude WORK.COVER9.AND_GATE._S0._B0._E6.* exclude WORK.COVER9.AND_GATE._S0._B0._E1.BIN_TRUE exclude WORK.COVER9.AND_GATE._S0._B0._E3.BIN_TRUE ############################################################################### # Test Toggle excluding ############################################################################### exclude WORK.COVER9.S_A.BIN_0_TO_1 exclude WORK.COVER9.S_B.* exclude WORK.COVER9.S_Y(2).BIN_0_TO_1 exclude WORK.COVER9.S_Y(2).BIN_1_TO_0 exclude WORK.COVER9.S_Y(1).* exclude WORK.COVER9.S_Y(0).* exclude WORK.COVER9.A.* exclude WORK.COVER9.B.* exclude WORK.COVER9.Y.* nvc-r1.17.1/test/regress/data/cover9_ef2.txt000066400000000000000000000002321504111170000206020ustar00rootroot00000000000000# Warning for tag which does not match any hierarchy exclude THIS_HIERARCHY_IS_FOR_SURE_INVALID_SHOULD_THROW_WARNING # Invalid command exducles HALO.HALOnvc-r1.17.1/test/regress/data/cover9_ef3.txt000066400000000000000000000001031504111170000206000ustar00rootroot00000000000000 # Invalid bin name WTF_BIN exclude WORK.COVER9.P0._S0._E0.WTF_BIN nvc-r1.17.1/test/regress/data/cover9_ef5.txt000066400000000000000000000000341504111170000206050ustar00rootroot00000000000000 # Missing hierarchy excludenvc-r1.17.1/test/regress/debug1.vhd000066400000000000000000000010631504111170000170420ustar00rootroot00000000000000entity debug1 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; architecture test of debug1 is signal fRn2 : std_logic_vector(22 downto 0); signal fR : std_logic_vector(23 downto 0); signal round : std_logic; begin warn: fRn2 <= shl(fR(23 downto 1), ((22 downto 1 => '0') & round)); -- rounding sqrt never changes exponents control: process is begin wait for 1 ns; report "simulation finished"; wait; end process; end architecture; nvc-r1.17.1/test/regress/debug2.vhd000066400000000000000000000025261504111170000170500ustar00rootroot00000000000000entity debug2 is end entity; architecture test of debug2 is procedure proc1 is begin report "proc1" severity warning; end procedure; begin p1: process is procedure proc2 is begin proc1; report "proc2" severity warning; end procedure; begin report "p1" severity warning; proc1; proc2; wait; end process; b1: block is procedure proc3 is begin report "proc3" severity warning; end procedure; begin p2: process is procedure proc4 is begin report "proc4" severity warning; end procedure; begin wait for 1 ns; proc3; proc4; proc1; report "p2" severity warning; wait; end process; end block; g1: if 2 > 1 generate begin p3: process is begin wait for 2 ns; report "p3" severity warning; wait; end process; g2: for i in 1 to 1 generate begin p4: process is begin wait for 3 ns; report "p4" severity warning; wait; end process; end generate; end generate; end architecture; nvc-r1.17.1/test/regress/debug3.vhd000066400000000000000000000016671504111170000170560ustar00rootroot00000000000000use std.textio.all; package broken_module is type prot_t is protected procedure proc; end protected; end package; package body broken_module is type prot_t is protected body variable var : natural := 0; procedure file_proc is file fwrite : text; variable s : string(1 to 3); begin file_open(fwrite, "tmp", WRITE_MODE); file_close(fwrite); write(fwrite, s); -- Write to closed file end procedure; procedure proc is begin file_proc; var := 0; -- Comment out this and it will not fail end procedure; end protected body; end package body; ------------------------------------------------------------------------------- entity debug3 is end entity; use work.broken_module.all; architecture test of debug3 is shared variable p : prot_t; begin process is begin p.proc; wait; end process; end architecture; nvc-r1.17.1/test/regress/debug4.vhd000066400000000000000000000012201504111170000170400ustar00rootroot00000000000000entity debug4 is end entity; architecture test of debug4 is function func2 (x : bit_vector) return bit_vector is begin report "warning" severity warning; return x; end function; function func1 (x : bit_vector) return bit_vector is begin return func2(x); end function; signal s1 : bit_vector(7 downto 0); signal s2 : bit_vector(3 downto 0); begin b: block is port (p1 : in bit_vector(3 downto 0); p2 : out bit_vector(7 downto 0)); port map (p1 => func1(s1(3 downto 0)), func1(p2(3 downto 0)) => s2); begin end block; end architecture; nvc-r1.17.1/test/regress/default1.vhd000066400000000000000000000016141504111170000174020ustar00rootroot00000000000000entity default1 is end entity; architecture test of default1 is signal s : positive; begin process is type mat2x2 is array (1 to 2, 1 to 2) of natural; type int_array10 is array (1 to 10) of positive; type int_array5 is array (5 to 7) of positive; variable x : integer; variable v : bit_vector(1 to 3); variable m : mat2x2; variable p : int_array10; variable q : int_array5; begin assert s = 1; assert x = integer'left; assert v = ('0', '0', '0'); assert m = ((0, 0), (0, 0)); assert p = (1 to 10 => 1); assert q = (5 to 7 => 1); assert p'left = 1; assert p'right = 10; assert q'left = 5; assert q'right = 7; assert q'length = 3; s <= 4; -- FIXME wait; end process; end architecture; nvc-r1.17.1/test/regress/default2.vhd000066400000000000000000000022501504111170000174000ustar00rootroot00000000000000entity default2 is end entity; architecture test of default2 is procedure proc1 (x : integer) is type real_vec is array (integer range <>) of real; variable v : real_vec(1 to x); begin assert v(1) = real'left; assert v(x) = real'left; end procedure; procedure proc2 (x : integer) is type rec is record x : real; y : bit_vector(1 to x); end record; type rec_vec is array (natural range <>) of rec; variable v : rec_vec(1 to x); begin assert v(1).x = real'left; assert v(1).y = (1 to x => '0'); assert v(x).x = real'left; assert v(x).y = (1 to x => '0'); end procedure; procedure proc3 (x : integer) is type int_ptr is access integer; type rec is record x : int_ptr; end record; type rec_vec is array (natural range <>) of rec; variable v : rec_vec(1 to x); begin assert v(1).x = null; assert v(x).x = null; end procedure; begin main: process is begin proc1(5); proc2(6); proc3(2); wait; end process; end architecture; nvc-r1.17.1/test/regress/delay1.vhd000066400000000000000000000032131504111170000170510ustar00rootroot00000000000000entity delay1 is end entity; architecture test of delay1 is signal x, y1, y2 : bit; begin y1 <= transport x after 450 ps; y2 <= reject 500 ps inertial x after 950 ps; process is begin -- Test transport delay mechanism x <= '1'; -- 0 wait for 1 ns; assert y1 = '1'; -- 1000 x <= '0'; wait for 200 ps; assert y1 = '1'; -- 1200 x <= '1'; wait for 100 ps; assert y1 = '1'; -- 1300 x <= '0'; wait for 200 ps; assert y1 = '0'; -- 1500 wait for 200 ps; assert y1 = '1'; -- 1700 wait for 100 ps; assert y1 = '0'; -- 1800 x <= transport '1' after 100 ps; x <= transport '0' after 100 ps; wait for 500 ps; assert x = '0'; -- 2300 assert y1 = '0'; x <= transport '1' after 200 ps; x <= transport '0' after 100 ps; wait for 700 ps; assert x = '0'; -- 3000 assert y1 = '0'; assert now = 3000 ps; -- Test inertial delay mechanism assert y2 = '0'; x <= '1'; wait for 500 ps; x <= '0'; -- 3500 wait for 200 ps; x <= '1'; -- 3700 wait for 300 ps; assert y2 = '0'; -- 4000 wait for 500 ps; assert y2 = '0'; -- 4500 wait for 200 ps; assert y2 = '1'; -- 4700 wait; end process; end architecture; nvc-r1.17.1/test/regress/delay2.vhd000066400000000000000000000015161504111170000170560ustar00rootroot00000000000000entity delay2 is end entity; architecture test of delay2 is signal clk : bit; begin clock_p: process is begin if now < 1 us then clk <= '1' after 5 ns, '0' after 10 ns; wait for 10 ns; else wait; end if; end process; check_p: process is variable now_ns : integer; begin if now < 1 us then wait for 0 ns; now_ns := integer(now / ns); case now_ns mod 10 is when 0 => assert clk = '0'; when 5 => assert clk = '1'; when others => report "clk changed at unexpected time"; end case; wait for 5 ns; else wait; end if; end process; end architecture; nvc-r1.17.1/test/regress/delay3.vhd000066400000000000000000000003711504111170000170550ustar00rootroot00000000000000entity delay3 is end entity; architecture test of delay3 is signal x : bit; begin p1: process is variable v : time := 5 ns; begin x <= reject v inertial '1' after 2 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver1.vhd000066400000000000000000000023061504111170000172500ustar00rootroot00000000000000entity driver1 is end entity; architecture test of driver1 is type u is (A, B, C); type uv is array (natural range <>) of u; function func (x : uv) return u is begin --report "func called"; for i in x'range loop -- report u'image(x(i)); end loop; for i in x'range loop if x(i) = A then return A; end if; end loop; return B; end function; subtype r is func u; signal s : r := B; signal k : r := C; begin one: process is begin assert s = B; s <= A; wait for 1 ns; assert s = A; s <= B; wait for 1 ns; assert s = B; null; wait for 1 ns; assert s = A; wait; end process; two: process is begin assert s = B; s <= B; wait for 1 ns; assert s = A; null; wait for 1 ns; assert s = B; s <= A; wait for 1 ns; assert s = A; wait; end process; three: process is begin k <= C; wait for 1 ns; assert k = B; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver10.vhd000066400000000000000000000033371504111170000173350ustar00rootroot00000000000000package pack is type op_t is (IDLE, DO_A, DO_B, CLASH); type op_vec_t is array (natural range <>) of op_t; function resolved (s : op_vec_t) return op_t; subtype r_op_t is resolved op_t; end package; package body pack is function resolved (s : op_vec_t) return op_t is variable result : op_t := IDLE; begin for i in s'range loop if result = IDLE then result := s(i); elsif s(i) /= IDLE then result := CLASH; exit; end if; end loop; report "result=" & op_t'image(result); return result; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( s : inout r_op_t; done : out boolean ); end entity; architecture test of sub is begin p1: process is begin assert s = idle; wait on s; assert now = 1 ns; assert s = do_a; wait on s; assert now = 2 ns; assert s = do_b; done <= true; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity driver10 is end entity; architecture test of driver10 is signal t : r_op_t := IDLE; signal done : boolean := false; begin uut: entity work.sub port map (t, done); p2: process is begin assert t = IDLE; wait for 1 ns; t <= DO_A; wait for 1 ns; t <= DO_B; wait; end process; p3: process is begin wait for 1 hr; assert done = true; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver11.vhd000066400000000000000000000015721504111170000173350ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub is port ( x : inout std_logic ); end entity; architecture test of sub is begin p1: process is begin x <= '1'; wait for 1 ns; x <= '0'; wait for 0 ns; assert x'active; assert not x'event; assert x = 'U'; x <= 'L'; wait for 0 ns; assert x'active; assert not x'event; assert x = 'U'; assert x = x'last_value; wait; end process; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity driver11 is end entity; architecture test of driver11 is signal y : std_logic; begin u: entity work.sub port map ( y ); p2: process is begin y <= 'U'; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver12.vhd000066400000000000000000000030571504111170000173360ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package pack is type rec is record x : std_logic; y : std_logic_vector(2 downto 0); end record; function init_signals return rec; end package; package body pack is function init_signals return rec is begin return (x => 'Z', y => "000"); end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( p : inout rec := init_signals ); end entity; library ieee; use ieee.std_logic_1164.all; architecture test of sub is begin p1: process is begin assert p.x = '0'; assert p.y = "000"; wait for 1 ns; assert p.x = '1'; wait; end process; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity sub2 is port ( x : out std_logic := '0'; y : in std_logic_vector(2 downto 0) ); end entity; architecture test of sub2 is begin x <= '0', '1' after 1 ns; end architecture; ------------------------------------------------------------------------------- entity driver12 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of driver12 is signal s : std_logic; signal t : std_logic_vector(2 downto 0); begin u1: entity work.sub port map ( p.x => s, p.y => t ); u2: entity work.sub2 port map ( x => s, y => t ); end architecture; nvc-r1.17.1/test/regress/driver13.vhd000066400000000000000000000030111504111170000173250ustar00rootroot00000000000000entity driver13 is end entity; architecture test of driver13 is constant MAX_NAME_LENGTH : positive := 20; type t_channel is (NA, ALL_CHANNELS, RX, TX); type t_record_unresolved is record trigger : bit; vvc_name : string(1 to MAX_NAME_LENGTH); vvc_instance_idx : integer; vvc_channel : t_channel; end record; constant C_VVC_TARGET_RECORD_DEFAULT : t_record_unresolved := ( trigger => '0', vvc_name => (others => '?'), vvc_instance_idx => -1, vvc_channel => NA ); -- type t_record_drivers is array (natural range <> ) of t_record_unresolved; function resolved ( input : t_record_drivers) return t_record_unresolved; subtype t_record is resolved t_record_unresolved; function resolved ( input : t_record_drivers) return t_record_unresolved is variable v_result : t_record_unresolved := input(input'low); begin for i in input'range loop report to_string(i) & ": trigger=" & to_string(input(i).trigger) & " vvc_name=" & input(i).vvc_name; assert input(i).vvc_name(1 to 5) = "hello" or input(i).vvc_name(1 to 5) = "world" or input(i).vvc_name(1 to 5) = (1 to 5 => NUL); end loop; return v_result; end resolved; signal s : t_record; begin p1: s <= ('0', ("hello", others => NUL), 1, RX); p2: s <= ('1', ("world", others => NUL), 2, TX); end architecture; nvc-r1.17.1/test/regress/driver14.vhd000066400000000000000000000011521504111170000173320ustar00rootroot00000000000000entity driver14 is end entity; architecture test of driver14 is type rec is record x, y : natural; end record; type rec_array is array (natural range <>) of rec; function resolved (x : rec_array) return rec is begin return x(0); -- Returns pointer to its argument end function; subtype rrec is resolved rec; signal s : rrec; begin p1: s <= (1, 2); p2: s <= (3, 4); p3: process is begin assert s = (0, 0); wait for 0 ns; assert s = (1, 2) or s = (3, 4); wait; end process; end architecture; nvc-r1.17.1/test/regress/driver15.vhd000066400000000000000000000010101504111170000173240ustar00rootroot00000000000000entity driver15 is end entity; architecture test of driver15 is function resolved (x : bit_vector) return bit is variable r : bit := '0'; begin for i in x'range loop r := r or x(i); end loop; report "result is " & bit'image(r); return r; end function; subtype rbit is resolved bit; signal s : rbit; begin p1: s <= '0'; p2: process is begin wait for 1 ns; s <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver16.vhd000066400000000000000000000004671504111170000173440ustar00rootroot00000000000000entity driver16 is end entity; architecture test of driver16 is signal s : bit_vector(1 to 3); begin p1: process is variable i : natural := 2; begin s <= "101"; s(i) <= '1'; wait for 0 ns; assert s = "111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver17.vhd000066400000000000000000000010251504111170000173340ustar00rootroot00000000000000entity driver17 is end entity; architecture test of driver17 is signal s : bit_vector(1 to 8); begin p1: process is begin s <= X"00"; for i in 1 to 8 loop s(i) <= '1'; end loop; wait for 1 ns; assert s = X"ff"; s(4) <= '0' after 0 ns, '1' after 2 ns; s(1 to 3) <= "111"; wait for 1 ns; assert s = "11101111"; s(5 to 8) <= X"f"; wait for 1 ns; assert s = X"ff"; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver18.vhd000066400000000000000000000021531504111170000173400ustar00rootroot00000000000000package pack is type t_nat_vec is array (natural range <>) of natural; function count_drivers (inputs : t_nat_vec) return natural; subtype t_rnat is count_drivers natural; end package; package body pack is function count_drivers (inputs : t_nat_vec) return natural is begin return inputs'length; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o : out t_rnat ); end entity; architecture three_drivers of sub is begin o <= 6; o <= 52; o <= 99; postponed assert o = 3; end architecture; architecture no_drivers of sub is begin postponed assert o = 0; end architecture; ------------------------------------------------------------------------------- entity driver18 is end entity; use work.pack.all; architecture test of driver18 is signal s : t_rnat; begin u1: entity work.sub(three_drivers) port map ( s ); u2: entity work.sub(no_drivers) port map ( s ); s <= 777; s <= 100; postponed assert s = 4; end architecture; nvc-r1.17.1/test/regress/driver19.vhd000066400000000000000000000025041504111170000173410ustar00rootroot00000000000000package pack is type t_nat_vec is array (natural range <>) of natural; function count_drivers (inputs : t_nat_vec) return natural; subtype t_rnat is count_drivers natural; impure function get_limit return integer; end package; package body pack is function count_drivers (inputs : t_nat_vec) return natural is begin return inputs'length; end function; impure function get_limit return integer is begin return 3; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( o : out t_rnat ); end entity; architecture three_drivers of sub is constant limit : integer := get_limit; begin g: for i in 1 to limit generate o <= 6; end generate; postponed assert o = 3; end architecture; architecture no_drivers of sub is begin postponed assert o = 0; end architecture; ------------------------------------------------------------------------------- entity driver19 is end entity; use work.pack.all; architecture test of driver19 is signal s : t_rnat; begin u1: entity work.sub(three_drivers) port map ( s ); u2: entity work.sub(no_drivers) port map ( s ); s <= 777; s <= 100; postponed assert s = 4; end architecture; nvc-r1.17.1/test/regress/driver2.vhd000066400000000000000000000006551504111170000172560ustar00rootroot00000000000000entity driver2 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of driver2 is signal x : std_logic; begin x <= 'H'; p1: process is begin x <= 'Z'; wait for 1 ns; assert x = 'H'; x <= '0'; wait for 1 ns; assert x = '0'; x <= 'Z'; wait for 1 ns; assert x = 'H'; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver20.vhd000066400000000000000000000024241504111170000173320ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity driver20 is end entity; architecture test of driver20 is constant PERIOD : time := 10 ns; signal clk : std_logic; signal running : boolean := true; begin g: for i in 1 to 2 generate b: block is port ( oclk : out std_logic ); port map ( clk ); signal xclk : std_logic := '1'; begin xclk <= not xclk after PERIOD/2 when running; oclk <= xclk; end block; end generate; check: process is begin assert clk = 'U'; wait for 0 ns; assert clk = '1'; assert not rising_edge(clk); assert not falling_edge(clk); wait for PERIOD / 2; assert clk = '1'; assert not rising_edge(clk); assert not falling_edge(clk); wait for 0 ns; assert clk = '0'; assert not rising_edge(clk); assert falling_edge(clk); wait for PERIOD / 2; assert clk = '0'; assert not rising_edge(clk); assert not falling_edge(clk); wait for 0 ns; assert clk = '1'; assert rising_edge(clk); assert not falling_edge(clk); running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver21.vhd000066400000000000000000000010401504111170000173240ustar00rootroot00000000000000entity driver21 is end entity; architecture test of driver21 is type t_rec is record x, y : natural; end record; type t_rec_array is array (natural range <>) of t_rec; function resolved (r : t_rec_array) return t_rec is begin assert r(0).x = 1 severity failure; assert r(0).y = 2 severity failure; return r(0); end function; subtype t_resolved_rec is resolved t_rec; signal s : t_resolved_rec := (1, 2); begin s <= (6, 7) after 1 ns; s <= (3, 4); end architecture; nvc-r1.17.1/test/regress/driver22.vhd000066400000000000000000000011041504111170000173260ustar00rootroot00000000000000entity driver22 is end entity; architecture test of driver22 is type t_rec is record f, g : integer; end record; type t_rec_array is array (natural range <>) of t_rec; view t_rec_in of t_rec is f : in; g : out; end view; signal s : t_rec; begin b: block is port ( p : view (t_rec_in) of t_rec_array ); port map ( p(0) => s ); begin process (all) is variable sel : natural := 0; begin p(sel).g <= p(sel).f + 1; end process; end block; end architecture; nvc-r1.17.1/test/regress/driver23.vhd000066400000000000000000000012501504111170000173310ustar00rootroot00000000000000entity driver23 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of driver23 is type t_rec is record x : std_logic; y : std_logic_vector(7 downto 0); end record; signal s : t_rec; begin s <= ('1', X"Z0"); b: block is port ( p : out t_rec ); port map ( s ); begin check: process is begin p <= ('0', X"5Z"); wait for 0 ns; report to_string(p.x); report to_string(p.y); assert p = ('0', X"5Z"); assert p'driving_value = ('0', X"5Z"); wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/driver3.vhd000066400000000000000000000006741504111170000172600ustar00rootroot00000000000000entity driver3 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of driver3 is signal x : std_logic_vector(0 to 0); begin x <= "H"; p1: process is begin x <= "Z"; wait for 1 ns; assert x = "H"; x <= "0"; wait for 1 ns; assert x = "0"; x <= "Z"; wait for 1 ns; assert x = "H"; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver4.vhd000066400000000000000000000012051504111170000172500ustar00rootroot00000000000000entity sub is port ( x : out integer := 5 ); end entity; architecture test of sub is begin p1: process is begin wait for 20 ns; x <= 10; wait; end process; end architecture; ------------------------------------------------------------------------------- entity driver4 is end entity; architecture test of driver4 is signal x : integer := 50; begin sub_i: entity work.sub port map ( x => x ); p2: process is begin report integer'image(x); assert x = 5; wait for 30 ns; assert x = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver5.vhd000066400000000000000000000010011504111170000172430ustar00rootroot00000000000000entity driver5 is end entity; architecture test of driver5 is type int_vec is array (integer range <>) of integer; function resolved(x : int_vec) return integer is begin return x'length; end function; subtype rint is resolved integer; signal s : rint; begin s <= 5; process is begin assert s = 2; wait for 0 ns; assert s = 2; s <= 4; wait for 1 ns; assert s = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver6.vhd000066400000000000000000000027461504111170000172650ustar00rootroot00000000000000entity driver6 is end entity; architecture test of driver6 is type int_vec is array (natural range <>) of integer; function resolved (v : int_vec) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; subtype rint is resolved integer; signal x : rint := 0; type rint_vec is array (natural range <>) of rint; signal y : rint_vec(1 to 2) := (0, 0); signal z : natural; begin p1: process is begin x <= 1; assert x'driving_value = 0; wait for 1 ns; assert x = 3; assert x'driving; assert x'driving_value = 1; wait; end process; p2: process is begin x <= 2; assert x'driving_value = 0; wait for 1 ns; assert x'driving; assert x'driving_value = 2; wait; end process; p3: process is begin y <= (1, 2); wait for 1 ns; assert y = (6, 2); assert y'driving; assert y'driving_value = (1, 2); wait; end process; p4: process is begin y(1) <= 5; wait for 1 ns; assert not y'driving; wait; end process; p5: process is begin z <= 1; assert z = 0; assert z'driving_value = 0; wait for 1 ns; assert z'driving_value = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/driver7.vhd000066400000000000000000000013371504111170000172610ustar00rootroot00000000000000entity driver7 is end entity; architecture test of driver7 is type int_vec is array (natural range <>) of integer; function resolved (v : int_vec) return integer is variable result : integer := 0; begin for i in v'range loop result := result + v(i); end loop; return result; end function; subtype rint is resolved integer; signal x : rint := 0; begin p1: process is begin x <= 1; wait for 1 ns; assert x = 3; assert x'driving; assert x'driving_value = 1; wait; end process; p2: process is begin assert x'driving; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/driver8.vhd000066400000000000000000000062671504111170000172710ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub is generic ( n : natural range 0 to 1 ); port ( x : inout std_logic ); end entity; architecture test of sub is begin p1: process is begin assert x = 'U'; wait for 1 ns; case n is when 0 => x <= 'L'; wait for 0 ns; assert x'active; assert x'event; assert x = '0' report "expected '0' got " & std_logic'image(x); wait for 0 ns; assert x'active; assert x'event; wait for 0 ns; assert x'active; assert x'event; x <= '1'; wait for 0 ns; assert x'active; assert x'event; when 1 => x <= '0'; wait for 0 ns; assert x = '0' report "expected '0' got " & std_logic'image(x); assert x'active; assert x'event report "no event: " & std_logic'image(x'last_value) & " -> " & std_logic'image(x); x <= '1'; wait for 0 ns; assert x'active; assert x'event; assert x = '1' report "expected '1' got " & std_logic'image(x); x <= 'Z'; wait for 0 ns; assert x'active; assert x'event; assert x = 'L' report "expected 'L' got " & std_logic'image(x); wait for 0 ns; assert x'active; assert x'event; assert x = '1' report "expected '1' got " & std_logic'image(x); wait for 5 ns; assert x = 'X' report "expected 'X' got " & std_logic'image(x); x <= '1'; wait for 0 ns; assert x'active; assert not x'event; end case; wait; end process; p2: process is begin x <= 'Z'; for i in 1 to 4 loop wait on x; end loop; assert x = '1'; wait for 1 ns; x <= '0'; wait; end process; end architecture; ------------------------------------------------------------------------------- entity driver8 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of driver8 is signal y : std_logic; begin sub1: entity work.sub generic map ( 0 ) port map ( y ); sub2: entity work.sub generic map ( 1 ) port map ( y ); p1: process is begin assert y = 'U'; wait for 1 ns; assert y = 'U' report "expected 'U' got " & std_logic'image(y); wait for 0 ns; assert y = '0' report "expected '0' got " & std_logic'image(y); wait for 0 ns; assert y = '1' report "expected '1' got " & std_logic'image(y); wait for 0 ns; assert y = 'L' report "expected 'L' got " & std_logic'image(y); wait for 1 ns; assert y = '1' report "expected '1' got " & std_logic'image(y); wait for 5 ns; assert y = 'X' report "expected 'X' got " & std_logic'image(y); wait; end process; end architecture; nvc-r1.17.1/test/regress/driver9.vhd000066400000000000000000000003031504111170000172530ustar00rootroot00000000000000entity driver9 is end entity; architecture test of driver9 is signal x : integer; begin x <= 1; x <= 2; -- Error, this used to be detected statically end architecture; nvc-r1.17.1/test/regress/elab1.vhd000066400000000000000000000012201504111170000166520ustar00rootroot00000000000000entity elab1_bot is port ( i : in integer; o : out integer ); end entity; architecture test of elab1_bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity elab1 is end entity; architecture test of elab1 is signal x, y : integer; begin uut: entity work.elab1_bot port map ( x, y ); process is begin x <= 0; wait for 1 ns; assert y = 1; x <= 2; wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab10.vhd000066400000000000000000000013071504111170000167400ustar00rootroot00000000000000entity sub is port ( a : in bit_vector ); end entity; architecture test of sub is begin process (a) begin report a'path_name & " range is " & integer'image(a'left) & " to " & integer'image(a'right) ; end process; end architecture; ------------------------------------------------------------------------------- entity elab10 is end entity; architecture test of elab10 is signal x : bit_vector(1 to 5); signal y : bit_vector(6 to 10); begin sub1_i: entity work.sub port map ( x ); sub2_i: entity work.sub port map ( y ); process is begin y <= not y after 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab11.vhd000066400000000000000000000013611504111170000167410ustar00rootroot00000000000000entity sub is port ( x, y : in bit_vector(3 downto 0); z : out bit_vector(7 downto 0) ); end entity; architecture test of sub is begin z <= x & y; end architecture; ------------------------------------------------------------------------------- entity elab11 is end entity; architecture test of elab11 is signal a, b : bit_vector(7 downto 0); begin sub_i: entity work.sub port map ( x => a(7 downto 4), y => a(5 downto 2), z => b ); process is begin a <= "11110000"; wait for 1 ns; assert b = "11111100"; a <= "10110011"; wait for 1 ns; assert b = "10111100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab12.vhd000066400000000000000000000015371504111170000167470ustar00rootroot00000000000000entity sub is generic ( WIDTH : integer ); port ( x : in bit; y : out bit_vector(WIDTH - 1 downto 0) ); end entity; architecture test of sub is begin y <= (WIDTH - 1 downto 0 => x); end architecture; ------------------------------------------------------------------------------- entity elab12 is end entity; architecture test of elab12 is signal x1, x2 : bit; signal y1 : bit_vector(3 downto 0); signal y2 : bit_vector(4 downto 0); begin sub2_i: entity work.sub generic map ( 5 ) port map ( x2, y2 ); sub1_i: entity work.sub generic map ( 4 ) port map ( x1, y1 ); process is begin x1 <= '0'; x2 <= '1'; wait for 1 ns; assert y1 = "0000"; assert y2 = "11111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab13.vhd000066400000000000000000000016171504111170000167470ustar00rootroot00000000000000entity recur is generic ( DEPTH : natural; delay : delay_length ); end entity; architecture test of recur is begin base_g: if DEPTH = 0 generate process is begin wait for delay; report recur'path_name; wait; end process; end generate; recur_g: if DEPTH > 0 generate recur1_i: entity work.recur generic map ( DEPTH => DEPTH - 1, delay => delay ); recur2_i: entity work.recur generic map ( DEPTH => DEPTH - 1, delay => delay + (2**(depth-1)) * ns ); end generate; end architecture; ------------------------------------------------------------------------------- entity elab13 is end entity; architecture test of elab13 is begin top_i: entity work.recur generic map ( DEPTH => 3, delay => 0 ns ); end architecture; nvc-r1.17.1/test/regress/elab14.vhd000066400000000000000000000020761504111170000167500ustar00rootroot00000000000000entity sub is port ( i : in bit_vector(7 downto 0); o : out bit_vector(7 downto 0) ); end entity; architecture test of sub is begin o <= not i after 1 ns; end architecture; ------------------------------------------------------------------------------- entity elab14 is end entity; architecture test of elab14 is signal a : bit_vector(1 downto 0); signal b : bit_vector(5 downto 0); signal c : bit_vector(5 downto 2); signal d : bit_vector(3 downto 0); begin sub_i: entity work.sub port map ( i(1 downto 0) => a, i(7 downto 2) => b, o(3 downto 0) => c, o(7 downto 4) => d ); process is begin assert c = "0000"; assert d = "0000"; wait for 2 ns; assert c = "1111"; assert d = "1111"; a <= "11"; wait for 2 ns; assert c = "1100"; assert d = "1111"; b <= "011110"; wait for 2 ns; assert c = "0100"; assert d = "1000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab15.vhd000066400000000000000000000006271504111170000167510ustar00rootroot00000000000000entity sub is port ( x : in bit; y : out bit_vector(0 downto 0) ); end entity; architecture test of sub is begin y(0) <= x after 1 ps; end architecture; ------------------------------------------------------------------------------- entity elab15 is end entity; architecture test of elab15 is begin sub_i: entity work.sub port map ( x => '1' ); end architecture; nvc-r1.17.1/test/regress/elab16.vhd000066400000000000000000000021671504111170000167530ustar00rootroot00000000000000package elab16_pack is type int8 is array (7 downto 0) of integer; type int8_vector is array (integer range <>) of int8; end package; ------------------------------------------------------------------------------- use work.elab16_pack.all; entity sub is generic ( val : integer ); port ( x : out int8 ); end entity; architecture test of sub is begin xg: for i in int8'range generate x(i) <= val + i; end generate; end architecture; ------------------------------------------------------------------------------- entity elab16 is end entity; use work.elab16_pack.all; architecture test of elab16 is signal xs : int8_vector(0 to 7); begin sub_g: for i in 0 to 7 generate sub_i: entity work.sub generic map ( val => i * 8 ) port map ( x => xs(i) ); end generate; process is begin wait for 1 ns; for i in 0 to 7 loop for j in 0 to 7 loop assert xs(i)(j) = (i * 8) + j; end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab17.vhd000066400000000000000000000015131504111170000167460ustar00rootroot00000000000000entity sub is generic ( NUM : integer ); port ( s : in bit ); end entity; architecture test of sub is begin process is begin wait for (NUM * 10 ns) + 1 ns; assert s = '1'; wait; end process; end architecture; ------------------------------------------------------------------------------- entity elab17 is end entity; architecture test of elab17 is signal vec : bit_vector(2 downto 0); begin gen: for i in 0 to 2 generate signal s : bit; begin sub_i: entity work.sub generic map ( i ) port map ( vec(i) ); end generate; process is begin vec <= "001"; wait for 10 ns; vec <= "010"; wait for 10 ns; vec <= "100"; wait for 10 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab18.vhd000066400000000000000000000017411504111170000167520ustar00rootroot00000000000000entity sub is port ( a : in bit_vector(1 downto 0); b, c : out bit_vector(1 downto 0); d : out bit_vector(1 downto 0) := "00" ); end entity; architecture test of sub is begin p1: (b(0), c(0)) <= a; p2: (b(1), c(1)) <= a; p3: d(1) <= '1'; end architecture; ------------------------------------------------------------------------------- entity elab18 is end entity; architecture test of elab18 is signal a1, b1, a2, b2 : bit_vector(1 downto 0); begin sub1_i: entity work.sub port map ( a => a1, b => b1, c => open ); p4: process is begin a1 <= "01"; wait for 1 ns; assert b1 = "00"; wait; end process; sub2_i: entity work.sub port map ( a => a2, b => b2 ); p5: process is begin a2 <= "10"; wait for 1 ns; assert b2 = "11"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab19.vhd000066400000000000000000000016241504111170000167530ustar00rootroot00000000000000entity sub2 is port ( x : in bit; y : out bit ); end entity; architecture test of sub2 is begin y <= x after 1 ns; end architecture; ------------------------------------------------------------------------------- entity sub1 is port ( x : in bit_vector(7 downto 0); y : out bit_vector(7 downto 0) ); end entity; architecture test of sub1 is begin sub_g: for i in x'range generate sub2_i: entity work.sub2 port map ( x(i), y(i) ); end generate; end architecture; ------------------------------------------------------------------------------- entity elab19 is end entity; architecture test of elab19 is signal o : bit_vector(7 downto 0); begin sub1_i: entity work.sub1 port map ( X"ab", o ); process is begin wait for 2 ns; assert o = X"ab"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab2.vhd000066400000000000000000000013741504111170000166650ustar00rootroot00000000000000entity elab2_bot is port ( i : in integer; o : out integer ); end entity; architecture test of elab2_bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity elab2 is end entity; architecture test of elab2 is signal a, b, c : integer; begin bot1: entity work.elab2_bot port map ( a, b ); bot2: entity work.elab2_bot port map ( b, c ); process is begin a <= 0; wait for 1 ns; assert b = 1; assert c = 2; a <= 2; wait for 1 ns; assert b = 3; assert c = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab20.vhd000066400000000000000000000015261504111170000167440ustar00rootroot00000000000000entity sub is generic ( WIDTH : integer; INIT : bit ); port ( x : out bit_vector(31 downto 0); y : in bit_vector(WIDTH - 1 downto 0) ); end entity; architecture test of sub is signal y1 : bit_vector(WIDTH - 1 downto 0); begin x <= (31 downto WIDTH => '0') & y1; y1 <= y; end architecture; ------------------------------------------------------------------------------- entity elab20 is end entity; architecture test of elab20 is signal x : bit_vector(31 downto 0); signal y : bit_vector(7 downto 0); begin process is begin y <= X"55"; wait for 1 ns; assert x = X"00000055"; wait; end process; sub_i: entity work.sub generic map ( WIDTH => 8, INIT => '0' ) port map ( x, y ); end architecture; nvc-r1.17.1/test/regress/elab21.vhd000066400000000000000000000017571504111170000167530ustar00rootroot00000000000000package pack is type rec is record a, b : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( x : in integer; y : out integer; r : in rec ); end entity; architecture test of sub is begin y <= x + r.a + r.b; end architecture; ------------------------------------------------------------------------------- entity elab21 is end entity; use work.pack.all; architecture test of elab21 is signal r1, r2 : rec := (0, 0); begin sub_i: entity work.sub port map ( x => r1.a, y => r1.b, r => r2 ); process is begin r1.a <= 0; r2 <= (0, 0); wait for 1 ns; assert r1.b = 0; r1.a <= 5; wait for 1 ns; assert r1.b = 5; r2 <= (2, 3); wait for 1 ns; assert r1.b = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab22.vhd000066400000000000000000000020261504111170000167420ustar00rootroot00000000000000entity sub is port ( i : in bit_vector(0 to 7); o : out bit_vector(0 to 7) ); end entity; architecture test of sub is begin o <= not i after 1 ns; end architecture; ------------------------------------------------------------------------------- entity elab22 is end entity; architecture test of elab22 is signal a : bit_vector(0 to 1); signal b : bit_vector(0 to 5); signal c : bit_vector(2 to 5); signal d : bit_vector(0 to 3); begin sub_i: entity work.sub port map ( i(0 to 1) => a, i(2 to 7) => b, o(0 to 3) => c, o(4 to 7) => d ); process is begin assert c = "0000"; assert d = "0000"; wait for 2 ns; assert c = "1111"; assert d = "1111"; a <= "11"; wait for 2 ns; assert c = "0011"; assert d = "1111"; b <= "011110"; wait for 2 ns; assert c = "0010"; assert d = "0001"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab23.vhd000066400000000000000000000012411504111170000167410ustar00rootroot00000000000000entity sub is port ( x : in integer; y : out integer ); end entity; architecture test of sub is begin process is begin if x'active then -- NULL nets array here y <= x + 1; end if; wait; end process; end architecture; ------------------------------------------------------------------------------- entity elab23 is end entity; architecture test of elab23 is signal y : integer; begin sub_i: entity work.sub port map ( x => 0, y => y ); process is begin wait for 1 ns; assert y = integer'low; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab24.vhd000066400000000000000000000032651504111170000167520ustar00rootroot00000000000000entity sub2 is port ( x0, x1 : in bit; y0, y1 : out bit ); end entity; architecture test of sub2 is begin y0 <= x0 after 0 ns; y1 <= not x1 after 0 ns; end architecture; ------------------------------------------------------------------------------- entity sub is port ( x : in bit_vector(1 downto 0); y : out bit_vector(1 downto 0) ); end entity; architecture test1 of sub is begin y(0) <= x(0) after 0 ns; y(1) <= not x(1) after 0 ns; end architecture; architecture test2 of sub is begin sub2_i: entity work.sub2 port map ( x0 => x(0), x1 => x(1), y0 => y(0), y1 => y(1) ); end architecture; ------------------------------------------------------------------------------- entity elab24 is end entity; architecture test of elab24 is begin test_a: block is signal x0, x1, y0, y1 : bit; begin sub_i: entity work.sub(test1) port map ( x(0) => x0, x(1) => x1, y(0) => y0, y(1) => y1 ); process is begin x0 <= '1'; wait for 2 ns; assert y0 = '1'; wait; end process; end block; test_b: block is signal x0, x1, y0, y1 : bit; begin sub_i: entity work.sub(test2) port map ( x(0) => x0, x(1) => x1, y(0) => y0, y(1) => y1 ); process is begin x0 <= '1'; wait for 2 ns; assert y0 = '1'; wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/elab25.vhd000066400000000000000000000011231504111170000167420ustar00rootroot00000000000000entity sub is port ( a : in bit_vector(2 downto 0); b : out bit_vector(2 downto 0) ); end entity; architecture test of sub is begin b <= a after 0 ns; end architecture; ------------------------------------------------------------------------------- entity elab25 is end entity; architecture test of elab25 is signal x0, x1 : bit_vector(1 downto 0); signal y0, y1 : bit; begin sub_i: entity work.sub port map ( a(1 downto 0) => x0, a(2) => y0, b(1 downto 0) => x1, b(2) => y1 ); end architecture; nvc-r1.17.1/test/regress/elab26.vhd000066400000000000000000000036701504111170000167540ustar00rootroot00000000000000-- https://github.com/ghdl/ghdl/issues/1842 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; library work; package signal_pkg is type t_sigs is array (natural range <>) of std_logic_vector(7 downto 0); type t_signals is record dta: t_sigs(0 to 7); end record; end signal_pkg; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; library work; use work.signal_pkg.all; entity source is generic ( instance_number : integer := 0); port ( rst_n_i : in std_logic; clk_i : in std_logic; outs : out t_signals ); end entity source; architecture sim of source is signal toggle : std_logic := '0'; begin -- architecture rtl process(clk_i) begin if rising_edge(clk_i) then if rst_n_i = '0' then outs.dta(instance_number) <= (others => '0'); else toggle <= not toggle; if toggle='0' then outs.dta(instance_number) <= (others => '0'); end if; outs.dta(instance_number) <= std_logic_vector(to_unsigned(instance_number + 2, 8)); end if; end if; end process; end architecture sim; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; library work; use work.signal_pkg.all; entity elab26 is end elab26; architecture beh1 of elab26 is signal clk : std_logic := '0'; signal rst_n : std_logic := '0'; signal test : t_signals; begin -- beh1 clk <= not clk after 10 ns when now < 50 ns; process begin rst_n <= '0'; wait for 30 ns; rst_n <= '1'; wait; end process; g1: for i in 0 to 7 generate source_1: entity work.source generic map ( instance_number => i) port map ( rst_n_i => rst_n, clk_i => clk, outs => test); end generate g1; check_p: process is begin wait for 50 ns; for i in 0 to 7 loop assert test.dta(i) = (0 to 7 => 'U'); end loop; wait; end process; end beh1; nvc-r1.17.1/test/regress/elab27.vhd000066400000000000000000000016461504111170000167560ustar00rootroot00000000000000entity sub is port ( c : out integer := 0; a, b : in integer ); end entity; architecture impl of sub is begin c <= a + b; end architecture; ------------------------------------------------------------------------------- entity elab27 is end entity; architecture test of elab27 is component comp is port ( b : in integer; c : out integer; a : in integer ); end component; signal x, y1, y2, z : integer := 0; for all : comp use entity work.sub; function negate (x : in integer) return integer is begin return -x; end function; begin uut1: component comp port map (x, y1, z); uut2: component comp port map (x, negate(c) => y2, a => z); p1: process is begin x <= 1; z <= 2; wait for 1 ns; assert y1 = 3; assert y2 = -3; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab28.vhd000066400000000000000000000023151504111170000167510ustar00rootroot00000000000000package pack is type rec is record x, y : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r : rec; en : boolean ); port ( x_out, y_out : out bit_vector(1 to 2) ); end entity; architecture test of sub is begin g: if en generate main: process is function get_bits(n : integer) return bit_vector is begin case n is when 1 => return (1 to 2 => '1'); when others => return (1 to 2 => '0'); end case; end function; constant x : bit_vector(1 to 2) := get_bits(r.x); constant y : bit_vector(1 to 2) := get_bits(r.y); begin x_out <= x; y_out <= y; wait; end process; end generate; end architecture; ------------------------------------------------------------------------------- entity elab28 is end entity; architecture test of elab28 is signal x, y : bit_vector(1 to 2); begin uut: entity work.sub generic map ( ( 0, 1 ), true ) port map ( x, y ); end architecture; nvc-r1.17.1/test/regress/elab29.vhd000066400000000000000000000012331504111170000167500ustar00rootroot00000000000000entity sub is port ( i : in integer; o : out integer ); end entity; architecture test of sub is begin o <= i; end architecture; ------------------------------------------------------------------------------- entity elab29 is end entity; architecture test of elab29 is signal x, y, z : integer := 0; begin u: entity work.sub port map ( x + y, z ); main: process is begin x <= 2; y <= 3; wait for 1 ns; assert z = 5; x <= 7; wait for 1 ns; assert z = 10; y <= -1; wait for 1 ns; assert z = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab3.vhd000066400000000000000000000014701504111170000166630ustar00rootroot00000000000000entity sub is end entity; architecture test of sub is signal p : integer; begin process is begin wait for 2 ns; report p'instance_name; report p'path_name; wait; end process; end architecture; ------------------------------------------------------------------------------- entity elab3 is end entity; architecture test of elab3 is signal x : integer; begin s: entity work.sub; b: block is signal y : integer; begin process is begin wait for 1 ns; report y'instance_name; report y'path_name; wait; end process; end block; process is begin report x'instance_name; report x'path_name; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab30.vhd000066400000000000000000000010671504111170000167450ustar00rootroot00000000000000entity sub is generic ( def : integer; g : integer := def ); port ( x : out integer ); end entity; architecture test of sub is begin x <= g; end architecture; ------------------------------------------------------------------------------- entity elab30 is end entity; architecture test of elab30 is signal x : integer; begin u: entity work.sub generic map ( def => 42 ) port map ( x ); p1: process is begin wait for 1 ns; assert x = 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab31.vhd000066400000000000000000000030311504111170000167370ustar00rootroot00000000000000package pack is type rec is record x : integer; end record; type pt is protected impure function next_id return integer; end protected; impure function get_rec return rec; function get_id (r : rec) return integer; end package; package body pack is type pt is protected body variable ctr : integer := 0; impure function next_id return integer is begin ctr := ctr + 1; return ctr; end function; end protected body; shared variable p : pt; impure function get_rec return rec is begin return (x => p.next_id); end function; function get_id (r : rec) return integer is begin return r.x; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r1, r2 : rec ); port ( s1 : in bit_vector(1 to get_id(r1)); s2 : in bit_vector(1 to get_id(r2)) ); end entity; architecture test of sub is begin p1: process is begin assert s1 = "0"; assert s2 = "00"; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity elab31 is end entity; architecture test of elab31 is constant r1, r2 : rec := get_rec; signal s1 : bit_vector(1 to 1); signal s2 : bit_vector(1 to 2); begin u: entity work.sub generic map ( r1, r2 ) port map ( s1, s2 ); end architecture; nvc-r1.17.1/test/regress/elab32.vhd000066400000000000000000000006051504111170000167440ustar00rootroot00000000000000entity sub is port ( x : in bit_vector ); begin assert x'length = 1; end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity elab32 is end entity; architecture test of elab32 is signal b : bit; begin uut: entity work.sub port map ( x(0) => b ); end architecture; nvc-r1.17.1/test/regress/elab33.vhd000066400000000000000000000024541504111170000167510ustar00rootroot00000000000000package pack is type rec is record x : integer; y : bit_vector; end record; type rec_array is array (natural range <>) of rec; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : in rec_array; o1 : out integer_vector; o2 : out bit_vector ); end entity; architecture test of sub is begin g: for n in i'range generate constant stride : natural := i(n).y'length; begin o1(n) <= i(n).x; o2(1 + (n-1)*stride to n*stride) <= i(n).y; end generate; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity elab33 is end entity; architecture test of elab33 is signal a : rec_array(1 to 2)(y(1 to 3)); signal b : integer_vector(1 to 2); signal c : bit_vector(1 to 6); begin u : entity work.sub port map ( a, b, c ); check: process is begin a(1) <= (y => "101", x => 2); wait for 1 ns; assert b = (2, integer'left); assert c = "101000"; a(2).x <= 5; a(2).y <= "110"; wait for 1 ns; assert b = (2, 5); assert c = "101110"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab34.vhd000066400000000000000000000030471504111170000167510ustar00rootroot00000000000000entity sub is generic ( width : positive ); port ( clk : in bit; rst : in bit; vec : out integer_vector(1 to width) ); end entity; architecture test of sub is begin g1: if width = 1 generate p: process (clk) is begin if rst = '1' then vec(1) <= 0; elsif rising_edge(clk) then vec(1) <= vec(1) + 1; end if; end process; else g2: generate u1: entity work.sub generic map ( width / 2 ) port map ( clk, rst, vec(1 to width / 2) ); u2: entity work.sub generic map ( width / 2 ) port map ( clk, rst, vec(width/2 + 1 to width) ); end generate; end architecture; ------------------------------------------------------------------------------- entity elab34 is end entity; architecture test of elab34 is signal clk, rst : bit := '1'; signal vec : integer_vector(1 to 8); begin top: entity work.sub generic map ( 8 ) port map ( clk, rst, vec ); check: process is begin wait for 1 ns; rst <= '0'; clk <= '0'; assert vec = (1 to 8 => 0); wait for 1 ns; clk <= '1'; assert vec = (1 to 8 => 0); wait for 0 ns; assert vec = (1 to 8 => 0); wait for 0 ns; assert vec = (1 to 8 => 1); clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; assert vec = (1 to 8 => 2); wait; end process; end architecture; nvc-r1.17.1/test/regress/elab35.vhd000066400000000000000000000043171504111170000167530ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package types_pkg is type sl2d_t is array(natural range <>,natural range <>) of std_logic; type slv_7_0_t is array(natural range <>) of std_logic_vector(7 downto 0); subtype ram_bank_t is slv_7_0_t(0 to 32767); type ram_t is array(0 to 3) of ram_bank_t; end package; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.types_pkg.all; entity sub is generic ( width : integer; depth_log2 : integer; init : sl2d_t := (0 downto 1 => (0 downto 1 => '0')) ); end entity; architecture test of sub is subtype ram_word_t is std_logic_vector(width-1 downto 0); type ram_t is array(natural range <>) of ram_word_t; function ram_init return ram_t is variable r : ram_t(0 to (2**depth_log2)-1); begin r := (others => (others => '0')); if init'high = r'high then for i in 0 to r'length-1 loop for j in 0 to width-1 loop r(i)(j) := init(i,j); end loop; end loop; end if; return r; end function ram_init; signal ram : ram_t(0 to (2**depth_log2)-1) := ram_init; begin end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.types_pkg.all; entity elab35 is end entity; architecture test of elab35 is constant size_log2 : integer := 16; function rambank2sl2d(constant x : ram_bank_t) return sl2d_t is variable r : sl2d_t(0 to (2**(size_log2-2))-1,7 downto 0); begin for i in 0 to r'length-1 loop for j in 0 to 7 loop r(i,j) := x(i)(j); end loop; end loop; return r; end function rambank2sl2d; constant ram_init : ram_t := (others => (others => (others => '0') ) ); begin g: for i in 0 to 3 generate RAM: entity work.sub generic map ( width => 8, depth_log2 => size_log2-2, init => rambank2sl2d(ram_init(i)) ); end generate; end architecture; nvc-r1.17.1/test/regress/elab36.vhd000066400000000000000000000016161504111170000167530ustar00rootroot00000000000000entity sub is generic ( id : natural ); port ( o : out integer ); end entity; architecture test of sub is begin g1: if id = 1 generate o <= 1; end generate; g2: if id = 2 generate o <= 2; end generate; g3: if id = 3 generate o <= 3; end generate; end architecture; ------------------------------------------------------------------------------- entity elab36 is end entity; architecture test of elab36 is shared variable counter : natural := 0; impure function get_id return natural is begin counter := counter + 1; return counter; end function; signal s : integer; constant id : natural := get_id; begin u: entity work.sub generic map ( id ) port map ( s ); p1: process is begin wait for 1 ns; assert s = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab37.vhd000066400000000000000000000027411504111170000167540ustar00rootroot00000000000000package pack is type params_t is record width : natural; end record; end package; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.pack.all; entity sub is generic ( depth : natural; params : params_t ); port ( clk : inout std_logic := 'Z' ); end entity; architecture test of sub is begin g1: if depth > 0 generate u: entity work.sub generic map ( depth - 1, params ) port map ( clk ); end generate; g2: if depth = 0 generate signal s : bit_vector(1 to params.width); begin p1: process is begin assert clk = '0'; assert s'length = 5; s <= (others => '1'); wait for 1 ns; assert clk = '1'; wait; end process; end generate; end architecture; ------------------------------------------------------------------------------- entity elab37 is end entity; use work.pack.all; library ieee; use ieee.std_logic_1164.all; architecture test of elab37 is constant params : params_t := ( width => 5 ); signal vec : bit_vector(1 to 5); signal clk : std_logic := '0'; begin u: entity work.sub generic map ( 2, params ) port map ( clk ); check: process is begin clk <= '1'; wait for 1 ns; -- assert vec = "11111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab38.vhd000066400000000000000000000030011504111170000167430ustar00rootroot00000000000000package pack is type int_vec is array (natural range <>) of integer; type params_t is record width : natural; scale : natural; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( depth : natural; params : params_t ); port ( vec : in int_vec(1 to 2 ** (depth * params.scale)) ); end entity; architecture test of sub is begin g1: if depth > 0 generate constant mid : integer := 2 ** ((depth - 1) * params.scale); constant a_low : integer := 1; constant a_high : integer := mid; constant b_low : integer := mid + 1; constant b_high : integer := 2 ** (depth * params.scale); begin a: entity work.sub generic map ( depth - 1, params ) port map ( vec(a_low to a_high) ); b: entity work.sub generic map ( depth - 1, params ) port map ( vec(b_low to b_high) ); end generate; g2: if depth = 0 generate begin assert vec = (1 => 42); end generate; end architecture; ------------------------------------------------------------------------------- entity elab38 is end entity; use work.pack.all; architecture test of elab38 is constant params : params_t := ( width => 5, scale => 1 ); signal vec : int_vec(1 to 4) := (42, 42, 42, 42); begin u: entity work.sub generic map ( 2, params ) port map ( vec ); end architecture; nvc-r1.17.1/test/regress/elab39.sh000066400000000000000000000005101504111170000165770ustar00rootroot00000000000000set -xe pwd which nvc cat >test.vhd < x1, y => 2, z => z1 ); sub2_i: entity work.sub port map ( x => 6 + 15, y => 2 * 4, z => z2 ); process is begin x1 <= 5; wait for 1 ns; assert z1 = 7; assert z2 = 29; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab40.vhd000066400000000000000000000047041504111170000167470ustar00rootroot00000000000000package PassthroughDUTPkg is type VideoDataArray is array (natural range <>) of bit_vector; end PassthroughDUTPkg; ------------------------------------------------------------------------------- use work.PassthroughDUTPkg.all; entity PassthroughDUT is generic ( PIXEL_DEPTH : natural := 24; -- number of bits in a pixel NUM_DATA_STREAMS : natural := 1 -- number of pixel data streams ); port ( -- VideoBus input vid_fval_in : in bit; vid_lval_in : in bit; vid_dval_in : in bit; vid_data_in : in VideoDataArray(0 to NUM_DATA_STREAMS-1)(PIXEL_DEPTH-1 downto 0); -- VideoBus output vid_fval_out : out bit; vid_lval_out : out bit; vid_dval_out : out bit; vid_data_out : out VideoDataArray(0 to NUM_DATA_STREAMS-1)(PIXEL_DEPTH-1 downto 0) ); end entity; architecture SimplePassthrough of PassthroughDUT is begin vid_fval_out <= vid_fval_in; vid_lval_out <= vid_lval_in; vid_dval_out <= vid_dval_in; vid_data_out <= vid_data_in; end architecture; ------------------------------------------------------------------------------- entity elab40 is generic ( PIXEL_DEPTH : natural := 24; -- number of bits in a pixel (RGB = 3*8) NUM_DATA_STREAMS : natural := 1 -- number of pixel data streams ); end entity; architecture test of elab40 is --- VideoBus input signal vid_fval_in : bit; signal vid_lval_in : bit; signal vid_dval_in : bit; signal vid_data_in : bit_vector(PIXEL_DEPTH-1 downto 0); -- VideoBus output signal vid_fval_out : bit; signal vid_lval_out : bit; signal vid_dval_out : bit; signal vid_data_out : bit_vector(PIXEL_DEPTH-1 downto 0); begin passthroughdut_inst: entity work.PassthroughDUT generic map ( PIXEL_DEPTH => PIXEL_DEPTH, NUM_DATA_STREAMS => NUM_DATA_STREAMS ) port map ( vid_fval_in => vid_fval_in, vid_lval_in => vid_lval_in, vid_dval_in => vid_dval_in, vid_data_in(0) => vid_data_in, vid_fval_out => vid_fval_out, vid_lval_out => vid_lval_out, vid_dval_out => vid_dval_out, vid_data_out(0) => vid_data_out ); check: process is begin vid_data_in <= X"123456"; wait for 1 ns; assert vid_data_out = X"123456"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab5.vhd000066400000000000000000000013551504111170000166670ustar00rootroot00000000000000entity sub is port ( x : out integer ); end entity; architecture one of sub is begin x <= 1; end architecture; architecture two of sub is begin x <= 2; end architecture; ------------------------------------------------------------------------------- entity elab5 is end entity; architecture test of elab5 is signal x1, x2, x3 : integer; begin sub1: entity work.sub(one) port map ( x1 ); sub2: entity work.sub(two) port map ( x2 ); sub3: entity work.sub -- Should select `two' port map ( x3 ); process is begin wait for 1 ns; assert x1 = 1; assert x2 = 2; assert x3 = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab6.vhd000066400000000000000000000007361504111170000166720ustar00rootroot00000000000000entity elab6 is end entity; architecture test of elab6 is type int_vec is array (integer range <>) of integer; signal s : int_vec(1 to 10); begin test_g: for i in s'range generate signal tmp : integer; begin tmp <= i * 2; s(i) <= tmp; end generate; process is begin wait for 1 ns; for i in s'range loop assert s(i) = i * 2; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab7.vhd000066400000000000000000000023321504111170000166650ustar00rootroot00000000000000entity sub2 is generic ( VALUE : integer ); port ( x : out integer ); end entity; architecture test of sub2 is begin x <= VALUE; end architecture; ------------------------------------------------------------------------------- entity sub1 is generic ( ENABLE : boolean ); port ( y : out integer ); end entity; architecture test of sub1 is begin value7_g: if ENABLE generate sub: entity work.sub2 generic map ( VALUE => 7 ) port map ( x => y ); end generate; value5_g: if not ENABLE generate sub: entity work.sub2 generic map ( VALUE => 5 ) port map ( x => y ); end generate; end architecture; ------------------------------------------------------------------------------- entity elab7 is end entity; architecture test of elab7 is signal a, b : integer; begin sa: entity work.sub1 generic map ( ENABLE => true ) port map ( y => a ); sb: entity work.sub1 generic map ( ENABLE => false ) port map ( y => b ); process is begin wait for 1 ns; assert a = 7; assert b = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab8.vhd000066400000000000000000000023141504111170000166660ustar00rootroot00000000000000entity sub is port ( foo : out bit_vector(1 to 3) ); end entity; architecture test of sub is begin process is begin foo <= "101"; wait for 10 ns; foo <= "010"; wait for 10 ns; foo <= "100"; wait; end process; end architecture; ------------------------------------------------------------------------------- entity elab8 is end entity; architecture test of elab8 is signal bar : bit_vector(1 to 3); signal a, b, c : bit; begin sub1_i: entity work.sub port map ( foo(1) => bar(3), foo(2) => bar(2), foo(3) => bar(1) ); sub2_i: entity work.sub port map ( foo(1) => a, foo(2) => b, foo(3) => c ); process is begin wait for 1 ns; assert a = '1'; assert b = '0'; assert c = '1'; assert bar = "101"; wait for 10 ns; assert a = '0'; assert b = '1'; assert c = '0'; assert bar = "010"; wait for 10 ns; assert a = '1'; assert b = '0'; assert c = '0'; assert bar = "001"; wait; end process; end architecture; nvc-r1.17.1/test/regress/elab9.vhd000066400000000000000000000012701504111170000166670ustar00rootroot00000000000000entity sub_ent is end entity; architecture test of sub_ent is begin process is begin report sub_ent'path_name; report sub_ent'instance_name; report test'path_name; report test'instance_name; wait; end process; end architecture; ------------------------------------------------------------------------------- entity elab9 is end entity; architecture test of elab9 is begin sub_i: entity work.sub_ent; process is begin wait for 1 ns; report elab9'path_name; report elab9'instance_name; report test'path_name; report test'instance_name; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename1.vhd000066400000000000000000000020561504111170000170440ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process (y) is begin x <= y + 5; end process; end architecture; ------------------------------------------------------------------------------- entity ename1 is end entity; architecture test of ename1 is begin uut: entity work.bot; p2: process is begin assert <> = 0; wait for 1 ns; <> <= force 5; wait for 0 ns; assert <> = 5; wait for 0 ns; assert <> = 10; <> <= release; wait for 1 ns; assert <> = 5; wait for 10 ns; assert <> = 25; wait; end process; p3: process is alias y is <>; begin y <= 0; wait for 10 ns; y <= 20; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename10.vhd000066400000000000000000000010141504111170000171150ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename10 is end entity; architecture test of ename10 is begin uut: entity work.bot; p2: process is begin assert <> = 0; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename11.vhd000066400000000000000000000010121504111170000171140ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename11 is end entity; architecture test of ename11 is begin uut: entity work.bot; p2: process is begin assert <> = 0; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename12.vhd000066400000000000000000000010131504111170000171160ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename12 is end entity; architecture test of ename12 is begin uut: entity work.bot; p2: process is begin assert <> = 0; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename13.vhd000066400000000000000000000010171504111170000171230ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename13 is end entity; architecture test of ename13 is begin uut: entity work.bot; p2: process is begin assert <> = '0'; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename14.vhd000066400000000000000000000010141504111170000171210ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename14 is end entity; architecture test of ename14 is begin uut: entity work.bot; p2: process is begin assert <> = 0; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename15.vhd000066400000000000000000000012541504111170000171300ustar00rootroot00000000000000entity ename15 is end entity; architecture test of ename15 is type t_three_ints is array (1 to 3) of integer; signal s : bit_vector(1 to 3); begin check: process is begin assert <> = (0, 0, 0); assert <> = "000"; s <= "101"; wait for 2 ns; assert <> = (1, 2, 3); assert <> = "101"; wait; end process; b: block is port ( p : in bit_vector); port map ( s ); signal s : t_three_ints := (0, 0, 0); begin s <= (1, 2, 3) after 1 ns; end block; end architecture; nvc-r1.17.1/test/regress/ename16.vhd000066400000000000000000000007651504111170000171370ustar00rootroot00000000000000package my_pkg is signal sig_in_package : natural := 17; end package; entity ename16 is end entity; architecture test of ename16 is begin process alias al is << signal @work.my_pkg.sig_in_package : natural >>; begin wait for 1 ns; assert (al = 17); al <= 5; wait for 1 ns; assert al = 5; wait for 1 ns; assert << signal @work.my_pkgxxxx.sig : natural >> = 1; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename17.vhd000066400000000000000000000006151504111170000171320ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is begin p2: process is begin assert <> = '0'; -- Error wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename17 is end entity; architecture test of ename17 is begin uut: entity work.bot; end architecture; nvc-r1.17.1/test/regress/ename2.vhd000066400000000000000000000011351504111170000170420ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename2 is end entity; architecture test of ename2 is begin uut: entity work.bot; p2: process is alias a1 is <>; -- Error (once) alias a2 is <>; -- Error begin assert a1 = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename3.vhd000066400000000000000000000015441504111170000170470ustar00rootroot00000000000000entity bot is generic ( N : integer ); end entity; architecture test of bot is constant k : integer := N; signal x, y : natural; begin p1: process (y) is begin x <= y + 5; end process; end architecture; ------------------------------------------------------------------------------- entity ename3 is end entity; architecture test of ename3 is begin g: for i in 1 to 3 generate uut: entity work.bot generic map (N => i); end generate; p1: process is begin assert << constant g(1).uut.k : integer >> = 1; assert << constant g(2).uut.k : integer >> = 2; assert << constant g(3).uut.k : integer >> = 3; << signal g(1).uut.x : integer >> <= force 1; wait for 1 ns; assert << signal g(1).uut.x : integer >> = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename4.vhd000066400000000000000000000014001504111170000170370ustar00rootroot00000000000000entity bot is generic ( N : integer ); end entity; architecture test of bot is constant k : integer := N; signal x, y : natural; begin p1: process (y) is begin x <= y + 5; end process; p2: process is begin assert << constant ^.^.g(N).uut.k : integer >> = N; << signal ^.^.g(N).uut.x : integer >> <= force 1; wait for 1 ns; assert << signal ^.^.g(N).uut.x : integer >> = 1; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename4 is end entity; architecture test of ename4 is begin g: for i in 1 to 3 generate uut: entity work.bot generic map (N => i); end generate; end architecture; nvc-r1.17.1/test/regress/ename5.vhd000066400000000000000000000010131504111170000170400ustar00rootroot00000000000000entity ename5 is end entity; architecture test of ename5 is begin b1: block is signal s1 : bit_vector(1 to 3); constant c1 : string := "hello"; begin s1 <= "101"; end block; p1: process is begin wait for 1 ns; assert << signal b1.s1 : bit_vector >> = "101"; -- OK assert << constant b1.c1 : string(1 to 5) >> = "hello"; -- OK assert << constant b1.c1 : string(1 to 6) >> = "hello"; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ename6.vhd000066400000000000000000000015401504111170000170460ustar00rootroot00000000000000package pack is procedure p; end package; package body pack is procedure p is alias s1 is << signal .ename6.b1.s1 : bit >>; begin s1 <= force '1'; end procedure; end package body; ------------------------------------------------------------------------------- entity ename6 is end entity; use work.pack.all; architecture test of ename6 is begin b1: block is signal s1 : bit; constant c1 : string := "hello"; begin p1: process is begin assert s1 = '0'; p; wait for 0 ns; assert s1 = '1'; s1 <= release; wait for 6 ns; assert s1 = '1'; wait; end process; end block; p1: process is begin wait for 5 ns; p; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename7.vhd000066400000000000000000000017711504111170000170550ustar00rootroot00000000000000entity sub1 is end entity; architecture test of sub1 is signal t : natural; begin p1: process is alias s is <>; begin s <= 5; wait for 0 ns; assert t = 42; wait; end process; end architecture; ------------------------------------------------------------------------------- entity sub2 is end entity; architecture test of sub2 is begin p2: process is alias t is <>; begin t <= 42; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename7 is end entity; architecture test of ename7 is signal s : natural; component sub1 is end component; component sub2 is end component; begin u1: component sub1; u2: component sub2; p3: process is begin assert s = 0; wait for 0 ns; assert s = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/ename8.vhd000066400000000000000000000012131504111170000170450ustar00rootroot00000000000000entity ename8 is end entity; architecture test of ename8 is begin g: for i in 1 to 1 generate signal y : integer := 0; begin b: block is signal x : integer := 0; begin process is begin << signal ^.^.g(1).y : integer >> <= 55; wait for 1 ns; assert x = 42; wait; end process; end block; process is begin << signal b.x : integer >> <= 42; wait for 1 ns; assert y = 55; wait; end process; end generate; end architecture; nvc-r1.17.1/test/regress/ename9.vhd000066400000000000000000000010361504111170000170510ustar00rootroot00000000000000entity bot is end entity; architecture test of bot is signal x, y : natural; begin p1: process is begin wait for 5 ns; x <= 5; wait; end process; end architecture; ------------------------------------------------------------------------------- entity ename9 is end entity; architecture test of ename9 is begin uut: entity work.bot; p2: process is alias a2 is <>; -- Error begin assert a2 = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/fact.vhd000066400000000000000000000016031504111170000166100ustar00rootroot00000000000000entity fact_gen is port ( question : in integer; answer : out integer ); end entity; architecture behav of fact_gen is begin process (question) is variable tmp : integer; begin tmp := 1; for i in 1 to question loop tmp := tmp * i; end loop; answer <= tmp; end process; end architecture; ------------------------------------------------------------------------------- entity fact is end entity; architecture test of fact is signal question, answer : integer; begin uut: entity work.fact_gen port map ( question => question, answer => answer ); process is begin for i in 1 to 15 loop question <= i; wait on answer; report integer'image(answer); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/file1.vhd000066400000000000000000000025001504111170000166700ustar00rootroot00000000000000entity file1 is end entity; architecture test of file1 is type char_file is file of character; file f1 : char_file; type string_file is file of string; file f2 : string_file; file f3 : string_file open WRITE_MODE is "test2.txt"; begin process is variable c : character; variable s : string(1 to 3); variable len : natural; variable status : file_open_status; begin file_open(f1, "test.txt", WRITE_MODE); write(f1, 'x'); write(f1, 'y'); write(f1, LF); file_close(f1); file_open(f1, "test.txt"); read(f1, c); assert c = 'x'; read(f1, c); assert c = 'y'; read(f1, c); assert c = LF; assert endfile(f1); file_close(f1); file_open(f2, "test.txt", READ_MODE); read(f2, s, len); assert s = "xy" & LF; assert len = 3; file_close(f2); write(f3, "hello"); file_close(f3); file_open(status, f3, "test2.txt", READ_MODE); assert status = OPEN_OK; read(f3, s, len); assert len = 3; assert s = "hel"; file_close(f3); file_open(status, f3, "not_here", READ_MODE); assert status = NAME_ERROR; wait; end process; end architecture; nvc-r1.17.1/test/regress/file10.vhd000066400000000000000000000013251504111170000167540ustar00rootroot00000000000000entity file10 is end entity; architecture test of file10 is type rec is record x : integer; s : string(1 to 5); end record; type rec_array is array (natural range <>) of rec; type rf is file of rec_array; begin p1: process is file f : rf; variable v : rec_array(1 to 2); variable len : integer; begin file_open(f, "file.bin", write_mode); write(f, ((1, "hello"), (2, "world"))); file_close(f); file_open(f, "file.bin", read_mode); read(f, v, len); assert len = 2; assert v(1) = (1, "hello"); assert v(2) = (2, "world"); file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/file11.vhd000066400000000000000000000007251504111170000167600ustar00rootroot00000000000000entity file11 is end entity; architecture test of file11 is type char_file is file of character; file f1, f2 : char_file; begin process is variable c : character; begin file_open(f1, "test.txt", WRITE_MODE); write(f1, 'x'); flush(f1); -- Check we can open the same file again file_open(f2, "test.txt"); read(f2, c); assert c = 'x'; wait; end process; end architecture; nvc-r1.17.1/test/regress/file12.vhd000066400000000000000000000031611504111170000167560ustar00rootroot00000000000000entity file12 is end entity; architecture test of file12 is type char_file is file of character; file f : char_file; begin process is variable c : character; begin file_open(f, "test.txt", WRITE_MODE); assert file_mode(f) = WRITE_MODE; assert file_size(f) = 0; write(f, 'x'); write(f, 'y'); write(f, 'z'); assert file_position(f) = 3; assert file_position(f, FILE_ORIGIN_CURRENT) = 0; assert file_position(f, FILE_ORIGIN_END) = 0; assert file_size(f) = 3; file_close(f); assert file_state(f) = STATE_CLOSED; assert file_open(f, "test.txt", READ_WRITE_MODE) = OPEN_OK; read(f, c); assert c = 'x'; file_seek(f, 1); write(f, 'q'); file_seek(f, 2); assert file_position(f, FILE_ORIGIN_END) = 1; read(f, c); assert c = 'z'; assert endfile(f); file_rewind(f); read(f, c); assert c = 'x'; read(f, c); assert c = 'q'; file_truncate(f, 1); assert file_size(f) = 1; file_rewind(f); read(f, c); assert c = 'x'; assert endfile(f); file_seek(f, 1); write(f, '1'); write(f, '2'); file_truncate(f, -1, FILE_ORIGIN_END); file_rewind(f); read(f, c); assert c = 'x'; read(f, c); assert c = '1'; assert endfile(f); assert file_state(f) = STATE_OPEN; assert file_mode(f) = READ_WRITE_MODE; assert file_canseek(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/file13.vhd000066400000000000000000000006241504111170000167600ustar00rootroot00000000000000entity file13 is end entity; architecture test of file13 is type ft is file of character; file f : ft; begin process is begin file_open(f, "test.txt", write_mode); write(f, 'x'); file_close(f); file_open(f, "test.txt", read_mode); write(f, 'x'); -- Error file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/file14.vhd000066400000000000000000000005271504111170000167630ustar00rootroot00000000000000entity file14 is end entity; architecture test of file14 is type ft is file of character; file f : ft; begin process is variable ch : character; begin file_open(f, "test.txt", write_mode); read(f, ch); -- Error file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/file15.vhd000066400000000000000000000016331504111170000167630ustar00rootroot00000000000000entity file15 is end entity; architecture test of file15 is type t_rec is record num : natural; str : string(1 to 5); end record; type t_file is file of t_rec; type t_strtab is array (natural range <>) of string(1 to 5); constant strtab : t_strtab(1 to 5) := ( "hello", "world", "12345", "hello", "donut" ); begin testing: process is file f : t_file; variable r : t_rec; begin file_open(f, "out", write_mode); for i in strtab'range loop write(f, (num => i, str => strtab(i))); end loop; file_close(f); file_open(f, "out", read_mode); for i in strtab'range loop read(f, r); assert r.num = i; assert r.str = strtab(i) report r.str; end loop; file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/file2.vhd000066400000000000000000000010201504111170000166650ustar00rootroot00000000000000entity file2 is end entity; architecture test of file2 is subtype bit_vec5 is bit_vector(1 to 5); type ft is file of bit_vec5; begin process is file f : ft; variable v : bit_vec5; begin file_open(f, "test.bin", WRITE_MODE); v := "10100"; write(f, v); file_close(f); v := "00000"; file_open(f, "test.bin", READ_MODE); read(f, v); file_close(f); assert v = "10100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/file3.vhd000066400000000000000000000015201504111170000166730ustar00rootroot00000000000000entity file3 is end entity; architecture a of file3 is begin main : process constant file_name : string := "output.raw"; type binary_file is file of character; file fptr : binary_file; variable fstatus : file_open_status; variable tmp, tmp2 : character; begin assert character'pos(character'low) = 0; assert character'pos(character'high) = 255; file_open(fstatus, fptr, file_name, write_mode); assert fstatus = open_ok; for i in 0 to 255 loop write(fptr, character'val(i)); end loop; file_close(fptr); file_open(fstatus, fptr, file_name, read_mode); assert fstatus = open_ok; for i in 0 to 255 loop read(fptr, tmp); assert character'pos(tmp) = i; end loop; assert endfile(fptr); file_close(fptr); report "Success"; wait; end process; end; nvc-r1.17.1/test/regress/file4.vhd000066400000000000000000000011521504111170000166750ustar00rootroot00000000000000entity file4 is end entity; architecture test of file4 is type natural_vector is array (natural range <>) of natural; subtype natural5 is natural_vector(1 to 5); type ft is file of natural5; begin process is file f : ft; variable v : natural5; begin file_open(f, "test.bin", WRITE_MODE); v := (1, 2, 3, 4, 5); write(f, v); file_close(f); v := (others => 0); file_open(f, "test.bin", READ_MODE); read(f, v); file_close(f); assert v = (1, 2, 3, 4, 5); wait; end process; end architecture; nvc-r1.17.1/test/regress/file5.vhd000066400000000000000000000012621504111170000167000ustar00rootroot00000000000000entity file5 is end entity; architecture test of file5 is type natural_vector is array (natural range <>) of natural; type ft is file of natural_vector; begin process is file f : ft; variable v : natural_vector(1 to 5); variable len : natural; begin file_open(f, "test.bin", WRITE_MODE); v := (1, 2, 3, 4, 5); write(f, v); file_close(f); v := (others => 0); file_open(f, "test.bin", READ_MODE); read(f, v, len); file_close(f); assert v = (1, 2, 3, 4, 5); report integer'image(len); assert len = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/file6.vhd000066400000000000000000000013421504111170000167000ustar00rootroot00000000000000entity file6 is end entity; architecture test of file6 is type natural_vector is array (natural range <>) of natural; type ft is file of natural_vector; begin process is file f1, f2 : ft; variable v : natural_vector(1 to 5); variable len : natural; begin file_open(f1, "test.bin", WRITE_MODE); v := (1, 2, 3, 4, 5); write(f1, v); flush(f1); -- Flush without closing v := (others => 0); file_open(f2, "test.bin", READ_MODE); read(f2, v, len); file_close(f2); assert v = (1, 2, 3, 4, 5); report integer'image(len); assert len = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/file7.vhd000066400000000000000000000020051504111170000166760ustar00rootroot00000000000000-- -- Reduced from VESTs cases tc640 and tc641 -- entity file7 is end entity; architecture test of file7 is subtype word is bit_vector(0 to 15); constant size : integer := 7; type primary_memory is array (0 to size) of word; type primary_memory_file is file of primary_memory; constant C38 : word := (others => '1'); constant C44 : primary_memory := (others => C38); begin writer: process file filein : primary_memory_file open write_mode is "iofile.42"; begin for i in 1 to 10 loop write(filein, C44); end loop; file_close(filein); wait; end process; reader: process file filein : primary_memory_file; variable v : primary_memory; begin wait for 1 ns; file_open(filein, "iofile.42"); for i in 1 to 10 loop assert not endfile(filein); read(filein,v); assert v = C44; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/file8.vhd000066400000000000000000000003741504111170000167060ustar00rootroot00000000000000entity file8 is end entity; use std.textio.all; architecture test of file8 is begin p1: process is file F: text open read_mode is "NOT_HERE.txt"; -- Error begin wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/file9.vhd000066400000000000000000000005031504111170000167010ustar00rootroot00000000000000entity file9 is end entity; architecture test of file9 is begin p1: process is type ft is file of integer; file f : ft; begin -- "If F is not associated with an external file, then FILE_CLOSE -- has no effect" file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/for1.vhd000066400000000000000000000010041504111170000165350ustar00rootroot00000000000000entity for1 is end entity; architecture test of for1 is begin process is variable x : integer; begin for i in 1 to 5 loop report integer'image(i); end loop; for i in 100 downto 95 loop report integer'image(i); end loop; x := -1; for i in 1 to x loop null; end loop; x := 4; for i in 5 to x loop null; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/for2.vhd000066400000000000000000000005641504111170000165500ustar00rootroot00000000000000entity for2 is end entity; architecture test of for2 is type myint is range -1 to 4; type myenum is (A, B, C, D); begin process is begin for x in myint loop report myint'image(x); end loop; for y in myenum loop report myenum'image(y); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/for3.vhd000066400000000000000000000007751504111170000165550ustar00rootroot00000000000000entity for3 is end entity; architecture fum of for3 is signal mySignalVector: bit_vector (7 downto 0); signal myOtherSignal: bit := '1'; begin process begin L1: for i in 0 to 9 loop for i in 0 to 7 loop mySignalVector(i) <= myOtherSignal; report "outer loop i = " & integer'image(L1.i); report "inner loop i = " & integer'image(i); end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/for4.vhd000066400000000000000000000006461504111170000165530ustar00rootroot00000000000000entity for4 is end entity; architecture test of for4 is begin main: process is variable n, count : natural; begin n := 6; for i in 1 to n loop -- Discrete range evaluated here n := 3; -- Does not affect loop trip count count := count + 1; end loop; assert count = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/force1.vhd000066400000000000000000000013421504111170000170520ustar00rootroot00000000000000entity force1 is end entity; architecture test of force1 is signal s : natural; begin p1: s <= 1 after 1 ns, 2 after 2 ns, 3 after 3 ns, 4 after 4 ns; p2: process is begin assert s = 0; wait for 1 ns; assert s = 1; assert s'active; s <= force 42; assert s = 1; wait for 0 ns; assert s'active; assert s'event; assert s = 42; wait for 0 ns; assert not s'active; wait for 2 ns; assert s = 42; s <= release; assert s = 42; wait for 0 ns; assert s'active; assert s = 3; wait for 0 ns; assert not s'active; wait; end process; end architecture; nvc-r1.17.1/test/regress/force2.vhd000066400000000000000000000010011504111170000170430ustar00rootroot00000000000000entity force2 is end entity; architecture test of force2 is signal s : bit_vector(1 to 3); begin p1: process is variable n : integer; begin n := 3; assert s = "000"; s <= "101"; wait for 1 ns; s <= force "010"; wait for 0 ns; assert s = "010"; s(n) <= '0'; wait for 0 ns; assert s = "010"; s <= release; wait for 0 ns; assert s = "100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/force3.vhd000066400000000000000000000006421504111170000170560ustar00rootroot00000000000000entity force3 is end entity; architecture test of force3 is signal s : bit_vector(1 to 3); function get_val return bit_vector is begin return "111111111"; end function; begin s <= "111"; process is begin s <= force "101"; wait for 0 ns; assert s = "101"; s <= force get_val; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/func1.vhd000066400000000000000000000005431504111170000167110ustar00rootroot00000000000000entity func1 is end entity; architecture test of func1 is function add1(x : integer) return integer is begin return x + 1; end function; begin process is variable r : integer; begin r := 2; r := add1(r); assert r = 3 report integer'image(r); wait; end process; end architecture; nvc-r1.17.1/test/regress/func10.vhd000066400000000000000000000014611504111170000167710ustar00rootroot00000000000000entity func10 is end entity; architecture test of func10 is type int3d is array (natural range <>, natural range <>, natural range <>) of integer; function func1(x, y, z : in integer) return integer is variable r : int3d(1 to x, 1 to y, 1 to z); begin for i in 1 to x loop for j in 1 to y loop for k in 1 to z loop r(i, j, k) := i + j + k; end loop; end loop; end loop; return r(x / 2, y / 2, z / 2); end function; begin process is variable x, y, z : integer; begin x := 4; y := 5; z := 6; wait for 1 ns; assert func1(x, y, z) = 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/func11.vhd000066400000000000000000000006231504111170000167710ustar00rootroot00000000000000entity func11 is end entity; architecture test of func11 is function foo(x : integer) return integer is begin return x + 1; end function; function foo(x : integer) return real is begin return real(x) + 1.0; end function; begin process is begin assert foo(1) = 2; assert foo(1) = 2.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/func12.vhd000066400000000000000000000017421504111170000167750ustar00rootroot00000000000000entity func12 is end entity; architecture test of func12 is function popcnt_high(value : in bit_vector(7 downto 0)) return natural is variable cnt : natural := 0; begin report integer'image(value'left); for i in 7 downto 4 loop report bit'image(value(i)); if value(i) = '1' then cnt := cnt + 1; end if; end loop; return cnt; end function; function get_bits(v : in bit_vector(7 downto 0)) return bit_vector is begin for i in v'range loop report integer'image(i) & " = " & bit'image(v(i)); end loop; return v; end function; begin process is variable v : bit_vector(0 to 7) := X"05"; begin assert popcnt_high(v) = 0; v := X"f0"; assert popcnt_high(v) = 4; assert popcnt_high(get_bits(X"20")) = 1; --assert popcnt_high(v(0 to 3)) = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/func13.vhd000066400000000000000000000015651504111170000170010ustar00rootroot00000000000000entity func13 is end entity; architecture test of func13 is signal five : integer := 5; signal zero : integer := 0; begin process is variable x : integer; variable y : bit_vector(7 downto 0); impure function add_to_x(y : integer) return integer is impure function do_it return integer is begin report integer'image(x) & " + " & integer'image(y); return x + y; end function; begin return do_it; end function; impure function get_bit(n : integer) return bit is begin return y(n); end function; begin x := 2; assert add_to_x(five) = 7; x := 3; assert add_to_x(five) = 8; y := X"00"; assert get_bit(zero) = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/func14.vhd000066400000000000000000000014041504111170000167720ustar00rootroot00000000000000entity func14 is end entity; architecture test of func14 is begin one: process is function func(x : integer) return integer is begin return x * 2; end function; variable y : integer; begin y := 2; wait for 1 ns; assert func(y) = 4; y := 4; wait for 1 ns; assert func(y) = 8; wait; end process; two: process is function func(x : integer) return integer is begin return x / 2; end function; variable y : integer; begin y := 2; wait for 1 ns; assert func(y) = 1; y := 4; wait for 1 ns; assert func(y) = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/func15.vhd000066400000000000000000000006711504111170000170000ustar00rootroot00000000000000entity func15 is end entity; architecture test of func15 is -- Generated invalid LLVM IR function outer(d : bit_vector(7 downto 0)) return bit is function inner(x : in bit) return bit is begin return not x; end function; begin return inner(d(2)); end function; begin process is begin assert outer(X"ff") = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/func16.vhd000066400000000000000000000015621504111170000170010ustar00rootroot00000000000000entity func16 is end entity func16; architecture test of func16 is constant STATE_WORD_SIZE : integer := 8; type state_type is array (3 downto 0) of bit_vector(STATE_WORD_SIZE-1 downto 0); function TestFunction (StateInxD : state_type) return state_type is variable StateOutxD : state_type; begin StateOutxD := StateInxD; return StateOutxD; end function TestFunction; begin process is variable r : state_type; begin r(0) := x"12"; r(1) := x"34"; r(2) := x"56"; r(3) := x"78"; r := TestFunction(r); assert r(0) = x"12" report "Vector mismatch!!"; assert r(1) = x"34" report "Vector mismatch!!"; assert r(2) = x"56" report "Vector mismatch!!"; assert r(3) = x"78" report "Vector mismatch!!"; wait; end process; end architecture; nvc-r1.17.1/test/regress/func17.vhd000066400000000000000000000007351504111170000170030ustar00rootroot00000000000000entity func17 is end entity; architecture test of func17 is function func(x : bit_vector) return bit_vector is variable y : bit_vector(1 to x'length) := x; begin y(1 + x'length / 2) := '1'; -- Would corrupt X return y; end function; begin process is variable b : bit_vector(1 to 3); begin b := "101"; assert func(b) = "111"; assert b = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/func18.vhd000066400000000000000000000014031504111170000167750ustar00rootroot00000000000000entity func18 is end entity; architecture test of func18 is function get_array(n : in integer) return bit_vector is -- The state struct for this function cannot be allocated on the stack variable result : bit_vector(3 downto 0); function get_xor return bit_vector is begin case n is when 1 => return X"1"; when 2 => return X"2"; when others => return X"f"; end case; end function; begin result := result xor get_xor; return result; end function; begin p1: process is variable n : integer := 1; begin wait for 1 ns; assert get_array(n) = X"1"; wait; end process; end architecture; nvc-r1.17.1/test/regress/func19.vhd000066400000000000000000000010451504111170000170000ustar00rootroot00000000000000entity func19 is end entity; architecture test of func19 is function maybe_not_return (x : integer) return integer is begin if x > 0 then return x * 2; end if; end function; signal x, y : integer := 0; begin p1: y <= maybe_not_return(x); p2: process is begin x <= 55; wait for 1 ns; assert y = 110; x <= -1; wait for 1 ns; assert false report "should not reach here: " & integer'image(y); wait; end process; end architecture; nvc-r1.17.1/test/regress/func2.vhd000066400000000000000000000023371504111170000167150ustar00rootroot00000000000000entity func2 is end entity; architecture rtl of func2 is type int_array is array (integer range <>) of integer; function len(x : int_array) return integer is begin return x'length; end function; function sum(x : int_array) return integer is variable tmp : integer := 0; begin for i in x'range loop tmp := tmp + x(i); end loop; return tmp; end function; function asc(x : int_array) return boolean is begin return x'ascending; end function; function get_low(x : int_array) return integer is begin return x'low; end function; function get_high(x : int_array) return integer is begin return x'high; end function; begin process is variable u : int_array(5 downto 1) := (6, 3, 1, 1, 2); variable v : int_array(1 to 5) := (3, 5, 6, 1, 2); begin assert len(v) = 5; assert sum(v) = 17; assert len(u) = 5; assert sum(u) = 13; assert asc(v); assert get_low(u) = 1; assert get_low(v) = 1; assert get_high(u) = 5; assert get_high(v) = 5; assert not asc(u); wait; end process; end architecture; nvc-r1.17.1/test/regress/func20.vhd000066400000000000000000000006671504111170000170010ustar00rootroot00000000000000entity func20 is end entity; architecture test of func20 is impure function outer return string is variable s : string(1 to 5); impure function inner return string is begin return s; end function; begin s := "hello"; return inner; end function; begin p1: process is begin assert outer = "hello"; wait; end process; end architecture; nvc-r1.17.1/test/regress/func21.vhd000066400000000000000000000007511504111170000167740ustar00rootroot00000000000000entity func21 is end entity; architecture test of func21 is type rec is record x, y : integer; end record; function func (r : rec) return integer is begin return r.x + r.y; end function; begin p1: process is variable a, b : integer; begin assert func(r.x => 1, r.y => 2) = 3; a := 4; b := 5; wait for 1 ns; assert func(r.x => a, r.y => b) = 9; wait; end process; end architecture; nvc-r1.17.1/test/regress/func22.vhd000066400000000000000000000021241504111170000167710ustar00rootroot00000000000000entity func22 is end entity; architecture test of func22 is function iota return result_t of integer_vector is variable result : result_t; variable counter : natural; begin for i in result'range loop result(i) := counter; counter := counter + 1; end loop; return result; end function; signal s1 : integer_vector(1 to 5); signal s2 : integer_vector(6 to 6) := iota; begin p1: process is variable v1 : integer_vector(1 to 3); variable v2 : integer_vector(7 to 12); begin v1 := iota; assert v1 = (0, 1, 2); v2 := iota; assert v2 = (0, 1, 2, 3, 4, 5); wait; end process; p2: s2 <= iota; p3: process is begin assert s2 = (0 => 0); s1 <= iota; wait for 1 ns; assert s1 = (0, 1, 2, 3, 4); assert s2 = (0 => 0); wait; end process; p4: process is constant c1 : integer_vector(4 to 5) := iota; begin assert c1 = (0, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/func23.vhd000066400000000000000000000022031504111170000167700ustar00rootroot00000000000000entity func23 is end entity; architecture test of func23 is type rec_t is record f : integer_vector; end record; function iota return result_t of rec_t is variable result : result_t; variable counter : natural; begin for i in result.f'range loop result.f(i) := counter; counter := counter + 1; end loop; return result; end function; signal s1 : rec_t(f(1 to 5)); signal s2 : rec_t(f(6 to 6)) := iota; begin p1: process is variable v1 : rec_t(f(1 to 3)); variable v2 : rec_t(f(7 to 12)); begin v1 := iota; assert v1.f = (0, 1, 2); v2 := iota; assert v2.f = (0, 1, 2, 3, 4, 5); wait; end process; p2: s2 <= iota; p3: process is begin assert s2.f = (0 => 0); s1 <= iota; wait for 1 ns; assert s1.f = (0, 1, 2, 3, 4); assert s2.f = (0 => 0); wait; end process; p4: process is constant c1 : rec_t(f(4 to 5)) := iota; begin assert c1.f = (0, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/func24.vhd000066400000000000000000000007171504111170000170010ustar00rootroot00000000000000-- From VHDL Compliance-Tests repo library ieee; use ieee.numeric_std.all; entity func24 is end entity; architecture tb of func24 is begin main: process function meaning_of_life return return_value of unsigned is begin return to_unsigned(42, return_value'length); end function; variable the_answer : unsigned(7 downto 0); begin the_answer := meaning_of_life; assert the_answer = 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/func25.vhd000066400000000000000000000015031504111170000167740ustar00rootroot00000000000000entity func25 is end entity; architecture test of func25 is function change_bounds (s : string; l, r : positive) return string is alias ss : string(l to r) is s; begin return ss; end function; impure function get_string (c : character) return string is variable s : string(1 to 15); begin s := "hello, world! " & c; return change_bounds(s, 101, 115); -- Returns a pointer to S end function; function get_left (s : string) return positive is begin return s'left; end function; signal c : character := 'x'; begin p1: process is begin wait for 1 ns; report get_string(c); assert get_string(c) = "hello, world! x"; assert get_left(get_string(c)) = 101; wait; end process; end architecture; nvc-r1.17.1/test/regress/func3.vhd000066400000000000000000000035121504111170000167120ustar00rootroot00000000000000entity func3 is end entity; architecture test of func3 is type int_array is array (integer range <>) of integer; function copy_and_sum_1(x : int_array) return integer is variable tmp : int_array(1 to x'length); variable sum : integer := 0; begin for i in x'range loop tmp(i) := x(i); end loop; for i in tmp'range loop sum := sum + tmp(i); end loop; return sum; end function; function copy_and_sum_2(x : int_array) return integer is variable tmp : int_array(x'range); variable sum : integer := 0; begin for i in x'range loop tmp(i) := x(i); end loop; for i in tmp'range loop sum := sum + tmp(i); end loop; return sum; end function; function copy_and_add_1(x : int_array; y : integer) return int_array is variable tmp : int_array(1 to 5); begin for i in 1 to 5 loop tmp(i) := x(i) + y; end loop; return tmp; end function; function copy_and_add_2(x : int_array; y : integer) return int_array is variable tmp : int_array(x'range); begin for i in tmp'range loop tmp(i) := x(i) + y; report integer'image(tmp(i)); end loop; return tmp; end function; begin process is variable a : int_array(1 to 5) := (1, 2, 3, 4, 5); variable b : int_array(6 downto 2) := (1, 2, 3, 4, 5); variable c : int_array(1 to 5); begin assert copy_and_sum_1(a) = 15; assert copy_and_sum_2(a) = 15; assert copy_and_sum_2(b) = 15; c := copy_and_add_1(a, 1); assert c = (2, 3, 4, 5, 6); c := copy_and_add_2(a, 5); assert c = (6, 7, 8, 9, 10); wait; end process; end architecture; nvc-r1.17.1/test/regress/func4.vhd000066400000000000000000000007451504111170000167200ustar00rootroot00000000000000entity func4 is end entity; architecture test of func4 is type int_array is array (integer range <>) of integer; function cut(x : int_array; l, r : integer) return int_array is begin return x(l to r); end function; begin process is variable a : int_array(1 to 4) := (1, 2, 3, 4); variable tmp : int_array(1 to 2); begin tmp := cut(a, 2, 3); assert tmp = (2, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/func5.vhd000066400000000000000000000014161504111170000167150ustar00rootroot00000000000000package p is function add_one_s(signal s : in integer) return integer; function event(signal s : in integer) return boolean; end package; package body p is function add_one_s(signal s : in integer) return integer is begin return s + 1; end function; function event(signal s : in integer) return boolean is begin return s'event; end function; end package body; entity func5 is end entity; use work.p.all; architecture test of func5 is signal x : integer := 5; begin process is begin assert add_one_s(x) = 6; x <= 2; wait for 0 ns; assert event(x); wait for 1 ns; assert add_one_s(x) = 3; assert not event(x); wait; end process; end architecture; nvc-r1.17.1/test/regress/func6.vhd000066400000000000000000000014711504111170000167170ustar00rootroot00000000000000entity func6 is end entity; architecture test of func6 is function flip(x : bit_vector(3 downto 0)) return bit_vector is variable r : bit_vector(3 downto 0); begin r(0) := x(3); r(1) := x(2); r(2) := x(1); r(3) := x(0); return r; end function; function flipu(x : bit_vector) return bit_vector is begin return flip(x); end function; function flipu2(x : bit_vector) return bit_vector is begin return flip(x(3 downto 0)); end function; begin process is variable b : bit_vector(3 downto 0); begin assert flip("1010") = "0101"; b := "1100"; assert flip(b) = "0011"; assert flipu(b) = "0011"; assert flipu2(b) = "0011"; wait; end process; end architecture; nvc-r1.17.1/test/regress/func7.vhd000066400000000000000000000010031504111170000167070ustar00rootroot00000000000000entity func7 is end entity; architecture test of func7 is type int_vector is array (natural range <>) of integer; subtype int_vec_3 is int_vector(0 to 2); function get_ints(a, b, c : integer) return int_vec_3 is begin return int_vec_3'(a, b, c); end function; begin process is variable v : int_vec_3; begin v := get_ints(1, 2, 3); assert v = (1, 2, 3); assert get_ints(4, 5, 6) = (4, 5, 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/func8.vhd000066400000000000000000000011631504111170000167170ustar00rootroot00000000000000entity func8 is end entity; architecture test of func8 is type real_vector is array (natural range <>) of real; function lookup(index : integer) return real is constant table : real_vector := ( 0.62, 61.62, 71.7, 17.25, 26.15, 651.6, 0.45, 5.761 ); begin return table(index); end function; begin process is variable x : integer; begin x := 0; wait for 0 ns; assert lookup(x) = 0.62; -- Avoid constant folding x := 2; wait for 0 ns; assert lookup(x) = 71.7; wait; end process; end architecture; nvc-r1.17.1/test/regress/func9.vhd000066400000000000000000000012031504111170000167130ustar00rootroot00000000000000entity func9 is end entity; architecture test of func9 is constant msg0 : string := "zero"; constant msg1 : string := "one"; function get_message(x : in bit) return string is begin case x is when '0' => return msg0; when '1' => return msg1; end case; end function; begin process is variable x : bit; begin x := '1'; wait for 1 ns; -- Prevent constant folding assert get_message(x) = "one"; x := '0'; wait for 1 ns; assert get_message(x) = "zero"; wait; end process; end architecture; nvc-r1.17.1/test/regress/generic1.vhd000066400000000000000000000012011504111170000173620ustar00rootroot00000000000000entity bot is generic ( constant N : integer ); port ( x : out integer ); end entity; architecture test of bot is begin x <= N; end architecture; ------------------------------------------------------------------------------- entity generic1 is end entity; architecture test of generic1 is signal xa, xb : integer; begin a: entity work.bot generic map ( 5 ) port map ( xa ); b: entity work.bot generic map ( 7 ) port map ( xb ); process is begin wait for 1 ns; assert xa = 5; assert xb = 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack1.vhd000066400000000000000000000024201504111170000173620ustar00rootroot00000000000000package myfixed is generic ( whole : natural; frac : natural ); constant width : natural := whole + frac; type fixed_t is array (1 to width) of bit; function "+"(x, y : fixed_t) return fixed_t; function total_bits return natural; end package; package body myfixed is function total_bits return natural is begin return whole + frac; end function; function "+"(x, y : fixed_t) return fixed_t is variable result : fixed_t; begin for i in 1 to width loop result(i) := x(i) or y(i); end loop; return result; end function; end package body; ------------------------------------------------------------------------------- entity genpack1 is end entity; architecture test of genpack1 is package myfixed_2_4 is new work.myfixed generic map (2, 4); use myfixed_2_4.all; constant c : natural := myfixed_2_4.width; constant d : myfixed_2_4.fixed_t := (others => '0'); begin p1: process is variable v : myfixed_2_4.fixed_t; begin assert c = 6; assert myfixed_2_4.total_bits = 6; v := "110000"; v := v + d; assert v = "110000"; assert whole = 2; assert frac = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack10.vhd000066400000000000000000000017531504111170000174520ustar00rootroot00000000000000package pack1 is generic (n : integer); type pt is protected procedure get_str (s : out string); end protected; end package ; package body pack1 is constant h : string := "hello"; type pt is protected body procedure get_str (s : out string) is begin s := h; end procedure; end protected body; end package body; ------------------------------------------------------------------------------- package pack2 is procedure test; end package; package body pack2 is package inst is new work.pack1 generic map (n => 5) ; use inst.all; shared variable p : pt; procedure test is variable s : string(1 to 5); begin p.get_str(s); assert s = "hello"; end procedure; end package body ; ------------------------------------------------------------------------------- entity genpack10 is end entity; use work.pack2.all; architecture aa of genpack10 is begin test; end architecture; nvc-r1.17.1/test/regress/genpack11.vhd000066400000000000000000000017601504111170000174510ustar00rootroot00000000000000package pack is generic ( x : string := "foo" ) ; constant s : string := x ; constant k : integer; end package ; package body pack is constant k : integer := 42; end package body; ------------------------------------------------------------------------------- package pack2 is function get_str return string; constant kk : integer; end package ; package body pack2 is package pack3 is new work.pack generic map (x => "bar") ; use pack3.all; function get_str return string is begin return pack3.s; end function; constant kk : integer := pack3.k + 1; end package body ; ------------------------------------------------------------------------------- entity genpack11 is end entity; use work.pack2.all; architecture test of genpack11 is signal s : string(1 to 3) := "bar"; begin p1: process is begin assert get_str = "bar"; assert get_str = s; assert kk = 43; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack12.vhd000066400000000000000000000013431504111170000174470ustar00rootroot00000000000000package sigpack is generic (width : positive); signal s : bit_vector(1 to width); signal t : integer; end package; entity genpack12 is end entity; package p1 is new work.sigpack generic map (3); use work.p1.all; architecture test of genpack12 is package p2 is new work.sigpack generic map (4); package p3 is new work.sigpack generic map (5); begin s <= "110"; t <= 5; p2.s <= "1010"; p2.t <= 7; p3.s <= "11001"; p3.t <= 3; check: process is begin wait for 1 ns; assert s = "110"; assert p2.s = "1010"; assert p3.s = "11001"; assert t = 5; assert p2.t = 7; assert p3.t = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack13.vhd000066400000000000000000000012771504111170000174560ustar00rootroot00000000000000package outer is package inner is generic ( N : integer ); --impure function get_n return integer; end package; end package; -- package body outer is -- package body inner is -- impure function get_n return integer is -- begin -- return n; -- end function; -- end package body; -- end package body; entity genpack13 is end entity; use work.outer.all; architecture test of genpack13 is package inner4 is new inner generic map ( 4 ); package inner5 is new inner generic map ( 5 ); begin p1: process is begin assert inner4.n = 4; assert inner5.n = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack14.vhd000066400000000000000000000015531504111170000174540ustar00rootroot00000000000000package genpkg is generic (val : natural := 5; function plus (l, r : integer) return integer); procedure add (l : inout integer); end genpkg; package body genpkg is procedure add (l : inout integer) is begin l := plus (l, val); end add; end genpkg; package genpkg2 is generic (v : natural; type t1; package subgenpkg is new work.genpkg generic map (<>)); end genpkg2; package my_adder_pkg is new work.genpkg generic map (val => open, plus => "+"); ------------------------------------------------------------------------------- entity genpack14 is end entity; use work.my_adder_pkg.all; architecture test of genpack14 is begin p1: process is variable x : integer := 0; begin add(x); assert x = 5; add(x); assert x = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack15.vhd000066400000000000000000000042051504111170000174520ustar00rootroot00000000000000package generic_array_pkg is generic ( type t; size : natural ); type t_array is protected impure function get (pos : natural) return t; procedure set (pos : natural; value : t); end protected; end package; package body generic_array_pkg is type t_array is protected body type t_backing is array (1 to size) of t; variable data : t_backing; impure function get (pos : natural) return t is begin return data(pos); end function; procedure set (pos : natural; value : t) is begin data(pos) := value; end procedure; end protected body; end package body; ------------------------------------------------------------------------------- package generic_stack_pkg is generic ( type t; size : natural ); type t_stack is protected impure function pop return t; procedure push (value : t); end protected; end package; package body generic_stack_pkg is package array_pkg is new work.generic_array_pkg generic map ( t => t, size => size ); type t_stack is protected body variable count : natural; variable data : array_pkg.t_array; impure function pop return t is constant pos : positive := count; begin count := count - 1; return data.get(pos); end function; procedure push (value : t) is begin count := count + 1; data.set(count, value); end procedure; end protected body; end package body; ------------------------------------------------------------------------------- entity genpack15 is end entity; architecture test of genpack15 is package stack_pkg is new work.generic_stack_pkg generic map ( t => integer, size => 8 ); shared variable stack : stack_pkg.t_stack; begin tb: process is begin stack.push(5); stack.push(6); stack.push(7); wait for 1 ns; assert stack.pop = 7; assert stack.pop = 6; assert stack.pop = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack16.vhd000066400000000000000000000017021504111170000174520ustar00rootroot00000000000000package pack is generic ( g : integer ); constant msg : string; end package; package body pack is constant msg : string := "hello"; end package body; ------------------------------------------------------------------------------- entity sub is generic ( package p is new work.pack generic map (<>) ); port ( o : out string ); end entity; architecture test of sub is begin p1: process is begin report p.msg; o <= p.msg; wait; end process; end architecture; ------------------------------------------------------------------------------- entity genpack16 is end entity; architecture test of genpack16 is package i is new work.pack generic map ( 5 ); signal s : string(1 to 5); begin u: entity work.sub generic map ( i ) port map ( s ); check: process is begin wait for 1 ns; assert s = "hello"; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack17.vhd000066400000000000000000000036621504111170000174620ustar00rootroot00000000000000package adder is generic (type t; function "+" (a, b : t) return t is <>; function to_string (x : t) return string is <>); function add (x, y : t) return t; end package; package body adder is function add (x, y : t) return t is begin report "add " & to_string(x) & " + " & to_string(y); return x + y; end function; end package body; ------------------------------------------------------------------------------- entity sub is generic ( package p is new work.adder generic map (<>) ); port ( x, y : in p.t; z : out p.t ); end entity; architecture test of sub is begin z <= p.add(x, y); end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub is generic ( package p is new work.adder generic map (<>) ); port ( x : in p.t; z : out p.t ); end component; signal xr, zr : real := 0.0; signal xi, zi : integer := 0; package real_adder is new work.adder generic map ( real ); package int_adder is new work.adder generic map ( integer ); begin u1: sub generic map ( real_adder ) port map ( xr, zr ); u2: sub generic map ( int_adder ) port map ( xi, zi ); check: process is begin xr <= 1.0; wait for 1 ns; assert zr = 2.0; xr <= 5.0; wait for 1 ns; assert zr = 10.0; xi <= 8; wait for 1 ns; assert zi = 16; xi <= 100; wait for 1 ns; assert zi = 200; wait; end process; end architecture; ------------------------------------------------------------------------------- configuration genpack17 of top is for test for all : sub use entity work.sub port map ( x => x, y => x, z => z ); end for; end for; end configuration; nvc-r1.17.1/test/regress/genpack18.vhd000066400000000000000000000041101504111170000174500ustar00rootroot00000000000000package adder is generic (type t; function "+" (a, b : t) return t is <>; function to_string (x : t) return string is <>); function add (x, y : t) return t; end package; package body adder is function add (x, y : t) return t is begin report "add " & to_string(x) & " + " & to_string(y); return x + y; end function; end package body; ------------------------------------------------------------------------------- package components is component sub_c is generic ( package p is new work.adder generic map (<>) ); port ( x : in p.t; z : out p.t ); end component; end package; ------------------------------------------------------------------------------- entity sub is generic ( package p is new work.adder generic map (<>) ); port ( x, y : in p.t; z : out p.t ); end entity; architecture test of sub is begin z <= p.add(x, y); end architecture; ------------------------------------------------------------------------------- entity top is end entity; use work.components.all; architecture test of top is signal xr, zr : real := 0.0; signal xi, zi : integer := 0; package real_adder is new work.adder generic map ( real ); package int_adder is new work.adder generic map ( integer ); begin u1: sub_c generic map ( real_adder ) port map ( xr, zr ); u2: sub_c generic map ( int_adder ) port map ( xi, zi ); check: process is begin xr <= 1.0; wait for 1 ns; assert zr = 2.0; xr <= 5.0; wait for 1 ns; assert zr = 10.0; xi <= 8; wait for 1 ns; assert zi = 16; xi <= 100; wait for 1 ns; assert zi = 200; wait; end process; end architecture; ------------------------------------------------------------------------------- configuration genpack18 of top is for test for all : sub_c use entity work.sub port map ( x => x, y => x, z => z ); end for; end for; end configuration; nvc-r1.17.1/test/regress/genpack19.vhd000066400000000000000000000032731504111170000174620ustar00rootroot00000000000000package pack1 is function get_string return string; end package; package body pack1 is constant s : string := "hello"; function get_string return string is begin return s; end function; end package body; ------------------------------------------------------------------------------- package pack2 is generic ( x : integer ); function get_string return string; end package; package body pack2 is function get_string return string is begin return work.pack1.get_string; end function; end package body; ------------------------------------------------------------------------------- package pack3 is function get_string return string; end package; package body pack3 is constant s : string := "world"; function get_string return string is begin return s; end function; end package body; ------------------------------------------------------------------------------- package pack4 is generic ( x : integer ); function get_string return string; end package; package body pack4 is function get_string return string is begin return work.pack3.get_string; end function; end package body; ------------------------------------------------------------------------------- package inst1 is new work.pack2 generic map ( 4 ); ------------------------------------------------------------------------------- entity genpack19 is end entity; architecture test of genpack19 is package inst2 is new work.pack4 generic map ( 6 ); begin check: process is begin assert work.inst1.get_string = "hello"; assert inst2.get_string = "world"; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack2.vhd000066400000000000000000000022361504111170000173700ustar00rootroot00000000000000package poly is generic (a, b : integer); function apply (x : integer) return integer; end package; package body poly is function apply (x : integer) return integer is begin return x * a + b; end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply(n); end function; end package body; ------------------------------------------------------------------------------- entity genpack2 is end entity; architecture test of genpack2 is package my_poly1 is new work.poly generic map (a => 2, b => 3); package my_wrap1 is new work.wrapper generic map (p => my_poly1); begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 7; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 13; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack3.vhd000066400000000000000000000032711504111170000173710ustar00rootroot00000000000000package poly is generic (a, b : integer); function apply (x : integer) return integer; end package; package body poly is function apply (x : integer) return integer is begin return x * a + b; end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; procedure check_params (xa, xb : integer); end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply(n); end function; procedure check_params (xa, xb : integer) is begin report "a=" & to_string(a) & " b=" & to_string(b); assert a = xa; assert b = xb; end procedure; end package body; ------------------------------------------------------------------------------- entity genpack3 is end entity; architecture test of genpack3 is package my_poly1 is new work.poly generic map (a => 2, b => 3); package my_wrap1 is new work.wrapper generic map (p => my_poly1); package my_poly2 is new work.poly generic map (a => 5, b => 1); package my_wrap2 is new work.wrapper generic map (p => my_poly2); begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 7; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 13; my_wrap1.check_params(2, 3); assert my_wrap2.wrapped_apply(2) = 11; assert my_wrap2.wrapped_apply(v) = 26; my_wrap2.check_params(v, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack4.vhd000066400000000000000000000036201504111170000173700ustar00rootroot00000000000000package poly is generic (a, b : integer); function apply (x : integer) return integer; end package; package body poly is function add (x, y : integer) return integer is begin return x + y; end function; function mul (x, y : integer) return integer is begin return x * y; end function; function apply (x : integer) return integer is begin return add(mul(x, a), b); end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; procedure check_params (xa, xb : integer); end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply(n); end function; procedure check_params (xa, xb : integer) is begin report "a=" & to_string(a) & " b=" & to_string(b); assert a = xa; assert b = xb; end procedure; end package body; ------------------------------------------------------------------------------- entity genpack4 is end entity; architecture test of genpack4 is package my_poly1 is new work.poly generic map (a => 2, b => 3); package my_wrap1 is new work.wrapper generic map (p => my_poly1); package my_poly2 is new work.poly generic map (a => 5, b => 1); package my_wrap2 is new work.wrapper generic map (p => my_poly2); begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 7; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 13; my_wrap1.check_params(2, 3); assert my_wrap2.wrapped_apply(2) = 11; assert my_wrap2.wrapped_apply(v) = 26; my_wrap2.check_params(v, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack5.vhd000066400000000000000000000026601504111170000173740ustar00rootroot00000000000000package poly is generic (a, b, def : integer); function apply (x : integer := def) return integer; end package; package body poly is function apply (x : integer := def) return integer is begin return x * a + b; end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply(n); end function; end package body; ------------------------------------------------------------------------------- entity genpack5 is end entity; architecture test of genpack5 is package my_poly1 is new work.poly generic map (a => 2, b => 3, def => 10); package my_wrap1 is new work.wrapper generic map (p => my_poly1); package my_poly2 is new work.poly generic map (a => 5, b => 1, def => 1); package my_wrap2 is new work.wrapper generic map (p => my_poly2); begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 7; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 13; assert my_wrap2.wrapped_apply(2) = 11; assert my_wrap2.wrapped_apply(v) = 26; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack6.vhd000066400000000000000000000026541504111170000174000ustar00rootroot00000000000000package poly is generic (a, b, def : integer); function apply (x : integer := def) return integer; end package; package body poly is function apply (x : integer := def) return integer is begin return x * a + b; end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply; end function; end package body; ------------------------------------------------------------------------------- entity genpack6 is end entity; architecture test of genpack6 is package my_poly1 is new work.poly generic map (a => 2, b => 3, def => 10); package my_wrap1 is new work.wrapper generic map (p => my_poly1); package my_poly2 is new work.poly generic map (a => 5, b => 1, def => 1); package my_wrap2 is new work.wrapper generic map (p => my_poly2); begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 23; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 23; assert my_wrap2.wrapped_apply(2) = 6; assert my_wrap2.wrapped_apply(v) = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack7.vhd000066400000000000000000000030371504111170000173750ustar00rootroot00000000000000package poly is generic (a, b, def : integer); function apply (x : integer := def) return integer; end package; package body poly is function apply (x : integer := def) return integer is begin return x * a + b; end function; end package body; ------------------------------------------------------------------------------- package wrapper is generic ( package p is new work.poly generic map ( <> ) ); function wrapped_apply (n : integer) return integer; end package; package body wrapper is use p.all; function wrapped_apply (n : integer) return integer is begin return apply; end function; end package body; ------------------------------------------------------------------------------- package my_poly1 is new work.poly generic map (a => 2, b => 3, def => 10); package my_wrap1 is new work.wrapper generic map (p => work.my_poly1); package my_poly2 is new work.poly generic map (a => 5, b => 1, def => 1); package my_wrap2 is new work.wrapper generic map (p => work.my_poly2); ------------------------------------------------------------------------------- entity genpack7 is end entity; use work.my_wrap1; use work.my_wrap2; architecture test of genpack7 is begin main: process is variable v : integer := 5; begin assert my_wrap1.wrapped_apply(2) = 23; wait for 1 ns; assert my_wrap1.wrapped_apply(v) = 23; assert my_wrap2.wrapped_apply(2) = 6; assert my_wrap2.wrapped_apply(v) = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack8.vhd000066400000000000000000000041451504111170000173770ustar00rootroot00000000000000package gen_counter_pt is generic ( type t; one, zero : t; function "+"(x, y : t) return t is <>; function "-"(x, y : t) return t is <> ); type counter is protected procedure increment; procedure decrement; impure function value return t; end protected; end package; package body gen_counter_pt is type counter is protected body variable val : t := zero; procedure increment is begin val := val + one; end procedure; procedure decrement is begin val := val - one; end procedure; impure function value return t is begin return val; end function; end protected body; end package body; ------------------------------------------------------------------------------- package gen_counter is generic ( type t; one, zero : t; function "+"(x, y : t) return t is <>; function "-"(x, y : t) return t is <> ); package pt is new work.gen_counter_pt generic map ( t => t, one => one, zero => zero ); shared variable var : pt.counter; end package; ------------------------------------------------------------------------------- package int_counter is new work.gen_counter generic map ( t => integer, one => 1, zero => 0 ); ------------------------------------------------------------------------------- use work.int_counter; entity genpack8 is end entity; architecture test of genpack8 is package real_counter is new work.gen_counter generic map (t => real, one => 1.0, zero => 0.0 ); begin main: process is begin assert int_counter.var.value = 0; int_counter.var.increment; int_counter.var.increment; int_counter.var.decrement; assert int_counter.var.value = 1; assert real_counter.var.value = 0.0; real_counter.var.increment; real_counter.var.increment; real_counter.var.decrement; assert real_counter.var.value = 1.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/genpack9.vhd000066400000000000000000000015071504111170000173770ustar00rootroot00000000000000package pack1 is generic (n : integer); function add (x : integer) return integer; end package ; package body pack1 is function add (x : integer) return integer is begin return x + n; end function; end package body; ------------------------------------------------------------------------------- package pack2 is procedure test; end package; package body pack2 is package inst is new work.pack1 generic map (n => 5) ; use inst.all; procedure test is variable v : integer := 5; begin assert add(2) = 7; assert add(v) = 10; end procedure; end package body ; ------------------------------------------------------------------------------- entity genpack9 is end entity; use work.pack2.all; architecture aa of genpack9 is begin test; end architecture; nvc-r1.17.1/test/regress/gensub1.vhd000066400000000000000000000006731504111170000172450ustar00rootroot00000000000000entity gensub1 is end entity; architecture test of gensub1 is function adder generic (n : integer) (x : integer) return integer is begin return x + n; end function; function add1 is new adder generic map (1); signal s : integer; begin p1: process is begin assert add1(1) = 2; s <= 5; wait for 1 ns; assert add1(s) = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/gensub2.vhd000066400000000000000000000013121504111170000172350ustar00rootroot00000000000000entity gensub2 is end entity; architecture test of gensub2 is function adder generic (type t; function "+"(l, r : t) return t is <>; n : t) (x : t) return t is begin return x + n; end function; function add1 is new adder generic map (t => integer, n => 1); function add1 is new adder generic map (t => real, n => 1.0); signal s : integer; signal r : real; begin p1: process is begin assert add1(1) = 2; assert add1(2.0) = 3.0; s <= 5; r <= 4.0; wait for 1 ns; assert add1(s) = 6; assert add1(r) = 5.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/gensub3.vhd000066400000000000000000000022331504111170000172410ustar00rootroot00000000000000package pack1 is function adder generic (type t; function "+"(l, r : t) return t is <>; n : t) (x : t) return t; end package; package body pack1 is function adder generic (type t; function "+"(l, r : t) return t is <>; n : t) (x : t) return t is begin return x + n; end function; end package body; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is function add1 is new adder generic map (t => integer, n => 1); function add1 is new adder generic map (t => real, n => 1.0); end package; ------------------------------------------------------------------------------- entity gensub3 is end entity; use work.pack2.all; architecture test of gensub3 is signal s : integer; signal r : real; begin p1: process is begin assert add1(1) = 2; assert add1(2.0) = 3.0; s <= 5; r <= 4.0; wait for 1 ns; assert add1(s) = 6; assert add1(r) = 5.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/gensub4.vhd000066400000000000000000000030041504111170000172370ustar00rootroot00000000000000package genfact is function fact generic (type t; function "*"(l, r : t) return t is <>; function "-"(l, r : t) return t is <>; function "<"(l, r : t) return boolean is <>; one : t) (n : t) return t; end package; package body genfact is function fact generic (type t; function "*"(l, r : t) return t is <>; function "-"(l, r : t) return t is <>; function "<"(l, r : t) return boolean is <>; one : t) (n : t) return t is begin if n < one then return one; else return n * fact(n - ONE); end if; end function; end package body; ------------------------------------------------------------------------------- entity gensub4 is end entity; architecture test of gensub4 is function fact_int is new work.genfact.fact generic map (t => integer, one => 1); function fact_real is new work.genfact.fact generic map (t => real, one => 1.0); signal s : integer; signal r : real; begin p1: process is begin assert fact_int(1) = 1; assert fact_int(5) = 120; assert fact_real(1.0) = 1.0; assert fact_real(4.0) = 24.0; s <= 4; r <= 2.0; wait for 1 ns; assert fact_int(s) = 24; assert fact_real(r) = 2.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/gensub5.vhd000066400000000000000000000012401504111170000172400ustar00rootroot00000000000000entity gensub5 is end entity; architecture test of gensub5 is function f generic(type t; function to_string(x : t) return string is <>) parameter(value : t ; sfmt : string := "s") return string is begin return to_string(value) & sfmt; end function ; type state_t is (IDLE, CHECKING, FOO, BAR) ; function to_string(x : state_t) return string is begin return state_t'image(x) ; end function ; function f is new f generic map (t => state_t) ; begin p1: process is begin assert f(idle) = "idles"; assert f(foo) = "foos"; wait; end process; end architecture; nvc-r1.17.1/test/regress/gensub6.vhd000066400000000000000000000021311504111170000172410ustar00rootroot00000000000000entity gensub6 is end entity; architecture test of gensub6 is procedure proc generic (procedure preal(value : out real); procedure pint(value : out integer)) (x : out integer; y : out real) is begin preal(y); pint(x); end procedure; procedure get generic (type t; n : t) (x : out t) is begin x := n; end procedure; procedure get_one is new get generic map (t => integer, n => 1); procedure get_one is new get generic map (t => real, n => 1.0); procedure get_two is new get generic map (t => integer, n => 2); procedure get_two is new get generic map (t => real, n => 2.0); procedure proc_one is new proc generic map (preal => get_one, get_one); procedure proc_two is new proc generic map (preal => get_two, get_two); begin p1: process is variable i : integer; variable r : real; begin proc_one(i, r); assert i = 1; assert r = 1.0; proc_two(i, r); assert i = 2; assert r = 2.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype1.vhd000066400000000000000000000050311504111170000174260ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity fifo is generic ( type T; DEPTH : positive ); port ( clk : in std_logic; pop : in std_logic; push : in std_logic; full : out std_logic; valid : out std_logic; din : in T; dout : out T ); end entity; architecture test of fifo is type fifo_data_t is array (0 to DEPTH - 1) of T; signal wptr, rptr : natural := 1; signal data : fifo_data_t; begin full <= '1' when (wptr + 1) mod DEPTH = rptr else '0'; valid <= '1' when wptr /= rptr else '0'; dout <= data(rptr); behav: process (clk) is begin if rising_edge(clk) then if push = '1' then assert full = '0'; data(wptr) <= din; wptr <= (wptr + 1) mod DEPTH; end if; if pop = '1' then assert valid = '1'; rptr <= (rptr + 1) mod DEPTH; end if; end if; end process; end architecture; ------------------------------------------------------------------------------- entity gentype1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of gentype1 is signal clk : std_logic; signal pop : std_logic; signal push : std_logic; signal din : integer; signal dout : integer; signal full : std_logic; signal valid : std_logic; procedure pulse (signal clk : out std_logic) is begin clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin u: entity work.fifo generic map ( T => integer, depth => 4 ) port map ( clk => clk, pop => pop, push => push, din => din, dout => dout, full => full, valid => valid ); main: process is begin wait for 1 ns; assert full = '0'; assert valid = '0'; din <= 5; push <= '1'; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = 5; din <= 7; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = 5; push <= '0'; pop <= '1'; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = 7; pulse(clk); assert full = '0'; assert valid = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype2.vhd000066400000000000000000000013231504111170000174270ustar00rootroot00000000000000package cmp_pkg is generic ( type t; function cmp_fn (x, y : t) return boolean ); function equal (a, b : t) return boolean; end package; package body cmp_pkg is function equal (a, b : t) return boolean is begin return cmp_fn(a, b); end function; end package body; ------------------------------------------------------------------------------- entity gentype2 is end entity; architecture test of gentype2 is package cmp_int is new work.cmp_pkg generic map ( t => integer, cmp_fn => "=" ); use cmp_int.all; begin main: process is begin assert equal(4, 4); assert not equal(5, 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype3.vhd000066400000000000000000000051541504111170000174360ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity fifo is generic ( type T; DEPTH : positive ); port ( clk : in std_logic; pop : in std_logic; push : in std_logic; full : out std_logic; valid : out std_logic; din : in T; dout : out T ); end entity; architecture test of fifo is type fifo_data_t is array (0 to DEPTH - 1) of T; signal wptr, rptr : natural := 1; signal data : fifo_data_t; begin full <= '1' when (wptr + 1) mod DEPTH = rptr else '0'; valid <= '1' when wptr /= rptr else '0'; dout <= data(rptr); behav: process (clk) is begin if rising_edge(clk) then if push = '1' then assert full = '0'; data(wptr) <= din; wptr <= (wptr + 1) mod DEPTH; end if; if pop = '1' then assert valid = '1'; rptr <= (rptr + 1) mod DEPTH; end if; end if; end process; end architecture; ------------------------------------------------------------------------------- entity gentype3 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of gentype3 is signal clk : std_logic; signal pop : std_logic; signal push : std_logic; signal din : std_logic_vector(7 downto 0); signal dout : std_logic_vector(7 downto 0); signal full : std_logic; signal valid : std_logic; procedure pulse (signal clk : out std_logic) is begin clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin u: entity work.fifo generic map ( T => std_logic_vector(7 downto 0), depth => 4 ) port map ( clk => clk, pop => pop, push => push, din => din, dout => dout, full => full, valid => valid ); main: process is begin wait for 1 ns; assert full = '0'; assert valid = '0'; din <= X"05"; push <= '1'; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = X"05"; din <= X"07"; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = X"05"; push <= '0'; pop <= '1'; pulse(clk); assert full = '0'; assert valid = '1'; assert dout = X"07"; pulse(clk); assert full = '0'; assert valid = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype4.vhd000066400000000000000000000012701504111170000174320ustar00rootroot00000000000000package cmp_pkg is generic ( type t ); function equal (a, b : t) return boolean; end package; package body cmp_pkg is function equal (a, b : t) return boolean is begin return a = b; end function; end package body; ------------------------------------------------------------------------------- entity gentype4 is end entity; architecture test of gentype4 is package cmp_int is new work.cmp_pkg generic map ( integer ); use cmp_int.all; begin main: process is variable v : integer; begin v := 4; wait for 1 ns; assert equal(4, v); assert not equal(5, 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype5.vhd000066400000000000000000000020041504111170000174270ustar00rootroot00000000000000-- https://github.com/VHDL/Compliance-Tests/blob/main/vhdl_2008/tb_entity_generic_type.vhd entity entity_generic_type is generic ( type mytype; function is_good (x: mytype) return boolean ); port( data : in mytype; good : out boolean ); end entity; architecture arch of entity_generic_type is begin good <= is_good(data); end architecture arch; entity gentype5 is end entity; architecture tb of gentype5 is function integer_good (x: integer) return boolean is begin if x /= 0 then return true; else return false; end if; end function integer_good; signal data : integer; signal good : boolean; begin uut : entity work.entity_generic_type generic map( mytype => integer, is_good => integer_good ) port map( data => data, good => good ); main : process begin data <= 10; wait for 1 ns; assert good; data <= 0; wait for 1 ns; assert not good; wait; end process main; end architecture tb; nvc-r1.17.1/test/regress/gentype6.vhd000066400000000000000000000017461504111170000174440ustar00rootroot00000000000000package pack1 is type t is (a, b, c); function "=" (l, r : t) return boolean; end package; package body pack1 is function "=" (l, r : t) return boolean is begin -- Should be called in both 2008 and 2019 report "user-defined = called"; return false; end function; end package body; ------------------------------------------------------------------------------- package pack2 is generic (type g); function equal (l, r : g) return boolean; end package; package body pack2 is function equal (l, r : g) return boolean is begin return l = r; end function; end package body; ------------------------------------------------------------------------------- entity gentype6 is end entity; use work.pack1.all; architecture test of gentype6 is package pack3 is new work.pack2 generic map (g => t); begin check: process is begin assert not pack3.equal(a, a); wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype7.vhd000066400000000000000000000030231504111170000174330ustar00rootroot00000000000000entity gentype7 is end entity; architecture test of gentype7 is signal i : integer; signal a : bit_vector(1 to 3); signal v : integer_vector(1 to 5); begin b1: block is generic ( type t is range <> ); generic map ( t => integer ); signal s : t; begin i <= integer(s); s <= 42; end block; b2: block is generic ( type e is (<>); type i is range <>; type t is array (i range <>) of bit ); generic map ( e => bit, i => natural, t => bit_vector ); signal s : t(1 to 3); begin a <= bit_vector(s); s <= "101"; end block; b3: block is package gp is generic ( type element_type is private; type index_type is (<>); type array_type is array (index_type range <>) of element_type; left_index, right_index : index_type ); signal s : array_type(left_index to right_index); end package; package p is new gp generic map ( element_type => integer, index_type => natural, array_type => integer_vector, left_index => 1, right_index => 5 ); begin p.s <= (1, 2, 3, 4, 5); v <= p.s; end block; check: process is begin wait for 1 ns; assert i = 42; assert a = "101"; assert v = (1, 2, 3, 4, 5); wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype8.vhd000066400000000000000000000022551504111170000174420ustar00rootroot00000000000000entity sub is generic ( type t; function "+" (a, b : t) return t is <> ); port ( x, y : in t; z : out t ); end entity; architecture test of sub is begin z <= x + y; end architecture; ------------------------------------------------------------------------------- entity gentype8 is end entity; architecture test of gentype8 is component sub is generic ( type t; function "+" (a, b : t) return t is <> ); port ( cx : in t; cz : out t ); end component; signal xr, zr : real := 0.0; signal xi, zi : integer := 0; for all : sub use entity work.sub port map ( x => cx, y => cx, z => cz ); begin u1: sub generic map ( real ) port map ( xr, zr ); u2: sub generic map ( integer ) port map ( xi, zi ); check: process is begin xr <= 1.0; wait for 1 ns; assert zr = 2.0; xr <= 5.0; wait for 1 ns; assert zr = 10.0; xi <= 8; wait for 1 ns; assert zi = 16; xi <= 100; wait for 1 ns; assert zi = 200; wait; end process; end architecture; nvc-r1.17.1/test/regress/gentype9.vhd000066400000000000000000000025321504111170000174410ustar00rootroot00000000000000entity sub is generic ( type t; function "+" (a, b : t) return t is <> ); port ( x, y : in t; z : out t ); end entity; architecture test of sub is begin z <= x + y; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub is generic ( type t; function "+" (a, b : t) return t is <> ); port ( cx : in t; cz : out t ); end component; signal xr, zr : real := 0.0; signal xi, zi : integer := 0; begin u1: sub generic map ( real ) port map ( xr, zr ); u2: sub generic map ( integer ) port map ( xi, zi ); check: process is begin xr <= 1.0; wait for 1 ns; assert zr = 2.0; xr <= 5.0; wait for 1 ns; assert zr = 10.0; xi <= 8; wait for 1 ns; assert zi = 16; xi <= 100; wait for 1 ns; assert zi = 200; wait; end process; end architecture; ------------------------------------------------------------------------------- configuration gentype9 of top is for test for all : sub use entity work.sub port map ( x => cx, y => cx, z => cz ); end for; end for; end configuration; nvc-r1.17.1/test/regress/gold/000077500000000000000000000000001504111170000161155ustar00rootroot00000000000000nvc-r1.17.1/test/regress/gold/access1.txt000066400000000000000000000001331504111170000201750ustar00rootroot000000000000000ms+1: 10 0ms+1: 9 0ms+1: 8 0ms+1: 7 0ms+1: 6 0ms+1: 5 0ms+1: 4 0ms+1: 3 0ms+1: 2 0ms+1: 1 nvc-r1.17.1/test/regress/gold/access10.txt000066400000000000000000000003171504111170000202610ustar00rootroot00000000000000out of memory attempting to allocate 64 byte object Note: the current heap size is 1048576 bytes which you can increase with the -H option, for example -H 2m Procedure DO_TEST [REC_PTR] Process :access10:p1 nvc-r1.17.1/test/regress/gold/access6.txt000066400000000000000000000000301504111170000201760ustar00rootroot00000000000000null access dereference nvc-r1.17.1/test/regress/gold/access8.txt000066400000000000000000000001531504111170000202060ustar00rootroot00000000000000attempting to allocate 40000000024 byte object which is larger than the maximum supported 4294967295 bytes nvc-r1.17.1/test/regress/gold/alias1.txt000066400000000000000000000005041504111170000200270ustar00rootroot000000000000000ms+0: --- X1 --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: --- Y1 --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: --- Z1 --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 1ns+0: --- X2 --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 1ns+0: --- Y2 --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 1ns+0: --- Z2 --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 nvc-r1.17.1/test/regress/gold/alias12.txt000066400000000000000000000003441504111170000201130ustar00rootroot00000000000000value length 2 does not match alias A length 3 alias12.vhd | 7 | alias a : bit_vector(1 to 3) is x; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Function GET [BIT_VECTOR, NATURAL return BIT] Process :alias12:main nvc-r1.17.1/test/regress/gold/alias2.txt000066400000000000000000000004761504111170000200400ustar00rootroot000000000000000ms+0: --- X --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: --- Y --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: --- Z --- 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 1ns+0: --- X --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 1ns+0: --- Y --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 1ns+0: --- Z --- 1ns+0: 1 1ns+0: 2 1ns+0: 3 1ns+0: 4 nvc-r1.17.1/test/regress/gold/alias5.txt000066400000000000000000000000451504111170000200330ustar00rootroot000000000000000ms+0: tpd'left=3 0ms+0: tpd'right=0 nvc-r1.17.1/test/regress/gold/arith2.txt000066400000000000000000000000211504111170000200400ustar00rootroot00000000000000division by zero nvc-r1.17.1/test/regress/gold/arith4.txt000066400000000000000000000000741504111170000200520ustar00rootroot000000000000001ns+0: result of 2 ** 16 cannot be represented as MY_UINT16 nvc-r1.17.1/test/regress/gold/arith5.txt000066400000000000000000000000301504111170000200430ustar00rootroot000000000000002ns+0: division by zero nvc-r1.17.1/test/regress/gold/array15.txt000066400000000000000000000003351504111170000201430ustar00rootroot00000000000000choice length 5 does not match expected length 3 | 15 | 2 => get_bits(b) ); | ^^^^^^^^^^^^^^^^ Procedure DO_TEST [NATURAL, NATURAL] Process :array15:p1 nvc-r1.17.1/test/regress/gold/assert1.txt000066400000000000000000000001041504111170000202330ustar00rootroot000000000000000ms+0: hello world 0ms+0: not important 0ms+0: Assertion violation. nvc-r1.17.1/test/regress/gold/assert10.txt000066400000000000000000000006201504111170000203160ustar00rootroot000000000000000 fs foo error bar message### ###message #message## 0 fs foo error bar long message long message long message 0ms+0: invalid string replacement variable 'Q' ** ERROR: message at 0.005 ns : :assert10 5ps+0: message 5ps+0: invalid precision 'foobar' in format string ** ERROR: report at 0.005 ns : :assert10 5ps+0: precision is only valid for 't' variable 5ps+0: invalid assert format: {s:.sec} nvc-r1.17.1/test/regress/gold/assert2.txt000066400000000000000000000000171504111170000202370ustar00rootroot000000000000001ns+1: x >= 10 nvc-r1.17.1/test/regress/gold/assert3.txt000066400000000000000000000000331504111170000202360ustar00rootroot00000000000000Note: 0ms+0: should assert nvc-r1.17.1/test/regress/gold/assert6.txt000066400000000000000000000021001504111170000202360ustar00rootroot000000000000001ns+0: Assertion violation. | 17 | assert x = 5 severity warning; | ^^^^^ 0 = 5 is false 1ns+0: Assertion violation. | 18 | assert x < -1 severity warning; | ^^^^^^ 0 < -1 is false 1ns+0: Assertion violation. | 19 | assert character'val(x) /= NUL severity warning; | ^^^^^^^^^^^^^^^^^^^^^^^ NUL /= NUL is false 2ns+0: Assertion violation. | 22 | assert x > 1000 severity warning; | ^^^^^^^^ 512 > 1000 is false 2ns+0: Assertion violation. | 23 | assert x <= 2 severity warning; | ^^^^^^ 512 <= 2 is false 2ns+0: Assertion violation. | 24 | assert x >= 2000 severity warning; | ^^^^^^^^^ 512 >= 2000 is false 2ns+0: Assertion violation. | 25 | assert y = 4.56 severity warning; | ^^^^^^^^ 3.1419999999999999 = 4.5599999999999996 is false 2ns+0: Assertion violation. 2ns+0: Assertion violation. | 30 | assert p = null severity warning; = NULL is false nvc-r1.17.1/test/regress/gold/assert7.txt000066400000000000000000000013071504111170000202470ustar00rootroot000000000000000ms+0: this is error 1 0ms+0: this is error 2 0ms+0: this is error 3 0ms+0: this is error 4 0ms+0: this is error 5 0ms+0: this is error 6 0ms+0: this is error 7 0ms+0: this is error 8 0ms+0: this is error 9 0ms+0: this is error 10 0ms+0: this is error 11 0ms+0: this is error 12 0ms+0: this is error 13 0ms+0: this is error 14 0ms+0: this is error 15 0ms+0: this is error 16 0ms+0: this is error 17 0ms+0: this is error 18 0ms+0: this is error 19 0ms+0: this is error 20 0ms+0: this is error 21 0ms+0: this is error 22 0ms+0: this is error 23 0ms+0: this is error 24 0ms+0: this is error 25 0ms+0: this is error 26 0ms+0: this is error 27 0ms+0: this is error 28 0ms+0: this is error 29 0ms+0: this is error 30 nvc-r1.17.1/test/regress/gold/assert8.txt000066400000000000000000000004561504111170000202540ustar00rootroot00000000000000Note: 0ms+0: First note Warning: 0ms+0: First warning Error: 0ms+0: First error Note: 0ms+0: Second note Warning: 0ms+0: Second warning Error: 0ms+0: Second error Note: 0ms+0: Clearing VHDL asserts Note: 0ms+0: Note report Warning: 0ms+0: Warning report Error: 0ms+0: Error report 0ms+0: FINISH called nvc-r1.17.1/test/regress/gold/assert9.txt000066400000000000000000000002251504111170000202470ustar00rootroot000000000000005ns+0: EXAMPLE NOTE 5ns+0: EXAMPLE WARNING 5ns+0: EXAMPLE ERROR 6ns+0: EXAMPLE WARNING 6ns+0: EXAMPLE ERROR 7ns+0: EXAMPLE ERROR 9ns+0: END THE TEST nvc-r1.17.1/test/regress/gold/attr12.txt000066400000000000000000000000561504111170000177740ustar00rootroot000000000000000ms+0: :work:pack: <-- 0ms+0: :work:pack: <-- nvc-r1.17.1/test/regress/gold/attr17.txt000066400000000000000000000002641504111170000200020ustar00rootroot00000000000000Note: 0ms+0: A ~ :work:pack:func[integer return integer]:x Note: 0ms+0: B ~ :work:pack:func[integer return integer] Note: 0ms+0: C ~ :attr17(arch):report_instance_name[string]:val nvc-r1.17.1/test/regress/gold/attr19.txt000066400000000000000000000004031504111170000177770ustar00rootroot00000000000000:attr19(arch):monitor[record_t]:/0 fs: (a => -2147483648, b => '0') :attr19(arch):monitor[record_t]:/0 fs: (a => 10, b => '0') :attr19(arch):monitor[record_t]:/10000000 fs: (a => 11, b => '0') :attr19(arch):monitor[record_t]:/25000000 fs: (a => 11, b => '1') nvc-r1.17.1/test/regress/gold/attr21.txt000066400000000000000000000001541504111170000177730ustar00rootroot000000000000000ms+0: :attr21(test):foo[integer return boolean]: 0ms+0: :attr21(test):foo[bit return string]: 0ms+0: hello nvc-r1.17.1/test/regress/gold/attr3.txt000066400000000000000000000001321504111170000177070ustar00rootroot000000000000000ms+0: 5 0ms+0: 4 0ms+0: 3 0ms+0: 2 0ms+0: 1 0ms+0: 5 0ms+0: 4 0ms+0: 3 0ms+0: 2 0ms+0: 1 nvc-r1.17.1/test/regress/gold/bounds1.txt000066400000000000000000000000531504111170000202270ustar00rootroot00000000000000index 602 outside of INTEGER range 1 to 10 nvc-r1.17.1/test/regress/gold/bounds10.txt000066400000000000000000000000621504111170000203070ustar00rootroot00000000000000value length 8 does not match variable A length 4 nvc-r1.17.1/test/regress/gold/bounds11.txt000066400000000000000000000002071504111170000203110ustar00rootroot00000000000000value 101 outside of MY_INT range 0 to 100 for signal I bounds11.vhd | 9 | p1: i <= i + 1 after 10 ns; | ^^^^^ nvc-r1.17.1/test/regress/gold/bounds12.txt000066400000000000000000000000361504111170000203120ustar00rootroot00000000000000invalid integer value "hello" nvc-r1.17.1/test/regress/gold/bounds13.txt000066400000000000000000000002401504111170000203100ustar00rootroot00000000000000value 4 outside of MYINT range 1 to 3 | 8 | type myint is range 1 to 3; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Attribute MYINT'VALUE bounds13.vhd nvc-r1.17.1/test/regress/gold/bounds14.txt000066400000000000000000000000611504111170000203120ustar00rootroot00000000000000value length 12 does not match signal X length 8 nvc-r1.17.1/test/regress/gold/bounds15.txt000066400000000000000000000002661504111170000203220ustar00rootroot00000000000000value -1 outside of NATURAL range 0 to 2147483647 for parameter N bounds15.vhd | 25 | report integer'image(fact(x)); -- Error | ^ nvc-r1.17.1/test/regress/gold/bounds16.txt000066400000000000000000000002751504111170000203230ustar00rootroot00000000000000value -1 outside of NATURAL range 0 to 2147483647 for variable R | 7 | variable r : natural := x; | ^ Function ADD_NAT [INTEGER return NATURAL] bounds16.vhd nvc-r1.17.1/test/regress/gold/bounds17.txt000066400000000000000000000000631504111170000203170ustar00rootroot00000000000000value length 12 does not match variable X length 8 nvc-r1.17.1/test/regress/gold/bounds18.txt000066400000000000000000000001441504111170000203200ustar00rootroot00000000000000actual length 3 does not match parameter X length 5 Procedure PROC [POSITIVE] Process :bounds18:_p0 nvc-r1.17.1/test/regress/gold/bounds19.txt000066400000000000000000000001761504111170000203260ustar00rootroot00000000000000actual length 2 for dimension 2 does not match parameter X length 3 Procedure PROC [POSITIVE, POSITIVE] Process :bounds19:_p0 nvc-r1.17.1/test/regress/gold/bounds2.txt000066400000000000000000000000551504111170000202320ustar00rootroot00000000000000index 51761 outside of INTEGER range 1 to 10 nvc-r1.17.1/test/regress/gold/bounds20.txt000066400000000000000000000000601504111170000203060ustar00rootroot00000000000000value length 3 does not match signal B length 2 nvc-r1.17.1/test/regress/gold/bounds21.txt000066400000000000000000000000651504111170000203140ustar00rootroot00000000000000actual length 8 does not match generic INFO length 7 nvc-r1.17.1/test/regress/gold/bounds22.txt000066400000000000000000000000561504111170000203150ustar00rootroot00000000000000value length 6 does not match target length 5 nvc-r1.17.1/test/regress/gold/bounds23.txt000066400000000000000000000000561504111170000203160ustar00rootroot00000000000000value length 5 does not match target length 3 nvc-r1.17.1/test/regress/gold/bounds24.txt000066400000000000000000000000651504111170000203170ustar00rootroot00000000000000value length 1000 does not match variable R length 3 nvc-r1.17.1/test/regress/gold/bounds25.txt000066400000000000000000000000631504111170000203160ustar00rootroot00000000000000value length 19 does not match variable X length 2 nvc-r1.17.1/test/regress/gold/bounds26.txt000066400000000000000000000000601504111170000203140ustar00rootroot00000000000000index DEL outside of CHARACTER range 'a' to 'c' nvc-r1.17.1/test/regress/gold/bounds27.txt000066400000000000000000000000501504111170000203140ustar00rootroot00000000000000index 1 outside of NATURAL range 1 to 0 nvc-r1.17.1/test/regress/gold/bounds28.txt000066400000000000000000000002741504111170000203250ustar00rootroot00000000000000value -5 FS outside of DELAY_LENGTH range 0 HR to 9223372036854775807 FS for variable T bounds28.vhd | 16 | t := n * fs; -- Error | ^^^^^^ nvc-r1.17.1/test/regress/gold/bounds29.txt000066400000000000000000000000771504111170000203270ustar00rootroot00000000000000value 10.00001 outside of MY_REAL range 0 to 10 for variable R nvc-r1.17.1/test/regress/gold/bounds3.txt000066400000000000000000000000631504111170000202320ustar00rootroot00000000000000index -2147483648 outside of INTEGER range 5 to 7 nvc-r1.17.1/test/regress/gold/bounds30.txt000066400000000000000000000000731504111170000203130ustar00rootroot00000000000000negative exponent -1 only allowed for floating-point types nvc-r1.17.1/test/regress/gold/bounds31.txt000066400000000000000000000000571504111170000203160ustar00rootroot00000000000000value length 3 does not match field X length 6 nvc-r1.17.1/test/regress/gold/bounds32.txt000066400000000000000000000002361504111170000203160ustar00rootroot00000000000000value length 4 does not match target length 3 bounds32.vhd | 22 | s <= (x => v(1 to n)); -- Error | ^^^^^^^^^ nvc-r1.17.1/test/regress/gold/bounds33.txt000066400000000000000000000003131504111170000203130ustar00rootroot00000000000000value length 16 does not match target length 3 bounds33.vhd | 11 | p := (x => "1111111111111111"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Procedure ASSIGN [REC] Process :bounds33:main nvc-r1.17.1/test/regress/gold/bounds34.txt000066400000000000000000000002021504111170000203110ustar00rootroot00000000000000index 6 outside of INTEGER range 1 to 4 bounds34.vhd | 15 | x := ( y, 0, integer_vector'(1, 2, 3) ); -- Error | nvc-r1.17.1/test/regress/gold/bounds35.txt000066400000000000000000000002561504111170000203230ustar00rootroot00000000000000aggregate length 4 does not match subtype INTEGER_VECTOR length 2 bounds35.vhd | 16 | (i1, i0) := x(4 downto i1); -- Error | ^^^^^^^^ nvc-r1.17.1/test/regress/gold/bounds36.txt000066400000000000000000000002541504111170000203220ustar00rootroot00000000000000aggregate length 4 does not match subtype INTEGER_VECTOR length 3 bounds36.vhd | 16 | (i1, y) := x(4 downto i1); -- Error | ^^^^^^^ nvc-r1.17.1/test/regress/gold/bounds37.txt000066400000000000000000000002541504111170000203230ustar00rootroot00000000000000aggregate length 4 does not match subtype INTEGER_VECTOR length 3 bounds37.vhd | 17 | (i1, y) <= x(4 downto i1); -- Error | ^^^^^^^ nvc-r1.17.1/test/regress/gold/bounds38.txt000066400000000000000000000003311504111170000203200ustar00rootroot00000000000000index 5 outside of INTEGER range 1 to 2 | 14 | result(i, j) := x(i, j) * 2; -- Error | ^ Function DOUBLE [INT_VEC_2D return INT_VEC_2D] Process :bounds38:p2 nvc-r1.17.1/test/regress/gold/bounds39.txt000066400000000000000000000000741504111170000203250ustar00rootroot000000000000001ns+0: value length 9 does not match subtype BV10 length 10 nvc-r1.17.1/test/regress/gold/bounds4.txt000066400000000000000000000000521504111170000202310ustar00rootroot00000000000000index 15 outside of NATURAL range 1 to 10 nvc-r1.17.1/test/regress/gold/bounds40.txt000066400000000000000000000001071504111170000203120ustar00rootroot00000000000000(init): aggregate length 6 does not match subtype REAL_VECTOR length 5 nvc-r1.17.1/test/regress/gold/bounds41.txt000066400000000000000000000002511504111170000203130ustar00rootroot00000000000000(init): index 6 outside of INTEGER range 1 to 5 bounds41.vhd:15 | 15 | constant c2 : real_vector(1 to c1'length) := (0.0, 1.0, 0.0, 1.0, c1(2), 0.0); | nvc-r1.17.1/test/regress/gold/bounds42.txt000066400000000000000000000001101504111170000203060ustar00rootroot000000000000000ms+0: 00001111 0ms+0: choice length 8 does not match expected length 3 nvc-r1.17.1/test/regress/gold/bounds43.txt000066400000000000000000000001261504111170000203160ustar00rootroot00000000000000(init): value -9223372036854775808 outside of INTEGER range -2147483648 to 2147483647 nvc-r1.17.1/test/regress/gold/bounds44.txt000066400000000000000000000002431504111170000203170ustar00rootroot000000000000000ms+0: value length 5 does not match signal P length 2 bounds44.vhd:13 | 13 | port map ( p => inertial get_bits('1', 5) ); | ^ nvc-r1.17.1/test/regress/gold/bounds45.txt000066400000000000000000000001141504111170000203150ustar00rootroot000000000000000ms+0: value length 3 does not match constant SLV_ARRAY_NORMALIZED length 7 nvc-r1.17.1/test/regress/gold/bounds5.txt000066400000000000000000000000541504111170000202340ustar00rootroot00000000000000index 9 outside of INTEGER range 8 downto 0 nvc-r1.17.1/test/regress/gold/bounds6.txt000066400000000000000000000002431504111170000202350ustar00rootroot00000000000000value 1517262 outside of CHARACTER range NUL to 'ÿ' for attribute 'VAL bounds6.vhd | 17 | c := character'val(i); | ^^^^^^^^^^^^^^^^ nvc-r1.17.1/test/regress/gold/bounds7.txt000066400000000000000000000000701504111170000202340ustar00rootroot00000000000000value 11 outside of MY_INT range 1 to 10 for variable X nvc-r1.17.1/test/regress/gold/bounds8.txt000066400000000000000000000000601504111170000202340ustar00rootroot00000000000000value length 8 does not match signal A length 4 nvc-r1.17.1/test/regress/gold/bounds9.txt000066400000000000000000000000611504111170000202360ustar00rootroot00000000000000index 0 outside of NATURAL range 1 to 2147483647 nvc-r1.17.1/test/regress/gold/case13.txt000066400000000000000000000002141504111170000177320ustar00rootroot000000000000000ms+0: zeros 0ms+1: ones expression length 5 does not match case choice length 3 | 19 | case get_bits(n, b) is | ^ nvc-r1.17.1/test/regress/gold/case5.txt000066400000000000000000000001561504111170000176600ustar00rootroot00000000000000value 9 outside of MODCOUNT range 0 to 7 case5.vhd | 13 | case modcount(integer(a) + b) is | nvc-r1.17.1/test/regress/gold/cond1.txt000066400000000000000000000000621504111170000176600ustar00rootroot000000000000000ms+0: x = y 0ms+0: x /= y + 1 0ms+0: x = y still nvc-r1.17.1/test/regress/gold/cond2.txt000066400000000000000000000000331504111170000176570ustar00rootroot000000000000001ns+0: y = 2 1ns+0: x /= 4 nvc-r1.17.1/test/regress/gold/conf1.txt000066400000000000000000000001341504111170000176620ustar00rootroot000000000000001ns+0: 4 <=> 2 = false 2ns+0: 4 <=> 7 = true 11ns+0: 4 <=> 2 = true 12ns+0: 4 <=> 7 = false nvc-r1.17.1/test/regress/gold/conf2.txt000066400000000000000000000001341504111170000176630ustar00rootroot000000000000001ns+0: 4 <=> 2 = false 2ns+0: 4 <=> 7 = true 11ns+0: 4 <=> 2 = true 12ns+0: 4 <=> 7 = false nvc-r1.17.1/test/regress/gold/const3.txt000066400000000000000000000000271504111170000200660ustar00rootroot000000000000000ms+0: zero 0ms+0: one nvc-r1.17.1/test/regress/gold/conv10.txt000066400000000000000000000001251504111170000177620ustar00rootroot000000000000000ms+0: value -9223372036854775808 outside of INTEGER range -2147483648 to 2147483647 nvc-r1.17.1/test/regress/gold/counter.txt000066400000000000000000000001041504111170000203300ustar00rootroot000000000000000ms+0: -2147483648 5ns+2: 1 15ns+2: 2 25ns+2: 3 35ns+2: 4 45ns+2: 5 nvc-r1.17.1/test/regress/gold/cover1.txt000066400000000000000000000003021504111170000200500ustar00rootroot00000000000000** Note: code coverage results for: WORK.COVER1 ** Note: statement: 97.7 % (42/43) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. nvc-r1.17.1/test/regress/gold/cover1.xml000066400000000000000000000153621504111170000200450ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover10.txt000066400000000000000000000046151504111170000201430ustar00rootroot00000000000000** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_0_TO_1' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_1_TO_0' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered coverage details. ** Note: code coverage results for: WORK.COVER10 ** Note: statement: 100.0 % (8/8) ** Note: branch: N.A. ** Note: toggle: 66.7 % (4/6) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_0_TO_1' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_1_TO_0' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: uncovered coverage details. ** Note: code coverage results for: WORK.COVER10 ** Note: statement: 100.0 % (8/8) ** Note: branch: N.A. ** Note: toggle: 66.7 % (4/6) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_0_TO_1' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.BIN_1_TO_0' > data/cover10_ef1.txt:2 | 2 | exclude WORK.COVER10.SIGNAL_WHICH_IS_EXCLUDED.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: excluded coverage details. ** Note: code coverage results for: WORK.COVER10 ** Note: statement: 100.0 % (8/8) ** Note: branch: N.A. ** Note: toggle: 66.7 % (4/6) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover12.txt000066400000000000000000000014251504111170000201410ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER12 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: 100.0 % (24/24) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER12 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: 58.3 % (14/24) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover13.txt000066400000000000000000000024771504111170000201520ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER13 ** Note: statement: 100.0 % (11/11) ** Note: branch: N.A. ** Note: toggle: 50.0 % (2/4) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Coverage for sub-hierarchies: Hierarchy Statement Branch Toggle Expression FSM state LEVEL_1_INST 100.0 % (4/4) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) NOT_INTERESTING_ENTITY_INST 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) LEVEL_2_INST 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) NOT_INTERESTING_ENTITY_INST 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) 0.0 % (0/0) LEAF_ENTITY_INST 100.0 % (7/7) 0.0 % (0/0) 50.0 % (2/4) 0.0 % (0/0) 0.0 % (0/0) nvc-r1.17.1/test/regress/gold/cover14.txt000066400000000000000000000014101504111170000201350ustar00rootroot00000000000000** Note: excluding expression: 'WORK.COVER14._P0._S0._E6.BIN_1_1' > data/cover14_ef1.txt:1 | 1 | exclude WORK.COVER14._P0._S0._E6.BIN_1_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER14._P1._S0._E5.BIN_0_1' > data/cover14_ef1.txt:2 | 2 | exclude WORK.COVER14._P1._S0._E5.BIN_0_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER14 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: 85.7 % (12/14) ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover15.xml000066400000000000000000000074261504111170000201340ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover16.xml000066400000000000000000000073741504111170000201370ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover17.xml000066400000000000000000000031051504111170000201240ustar00rootroot00000000000000 . nvc-r1.17.1/test/regress/gold/cover18.txt000066400000000000000000000034101504111170000201430ustar00rootroot00000000000000** Warning: redirecting work/_WORK.COVER18.elab.covdb to cover18.ncdb, please update your scripts ** Note: excluding FSM state: 'WORK.COVER18.CURR_STATE.BIN_STATE.ST_ONE' > data/cover18_ef.txt:1 | 1 | exclude WORK.COVER18.CURR_STATE.BIN_STATE.ST_ONE | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: FSM state: 'WORK.COVER18.CURR_STATE.BIN_STATE.ST_WAITING' is already covered, it will be reported as covered. > data/cover18_ef.txt:2 | 2 | exclude WORK.COVER18.CURR_STATE.BIN_STATE.ST_WAITING | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding FSM state: 'WORK.COVER18.STATE_REG.BIN_STATE.S_10' > data/cover18_ef.txt:4 | 4 | exclude WORK.COVER18.STATE_REG.BIN_STATE.S_10 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding FSM state: 'WORK.COVER18.STATE_REG.BIN_STATE.S_100' > data/cover18_ef.txt:5 | 5 | exclude WORK.COVER18.STATE_REG.BIN_STATE.S_100 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding FSM state: 'WORK.COVER18.STATE_REG.BIN_STATE.S_200' > data/cover18_ef.txt:6 | 6 | exclude WORK.COVER18.STATE_REG.BIN_STATE.S_200 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding FSM state: 'WORK.COVER18.STATE_REG.BIN_STATE.S_270' > data/cover18_ef.txt:7 | 7 | exclude WORK.COVER18.STATE_REG.BIN_STATE.S_270 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER18 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: 6.5 % (18/278) ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover19.txt000066400000000000000000000007521504111170000201520ustar00rootroot00000000000000** Warning: redirecting work/_WORK.COVER19.elab.covdb to cover19.ncdb, please update your scripts ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER19 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: 66.7 % (6/9) ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover2.xml000066400000000000000000000423601504111170000200440ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover20.txt000066400000000000000000000006231504111170000201370ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER20 ** Note: statement: 100.0 % (16/16) ** Note: branch: N.A. ** Note: toggle: 50.0 % (4/8) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover21.txt000066400000000000000000000010171504111170000201360ustar00rootroot00000000000000** Warning: redirecting work/_WORK.COVER21.elab.covdb to cover21.ncdb, please update your scripts ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER21 ** Note: statement: 100.0 % (13/13) ** Note: branch: 100.0 % (2/2) ** Note: toggle: 83.3 % (5/6) ** Note: expression: 100.0 % (2/2) ** Note: FSM state: N.A. ** Note: functional: 75.0 % (3/4) nvc-r1.17.1/test/regress/gold/cover22.txt000066400000000000000000000013631504111170000201430ustar00rootroot00000000000000** Warning: the -c sub-command is deprecated, use --cover-report or --cover-merge instead ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER22_A ** Note: statement: 100.0 % (4/4) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: code coverage results for: SECOND_LIB.COVER22_B ** Note: statement: 100.0 % (4/4) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover23.txt000066400000000000000000000027671504111170000201550ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK_A.COVER23_TOP_TB ** Note: statement: 91.7 % (33/36) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: code coverage results for: WORK_B.COVER23_UNIT_TB ** Note: statement: 71.4 % (10/14) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Debug: folding coverage scopes: ** Note: Target - WORK_A.COVER23_TOP_TB.DUT_TOP_INST.SUB_BLOCK_INST ** Note: Source - WORK_B.COVER23_UNIT_TB.SUB_BLOCK_INST ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK_A.COVER23_TOP_TB ** Note: statement: 97.2 % (35/36) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: code coverage results for: WORK_B.COVER23_UNIT_TB ** Note: statement: 71.4 % (10/14) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover24.txt000066400000000000000000000007711504111170000201470ustar00rootroot00000000000000** Warning: redirecting work/_WORK.COVER24.elab.covdb to cover24.ncdb, please update your scripts ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: cover24.vhd ** Note: statement: 75.0 % (6/8) ** Note: branch: 50.0 % (2/4) ** Note: toggle: N.A. ** Note: expression: 50.0 % (1/2) ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover25.xml000066400000000000000000000023211504111170000201220ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover26.txt000066400000000000000000000006111504111170000201420ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER26 ** Note: statement: 100.0 % (4/4) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover27.txt000066400000000000000000000006111504111170000201430ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER27 ** Note: statement: 100.0 % (8/8) ** Note: branch: N.A. ** Note: toggle: N.A. ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover27_a.xml000066400000000000000000000034411504111170000204300ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover27_b.xml000066400000000000000000000034471504111170000204370ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover3.xml000066400000000000000000000161331504111170000200440ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover4.xml000066400000000000000000000052761504111170000200530ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover5.txt000066400000000000000000000040631504111170000200640ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER5 ** Note: statement: 42.9 % (9/21) ** Note: branch: 14.3 % (2/14) ** Note: toggle: 3.1 % (1/32) ** Note: expression: 14.3 % (2/14) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER5 ** Note: statement: 47.6 % (10/21) ** Note: branch: 28.6 % (4/14) ** Note: toggle: 6.2 % (2/32) ** Note: expression: 28.6 % (4/14) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER5 ** Note: statement: 52.4 % (11/21) ** Note: branch: 42.9 % (6/14) ** Note: toggle: 9.4 % (3/32) ** Note: expression: 42.9 % (6/14) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER5 ** Note: statement: 57.1 % (12/21) ** Note: branch: 50.0 % (7/14) ** Note: toggle: 12.5 % (4/32) ** Note: expression: 50.0 % (7/14) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER5 ** Note: statement: 100.0 % (21/21) ** Note: branch: 92.9 % (13/14) ** Note: toggle: 28.1 % (9/32) ** Note: expression: 92.9 % (13/14) ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover6.txt000066400000000000000000000022301504111170000200570ustar00rootroot00000000000000** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER6 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: 16.7 % (2/12) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER6 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: 33.3 % (4/12) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER6 ** Note: statement: N.A. ** Note: branch: N.A. ** Note: toggle: 50.0 % (6/12) ** Note: expression: N.A. ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/cover7.xml000066400000000000000000000150421504111170000200460ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover8.xml000066400000000000000000000325641504111170000200570ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/cover9.txt000066400000000000000000000336361504111170000201000ustar00rootroot00000000000000** Note: excluding toggle: 'WORK.COVER9.S_A.BIN_0_TO_1' > data/cover9_ef1.txt:48 | 48 | exclude WORK.COVER9.S_A.BIN_0_TO_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_B.BIN_0_TO_1' > data/cover9_ef1.txt:49 | 49 | exclude WORK.COVER9.S_B.* | ^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_B.BIN_1_TO_0' > data/cover9_ef1.txt:49 | 49 | exclude WORK.COVER9.S_B.* | ^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(2).BIN_0_TO_1' > data/cover9_ef1.txt:50 | 50 | exclude WORK.COVER9.S_Y(2).BIN_0_TO_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(2).BIN_1_TO_0' > data/cover9_ef1.txt:51 | 51 | exclude WORK.COVER9.S_Y(2).BIN_1_TO_0 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(1).BIN_0_TO_1' > data/cover9_ef1.txt:52 | 52 | exclude WORK.COVER9.S_Y(1).* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(1).BIN_1_TO_0' > data/cover9_ef1.txt:52 | 52 | exclude WORK.COVER9.S_Y(1).* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(0).BIN_0_TO_1' > data/cover9_ef1.txt:53 | 53 | exclude WORK.COVER9.S_Y(0).* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.S_Y(0).BIN_1_TO_0' > data/cover9_ef1.txt:53 | 53 | exclude WORK.COVER9.S_Y(0).* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.A.BIN_0_TO_1' > data/cover9_ef1.txt:54 | 54 | exclude WORK.COVER9.A.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.A.BIN_1_TO_0' > data/cover9_ef1.txt:54 | 54 | exclude WORK.COVER9.A.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.B.BIN_0_TO_1' > data/cover9_ef1.txt:55 | 55 | exclude WORK.COVER9.B.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.B.BIN_1_TO_0' > data/cover9_ef1.txt:55 | 55 | exclude WORK.COVER9.B.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.Y.BIN_0_TO_1' > data/cover9_ef1.txt:56 | 56 | exclude WORK.COVER9.Y.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.Y.BIN_1_TO_0' > data/cover9_ef1.txt:56 | 56 | exclude WORK.COVER9.Y.* | ^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.A.BIN_0_TO_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: toggle: 'WORK.COVER9.SUB_BLOCK_INST.A.BIN_1_TO_0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.B.BIN_0_TO_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.B.BIN_1_TO_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(2).BIN_0_TO_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(2).BIN_1_TO_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(1).BIN_0_TO_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(1).BIN_1_TO_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(0).BIN_0_TO_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding toggle: 'WORK.COVER9.SUB_BLOCK_INST.Y(0).BIN_1_TO_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: statement: 'WORK.COVER9.SUB_BLOCK_INST.XOR_GATE._S0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.SUB_BLOCK_INST.XOR_GATE._S0._E0.BIN_0_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.XOR_GATE._S0._E1.BIN_0_1' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.SUB_BLOCK_INST.XOR_GATE._S0._E2.BIN_1_0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.SUB_BLOCK_INST.XOR_GATE._S0._E3.BIN_1_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: statement: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E0.BIN_FALSE' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E1.BIN_TRUE' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E2.BIN_FALSE' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E3.BIN_TRUE' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E4.BIN_0_1' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E5.BIN_1_0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._E6.BIN_1_1' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding branch: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0.BIN_TRUE' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: branch: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0.BIN_FALSE' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding statement: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B0._S0' > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: statement: 'WORK.COVER9.SUB_BLOCK_INST.AND_GATE._S0._B1._S0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Warning: statement: 'WORK.COVER9.SUB_BLOCK_INST._P0._S0' is already covered, it will be reported as covered. > data/cover9_ef1.txt:5 | 5 | exclude WORK.COVER9.SUB_BLOCK_INST.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.P0._S0._E0.BIN_0_0' > data/cover9_ef1.txt:32 | 32 | exclude WORK.COVER9.P0._S0._E0.BIN_0_0 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.P0._S0._E1.BIN_0_1' > data/cover9_ef1.txt:33 | 33 | exclude WORK.cover9.P0._S0._E1.BIN_0_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.P0._S0._E2.BIN_1_0' > data/cover9_ef1.txt:34 | 34 | exclude WORK.COVER9.P0._S0._E2.BIN_1_0 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.P0._S0._E3.BIN_1_1' > data/cover9_ef1.txt:35 | 35 | exclude WORK.COVER9.P0._S0._E3.BIN_1_1 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.AND_GATE._S0._B0._E1.BIN_TRUE' > data/cover9_ef1.txt:41 | 41 | exclude WORK.COVER9.AND_GATE._S0._B0._E1.BIN_TRUE | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.AND_GATE._S0._B0._E3.BIN_TRUE' > data/cover9_ef1.txt:42 | 42 | exclude WORK.COVER9.AND_GATE._S0._B0._E3.BIN_TRUE | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.AND_GATE._S0._B0._E4.BIN_0_1' > data/cover9_ef1.txt:37 | 37 | exclude WORK.COVER9.AND_GATE._S0._B0._E4.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.AND_GATE._S0._B0._E5.BIN_1_0' > data/cover9_ef1.txt:38 | 38 | exclude WORK.COVER9.AND_GATE._S0._B0._E5.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding expression: 'WORK.COVER9.AND_GATE._S0._B0._E6.BIN_1_1' > data/cover9_ef1.txt:39 | 39 | exclude WORK.COVER9.AND_GATE._S0._B0._E6.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding branch: 'WORK.COVER9.AND_GATE._S0._B0.BIN_TRUE' > data/cover9_ef1.txt:20 | 20 | exclude WORK.COVER9.AND_GATE._S0._B0.BIN_TRUE | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding statement: 'WORK.COVER9.AND_GATE._S0._B0.A' > data/cover9_ef1.txt:10 | 10 | exclude WORK.COVER9.AND_GATE._S0._B0.A | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding branch: 'WORK.COVER9.P1.CASE_STMT._B3.BIN_CHOICE' > data/cover9_ef1.txt:23 | 23 | exclude WORK.COVER9.P1.CASE_STMT._B3.BIN_CHOICE | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding statement: 'WORK.COVER9.P1.CASE_STMT.RPT4' > data/cover9_ef1.txt:11 | 11 | exclude WORK.COVER9.P1.CASE_STMT.RPT4 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding branch: 'WORK.COVER9.P1.CASE_STMT._B4.BIN_CHOICE' > data/cover9_ef1.txt:26 | 26 | exclude WORK.COVER9.P1.case_stmt._B4.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding statement: 'WORK.COVER9.P1.CASE_STMT.RPT5' > data/cover9_ef1.txt:12 | 12 | exclude WORK.COVER9.p1.CASE_STMT.RPT5 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding branch: 'WORK.COVER9.P1.CASE_STMT._B_OTHERS.BIN_CHOICE' > data/cover9_ef1.txt:27 | 27 | exclude WORK.COVER9.P1.CASE_STMT._B_OTHERS.* | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: excluding statement: 'WORK.COVER9.P1.CASE_STMT.RPT6' > data/cover9_ef1.txt:13 | 13 | exclude WORK.COVER9.P1.CASE_STMT.RPT6 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER9 ** Note: statement: 100.0 % (29/29) ** Note: branch: 100.0 % (10/10) ** Note: toggle: 79.4 % (27/34) ** Note: expression: 100.0 % (22/22) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Error: invalid command: exducles > data/cover9_ef2.txt:5 | 5 | exducles HALO.HALO | ^^^^^^^^^^^^^^^^^^ ** Warning: excluded hierarchy does not match any coverage item: 'THIS_HIERARCHY_IS_FOR_SURE_INVALID_SHOULD_THROW_WARNING' > data/cover9_ef2.txt:2 | 2 | exclude THIS_HIERARCHY_IS_FOR_SURE_INVALID_SHOULD_THROW_WARNING | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html1. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER9 ** Note: statement: 82.8 % (24/29) ** Note: branch: 50.0 % (5/10) ** Note: toggle: 8.8 % (3/34) ** Note: expression: 40.9 % (9/22) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Warning: excluded hierarchy does not match any coverage item: 'WORK.COVER9.P0._S0._E0.WTF_BIN' > data/cover9_ef3.txt:3 | 3 | exclude WORK.COVER9.P0._S0._E0.WTF_BIN | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ** Note: Code coverage report folder: html2. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER9 ** Note: statement: 82.8 % (24/29) ** Note: branch: 50.0 % (5/10) ** Note: toggle: 8.8 % (3/34) ** Note: expression: 40.9 % (9/22) ** Note: FSM state: N.A. ** Note: functional: N.A. ** Error: exclude hierarchy missing > data/cover9_ef5.txt:3 | 3 | exclude | ^^^^^^^ ** Note: Code coverage report folder: html4. ** Note: Code coverage report contains: covered, uncovered, excluded coverage details. ** Note: code coverage results for: WORK.COVER9 ** Note: statement: 82.8 % (24/29) ** Note: branch: 50.0 % (5/10) ** Note: toggle: 8.8 % (3/34) ** Note: expression: 40.9 % (9/22) ** Note: FSM state: N.A. ** Note: functional: N.A. nvc-r1.17.1/test/regress/gold/debug1.txt000066400000000000000000000005101504111170000200210ustar00rootroot00000000000000Warning: 0ms+0: There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es). Function MAKE_BINARY [UNSIGNED return UNSIGNED] Function SHL [UNSIGNED, UNSIGNED return UNSIGNED] Function SHL [STD_LOGIC_VECTOR, STD_LOGIC_VECTOR return STD_LOGIC_VECTOR] Process :debug1:warn Note: 1ns+0: simulation finished nvc-r1.17.1/test/regress/gold/debug2.txt000066400000000000000000000007201504111170000200250ustar00rootroot00000000000000Warning: 0ms+0: p1 Warning: 0ms+0: proc1 Procedure PROC1 [] Process :debug2:p1 Warning: 0ms+0: proc1 Procedure PROC1 [] Procedure PROC2 [] Process :debug2:p1 Warning: 0ms+0: proc2 Procedure PROC2 [] Process :debug2:p1 Warning: 1ns+0: proc3 Procedure PROC3 [] Process :debug2:b1:p2 Warning: 1ns+0: proc4 Procedure PROC4 [] Process :debug2:b1:p2 Warning: 1ns+0: proc1 Procedure PROC1 [] Process :debug2:b1:p2 Warning: 1ns+0: p2 Warning: 2ns+0: p3 Warning: 3ns+0: p4 nvc-r1.17.1/test/regress/gold/debug3.txt000066400000000000000000000001221504111170000200220ustar00rootroot00000000000000write to closed file Procedure FILE_PROC [] Procedure PROC [] Process :debug3:_p0 nvc-r1.17.1/test/regress/gold/debug4.txt000066400000000000000000000004121504111170000200250ustar00rootroot00000000000000(init): warning Function FUNC2 [BIT_VECTOR return BIT_VECTOR] at Function FUNC1 [BIT_VECTOR return BIT_VECTOR] at Port conversion at (init): warning Function FUNC2 [BIT_VECTOR return BIT_VECTOR] at Function FUNC1 [BIT_VECTOR return BIT_VECTOR] at Port conversion at nvc-r1.17.1/test/regress/gold/delay3.txt000066400000000000000000000001011504111170000200270ustar00rootroot000000000000000ms+0: signal X pulse reject limit 5ns is greater than delay 2ns nvc-r1.17.1/test/regress/gold/driver15.txt000066400000000000000000000001001504111170000203060ustar00rootroot00000000000000(init): result is '0' 0ms+1: result is '0' 1ns+1: result is '1' nvc-r1.17.1/test/regress/gold/driver21.txt000066400000000000000000000000341504111170000203110ustar00rootroot000000000000001ns+0: Assertion violation. nvc-r1.17.1/test/regress/gold/driver22.txt000066400000000000000000000003001504111170000203060ustar00rootroot00000000000000(init): element F of signal P has multiple sources element F declared here connected to signal S composite signal P declared with unresolved type T_REC_ARRAY driven by process :driver22:b:_p0 nvc-r1.17.1/test/regress/gold/driver7.txt000066400000000000000000000000641504111170000202400ustar00rootroot00000000000000process :driver7:p2 does not contain a driver for X nvc-r1.17.1/test/regress/gold/driver9.txt000066400000000000000000000000511504111170000202360ustar00rootroot00000000000000unresolved signal X has multiple sources nvc-r1.17.1/test/regress/gold/elab10.txt000066400000000000000000000001211504111170000177140ustar00rootroot000000000000000ms+0: :elab10:sub1_i:a range is 1 to 5 1ns+0: :elab10:sub2_i:a range is 6 to 10 nvc-r1.17.1/test/regress/gold/elab13.txt000066400000000000000000000011101504111170000177160ustar00rootroot000000000000000ms+1: :elab13:top_i:recur_g:recur1_i:recur_g:recur1_i:recur_g:recur1_i: 1ns+0: :elab13:top_i:recur_g:recur1_i:recur_g:recur1_i:recur_g:recur2_i: 2ns+0: :elab13:top_i:recur_g:recur1_i:recur_g:recur2_i:recur_g:recur1_i: 3ns+0: :elab13:top_i:recur_g:recur1_i:recur_g:recur2_i:recur_g:recur2_i: 4ns+0: :elab13:top_i:recur_g:recur2_i:recur_g:recur1_i:recur_g:recur1_i: 5ns+0: :elab13:top_i:recur_g:recur2_i:recur_g:recur1_i:recur_g:recur2_i: 6ns+0: :elab13:top_i:recur_g:recur2_i:recur_g:recur2_i:recur_g:recur1_i: 7ns+0: :elab13:top_i:recur_g:recur2_i:recur_g:recur2_i:recur_g:recur2_i: nvc-r1.17.1/test/regress/gold/elab3.txt000066400000000000000000000002041504111170000176400ustar00rootroot000000000000000ms+0: :elab3(test):x 0ms+0: :elab3:x 1ns+0: :elab3(test):b:y 1ns+0: :elab3:b:y 2ns+0: :elab3(test):s@sub(test):p 2ns+0: :elab3:s:p nvc-r1.17.1/test/regress/gold/elab9.txt000066400000000000000000000003041504111170000176470ustar00rootroot000000000000000ms+0: :elab9:sub_i: 0ms+0: :elab9(test):sub_i@sub_ent(test): 0ms+0: :elab9:sub_i: 0ms+0: :elab9(test):sub_i@sub_ent(test): 1ns+0: :elab9: 1ns+0: :elab9(test): 1ns+0: :elab9: 1ns+0: :elab9(test): nvc-r1.17.1/test/regress/gold/ename10.txt000066400000000000000000000001501504111170000201000ustar00rootroot000000000000000ms+0: class of object X is not variable ^ declaration of X as signal external name with class variable nvc-r1.17.1/test/regress/gold/ename11.txt000066400000000000000000000001031504111170000200770ustar00rootroot000000000000000ms+0: external name X not found name BOT not found inside ENAME11 nvc-r1.17.1/test/regress/gold/ename12.txt000066400000000000000000000000771504111170000201120ustar00rootroot000000000000000ms+0: FOO is not the name of the root of the design hierarchy nvc-r1.17.1/test/regress/gold/ename13.txt000066400000000000000000000001451504111170000201070ustar00rootroot000000000000000ms+0: class of object UUT is not signal declaration of UUT as label external name with class signal nvc-r1.17.1/test/regress/gold/ename14.txt000066400000000000000000000001061504111170000201050ustar00rootroot000000000000000ms+0: X is not a concurrent region location of X error occurred here nvc-r1.17.1/test/regress/gold/ename16.txt000066400000000000000000000000501504111170000201050ustar00rootroot000000000000003ns+0: WORK.MY_PKGXXXX is not a package nvc-r1.17.1/test/regress/gold/ename17.txt000066400000000000000000000000761504111170000201160ustar00rootroot000000000000000ms+0: relative pathname has no containing declarative region nvc-r1.17.1/test/regress/gold/ename2.txt000066400000000000000000000001001504111170000200140ustar00rootroot00000000000000(init): external name Z not found ^ name Z not found inside UUT nvc-r1.17.1/test/regress/gold/ename5.txt000066400000000000000000000001231504111170000200240ustar00rootroot000000000000001ns+0: object C1 length 5 does not match external name subtype indication length 6 nvc-r1.17.1/test/regress/gold/ename9.txt000066400000000000000000000001451504111170000200340ustar00rootroot00000000000000(init): type of signal X is not BIT ^ declaration of X with type NATURAL external name with type BIT nvc-r1.17.1/test/regress/gold/fact.txt000066400000000000000000000004341504111170000175740ustar00rootroot000000000000000ms+1: 1 0ms+3: 2 0ms+5: 6 0ms+7: 24 0ms+9: 120 0ms+11: 720 0ms+13: 5040 0ms+15: 40320 0ms+17: 362880 0ms+19: 3628800 0ms+21: 39916800 0ms+23: 479001600 result of 479001600 * 13 cannot be represented as INTEGER | 15 | tmp := tmp * i; | ^^^^^^^ nvc-r1.17.1/test/regress/gold/file13.txt000066400000000000000000000000341504111170000177360ustar00rootroot000000000000000ms+0: write to file failed nvc-r1.17.1/test/regress/gold/file14.txt000066400000000000000000000000351504111170000177400ustar00rootroot000000000000000ms+0: read from file failed nvc-r1.17.1/test/regress/gold/file8.txt000066400000000000000000000000351504111170000176630ustar00rootroot00000000000000failed to open NOT_HERE.txt: nvc-r1.17.1/test/regress/gold/for1.txt000066400000000000000000000001521504111170000175230ustar00rootroot000000000000000ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: 5 0ms+0: 100 0ms+0: 99 0ms+0: 98 0ms+0: 97 0ms+0: 96 0ms+0: 95 nvc-r1.17.1/test/regress/gold/for2.txt000066400000000000000000000001331504111170000175230ustar00rootroot000000000000000ms+0: -1 0ms+0: 0 0ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 0ms+0: a 0ms+0: b 0ms+0: c 0ms+0: d nvc-r1.17.1/test/regress/gold/for3.txt000066400000000000000000000113001504111170000175220ustar00rootroot00000000000000Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 0 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 1 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 2 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 3 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 4 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 5 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 6 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 7 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 8 Note: 0ms+0: inner loop i = 7 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 0 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 1 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 2 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 3 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 4 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 5 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 6 Note: 0ms+0: outer loop i = 9 Note: 0ms+0: inner loop i = 7 nvc-r1.17.1/test/regress/gold/force3.txt000066400000000000000000000000671504111170000200420ustar00rootroot000000000000000ms+1: value length 9 does not match signal S length 3 nvc-r1.17.1/test/regress/gold/func19.txt000066400000000000000000000003201504111170000177560ustar00rootroot00000000000000function MAYBE_NOT_RETURN did not return a value | 6 | function maybe_not_return (x : integer) return integer is | ^ Function MAYBE_NOT_RETURN [INTEGER return INTEGER] Process :func19:p1 nvc-r1.17.1/test/regress/gold/ieee11.txt000066400000000000000000000003061504111170000177260ustar00rootroot000000000000000ms+0: NUMERIC_STD.TO_01: null detected, returning NAU 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated nvc-r1.17.1/test/regress/gold/ieee12.txt000066400000000000000000000043321504111170000177320ustar00rootroot000000000000000ms+0: Assertion Note: start of tests 0ms+0: Assertion Note: A.15 test done 0ms+0: Assertion Note: A.16 test done 0ms+0: Assertion Note: A.17, A.18 tests done 0ms+0: Assertion Note: A.19, A.20 tests done 0ms+0: Assertion Note: A.21, A.23, A.24 tests done 0ms+0: Assertion Note: A.22, A.25, A.26 tests done 0ms+0: Assertion Note: A.27, A.29, A.30 tests done 0ms+0: Assertion Note: A.28, A.31, A.32 tests done 0ms+0: Assertion Note: A.33, A.35, A.36 tests done 0ms+0: Assertion Note: A.34, A.37, A.38 tests done 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.13 tests done 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.14 tests done 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.17 tests done 0ms+0: Assertion Note: C.18 tests done 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.15 tests done 0ms+0: Assertion Warning: NUMERIC_STD."<=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.16 tests done 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.19 tests done 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.20 tests done 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.21 tests done 0ms+0: Assertion Note: C.22 tests done 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.23 tests done 0ms+0: Assertion Warning: NUMERIC_STD.">=": null argument detected, returning FALSE 0ms+0: Assertion Note: C.24 tests done 0ms+0: Assertion Note: R.1 tests done 0ms+0: Assertion Note: R.2 tests done 0ms+0: Assertion Note: END OF TESTS nvc-r1.17.1/test/regress/gold/ieee13.txt000066400000000000000000000041571504111170000177400ustar00rootroot000000000000000ms+0: A.3 tests done 0ms+0: A.4 tests done 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: A.5 tests done 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: A.6 tests done 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: A.7 tests done 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: A.8 tests done 0ms+0: A.9 tests done 0ms+0: A.10 tests done 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: A.11 tests done 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_UNSIGNED: vector truncated 0ms+0: A.12 tests done 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: A.13 tests done 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: NUMERIC_STD.TO_SIGNED: vector truncated 0ms+0: A.14 tests done 0ms+0: END OF test suite tb4 nvc-r1.17.1/test/regress/gold/ieee14.txt000066400000000000000000000030201504111170000177250ustar00rootroot000000000000000ms+0: NUMERIC_STD."=": null argument detected, returning FALSE 0ms+0: NUMERIC_STD."=": metavalue detected, returning FALSE 0ms+0: C.29 tests done 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: C.1 tests done 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: C.2 tests done 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: C.3 tests done 0ms+0: C.4 tests done 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: C.5 tests done 0ms+0: NUMERIC_STD.">": null argument detected, returning FALSE 0ms+0: C.6 tests done 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: C.7 tests done 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: C.8 tests done 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: C.11 tests done 0ms+0: C.12 tests done 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: C.9 tests done 0ms+0: NUMERIC_STD."<": null argument detected, returning FALSE 0ms+0: C.10 tests done 0ms+0: NUMERIC_STD."=": null argument detected, returning FALSE 0ms+0: NUMERIC_STD."=": metavalue detected, returning FALSE 0ms+0: NUMERIC_STD."=": null argument detected, returning FALSE 0ms+0: NUMERIC_STD."=": metavalue detected, returning FALSE 0ms+0: c.28, c.30 tests done 0ms+0: END OF test suite tb3 nvc-r1.17.1/test/regress/gold/ieee15.txt000066400000000000000000000001371504111170000177340ustar00rootroot000000000000000ms+0: STD_LOGIC_1164."and": arguments of overloaded 'and' operator are not of the same length nvc-r1.17.1/test/regress/gold/ieee18.txt000066400000000000000000000000641504111170000177360ustar00rootroot000000000000002ns+0: NUMERIC_STD.DIVMOD: DIV, MOD, or REM by zero nvc-r1.17.1/test/regress/gold/ieee9.txt000066400000000000000000000001231504111170000176520ustar00rootroot000000000000000ms+0: -9.96484375 0ms+0: -2551 0ms+0: -9.96484375 0ms+0: -2551 0ms+0: -9.96484375 nvc-r1.17.1/test/regress/gold/image1.txt000066400000000000000000000003371504111170000200240ustar00rootroot000000000000000ms+0: 4 0ms+0: -42 0ms+0: 73 0ms+0: i=73 units 0ms+0: 'c' 0ms+0: 'X' 10ps+0: 10000 fs 1010ps+0: a 1010ps+0: c 1010ps+0: a 1010ps+0: 3 1010ps+0: 20 unit_1 1010ps+0: 0 1010ps+0: 10 1010ps+0: -2147483648 1010ps+0: 2147483647 nvc-r1.17.1/test/regress/gold/issue101.txt000066400000000000000000000004031504111170000202250ustar00rootroot000000000000000ms+54: RESULT = 536870912 0ms+55: RESULT = 805306368 0ms+56: RESULT = 1073741824 result of 1610612736 + 536870912 cannot be represented as INTEGER | 16 | RESULT <= signal1 + signal2 + signal3; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ nvc-r1.17.1/test/regress/gold/issue103.txt000066400000000000000000000000201504111170000202220ustar00rootroot00000000000000 >> test nvc-r1.17.1/test/regress/gold/issue1030.dump000066400000000000000000000005501504111170000204400ustar00rootroot00000000000000$comment issue1030.b.p[7:0] is aliased to z[1:8] $end #0 issue1030.s[2].f.z[1:8] 00000000 #0 issue1030.s[2].f.y[7:0] 00000000 #0 issue1030.s[2].f.x 0 #0 issue1030.s[1].f.z[1:8] 00000000 #0 issue1030.s[1].f.y[7:0] 00000000 #0 issue1030.s[1].f.x 0 #1000000 issue1030.s[1].f.x 1 #1000000 issue1030.s[1].f.y[7:0] 00000001 #1000000 issue1030.s[1].f.z[1:8] 00000010 nvc-r1.17.1/test/regress/gold/issue1060.txt000066400000000000000000000000301504111170000203060ustar00rootroot000000000000005ns+0: this is an error nvc-r1.17.1/test/regress/gold/issue1071.dump000066400000000000000000000004501504111170000204440ustar00rootroot00000000000000#0 issue1071.e[0][1][7:0] 00000000 #0 issue1071.e[0][0][7:0] 00000000 #0 issue1071.c[1][7:0] 00000000 #0 issue1071.c[0][7:0] 00000000 #10000000 issue1071.c[0][7:0] 00000010 #10000000 issue1071.c[1][7:0] 00000001 #10000000 issue1071.e[0][0][7:0] 00000010 #10000000 issue1071.e[0][1][7:0] 00000001 nvc-r1.17.1/test/regress/gold/issue1079.txt000066400000000000000000000001201504111170000203200ustar00rootroot00000000000000::hello world 1 ::hello world 2 ::hello world 3 ::hello world 4 ::hello world 5 nvc-r1.17.1/test/regress/gold/issue110.txt000066400000000000000000000000041504111170000202220ustar00rootroot000000000000004 5 nvc-r1.17.1/test/regress/gold/issue1231.txt000066400000000000000000000001001504111170000203040ustar00rootroot000000000000000ms+0: range direction of slice DOWNTO does not match prefix TO nvc-r1.17.1/test/regress/gold/issue185.txt000066400000000000000000000004571504111170000202520ustar00rootroot000000000000000ms+0: record parameter does not work 0ms+0: 0 0ms+1: 0 0ms+1: 1 0ms+2: 1 0ms+2: integer parameter works 0ms+2: 0 0ms+3: 0 0ms+3: 1 0ms+4: 1 0ms+4: string parameter works 0ms+4: hello 0ms+5: hello 0ms+5: foobar 0ms+6: foobar 0ms+6: bit_vector parameter works 0ms+6: '0' 0ms+7: '0' 0ms+7: '1' 0ms+8: '1' nvc-r1.17.1/test/regress/gold/issue202.txt000066400000000000000000000001461504111170000202330ustar00rootroot000000000000000ms+0: Report Note: 'U' 0ms+0: Report Note: 'U''U' 0ms+1: Report Note: 'X' 0ms+1: Report Note: 'X''0' nvc-r1.17.1/test/regress/gold/issue225.txt000066400000000000000000000000031504111170000202300ustar00rootroot00000000000000ok nvc-r1.17.1/test/regress/gold/issue227.txt000066400000000000000000000000441504111170000202370ustar00rootroot0000000000000011 21 12 21 11 21 12 21 11 21 12 21 nvc-r1.17.1/test/regress/gold/issue228.txt000066400000000000000000000002121504111170000202350ustar00rootroot00000000000000value 10 outside of INTEGER range 0 to 3 for generic G issue228.vhd | 2 | generic (G : integer range 0 to 3); | ^ nvc-r1.17.1/test/regress/gold/issue234.txt000066400000000000000000000000241504111170000202330ustar00rootroot000000000000000ms+0: ok 0ms+0: ok nvc-r1.17.1/test/regress/gold/issue308.txt000066400000000000000000000003071504111170000202410ustar00rootroot00000000000000 0 ns Simulation Start. 100 ns Simulation Phase 1. 200 ns Simulation Phase 2. 2147 ns Simulation Phase 3. 2148 ns Simulation Phase 4. 2149 ns Simulation Done. nvc-r1.17.1/test/regress/gold/issue351.txt000066400000000000000000000005611504111170000202410ustar00rootroot000000000000000 to 3 | 0 | 0 | 0 | 1 | 1 | 1 | 2 | 2 | 2 | 3 | 3 | 3 1 to 3 | 1 | 1 | 1 | 2 | 2 | 2 | 3 | 3 | 3 2 to 3 | 2 | 2 | 2 | 3 | 3 | 3 3 to 3 | 3 | 3 | 3 nvc-r1.17.1/test/regress/gold/issue377.txt000066400000000000000000000000661504111170000202510ustar00rootroot000000000000000ms+0: There is an 'U'|'X' 1ns+1: There is an 'U'|'X' nvc-r1.17.1/test/regress/gold/issue433.txt000066400000000000000000000000561504111170000202410ustar00rootroot000000000000001ns+0: TEST_NG:U1():OK 2ns+0: TEST_NG:U2():OK nvc-r1.17.1/test/regress/gold/issue45.txt000066400000000000000000000000561504111170000201600ustar00rootroot000000000000000ms+0: :issue45(a):b:p: 0ms+0: :issue45(a):b: nvc-r1.17.1/test/regress/gold/issue454.dump000066400000000000000000000002311504111170000203650ustar00rootroot00000000000000#0 issue454.r.y 10000000000000000000000000000000 #0 issue454.r.x 00000000000000000000000000000101 #1000000 issue454.r.y 00000000000000000000000000101010 nvc-r1.17.1/test/regress/gold/issue469.txt000066400000000000000000000000311504111170000202430ustar00rootroot00000000000000va1 is false va1 is true nvc-r1.17.1/test/regress/gold/issue494.txt000066400000000000000000000000351504111170000202450ustar00rootroot00000000000000empty file name in FILE_OPEN nvc-r1.17.1/test/regress/gold/issue521.txt000066400000000000000000000002551504111170000202400ustar00rootroot00000000000000limit of 10000 delta cycles reached driver for signal I is active driver for signal J is active process :issue521:p1 is active you can increase this limit with --stop-delta nvc-r1.17.1/test/regress/gold/issue524.dump000066400000000000000000000001561504111170000203710ustar00rootroot00000000000000#0 issue524.s 0.5 #1000000 issue524.s 1 #2000000 issue524.s 1.5 #3000000 issue524.s 2 #4000000 issue524.s 2.5 nvc-r1.17.1/test/regress/gold/issue536.dump000066400000000000000000000166221504111170000204010ustar00rootroot00000000000000#0 issue536.ttx_data[127] 00000000000000000000000000000000 #0 issue536.ttx_data[126] 00000000000000000000000000000000 #0 issue536.ttx_data[125] 00000000000000000000000000000000 #0 issue536.ttx_data[124] 00000000000000000000000000000000 #0 issue536.ttx_data[123] 00000000000000000000000000000000 #0 issue536.ttx_data[122] 00000000000000000000000000000000 #0 issue536.ttx_data[121] 00000000000000000000000000000000 #0 issue536.ttx_data[120] 00000000000000000000000000000000 #0 issue536.ttx_data[119] 00000000000000000000000000000000 #0 issue536.ttx_data[118] 00000000000000000000000000000000 #0 issue536.ttx_data[117] 00000000000000000000000000000000 #0 issue536.ttx_data[116] 00000000000000000000000000000000 #0 issue536.ttx_data[115] 00000000000000000000000000000000 #0 issue536.ttx_data[114] 00000000000000000000000000000000 #0 issue536.ttx_data[113] 00000000000000000000000000000000 #0 issue536.ttx_data[112] 00000000000000000000000000000000 #0 issue536.ttx_data[111] 00000000000000000000000000000000 #0 issue536.ttx_data[110] 00000000000000000000000000000000 #0 issue536.ttx_data[109] 00000000000000000000000000000000 #0 issue536.ttx_data[108] 00000000000000000000000000000000 #0 issue536.ttx_data[107] 00000000000000000000000000000000 #0 issue536.ttx_data[106] 00000000000000000000000000000000 #0 issue536.ttx_data[105] 00000000000000000000000000000000 #0 issue536.ttx_data[104] 00000000000000000000000000000000 #0 issue536.ttx_data[103] 00000000000000000000000000000000 #0 issue536.ttx_data[102] 00000000000000000000000000000000 #0 issue536.ttx_data[101] 00000000000000000000000000000000 #0 issue536.ttx_data[100] 00000000000000000000000000000000 #0 issue536.ttx_data[99] 00000000000000000000000000000000 #0 issue536.ttx_data[98] 00000000000000000000000000000000 #0 issue536.ttx_data[97] 00000000000000000000000000000000 #0 issue536.ttx_data[96] 00000000000000000000000000000000 #0 issue536.ttx_data[95] 00000000000000000000000000000000 #0 issue536.ttx_data[94] 00000000000000000000000000000000 #0 issue536.ttx_data[93] 00000000000000000000000000000000 #0 issue536.ttx_data[92] 00000000000000000000000000000000 #0 issue536.ttx_data[91] 00000000000000000000000000000000 #0 issue536.ttx_data[90] 00000000000000000000000000000000 #0 issue536.ttx_data[89] 00000000000000000000000000000000 #0 issue536.ttx_data[88] 00000000000000000000000000000000 #0 issue536.ttx_data[87] 00000000000000000000000000000000 #0 issue536.ttx_data[86] 00000000000000000000000000000000 #0 issue536.ttx_data[85] 00000000000000000000000000000000 #0 issue536.ttx_data[84] 00000000000000000000000000000000 #0 issue536.ttx_data[83] 00000000000000000000000000000000 #0 issue536.ttx_data[82] 00000000000000000000000000000000 #0 issue536.ttx_data[81] 00000000000000000000000000000000 #0 issue536.ttx_data[80] 00000000000000000000000000000000 #0 issue536.ttx_data[79] 00000000000000000000000000000000 #0 issue536.ttx_data[78] 00000000000000000000000000000000 #0 issue536.ttx_data[77] 00000000000000000000000000000000 #0 issue536.ttx_data[76] 00000000000000000000000000000000 #0 issue536.ttx_data[75] 00000000000000000000000000000000 #0 issue536.ttx_data[74] 00000000000000000000000000000000 #0 issue536.ttx_data[73] 00000000000000000000000000000000 #0 issue536.ttx_data[72] 00000000000000000000000000000000 #0 issue536.ttx_data[71] 00000000000000000000000000000000 #0 issue536.ttx_data[70] 00000000000000000000000000000000 #0 issue536.ttx_data[69] 00000000000000000000000000000000 #0 issue536.ttx_data[68] 00000000000000000000000000000000 #0 issue536.ttx_data[67] 00000000000000000000000000000000 #0 issue536.ttx_data[66] 00000000000000000000000000000000 #0 issue536.ttx_data[65] 00000000000000000000000000000000 #0 issue536.ttx_data[64] 00000000000000000000000000000000 #0 issue536.ttx_data[63] 00000000000000000000000000000000 #0 issue536.ttx_data[62] 00000000000000000000000000000000 #0 issue536.ttx_data[61] 00000000000000000000000000000000 #0 issue536.ttx_data[60] 00000000000000000000000000000000 #0 issue536.ttx_data[59] 00000000000000000000000000000000 #0 issue536.ttx_data[58] 00000000000000000000000000000000 #0 issue536.ttx_data[57] 00000000000000000000000000000000 #0 issue536.ttx_data[56] 00000000000000000000000000000000 #0 issue536.ttx_data[55] 00000000000000000000000000000000 #0 issue536.ttx_data[54] 00000000000000000000000000000000 #0 issue536.ttx_data[53] 00000000000000000000000000000000 #0 issue536.ttx_data[52] 00000000000000000000000000000000 #0 issue536.ttx_data[51] 00000000000000000000000000000000 #0 issue536.ttx_data[50] 00000000000000000000000000000000 #0 issue536.ttx_data[49] 00000000000000000000000000000000 #0 issue536.ttx_data[48] 00000000000000000000000000000000 #0 issue536.ttx_data[47] 00000000000000000000000000000000 #0 issue536.ttx_data[46] 00000000000000000000000000000000 #0 issue536.ttx_data[45] 00000000000000000000000000000000 #0 issue536.ttx_data[44] 00000000000000000000000000000000 #0 issue536.ttx_data[43] 00000000000000000000000000000000 #0 issue536.ttx_data[42] 00000000000000000000000000000000 #0 issue536.ttx_data[41] 00000000000000000000000000000000 #0 issue536.ttx_data[40] 00000000000000000000000000000000 #0 issue536.ttx_data[39] 00000000000000000000000000000000 #0 issue536.ttx_data[38] 00000000000000000000000000000000 #0 issue536.ttx_data[37] 00000000000000000000000000000000 #0 issue536.ttx_data[36] 00000000000000000000000000000000 #0 issue536.ttx_data[35] 00000000000000000000000000000000 #0 issue536.ttx_data[34] 00000000000000000000000000000000 #0 issue536.ttx_data[33] 00000000000000000000000000000000 #0 issue536.ttx_data[32] 00000000000000000000000000000000 #0 issue536.ttx_data[31] 00000000000000000000000000000000 #0 issue536.ttx_data[30] 00000000000000000000000000000000 #0 issue536.ttx_data[29] 00000000000000000000000000000000 #0 issue536.ttx_data[28] 00000000000000000000000000000000 #0 issue536.ttx_data[27] 00000000000000000000000000000000 #0 issue536.ttx_data[26] 00000000000000000000000000000000 #0 issue536.ttx_data[25] 00000000000000000000000000000000 #0 issue536.ttx_data[24] 00000000000000000000000000000000 #0 issue536.ttx_data[23] 00000000000000000000000000000000 #0 issue536.ttx_data[22] 00000000000000000000000000000000 #0 issue536.ttx_data[21] 00000000000000000000000000000000 #0 issue536.ttx_data[20] 00000000000000000000000000000000 #0 issue536.ttx_data[19] 00000000000000000000000000000000 #0 issue536.ttx_data[18] 00000000000000000000000000000000 #0 issue536.ttx_data[17] 00000000000000000000000000000000 #0 issue536.ttx_data[16] 00000000000000000000000000000000 #0 issue536.ttx_data[15] 00000000000000000000000000000000 #0 issue536.ttx_data[14] 00000000000000000000000000000000 #0 issue536.ttx_data[13] 00000000000000000000000000000000 #0 issue536.ttx_data[12] 00000000000000000000000000000000 #0 issue536.ttx_data[11] 00000000000000000000000000000000 #0 issue536.ttx_data[10] 00000000000000000000000000000000 #0 issue536.ttx_data[9] 00000000000000000000000000000000 #0 issue536.ttx_data[8] 00000000000000000000000000000000 #0 issue536.ttx_data[7] 00000000000000000000000000000000 #0 issue536.ttx_data[6] 00000000000000000000000000000000 #0 issue536.ttx_data[5] 00000000000000000000000000000000 #0 issue536.ttx_data[4] 00000000000000000000000000000000 #0 issue536.ttx_data[3] 00000000000000000000000000000000 #0 issue536.ttx_data[2] 00000000000000000000000000000000 #0 issue536.ttx_data[1] 00000000000000000000000000000000 #0 issue536.ttx_data[0] 00000000000000000000000000000000 #1000000 issue536.ttx_data[5] 00000000000000000000000000000010 #6000000 issue536.ttx_data[100] 00000000000000000000000000110111 nvc-r1.17.1/test/regress/gold/issue586.dump000066400000000000000000000002651504111170000204020ustar00rootroot00000000000000#0 issue586.u2.r.x[1:5] 00000 #0 issue586.u1.r.x[1:3] 000 #0 issue586.r.r.x[1:5] 00000 #0 issue586.s[1:3] 000 #1000000 issue586.r.r.x[1:5] 00100 #1000000 issue586.u2.r.x[1:5] 00100 nvc-r1.17.1/test/regress/gold/issue592.txt000066400000000000000000000001171504111170000202450ustar00rootroot000000000000002ns+0: value -2048 outside of NATURAL range 0 to 2147483647 for variable ZERO1 nvc-r1.17.1/test/regress/gold/issue597.txt000066400000000000000000000007031504111170000202530ustar00rootroot00000000000000(init): signal S1 has 2 sources including port O1 which has initial value 'U' and no driver in instance U (init): sub-element of signal S4 has 2 sources including port O4 which has initial value 'U' and no driver in instance U (init): signal S2.Y has 2 sources including port O2.Y which has initial value 'U' and no driver in instance U (init): signal S2.R.X has 2 sources including port O2.R.X which has initial value 'U' and no driver in instance U nvc-r1.17.1/test/regress/gold/issue615.txt000066400000000000000000000007061504111170000202450ustar00rootroot00000000000000(32768,0) (32138,6393) (30274,12540) (27246,18205) (23170,23170) (18205,27246) (12540,30274) (6393,32138) (0,32768) (-6393,32138) (-12540,30274) (-18205,27246) (-23170,23170) (-27246,18205) (-30274,12540) (-32138,6393) (-32768,0) (-32138,-6393) (-30274,-12540) (-27246,-18205) (-23170,-23170) (-18205,-27246) (-12540,-30274) (-6393,-32138) (0,-32768) (6393,-32138) (12540,-30274) (18205,-27246) (23170,-23170) (27246,-18205) (30274,-12540) (32138,-6393) nvc-r1.17.1/test/regress/gold/issue616.txt000066400000000000000000000000601504111170000202370ustar00rootroot00000000000000value length 17 does not match target length 16 nvc-r1.17.1/test/regress/gold/issue617.txt000066400000000000000000000000721504111170000202430ustar00rootroot000000000000000ms+1: index -32 outside of INTEGER range 0 to 2147483647 nvc-r1.17.1/test/regress/gold/issue668.txt000066400000000000000000000000551504111170000202520ustar00rootroot000000000000000ms+1: 0 ==> 0 1ns+0: 1 ==> 1 2ns+0: 2 ==> 1 nvc-r1.17.1/test/regress/gold/issue700.txt000066400000000000000000000000261504111170000202330ustar00rootroot00000000000000â€â€Hiââ¡ Hi nvc-r1.17.1/test/regress/gold/issue701.txt000066400000000000000000000000601504111170000202320ustar00rootroot000000000000000ms+1: index 10 outside of NATURAL range 0 to 9 nvc-r1.17.1/test/regress/gold/issue703.dump000066400000000000000000000007041504111170000203670ustar00rootroot00000000000000#0 issue703.u.r.f 0 #0 issue703.u.r.p.y 10000000000000000000000000000000 #0 issue703.u.r.p.x 10000000000000000000000000000000 #0 issue703.s 1 #1000000 issue703.u.r.p.x 00000000000000000000000000000001 #1000000 issue703.u.r.p.y 00000000000000000000000000000010 #1000000 issue703.u.r.f 1 #2000000 issue703.s 0 #5000000 issue703.u.r.f 0 #5000000 issue703.u.r.p.y 00000000000000000000000000110111 #5000000 issue703.u.r.p.x 00000000000000000000000000000101 nvc-r1.17.1/test/regress/gold/issue703.gtkw000066400000000000000000000001701504111170000203730ustar00rootroot00000000000000-/ [color] 4 issue703.s -/u/ -r: -r.p: [color] 5 issue703.u.r.p.x [color] 5 issue703.u.r.p.y - [color] 5 issue703.u.r.f nvc-r1.17.1/test/regress/gold/issue704.dump000066400000000000000000000024201504111170000203650ustar00rootroot00000000000000#0 issue704.u.o.y 00000000000000000000000000000000 #0 issue704.u.o.x 00000000000000000000000000000000 #0 issue704.u.i.y 00000000000000000000000000000000 #0 issue704.u.i.x 00000000000000000000000000000000 #0 issue704.y.y 00000000000000000000000000000000 #0 issue704.y.x 00000000000000000000000000000000 #0 issue704.x.y 00000000000000000000000000000000 #0 issue704.x.x 00000000000000000000000000000000 #1000000 issue704.x.x 00000000000000000000000000000001 #1000000 issue704.x.y 00000000000000000000000000000010 #1000000 issue704.u.i.x 00000000000000000000000000000001 #1000000 issue704.u.i.y 00000000000000000000000000000010 #2000000 issue704.u.i.y 00000000000000000000000000000110 #2000000 issue704.u.i.x 00000000000000000000000000000101 #2000000 issue704.x.y 00000000000000000000000000000110 #2000000 issue704.x.x 00000000000000000000000000000101 #2000000 issue704.y.x 00000000000000000000000000000001 #2000000 issue704.y.y 00000000000000000000000000000010 #2000000 issue704.u.o.x 00000000000000000000000000000001 #2000000 issue704.u.o.y 00000000000000000000000000000010 #3000000 issue704.u.o.y 00000000000000000000000000000110 #3000000 issue704.u.o.x 00000000000000000000000000000101 #3000000 issue704.y.y 00000000000000000000000000000110 #3000000 issue704.y.x 00000000000000000000000000000101 nvc-r1.17.1/test/regress/gold/issue718.txt000066400000000000000000000002521504111170000202450ustar00rootroot00000000000000this is line 1 this is line 2 this is line 3 this is line 4 this is line 5 this is line 6 this is line 7 this is line 8 this is line 9 this is line 10 0ms+0: STOP called nvc-r1.17.1/test/regress/gold/issue730.txt000066400000000000000000000000511504111170000202340ustar00rootroot0000000000000015ns+0: Report Note: :issue730:test_mod: nvc-r1.17.1/test/regress/gold/issue734.txt000066400000000000000000000000631504111170000202430ustar00rootroot000000000000001ns+0: index 0 outside of INTEGER range 0 downto 1 nvc-r1.17.1/test/regress/gold/issue747.txt000066400000000000000000000000651504111170000202510ustar00rootroot00000000000000(init): index 10 outside of NATURAL range 9 downto 0 nvc-r1.17.1/test/regress/gold/issue801.txt000066400000000000000000000003001504111170000202300ustar00rootroot00000000000000clk: 0, foo: 00 clk: 1, foo: 00 clk: 0, foo: AB clk: 1, foo: AB clk: 0, foo: AB clk: 1, foo: AB clk: 0, foo: BC clk: 1, foo: BC clk: 0, foo: BC clk: 1, foo: BC clk: 0, foo: BC clk: 1, foo: BC nvc-r1.17.1/test/regress/gold/issue808.txt000066400000000000000000000000061504111170000202420ustar00rootroot000000000000000 1 0 nvc-r1.17.1/test/regress/gold/issue816.txt000066400000000000000000000000161504111170000202420ustar00rootroot000000000000002ns+0: passed nvc-r1.17.1/test/regress/gold/issue817.txt000066400000000000000000000000651504111170000202470ustar00rootroot000000000000000ms+0: value length 7 does not match target length 8 nvc-r1.17.1/test/regress/gold/issue840.dump000066400000000000000000000001441504111170000203670ustar00rootroot00000000000000#0 issue840.t 00000000000000000000000000000001 #1000000 issue840.t 00000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/issue851.dump000066400000000000000000000004361504111170000203750ustar00rootroot00000000000000#0 issue851.b.t[1:3] 000 #0 issue851.b.p[1:3] 101 #0 issue851.s[1:3] 101 #1000000 issue851.s[1:3] 111 #1000000 issue851.b.p[1:3] 111 #1000000 issue851.b.t[1:3] 101 #2000000 issue851.b.t[1:3] 111 #2000000 issue851.b.p[1:3] 001 #2000000 issue851.s[1:3] 001 #3000000 issue851.b.t[1:3] 001 nvc-r1.17.1/test/regress/gold/issue852.dump000066400000000000000000000015651504111170000204020ustar00rootroot00000000000000#0 issue852.mc.write_count 0000000000000000000000000000000000000000000000000000000000000000 #0 issue852.mc.read_count 0000000000000000000000000000000000000000000000000000000000000000 #0 issue852.mc.memory[7][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[6][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[5][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[4][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[3][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[2][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[1][31:0] 00000000000000000000000000000000 #0 issue852.mc.memory[0][31:0] 00000000000000000000000000000000 #0 issue852.mc.prefix[1:21] apb: mock completer: #2000000 issue852.mc.memory[4][31:0] 11011110101011011011111011101111 #5000000 issue852.mc.memory[7][31:0] 11001010111111101011101010111110 nvc-r1.17.1/test/regress/gold/issue856.dump000066400000000000000000000023151504111170000204000ustar00rootroot00000000000000#0 issue856.b.p[1].g 0000000000000000000000000000000000000000000000000000000000011011 #0 issue856.b.p[1].f[3].y 0000000000000000000000000000000000000000000000000000000000000111 #0 issue856.b.p[1].f[3].x 0000000000000000000000000000000000000000000000000000000000000110 #0 issue856.b.p[1].f[2].y 0000000000000000000000000000000000000000000000000000000000000101 #0 issue856.b.p[1].f[2].x 0000000000000000000000000000000000000000000000000000000000000100 #0 issue856.b.p[1].f[1].y 0000000000000000000000000000000000000000000000000000000000000011 #0 issue856.b.p[1].f[1].x 0000000000000000000000000000000000000000000000000000000000000010 #0 issue856.s.g 0000000000000000000000000000000000000000000000000000000000011011 #0 issue856.s.f[3].y 0000000000000000000000000000000000000000000000000000000000000111 #0 issue856.s.f[3].x 0000000000000000000000000000000000000000000000000000000000000110 #0 issue856.s.f[2].y 0000000000000000000000000000000000000000000000000000000000000101 #0 issue856.s.f[2].x 0000000000000000000000000000000000000000000000000000000000000100 #0 issue856.s.f[1].y 0000000000000000000000000000000000000000000000000000000000000011 #0 issue856.s.f[1].x 0000000000000000000000000000000000000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/issue862.txt000066400000000000000000000000661504111170000202500ustar00rootroot00000000000000a is matrix 11 rows and 11 with elements of length 10 nvc-r1.17.1/test/regress/gold/issue878.dump000066400000000000000000000015131504111170000204030ustar00rootroot00000000000000#0 issue878.s[3][2].y 00000000000000000000000000000000 #0 issue878.s[3][2].x 00000000000000000000000000000000 #0 issue878.s[3][1].y 00000000000000000000000000000000 #0 issue878.s[3][1].x 00000000000000000000000000000000 #0 issue878.s[2][2].y 00000000000000000000000000000000 #0 issue878.s[2][2].x 00000000000000000000000000000000 #0 issue878.s[2][1].y 00000000000000000000000000000000 #0 issue878.s[2][1].x 00000000000000000000000000000000 #0 issue878.s[1][2].y 00000000000000000000000000000000 #0 issue878.s[1][2].x 00000000000000000000000000000000 #0 issue878.s[1][1].y 00000000000000000000000000000000 #0 issue878.s[1][1].x 00000000000000000000000000000000 #1000000 issue878.s[2][1].x 00000000000000000000000000000001 #1000000 issue878.s[2][1].y 00000000000000000000000000000010 #3000000 issue878.s[3][2].x 00000000000000000000000000101010 nvc-r1.17.1/test/regress/gold/issue885.txt000066400000000000000000000005341504111170000202550ustar00rootroot000000000000000ms+10000: limit of 10000 delta cycles reached | 7 | b : out std_logic_vector(1 downto 0) | ^ driver for port B is active ... 12 | signal c : std_logic; | ^ driver for signal C is active ... 28 | b : out std_logic_vector(1 downto 0) := "00" | ^ driver for port B is active | nvc-r1.17.1/test/regress/gold/issue901.dump000066400000000000000000000004261504111170000203700ustar00rootroot00000000000000#0 work.pack.y[2:0] 000 #0 work.pack.x 00000000000000000000000000000000 #0 issue901.z 0 #1000000 work.pack.x 00000000000000000000000000000001 #2000000 work.pack.x 00000000000000000000000000000101 #6000000 work.pack.y[2:0] 101 #7000000 work.pack.y[2:0] 110 #8000000 issue901.z 1 nvc-r1.17.1/test/regress/gold/issue903.xml000066400000000000000000000007451504111170000202310ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/issue904.dump000066400000000000000000000005731504111170000203760ustar00rootroot00000000000000#0 issue904.clk 0 #0 issue904.y 0 #0 issue904.x 0 #1000000 issue904.x 1 #1000000 issue904.clk 1 #2000000 issue904.clk 0 #2000000 issue904.y 1 #3000000 issue904.clk 1 #3000000 issue904.x 0 #4000000 issue904.clk 0 #5000000 issue904.clk 1 #5000000 issue904.x 1 #6000000 issue904.clk 0 #7000000 issue904.clk 1 #8000000 issue904.clk 0 #9000000 issue904.clk 1 #10000000 issue904.clk 0 nvc-r1.17.1/test/regress/gold/issue906.xml000066400000000000000000000023111504111170000202230ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/issue907.txt000066400000000000000000000001721504111170000202460ustar00rootroot00000000000000(init): type of signal E is not WORK.B-SIM.F declaration of E with type WORK.A-RTL.F external name with type WORK.B-SIM.F nvc-r1.17.1/test/regress/gold/issue909.txt000066400000000000000000000004471504111170000202550ustar00rootroot00000000000000Warning: omitting hierarchy WORK.TOP.UUT from the coverage report as the correpsonding source file could not be found > sub.vhd:5 statement: 100.0 % (1/1) branch: N.A. toggle: N.A. expression: N.A. FSM state: N.A. functional: N.A. nvc-r1.17.1/test/regress/gold/issue941.xml000066400000000000000000000015241504111170000202270ustar00rootroot00000000000000 nvc-r1.17.1/test/regress/gold/issue957.dump000066400000000000000000000044431504111170000204060ustar00rootroot00000000000000$comment issue957.uut.clk is aliased to clk $end $comment issue957.uut.datain[15:0] is aliased to datain[15:0] $end $comment issue957.uut.sel[1:0] is aliased to sel[1:0] $end $comment issue957.uut.en is aliased to en $end #0 issue957.uut.test[0][15:0] 0000000000000000 #0 issue957.uut.test[1][15:0] 0000000000000000 #0 issue957.uut.test[2][15:0] 0000000000000000 #0 issue957.en 0 #0 issue957.sel[1:0] 00 #0 issue957.datain[15:0] 0000000000000000 #0 issue957.clk 0 #0 issue957.clk_period 20 NS #10000000 issue957.clk 1 #20000000 issue957.clk 0 #30000000 issue957.clk 1 #40000000 issue957.clk 0 #50000000 issue957.clk 1 #60000000 issue957.clk 0 #70000000 issue957.clk 1 #80000000 issue957.clk 0 #90000000 issue957.clk 1 #100000000 issue957.clk 0 #110000000 issue957.clk 1 #110000000 issue957.datain[15:0] 0001000100010001 #110000000 issue957.en 1 #120000000 issue957.clk 0 #130000000 issue957.clk 1 #130000000 issue957.en 0 #130000000 issue957.uut.test[0][15:0] 0001000100010001 #140000000 issue957.clk 0 #150000000 issue957.clk 1 #160000000 issue957.clk 0 #170000000 issue957.clk 1 #180000000 issue957.clk 0 #190000000 issue957.clk 1 #200000000 issue957.clk 0 #210000000 issue957.clk 1 #220000000 issue957.clk 0 #230000000 issue957.clk 1 #240000000 issue957.clk 0 #250000000 issue957.clk 1 #250000000 issue957.en 1 #250000000 issue957.datain[15:0] 0011001100110011 #250000000 issue957.sel[1:0] 10 #260000000 issue957.clk 0 #270000000 issue957.clk 1 #270000000 issue957.en 0 #270000000 issue957.uut.test[2][15:0] 0011001100110011 #280000000 issue957.clk 0 #290000000 issue957.clk 1 #300000000 issue957.clk 0 #310000000 issue957.clk 1 #320000000 issue957.clk 0 #330000000 issue957.clk 1 #340000000 issue957.clk 0 #350000000 issue957.clk 1 #360000000 issue957.clk 0 #370000000 issue957.clk 1 #380000000 issue957.clk 0 #390000000 issue957.clk 1 #390000000 issue957.en 1 #390000000 issue957.sel[1:0] 01 #390000000 issue957.datain[15:0] 0010001000100010 #400000000 issue957.clk 0 #410000000 issue957.clk 1 #410000000 issue957.en 0 #410000000 issue957.uut.test[1][15:0] 0010001000100010 #420000000 issue957.clk 0 #430000000 issue957.clk 1 #440000000 issue957.clk 0 #450000000 issue957.clk 1 #460000000 issue957.clk 0 #470000000 issue957.clk 1 #480000000 issue957.clk 0 #490000000 issue957.clk 1 #500000000 issue957.clk 0 #510000000 issue957.clk 1 nvc-r1.17.1/test/regress/gold/issue96.txt000066400000000000000000000001051504111170000201610ustar00rootroot00000000000000called the user function concatenated string is abcdBefgh abcdBefgh nvc-r1.17.1/test/regress/gold/issue962.dump000066400000000000000000000003441504111170000203760ustar00rootroot00000000000000#0 issue962.i_channel_states[1].descriptor[4:0] 00000 #0 issue962.i_channel_states[0].descriptor[4:0] 00000 #1000000 issue962.i_channel_states[1].descriptor[4:0] 10110 #2000000 issue962.i_channel_states[0].descriptor[4:0] 00001 nvc-r1.17.1/test/regress/gold/issue970.txt000066400000000000000000000001631504111170000202460ustar00rootroot00000000000000(0=>8, 1=>7, 2=>6, 3=>5, 4=>4, 5=>3, 6=>2, 7=>1) (15=>L, 16=>1, 17=>0, 18=>U, 19=>-, 20=>X) (9=>1) () (4=>2, 5=>1) nvc-r1.17.1/test/regress/gold/issue972.dump000066400000000000000000000016001504111170000203730ustar00rootroot00000000000000#0 issue972.b.o[0].f 00000000000000000000000000000000 #0 issue972.b.o[1].f 00000000000000000000000000000000 #0 issue972.b.i[0].f 00000000000000000000000000000000 #0 issue972.b.i[1].f 00000000000000000000000000000000 #0 issue972.y[0].f 00000000000000000000000000000000 #0 issue972.y[1].f 00000000000000000000000000000000 #0 issue972.x[0].f 00000000000000000000000000000000 #0 issue972.x[1].f 00000000000000000000000000000000 #1000000 issue972.x[1].f 00000000000000000000000000000001 #1000000 issue972.b.i[1].f 00000000000000000000000000000001 #2000000 issue972.b.i[1].f 00000000000000000000000000000010 #2000000 issue972.x[1].f 00000000000000000000000000000010 #2000000 issue972.y[1].f 00000000000000000000000000000001 #2000000 issue972.b.o[1].f 00000000000000000000000000000001 #3000000 issue972.b.o[1].f 00000000000000000000000000000010 #3000000 issue972.y[1].f 00000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/issue979.dump000066400000000000000000000000661504111170000204070ustar00rootroot00000000000000#0 issue979.foo_inst.rd_data 0 #0 issue979.wrb_data 0 nvc-r1.17.1/test/regress/gold/issue985.dump000066400000000000000000000002001504111170000203720ustar00rootroot00000000000000#0 issue985.mem[0][3:0] 1111 #0 issue985.mem[1][3:0] 0000 #1000000 issue985.mem[1][3:0] 0001 #1000000 issue985.mem[0][3:0] 0000 nvc-r1.17.1/test/regress/gold/ivtest2.txt000066400000000000000000000006301504111170000202550ustar00rootroot00000000000000time= 51, cat1=1 time= 52, cat2=1 time= 53, cat3=1 time= 54, cat4=1 time= 55, foo1=1 time= 56, foo2=1 time= 57, foo3=1 time= 58, foo4=1 time= 59, bar1=1 time= 59, bar2=1 time= 59, bar3=1 time= 59, bar4=1 nvc-r1.17.1/test/regress/gold/proc13.txt000066400000000000000000000000771504111170000177710ustar00rootroot000000000000001ns+0: division by zero Parameter X at Process :proc13:main at nvc-r1.17.1/test/regress/gold/proc7.txt000066400000000000000000000001021504111170000177010ustar00rootroot000000000000001ns+0: '1' 1ns+0: '0' 1ns+0: '1' 2ns+0: '1' 2ns+0: '1' 2ns+0: '0' nvc-r1.17.1/test/regress/gold/proc8.txt000066400000000000000000000001141504111170000177050ustar00rootroot000000000000000ms+0: 1 0ms+0: 2 0ms+0: 3 0ms+0: 4 1ns+0: -1 1ns+0: -2 1ns+0: -3 1ns+0: -4 nvc-r1.17.1/test/regress/gold/protected11.txt000066400000000000000000000000701504111170000210060ustar00rootroot000000000000000ms+0: cannot wait inside call to protected type method nvc-r1.17.1/test/regress/gold/psl1.txt000066400000000000000000000000711504111170000175330ustar00rootroot000000000000005ns+0: PSL assertion failed 45ns+0: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl10.txt000066400000000000000000000000341504111170000176120ustar00rootroot000000000000007ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl11.txt000066400000000000000000000001151504111170000176130ustar00rootroot000000000000008ns+0: FINISH called 8ns+0: PSL assertion failed 8ns+0: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl13.txt000066400000000000000000000001601504111170000176150ustar00rootroot000000000000002ns+1: PSL assertion failed 3ns+1: PSL assertion failed 5ns+1: PSL assertion failed 7ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl14.txt000066400000000000000000000002161504111170000176200ustar00rootroot000000000000006ns+0: cov_1 hit 8ns+0: cov_1 hit 10ns+0: cov_2 hit 11ns+0: cov_2 hit 12ns+0: cov_3 hit 13ns+0: cov_5 hit 14ns+0: cov_5 hit 15ns+0: cov_5 hit nvc-r1.17.1/test/regress/gold/psl15.txt000066400000000000000000000003641504111170000176250ustar00rootroot000000000000003ns+0: cov_2 hit 4ns+0: cov_1 hit 4ns+0: cov_2 hit 5ns+0: cov_4 hit 8ns+0: cov_2 hit 8ns+0: cov_3 hit 8ns+0: cov_4 hit 9ns+0: cov_1 hit 12ns+0: cov_4 hit 13ns+0: cov_2 hit 15ns+0: cov_4 hit 16ns+0: cov_1 hit 16ns+0: cov_2 hit 17ns+0: cov_1 hit nvc-r1.17.1/test/regress/gold/psl16.txt000066400000000000000000000000641504111170000176230ustar00rootroot000000000000002ns+0: cov_1 hit 8ns+0: cov_2_hit 12ns+0: cov_3_hit nvc-r1.17.1/test/regress/gold/psl17.txt000066400000000000000000000000261504111170000176220ustar00rootroot000000000000003ns+1: one 5ns+1: two nvc-r1.17.1/test/regress/gold/psl18.txt000066400000000000000000000000701504111170000176220ustar00rootroot000000000000005ns+1: PSL assertion failed 7ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl19.txt000066400000000000000000000001461504111170000176270ustar00rootroot00000000000000** Note: 2ns+1: one ** Note: 3ns+1: one ** Note: 4ns+1: two ** Note: 6ns+1: three ** Note: 7ns+1: fournvc-r1.17.1/test/regress/gold/psl2.txt000066400000000000000000000002141504111170000175330ustar00rootroot000000000000002ns+1: PSL assertion failed 2ns+1: PSL assertion failed 3ns+1: PSL assertion failed 4ns+1: PSL assertion failed 5ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl20.txt000066400000000000000000000002011504111170000176070ustar00rootroot00000000000000** Note: 2ns+1: ROSE ** Note: 3ns+1: STABLE ** Note: 4ns+1: STABLE ** Note: 5ns+1: FELL ** Note: 6ns+1: ROSE ** Note: 7ns+1: FELLnvc-r1.17.1/test/regress/gold/psl21.txt000066400000000000000000000002621504111170000176170ustar00rootroot000000000000001ns+1: two 1ns+1: three 2ns+1: one 2ns+1: two 3ns+1: two 5ns+1: two 5ns+1: three 6ns+1: one 6ns+1: three 7ns+1: two 7ns+1: three 8ns+1: one 10ns+1: one 10ns+1: two 10ns+1: three nvc-r1.17.1/test/regress/gold/psl3.txt000066400000000000000000000000341504111170000175340ustar00rootroot000000000000006ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl4.txt000066400000000000000000000004351504111170000175420ustar00rootroot0000000000000040ns+1: PSL assertion failed 50ns+1: PSL assertion failed 50ns+1: PSL assertion failed 60ns+1: PSL assertion failed 70ns+1: PSL assertion failed 80ns+1: PSL assertion failed 90ns+1: PSL assertion failed 100ns+1: PSL assertion failed 130ns+1: PSL assertion failed 135ns+1: FINISH callednvc-r1.17.1/test/regress/gold/psl5.txt000066400000000000000000000000341504111170000175360ustar00rootroot000000000000007ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl6.txt000066400000000000000000000001251504111170000175400ustar00rootroot000000000000002ns+1: PSL assertion failed 4ns+1: PSL assertion failed 10ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl7.txt000066400000000000000000000000771504111170000175470ustar00rootroot00000000000000** Note: 5ns+0: one ** Note: 5ns+0: two ** Note: 35ns+0: three nvc-r1.17.1/test/regress/gold/psl8.txt000066400000000000000000000000341504111170000175410ustar00rootroot000000000000005ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/psl9.txt000066400000000000000000000000351504111170000175430ustar00rootroot0000000000000011ns+1: PSL assertion failed nvc-r1.17.1/test/regress/gold/range1.txt000066400000000000000000000006471504111170000200420ustar00rootroot000000000000000ms+0: little_range = 00000000 1ns+0: stride = 7 1ns+1: little_range = 11111110 2ns+0: stride = 6 2ns+1: little_range = 11101101 3ns+0: stride = 5 3ns+1: little_range = 11111010 4ns+0: stride = 4 4ns+1: little_range = 11001110 5ns+0: stride = 3 5ns+1: little_range = 11011110 6ns+0: stride = 2 6ns+1: little_range = 10101101 7ns+0: stride = 1 7ns+1: little_range = 10111110 8ns+0: stride = 0 8ns+1: little_range = 11101111 nvc-r1.17.1/test/regress/gold/real1.txt000066400000000000000000000001541504111170000176620ustar00rootroot000000000000000ms+0: 5 0ms+0: -526.2 0ms+0: 1.23456 0ms+0: 0.5 0ms+0: -1.79769313486232e+308 0ms+0: 1.79769313486232e+308 nvc-r1.17.1/test/regress/gold/real3.txt000066400000000000000000000000551504111170000176640ustar00rootroot000000000000000ms+0: real: -523467 0ms+1: integer: -523467 nvc-r1.17.1/test/regress/gold/real4.txt000066400000000000000000000001521504111170000176630ustar00rootroot000000000000001ns+0: value inf outside of REAL range -1.7976931348623157e+308 to 1.7976931348623157e+308 for variable X nvc-r1.17.1/test/regress/gold/real7.txt000066400000000000000000000001331504111170000176650ustar00rootroot000000000000000ms+0: value inf outside of REAL range -1.7976931348623157e+308 to 1.7976931348623157e+308 nvc-r1.17.1/test/regress/gold/record38.txt000066400000000000000000000000701504111170000203040ustar00rootroot00000000000000(init): value length 2 does not match signal S length 1 nvc-r1.17.1/test/regress/gold/signal11.txt000066400000000000000000000000501504111170000202700ustar00rootroot000000000000000ms+0: :work:pack:x 0ms+0: :work:pack:x nvc-r1.17.1/test/regress/gold/signal23.txt000066400000000000000000000001121504111170000202720ustar00rootroot000000000000000ms+0: if: cs: '0' addr: 0000 rdata: 00000000 wdata: 00000000 nvc-r1.17.1/test/regress/gold/signal29.txt000066400000000000000000000000451504111170000203050ustar00rootroot000000000000001ns+0: illegal negative delay -10 ps nvc-r1.17.1/test/regress/gold/signal6.txt000066400000000000000000000000551504111170000202210ustar00rootroot000000000000000ms+0: 0 0ms+1: 1 3ns+0: 2 5ns+0: 4 9ns+0: 8 nvc-r1.17.1/test/regress/gold/stop1.txt000066400000000000000000000000321504111170000177170ustar00rootroot00000000000000STOP called with status 0 nvc-r1.17.1/test/regress/gold/stop2.txt000066400000000000000000000000321504111170000177200ustar00rootroot00000000000000STOP called with status 0 nvc-r1.17.1/test/regress/gold/synopsys2.txt000066400000000000000000000005631504111170000206530ustar00rootroot000000000000000ms+0: There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es) Function "+" [UNSIGNED, UNSIGNED return STD_LOGIC_VECTOR] Process :synopsys2:test_unsigned_plus There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es). Function "-" [UNSIGNED, UNSIGNED return STD_LOGIC_VECTOR] Process :synopsys2:test_unsigned_minus nvc-r1.17.1/test/regress/gold/synopsys3.txt000066400000000000000000000003201504111170000206430ustar00rootroot000000000000000ms+0: index 0 outside of NATURAL range -1 downto 0 Function CONV_UNSIGNED [UNSIGNED, INTEGER return UNSIGNED] at Function "+" [UNSIGNED, UNSIGNED return UNSIGNED] at Process :synopsys3:test_unsigned_plus at nvc-r1.17.1/test/regress/gold/tcl3.txt000066400000000000000000000002301504111170000175160ustar00rootroot00000000000000boo while executing "error "boo"" (procedure "proc2" line 2) invoked from within "proc2" (procedure "proc1" line 2) invoked from within "proc1" (file " nvc-r1.17.1/test/regress/gold/textio1.txt000066400000000000000000000001571504111170000202560ustar00rootroot00000000000000hello, world one two hello | world 0 0110101 true 10 ns 0.05 us 1.234000e+00 1.2 1.2346 nvc-r1.17.1/test/regress/gold/textio5.txt000066400000000000000000000000121504111170000202500ustar00rootroot000000000000000123 4567 nvc-r1.17.1/test/regress/gold/value3.txt000066400000000000000000000001021504111170000200460ustar00rootroot000000000000000ms+0: value length 3 does not match subtype T_PAIR_PAIR length 2 nvc-r1.17.1/test/regress/gold/value4.txt000066400000000000000000000000551504111170000200560ustar00rootroot000000000000000ms+0: invalid character 'X' in string "abX" nvc-r1.17.1/test/regress/gold/vhpi1.txt000066400000000000000000000031371504111170000177110ustar00rootroot00000000000000loading VHPI plugin hello, world! tool is nvc tool version is arg is +foo=bar root handle root name is VHPI1 root case name is vhpi1 root full name is :VHPI1 root full case name is :vhpi1 root port is X root port is Y root signal is V root signal is B root signal is R root decl is V root decl is B root decl is R arch handle arch name is VHPI1-TEST arch unit name is WORK.vhpi1-test entity handle entity name is VHPI1 entity unit name is WORK.vhpi1 x handle x name X x full name is :VHPI1:X y handle y name Y y full name is :VHPI1:Y r handle r type handle r type name is ZERO_TO_ONE r type full name is @WORK:VHPI1-TEST:ZERO_TO_ONE v handle v name is V v full name is :VHPI1:V v type handle v type name is BIT_VECTOR v type full name is @STD:STANDARD:BIT_VECTOR v dimensions 1 v type range handle v left bound 3 v right bound 0 v elem type handle v elem type name is BIT v elem type full name is @STD:STANDARD:BIT v elem literal 0 is '0' v elem literal 1 is '1' v indexed name is V(3) v indexed name is V(2) v indexed name is V(1) v indexed name is V(0) name is A_NAME_WITH_MIXED_CASE case name is A_name_with_MIXED_case full case name is :vhpi1:A_name_with_MIXED_case start of sim callback! user data is 'some user data' 0ms+0: x=5 after_5ns callback! 5ns+1: x=70 5000001fs+0: mutual callback! 5000001fs+0: mutual callback! 5000001fs+0: deferred work callback! 5000002fs+0: enabled callback! y value changed to 71 6ns+0: mutual callback! 6ns+1: x=72 y value changed to 73 7ns+1: x=74 y value changed to 75 b bit string '0' need 5 bytes for v string v bit string '0011' VHPI plugin requested end of simulation end of sim callback nvc-r1.17.1/test/regress/gold/vhpi5.txt000066400000000000000000000226231504111170000177160ustar00rootroot00000000000000test name is vhpi5 hello, world! root handle root name is VHPI5 m handle m elem 0 is A m elem 1 is B m elem 2 is C M.A = 0000 M.B = 0010 M.C(0) = 0020 M.C(1) = 0021 N(0,0).A = 0000 N(0,0).B = 0010 N(0,0).C(0) = 0020 N(0,0).C(1) = 0021 N(0,1).A = 0100 N(0,1).B = 0110 N(0,1).C(0) = 0120 N(0,1).C(1) = 0121 N(0,2).A = 0200 N(0,2).B = 0210 N(0,2).C(0) = 0220 N(0,2).C(1) = 0221 N(0,3).A = 0300 N(0,3).B = 0310 N(0,3).C(0) = 0320 N(0,3).C(1) = 0321 N(0,4).A = 0400 N(0,4).B = 0410 N(0,4).C(0) = 0420 N(0,4).C(1) = 0421 N(1,0).A = 1000 N(1,0).B = 1010 N(1,0).C(0) = 1020 N(1,0).C(1) = 1021 N(1,1).A = 1100 N(1,1).B = 1110 N(1,1).C(0) = 1120 N(1,1).C(1) = 1121 N(1,2).A = 1200 N(1,2).B = 1210 N(1,2).C(0) = 1220 N(1,2).C(1) = 1221 N(1,3).A = 1300 N(1,3).B = 1310 N(1,3).C(0) = 1320 N(1,3).C(1) = 1321 N(1,4).A = 1400 N(1,4).B = 1410 N(1,4).C(0) = 1420 N(1,4).C(1) = 1421 N(2,0).A = 2000 N(2,0).B = 2010 N(2,0).C(0) = 2020 N(2,0).C(1) = 2021 N(2,1).A = 2100 N(2,1).B = 2110 N(2,1).C(0) = 2120 N(2,1).C(1) = 2121 N(2,2).A = 2200 N(2,2).B = 2210 N(2,2).C(0) = 2220 N(2,2).C(1) = 2221 N(2,3).A = 2300 N(2,3).B = 2310 N(2,3).C(0) = 2320 N(2,3).C(1) = 2321 N(2,4).A = 2400 N(2,4).B = 2410 N(2,4).C(0) = 2420 N(2,4).C(1) = 2421 N(3,0).A = 3000 N(3,0).B = 3010 N(3,0).C(0) = 3020 N(3,0).C(1) = 3021 N(3,1).A = 3100 N(3,1).B = 3110 N(3,1).C(0) = 3120 N(3,1).C(1) = 3121 N(3,2).A = 3200 N(3,2).B = 3210 N(3,2).C(0) = 3220 N(3,2).C(1) = 3221 N(3,3).A = 3300 N(3,3).B = 3310 N(3,3).C(0) = 3320 N(3,3).C(1) = 3321 N(3,4).A = 3400 N(3,4).B = 3410 N(3,4).C(0) = 3420 N(3,4).C(1) = 3421 N(4,0).A = 4000 N(4,0).B = 4010 N(4,0).C(0) = 4020 N(4,0).C(1) = 4021 N(4,1).A = 4100 N(4,1).B = 4110 N(4,1).C(0) = 4120 N(4,1).C(1) = 4121 N(4,2).A = 4200 N(4,2).B = 4210 N(4,2).C(0) = 4220 N(4,2).C(1) = 4221 N(4,3).A = 4300 N(4,3).B = 4310 N(4,3).C(0) = 4320 N(4,3).C(1) = 4321 N(4,4).A = 4400 N(4,4).B = 4410 N(4,4).C(0) = 4420 N(4,4).C(1) = 4421 N(5,0).A = 5000 N(5,0).B = 5010 N(5,0).C(0) = 5020 N(5,0).C(1) = 5021 N(5,1).A = 5100 N(5,1).B = 5110 N(5,1).C(0) = 5120 N(5,1).C(1) = 5121 N(5,2).A = 5200 N(5,2).B = 5210 N(5,2).C(0) = 5220 N(5,2).C(1) = 5221 N(5,3).A = 5300 N(5,3).B = 5310 N(5,3).C(0) = 5320 N(5,3).C(1) = 5321 N(5,4).A = 5400 N(5,4).B = 5410 N(5,4).C(0) = 5420 N(5,4).C(1) = 5421 N(6,0).A = 6000 N(6,0).B = 6010 N(6,0).C(0) = 6020 N(6,0).C(1) = 6021 N(6,1).A = 6100 N(6,1).B = 6110 N(6,1).C(0) = 6120 N(6,1).C(1) = 6121 N(6,2).A = 6200 N(6,2).B = 6210 N(6,2).C(0) = 6220 N(6,2).C(1) = 6221 N(6,3).A = 6300 N(6,3).B = 6310 N(6,3).C(0) = 6320 N(6,3).C(1) = 6321 N(6,4).A = 6400 N(6,4).B = 6410 N(6,4).C(0) = 6420 N(6,4).C(1) = 6421 O.A = 0000 O.B = 1000 O.C(0) = 2000 O.C(1) = 2100 O.C(2) = 2200 O.C(3) = 2300 O.C(4) = 2400 O.D(0) = 3000 O.D(1) = 3100 O.D(2) = 3200 O.D(3) = 3300 O.D(4) = 3400 O.E(0).A = 4000 O.E(0).B = 4010 O.E(0).C(0) = 4020 O.E(0).C(1) = 4021 O.E(1).A = 4100 O.E(1).B = 4110 O.E(1).C(0) = 4120 O.E(1).C(1) = 4121 O.E(2).A = 4200 O.E(2).B = 4210 O.E(2).C(0) = 4220 O.E(2).C(1) = 4221 O.E(3).A = 4300 O.E(3).B = 4310 O.E(3).C(0) = 4320 O.E(3).C(1) = 4321 O.E(4).A = 4400 O.E(4).B = 4410 O.E(4).C(0) = 4420 O.E(4).C(1) = 4421 O.F(0).A = 5000 O.F(0).B = 5010 O.F(0).C(0) = 5020 O.F(0).C(1) = 5021 O.F(1).A = 5100 O.F(1).B = 5110 O.F(1).C(0) = 5120 O.F(1).C(1) = 5121 O.F(2).A = 5200 O.F(2).B = 5210 O.F(2).C(0) = 5220 O.F(2).C(1) = 5221 O.F(3).A = 5300 O.F(3).B = 5310 O.F(3).C(0) = 5320 O.F(3).C(1) = 5321 O.F(4).A = 5400 O.F(4).B = 5410 O.F(4).C(0) = 5420 O.F(4).C(1) = 5421 O.G(0).A = 6000 O.G(0).B = 6010 O.G(0).C(0) = 6020 O.G(0).C(1) = 6021 O.G(1).A = 6100 O.G(1).B = 6110 O.G(1).C(0) = 6120 O.G(1).C(1) = 6121 O.G(2).A = 6200 O.G(2).B = 6210 O.G(2).C(0) = 6220 O.G(2).C(1) = 6221 O.G(3).A = 6300 O.G(3).B = 6310 O.G(3).C(0) = 6320 O.G(3).C(1) = 6321 O.G(4).A = 6400 O.G(4).B = 6410 O.G(4).C(0) = 6420 O.G(4).C(1) = 6421 M.A = 0000 M.B = 0100 M.C(0) = 0200 M.C(1) = 1200 N(0,0).A = 0000 N(0,0).B = 0100 N(0,0).C(0) = 0200 N(0,0).C(1) = 1200 N(0,1).A = 0010 N(0,1).B = 0110 N(0,1).C(0) = 0210 N(0,1).C(1) = 1210 N(0,2).A = 0020 N(0,2).B = 0120 N(0,2).C(0) = 0220 N(0,2).C(1) = 1220 N(0,3).A = 0030 N(0,3).B = 0130 N(0,3).C(0) = 0230 N(0,3).C(1) = 1230 N(0,4).A = 0040 N(0,4).B = 0140 N(0,4).C(0) = 0240 N(0,4).C(1) = 1240 N(1,0).A = 0001 N(1,0).B = 0101 N(1,0).C(0) = 0201 N(1,0).C(1) = 1201 N(1,1).A = 0011 N(1,1).B = 0111 N(1,1).C(0) = 0211 N(1,1).C(1) = 1211 N(1,2).A = 0021 N(1,2).B = 0121 N(1,2).C(0) = 0221 N(1,2).C(1) = 1221 N(1,3).A = 0031 N(1,3).B = 0131 N(1,3).C(0) = 0231 N(1,3).C(1) = 1231 N(1,4).A = 0041 N(1,4).B = 0141 N(1,4).C(0) = 0241 N(1,4).C(1) = 1241 N(2,0).A = 0002 N(2,0).B = 0102 N(2,0).C(0) = 0202 N(2,0).C(1) = 1202 N(2,1).A = 0012 N(2,1).B = 0112 N(2,1).C(0) = 0212 N(2,1).C(1) = 1212 N(2,2).A = 0022 N(2,2).B = 0122 N(2,2).C(0) = 0222 N(2,2).C(1) = 1222 N(2,3).A = 0032 N(2,3).B = 0132 N(2,3).C(0) = 0232 N(2,3).C(1) = 1232 N(2,4).A = 0042 N(2,4).B = 0142 N(2,4).C(0) = 0242 N(2,4).C(1) = 1242 N(3,0).A = 0003 N(3,0).B = 0103 N(3,0).C(0) = 0203 N(3,0).C(1) = 1203 N(3,1).A = 0013 N(3,1).B = 0113 N(3,1).C(0) = 0213 N(3,1).C(1) = 1213 N(3,2).A = 0023 N(3,2).B = 0123 N(3,2).C(0) = 0223 N(3,2).C(1) = 1223 N(3,3).A = 0033 N(3,3).B = 0133 N(3,3).C(0) = 0233 N(3,3).C(1) = 1233 N(3,4).A = 0043 N(3,4).B = 0143 N(3,4).C(0) = 0243 N(3,4).C(1) = 1243 N(4,0).A = 0004 N(4,0).B = 0104 N(4,0).C(0) = 0204 N(4,0).C(1) = 1204 N(4,1).A = 0014 N(4,1).B = 0114 N(4,1).C(0) = 0214 N(4,1).C(1) = 1214 N(4,2).A = 0024 N(4,2).B = 0124 N(4,2).C(0) = 0224 N(4,2).C(1) = 1224 N(4,3).A = 0034 N(4,3).B = 0134 N(4,3).C(0) = 0234 N(4,3).C(1) = 1234 N(4,4).A = 0044 N(4,4).B = 0144 N(4,4).C(0) = 0244 N(4,4).C(1) = 1244 N(5,0).A = 0005 N(5,0).B = 0105 N(5,0).C(0) = 0205 N(5,0).C(1) = 1205 N(5,1).A = 0015 N(5,1).B = 0115 N(5,1).C(0) = 0215 N(5,1).C(1) = 1215 N(5,2).A = 0025 N(5,2).B = 0125 N(5,2).C(0) = 0225 N(5,2).C(1) = 1225 N(5,3).A = 0035 N(5,3).B = 0135 N(5,3).C(0) = 0235 N(5,3).C(1) = 1235 N(5,4).A = 0045 N(5,4).B = 0145 N(5,4).C(0) = 0245 N(5,4).C(1) = 1245 N(6,0).A = 0006 N(6,0).B = 0106 N(6,0).C(0) = 0206 N(6,0).C(1) = 1206 N(6,1).A = 0016 N(6,1).B = 0116 N(6,1).C(0) = 0216 N(6,1).C(1) = 1216 N(6,2).A = 0026 N(6,2).B = 0126 N(6,2).C(0) = 0226 N(6,2).C(1) = 1226 N(6,3).A = 0036 N(6,3).B = 0136 N(6,3).C(0) = 0236 N(6,3).C(1) = 1236 N(6,4).A = 0046 N(6,4).B = 0146 N(6,4).C(0) = 0246 N(6,4).C(1) = 1246 O.A = 0000 O.B = 0001 O.C(0) = 0002 O.C(1) = 0012 O.C(2) = 0022 O.C(3) = 0032 O.C(4) = 0042 O.D(0) = 0003 O.D(1) = 0013 O.D(2) = 0023 O.D(3) = 0033 O.D(4) = 0043 O.E(0).A = 0004 O.E(0).B = 0104 O.E(0).C(0) = 0204 O.E(0).C(1) = 1204 O.E(1).A = 0014 O.E(1).B = 0114 O.E(1).C(0) = 0214 O.E(1).C(1) = 1214 O.E(2).A = 0024 O.E(2).B = 0124 O.E(2).C(0) = 0224 O.E(2).C(1) = 1224 O.E(3).A = 0034 O.E(3).B = 0134 O.E(3).C(0) = 0234 O.E(3).C(1) = 1234 O.E(4).A = 0044 O.E(4).B = 0144 O.E(4).C(0) = 0244 O.E(4).C(1) = 1244 O.F(0).A = 0005 O.F(0).B = 0105 O.F(0).C(0) = 0205 O.F(0).C(1) = 1205 O.F(1).A = 0015 O.F(1).B = 0115 O.F(1).C(0) = 0215 O.F(1).C(1) = 1215 O.F(2).A = 0025 O.F(2).B = 0125 O.F(2).C(0) = 0225 O.F(2).C(1) = 1225 O.F(3).A = 0035 O.F(3).B = 0135 O.F(3).C(0) = 0235 O.F(3).C(1) = 1235 O.F(4).A = 0045 O.F(4).B = 0145 O.F(4).C(0) = 0245 O.F(4).C(1) = 1245 O.G(0).A = 0006 O.G(0).B = 0106 O.G(0).C(0) = 0206 O.G(0).C(1) = 1206 O.G(1).A = 0016 O.G(1).B = 0116 O.G(1).C(0) = 0216 O.G(1).C(1) = 1216 O.G(2).A = 0026 O.G(2).B = 0126 O.G(2).C(0) = 0226 O.G(2).C(1) = 1226 O.G(3).A = 0036 O.G(3).B = 0136 O.G(3).C(0) = 0236 O.G(3).C(1) = 1236 O.G(4).A = 0046 O.G(4).B = 0146 O.G(4).C(0) = 0246 O.G(4).C(1) = 1246 nvc-r1.17.1/test/regress/gold/vlog2.txt000066400000000000000000000001221504111170000177020ustar00rootroot00000000000000hello, world! string=foo foo 42 00000005 0 0ms+0: $finish called nvc-r1.17.1/test/regress/gold/vlog20.txt000066400000000000000000000002261504111170000177670ustar00rootroot0000000000000000 + 00 ==> 00 01 + 05 ==> 06 02 + 0a ==> 0c 03 + 0f ==> 12 04 + 14 ==> 18 05 + 19 ==> 1e 06 + 1e ==> 24 07 + 23 ==> 2a 08 + 28 ==> 30 09 + 2d ==> 36 nvc-r1.17.1/test/regress/gold/vlog3.txt000066400000000000000000000000501504111170000177030ustar00rootroot00000000000000x ==> x x ==> 1 x ==> 1 x ==> 0 x ==> 0 nvc-r1.17.1/test/regress/gold/vlog4.txt000066400000000000000000000000361504111170000177100ustar00rootroot00000000000000x ==> x x ==> 42 x ==> 12 nvc-r1.17.1/test/regress/gold/vlog5.txt000066400000000000000000000000431504111170000177070ustar00rootroot000000000000000 1 0 0 nvc-r1.17.1/test/regress/gold/vlog6.txt000066400000000000000000000000221504111170000177050ustar00rootroot000000000000001 1 1 ff 0 0 0 7f nvc-r1.17.1/test/regress/gold/vlog7.txt000066400000000000000000000000141504111170000177070ustar00rootroot00000000000000x x x 0 1 0 nvc-r1.17.1/test/regress/gold/wait12.txt000066400000000000000000000001431504111170000177630ustar00rootroot000000000000001ns+3: wake up postponed process 1 2ns+1: wake up postponed process 2 3ns+0: wake up other process nvc-r1.17.1/test/regress/gold/wait2.txt000066400000000000000000000000441504111170000177020ustar00rootroot000000000000003ns+1: done proc2 3ns+2: done proc1 nvc-r1.17.1/test/regress/gold/wait26.txt000066400000000000000000000000531504111170000177700ustar00rootroot000000000000006ns+0: illegal negative delay -3600000 ms nvc-r1.17.1/test/regress/gold/wait28.txt000066400000000000000000000000701504111170000177710ustar00rootroot000000000000000ms+0: cannot wait inside process with sensitivity list nvc-r1.17.1/test/regress/gold/wait6.txt000066400000000000000000000002041504111170000177040ustar00rootroot000000000000000ms+0: x changed '0' '0' '0' '0' 0ms+1: x changed '0' '0' '0' '1' 1ns+1: x changed '0' '0' '1' '0' 2ns+1: x changed '1' '1' '1' '1' nvc-r1.17.1/test/regress/gold/wave1.dump000066400000000000000000000001501504111170000200230ustar00rootroot00000000000000#0 wave1.y[1:3] ZZZ #0 wave1.x 1 #1000000 wave1.x 0 #1000000 wave1.y[1:3] 101 #2000000 wave1.y[1:3] 001 nvc-r1.17.1/test/regress/gold/wave10.dump000066400000000000000000000002711504111170000201070ustar00rootroot00000000000000$comment wave10.u1.x[1:5] is aliased to s[1:5] $end $comment wave10.u2.x[1:5] is aliased to s[1:5] $end #0 wave10.s[1:5] 00000 #1000000 wave10.s[1:5] 01000 #2000000 wave10.s[1:5] 11100 nvc-r1.17.1/test/regress/gold/wave11.dump000066400000000000000000000007541504111170000201160ustar00rootroot00000000000000#0 wave11.b.r.f4[2].f2[1:3] 000 #0 wave11.b.r.f4[2].f1 false #0 wave11.b.r.f4[1].f2[1:3] 000 #0 wave11.b.r.f4[1].f1 false #0 wave11.b.r.f4[0].f2[1:3] 000 #0 wave11.b.r.f4[0].f1 false #0 wave11.b.r.f3.f2[1:3] 000 #0 wave11.b.r.f3.f1 false #0 wave11.b.r.f2[1:3] 000 #0 wave11.b.r.f1 10000000000000000000000000000000 #0 wave11.b.p1[1:3] 000 #0 wave11.s[1:3] 000 #1000000 wave11.b.r.f2[1:3] 100 #2000000 wave11.b.r.f2[1:3] 000 #3000000 wave11.b.r.f3.f2[1:3] 010 #4000000 wave11.b.r.f4[1].f1 true nvc-r1.17.1/test/regress/gold/wave12.dump000066400000000000000000000003061504111170000201100ustar00rootroot00000000000000#0 wave12.a[2][7:0] 00000000 #0 wave12.a[1][7:0] 00010000 #1000000 wave12.a[1][7:0] 00000001 #2000000 wave12.a[1][7:0] 00010000 #3000000 wave12.a[1][7:0] 00000001 #4000000 wave12.a[1][7:0] 00010000 nvc-r1.17.1/test/regress/gold/wave2.dump000066400000000000000000000000411504111170000200230ustar00rootroot00000000000000#0 wave2.foobaz 0 #0 wave2.bar 1 nvc-r1.17.1/test/regress/gold/wave3.dump000066400000000000000000000304241504111170000200340ustar00rootroot00000000000000$comment wave3.sub_i.x[7:0] is aliased to x[7:0] $end #0 work.p.s 1 #0 wave3.gen(3).g 10000000000000000000000000000000 #0 wave3.gen(2).g 10000000000000000000000000000000 #0 wave3.gen(1).g 10000000000000000000000000000000 #0 wave3.sub_i.ctr2[15:0] 0000000000000000 #0 wave3.sub_i.ctr[3:18] 0000000000000000 #0 wave3.sub_i.y[7:0] UUUUUUUU #0 wave3.a_block.c nul #0 wave3.a_block.c 'a' #0 wave3.a_block.i 00000000000000000000000000000000 #0 wave3.s2 one #0 wave3.s init #0 wave3.t 0 HR #0 wave3.q[3:1] 011 #0 wave3.p[1:3] 110 #0 wave3.m[1:3] #0 wave3.m[1:3] abc #0 wave3.b false #0 wave3.b true #0 wave3.o 0 #0 wave3.z u #0 wave3.y[7:0] UUUUUUUU #0 wave3.x[7:0] 10101010 #1000 wave3.t 20 US #4000000 wave3.s2 two #5000000 wave3.y[7:0] 10101010 #5000000 wave3.sub_i.y[7:0] 10101010 #20000000 wave3.a_block.i 00000000000000000000000000000001 #20000000 wave3.a_block.c 'b' #20000000 wave3.sub_i.ctr[3:18] 0000000000000001 #20000000 wave3.sub_i.ctr2[15:0] 0000000000000001 #40000000 wave3.sub_i.ctr2[15:0] 0000000000000010 #40000000 wave3.sub_i.ctr[3:18] 0000000000000010 #40000000 wave3.a_block.c 'c' #40000000 wave3.a_block.i 00000000000000000000000000000010 #50000000 wave3.x[7:0] 01010101 #55000000 wave3.sub_i.y[7:0] 01010101 #55000000 wave3.y[7:0] 01010101 #60000000 wave3.a_block.i 00000000000000000000000000000011 #60000000 wave3.a_block.c 'a' #60000000 wave3.sub_i.ctr[3:18] 0000000000000011 #60000000 wave3.sub_i.ctr2[15:0] 0000000000000011 #60000000 wave3.s one #80000000 wave3.sub_i.ctr2[15:0] 0000000000000100 #80000000 wave3.sub_i.ctr[3:18] 0000000000000100 #80000000 wave3.a_block.c 'b' #80000000 wave3.a_block.i 00000000000000000000000000000100 #100000000 wave3.a_block.i 00000000000000000000000000000101 #100000000 wave3.a_block.c 'c' #100000000 wave3.sub_i.ctr[3:18] 0000000000000101 #100000000 wave3.sub_i.ctr2[15:0] 0000000000000101 #100000000 wave3.x[7:0] 10101010 #100000000 wave3.z x #105000000 wave3.y[7:0] 10101010 #105000000 wave3.sub_i.y[7:0] 10101010 #120000000 wave3.sub_i.ctr2[15:0] 0000000000000110 #120000000 wave3.sub_i.ctr[3:18] 0000000000000110 #120000000 wave3.a_block.c 'a' #120000000 wave3.a_block.i 00000000000000000000000000000110 #140000000 wave3.a_block.i 00000000000000000000000000000111 #140000000 wave3.a_block.c 'b' #140000000 wave3.sub_i.ctr[3:18] 0000000000000111 #140000000 wave3.sub_i.ctr2[15:0] 0000000000000111 #150000000 wave3.x[7:0] 01010101 #150000000 wave3.s two #155000000 wave3.sub_i.y[7:0] 01010101 #155000000 wave3.y[7:0] 01010101 #160000000 wave3.sub_i.ctr2[15:0] 0000000000001000 #160000000 wave3.sub_i.ctr[3:18] 0000000000001000 #160000000 wave3.a_block.c 'c' #160000000 wave3.a_block.i 00000000000000000000000000001000 #180000000 wave3.a_block.i 00000000000000000000000000001001 #180000000 wave3.a_block.c 'a' #180000000 wave3.sub_i.ctr[3:18] 0000000000001001 #180000000 wave3.sub_i.ctr2[15:0] 0000000000001001 #200000000 wave3.sub_i.ctr2[15:0] 0000000000001010 #200000000 wave3.sub_i.ctr[3:18] 0000000000001010 #200000000 wave3.a_block.c 'b' #200000000 wave3.a_block.i 00000000000000000000000000001010 #200000000 wave3.x[7:0] 10101010 #200000000 wave3.z h #205000000 wave3.y[7:0] 10101010 #205000000 wave3.sub_i.y[7:0] 10101010 #220000000 wave3.a_block.i 00000000000000000000000000001011 #220000000 wave3.a_block.c 'c' #220000000 wave3.sub_i.ctr[3:18] 0000000000001011 #220000000 wave3.sub_i.ctr2[15:0] 0000000000001011 #240000000 wave3.sub_i.ctr2[15:0] 0000000000001100 #240000000 wave3.sub_i.ctr[3:18] 0000000000001100 #240000000 wave3.a_block.c 'a' #240000000 wave3.a_block.i 00000000000000000000000000001100 #250000000 wave3.x[7:0] 01010101 #255000000 wave3.sub_i.y[7:0] 01010101 #255000000 wave3.y[7:0] 01010101 #260000000 wave3.a_block.i 00000000000000000000000000001101 #260000000 wave3.a_block.c 'b' #260000000 wave3.sub_i.ctr[3:18] 0000000000001101 #260000000 wave3.sub_i.ctr2[15:0] 0000000000001101 #280000000 wave3.sub_i.ctr2[15:0] 0000000000001110 #280000000 wave3.sub_i.ctr[3:18] 0000000000001110 #280000000 wave3.a_block.c 'c' #280000000 wave3.a_block.i 00000000000000000000000000001110 #300000000 wave3.a_block.i 00000000000000000000000000001111 #300000000 wave3.a_block.c 'a' #300000000 wave3.sub_i.ctr[3:18] 0000000000001111 #300000000 wave3.sub_i.ctr2[15:0] 0000000000001111 #300000000 wave3.x[7:0] 10101010 #300000000 wave3.z z #305000000 wave3.y[7:0] 10101010 #305000000 wave3.sub_i.y[7:0] 10101010 #320000000 wave3.sub_i.ctr2[15:0] 0000000000010000 #320000000 wave3.sub_i.ctr[3:18] 0000000000010000 #320000000 wave3.a_block.c 'b' #320000000 wave3.a_block.i 00000000000000000000000000010000 #340000000 wave3.a_block.i 00000000000000000000000000010001 #340000000 wave3.a_block.c 'c' #340000000 wave3.sub_i.ctr[3:18] 0000000000010001 #340000000 wave3.sub_i.ctr2[15:0] 0000000000010001 #350000000 wave3.x[7:0] 01010101 #355000000 wave3.sub_i.y[7:0] 01010101 #355000000 wave3.y[7:0] 01010101 #360000000 wave3.sub_i.ctr2[15:0] 0000000000010010 #360000000 wave3.sub_i.ctr[3:18] 0000000000010010 #360000000 wave3.a_block.c 'a' #360000000 wave3.a_block.i 00000000000000000000000000010010 #380000000 wave3.a_block.i 00000000000000000000000000010011 #380000000 wave3.a_block.c 'b' #380000000 wave3.sub_i.ctr[3:18] 0000000000010011 #380000000 wave3.sub_i.ctr2[15:0] 0000000000010011 #400000000 wave3.sub_i.ctr2[15:0] 0000000000010100 #400000000 wave3.sub_i.ctr[3:18] 0000000000010100 #400000000 wave3.a_block.c 'c' #400000000 wave3.a_block.i 00000000000000000000000000010100 #400000000 wave3.x[7:0] 10101010 #400000000 wave3.z l #405000000 wave3.y[7:0] 10101010 #405000000 wave3.sub_i.y[7:0] 10101010 #420000000 wave3.a_block.i 00000000000000000000000000010101 #420000000 wave3.a_block.c 'a' #420000000 wave3.sub_i.ctr[3:18] 0000000000010101 #420000000 wave3.sub_i.ctr2[15:0] 0000000000010101 #440000000 wave3.sub_i.ctr2[15:0] 0000000000010110 #440000000 wave3.sub_i.ctr[3:18] 0000000000010110 #440000000 wave3.a_block.c 'b' #440000000 wave3.a_block.i 00000000000000000000000000010110 #450000000 wave3.x[7:0] 01010101 #455000000 wave3.sub_i.y[7:0] 01010101 #455000000 wave3.y[7:0] 01010101 #460000000 wave3.a_block.i 00000000000000000000000000010111 #460000000 wave3.a_block.c 'c' #460000000 wave3.sub_i.ctr[3:18] 0000000000010111 #460000000 wave3.sub_i.ctr2[15:0] 0000000000010111 #480000000 wave3.sub_i.ctr2[15:0] 0000000000011000 #480000000 wave3.sub_i.ctr[3:18] 0000000000011000 #480000000 wave3.a_block.c 'a' #480000000 wave3.a_block.i 00000000000000000000000000011000 #500000000 wave3.a_block.i 00000000000000000000000000011001 #500000000 wave3.a_block.c 'b' #500000000 wave3.sub_i.ctr[3:18] 0000000000011001 #500000000 wave3.sub_i.ctr2[15:0] 0000000000011001 #500000000 wave3.x[7:0] 10101010 #500000000 wave3.z - #505000000 wave3.y[7:0] 10101010 #505000000 wave3.sub_i.y[7:0] 10101010 #520000000 wave3.sub_i.ctr2[15:0] 0000000000011010 #520000000 wave3.sub_i.ctr[3:18] 0000000000011010 #520000000 wave3.a_block.c 'c' #520000000 wave3.a_block.i 00000000000000000000000000011010 #540000000 wave3.a_block.i 00000000000000000000000000011011 #540000000 wave3.a_block.c 'a' #540000000 wave3.sub_i.ctr[3:18] 0000000000011011 #540000000 wave3.sub_i.ctr2[15:0] 0000000000011011 #550000000 wave3.x[7:0] 01010101 #555000000 wave3.sub_i.y[7:0] 01010101 #555000000 wave3.y[7:0] 01010101 #560000000 wave3.sub_i.ctr2[15:0] 0000000000011100 #560000000 wave3.sub_i.ctr[3:18] 0000000000011100 #560000000 wave3.a_block.c 'b' #560000000 wave3.a_block.i 00000000000000000000000000011100 #580000000 wave3.a_block.i 00000000000000000000000000011101 #580000000 wave3.a_block.c 'c' #580000000 wave3.sub_i.ctr[3:18] 0000000000011101 #580000000 wave3.sub_i.ctr2[15:0] 0000000000011101 #600000000 wave3.sub_i.ctr2[15:0] 0000000000011110 #600000000 wave3.sub_i.ctr[3:18] 0000000000011110 #600000000 wave3.a_block.c 'a' #600000000 wave3.a_block.i 00000000000000000000000000011110 #600000000 wave3.x[7:0] 10101010 #600000000 wave3.z 1 #605000000 wave3.y[7:0] 10101010 #605000000 wave3.sub_i.y[7:0] 10101010 #620000000 wave3.a_block.i 00000000000000000000000000011111 #620000000 wave3.a_block.c 'b' #620000000 wave3.sub_i.ctr[3:18] 0000000000011111 #620000000 wave3.sub_i.ctr2[15:0] 0000000000011111 #640000000 wave3.sub_i.ctr2[15:0] 0000000000100000 #640000000 wave3.sub_i.ctr[3:18] 0000000000100000 #640000000 wave3.a_block.c 'c' #640000000 wave3.a_block.i 00000000000000000000000000100000 #650000000 wave3.x[7:0] 01010101 #655000000 wave3.sub_i.y[7:0] 01010101 #655000000 wave3.y[7:0] 01010101 #660000000 wave3.a_block.i 00000000000000000000000000100001 #660000000 wave3.a_block.c 'a' #660000000 wave3.sub_i.ctr[3:18] 0000000000100001 #660000000 wave3.sub_i.ctr2[15:0] 0000000000100001 #680000000 wave3.sub_i.ctr2[15:0] 0000000000100010 #680000000 wave3.sub_i.ctr[3:18] 0000000000100010 #680000000 wave3.a_block.c 'b' #680000000 wave3.a_block.i 00000000000000000000000000100010 #700000000 wave3.a_block.i 00000000000000000000000000100011 #700000000 wave3.a_block.c 'c' #700000000 wave3.sub_i.ctr[3:18] 0000000000100011 #700000000 wave3.sub_i.ctr2[15:0] 0000000000100011 #700000000 wave3.x[7:0] 10101010 #705000000 wave3.y[7:0] 10101010 #705000000 wave3.sub_i.y[7:0] 10101010 #720000000 wave3.sub_i.ctr2[15:0] 0000000000100100 #720000000 wave3.sub_i.ctr[3:18] 0000000000100100 #720000000 wave3.a_block.c 'a' #720000000 wave3.a_block.i 00000000000000000000000000100100 #740000000 wave3.a_block.i 00000000000000000000000000100101 #740000000 wave3.a_block.c 'b' #740000000 wave3.sub_i.ctr[3:18] 0000000000100101 #740000000 wave3.sub_i.ctr2[15:0] 0000000000100101 #750000000 wave3.x[7:0] 01010101 #755000000 wave3.sub_i.y[7:0] 01010101 #755000000 wave3.y[7:0] 01010101 #760000000 wave3.sub_i.ctr2[15:0] 0000000000100110 #760000000 wave3.sub_i.ctr[3:18] 0000000000100110 #760000000 wave3.a_block.c 'c' #760000000 wave3.a_block.i 00000000000000000000000000100110 #780000000 wave3.a_block.i 00000000000000000000000000100111 #780000000 wave3.a_block.c 'a' #780000000 wave3.sub_i.ctr[3:18] 0000000000100111 #780000000 wave3.sub_i.ctr2[15:0] 0000000000100111 #800000000 wave3.sub_i.ctr2[15:0] 0000000000101000 #800000000 wave3.sub_i.ctr[3:18] 0000000000101000 #800000000 wave3.a_block.c 'b' #800000000 wave3.a_block.i 00000000000000000000000000101000 #800000000 wave3.x[7:0] 10101010 #805000000 wave3.y[7:0] 10101010 #805000000 wave3.sub_i.y[7:0] 10101010 #820000000 wave3.a_block.i 00000000000000000000000000101001 #820000000 wave3.a_block.c 'c' #820000000 wave3.sub_i.ctr[3:18] 0000000000101001 #820000000 wave3.sub_i.ctr2[15:0] 0000000000101001 #840000000 wave3.sub_i.ctr2[15:0] 0000000000101010 #840000000 wave3.sub_i.ctr[3:18] 0000000000101010 #840000000 wave3.a_block.c 'a' #840000000 wave3.a_block.i 00000000000000000000000000101010 #850000000 wave3.x[7:0] 01010101 #855000000 wave3.sub_i.y[7:0] 01010101 #855000000 wave3.y[7:0] 01010101 #860000000 wave3.a_block.i 00000000000000000000000000101011 #860000000 wave3.a_block.c 'b' #860000000 wave3.sub_i.ctr[3:18] 0000000000101011 #860000000 wave3.sub_i.ctr2[15:0] 0000000000101011 #880000000 wave3.sub_i.ctr2[15:0] 0000000000101100 #880000000 wave3.sub_i.ctr[3:18] 0000000000101100 #880000000 wave3.a_block.c 'c' #880000000 wave3.a_block.i 00000000000000000000000000101100 #900000000 wave3.a_block.i 00000000000000000000000000101101 #900000000 wave3.a_block.c 'a' #900000000 wave3.sub_i.ctr[3:18] 0000000000101101 #900000000 wave3.sub_i.ctr2[15:0] 0000000000101101 #900000000 wave3.x[7:0] 10101010 #905000000 wave3.y[7:0] 10101010 #905000000 wave3.sub_i.y[7:0] 10101010 #920000000 wave3.sub_i.ctr2[15:0] 0000000000101110 #920000000 wave3.sub_i.ctr[3:18] 0000000000101110 #920000000 wave3.a_block.c 'b' #920000000 wave3.a_block.i 00000000000000000000000000101110 #940000000 wave3.a_block.i 00000000000000000000000000101111 #940000000 wave3.a_block.c 'c' #940000000 wave3.sub_i.ctr[3:18] 0000000000101111 #940000000 wave3.sub_i.ctr2[15:0] 0000000000101111 #950000000 wave3.x[7:0] 01010101 #955000000 wave3.sub_i.y[7:0] 01010101 #955000000 wave3.y[7:0] 01010101 #960000000 wave3.sub_i.ctr2[15:0] 0000000000110000 #960000000 wave3.sub_i.ctr[3:18] 0000000000110000 #960000000 wave3.a_block.c 'a' #960000000 wave3.a_block.i 00000000000000000000000000110000 #980000000 wave3.a_block.i 00000000000000000000000000110001 #980000000 wave3.a_block.c 'b' #980000000 wave3.sub_i.ctr[3:18] 0000000000110001 #980000000 wave3.sub_i.ctr2[15:0] 0000000000110001 #1000000000 wave3.sub_i.ctr2[15:0] 0000000000110010 #1000000000 wave3.sub_i.ctr[3:18] 0000000000110010 #1000000000 wave3.a_block.c 'c' #1000000000 wave3.a_block.i 00000000000000000000000000110010 #1000000000 wave3.x[7:0] 10101010 nvc-r1.17.1/test/regress/gold/wave3.gtkw000066400000000000000000000010531504111170000200370ustar00rootroot00000000000000-/ [color] 4 wave3.x[7:0] [color] 4 wave3.y[7:0] [color] 4 wave3.z [color] 4 wave3.o [color] 4 wave3.b [color] 4 wave3.m[1:3] [color] 4 wave3.p[1:3] [color] 4 wave3.q[3:1] [color] 4 wave3.t [color] 4 wave3.s [color] 4 wave3.s2 -/a_block/ [color] 5 wave3.a_block.i [color] 5 wave3.a_block.c -/sub_i/ [color] 6 wave3.sub_i.x[7:0] [color] 6 wave3.sub_i.y[7:0] [color] 6 wave3.sub_i.ctr[3:18] [color] 6 wave3.sub_i.ctr2[15:0] -/gen(1)/ [color] 7 wave3.gen(1).g -/gen(2)/ [color] 1 wave3.gen(2).g -/gen(3)/ [color] 2 wave3.gen(3).g -work.p/ [color] 3 work.p.s nvc-r1.17.1/test/regress/gold/wave4.dump000066400000000000000000000007641504111170000200410ustar00rootroot00000000000000#0 wave4.addr 00000000000000000000000000000000 #0 wave4.dout[7:0] UUUUUUUU #0 wave4.mem[9][7:0] UUUUUUUU #0 wave4.mem[8][7:0] UUUUUUUU #0 wave4.mem[7][7:0] UUUUUUUU #0 wave4.mem[6][7:0] UUUUUUUU #0 wave4.mem[5][7:0] UUUUUUUU #0 wave4.mem[4][7:0] UUUUUUUU #0 wave4.mem[3][7:0] UUUUUUUU #0 wave4.mem[2][7:0] 00000001 #0 wave4.mem[1][7:0] UUUUUUUU #0 wave4.mem[0][7:0] UUUUUUUU #1000000 wave4.mem[5][7:0] 01010101 #10000000 wave4.dout[7:0] 01010101 #10000000 wave4.addr 00000000000000000000000000000101 nvc-r1.17.1/test/regress/gold/wave5.dump000066400000000000000000000006261504111170000200370ustar00rootroot00000000000000#0 wave5.r.z.b 10000000000000000000000000000000 #0 wave5.r.z.a 10000000000000000000000000000000 #0 wave5.r.y[1:3] UUU #0 wave5.r.x 10000000000000000000000000000000 #1000000 wave5.r.y[1:3] 101 #2000000 wave5.r.z.a 00000000000000000000000000000110 #2000000 wave5.r.z.b 00000000000000000000000000000101 #3000000 wave5.r.z.a 00000000000000000000000000000001 #3000000 wave5.r.x 00000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/wave5.gtkw000066400000000000000000000001461504111170000200430ustar00rootroot00000000000000-/ -r: [color] 4 wave5.r.x [color] 4 wave5.r.y[1:3] -r.z: [color] 4 wave5.r.z.a [color] 4 wave5.r.z.b nvc-r1.17.1/test/regress/gold/wave6.dump000066400000000000000000000006621504111170000200400ustar00rootroot00000000000000#0 wave6.r.z.b 10000000000000000000000000000000 #0 wave6.r.z.a 10000000000000000000000000000000 #0 wave6.r.y[1:3] UUU #0 wave6.r.x 10000000000000000000000000000000 #1000000 wave6.r.y[1:3] 101 #2000000 wave6.r.z.a 00000000000000000000000000000110 #2000000 wave6.r.z.b 00000000000000000000000000000101 #3000000 wave6.r.z.a 00000000000000000000000000000001 #3000000 wave6.r.y[1:3] 010 #3000000 wave6.r.x 00000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/wave7.dump000066400000000000000000000002201504111170000200270ustar00rootroot00000000000000#0 wave7.x 10000000000000000000000000000000 #1000000 wave7.x 00000000000000000000000000000001 #2000000 wave7.x 00000000000000000000000000000010 nvc-r1.17.1/test/regress/gold/wave8.dump000066400000000000000000000000541504111170000200350ustar00rootroot00000000000000#0 wave8.u.o[1:4] 0000 #0 wave8.x[1:4] 0000 nvc-r1.17.1/test/regress/gold/wave9.dump000066400000000000000000000003131504111170000200340ustar00rootroot00000000000000$comment wave9.u.ii is aliased to x $end #0 wave9.u.oo 0 #0 wave9.y 0 #0 wave9.x 0 #1000000 wave9.x 1 #1001000 wave9.y 1 #1001000 wave9.u.oo 1 #2000000 wave9.x 0 #2001000 wave9.u.oo 0 #2001000 wave9.y 0 nvc-r1.17.1/test/regress/gold/while1.txt000066400000000000000000000001321504111170000200430ustar00rootroot000000000000000ms+0: 5 0ms+0: 4 0ms+0: 3 0ms+0: 2 0ms+0: 1 0ms+0: 0 1ns+0: 1 2ns+0: 2 3ns+0: 3 4ns+0: 4 nvc-r1.17.1/test/regress/grlib1.vhd000066400000000000000000000037301504111170000170560ustar00rootroot00000000000000entity grlib1 is end entity; architecture test of grlib1 is constant NAHBMST : integer := 16; -- maximum AHB masters constant NAHBSLV : integer := 16; -- maximum AHB slaves constant NAPBSLV : integer := 16; -- maximum APB slaves constant NAHBAMR : integer := 4; -- maximum address mapping registers constant NAHBIR : integer := 4; -- maximum AHB identification registers constant NAHBCFG : integer := NAHBIR + NAHBAMR; -- words in AHB config block subtype amba_vendor_type is integer range 0 to 16#ff#; subtype amba_device_type is integer range 0 to 16#3ff#; subtype amba_version_type is integer range 0 to 16#3f#; subtype amba_cfgver_type is integer range 0 to 3; subtype ahb_addr_type is integer range 0 to 16#fff#; subtype amba_config_word is bit_vector(31 downto 0); type ahb_config_type is array (0 to NAHBCFG-1) of amba_config_word; constant gAWidth: Positive := 18; -- address width constant zero32 : bit_vector(31 downto 0) := (others => '0'); constant HADDR: Integer := 0; constant HMASK: Integer := 16#FFF#; function ahb_device_reg(vendor : amba_vendor_type; device : amba_device_type; cfgver : amba_cfgver_type; version : amba_version_type) return bit_vector is begin return X"01234567"; end function; function ahb_membar(memaddr : ahb_addr_type; prefetch, cache : bit; addrmask : ahb_addr_type) return bit_vector is begin return (31 downto 0 => '1'); end function; constant HCONFIG : ahb_config_type := ( 0 => ahb_device_reg (0, 0, 0, gAWidth), 4 => ahb_membar(HADDR, '1', '1', HMASK), others => zero32); begin check: process is begin assert HCONFIG(0) = X"01234567"; assert HCONFIG(1) = X"00000000"; assert HCONFIG(4) = X"ffffffff"; wait; end process; end architecture; nvc-r1.17.1/test/regress/guard1.vhd000066400000000000000000000010051504111170000170520ustar00rootroot00000000000000entity guard1 is end entity; architecture test of guard1 is signal value : natural := 0; signal output : natural; begin b1: block (value < 10) is begin output <= guarded value * 2; end block; check: process is begin value <= 3; wait for 1 ns; assert output = 6; value <= 4; wait for 1 ns; assert output = 8; value <= 10; wait for 1 ns; assert output = 8; wait; end process; end architecture; nvc-r1.17.1/test/regress/guard2.vhd000066400000000000000000000015471504111170000170660ustar00rootroot00000000000000entity guard2 is end entity; architecture test of guard2 is type int_vec is array (natural range <>) of integer; function resolved (x : int_vec) return integer is begin return x'length; end function; subtype rint is resolved integer; signal vbus : rint bus; signal vreg : rint register; begin check: process is begin assert vbus = 1; assert vbus'driving; vbus <= 100; wait for 1 ns; assert vbus = 1; vbus <= null; wait for 1 ns; assert vbus = 0; assert not vbus'driving; assert vreg = 1; assert vreg'driving; vreg <= 123; wait for 1 ns; assert vreg = 1; vreg <= null; wait for 1 ns; assert vreg = 1; assert not vreg'driving; wait; end process; end architecture; nvc-r1.17.1/test/regress/guard3.vhd000066400000000000000000000010641504111170000170610ustar00rootroot00000000000000entity guard3 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of guard3 is signal s : std_logic bus := 'H'; begin p1: process is begin assert s = 'H'; s <= '0'; wait for 1 ns; assert s = '0'; s <= null after 5 ns; wait for 1 ns; assert s = '0'; wait for 5 ns; assert s = 'Z'; s <= '1' after 1 ns; wait for 0 ns; assert s = 'Z'; wait for 1 ns; assert s = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/guard4.vhd000066400000000000000000000020101504111170000170520ustar00rootroot00000000000000entity guard4 is end entity; architecture test of guard4 is type t_nat_vec is array (natural range <>) of natural; function resolved (x : t_nat_vec) return natural is variable r : natural; begin for i in x'range loop if x(i) > r then r := x(i); end if; end loop; return r; end function; subtype rnatural is resolved natural; signal value : natural := 0; signal output : rnatural bus; disconnect output : rnatural after 2 ns; begin b1: block (value < 10) is begin with value select output <= guarded 42 when 3, value * 2 when others; end block; check: process is begin value <= 3; wait for 1 ns; assert output = 42; value <= 4; wait for 1 ns; assert output = 8; value <= 10; wait for 1 ns; assert output = 8; wait for 1 ns; assert output = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/guard5.vhd000066400000000000000000000014571504111170000170710ustar00rootroot00000000000000entity guard5 is end entity; architecture test of guard5 is type int_vec is array (natural range <>) of integer; function resolved (x : int_vec) return integer is begin return x'length; end function; subtype rint is resolved integer; signal vbus : rint bus; begin b: block is port ( pbus : inout rint bus ); port map ( vbus ); begin check: process is begin assert pbus = 1; assert pbus'driving; pbus <= 100; wait for 1 ns; assert pbus = 1; pbus <= null; wait for 1 ns; assert pbus = 1 severity warning; -- XXX: wrong assert not pbus'driving; wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/ieee1.vhd000066400000000000000000000012601504111170000166620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity ieee1 is end entity; architecture test of ieee1 is begin process is variable a, b, c : std_logic_vector(3 downto 0); variable d : std_logic_vector(5 downto 0); begin a := ( '0', '1', '0', '0' ); b := ( '1', '0', '1', '0' ); assert_a: assert ((a(3) or b(3)) = '1') report "a"; c := (a or b); assert c(3) = '1' report "c(3)"; assert c(0) = '0' report "c(0)"; assert_b: assert c = ( '1', '1', '1', '0' ) report "b"; d(4 downto 1) := (a or b); assert d = ( 'U', '1', '1', '1', '0', 'U' ); wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee10.vhd000066400000000000000000000025471504111170000167530ustar00rootroot00000000000000-- file numeric_std_tb1.vhd is a simulation testbench for -- IEEE 1076.3 numeric_std package. -- This is the first in a series of testbenches. -- library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity ieee10 is generic ( quiet : boolean := false); -- make the simulation quiet end entity ieee10; architecture t1 of ieee10 is begin process -- required A15_38 variable res4,sgn4: signed(3 downto 0); variable sgn6: signed(5 downto 0); variable res8: signed(7 downto 0); variable sgn10,res10:signed(9 downto 0); variable ures4,uns4: unsigned(1 to 4); variable uns6: unsigned(2 to 7); variable uns8: unsigned(0 to 7); variable uns10,ures10:unsigned(1 to 10); begin -- Id: A.21, A.23, and A.24 for i in 0 to 1023 loop uns10:=to_unsigned(i,10); for j in 1 to 15 loop uns4:=to_unsigned(j,4); ures10:=uns10/uns4; assert to_integer(ures10)=i/j report "A.21 fails" severity FAILURE; ures10:=uns10/j; assert to_integer(ures10)=i/j report "A.23 fails" severity FAILURE; ures10:=i/("000000"&uns4); assert to_integer(ures10)=i/j report "A.24 fails" severity FAILURE; end loop; end loop; if now < 2 ns then wait for 1 ns; else wait; end if; end process; end architecture t1; nvc-r1.17.1/test/regress/ieee11.vhd000066400000000000000000000055601504111170000167520ustar00rootroot00000000000000entity ieee11 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of ieee11 is signal s1 : std_logic_vector(16 downto 0) := "U01HLX-ZW101010X1"; signal s2 : unsigned(16 downto 0) := "U01HLX-ZW101010X1"; signal s3 : unsigned(31 downto 0) := X"12345678"; signal s4 : unsigned(0 downto 1); signal s5 : signed(15 downto 0) := to_signed(-1000, 16); signal s6 : signed(0 downto 1); signal s7 : unsigned(7 downto 0) := X"10"; signal s8 : unsigned(16 downto 0) := '0' & X"0010"; signal s9 : unsigned(1 to 8) := X"05"; signal s10 : std_logic_vector(200 downto 0) := (others => '0'); function is_null (x : unsigned) return boolean is begin return x'length = 0; end function; function is_null (x : signed) return boolean is begin return x'length = 0; end function; begin tb: process is variable five : integer := 5; variable one : integer := 1; begin assert to_x01(s1) = "X0110XXXX101010X1"; assert to_01(s2, '0') = (16 downto 0 => '0'); assert to_01(s3, '0') = X"12345678"; assert is_null(to_01(s4)); assert to_01(unsigned'("LLLLLLLLL"), '0') = "0000"; assert resize(s3, 40) = X"0012345678"; assert resize(s3, 32) = X"12345678"; assert resize(s3, 8) = X"78"; assert is_null(resize(s3, 0)); assert resize(s5, 8) = "10011000"; assert resize(s5, 20) = "11111111110000011000"; assert is_null(resize(s5, 0)); assert resize(s6, 8) = X"00"; assert s7 + 0 = s7; assert s7 + 1 = X"11"; assert s7 + 5 = X"15"; assert 0 + s7 = s7; assert 1 + s7 = X"11"; assert 5 + s7 = X"15"; assert s7 + X"001" = X"011"; assert s7 + X"f0" = X"00"; assert s7 + X"22" = X"32"; assert s8 + X"ffff" = "10000000000001111"; assert (X"0000" + to_signed(-1, 4)) = X"ffff"; assert (s1 and s1) = "U0110XXXX101010X1"; assert (s1 or s1) = "U0110XXXX101010X1"; assert (s1 xor s1) = "U0000XXXX000000X0"; assert to_unsigned(five, 8) = X"05"; assert to_unsigned(five, 16) = X"0005"; assert to_unsigned(five, 80) = X"00000000000000000005"; assert to_unsigned(five, 9) = "000000101"; assert to_unsigned(five, 2) = "01"; assert to_signed(five, 8) = X"05"; assert to_signed(-five, 8) = "11111011"; assert to_signed(-five, 80) = X"fffffffffffffffffb"; assert to_signed(-five, 2) = "11"; assert to_signed(one, 1) = "1"; assert s7 * 5 = X"50"; assert s9 * 2 = X"0a"; assert std_logic_vector(s7 * "UU") = "XXXXXXXXXX"; assert s5 * X"ffff" = 1000; assert s7 - s9 = X"0b"; assert s5 - 1 = -1001; assert s10 = (1 to 201 => '0'); wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee12.vhd000066400000000000000000001254331504111170000167550ustar00rootroot00000000000000-------------- test case header ------ --! Test intent : Coverage of standards. --! Test scope : abs a1 Nul input. --! Keywords : [operations, abs] --! References : [VH2008 16.6] --! [Rlink : REQ08xx] ----------------------------------------------- -- tb1 A15 - a38 from bishop tests. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity ieee12 is generic ( quiet : boolean := false); -- make the simulation quiet end entity; architecture ops of ieee12 is signal ANULL: UNSIGNED (0 downto 1); signal BNULL: UNSIGNED (0 downto 1); signal SANULL: SIGNED (0 downto 1); signal SBNULL: SIGNED (0 downto 1); begin process -- required A15_38 variable res4,sgn4: signed(3 downto 0); variable sgn6: signed(5 downto 0); variable res8: signed(7 downto 0); variable sgn10,res10:signed(9 downto 0); variable ures4,uns4: unsigned(1 to 4); variable uns6: unsigned(2 to 7); variable uns8: unsigned(0 to 7); variable uns10,ures10:unsigned(1 to 10); begin assert quiet report "start of tests" severity note; -- ************************************************ -- ************************************************ -- A15_38 tests from Kingsley :::::: -- A.15 tests for i in 0 to 63 loop uns6:=to_unsigned(i,6); for j in 0 to 15 loop uns4:=to_unsigned(j,4); uns10:=uns6*uns4; -- A.15 assert to_integer(uns10)=i*j report "A.15 fails 6x4" severity FAILURE; assert uns4*uns6=uns10 report "A.15 fails 4x6" severity FAILURE; end loop; end loop; assert quiet report "A.15 test done" severity note; -- A.16 tests for i in -32 to 31 loop sgn6:=to_signed(i,6); for j in -8 to 7 loop sgn4:=to_signed(j,4); res10:=sgn6*sgn4; -- A.16 assert to_integer(res10)=i*j report "A.16 fails 6x4" severity FAILURE; assert sgn4*sgn6=res10 report "A.16 fails 4x6" severity FAILURE; end loop; end loop; assert quiet report "A.16 test done" severity note; -- A.17 and A.18 tests for i in 0 to 15 loop uns4:=to_unsigned(i,4); assert (i/=8 or uns4="1000") and (i/=9 or uns4="1001") and (i/=15 or uns4="1111") and (i/=0 or uns4="0000") and (i/=3 or uns4="0011") and (i/=7 or uns4="0111") and (to_integer(uns4)=i); for j in 0 to 15 loop -- exaustively test 4x4 case uns8:=j*uns4; -- A.18 assert to_integer(uns8)=(i*j) report "A.18 fails" severity FAILURE; uns8:=uns4*j; -- A.17 assert to_integer(uns8)=(i*j) report "A.17 fails" severity FAILURE; end loop; -- uns8:=19*uns4; -- A.18; may note overflow of conversion -- assert to_integer(uns8)=(3*i) report "A.18 fails" severity FAILURE; -- uns8:=uns4*21; -- A.17; may note overflow of conversion -- assert to_integer(uns8)=(5*i) report "A.17 fails" severity FAILURE; end loop; assert quiet report "A.17, A.18 tests done" severity note; -- A.19 and A.20 tests for i in -8 to 7 loop sgn4:=to_signed(i,4); assert (i/=-8 or sgn4="1000") and (i/=-7 or sgn4="1001") and (i/=-1 or sgn4="1111") and (i/=0 or sgn4="0000") and (i/=3 or sgn4="0011") and (i/=7 or sgn4="0111") and (to_integer(sgn4)=i); for j in -8 to 7 loop -- exaustively test 4x4 case res8:=j*sgn4; -- A.20 assert to_integer(res8)=(i*j) report "A.20 fails" severity FAILURE; res8:=sgn4*j; -- A.19 assert to_integer(res8)=(i*j) report "A.19 fails" severity FAILURE; end loop; -- res8:=19*sgn4; -- A.20; may note overflow of conversion -- assert to_integer(res8)=(3*i) report "A.20 fails" severity FAILURE; -- res8:=sgn4*21; -- A.21; may note overflow of conversion -- assert to_integer(res8)=(5*i) report "A.19 fails" severity FAILURE; end loop; assert quiet report "A.19, A.20 tests done" severity note; -- Id: A.21, A.23, and A.24 for i in 0 to 1023 loop uns10:=to_unsigned(i,10); for j in 1 to 15 loop uns4:=to_unsigned(j,4); ures10:=uns10/uns4; assert to_integer(ures10)=i/j report "A.21 fails" severity FAILURE; ures10:=uns10/j; assert to_integer(ures10)=i/j report "A.23 fails" severity FAILURE; ures10:=i/("000000"&uns4); assert to_integer(ures10)=i/j report "A.24 fails" severity FAILURE; end loop; end loop; -- These examples test interesting parts of other division algorithms. -- They are not particularly targeted to the division algorithm in the -- numeric packages. -- (These are two examples of the pentium's FDIV bug.) assert (to_unsigned(5505001,23)&"0000000000000000")/to_unsigned(294911,19) ="100101010101010101001" -- =(5505001*65536/294911) report "A.21 fails ex.1" severity FAILURE; assert (to_unsigned(4195835,23)&"0000000000000000")/to_unsigned(3145727,22) ="10101010101110101" -- =(4195835*65536/3145727); report "A.21 fails ex.2" severity FAILURE; -- These examples exercise interesting parts of Knuth's Algorithm D, in -- Seminumerical Algorithms, section 4.3.2, when B is 256. assert (to_unsigned(112893473,28)/to_unsigned(19607,16))=to_unsigned(5757,16) report "A.21 fails ex.3" severity FAILURE; assert (to_unsigned(96419675,28)/to_unsigned(34257,16))=to_unsigned(2814,12) report "A.21 fails ex.4" severity FAILURE; assert (to_unsigned(244699666,28)/to_unsigned(59746,16))=to_unsigned(4095,13) report "A.21 fails ex.5" severity FAILURE; assert quiet report "A.21, A.23, A.24 tests done" severity note; -- Id: A.22, A.25 and A.26 for i in -512 to 511 loop sgn10:=to_signed(i,10); for j in -8 to 7 loop next when j=0; sgn4:=to_signed(j,4); res10:=sgn10/sgn4; -- the exception is because -512 overflows when it is negated. assert to_integer(res10)=i/j or (i=-512 and j=-1 and res10=-512) report "A.22 fails"; res10:=sgn10/j; assert to_integer(res10)=i/j or (i=-512 and j=-1 and res10=-512) report "A.25 fails" severity FAILURE; res10:=i/resize(sgn4,10); assert to_integer(res10)=i/j or (i=-512 and j=-1 and res10=-512) report "A.26 fails" severity FAILURE; end loop; end loop; -- (These are two examples of the pentium's FDIV bug.) assert (to_signed(5505001,24)&"0000000000000000")/to_signed(294911,20) ="0100101010101010101001" -- =(5505001*65536/294911) report "A.22 fails p1" severity FAILURE; assert (to_signed(-4195835,24)&"0000000000000000")/to_signed(3145727,23) ="11101010101010001011" -- =(4195835*65536/3145727); report "A.22 fails p2" severity FAILURE; assert quiet report "A.22, A.25, A.26 tests done" severity note; -- Id: A.27, A.29 and A.30 for i in 0 to 1023 loop uns10:=to_unsigned(i,10); for j in 1 to 15 loop uns4:=to_unsigned(j,4); ures4:=uns10 rem uns4; assert to_integer(ures4)=i rem j report "A.27 fails" severity FAILURE; ures10:=uns10 rem j; assert to_integer(ures10)=i rem j report "A.29 fails" severity FAILURE; ures10:=i rem ("000000"&uns4); assert to_integer(ures10)=i rem j report "A.30 fails" severity FAILURE; end loop; end loop; assert quiet report "A.27, A.29, A.30 tests done" severity note; -- Id: A.28, A.31 and A.32 for i in -512 to 511 loop sgn10:=to_signed(i,10); for j in -8 to 7 loop next when j=0; sgn4:=to_signed(j,4); res10:=resize((sgn10 rem sgn4),res10'length); assert to_integer(res10)=i rem j report "A.28 fails" severity FAILURE; res10:=sgn10 rem j; assert to_integer(res10)=i rem j report "A.31 fails" severity FAILURE; res10:=i rem resize(sgn4,10); assert to_integer(res10)=i rem j report "A.32 fails" severity FAILURE; end loop; end loop; assert quiet report "A.28, A.31, A.32 tests done" severity note; -- Id: A.33, A.35 and A.36 for i in 0 to 1023 loop uns10:=to_unsigned(i,10); for j in 1 to 15 loop uns4:=to_unsigned(j,4); ures10:=resize((uns10 mod uns4),ures10'length); assert to_integer(ures10)=i mod j report "A.33 fails" severity FAILURE; ures10:=uns10 mod j; assert to_integer(ures10)=i mod j report "A.35 fails" severity FAILURE; ures10:=i mod ("000000"&uns4); assert to_integer(ures10)=i mod j report "A.36 fails" severity FAILURE; end loop; end loop; assert quiet report "A.33, A.35, A.36 tests done" severity note; -- Id: A.34, A.37 and A.38 for i in -512 to 511 loop sgn10:=to_signed(i,10); for j in -8 to 7 loop next when j=0; sgn4:=to_signed(j,4); res10:=resize((sgn10 mod sgn4),res10'length); assert to_integer(res10)=i mod j report "A.34 fails" severity FAILURE; res10:=sgn10 mod j; assert to_integer(res10)=i mod j report "A.37 fails" severity FAILURE; res10:=i mod resize(sgn4,10); assert to_integer(res10)=i mod j report "A.38 fails" severity FAILURE; end loop; end loop; assert quiet report "A.34, A.37, A.38 tests done" severity note; -- ************************************************ -- ************************************************ -- C13_24 tests from Bhasker :::::: -- STD_C.13 tests: assert UNSIGNED'("0001") <= UNSIGNED'("0010") report "Test STD_C.13.1 failing." severity FAILURE; assert UNSIGNED'("01") <= UNSIGNED'("1010") report "Test STD_C.13.2 failing." severity FAILURE; assert UNSIGNED'("000001") <= UNSIGNED'("111") report "Test STD_C.13.3 failing." severity FAILURE; assert UNSIGNED'("010") <= UNSIGNED'("010") report "Test STD_C.13.5 failing." severity FAILURE; assert UNSIGNED'("00010010") <= UNSIGNED'("10010") report "Test STD_C.13.8 failing." severity FAILURE; assert UNSIGNED'("10") <= UNSIGNED'("0010") report "Test STD_C.13.9 failing." severity FAILURE; assert not (UNSIGNED'("110001") <= UNSIGNED'("100010")) report "Test STD_C.13.4 failing." severity FAILURE; assert not(UNSIGNED'("1111") <= UNSIGNED'("0001010")) report "Test STD_C.13.6 test failing." severity FAILURE; assert not(UNSIGNED'("10001000") <= UNSIGNED'("11")) report "Test STD_C.13.7 test failing." severity FAILURE; assert not(UNSIGNED'("110") <= UNSIGNED'("011")) report "Test STD_C.13.10 failing." severity FAILURE; assert not(UNSIGNED'("10010010") <= UNSIGNED'("10010")) report "Test STD_C.13.11 failing." severity FAILURE; assert not(UNSIGNED'("110") <= UNSIGNED'("LLHL")) report "Test STD_C.13.12 failing." severity FAILURE; if (not quiet) then assert not ( UNSIGNED'("110") <= BNULL) report "Test STD_C.13.13 failing." severity FAILURE; assert not (BNULL <= ANULL) report "Test STD_C.13.14 failing." severity FAILURE; end if; if (not quiet) then assert not (UNSIGNED'("10001") <= UNSIGNED'("10X0")) report "Test STD_C.13.15 failing." severity FAILURE; assert not (UNSIGNED'("1HHHLLXX0") <= UNSIGNED'("100")) report "Test STD_C.13.16 failing." severity FAILURE; end if; assert quiet report "C.13 tests done" severity note; --STD_C.14 tests: assert SIGNED'("0001") <= SIGNED'("0010") report "Test STD_C.14.1 failing." severity FAILURE; assert SIGNED'("01") <= SIGNED'("01010") report "Test STD_C.14.2 failing." severity FAILURE; assert SIGNED'("000001") <= SIGNED'("0111") report "Test STD_C.14.3 failing." severity FAILURE; assert SIGNED'("111100") <= SIGNED'("11100") report "Test STD_C.14.15 failing." severity FAILURE; assert SIGNED'("111100") <= SIGNED'("011100") report "Test STD_C.14.16 failing." severity FAILURE; assert SIGNED'("010") <= SIGNED'("010") report "Test STD_C.14.5 failing." severity FAILURE; assert SIGNED'("10000010") <= SIGNED'("111110010") report "Test STD_C.14.8 failing." severity FAILURE; assert SIGNED'("10") <= SIGNED'("0010") report "Test STD_C.14.9 failing." severity FAILURE; assert SIGNED'("00") <= SIGNED'("0000") report "Test STD_C.14.17 failing." severity FAILURE; assert SIGNED'("11100001100") <= SIGNED'("0000") report "Test STD_C.14.18 failing." severity FAILURE; assert not (SIGNED'("110001") <= SIGNED'("100010")) report "Test STD_C.14.4 failing." severity FAILURE; assert not(SIGNED'("1111") <= SIGNED'("1001010")) report "Test STD_C.14.6 test failing." severity FAILURE; assert not(SIGNED'("11") <= SIGNED'("10001000")) report "Test STD_C.14.7 test failing." severity FAILURE; assert not(SIGNED'("0110") <= SIGNED'("10001000")) report "Test STD_C.14.19 test failing." severity FAILURE; assert not(SIGNED'("010") <= SIGNED'("110")) report "Test STD_C.14.10 failing." severity FAILURE; assert not(SIGNED'("1001") <= SIGNED'("100100010")) report "Test STD_C.14.11 failing." severity FAILURE; assert not(SIGNED'("110") <= SIGNED'("10010")) report "Test STD_C.14.12 failing." severity FAILURE; assert not(SIGNED'("00000110") <= SIGNED'("0000")) report "Test STD_C.14.20 failing." severity FAILURE; if (not quiet) then assert not (SIGNED'("1HL") <= SBNULL) report "Test STD_C.14.13 failing." severity FAILURE; assert not (SBNULL <= SANULL) report "Test STD_C.14.14 failing." severity FAILURE; end if; if (not quiet) then assert not (SIGNED'("10001") <= SIGNED'("1HX-")) report "Test STD_C.14.21 failing." severity FAILURE; assert not (SIGNED'("1-------0") <= SIGNED'("100")) report "Test STD_C.14.22 failing." severity FAILURE; end if; assert quiet report "C.14 tests done" severity note; -- STD_C.17 tests assert UNSIGNED'("0001") <= 2 report "Test STD_C.17.1 failing." severity FAILURE; assert UNSIGNED'("01") <= 10 report "Test STD_C.17.2 failing." severity FAILURE; assert UNSIGNED'("000001") <= 7 report "Test STD_C.17.3 failing." severity FAILURE; assert UNSIGNED'("010") <= 2 report "Test STD_C.17.5 failing." severity FAILURE; assert UNSIGNED'("00010010") <= 18 report "Test STD_C.17.8 failing." severity FAILURE; assert UNSIGNED'("10") <= 2 report "Test STD_C.17.9 failing." severity FAILURE; assert not (UNSIGNED'("110001") <= 34) report "Test STD_C.17.4 failing." severity FAILURE; assert not(UNSIGNED'("1111") <= 10) report "Test STD_C.17.6 test failing." severity FAILURE; assert not(UNSIGNED'("10001000") <= 3) report "Test STD_C.17.7 test failing." severity FAILURE; assert not(UNSIGNED'("110") <= 3) report "Test STD_C.17.10 failing." severity FAILURE; assert not(UNSIGNED'("10010010") <= 18) report "Test STD_C.17.11 failing." severity FAILURE; assert not(UNSIGNED'("110") <= 2) report "Test STD_C.17.12 failing." severity FAILURE; assert (UNSIGNED'("HHL") <= 10000) report "Test STD_C.17.13 failing." severity FAILURE; if (not quiet) then assert not ( BNULL <= 0) report "Test STD_C.17.14 failing." severity FAILURE; assert not (UNSIGNED'("XUUZZ1WW0") <= 100) report "Test STD_C.17.15 failing." severity FAILURE; end if; assert quiet report "C.17 tests done" severity note; -- STD_C.18 tests assert SIGNED'("0001") <= 2 report "Test STD_C.18.1 failing." severity FAILURE; assert SIGNED'("01") <= 10 report "Test STD_C.18.2 failing." severity FAILURE; assert SIGNED'("100001") <= 7 report "Test STD_C.18.3 failing." severity FAILURE; assert SIGNED'("111100") <= -4 report "Test STD_C.18.15 failing." severity FAILURE; assert SIGNED'("111100") <= 28 report "Test STD_C.18.16 failing." severity FAILURE; assert SIGNED'("010") <= 2 report "Test STD_C.18.5 failing." severity FAILURE; assert SIGNED'("HLLLH0010") <= -14 report "Test STD_C.18.8 failing." severity FAILURE; assert SIGNED'("10") <= 2 report "Test STD_C.18.9 failing." severity FAILURE; assert SIGNED'("00") <= 0 report "Test STD_C.18.17 failing." severity FAILURE; assert SIGNED'("11100001100") <= -0 report "Test STD_C.18.18 failing." severity FAILURE; assert not (SIGNED'("110001") <= -30) report "Test STD_C.18.4 failing." severity FAILURE; assert not(SIGNED'("01111") <= +10) report "Test STD_C.18.6 test failing." severity FAILURE; assert not(SIGNED'("1100") <= -9) report "Test STD_C.18.7 test failing." severity FAILURE; assert not(SIGNED'("010001LLL") <= 3) report "Test STD_C.18.19 test failing." severity FAILURE; assert not(SIGNED'("0110") <= 3) report "Test STD_C.18.10 failing." severity FAILURE; assert not(SIGNED'("110") <= -15) report "Test STD_C.18.11 failing." severity FAILURE; assert not(SIGNED'("0110") <= 2) report "Test STD_C.18.12 failing." severity FAILURE; assert not(SIGNED'("00000110") <= 0) report "Test STD_C.18.20 failing." severity FAILURE; assert not (SIGNED'("0110") <= 0) report "Test STD_C.18.13 failing." severity FAILURE; if (not quiet) then assert not (SIGNED'("110") <= -1000000) report "Test STD_C.18.14 failing." severity FAILURE; assert not (SIGNED'("-0XZZZZW0") <= 100) report "Test STD_C.18.21 failing." severity FAILURE; end if; assert quiet report "C.18 tests done" severity note; -- STD_C.15 tests assert 1 <= UNSIGNED'("0010") report "Test STD_C.15.1 failing." severity FAILURE; assert 1 <= UNSIGNED'("1LHL") report "Test STD_C.15.2 failing." severity FAILURE; assert 1 <= UNSIGNED'("111") report "Test STD_C.15.3 failing." severity FAILURE; assert 2 <= UNSIGNED'("010") report "Test STD_C.15.5 failing." severity FAILURE; assert 18 <= UNSIGNED'("10010") report "Test STD_C.15.8 failing." severity FAILURE; assert 2 <= UNSIGNED'("0010") report "Test STD_C.15.9 failing." severity FAILURE; assert not (49 <= UNSIGNED'("100010")) report "Test STD_C.15.4 failing." severity FAILURE; assert not(15 <= UNSIGNED'("0001010")) report "Test STD_C.15.6 test failing." severity FAILURE; assert not(151 <= UNSIGNED'("11")) report "Test STD_C.15.7 test failing." severity FAILURE; assert not(6 <= UNSIGNED'("0HH")) report "Test STD_C.15.10 failing." severity FAILURE; assert not(256 <= UNSIGNED'("10010")) report "Test STD_C.15.11 failing." severity FAILURE; assert not(6 <= UNSIGNED'("0010")) report "Test STD_C.15.12 failing." severity FAILURE; if (not quiet) then assert not (8 <= BNULL) report "Test STD_C.15.13 failing." severity FAILURE; end if; assert not (3267 <= UNSIGNED'("111")) report "Test STD_C.15.14 failing." severity FAILURE; if (not quiet) then assert not (256 <= UNSIGNED'("-L")) report "Test STD_C.15.15 failing." severity FAILURE; end if; assert quiet report "C.15 tests done" severity note; -- STD_C.16 tests: assert 1 <= SIGNED'("0010") report "Test STD_C.16.1 failing." severity FAILURE; assert 8 <= SIGNED'("LHLH0") report "Test STD_C.16.2 failing." severity FAILURE; assert 1 <= SIGNED'("0111") report "Test STD_C.16.3 failing." severity FAILURE; assert -4 <= SIGNED'("11100") report "Test STD_C.16.15 failing." severity FAILURE; assert -4 <= SIGNED'("011100") report "Test STD_C.16.16 failing." severity FAILURE; assert 2 <= SIGNED'("010") report "Test STD_C.16.5 failing." severity FAILURE; assert -14 <= SIGNED'("10010") report "Test STD_C.16.8 failing." severity FAILURE; assert -2 <= SIGNED'("0010") report "Test STD_C.16.9 failing." severity FAILURE; assert 0 <= SIGNED'("0000") report "Test STD_C.16.17 failing." severity FAILURE; assert -2048 <= SIGNED'("0000") report "Test STD_C.16.18 failing." severity FAILURE; assert not (-15 <= SIGNED'("100010")) report "Test STD_C.16.4 failing." severity FAILURE; assert not(1 <= SIGNED'("10001010")) report "Test STD_C.16.6 test failing." severity FAILURE; assert not(-345 <= SIGNED'("H00L1L00111")) report "Test STD_C.16.7 test failing." severity FAILURE; assert not(-1024 <= SIGNED'("1000000111111")) report "Test STD_C.16.19 test failing." severity FAILURE; assert not(-2 <= SIGNED'("1000011")) report "Test STD_C.16.10 failing." severity FAILURE; assert not(-63 <= SIGNED'("10000010")) report "Test STD_C.16.11 failing." severity FAILURE; assert not(-2 <= SIGNED'("HLHL")) report "Test STD_C.16.12 failing." severity FAILURE; assert not(0 <= SIGNED'("1000")) report "Test STD_C.16.20 failing." severity FAILURE; if (not quiet) then assert not (-7 <= SBNULL) report "Test STD_C.16.13 failing." severity FAILURE; end if; assert not (-6457 <= SIGNED'("100000000000000010")) report "Test STD_C.16.14 failing." severity FAILURE; if (not quiet) then assert not (256 <= SIGNED'("HX")) report "Test STD_C.16.21 failing." severity FAILURE; end if; assert quiet report "C.16 tests done" severity note; -- STD_C.19 tests: assert UNSIGNED'("0010") >= UNSIGNED'("0LL1") report "Test STD_C.19.1 failing." severity FAILURE; assert UNSIGNED'("1010") >= UNSIGNED'("01") report "Test STD_C.19.2 failing." severity FAILURE; assert UNSIGNED'("111") >= UNSIGNED'("00000H") report "Test STD_C.19.3 failing." severity FAILURE; assert UNSIGNED'("010") >= UNSIGNED'("010") report "Test STD_C.19.5 failing." severity FAILURE; assert UNSIGNED'("10010") >= UNSIGNED'("00010010") report "Test STD_C.19.8 failing." severity FAILURE; assert UNSIGNED'("0010") >= UNSIGNED'("HL") report "Test STD_C.19.9 failing." severity FAILURE; assert not (UNSIGNED'("100010") >= UNSIGNED'("110001")) report "Test STD_C.19.4 failing." severity FAILURE; assert not(UNSIGNED'("0001010") >= UNSIGNED'("1111")) report "Test STD_C.19.6 test failing." severity FAILURE; assert not(UNSIGNED'("11") >= UNSIGNED'("10001000")) report "Test STD_C.19.7 test failing." severity FAILURE; assert not(UNSIGNED'("011") >= UNSIGNED'("110")) report "Test STD_C.19.10 failing." severity FAILURE; assert not(UNSIGNED'("10010") >= UNSIGNED'("10010010")) report "Test STD_C.19.11 failing." severity FAILURE; assert not(UNSIGNED'("0010") >= UNSIGNED'("110")) report "Test STD_C.19.12 failing." severity FAILURE; if (not quiet) then assert not (BNULL >= UNSIGNED'("110")) report "Test STD_C.19.13 failing." severity FAILURE; assert not (ANULL >= BNULL) report "Test STD_C.19.14 failing." severity FAILURE; end if; if (not quiet) then assert not (UNSIGNED'("10X0") >= UNSIGNED'("10001")) report "Test STD_C.19.15 failing." severity FAILURE; assert not (UNSIGNED'("100") >= UNSIGNED'("1HHHLLXX0")) report "Test STD_C.19.16 failing." severity FAILURE; end if; assert quiet report "C.19 tests done" severity note; --STD_C.20 tests: assert SIGNED'("0010") >= SIGNED'("0001") report "Test STD_C.20.1 failing." severity FAILURE; assert SIGNED'("01010") >= SIGNED'("01") report "Test STD_C.20.2 failing." severity FAILURE; assert SIGNED'("0111") >= SIGNED'("000001") report "Test STD_C.20.3 failing." severity FAILURE; assert SIGNED'("11100") >= SIGNED'("HHHHLL") report "Test STD_C.20.15 failing." severity FAILURE; assert SIGNED'("011100") >= SIGNED'("111100") report "Test STD_C.20.16 failing." severity FAILURE; assert SIGNED'("010") >= SIGNED'("010") report "Test STD_C.20.5 failing." severity FAILURE; assert SIGNED'("111110010") >= SIGNED'("10000010") report "Test STD_C.20.8 failing." severity FAILURE; assert SIGNED'("0010") >= SIGNED'("10") report "Test STD_C.20.9 failing." severity FAILURE; assert SIGNED'("0000") >= SIGNED'("00") report "Test STD_C.20.17 failing." severity FAILURE; assert SIGNED'("0000") >= SIGNED'("11100001100") report "Test STD_C.20.18 failing." severity FAILURE; assert not (SIGNED'("100010") >= SIGNED'("110001")) report "Test STD_C.20.4 failing." severity FAILURE; assert not(SIGNED'("1001010") >= SIGNED'("1111")) report "Test STD_C.20.6 test failing." severity FAILURE; assert not(SIGNED'("10001000") >= SIGNED'("11")) report "Test STD_C.20.7 test failing." severity FAILURE; assert not(SIGNED'("HLLLHLLL") >= SIGNED'("0110")) report "Test STD_C.20.19 test failing." severity FAILURE; assert not(SIGNED'("110") >= SIGNED'("010")) report "Test STD_C.20.10 failing." severity FAILURE; assert not(SIGNED'("100100010") >= SIGNED'("1001")) report "Test STD_C.20.11 failing." severity FAILURE; assert not(SIGNED'("10010") >= SIGNED'("110")) report "Test STD_C.20.12 failing." severity FAILURE; assert not(SIGNED'("0000") >= SIGNED'("00000110")) report "Test STD_C.20.20 failing." severity FAILURE; if (not quiet) then assert not (SBNULL >= SIGNED'("110")) report "Test STD_C.20.13 failing." severity FAILURE; assert not (SANULL >= SBNULL) report "Test STD_C.20.14 failing." severity FAILURE; end if; if (not quiet) then assert not (SIGNED'("1HX-") >= SIGNED'("10001")) report "Test STD_C.20.21 failing." severity FAILURE; assert not (SIGNED'("100") >= SIGNED'("1-------0")) report "Test STD_C.20.22 failing." severity FAILURE; end if; assert quiet report "C.20 tests done" severity note; -- STD_C.21 tests assert 2 >= UNSIGNED'("0001") report "Test STD_C.21.1 failing." severity FAILURE; assert 10 >= UNSIGNED'("01") report "Test STD_C.21.2 failing." severity FAILURE; assert 7 >= UNSIGNED'("000001") report "Test STD_C.21.3 failing." severity FAILURE; assert 2 >= UNSIGNED'("010") report "Test STD_C.21.5 failing." severity FAILURE; assert 18 >= UNSIGNED'("00010010") report "Test STD_C.21.8 failing." severity FAILURE; assert 2 >= UNSIGNED'("HL") report "Test STD_C.21.9 failing." severity FAILURE; assert not (34 >= UNSIGNED'("110001")) report "Test STD_C.21.4 failing." severity FAILURE; assert not(10 >= UNSIGNED'("1111")) report "Test STD_C.21.6 test failing." severity FAILURE; assert not(3 >= UNSIGNED'("10001000")) report "Test STD_C.21.7 test failing." severity FAILURE; assert not(3 >= UNSIGNED'("110")) report "Test STD_C.21.10 failing." severity FAILURE; assert not(18 >= UNSIGNED'("10010010")) report "Test STD_C.21.11 failing." severity FAILURE; assert not(2 >= UNSIGNED'("110")) report "Test STD_C.21.12 failing." severity FAILURE; assert (10000 >= UNSIGNED'("110")) report "Test STD_C.21.13 failing." severity FAILURE; if (not quiet) then assert not ( 0 >= BNULL) report "Test STD_C.21.14 failing." severity FAILURE; end if; if (not quiet) then assert not (100 >= UNSIGNED'("XUUZZ1WW0")) report "Test STD_C.21.15 failing." severity FAILURE; end if; assert quiet report "C.21 tests done" severity note; -- STD_C.22 tests assert 2 >= SIGNED'("LLLH") report "Test STD_C.22.1 failing." severity FAILURE; assert 10 >= SIGNED'("01") report "Test STD_C.22.2 failing." severity FAILURE; assert 7 >= SIGNED'("100001") report "Test STD_C.22.3 failing." severity FAILURE; assert -4 >= SIGNED'("111100") report "Test STD_C.22.15 failing." severity FAILURE; assert 28 >= SIGNED'("111100") report "Test STD_C.22.16 failing." severity FAILURE; assert 2 >= SIGNED'("010") report "Test STD_C.22.5 failing." severity FAILURE; assert -14 >= SIGNED'("100010010") report "Test STD_C.22.8 failing." severity FAILURE; assert 2 >= SIGNED'("10") report "Test STD_C.22.9 failing." severity FAILURE; assert 0 >= SIGNED'("00") report "Test STD_C.22.17 failing." severity FAILURE; assert -0 >= SIGNED'("11100001100") report "Test STD_C.22.18 failing." severity FAILURE; assert not (-30 >= SIGNED'("110001")) report "Test STD_C.22.4 failing." severity FAILURE; assert not(+10 >= SIGNED'("01111")) report "Test STD_C.22.6 test failing." severity FAILURE; assert not(-9 >= SIGNED'("1100")) report "Test STD_C.22.7 test failing." severity FAILURE; assert not(3 >= SIGNED'("010001000")) report "Test STD_C.22.19 test failing." severity FAILURE; assert not(3 >= SIGNED'("LHHL")) report "Test STD_C.22.10 failing." severity FAILURE; assert not(-15 >= SIGNED'("110")) report "Test STD_C.22.11 failing." severity FAILURE; assert not(2 >= SIGNED'("0110")) report "Test STD_C.22.12 failing." severity FAILURE; assert not(0 >= SIGNED'("00000110")) report "Test STD_C.22.20 failing." severity FAILURE; assert not (0 >= SIGNED'("0110")) report "Test STD_C.22.13 failing." severity FAILURE; assert not (-1000000 >= SIGNED'("110")) report "Test STD_C.22.14 failing." severity FAILURE; if (not quiet) then assert not (100 >= SIGNED'("-0XZZZZW0")) report "Test STD_C.22.21 failing." severity FAILURE; end if; assert quiet report "C.22 tests done" severity note; -- STD_C.23 tests assert UNSIGNED'("0010") >= 1 report "Test STD_C.23.1 failing." severity FAILURE; assert UNSIGNED'("1010") >= 1 report "Test STD_C.23.2 failing." severity FAILURE; assert UNSIGNED'("111") >= 1 report "Test STD_C.23.3 failing." severity FAILURE; assert UNSIGNED'("010") >= 2 report "Test STD_C.23.5 failing." severity FAILURE; assert UNSIGNED'("10010") >= 18 report "Test STD_C.23.8 failing." severity FAILURE; assert UNSIGNED'("0010") >= 2 report "Test STD_C.23.9 failing." severity FAILURE; assert not (UNSIGNED'("100010") >= 49) report "Test STD_C.23.4 failing." severity FAILURE; assert not(UNSIGNED'("0001010") >= 15) report "Test STD_C.23.6 test failing." severity FAILURE; assert not(UNSIGNED'("11") >= 151) report "Test STD_C.23.7 test failing." severity FAILURE; assert not(UNSIGNED'("LHH") >= 6) report "Test STD_C.23.10 failing." severity FAILURE; assert not(UNSIGNED'("10010") >= 256) report "Test STD_C.23.11 failing." severity FAILURE; assert not(UNSIGNED'("0010") >= 6) report "Test STD_C.23.12 failing." severity FAILURE; if (not quiet) then assert not (BNULL >= 8) report "Test STD_C.23.13 failing." severity FAILURE; end if; assert not (UNSIGNED'("111") >= 3267) report "Test STD_C.23.14 failing." severity FAILURE; if (not quiet) then assert not (UNSIGNED'("-L") >= 256) report "Test STD_C.23.15 failing." severity FAILURE; end if; assert quiet report "C.23 tests done" severity note; -- STD_C.24 tests: assert SIGNED'("0010") >= 1 report "Test STD_C.24.1 failing." severity FAILURE; assert SIGNED'("01010") >= 8 report "Test STD_C.24.2 failing." severity FAILURE; assert SIGNED'("0111") >= 1 report "Test STD_C.24.3 failing." severity FAILURE; assert SIGNED'("HHHLL") >= -4 report "Test STD_C.24.15 failing." severity FAILURE; assert SIGNED'("011100") >= -4 report "Test STD_C.24.16 failing." severity FAILURE; assert SIGNED'("010") >= 2 report "Test STD_C.24.5 failing." severity FAILURE; assert SIGNED'("10010") >= -14 report "Test STD_C.24.8 failing." severity FAILURE; assert SIGNED'("0010") >= -2 report "Test STD_C.24.9 failing." severity FAILURE; assert SIGNED'("0000") >= 0 report "Test STD_C.24.17 failing." severity FAILURE; assert SIGNED'("0000") >= -2048 report "Test STD_C.24.18 failing." severity FAILURE; assert not (SIGNED'("HLLLHL") >= -15) report "Test STD_C.24.4 failing." severity FAILURE; assert not(SIGNED'("10001010") >= 1) report "Test STD_C.24.6 test failing." severity FAILURE; assert not(SIGNED'("10011100111") >= -345) report "Test STD_C.24.7 test failing." severity FAILURE; assert not(SIGNED'("1000000111111") >= -1024) report "Test STD_C.24.19 test failing." severity FAILURE; assert not(SIGNED'("1000011") >= -2) report "Test STD_C.24.10 failing." severity FAILURE; assert not(SIGNED'("10000010") >= -63) report "Test STD_C.24.11 failing." severity FAILURE; assert not(SIGNED'("HLHL") >= -2) report "Test STD_C.24.12 failing." severity FAILURE; assert not(SIGNED'("1000") >= 0) report "Test STD_C.24.20 failing." severity FAILURE; if (not quiet) then assert not (SBNULL >= -7) report "Test STD_C.24.13 failing." severity FAILURE; end if; assert not (SIGNED'("1000000000000000H0") >= -6457) report "Test STD_C.24.14 failing." severity FAILURE; if (not quiet) then assert not (SIGNED'("HX") >= 256) report "Test STD_C.24.21 failing." severity FAILURE; end if; assert quiet report "C.24 tests done" severity note; -- ************************************************ -- ************************************************ -- r.1, r.2 tests from Bob Flatt :::::: -- r.1 tests: assert RESIZE(SIGNED'("0001") , 0)'length = 0 report "Test r.1.1 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 1) = "0" report "Test r.1.2 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 2) = "01" report "Test r.1.3 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 3) = "001" report "Test r.1.4 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 4) = "0001" report "Test r.1.5 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 5) = "00001" report "Test r.1.6 failing." severity FAILURE; assert RESIZE(SIGNED'("0001") , 6) = "000001" report "Test r.1.7 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 1) = "1" report "Test r.1.8 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 2) = "11" report "Test r.1.9 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 3) = "101" report "Test r.1.10 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 4) = "1001" report "Test r.1.11 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 5) = "11001" report "Test r.1.12 failing." severity FAILURE; assert RESIZE(SIGNED'("1001") , 6) = "111001" report "Test r.1.13 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 1) = "0" report "Test r.1.14 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 2) = "01" report "Test r.1.15 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 3) = "001" report "Test r.1.16 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 4) = "0101" report "Test r.1.17 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 5) = "00101" report "Test r.1.18 failing." severity FAILURE; assert RESIZE(SIGNED'("0101") , 6) = "000101" report "Test r.1.19 failing." severity FAILURE; if (not quiet) then assert RESIZE(SANULL , 0)'length = 0 report "Test r.1.20 failing." severity FAILURE; assert RESIZE(SANULL , 1) = "0" report "Test r.1.21 failing." severity FAILURE; assert RESIZE(SANULL , 2) = "00" report "Test r.1.22 failing." severity FAILURE; end if; assert RESIZE(SIGNED'("0") , 0)'length = 0 report "Test r.1.23 failing." severity FAILURE; assert RESIZE(SIGNED'("0") , 1) = "0" report "Test r.1.24 failing." severity FAILURE; assert RESIZE(SIGNED'("0") , 2) = "00" report "Test r.1.25 failing." severity FAILURE; assert RESIZE(SIGNED'("1") , 1) = "1" report "Test r.1.26 failing." severity FAILURE; assert RESIZE(SIGNED'("1") , 2) = "11" report "Test r.1.27 failing." severity FAILURE; assert quiet report "R.1 tests done" severity note; -- r.2 tests: assert RESIZE(UNSIGNED'("0001") , 0)'length = 0 report "Test r.2.1 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 1) = "1" report "Test r.2.2 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 2) = "01" report "Test r.2.3 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 3) = "001" report "Test r.2.4 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 4) = "0001" report "Test r.2.5 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 5) = "00001" report "Test r.2.6 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0001") , 6) = "000001" report "Test r.2.7 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 1) = "1" report "Test r.2.8 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 2) = "01" report "Test r.2.9 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 3) = "001" report "Test r.2.10 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 4) = "1001" report "Test r.2.11 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 5) = "01001" report "Test r.2.12 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1001") , 6) = "001001" report "Test r.2.13 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 1) = "1" report "Test r.2.14 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 2) = "01" report "Test r.2.15 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 3) = "101" report "Test r.2.16 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 4) = "0101" report "Test r.2.17 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 5) = "00101" report "Test r.2.18 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0101") , 6) = "000101" report "Test r.2.19 failing." severity FAILURE; if (not quiet) then assert RESIZE(ANULL , 0)'length = 0 report "Test r.2.20 failing." severity FAILURE; assert RESIZE(ANULL , 1) = "0" report "Test r.2.21 failing." severity FAILURE; assert RESIZE(ANULL , 2) = "00" report "Test r.2.22 failing." severity FAILURE; end if; assert RESIZE(UNSIGNED'("0") , 0)'length = 0 report "Test r.2.23 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0") , 1) = "0" report "Test r.2.24 failing." severity FAILURE; assert RESIZE(UNSIGNED'("0") , 2) = "00" report "Test r.2.25 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1") , 1) = "1" report "Test r.2.26 failing." severity FAILURE; assert RESIZE(UNSIGNED'("1") , 2) = "01" report "Test r.2.27 failing." severity FAILURE; -- end of r.1, r.2 tests from Bob Flatt. assert quiet report "R.2 tests done" severity note; -- ************************************************ -- ************************************************ -- ************************************************ -- ************************************************ -- ************************************************ -- ************************************************ assert FALSE report "END OF TESTS" severity note; wait; end process; end ops; nvc-r1.17.1/test/regress/ieee13.vhd000066400000000000000000000570161504111170000167570ustar00rootroot00000000000000-------------- test case header ------ --! Test intent : Coverage of standards. --! Test scope : abs a1 Nul input. --! Keywords : [operations, abs] --! References : [VH2008 16.6] --! [Rlink : REQ08xx] ----------------------------------------------- -- a1 and a2 from bishop tests. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; --use work.test_pkg.all; entity ieee13 is generic ( quiet : boolean := false); -- make the simulation quiet end entity; architecture ops of ieee13 is begin process procedure A_3 (LEFT, RIGHT, RESULT: in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_3; procedure A_3 (LEFT, RIGHT: in UNSIGNED) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_3; procedure A_4 (LEFT, RIGHT, RESULT: in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_4; procedure A_4 (LEFT, RIGHT: in SIGNED) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_4; procedure A_5 (LEFT:in UNSIGNED; RIGHT:in NATURAL; RESULT:in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_5; procedure A_5 (LEFT:in UNSIGNED; RIGHT:in NATURAL) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_5; procedure A_6 (LEFT:in NATURAL; RIGHT:in UNSIGNED; RESULT:in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_6; procedure A_6 (LEFT:in NATURAL; RIGHT:in UNSIGNED) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_6; procedure A_7 (LEFT:in INTEGER; RIGHT:in SIGNED; RESULT:in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_7; procedure A_7 (LEFT:in INTEGER; RIGHT:in SIGNED) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_7; procedure A_8 (LEFT:in SIGNED; RIGHT:in INTEGER; RESULT:in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT+RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_8; procedure A_8 (LEFT:in SIGNED; RIGHT:in INTEGER) is begin assert "+"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_8; procedure A_9 (LEFT, RIGHT, RESULT: in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_9; procedure A_9 (LEFT, RIGHT: in UNSIGNED) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_9; procedure A_10 (LEFT, RIGHT, RESULT: in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_10; procedure A_10 (LEFT, RIGHT: in SIGNED) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_10; procedure A_11 (LEFT:in UNSIGNED; RIGHT:in NATURAL; RESULT: in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_11; procedure A_11 (LEFT:in UNSIGNED; RIGHT: in NATURAL) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_11; procedure A_12 (LEFT:in NATURAL; RIGHT, RESULT: in UNSIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_12; procedure A_12 (LEFT: in NATURAL; RIGHT:in UNSIGNED) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_12; procedure A_13 (LEFT:in SIGNED; RIGHT:in INTEGER; RESULT: in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_13; procedure A_13 (LEFT:in SIGNED; RIGHT:in INTEGER) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_13; procedure A_14 (LEFT:in INTEGER; RIGHT, RESULT: in SIGNED) is begin assert STD_LOGIC_VECTOR (LEFT-RIGHT) = STD_LOGIC_VECTOR (RESULT) severity FAILURE; end A_14; procedure A_14 (LEFT:in INTEGER; RIGHT: in SIGNED) is begin assert "-"(LEFT, RIGHT)'length = 0 severity FAILURE; end A_14; begin A_3("0", "0", "0"); A_3("0", "1", "1"); A_3("1", "0", "1"); A_3("1", "1", "0"); A_3("0000", "0000", "0000"); A_3("0001", "0000", "0001"); A_3("0000", "0001", "0001"); A_3("0001", "0001", "0010"); A_3("0010", "0010", "0100"); A_3("0110", "1011", "0001"); A_3("0110", "0110", "1100"); A_3("1110", "1111", "1101"); A_3("0010", "0101", "0111"); A_3("0000", "1110", "1110"); A_3("0010", "1111", "0001"); A_3("0011", "0110", "1001"); A_3("1101", "1101", "1010"); A_3("1110", "0001", "1111"); A_3("1101", "0110", "0011"); A_3("0001", "1110", "1111"); A_3("0101", "10", "0111"); A_3("10", "0101", "0111"); A_3("0101", "10", "0111"); A_3("1111", "1111", "1110"); A_3("11111111", "0", "11111111"); A_3("0", "11111111", "11111111"); A_3("1", "01010101", "01010110"); A_3("01010101", "1", "01010110"); A_3("1111000011110000", "0000000011111111", "1111000111101111"); A_3("H00H", "HH00", "0101"); A_3("LHHL", "LLH0", "1000"); A_3("0HHH", "000H", "1000"); A_3("0H0H", "1010", "1111"); A_3("0010", "001X", "XXXX"); A_3("0X10", "HL10", "XXXX"); A_3("0010", "001-", "XXXX"); A_3("0010", "0Z10", "XXXX"); A_3("10", "00W0U-", "XXXXXX"); A_3("1", ""); A_3("", "11111111"); A_3("", ""); A_3("0X10", ""); A_3("", "01X"); assert quiet report "A.3 tests done" severity note; A_4("0", "0", "0"); A_4("0", "1", "1"); A_4("1", "0", "1"); A_4("1", "1", "0"); A_4("0000", "0000", "0000"); A_4("0001", "0000", "0001"); A_4("0000", "0001", "0001"); A_4("0001", "0001", "0010"); A_4("0010", "0010", "0100"); A_4("0110", "1011", "0001"); A_4("0110", "0110", "1100"); A_4("1110", "1111", "1101"); A_4("0010", "0101", "0111"); A_4("0000", "1110", "1110"); A_4("0010", "1111", "0001"); A_4("0011", "0110", "1001"); A_4("1101", "1101", "1010"); A_4("1110", "0001", "1111"); A_4("1101", "0110", "0011"); A_4("0001", "1110", "1111"); A_4("0101", "10", "0011"); A_4("10", "0101", "0011"); A_4("0101", "10", "0011"); A_4("1111", "111", "1110"); A_4("11111111", "10", "11111101"); A_4("1", "01010101", "01010100"); A_4("01010101", "1", "01010100"); A_4("1", "1", "0"); A_4("1", "111", "110"); A_4("111", "1", "110"); A_4("0", "1000", "1000"); A_4("1000", "0", "1000"); A_4("1000", "1000", "0000"); A_4("11", "01010101", "01010100"); A_4("1111000011110000", "0000000011111111", "1111000111101111"); A_4("H00H", "HH00", "0101"); A_4("LHHL", "LLH0", "1000"); A_4("0HHH", "000H", "1000"); A_4("0H0H", "1010", "1111"); A_4("0010", "001X", "XXXX"); A_4("0X10", "HL10", "XXXX"); A_4("0010", "001-", "XXXX"); A_4("0010", "0Z10", "XXXX"); A_4("10", "00W0U-", "XXXXXX"); A_4("1", ""); A_4("", "11111111"); A_4("", ""); A_4("0X10", ""); A_4("", "01X"); assert quiet report "A.4 tests done" severity note; A_5("0", 0, "0"); A_5("0", 1, "1"); A_5("1", 0, "1"); A_5("1", 1, "0"); A_5("0000", 0, "0000"); A_5("0001", 0, "0001"); A_5("0000", 1, "0001"); A_5("0001", 1, "0010"); A_5("0010", 2, "0100"); A_5("0110", 11, "0001"); A_5("0110", 6, "1100"); A_5("1110", 15, "1101"); A_5("0010", 5, "0111"); A_5("0000", 14, "1110"); A_5("0010", 15, "0001"); A_5("0011", 6, "1001"); A_5("1101", 13, "1010"); A_5("1110", 1, "1111"); A_5("1101", 6, "0011"); A_5("0001", 14, "1111"); A_5("0101", 2, "0111"); if (not quiet) then A_5("10", 5, "11"); end if; A_5("1111", 15, "1110"); A_5("11111111", 0, "11111111"); if (not quiet) then A_5("1", 75, "0"); A_5("0", 8, "0"); end if; A_5("1111000011110000", 255, "1111000111101111"); A_5("H00H", 12, "0101"); A_5("LHHL", 2, "1000"); A_5("0HHH", 1, "1000"); A_5("0H0H", 10, "1111"); A_5("0X10", 2, "XXXX"); if (not quiet) then A_5("0-", 10, "XX"); end if; A_5("0ZWU", 0, "XXXX"); A_5("X", 1, "X"); A_5("", 14); A_5("", 90210); assert quiet report "A.5 tests done" severity note; A_6(0, "0", "0"); A_6(0, "1", "1"); A_6(1, "0", "1"); A_6(1, "1", "0"); A_6(0, "0000", "0000"); A_6(0, "0001", "0001"); A_6(1, "0000", "0001"); A_6(1, "0001", "0010"); A_6(2, "0010", "0100"); A_6(11, "0110", "0001"); A_6(6, "0110", "1100"); A_6(15, "1110", "1101"); A_6(5, "0010", "0111"); A_6(14, "0000", "1110"); A_6(15, "0010", "0001"); A_6(6, "0011", "1001"); A_6(13, "1101", "1010"); A_6(1, "1110", "1111"); A_6(6, "1101", "0011"); A_6(14, "0001", "1111"); A_6(2, "0101", "0111"); if (not quiet) then A_6(5, "10", "11"); end if; A_6(15, "1111", "1110"); A_6(0, "11111111", "11111111"); if (not quiet) then A_6(75, "1", "0"); end if; A_6(0, "1000", "1000"); A_6(255, "1111000011110000", "1111000111101111"); A_6(12, "H00H", "0101"); A_6(2, "LHHL", "1000"); A_6(1, "0HHH", "1000"); A_6(10, "0H0H", "1111"); A_6(2, "0X10", "XXXX"); if (not quiet) then A_6(10, "0-", "XX"); end if; A_6(0, "0ZWU", "XXXX"); A_6(1, "X", "X"); A_6(14, ""); A_6(25678, ""); assert quiet report "A.6 tests done" severity note; A_7(0, "0", "0"); A_7(0, "1", "1"); if (not quiet) then A_7(1, "0", "1"); A_7(1, "1", "0"); end if; A_7(0, "0000", "0000"); A_7(0, "0001", "0001"); A_7(1, "0000", "0001"); A_7(1, "0001", "0010"); A_7(2, "0010", "0100"); A_7(-5, "0110", "0001"); A_7(6, "0110", "1100"); A_7(-1, "1110", "1101"); A_7(5, "0010", "0111"); A_7(-2, "0000", "1110"); A_7(-1, "0010", "0001"); A_7(6, "0011", "1001"); A_7(-3, "1101", "1010"); A_7(1, "1110", "1111"); A_7(6, "1101", "0011"); A_7(-2, "0001", "1111"); A_7(-2, "0101", "0011"); if (not quiet) then A_7(5, "10", "11"); end if; A_7(-1, "1111", "1110"); A_7(-2, "11111111", "11111101"); if (not quiet) then A_7(75, "1", "0"); end if; A_7(-1, "1", "0"); A_7(0, "1000", "1000"); if (not quiet) then A_7(85, "1111", "0100"); A_7(-85, "1111", "1010"); end if; A_7(255, "1111000011110000", "1111000111101111"); A_7(-4, "H00H", "0101"); A_7(2, "LHHL", "1000"); A_7(1, "0HHH", "1000"); A_7(-6, "0H0H", "1111"); if (not quiet) then A_7(16, "1X", "XX"); end if; A_7(-3, "001-", "XXXX"); A_7(7, "0Z10", "XXXX"); A_7(12, "00W0U-", "XXXXXX"); A_7(-5, ""); A_7(0, ""); assert quiet report "A.7 tests done" severity note; A_8("0", 0, "0"); if (not quiet) then A_8("0", 1, "1"); end if; A_8("1", 0, "1"); if (not quiet) then A_8("1", 1, "0"); end if; A_8("0000", 0, "0000"); A_8("0001", 0, "0001"); A_8("0000", 1, "0001"); A_8("0001", 1, "0010"); A_8("0010", 2, "0100"); A_8("0110", -5, "0001"); A_8("0110", 6, "1100"); A_8("1110", -1, "1101"); A_8("0010", 5, "0111"); A_8("0000", -2, "1110"); A_8("0010", -1, "0001"); A_8("0011", 6, "1001"); A_8("1101", -3, "1010"); A_8("1110", 1, "1111"); A_8("1101", 6, "0011"); A_8("0001", -2, "1111"); A_8("0101", -2, "0011"); if (not quiet) then A_8("10", 5, "11"); end if; A_8("1111", -1, "1110"); A_8("11111111", -2, "11111101"); if (not quiet) then A_8("1", 75, "0"); end if; A_8("1", -1, "0"); if (not quiet) then A_8("1111", 85, "0100"); A_8("1111", -85, "1010"); end if; A_8("00000", -8, "11000"); A_8("1111000011110000", 255, "1111000111101111"); A_8("H00H", -4, "0101"); A_8("LHHL", 2, "1000"); A_8("0HHH", 1, "1000"); A_8("0H0H", -6, "1111"); if (not quiet) then A_8("1X", 16, "XX"); end if; A_8("001-", -3, "XXXX"); A_8("0Z10", 7, "XXXX"); A_8("00W0U-", 12, "XXXXXX"); A_8("", -5); A_8("", 0); assert quiet report "A.8 tests done" severity note; A_9("0", "0", "0"); A_9("0", "1", "1"); A_9("1", "0", "1"); A_9("1", "1", "0"); A_9("0000", "0000", "0000"); A_9("0001", "0000", "0001"); A_9("0000", "0001", "1111"); A_9("0001", "0001", "0000"); A_9("0010", "0010", "0000"); A_9("0110", "1011", "1011"); A_9("0110", "0110", "0000"); A_9("1110", "1111", "1111"); A_9("0010", "0101", "1101"); A_9("0000", "1110", "0010"); A_9("0010", "1111", "0011"); A_9("0011", "0110", "1101"); A_9("1101", "1101", "0000"); A_9("1110", "0001", "1101"); A_9("1101", "0110", "0111"); A_9("0001", "1110", "0011"); A_9("0101", "10", "0011"); A_9("10", "0101", "1101"); A_9("0101", "10", "0011"); A_9("1111", "1111", "0000"); A_9("11111111", "0", "11111111"); A_9("0", "11111111", "00000001"); A_9("1", "01010101", "10101100"); A_9("01010101", "1", "01010100"); A_9("0", "1000", "1000"); A_9("1111000011110000", "0000000011111111", "1110111111110001"); A_9("H00H", "HH00", "1101"); A_9("LHHL", "LLH0", "0100"); A_9("0HHH", "000H", "0110"); A_9("0H0H", "1010", "1011"); A_9("0010", "001X", "XXXX"); A_9("0X10", "HL10", "XXXX"); A_9("00", "1-", "XX"); A_9("0010", "0Z10", "XXXX"); A_9("10", "00W0U-", "XXXXXX"); A_9("1", ""); A_9("", "11111111"); A_9("", ""); A_9("0X10", ""); A_9("", "01X"); assert quiet report "A.9 tests done" severity note; A_10("0", "0", "0"); A_10("0", "1", "1"); A_10("1", "0", "1"); A_10("1", "1", "0"); A_10("0000", "0000", "0000"); A_10("0001", "0000", "0001"); A_10("0000", "0001", "1111"); A_10("0001", "0001", "0000"); A_10("0010", "0010", "0000"); A_10("0110", "1011", "1011"); A_10("0110", "0110", "0000"); A_10("1110", "1111", "1111"); A_10("0010", "0101", "1101"); A_10("0000", "1110", "0010"); A_10("0010", "1111", "0011"); A_10("0011", "0110", "1101"); A_10("1101", "1101", "0000"); A_10("1110", "0001", "1101"); A_10("1101", "0110", "0111"); A_10("0001", "1110", "0011"); A_10("0101", "10", "0111"); A_10("10", "0101", "1001"); A_10("0101", "10", "0111"); A_10("1111", "111", "0000"); A_10("11111111", "10", "00000001"); A_10("10", "11111111", "11111111"); A_10("1", "01010101", "10101010"); A_10("01010101", "1", "01010110"); A_10("11", "01010101", "10101010"); A_10("01010101", "11", "01010110"); A_10("1", "1", "0"); A_10("1", "111", "000"); A_10("111", "1", "000"); A_10("111", "1", "000"); A_10("0", "1000", "1000"); A_10("1111000011110000", "0000000011111111", "1110111111110001"); A_10("H00H", "HH00", "1101"); A_10("LHHL", "LLH0", "0100"); A_10("0HHH", "000H", "0110"); A_10("0H0H", "1010", "1011"); A_10("0010", "1X", "XXXX"); A_10("0X10", "HL10", "XXXX"); A_10("0", "-", "X"); A_10("0010", "0Z10", "XXXX"); A_10("10", "00W0U-", "XXXXXX"); A_10("1", ""); A_10("", "11111111"); A_10("", ""); A_10("0X10", ""); A_10("", "01X"); assert quiet report "A.10 tests done" severity note; A_11("0", 0, "0"); A_11("0", 1, "1"); A_11("1", 0, "1"); A_11("1", 1, "0"); A_11("0000", 0, "0000"); A_11("0001", 0, "0001"); A_11("0000", 1, "1111"); A_11("0001", 1, "0000"); A_11("0010", 2, "0000"); A_11("0110", 11, "1011"); A_11("0110", 6, "0000"); A_11("1110", 15, "1111"); A_11("0010", 5, "1101"); A_11("0000", 14, "0010"); A_11("0010", 15, "0011"); A_11("0011", 6, "1101"); A_11("1101", 13, "0000"); A_11("1110", 1, "1101"); A_11("1101", 6, "0111"); A_11("0001", 14, "0011"); A_11("0101", 2, "0011"); if (not quiet) then A_11("10", 5, "01"); end if; A_11("1111", 15, "0000"); A_11("11111111", 0, "11111111"); if (not quiet) then A_11("1", 85, "0"); A_11("0", 8, "0"); end if; A_11("1111000011110000", 255, "1110111111110001"); A_11("H00H", 12, "1101"); A_11("LHHL", 2, "0100"); A_11("0HHH", 1, "0110"); A_11("0H0H", 10, "1011"); A_11("0X10", 2, "XXXX"); if (not quiet) then A_11("0-", 10, "XX"); end if; A_11("0ZWU", 0, "XXXX"); A_11("X", 1, "X"); A_11("", 10); A_11("", 90210); assert quiet report "A.11 tests done" severity note; A_12(0, "0", "0"); A_12(0, "1", "1"); A_12(1, "0", "1"); A_12(1, "1", "0"); A_12(0, "0000", "0000"); A_12(1, "0000", "0001"); A_12(0, "0001", "1111"); A_12(1, "0001", "0000"); A_12(2, "0010", "0000"); A_12(6, "1011", "1011"); A_12(6, "0110", "0000"); A_12(14, "1111", "1111"); A_12(2, "0101", "1101"); A_12(0, "1110", "0010"); A_12(2, "1111", "0011"); A_12(3, "0110", "1101"); A_12(13, "1101", "0000"); A_12(14, "0001", "1101"); A_12(13, "0110", "0111"); A_12(1, "1110", "0011"); if (not quiet) then A_12(5, "10", "11"); end if; A_12(2, "0101", "1101"); A_12(15, "1111", "0000"); if (not quiet) then A_12(255, "0000", "1111"); end if; A_12(1, "01010101","10101100"); A_12(0, "1000", "1000"); A_12(19, "0000000011111111", "1111111100010100"); A_12(9, "HH00", "1101"); A_12(6, "LLH0", "0100"); A_12(7, "000H", "0110"); A_12(5, "1010", "1011"); A_12(2, "0X10", "XXXX"); if (not quiet) then A_12(10, "0-", "XX"); end if; A_12(0, "0ZWU", "XXXX"); A_12(1, "X", "X"); A_12(10, ""); A_12(90210, ""); assert quiet report "A.12 tests done" severity note; A_13("0", 0, "0"); if (not quiet) then A_13("0", 1, "1"); end if; A_13("1", 0, "1"); if (not quiet) then A_13("1", 1, "0"); end if; A_13("0000", 0, "0000"); A_13("0001", 0, "0001"); A_13("0000", 1, "1111"); A_13("0001", 1, "0000"); A_13("0010", 2, "0000"); A_13("0110", -5, "1011"); A_13("0110", 6, "0000"); A_13("1110", -1, "1111"); A_13("0010", 5, "1101"); A_13("0000", -2, "0010"); A_13("0010", -1, "0011"); A_13("0011", 6, "1101"); A_13("1101", -3, "0000"); A_13("1110", 1, "1101"); A_13("1101", 6, "0111"); A_13("0001", -2, "0011"); A_13("0101", -2, "0111"); if (not quiet) then A_13("10", 5, "01"); end if; A_13("1111", -1, "0000"); A_13("11111111", -2, "00000001"); if (not quiet) then A_13("1", 85, "0"); A_13("11", 85, "10"); A_13("1", -1, "0"); A_13("0000", -8, "1000"); A_13("0", -7, "1"); end if; A_13("1111000011110000", 255, "1110111111110001"); A_13("H00H", -4, "1101"); A_13("LHHL", 2, "0100"); A_13("0HHH", 1, "0110"); A_13("0H0H", -6, "1011"); if (not quiet) then A_13("1X", 16, "XX"); end if; A_13("001-", -3, "XXXX"); A_13("0Z10", 7, "XXXX"); A_13("00W0U-", 12, "XXXXXX"); A_13("", 90210); A_13("", -369); assert quiet report "A.13 tests done" severity note; A_14(0, "0", "0"); A_14(0, "1", "1"); if (not quiet) then A_14(1, "0", "1"); A_14(1, "1", "0"); end if; A_14(0, "0000", "0000"); A_14(1, "0000", "0001"); A_14(0, "0001", "1111"); A_14(1, "0001", "0000"); A_14(2, "0010", "0000"); A_14(6, "1011", "1011"); A_14(6, "0110", "0000"); A_14(-2, "1111", "1111"); A_14(2, "0101", "1101"); A_14(0, "1110", "0010"); A_14(2, "1111", "0011"); A_14(3, "0110", "1101"); A_14(-3, "1101", "0000"); A_14(-2, "0001", "1101"); A_14(-3, "0110", "0111"); A_14(1, "1110", "0011"); if (not quiet) then A_14(5, "10", "11"); end if; A_14(-2, "0101", "1001"); A_14(-1, "111", "000"); A_14(-1, "10", "01"); A_14(-1, "01010101", "10101010"); A_14(-1, "1", "0"); A_14(-1, "111", "000"); A_14(0, "1000", "1000"); A_14(0, "01000", "11000"); A_14(-3856, "0000000011111111", "1110111111110001"); A_14(-7, "HH00", "1101"); A_14(6, "LLH0", "0100"); A_14(7, "000H", "0110"); A_14(5, "1010", "1011"); A_14(1, "1X", "XX"); if (not quiet) then A_14(7, "-", "X"); end if; A_14(6, "0Z10", "XXXX"); A_14(10, "00W0U-", "XXXXXX"); A_14(0, ""); A_14(-90210, ""); A_14(90210, ""); assert quiet report "A.14 tests done" severity note; assert FALSE report "END OF test suite tb4" severity note; wait; end process; end ops; nvc-r1.17.1/test/regress/ieee14.vhd000066400000000000000000000551741504111170000167630ustar00rootroot00000000000000-------------- test case header ------ --! Test intent : Coverage of standards. --! Test scope : abs a1 Nul input. --! Keywords : [operations, abs] --! References : [VH2008 16.6] --! [Rlink : REQ08xx] ----------------------------------------------- -- tb1 c1 - c30 from bishop tests. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity ieee14 is generic ( quiet : boolean := false); -- make the simulation quiet end entity; architecture ops of ieee14 is signal ANULL: UNSIGNED (0 downto 1); signal BNULL: UNSIGNED (0 downto 1); signal SANULL: SIGNED (0 downto 1); signal SBNULL: SIGNED (0 downto 1); begin process -- for c.28,c.30 constant min : Integer := -128; constant max : Integer := 127; constant smax : Natural := 8; variable i : Integer; variable s : Signed( smax-1 downto 0 ); variable sint : integer := 2; variable snat : natural := 2; begin -- std c.29 assert not(unsigned'("1000") = snat) report "Test C.29 fail" severity failure; assert unsigned'("0010") = snat report "Test C.29 fail" severity failure; assert not(unsigned'("00001") = snat) report "Test C.29 fail" severity failure; snat := 50000000; assert not(unsigned'("011111111") = snat) report "Test C.29 fail" severity failure; assert not(ANULL = snat) report "Test C.29 Null fail" severity failure; assert not(unsigned'("XXXXXX") = snat) report "Test C.29 X fail" severity failure; assert quiet report "C.29 tests done" severity note; -- STD_C.1 tests: assert UNSIGNED'("1010") > UNSIGNED'("01") report "Test STD_C.1.2 failing." severity FAILURE; assert not (UNSIGNED'("010") > UNSIGNED'("010")) report "Test STD_C.1.5 failing." severity FAILURE; assert not(UNSIGNED'("10010") > UNSIGNED'("00010010")) report "Test STD_C.1.8 failing." severity FAILURE; assert not (UNSIGNED'("100010") > UNSIGNED'("110001")) report "Test STD_C.1.4 failing." severity FAILURE; assert not(UNSIGNED'("0001010") > UNSIGNED'("1111")) report "Test STD_C.1.6 test failing." severity FAILURE; assert not(UNSIGNED'("11") > UNSIGNED'("10001000")) report "Test STD_C.1.7 test failing." severity FAILURE; assert not(UNSIGNED'("011") > UNSIGNED'("110")) report "Test STD_C.1.10 failing." severity FAILURE; assert not(UNSIGNED'("10010") > UNSIGNED'("10010010")) report "Test STD_C.1.11 failing." severity FAILURE; assert not(UNSIGNED'("0010") > UNSIGNED'("110")) report "Test STD_C.1.12 failing." severity FAILURE; if (not quiet) then assert not (BNULL > UNSIGNED'("110")) report "Test STD_C.1.13 failing." severity FAILURE; assert not (ANULL > BNULL) report "Test STD_C.1.14 failing." severity FAILURE; end if; assert quiet report "C.1 tests done" severity note; --STD_C.2 tests: assert SIGNED'("0010") > SIGNED'("0001") report "Test STD_C.2.1 failing." severity FAILURE; assert SIGNED'("01010") > SIGNED'("01") report "Test STD_C.2.2 failing." severity FAILURE; assert SIGNED'("0111") > SIGNED'("000001") report "Test STD_C.2.3 failing." severity FAILURE; assert SIGNED'("011100") > SIGNED'("111100") report "Test STD_C.2.16 failing." severity FAILURE; assert not (SIGNED'("010") > SIGNED'("010")) report "Test STD_C.2.5 failing." severity FAILURE; assert SIGNED'("111110010") > SIGNED'("10000010") report "Test STD_C.2.8 failing." severity FAILURE; assert SIGNED'("0010") > SIGNED'("10") report "Test STD_C.2.9 failing." severity FAILURE; assert not(SIGNED'("0000") > SIGNED'("00")) report "Test STD_C.2.17 failing." severity FAILURE; assert SIGNED'("0000") > SIGNED'("11100001100") report "Test STD_C.2.18 failing." severity FAILURE; assert not (SIGNED'("100010") > SIGNED'("110001")) report "Test STD_C.2.4 failing." severity FAILURE; assert not(SIGNED'("1001010") > SIGNED'("1111")) report "Test STD_C.2.6 test failing." severity FAILURE; assert not(SIGNED'("10001000") > SIGNED'("11")) report "Test STD_C.2.7 test failing." severity FAILURE; assert not(SIGNED'("110") > SIGNED'("010")) report "Test STD_C.2.10 failing." severity FAILURE; assert not(SIGNED'("100100010") > SIGNED'("1001")) report "Test STD_C.2.11 failing." severity FAILURE; assert not(SIGNED'("10010") > SIGNED'("110")) report "Test STD_C.2.12 failing." severity FAILURE; assert not(SIGNED'("0000") > SIGNED'("00000110")) report "Test STD_C.2.20 failing." severity FAILURE; if (not quiet) then assert not (SBNULL > SIGNED'("110")) report "Test STD_C.2.13 failing." severity FAILURE; assert not (SANULL > SBNULL) report "Test STD_C.2.14 failing." severity FAILURE; end if; assert quiet report "C.2 tests done" severity note; -- STD_C.3 tests assert 2 > UNSIGNED'("0001") report "Test STD_C.3.1 failing." severity FAILURE; assert 10 > UNSIGNED'("01") report "Test STD_C.3.2 failing." severity FAILURE; assert 7 > UNSIGNED'("000001") report "Test STD_C.3.3 failing." severity FAILURE; assert not (2 > UNSIGNED'("010")) report "Test STD_C.3.5 failing." severity FAILURE; assert not(18 > UNSIGNED'("00010010")) report "Test STD_C.3.8 failing." severity FAILURE; assert not (34 > UNSIGNED'("110001")) report "Test STD_C.3.4 failing." severity FAILURE; assert not(10 > UNSIGNED'("1111")) report "Test STD_C.3.6 test failing." severity FAILURE; assert not(3 > UNSIGNED'("10001000")) report "Test STD_C.3.7 test failing." severity FAILURE; assert not(3 > UNSIGNED'("110")) report "Test STD_C.3.10 failing." severity FAILURE; assert not(18 > UNSIGNED'("10010010")) report "Test STD_C.3.11 failing." severity FAILURE; assert not(2 > UNSIGNED'("110")) report "Test STD_C.3.12 failing." severity FAILURE; assert (10000 > UNSIGNED'("110")) report "Test STD_C.3.13 failing." severity FAILURE; if (not quiet) then assert not ( 0 > BNULL) report "Test STD_C.3.14 failing." severity FAILURE; end if; assert quiet report "C.3 tests done" severity note; -- STD_C.4 tests assert 10 > SIGNED'("01") report "Test STD_C.4.2 failing." severity FAILURE; assert 7 > SIGNED'("100001") report "Test STD_C.4.3 failing." severity FAILURE; assert not (-4 > SIGNED'("111100")) report "Test STD_C.4.15 failing." severity FAILURE; assert 28 > SIGNED'("111100") report "Test STD_C.4.16 failing." severity FAILURE; assert not(2 > SIGNED'("010")) report "Test STD_C.4.5 failing." severity FAILURE; assert -14 > SIGNED'("100010010") report "Test STD_C.4.8 failing." severity FAILURE; assert 2 > SIGNED'("10") report "Test STD_C.4.9 failing." severity FAILURE; assert not(0 > SIGNED'("00")) report "Test STD_C.4.17 failing." severity FAILURE; assert -0 > SIGNED'("11100001100") report "Test STD_C.4.18 failing." severity FAILURE; assert not (-30 > SIGNED'("110001")) report "Test STD_C.4.4 failing." severity FAILURE; assert not(+10 > SIGNED'("01111")) report "Test STD_C.4.6 test failing." severity FAILURE; assert not(-9 > SIGNED'("1100")) report "Test STD_C.4.7 test failing." severity FAILURE; assert not(3 > SIGNED'("010001000")) report "Test STD_C.4.19 test failing." severity FAILURE; assert not(-15 > SIGNED'("110")) report "Test STD_C.4.11 failing." severity FAILURE; assert not(2 > SIGNED'("0110")) report "Test STD_C.4.12 failing." severity FAILURE; assert not(0 > SIGNED'("00000110")) report "Test STD_C.4.20 failing." severity FAILURE; assert not (0 > SIGNED'("0110")) report "Test STD_C.4.13 failing." severity FAILURE; assert not (-1000000 > SIGNED'("110")) report "Test STD_C.4.14 failing." severity FAILURE; assert quiet report "C.4 tests done" severity note; -- STD_C.5 tests assert UNSIGNED'("0010") > 1 report "Test STD_C.5.1 failing." severity FAILURE; assert UNSIGNED'("1010") > 1 report "Test STD_C.5.2 failing." severity FAILURE; assert UNSIGNED'("111") > 1 report "Test STD_C.5.3 failing." severity FAILURE; assert not(UNSIGNED'("010") > 2) report "Test STD_C.5.5 failing." severity FAILURE; assert not(UNSIGNED'("10010") > 18) report "Test STD_C.5.8 failing." severity FAILURE; assert not(UNSIGNED'("0010") > 2) report "Test STD_C.5.9 failing." severity FAILURE; assert not (UNSIGNED'("100010") > 49) report "Test STD_C.5.4 failing." severity FAILURE; assert not(UNSIGNED'("0001010") > 15) report "Test STD_C.5.6 test failing." severity FAILURE; assert not(UNSIGNED'("11") > 151) report "Test STD_C.5.7 test failing." severity FAILURE; assert not(UNSIGNED'("10010") > 256) report "Test STD_C.5.11 failing." severity FAILURE; assert not(UNSIGNED'("0010") > 6) report "Test STD_C.5.12 failing." severity FAILURE; if (not quiet) then assert not (BNULL > 8) report "Test STD_C.5.13 failing." severity FAILURE; end if; assert not (UNSIGNED'("111") > 3267) report "Test STD_C.5.14 failing." severity FAILURE; assert quiet report "C.5 tests done" severity note; -- STD_C.6 tests: assert SIGNED'("0010") > 1 report "Test STD_C.6.1 failing." severity FAILURE; assert SIGNED'("01010") > 8 report "Test STD_C.6.2 failing." severity FAILURE; assert SIGNED'("0111") > 1 report "Test STD_C.6.3 failing." severity FAILURE; assert SIGNED'("011100") > -4 report "Test STD_C.6.16 failing." severity FAILURE; assert not(SIGNED'("010") > 2) report "Test STD_C.6.5 failing." severity FAILURE; assert not(SIGNED'("10010") > -14) report "Test STD_C.6.8 failing." severity FAILURE; assert SIGNED'("0010") > -2 report "Test STD_C.6.9 failing." severity FAILURE; assert not(SIGNED'("0000") > 0) report "Test STD_C.6.17 failing." severity FAILURE; assert SIGNED'("0000") > -2048 report "Test STD_C.6.18 failing." severity FAILURE; assert not(SIGNED'("10001010") > 1) report "Test STD_C.6.6 test failing." severity FAILURE; assert not(SIGNED'("10011100111") > -345) report "Test STD_C.6.7 test failing." severity FAILURE; assert not(SIGNED'("1000000111111") > -1024) report "Test STD_C.6.19 test failing." severity FAILURE; assert not(SIGNED'("1000011") > -2) report "Test STD_C.6.10 failing." severity FAILURE; assert not(SIGNED'("10000010") > -63) report "Test STD_C.6.11 failing." severity FAILURE; assert not(SIGNED'("1000") > 0) report "Test STD_C.6.20 failing." severity FAILURE; if (not quiet) then assert not (SBNULL > -7) report "Test STD_C.6.13 failing." severity FAILURE; end if; assert quiet report "C.6 tests done" severity note; -- STD_C.7 tests: assert UNSIGNED'("0001") < UNSIGNED'("0010") report "Test STD_C.7.1 failing." severity FAILURE; assert UNSIGNED'("01") < UNSIGNED'("1010") report "Test STD_C.7.2 failing." severity FAILURE; assert UNSIGNED'("000001") < UNSIGNED'("111") report "Test STD_C.7.3 failing." severity FAILURE; assert not(UNSIGNED'("010") < UNSIGNED'("010")) report "Test STD_C.7.5 failing." severity FAILURE; assert not(UNSIGNED'("00010010") < UNSIGNED'("10010")) report "Test STD_C.7.8 failing." severity FAILURE; assert not(UNSIGNED'("10") < UNSIGNED'("0010")) report "Test STD_C.7.9 failing." severity FAILURE; assert not (UNSIGNED'("110001") < UNSIGNED'("100010")) report "Test STD_C.7.4 failing." severity FAILURE; assert not(UNSIGNED'("1111") < UNSIGNED'("0001010")) report "Test STD_C.7.6 test failing." severity FAILURE; assert not(UNSIGNED'("10001000") < UNSIGNED'("11")) report "Test STD_C.7.7 test failing." severity FAILURE; assert not(UNSIGNED'("110") < UNSIGNED'("011")) report "Test STD_C.7.10 failing." severity FAILURE; assert not(UNSIGNED'("10010010") < UNSIGNED'("10010")) report "Test STD_C.7.11 failing." severity FAILURE; if (not quiet) then assert not ( UNSIGNED'("110") < BNULL) report "Test STD_C.7.13 failing." severity FAILURE; assert not (BNULL < ANULL) report "Test STD_C.7.14 failing." severity FAILURE; end if; assert quiet report "C.7 tests done" severity note; --STD_C.8 tests: assert SIGNED'("0001") < SIGNED'("0010") report "Test STD_C.8.1 failing." severity FAILURE; assert SIGNED'("01") < SIGNED'("01010") report "Test STD_C.8.2 failing." severity FAILURE; assert SIGNED'("000001") < SIGNED'("0111") report "Test STD_C.8.3 failing." severity FAILURE; assert not(SIGNED'("111100") < SIGNED'("11100")) report "Test STD_C.8.15 failing." severity FAILURE; assert SIGNED'("111100") < SIGNED'("011100") report "Test STD_C.8.16 failing." severity FAILURE; assert not(SIGNED'("010") < SIGNED'("010")) report "Test STD_C.8.5 failing." severity FAILURE; assert SIGNED'("10000010") < SIGNED'("111110010") report "Test STD_C.8.8 failing." severity FAILURE; assert SIGNED'("10") < SIGNED'("0010") report "Test STD_C.8.9 failing." severity FAILURE; assert not(SIGNED'("00") < SIGNED'("0000")) report "Test STD_C.8.17 failing." severity FAILURE; assert SIGNED'("11100001100") < SIGNED'("0000") report "Test STD_C.8.18 failing." severity FAILURE; assert not (SIGNED'("110001") < SIGNED'("100010")) report "Test STD_C.8.4 failing." severity FAILURE; assert not(SIGNED'("1111") < SIGNED'("1001010")) report "Test STD_C.8.6 test failing." severity FAILURE; assert not(SIGNED'("11") < SIGNED'("10001000")) report "Test STD_C.8.7 test failing." severity FAILURE; assert not(SIGNED'("0110") < SIGNED'("10001000")) report "Test STD_C.8.19 test failing." severity FAILURE; assert not(SIGNED'("010") < SIGNED'("110")) report "Test STD_C.8.10 failing." severity FAILURE; assert not(SIGNED'("1001") < SIGNED'("100100010")) report "Test STD_C.8.11 failing." severity FAILURE; assert not(SIGNED'("110") < SIGNED'("10010")) report "Test STD_C.8.12 failing." severity FAILURE; assert not(SIGNED'("00000110") < SIGNED'("0000")) report "Test STD_C.8.20 failing." severity FAILURE; if (not quiet) then assert not (SBNULL < SANULL) report "Test STD_C.8.14 failing." severity FAILURE; end if; assert quiet report "C.8 tests done" severity note; -- STD_C.11 tests assert UNSIGNED'("0001") < 2 report "Test STD_C.11.1 failing." severity FAILURE; assert UNSIGNED'("01") < 10 report "Test STD_C.11.2 failing." severity FAILURE; assert UNSIGNED'("000001") < 7 report "Test STD_C.11.3 failing." severity FAILURE; assert not(UNSIGNED'("010") < 2) report "Test STD_C.11.5 failing." severity FAILURE; assert not(UNSIGNED'("00010010") < 18) report "Test STD_C.11.8 failing." severity FAILURE; assert not(UNSIGNED'("10") < 2) report "Test STD_C.11.9 failing." severity FAILURE; assert not (UNSIGNED'("110001") < 34) report "Test STD_C.11.4 failing." severity FAILURE; assert not(UNSIGNED'("1111") < 10) report "Test STD_C.11.6 test failing." severity FAILURE; assert not(UNSIGNED'("10001000") < 3) report "Test STD_C.11.7 test failing." severity FAILURE; assert not(UNSIGNED'("110") < 3) report "Test STD_C.11.10 failing." severity FAILURE; assert not(UNSIGNED'("10010010") < 18) report "Test STD_C.11.11 failing." severity FAILURE; assert not(UNSIGNED'("110") < 2) report "Test STD_C.11.12 failing." severity FAILURE; if (not quiet) then assert not ( BNULL < 0) report "Test STD_C.11.14 failing." severity FAILURE; end if; assert quiet report "C.11 tests done" severity note; -- STD_C.12 tests assert SIGNED'("0001") < 2 report "Test STD_C.12.1 failing." severity FAILURE; assert SIGNED'("01") < 10 report "Test STD_C.12.2 failing." severity FAILURE; assert SIGNED'("100001") < 7 report "Test STD_C.12.3 failing." severity FAILURE; assert not(SIGNED'("111100") < -4) report "Test STD_C.12.15 failing." severity FAILURE; assert SIGNED'("111100") < 28 report "Test STD_C.12.16 failing." severity FAILURE; assert not(SIGNED'("010") < 2) report "Test STD_C.12.5 failing." severity FAILURE; assert SIGNED'("10") < 2 report "Test STD_C.12.9 failing." severity FAILURE; assert not(SIGNED'("00") < 0) report "Test STD_C.12.17 failing." severity FAILURE; assert SIGNED'("11100001100") < -0 report "Test STD_C.12.18 failing." severity FAILURE; assert not (SIGNED'("110001") < -30) report "Test STD_C.12.4 failing." severity FAILURE; assert not(SIGNED'("01111") < +10) report "Test STD_C.12.6 test failing." severity FAILURE; assert not(SIGNED'("1100") < -9) report "Test STD_C.12.7 test failing." severity FAILURE; assert not(SIGNED'("0110") < 3) report "Test STD_C.12.10 failing." severity FAILURE; assert not(SIGNED'("110") < -15) report "Test STD_C.12.11 failing." severity FAILURE; assert not(SIGNED'("0110") < 2) report "Test STD_C.12.12 failing." severity FAILURE; assert not(SIGNED'("00000110") < 0) report "Test STD_C.12.20 failing." severity FAILURE; assert not (SIGNED'("0110") < 0) report "Test STD_C.12.13 failing." severity FAILURE; assert not (SIGNED'("110") < -1000000) report "Test STD_C.12.14 failing." severity FAILURE; assert quiet report "C.12 tests done" severity note; -- STD_C.9 tests assert 1 < UNSIGNED'("0010") report "Test STD_C.9.1 failing." severity FAILURE; assert 1 < UNSIGNED'("111") report "Test STD_C.9.3 failing." severity FAILURE; assert not(2 < UNSIGNED'("010")) report "Test STD_C.9.5 failing." severity FAILURE; assert not(18 < UNSIGNED'("10010")) report "Test STD_C.9.8 failing." severity FAILURE; assert not(2 < UNSIGNED'("0010")) report "Test STD_C.9.9 failing." severity FAILURE; assert not (49 < UNSIGNED'("100010")) report "Test STD_C.9.4 failing." severity FAILURE; assert not(15 < UNSIGNED'("0001010")) report "Test STD_C.9.6 test failing." severity FAILURE; assert not(151 < UNSIGNED'("11")) report "Test STD_C.9.7 test failing." severity FAILURE; assert not(256 < UNSIGNED'("10010")) report "Test STD_C.9.11 failing." severity FAILURE; assert not(6 < UNSIGNED'("0010")) report "Test STD_C.9.12 failing." severity FAILURE; if (not quiet) then assert not (8 < BNULL) report "Test STD_C.9.13 failing." severity FAILURE; end if; assert not (3267 < UNSIGNED'("111")) report "Test STD_C.9.14 failing." severity FAILURE; assert quiet report "C.9 tests done" severity note; -- STD_C.10 tests: assert 1 < SIGNED'("0010") report "Test STD_C.10.1 failing." severity FAILURE; assert 1 < SIGNED'("0111") report "Test STD_C.10.3 failing." severity FAILURE; assert not(-4 < SIGNED'("11100")) report "Test STD_C.10.15 failing." severity FAILURE; assert -4 < SIGNED'("011100") report "Test STD_C.10.16 failing." severity FAILURE; assert not(2 < SIGNED'("010")) report "Test STD_C.10.5 failing." severity FAILURE; assert not(-14 < SIGNED'("10010")) report "Test STD_C.10.8 failing." severity FAILURE; assert -2 < SIGNED'("0010") report "Test STD_C.10.9 failing." severity FAILURE; assert not(0 < SIGNED'("0000")) report "Test STD_C.10.17 failing." severity FAILURE; assert -2048 < SIGNED'("0000") report "Test STD_C.10.18 failing." severity FAILURE; assert not (-15 < SIGNED'("100010")) report "Test STD_C.10.4 failing." severity FAILURE; assert not(1 < SIGNED'("10001010")) report "Test STD_C.10.6 test failing." severity FAILURE; assert not(-1024 < SIGNED'("1000000111111")) report "Test STD_C.10.19 test failing." severity FAILURE; assert not(-2 < SIGNED'("1000011")) report "Test STD_C.10.10 failing." severity FAILURE; assert not(-63 < SIGNED'("10000010")) report "Test STD_C.10.11 failing." severity FAILURE; assert not(0 < SIGNED'("1000")) report "Test STD_C.10.20 failing." severity FAILURE; if (not quiet) then assert not (-7 < SBNULL) report "Test STD_C.10.13 failing." severity FAILURE; end if; assert not (-6457 < SIGNED'("100000000000000010")) report "Test STD_C.10.14 failing." severity FAILURE; assert quiet report "C.10 tests done" severity note; -- c.28, c.30 tests, from Wolfgang: for a in min to max loop i := a; s := To_Signed( i, smax ); assert i = s report "failure in Function C.28 !" severity failure; assert s = i report "failure in Function C.30 !" severity failure; end loop; assert not(sint = sanull) report "Test C.28 Null fail" severity failure; assert not(sint = signed'("XXXXXX")) report "Test C.29 X's fail" severity failure; assert not(sanull = sint) report "Test C.30 Null fail" severity failure; assert not(signed'("XXXXXX") = sint) report "Test C.30 X's fail" severity failure; sint := 50000000; assert not(sint = signed'("01111111")) report "Test C.29 larger int fail" severity failure; assert not(signed'("01111111") = sint) report "Test C.30 larger int fail" severity failure; assert quiet report "c.28, c.30 tests done" severity note; assert FALSE report "END OF test suite tb3" severity note; wait; end process; end ops; nvc-r1.17.1/test/regress/ieee15.vhd000066400000000000000000000005231504111170000167500ustar00rootroot00000000000000entity ieee15 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of ieee15 is signal s : std_logic_vector(15 downto 0) := X"f0f0"; begin tb: process is begin assert (s and X"1234") = X"1030"; s <= s and "1101"; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee16.vhd000066400000000000000000003435011504111170000167570ustar00rootroot00000000000000------------------------------------------------------------------------ -- Copyright 1996 by VHDL International. All rights reserved. -- -- This source file is considered to be an aid to check implementations of the -- the IEEE standard 1076.2 and may be distributed without restriction -- as long as it is not sold or distributed for profit. -- -- THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR -- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -- DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS, IEEE, OR VHDL -- INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -- EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -- PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -- -- Title: Testbench for Standard VHDL MATH_REAL Package (PAR 1076.2) -- -- Developers: Members of the VHDL Mathematical Packages Working Group -- Code was written by Charles Swart (cswart@analogy.com) -- Data was supplied by many people. -- -- Purpose: An aid to check implementations of the IEEE MATH_REAL -- package, Standard 1076.2. -- -- -- Library: This can be compiled into any convient library. -- -- Limitation: Only values in the minimum required range may be tested -- to keep this test portable. -- That range is -1.0E38 to +1.0E38 inclusive. -- -- Notes: -- This file consists of an entity REAL_TESTS and a single -- architecture, ARCH. It references packages MATH_REAL -- and TEXTIO. -- -- To run this set of tests, choose an appropriate value for -- the constant FULL_RESULTS, compile and simulate for -- about 100 ns. -- -- Each process begins with a WAIT for a unique time interval. -- The purpose of this is to impose an order of evaluation -- on the tests to ease data comparisons between different -- implementations. -- -- The data was optained from a number of sources and is not -- guaranteed to be accurate. Many results are highly sensitive -- on the character to real conversion, which is often -- inaccurate in the last few places. -- -- Also, the tests are not comprehensive. -- -- The tests report the number of decimal digits of accuracy. -- There are several problems with this measurement. -- In some cases the number reported is one too many. -- The measurement also, probably correctly, reports that -- 5.0 and 4.99999 are close. -- A more fundamental problem involves values near zero. -- The test can (correctly) report 0 digits accuracy for small -- values. -- However, the results might still be perfectly reasonable. -- --- Suggestions, improvements and additional test points -- are welcome. -- -- ------------------------------------------------------------------------- -- Modification history: -- ------------------------------------------------------------------------- -- v0.91 | 05/01/96 | pre-release version -- Modified for VHDL-2006 05/25/06 David Bishop (dbishop@vhdl.org) ------------------------------------------------------------- library ieee; use ieee.math_real.all; use std.textio.all; entity IEEE16 is generic ( quiet : BOOLEAN := false; -- run quietly FULL_RESULTS : BOOLEAN := false); -- verbose output end entity IEEE16; architecture ARCH of IEEE16 is type REALX_VECTOR is array(POSITIVE range <>) of REAL; type INT_VECTOR is array(POSITIVE range <>) of INTEGER; -- constant FULL_RESULTS : BOOLEAN := false; -- TRUE for full results, FALSE for summary constant MAX_DIGITS : INTEGER := 60; -- large value to represent exact agreement constant NEAR_ZERO : REAL := 1.0E-07; -- values less than this are considered zero function COMPARE(EXPECTED : REAL; RESULT : REAL) return INTEGER is variable DENOMINATOR : REAL; variable TEMP1 : REAL; variable EXPECTED1 : REAL := EXPECTED; begin if EXPECTED1 = RESULT then return MAX_DIGITS; end if; --This is a kludge to get more reasonable results for values near zero. --The basic problem is that small representational errors may cause the --computed result to be more accurate than the "correct" expected result if ((abs(EXPECTED1) < NEAR_ZERO) and (abs(RESULT-0.0) < abs(RESULT-EXPECTED1))) then EXPECTED1 := 0.0; end if; if EXPECTED1 = 0.0 then DENOMINATOR := 1.0; else DENOMINATOR := 10.0 ** (INTEGER(FLOOR(LOG10(abs(EXPECTED1))))); end if; TEMP1 := LOG10(abs((EXPECTED1-RESULT)/DENOMINATOR)); if TEMP1 > 0.0 then return 0; end if; return INTEGER(CEIL(-TEMP1)); end COMPARE; procedure PRINT_RESULTS(FUNC_NAME : STRING; ARG1 : REALX_VECTOR; RESULTS : REALX_VECTOR; CORRECT_ANSWERS : REALX_VECTOR; ACCURACY : INT_VECTOR; FULL_RESULTS : BOOLEAN) is variable WORST_ACCURACY : INTEGER := ACCURACY(1); variable OUTLINE : LINE; begin if(FULL_RESULTS) then --write out header WRITE(OUTLINE, FUNC_NAME, left, 10); WRITE(OUTLINE, STRING'("argument"), left, 25); WRITE(OUTLINE, STRING'("result"), left, 25); WRITE(OUTLINE, STRING'("correct"), left, 25); WRITE(OUTLINE, STRING'("digits")); WRITELINE(OUTPUT, OUTLINE); --write out each value for I in 1 to ARG1'length loop WRITE(OUTLINE, STRING'(" ")); WRITE(OUTLINE, ARG1(I), left, 25); WRITE(OUTLINE, RESULTS(I), left, 25); WRITE(OUTLINE, CORRECT_ANSWERS(I), left, 25); WRITE(OUTLINE, ACCURACY(I), right, 2); WRITELINE(OUTPUT, OUTLINE); end loop; end if; --update accuracy for I in 1 to ACCURACY'length loop if ACCURACY(I) < WORST_ACCURACY then WORST_ACCURACY := ACCURACY(I); end if; end loop; if not quiet or WORST_ACCURACY < 6 then --in all cases print summary information WRITE(OUTLINE, FUNC_NAME); WRITE(OUTLINE, STRING'(" has worst case accuracy of ")); WRITE(OUTLINE, WORST_ACCURACY); WRITE(OUTLINE, STRING'(" digits.")); WRITELINE(OUTPUT, OUTLINE); --print blank line WRITELINE(OUTPUT, OUTLINE); end if; assert WORST_ACCURACY >= 6; end PRINT_RESULTS; procedure PRINT_RESULTS(FUNC_NAME : STRING; ARG1 : REALX_VECTOR; ARG2 : REALX_VECTOR; RESULTS : REALX_VECTOR; CORRECT_ANSWERS : REALX_VECTOR; ACCURACY : INT_VECTOR; FULL_RESULTS : BOOLEAN) is variable WORST_ACCURACY : INTEGER := ACCURACY(1); variable OUTLINE : LINE; begin if(FULL_RESULTS) then --write out header WRITE(OUTLINE, FUNC_NAME, left, 10); WRITE(OUTLINE, STRING'("argument1"), left, 25); WRITE(OUTLINE, STRING'("argument2"), left, 25); WRITE(OUTLINE, STRING'("result"), left, 25); WRITE(OUTLINE, STRING'("correct"), left, 25); WRITE(OUTLINE, STRING'("digits")); WRITELINE(OUTPUT, OUTLINE); --write out each value for I in 1 to ARG1'length loop WRITE(OUTLINE, STRING'(" ")); WRITE(OUTLINE, ARG1(I), left, 25); WRITE(OUTLINE, ARG2(I), left, 25); WRITE(OUTLINE, RESULTS(I), left, 25); WRITE(OUTLINE, CORRECT_ANSWERS(I), left, 25); WRITE(OUTLINE, ACCURACY(I), right, 2); WRITELINE(OUTPUT, OUTLINE); end loop; end if; --update accuracy for I in 1 to ACCURACY'length loop if ACCURACY(I) < WORST_ACCURACY then WORST_ACCURACY := ACCURACY(I); end if; end loop; if not quiet or WORST_ACCURACY < 6 then --in all cases print summary information WRITE(OUTLINE, FUNC_NAME); WRITE(OUTLINE, STRING'(" has worst case accuracy of ")); WRITE(OUTLINE, WORST_ACCURACY); WRITE(OUTLINE, STRING'(" digits.")); WRITELINE(OUTPUT, OUTLINE); --print blank line WRITELINE(OUTPUT, OUTLINE); end if; assert WORST_ACCURACY >= 6; end PRINT_RESULTS; -- print results for uniform procedure procedure PRINT_RESULTS(SEED1 : INT_VECTOR; SEED2 : INT_VECTOR; NEW_SEED1 : INT_VECTOR; NEW_SEED2 : INT_VECTOR; RESULTS : REALX_VECTOR; EXPECTED_SEED1 : INT_VECTOR; EXPECTED_SEED2 : INT_VECTOR; EXPECTED_RESULTS : REALX_VECTOR; FULL_RESULTS : BOOLEAN) is variable OUTLINE : LINE; variable FAIL_COUNT : INTEGER := 0; begin if(FULL_RESULTS) then --write out header WRITE(OUTLINE, STRING'("Test of UNIFORM procedure.")); WRITELINE(OUTPUT, OUTLINE); WRITE(OUTLINE, STRING'("seed1"), left, 12); WRITE(OUTLINE, STRING'("seed2"), left, 12); WRITE(OUTLINE, STRING'("new seed1"), left, 12); WRITE(OUTLINE, STRING'("new seed2"), left, 12); WRITE(OUTLINE, STRING'("results"), left, 21); WRITE(OUTLINE, STRING'("expected seed1"), left, 16); WRITE(OUTLINE, STRING'("expected seed2"), left, 16); WRITE(OUTLINE, STRING'("expected results"), left, 25); WRITELINE(OUTPUT, OUTLINE); --write out each value for I in 1 to SEED1'length loop WRITE(OUTLINE, SEED1(I), left, 12); WRITE(OUTLINE, SEED2(I), left, 12); WRITE(OUTLINE, NEW_SEED1(I), left, 12); WRITE(OUTLINE, NEW_SEED2(I), left, 12); WRITE(OUTLINE, RESULTS(I), left, 23); WRITE(OUTLINE, EXPECTED_SEED1(I), left, 12); WRITE(OUTLINE, EXPECTED_SEED2(I), left, 12); WRITE(OUTLINE, EXPECTED_RESULTS(I), left, 23); WRITELINE(OUTPUT, OUTLINE); if((NEW_SEED1(I) /= EXPECTED_SEED1(I)) or (NEW_SEED2(I) /= EXPECTED_SEED2(I))) then FAIL_COUNT := FAIL_COUNT+1; end if; end loop; end if; if FAIL_COUNT /= 0 or not quiet then --In all cases print summary information WRITE(OUTLINE, STRING'(" Procedure UNIFORM produced incorrect seeds in ")); WRITE(OUTLINE, FAIL_COUNT); WRITE(OUTLINE, STRING'(" cases.")); WRITELINE(OUTPUT, OUTLINE); --print blank line WRITELINE(OUTPUT, OUTLINE); end if; assert FAIL_COUNT = 0; end PRINT_RESULTS; begin SIGN_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.3, 4.7, 4.5, -4.3, -4.7, -4.5, -1.0E38, 1.0E38); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 1 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := SIGN(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("SIGN", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process SIGN_TEST; CEIL_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.3, 4.7, 4.5, -4.3, -4.7, -4.5, -1.0E38, 1.0E38); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 5.0, -5.0, 5.0, 5.0, 5.0, -4.0, -4.0, -4.0, -1.0E38, 1.0E38); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 2 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := CEIL(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("CEIL", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process CEIL_TEST; FLOOR_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.3, 4.7, 4.5, -4.3, -4.7, -4.5, 128.0, -128.0, -1.0E38, 1.0E38); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.0, 4.0, 4.0, -5.0, -5.0, -5.0, 128.0, -128.0, -1.0E38, 1.0E38); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 3 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := FLOOR(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("FLOOR", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process FLOOR_TEST; ROUND_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.3, 4.7, 4.5, -4.3, -4.7, -4.5, -1.0E38, 1.0E38); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.0, 5.0, 5.0, -4.0, -5.0, -5.0, -1.0E38, 1.0E38); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 4 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ROUND(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ROUND", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ROUND_TEST; TRUNC_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.3, 4.7, 4.5, -4.3, -4.7, -4.5, -1.0E38, 1.0E38); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 5.0, -5.0, 4.0, 4.0, 4.0, -4.0, -4.0, -4.0, -1.0E38, 1.0E38); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 5 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := TRUNC(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("TRUNC", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process TRUNC_TEST; MOD_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 5.0, 5.0, -5.0, -5.0 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 3.0, -3.0, 3.0, -3.0 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 2.0, -1.0, 1.0, -2.0 ); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 6 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := "MOD"(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("MOD", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process MOD_TEST; REALMAX_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 5.0, 5.0, -5.0, -5.0 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 3.0, -3.0, 3.0, -3.0 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 5.0, 5.0, 3.0, -3.0 ); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 7 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := REALMAX(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("REALMAX", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process REALMAX_TEST; REALMIN_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 5.0, 5.0, -5.0, -5.0 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 3.0, -3.0, 3.0, -3.0 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 3.0, -3.0, -5.0, -5.0 ); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 8 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := REALMIN(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("REALMIN", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process REALMIN_TEST; UNIFORM_TEST : process -- The results of this test were determined empirically -- The positive seed values produced should agree exactly, even if the -- real random numbers are not exact. constant SEED1 : INT_VECTOR := ( 1, 1, 2147483562, 2147483562, 100, 1000 ); constant SEED2 : INT_VECTOR(1 to SEED1'length) := ( 1, 2147483398, 1, 2147483398, 1492, 1066 ); constant EXPECTED_SEED1 : INT_VECTOR(1 to SEED1'length) := ( 40014, 40014, 2147443549, 2147443549, 4001400, 40014000 ); constant EXPECTED_SEED2 : INT_VECTOR(1 to SEED1'length) := ( 40692, 2147442707, 40692, 2147442707, 60712464, 43377672 ); constant EXPECTED_RESULTS : REALX_VECTOR(1 to SEED1'length) := ( 9.999996714911893E-1, 3.76575636697E-5, 9.999624060143342E-1, 3.920868146E-7, 9.735918394229275E-1, 9.98433655333257E-1 ); variable S1, S2 : POSITIVE; variable RSLT : REAL; variable RESULTS : REALX_VECTOR(1 to SEED1'length); variable NEW_SEED1, NEW_SEED2 : INT_VECTOR(1 to SEED1'length); begin wait for 9 ns; -- compute results for I in 1 to SEED1'length loop S1 := SEED1(I); S2 := SEED2(I); UNIFORM(S1, S2, RSLT); NEW_SEED1(I) := S1; NEW_SEED2(I) := S2; RESULTS(I) := RSLT; end loop; -- print results PRINT_RESULTS(SEED1, SEED2, NEW_SEED1, NEW_SEED2, RESULTS, EXPECTED_SEED1, EXPECTED_SEED2, EXPECTED_RESULTS, FULL_RESULTS); wait; end process UNIFORM_TEST; SQRT_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.00000000000000E+00, 3.00000000000000E+00, 2.18700000000000E+03, 1.59432300000000E+06, 1.16226146700000E+09, 8.47288609443000E+11, 6.17673396283947E+14, 4.50283905890997E+17, 3.28256967394537E+20, 2.39299329230618E+23, 1.74449211009120E+26, 1.27173474825649E+29, 9.27094631478979E+31, 6.75851986348175E+34, 4.92696098047820E+37, 3.33333333333333E-01, 1.11111111111111E-01, 1.52415790275873E-04, 2.09075158128769E-07, 2.86797199079244E-10, 3.93411795719128E-13, 5.39659527735429E-16, 7.40273700597296E-19, 1.01546460987283E-21, 1.39295556909854E-24, 1.91077581494998E-27, 2.62109165288064E-30, 3.59546180093366E-33, 4.93204636616414E-36); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.00000000000000E+00, 1.73205080756888E+00, 4.67653718043597E+01, 1.26266503871771E+03, 3.40919560453782E+04, 9.20482813225212E+05, 2.48530359570807E+07, 6.71031970841179E+08, 1.81178632127118E+10, 4.89182306743220E+11, 1.32079222820669E+13, 3.56613901615808E+14, 9.62857534362680E+15, 2.59971534277923E+17, 7.01923142550393E+18, 5.77350269189625E-01, 3.33333333333333E-01, 1.23456790123457E-02, 4.57247370827618E-04, 1.69350878084303E-05, 6.27225474386307E-07, 2.32305731254188E-08, 8.60391597237732E-10, 3.18663554532493E-11, 1.18023538715738E-12, 4.37124217465697E-14, 1.61897858320629E-15, 5.99621697483810E-17, 2.22082110179189E-18); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 10 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := SQRT(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("SQRT", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process SQRT_TEST; CBRT_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 1.00000000000000E+00, -1.0, 3.00000000000000E+00, 2.18700000000000E+03, 1.59432300000000E+06, 1.16226146700000E+09, 8.47288609443000E+11, 6.17673396283947E+14, 4.50283905890997E+17, 3.28256967394537E+20, 2.39299329230618E+23, 1.74449211009120E+26, 1.27173474825649E+29, 9.27094631478979E+31, 6.75851986348175E+34, 4.92696098047820E+37, 3.33333333333333E-01, 1.11111111111111E-01, 1.52415790275873E-04, 2.09075158128769E-07, 2.86797199079244E-10, 3.93411795719128E-13, 5.39659527735429E-16, 7.40273700597296E-19, 1.01546460987283E-21, 1.39295556909854E-24, 1.91077581494998E-27, 2.62109165288064E-30, 3.59546180093366E-33, 4.93204636616414E-36, -8.0); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.00000000000000E+00, -1.0, 1.44224957030741E+00, 1.29802461327667E+01, 1.16822215194900E+02, 1.05139993675410E+03, 9.46259943078691E+03, 8.51633948770822E+04, 7.66470553893739E+05, 6.89823498504365E+06, 6.20841148653929E+07, 5.58757033788536E+08, 5.02881330409683E+09, 4.52593197368714E+10, 4.07333877631843E+11, 3.66600489868659E+12, 6.93361274350634E-01, 4.80749856769136E-01, 5.34166507521263E-02, 5.93518341690292E-03, 6.59464824100324E-04, 7.32738693444805E-05, 8.14154103827560E-06, 9.04615670919511E-07, 1.00512852324390E-07, 1.11680947027100E-08, 1.24089941141222E-09, 1.37877712379136E-10, 1.53197458199040E-11, 1.70219397998933E-12, -2.0); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 11 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := CBRT(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("CBRT", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process CBRT_TEST; POWER_TEST1 : process constant ARG1 : INT_VECTOR := ( 1, -1, 0, 1, 0, -2, 25, 256, 5, 4, 4, 4, 1 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 0.0, 1.0, 1.0, 2.0, 0.0, 0.5, 0.25, 2.0, 3.0, -0.5, 1.0, 50.0 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 5.0, 4.0, 25.0, 64.0, 0.5, 4.0, 1.0 ); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); variable REAL_ARG1 : REALX_VECTOR(1 to ARG1'length); begin wait for 12 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := "**"(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- translate integer argument 1 to real for more uniform printing for I in 1 to ARG1'length loop REAL_ARG1(I) := REAL(ARG1(I)); end loop; -- print results PRINT_RESULTS("**[int,real]", REAL_ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process POWER_TEST1; POWER_TEST2 : process constant ARG1 : REALX_VECTOR := ( 1.0, -1.0, 0.0, 1.0, 0.0, -2.0, 25.0, 256.0, 5.0, 4.0, 4.0, 4.0, 1.0, 0.5 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 0.0, 1.0, 1.0, 2.0, 0.0, 0.5, 0.25, 2.0, 3.0, -0.5, 1.0, 50.0, -2.0 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 5.0, 4.0, 25.0, 64.0, 0.5, 4.0, 1.0, 4.0 ); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); variable REAL_ARG1 : REALX_VECTOR(1 to ARG1'length); begin wait for 13 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := "**"(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("**[real,real]", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process POWER_TEST2; EXP_TEST : process constant ARG1 : REALX_VECTOR := ( -7.50000000000000E+01, -5.00000000000000E+01, -2.50000000000000E+01, 0.00000000000000E+00, 2.50000000000000E+01, 5.00000000000000E+01, 7.50000000000000E+01, -1.00000000000000E+01, -9.00000000000000E+00, -8.00000000000000E+00, -7.00000000000000E+00, -6.00000000000000E+00, -5.00000000000000E+00, -4.00000000000000E+00, -3.00000000000000E+00, -2.00000000000000E+00, -1.00000000000000E+00, 0.00000000000000E+00, 1.00000000000000E+00, 2.00000000000000E+00, 3.00000000000000E+00, 4.00000000000000E+00, 5.00000000000000E+00, 6.00000000000000E+00, 7.00000000000000E+00, 8.00000000000000E+00, 9.00000000000000E+00, 1.00000000000000E+01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 2.67863696180808E-33, 1.92874984796392E-22, 1.38879438649640E-11, 1.00000000000000E+00, 7.20048993373859E+10, 5.18470552858707E+21, 3.73324199679900E+32, 4.53999297624849E-05, 1.23409804086680E-04, 3.35462627902512E-04, 9.11881965554516E-04, 2.47875217666636E-03, 6.73794699908547E-03, 1.83156388887342E-02, 4.97870683678639E-02, 1.35335283236613E-01, MATH_1_OVER_E, 1.00000000000000E+00, MATH_E, 7.38905609893065E+00, 2.00855369231877E+01, 5.45981500331442E+01, 1.48413159102577E+02, 4.03428793492735E+02, 1.09663315842846E+03, 2.98095798704173E+03, 8.10308392757538E+03, 2.20264657948067E+04); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 14 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := EXP(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("EXP", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process EXP_TEST; LN_TEST : process constant ARG1 : REALX_VECTOR := ( 1.00000000000000E+00, MATH_E, 3.00000000000000E+00, 9.00000000000000E+00, 2.70000000000000E+01, 8.10000000000000E+01, 5.90490000000000E+04, 4.30467210000000E+07, 3.13810596090000E+10, 2.28767924549610E+13, 1.66771816996666E+16, 1.21576654590569E+19, 8.86293811965250E+21, 6.46108188922667E+24, 4.71012869724624E+27, 3.43368382029251E+30, 2.50315550499324E+33, 1.82480036314007E+36, 3.33333333333333E-01, 1.11111111111111E-01, 3.70370370370370E-02, 5.08052634252909E-05, 6.96917193762563E-08, 9.55990663597481E-11, 1.31137265239709E-13, 1.79886509245143E-16, 2.46757900199099E-19, 3.38488203290945E-22, 4.64318523032846E-25, 6.36925271649995E-28, 8.73697217626879E-31, 1.19848726697789E-33, 1.64401545538805E-36); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 1.0, 1.09861228866811E+00, 2.19722457733622E+00, 3.29583686600433E+00, 4.39444915467244E+00, 1.09861228866811E+01, 1.75777966186898E+01, 2.41694703506984E+01, 3.07611440827071E+01, 3.73528178147157E+01, 4.39444915467244E+01, 5.05361652787330E+01, 5.71278390107417E+01, 6.37195127427504E+01, 7.03111864747590E+01, 7.69028602067677E+01, 8.34945339387763E+01, -1.09861228866811E+00, -2.19722457733622E+00, -3.29583686600433E+00, -9.88751059801299E+00, -1.64791843300216E+01, -2.30708580620303E+01, -2.96625317940390E+01, -3.62542055260476E+01, -4.28458792580563E+01, -4.94375529900649E+01, -5.60292267220736E+01, -6.26209004540823E+01, -6.92125741860909E+01, -7.58042479180996E+01, -8.23959216501082E+01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 15 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := LOG(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("LOG", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process LN_TEST; LOG2_TEST : process constant ARG1 : REALX_VECTOR := ( 1.0, 2.0, 0.5, 8.0, 0.125, 1024.0); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 1.0, -1.0, 3.0, -3.0, 10.0); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 16 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := LOG2(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("LOG2", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process LOG2_TEST; LOG10_TEST : process constant ARG1 : REALX_VECTOR := ( 1.00000000000000E+00, 10.0, 3.00000000000000E+00, 9.00000000000000E+00, 2.70000000000000E+01, 8.10000000000000E+01, 2.43000000000000E+02, 1.77147000000000E+05, 1.29140163000000E+08, 9.41431788270000E+10, 6.86303773648830E+13, 5.00315450989997E+16, 3.64729963771708E+19, 2.65888143589575E+22, 1.93832456676800E+25, 1.41303860917387E+28, 1.03010514608775E+31, 7.50946651497973E+33, 5.47440108942022E+36, 3.33333333333333E-01, 1.11111111111111E-01, 3.70370370370370E-02, 5.08052634252909E-05, 6.96917193762563E-08, 9.55990663597481E-11, 1.31137265239709E-13, 1.79886509245143E-16, 2.46757900199099E-19, 3.38488203290945E-22, 4.64318523032846E-25, 6.36925271649995E-28, 8.73697217626879E-31, 1.19848726697789E-33, 1.64401545538805E-36); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 1.0, 4.77121254719663E-01, 9.54242509439325E-01, 1.43136376415899E+00, 1.90848501887865E+00, 2.38560627359831E+00, 5.24833380191629E+00, 8.11106133023426E+00, 1.09737888585522E+01, 1.38365163868702E+01, 1.66992439151882E+01, 1.95619714435062E+01, 2.24246989718241E+01, 2.52874265001421E+01, 2.81501540284601E+01, 3.10128815567781E+01, 3.38756090850960E+01, 3.67383366134140E+01, -4.77121254719663E-01, -9.54242509439325E-01, -1.43136376415899E+00, -4.29409129247696E+00, -7.15681882079494E+00, -1.00195463491129E+01, -1.28822738774309E+01, -1.57450014057489E+01, -1.86077289340668E+01, -2.14704564623848E+01, -2.43331839907028E+01, -2.71959115190208E+01, -3.00586390473387E+01, -3.29213665756567E+01, -3.57840941039747E+01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 17 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := LOG10(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("LOG10", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process LOG10_TEST; LOG_TEST : process constant ARG1 : REALX_VECTOR := ( 1.00000000000000E+00, 3.00000000000000E+00, 9.00000000000000E+00, 2.70000000000000E+01, 8.10000000000000E+01, 2.43000000000000E+02, 1.77147000000000E+05, 1.29140163000000E+08, 9.41431788270000E+10, 6.86303773648830E+13, 5.00315450989997E+16, 3.64729963771708E+19, 2.65888143589575E+22, 1.93832456676800E+25, 1.41303860917387E+28, 1.03010514608775E+31, 7.50946651497973E+33, 5.47440108942022E+36, 3.33333333333333E-01, 1.11111111111111E-01, 3.70370370370370E-02, 5.08052634252909E-05, 6.96917193762563E-08, 9.55990663597481E-11, 1.31137265239709E-13, 1.79886509245143E-16, 2.46757900199099E-19, 3.38488203290945E-22, 4.64318523032846E-25, 6.36925271649995E-28, 8.73697217626879E-31, 1.19848726697789E-33, 1.64401545538805E-36, 1.0, 2.0, 0.5, 8.0, 0.125, 1024.0, 6.25 ); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.5 ); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 4.77121254719663E-01, 9.54242509439325E-01, 1.43136376415899E+00, 1.90848501887865E+00, 2.38560627359831E+00, 5.24833380191629E+00, 8.11106133023426E+00, 1.09737888585522E+01, 1.38365163868702E+01, 1.66992439151882E+01, 1.95619714435062E+01, 2.24246989718241E+01, 2.52874265001421E+01, 2.81501540284601E+01, 3.10128815567781E+01, 3.38756090850960E+01, 3.67383366134140E+01, -4.77121254719663E-01, -9.54242509439325E-01, -1.43136376415899E+00, -4.29409129247696E+00, -7.15681882079494E+00, -1.00195463491129E+01, -1.28822738774309E+01, -1.57450014057489E+01, -1.86077289340668E+01, -2.14704564623848E+01, -2.43331839907028E+01, -2.71959115190208E+01, -3.00586390473387E+01, -3.29213665756567E+01, -3.57840941039747E+01, 0.0, 1.0, -1.0, 3.0, -3.0, 10.0, 2.0); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 18 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := LOG(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("LOG(X,BASE)", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process LOG_TEST; SIN_TEST : process constant ARG1 : REALX_VECTOR := ( 0.00000000000000E+00, 1.0*MATH_PI, 2.0*MATH_PI, -1.0*MATH_PI, -2.0*MATH_PI, 1.0*MATH_PI_OVER_2, 5.0*MATH_PI_OVER_2, 9.0*MATH_PI_OVER_2, -3.0*MATH_PI_OVER_2, -7.0*MATH_PI_OVER_2, 3.0*MATH_PI_OVER_2, 7.0*MATH_PI_OVER_2, 11.0*MATH_PI_OVER_2, -1.0*MATH_PI_OVER_2, -5.0*MATH_PI_OVER_2, 5.23598775598299E-01, 7.85398163397448E-01, 1.04719755119660E+00, 1.57079632679490E+00, 2.09439510239320E+00, 2.35619449019234E+00, 2.61799387799149E+00, 3.1415926535897901E+00, 3.66519142918809E+00, 3.92699081698724E+00, 4.18879020478639E+00, 4.71238898038469E+00, 5.23598775598299E+00, 5.49778714378214E+00, 5.75958653158129E+00, 6.28318530717959E+00, 1.57079632679490E+01, 8.16814089933346E+01, -8.16814089933346E+01, 8.48230016469244E+01, -8.48230016469244E+01, 8.32522053201295E+01, 1.00000000000000E+00, 2.00000000000000E+00); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 5.00000000000000E-01, 7.07106781186547E-01, 8.66025403784440E-01, 1.00000000000000E+00, 8.66025403784436E-01, 7.07106781186551E-01, 5.00000000000004E-01, 0.0, -4.99999999999998E-01, -7.07106781186546E-01, -8.66025403784438E-01, -1.00000000000000E+00, -8.66025403784438E-01, -7.07106781186546E-01, -4.99999999999998E-01, 0.0, 1.419869022E-08, 0.0, 0.0, 1.419869022E-08, -1.419869022E-08, 1.00000000000000E+00, 8.41470984807897E-01, 9.09297426825682E-01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 19 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := SIN(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("SIN", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process SIN_TEST; COS_TEST : process constant ARG1 : REALX_VECTOR := ( 1.0*MATH_PI_OVER_2, 3.0*MATH_PI_OVER_2, 5.0*MATH_PI_OVER_2, -1.0*MATH_PI_OVER_2, -3.0*MATH_PI_OVER_2, 0.0*MATH_PI, 2.0*MATH_PI, 4.0*MATH_PI, -2.0*MATH_PI, -4.0*MATH_PI, 1.0*MATH_PI, 3.0*MATH_PI, 5.0*MATH_PI, -1.0*MATH_PI, -3.0*MATH_PI, 0.00000000000000E+00, 5.23598775598299E-01, 7.85398163397448E-01, 1.04719755119660E+00, 1.57079632679490E+00, 2.09439510239320E+00, 2.35619449019234E+00, 2.61799387799149E+00, 3.14159265358979E+00, 3.66519142918809E+00, 3.92699081698724E+00, 4.18879020478639E+00, 4.71238898038469E+00, 5.23598775598299E+00, 5.49778714378214E+00, 5.75958653158129E+00, 6.28318530717959E+00, 1.57079632679490E+01, 8.16814089933346E+01, -8.16814089933346E+01, 8.48230016469244E+01, -8.48230016469244E+01, 8.325220532012951E+01, 1.00000000000000E+00, 2.00000000000000E+00); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 1.00000000000000E+00, 8.66025403784439E-01, 7.07106781186548E-01, 4.99999999999998E-01, 0.0, -5.00000000000004E-01, -7.07106781186544E-01, -8.66025403784436E-01, -1.00000000000000E+00, -8.66025403784440E-01, -7.07106781186549E-01, -5.00000000000001E-01, 0.0, 5.00000000000001E-01, 7.07106781186549E-01, 8.66025403784440E-01, 1.00000000000000E+00, -1.00000000000000E+00, 1.00000000000000E+00, 1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, 7.09934511E-09, 5.40302305868140E-01, -4.16146836547142E-01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 20 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := COS(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("COS", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process COS_TEST; TAN_TEST : process constant ARG1 : REALX_VECTOR := ( 0.00000000000000E+00, MATH_PI, 2.0*MATH_PI, -MATH_PI, -2.0*MATH_PI, 5.23598775598299E-01, 7.85398163397448E-01, 1.04719755119660E+00, 2.09439510239320E+00, 2.35619449019234E+00, 2.61799387799149E+00, 3.1415926535897901E+00, 3.66519142918809E+00, 3.92699081698724E+00, 4.18879020478639E+00, 5.23598775598299E+00, 5.49778714378214E+00, 5.75958653158129E+00, 6.28318530717959E+00, 1.57079632679490E+01, 8.16814089933346E+01, -8.16814089933346E+01, 8.48230016469244E+01, -8.48230016469244E+01, 1.00000000000000E+00, 2.00000000000000E+00); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 0.00000000000000E+00, 5.77350269189626E-01, 9.99999999999999E-01, 1.73205080756889E+00, -1.73205080756886E+00, -1.00000000000001E+00, -5.77350269189632E-01, 0.0, 5.77350269189623E-01, 9.99999999999997E-01, 1.73205080756887E+00, -1.73205080756887E+00, -9.99999999999997E-01, -5.77350269189623E-01, 0.0, -1.023944006E-08, 0.0, 0.0, -1.419869022E-08, 1.419869022E-08, 1.55740772465490E+00, -2.18503986326152E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 21 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := TAN(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("TAN", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process TAN_TEST; ARCSIN_TEST : process constant ARG1 : REALX_VECTOR := ( -1.00000000000000E+00, 0.00000000000000E+00, 1.00000000000000E+00, -1.00000000000000E+00, -9.00000000000000E-01, -8.00000000000000E-01, -7.00000000000000E-01, -6.00000000000000E-01, -5.00000000000000E-01, -4.00000000000000E-01, -3.00000000000000E-01, -2.00000000000000E-01, -1.00000000000000E-01, -1.38777878078145E-16, 9.99999999999999E-02, 2.00000000000000E-01, 3.00000000000000E-01, 4.00000000000000E-01, 5.00000000000000E-01, 6.00000000000000E-01, 7.00000000000000E-01, 8.00000000000000E-01, 9.00000000000000E-01, 1.00000000000000E+00); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -MATH_PI_OVER_2, 0.00000000000000E+00, MATH_PI_OVER_2, -1.57079632679490E+00, -1.11976951499863E+00, -9.27295218001612E-01, -7.75397496610753E-01, -6.43501108793284E-01, -5.23598775598299E-01, -4.11516846067488E-01, -3.04692654015398E-01, -2.01357920790331E-01, -1.00167421161560E-01, -1.38777878078145E-16, 1.00167421161560E-01, 2.01357920790331E-01, 3.04692654015398E-01, 4.11516846067488E-01, 5.23598775598299E-01, 6.43501108793284E-01, 7.75397496610753E-01, 9.27295218001612E-01, 1.11976951499863E+00, 1.57079632679490E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 22 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCSIN(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCSIN", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCSIN_TEST; ARCCOS_TEST : process constant ARG1 : REALX_VECTOR := ( -1.00000000000000E+00, 0.00000000000000E+00, 1.00000000000000E+00, -1.00000000000000E+00, -9.00000000000000E-01, -8.00000000000000E-01, -7.00000000000000E-01, -6.00000000000000E-01, -5.00000000000000E-01, -4.00000000000000E-01, -3.00000000000000E-01, -2.00000000000000E-01, -1.00000000000000E-01, -1.38777878078145E-16, 9.99999999999999E-02, 2.00000000000000E-01, 3.00000000000000E-01, 4.00000000000000E-01, 5.00000000000000E-01, 6.00000000000000E-01, 7.00000000000000E-01, 8.00000000000000E-01, 9.00000000000000E-01, 1.00000000000000E+00); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( MATH_PI, MATH_PI_OVER_2, 0.00000000000000E+00, 3.14159265358979E+00, 2.69056584179353E+00, 2.49809154479651E+00, 2.34619382340565E+00, 2.21429743558818E+00, 2.09439510239320E+00, 1.98231317286238E+00, 1.87548898081029E+00, 1.77215424758523E+00, 1.67096374795646E+00, 1.57079632679490E+00, 1.47062890563334E+00, 1.36943840600457E+00, 1.26610367277950E+00, 1.15927948072741E+00, 1.04719755119660E+00, 9.27295218001612E-01, 7.95398830184144E-01, 6.43501108793284E-01, 4.51026811796262E-01, 0.00000000000000E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 23 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCCOS(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCCOS", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCCOS_TEST; ARCTAN_TEST : process constant ARG1 : REALX_VECTOR := ( -1.00500000000000E+03, -9.05000000000000E+02, -8.05000000000000E+02, -7.05000000000000E+02, -6.05000000000000E+02, -5.05000000000000E+02, -4.05000000000000E+02, -3.05000000000000E+02, -2.05000000000000E+02, -1.05000000000000E+02, -5.00000000000000E+00, -4.50000000000000E+00, -4.00000000000000E+00, -3.50000000000000E+00, -3.00000000000000E+00, -2.50000000000000E+00, -2.00000000000000E+00, -1.50000000000000E+00, -1.00000000000000E+00, -5.00000000000000E-01, 0.00000000000000E+00, 5.00000000000000E-01, 1.00000000000000E+00, 1.50000000000000E+00, 2.00000000000000E+00, 2.50000000000000E+00, 3.00000000000000E+00, 3.50000000000000E+00, 4.00000000000000E+00, 4.50000000000000E+00, 5.00000000000000E+00, 1.05000000000000E+02, 2.05000000000000E+02, 3.05000000000000E+02, 4.05000000000000E+02, 5.05000000000000E+02, 6.05000000000000E+02, 7.05000000000000E+02, 8.05000000000000E+02, 9.05000000000000E+02); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -1.56980130224766E+00, -1.56969135486892E+00, -1.56955409140904E+00, -1.56937788802987E+00, -1.56914343573817E+00, -1.56881613136333E+00, -1.56832719601021E+00, -1.56751765001864E+00, -1.56591831670550E+00, -1.56127280520128E+00, -1.37340076694502E+00, -1.35212738092095E+00, -1.32581766366803E+00, -1.29249666778979E+00, -1.24904577239825E+00, -1.19028994968253E+00, -1.10714871779409E+00, -9.82793723247329E-01, -7.85398163397448E-01, -4.63647609000806E-01, 0.00000000000000E+00, 4.63647609000806E-01, 7.85398163397448E-01, 9.82793723247329E-01, 1.10714871779409E+00, 1.19028994968253E+00, 1.24904577239825E+00, 1.29249666778979E+00, 1.32581766366803E+00, 1.35212738092095E+00, 1.37340076694502E+00, 1.56127280520128E+00, 1.56591831670550E+00, 1.56751765001864E+00, 1.56832719601021E+00, 1.56881613136333E+00, 1.56914343573817E+00, 1.56937788802987E+00, 1.56955409140904E+00, 1.56969135486892E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 24 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCTAN(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCTAN", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCTAN_TEST; ARCTAN2_TEST : process constant ARG1 : REALX_VECTOR := ( 0.0, 0.0, 3.0, -3.0, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -1.00100000000000E+03, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -9.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 9.90000000000000E+01, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 1.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02, 9.99000000000000E+02); constant ARG2 : REALX_VECTOR(1 to ARG1'length) := ( 3.0, -3.0, 0.0, 0.0, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02, -1.00100000000000E+03, -9.01000000000000E+02, -8.01000000000000E+02, -7.01000000000000E+02, -6.01000000000000E+02, -5.01000000000000E+02, -4.01000000000000E+02, -3.01000000000000E+02, -2.01000000000000E+02, -1.01000000000000E+02, -1.00000000000000E+00, 9.90000000000000E+01, 1.99000000000000E+02, 2.99000000000000E+02, 3.99000000000000E+02, 4.99000000000000E+02, 5.99000000000000E+02, 6.99000000000000E+02, 7.99000000000000E+02, 8.99000000000000E+02, 9.99000000000000E+02); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.0, MATH_PI, MATH_PI_OVER_2, -MATH_PI_OVER_2, -2.35619449019234E+00, -2.30366661926516E+00, -2.24565908653521E+00, -2.18172340400569E+00, -2.11150959908993E+00, -2.03484345634976E+00, -1.95181932173628E+00, -1.86289455800327E+00, -1.76896023071179E+00, -1.67135509872262E+00, -1.57179532746156E+00, -1.47221581315609E+00, -1.37455372569624E+00, -1.28053142686585E+00, -1.19149622171506E+00, -1.10834823741070E+00, -1.03155295065123E+00, -9.61211071835094E-01, -8.97152811273815E-01, -8.39030890387206E-01, -7.86398163064115E-01, -2.40872236111953E+00, -2.35619449019234E+00, -2.29750755223232E+00, -2.23199315268187E+00, -2.15905501228309E+00, -2.07827169191935E+00, -1.98953543034286E+00, -1.89321266005455E+00, -1.79028773752862E+00, -1.68242796909766E+00, -1.57190620425260E+00, -1.46135742860496E+00, -1.35342043298036E+00, -1.25037821664635E+00, -1.15391151212805E+00, -1.06501807814244E+00, -9.84075445180675E-01, -9.10983737233827E-01, -8.45326318518656E-01, -7.86509274051312E-01, -7.33864883156771E-01, -2.46672989384948E+00, -2.41488142815237E+00, -2.35619449019234E+00, -2.28971470467524E+00, -2.21449715597698E+00, -2.12973222913349E+00, -2.03494318687754E+00, -1.93025089792998E+00, -1.81665604696251E+00, -1.69622675494150E+00, -1.57204476559698E+00, -1.44782445723060E+00, -1.32728695441207E+00, -1.21353147331911E+00, -1.10864796704559E+00, -1.01365719237471E+00, -9.28694937143484E-01, -8.53293642560509E-01, -7.86648162746407E-01, -7.27814834799237E-01, -6.75838636623504E-01, -2.53066557637900E+00, -2.48039582770282E+00, -2.42267427570945E+00, -2.35619449019234E+00, -2.27954006632482E+00, -2.19131564547489E+00, -2.09040319972483E+00, -1.97637658112955E+00, -1.85003778247013E+00, -1.71389146389291E+00, -1.57222285935077E+00, -1.43049735313154E+00, -1.29419317888602E+00, -1.16762748849479E+00, -1.05334173792262E+00, -9.52168022855722E-01, -8.63699285330242E-01, -7.86826733854204E-01, -7.20157549952455E-01, -6.62274126837964E-01, -6.11867133256799E-01, -2.60087938129476E+00, -2.55333396810160E+00, -2.49789182440771E+00, -2.43284891405987E+00, -2.35619449019234E+00, -2.26569824232904E+00, -2.15918280748292E+00, -2.03510927169220E+00, -1.89354488485221E+00, -1.73729380295997E+00, -1.57246021877019E+00, -1.40753698586366E+00, -1.25104377173758E+00, -1.10914738268772E+00, -9.84716058441887E-01, -8.77861031762038E-01, -7.87064828520908E-01, -7.10155862651441E-01, -6.44901387934081E-01, -5.89284982942072E-01, -5.41596316438125E-01, -2.67754552403493E+00, -2.63411728846534E+00, -2.58265675125120E+00, -2.52107333490980E+00, -2.44669073805565E+00, -2.35619449019234E+00, -2.24578063722976E+00, -2.11180268145820E+00, -1.95233469528497E+00, -1.76972680485610E+00, -1.57279233212820E+00, -1.37570491033282E+00, -1.19270124366572E+00, -1.03272838009687E+00, -8.98249967734331E-01, -7.87398160730788E-01, -6.96541848597555E-01, -6.21871544576455E-01, -5.60060480989096E-01, -5.08419756926629E-01, -4.64848088616192E-01, -2.76056965864841E+00, -2.72285355004183E+00, -2.67744579350715E+00, -2.62198578065986E+00, -2.55320617290177E+00, -2.46660834315493E+00, -2.35619449019234E+00, -2.21469631869427E+00, -2.03544094443843E+00, -1.81753451889775E+00, -1.57329008721149E+00, -1.32875365053432E+00, -1.11014571181809E+00, -9.30094091140908E-01, -7.87898158189135E-01, -6.76936596172640E-01, -5.89926418026814E-01, -5.20839201746805E-01, -4.65148358249306E-01, -4.19565226145361E-01, -3.81713897657087E-01, -2.84949442238142E+00, -2.81917632033014E+00, -2.78213808245471E+00, -2.73601239925514E+00, -2.67727970869248E+00, -2.60058629892649E+00, -2.49769266169042E+00, -2.35619449019234E+00, -2.15956521371738E+00, -1.89453891042913E+00, -1.57411857370815E+00, -1.25303776716068E+00, -9.86636901866293E-01, -7.88731484385185E-01, -6.46302221915377E-01, -5.42773821994867E-01, -4.65648940551621E-01, -4.06617112385411E-01, -3.60278551238781E-01, -3.23084776420147E-01, -2.92650220882730E-01, -2.94342874967290E+00, -2.92210124285607E+00, -2.89573293342218E+00, -2.86235119791456E+00, -2.81884409553248E+00, -2.76005428509972E+00, -2.67694803594626E+00, -2.55282376666731E+00, -2.35619449019234E+00, -2.03643200474705E+00, -1.57577141012575E+00, -1.11313667017800E+00, -7.90398121731407E-01, -5.91851699242266E-01, -4.66650602976804E-01, -3.82922665126500E-01, -3.23752553723968E-01, -2.79999374082147E-01, -2.46450549023023E-01, -2.19964129419116E-01, -1.98550293747721E-01, -3.04103388166207E+00, -3.02996101128703E+00, -3.01616222544319E+00, -2.99849751649178E+00, -2.97509517742472E+00, -2.94266217552859E+00, -2.89485446148694E+00, -2.81785006995556E+00, -2.67595697563764E+00, -2.35619449019234E+00, -1.58069699338289E+00, -7.95397830084114E-01, -4.69659560616739E-01, -3.25758548967066E-01, -2.47925030558522E-01, -1.99706803808393E-01, -1.67043127110379E-01, -1.43498975540674E-01, -1.25741101775488E-01, -1.11877923692566E-01, -1.00758732328938E-01, -3.14059365292313E+00, -3.14048277613209E+00, -3.14034421478771E+00, -3.14016612103392E+00, -3.13992876161449E+00, -3.13959664825649E+00, -3.13909889317320E+00, -3.13827040667654E+00, -3.13661757025894E+00, -3.13169198700180E+00, -2.35619449019234E+00, -1.01006665853219E-02, -5.02508333081241E-03, -3.34446913547142E-03, -2.50626041658822E-03, -2.00400533330765E-03, -1.66944753085388E-03, -1.43061418852778E-03, -1.25156380208089E-03, -1.11234659350573E-03, -1.00100066666587E-03, 3.04301213995099E+00, 3.03215375539985E+00, 3.01862078402550E+00, 3.00129367992644E+00, 2.97833331265855E+00, 2.94650123712772E+00, 2.89954997732922E+00, 2.82383409395557E+00, 2.68393299697290E+00, 2.36619415687901E+00, 1.58089699338022E+00, 7.85398163397448E-01, 4.61635539281440E-01, 3.19742524967046E-01, 2.43208753470570E-01, 1.95853541025837E-01, 1.63794765433888E-01, 1.40695132106014E-01, 1.23276578696141E-01, 1.09680420507763E-01, 9.87765920676627E-02, 2.94535005249114E+00, 2.92421675977526E+00, 2.89808328120697E+00, 2.86498950568092E+00, 2.82184009853248E+00, 2.76349757046062E+00, 2.68094203861298E+00, 2.55743322866119E+00, 2.36119444852630E+00, 2.04045588741164E+00, 1.57582141012571E+00, 1.10916078751346E+00, 7.85398163397448E-01, 5.87230402928853E-01, 4.62644600310076E-01, 3.79469391656208E-01, 3.20748550723967E-01, 2.77354658341414E-01, 2.44095010926817E-01, 2.17844349524145E-01, 1.96625440633627E-01, 2.85132775366075E+00, 2.82117454344125E+00, 2.78432780011400E+00, 2.73842381528969E+00, 2.67994370948262E+00, 2.60352470689177E+00, 2.50089041793580E+00, 2.35952781118008E+00, 2.16264802603716E+00, 1.89655487576196E+00, 1.57414079593037E+00, 1.25105380182785E+00, 9.83565923866044E-01, 7.85398163397448E-01, 6.43099985669993E-01, 5.39829877697403E-01, 4.62979606428156E-01, 4.04200940108289E-01, 3.58084705225195E-01, 3.21082997753481E-01, 2.90813825888230E-01, 2.76229254850996E+00, 2.72470783892295E+00, 2.67944429384049E+00, 2.62413806471752E+00, 2.55551238523678E+00, 2.46904629452923E+00, 2.35869448498403E+00, 2.21709854871027E+00, 2.03744692977170E+00, 1.81872135735342E+00, 1.57330258721148E+00, 1.32758757332433E+00, 1.10815172648482E+00, 9.27696341124904E-01, 7.85398163397448E-01, 6.74496503215955E-01, 5.87617247111922E-01, 5.18683793428791E-01, 4.63146857915971E-01, 4.17708173952516E-01, 3.79988510768188E-01, 2.67914456420560E+00, 2.63581440493733E+00, 2.58445351916960E+00, 2.52296434965062E+00, 2.44865735855693E+00, 2.35819448752568E+00, 2.24773292296754E+00, 2.11357014878976E+00, 1.95371899192140E+00, 1.77050313060329E+00, 1.57280033212820E+00, 1.37494278576906E+00, 1.19132693513869E+00, 1.03096644909749E+00, 8.96299823578942E-01, 7.85398163397448E-01, 6.94574045618446E-01, 6.19978776731178E-01, 5.58261743622392E-01, 5.06720646862616E-01, 4.63247128445524E-01, 2.60234927744613E+00, 2.55487177197557E+00, 2.49949126393838E+00, 2.43449561212514E+00, 2.35786115531580E+00, 2.26733817539245E+00, 2.16072274482171E+00, 2.03644526734652E+00, 1.89454888051886E+00, 1.73783945390528E+00, 1.57246577432575E+00, 1.40700156136101E+00, 1.25004777607093E+00, 1.10781672036674E+00, 9.83179079682975E-01, 8.76222281176451E-01, 7.85398163397448E-01, 7.08508444862986E-01, 6.43300828403413E-01, 5.87745864143709E-01, 5.40125036203712E-01, 2.53200739862999E+00, 2.48178006402872E+00, 2.42408996935541E+00, 2.35762306064910E+00, 2.28095218944634E+00, 2.19266787137135E+00, 2.09163552854170E+00, 1.97741343918031E+00, 1.85079570087704E+00, 1.71429530233557E+00, 1.57222694098342E+00, 1.43010119468888E+00, 1.29344166845348E+00, 1.16659538668661E+00, 1.05211253336611E+00, 9.50817550063719E-01, 8.62287881931910E-01, 7.85398163397448E-01, 7.18741386418489E-01, 6.60889133115614E-01, 6.10524392128282E-01, 2.46794913806871E+00, 2.41612264531355E+00, 2.35744448954130E+00, 2.29095387674735E+00, 2.21569771472898E+00, 2.13085680778399E+00, 2.03594468504420E+00, 1.93107487803368E+00, 1.81724687581792E+00, 1.69653742857038E+00, 1.57204789059698E+00, 1.44751974809876E+00, 1.32670131586808E+00, 1.21271162156970E+00, 1.10764946887893E+00, 1.01253458317250E+00, 9.27495498391484E-01, 8.52054940376408E-01, 7.85398163397448E-01, 7.26573294213562E-01, 6.74618857008679E-01, 2.40982721718210E+00, 2.35730560084621E+00, 2.29861116159413E+00, 2.23307045363286E+00, 2.16008130973697E+00, 2.07921608372153E+00, 1.99036155294026E+00, 1.89388110321504E+00, 1.79076045621401E+00, 1.68267425048746E+00, 1.57190867338840E+00, 1.46111590628713E+00, 1.35295197727075E+00, 1.24971332904142E+00, 1.15308815284238E+00, 1.06407567993228E+00, 9.83050462651187E-01, 9.09907193679282E-01, 8.44223032581334E-01, 7.85398163397448E-01, 7.32759795111047E-01, 2.35719448985901E+00, 2.30466120995167E+00, 2.24663496341840E+00, 2.18266346005170E+00, 2.11239264323302E+00, 2.03564441541109E+00, 1.95251022445198E+00, 1.86344654767763E+00, 1.76934662054262E+00, 1.67155505912383E+00, 1.57179732746156E+00, 1.47201973472723E+00, 1.37417088616127E+00, 1.27998250090667E+00, 1.19080781602671E+00, 1.10754919834937E+00, 1.03067129059118E+00, 9.60271934666615E-01, 8.96177469786218E-01, 8.38036531683849E-01, 7.85398163397448E-01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 25 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCTAN(ARG1(I), ARG2(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCTAN(Y,X)", ARG1, ARG2, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCTAN2_TEST; SINH_TEST : process constant ARG1 : REALX_VECTOR := ( -6.28318530717959E+01, -3.14159265358979E+01, -2.51327412287183E+01, -1.25663706143593E+01, -1.00000000000000E+01, -9.50000000000000E+00, -9.00000000000000E+00, -8.50000000000000E+00, -8.00000000000000E+00, -7.50000000000000E+00, -7.00000000000000E+00, -6.50000000000000E+00, -6.28318530717959E+00, -6.00000000000000E+00, -5.50000000000000E+00, -5.00000000000000E+00, -4.50000000000000E+00, -4.00000000000000E+00, -3.50000000000000E+00, -3.14159265358979E+00, -3.00000000000000E+00, -2.50000000000000E+00, -2.00000000000000E+00, -1.57079632679489E+00, -1.50000000000000E+00, -1.00000000000000E+00, -7.85398163397448E-01, -5.00000000000000E-01, -3.92699081698724E-01, -1.96349540849362E-01, 0.00000000000000E+00, 1.96349540849362E-01, 3.92699081698724E-01, 5.00000000000000E-01, 7.85398163397448E-01, 1.00000000000000E+00, 1.50000000000000E+00, 1.57079632679489E+00, 2.00000000000000E+00, 2.50000000000000E+00, 3.00000000000000E+00, 3.14159265358979E+00, 3.50000000000000E+00, 4.00000000000000E+00, 4.50000000000000E+00, 5.00000000000000E+00, 5.50000000000000E+00, 6.00000000000000E+00, 6.28318530717959E+00, 6.50000000000000E+00, 7.00000000000000E+00, 7.50000000000000E+00, 8.00000000000000E+00, 8.50000000000000E+00, 9.00000000000000E+00, 9.50000000000000E+00, 1.00000000000000E+01, 1.25663706143593E+01, 2.51327412287183E+01, 3.14159265358979E+01, 6.28318530717959E+01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -9.69386754177469E+26, -2.20157529303153E+13, -4.11131577927957E+10, -1.43375656566601E+05, -1.10132328747034E+04, -6.67986337740502E+03, -4.05154190208279E+03, -2.45738431841538E+03, -1.49047882578955E+03, -9.04020930685847E+02, -5.48316123273247E+02, -3.32570064802584E+02, -2.67744894041017E+02, -2.01713157370279E+02, -1.22343922746391E+02, -7.42032105777888E+01, -4.50030111519918E+01, -2.72899171971278E+01, -1.65426272876350E+01, -1.15487393572577E+01, -1.00178749274099E+01, -6.05020448103979E+00, -3.62686040784702E+00, -2.30129890230728E+00, -2.12927945509482E+00, -1.17520119364380E+00, -8.68670961486009E-01, -5.21095305493747E-01, -4.02870381917066E-01, -1.97613623736882E-01, 0.00000000000000E+00, 1.97613623736882E-01, 4.02870381917066E-01, 5.21095305493747E-01, 8.68670961486009E-01, 1.17520119364380E+00, 2.12927945509482E+00, 2.30129890230728E+00, 3.62686040784702E+00, 6.05020448103979E+00, 1.00178749274099E+01, 1.15487393572577E+01, 1.65426272876350E+01, 2.72899171971278E+01, 4.50030111519918E+01, 7.42032105777888E+01, 1.22343922746391E+02, 2.01713157370279E+02, 2.67744894041017E+02, 3.32570064802584E+02, 5.48316123273247E+02, 9.04020930685847E+02, 1.49047882578955E+03, 2.45738431841538E+03, 4.05154190208279E+03, 6.67986337740502E+03, 1.10132328747034E+04, 1.43375656566601E+05, 4.11131577927957E+10, 2.20157529303153E+13, 9.69386754177469E+26); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 26 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := SINH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("SINH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process SINH_TEST; COSH_TEST : process constant ARG1 : REALX_VECTOR := ( -6.28318530717959E+01, -3.14159265358979E+01, -2.51327412287183E+01, -1.25663706143593E+01, -1.00000000000000E+01, -9.50000000000000E+00, -9.00000000000000E+00, -8.50000000000000E+00, -8.00000000000000E+00, -7.50000000000000E+00, -7.00000000000000E+00, -6.50000000000000E+00, -6.28318530717959E+00, -6.00000000000000E+00, -5.50000000000000E+00, -5.00000000000000E+00, -4.50000000000000E+00, -4.00000000000000E+00, -3.50000000000000E+00, -3.14159265358979E+00, -3.00000000000000E+00, -2.50000000000000E+00, -2.00000000000000E+00, -1.57079632679489E+00, -1.50000000000000E+00, -1.00000000000000E+00, -7.85398163397448E-01, -5.00000000000000E-01, -3.92699081698724E-01, -1.96349540849362E-01, 0.00000000000000E+00, 1.96349540849362E-01, 3.92699081698724E-01, 5.00000000000000E-01, 7.85398163397448E-01, 1.00000000000000E+00, 1.50000000000000E+00, 1.57079632679489E+00, 2.00000000000000E+00, 2.50000000000000E+00, 3.00000000000000E+00, 3.14159265358979E+00, 3.50000000000000E+00, 4.00000000000000E+00, 4.50000000000000E+00, 5.00000000000000E+00, 5.50000000000000E+00, 6.00000000000000E+00, 6.28318530717959E+00, 6.50000000000000E+00, 7.00000000000000E+00, 7.50000000000000E+00, 8.00000000000000E+00, 8.50000000000000E+00, 9.00000000000000E+00, 9.50000000000000E+00, 1.00000000000000E+01, 1.25663706143593E+01, 2.51327412287183E+01, 3.14159265358979E+01, 6.28318530717959E+01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 9.69386754177469E+26, 2.20157529303153E+13, 4.11131577927957E+10, 1.43375656570088E+05, 1.10132329201033E+04, 6.67986345225685E+03, 4.05154202549260E+03, 2.45738452188375E+03, 1.49047916125218E+03, 9.04021483770217E+02, 5.48317035155212E+02, 3.32571568241777E+02, 2.67746761483749E+02, 2.01715636122456E+02, 1.22348009517829E+02, 7.42099485247879E+01, 4.50141201485300E+01, 2.73082328360165E+01, 1.65728246710573E+01, 1.15919532755215E+01, 1.00676619957778E+01, 6.13228947966369E+00, 3.76219569108363E+00, 2.50917847865804E+00, 2.35240961524325E+00, 1.54308063481524E+00, 1.32460908925201E+00, 1.12762596520638E+00, 1.07810228857284E+00, 1.01933858177076E+00, 1.00000000000000E+00, 1.01933858177076E+00, 1.07810228857284E+00, 1.12762596520638E+00, 1.32460908925201E+00, 1.54308063481524E+00, 2.35240961524325E+00, 2.50917847865804E+00, 3.76219569108363E+00, 6.13228947966369E+00, 1.00676619957778E+01, 1.15919532755215E+01, 1.65728246710573E+01, 2.73082328360165E+01, 4.50141201485300E+01, 7.42099485247879E+01, 1.22348009517829E+02, 2.01715636122456E+02, 2.67746761483749E+02, 3.32571568241777E+02, 5.48317035155212E+02, 9.04021483770217E+02, 1.49047916125218E+03, 2.45738452188375E+03, 4.05154202549260E+03, 6.67986345225685E+03, 1.10132329201033E+04, 1.43375656570088E+05, 4.11131577927957E+10, 2.20157529303153E+13, 9.69386754177469E+26); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 27 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := COSH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("COSH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process COSH_TEST; TANH_TEST : process constant ARG1 : REALX_VECTOR := ( -6.28318530717959E+01, -3.14159265358979E+01, -2.51327412287183E+01, -2.00000000000000E+01, -1.50000000000000E+01, -1.25663706143593E+01, -1.00000000000000E+01, -6.28318530717959E+00, -5.00000000000000E+00, -3.14159265358979E+00, -2.00000000000000E+00, -1.90000000000000E+00, -1.80000000000000E+00, -1.70000000000000E+00, -1.60000000000000E+00, -1.57079632679489E+00, -1.50000000000000E+00, -1.40000000000000E+00, -1.30000000000000E+00, -1.20000000000000E+00, -1.00000000000000E+00, -9.00000000000000E-01, -8.00000000000000E-01, -7.85398163397448E-01, -7.00000000000000E-01, -6.00000000000000E-01, -5.00000000000000E-01, -4.00000000000000E-01, -3.92699081698724E-01, -3.00000000000000E-01, -2.00000000000000E-01, -1.96349540849362E-01, -1.00000000000000E-01, 0.00000000000000E+00, 1.00000000000000E-01, 1.96349540849362E-01, 2.00000000000000E-01, 3.00000000000000E-01, 3.92699081698724E-01, 4.00000000000000E-01, 5.00000000000000E-01, 6.00000000000000E-01, 7.00000000000000E-01, 7.85398163397448E-01, 8.00000000000000E-01, 9.00000000000000E-01, 1.00000000000000E+00, 1.10000000000000E+00, 1.20000000000000E+00, 1.30000000000000E+00, 1.40000000000000E+00, 1.50000000000000E+00, 1.57079632679489E+00, 1.60000000000000E+00, 1.70000000000000E+00, 1.80000000000000E+00, 1.90000000000000E+00, 2.00000000000000E+00, 3.14159265358979E+00, 5.00000000000000E+00, 6.28318530717959E+00, 1.00000000000000E+01, 1.50000000000000E+01, 1.25663706143593E+01, 2.00000000000000E+01, 2.51327412287183E+01, 3.14159265358979E+01, 6.28318530717959E+01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -1.00000000000000E+00, -9.99999999999813E-01, -9.99999999975677E-01, -9.99999995877693E-01, -9.99993025339611E-01, -9.99909204262595E-01, -9.96272076220750E-01, -9.64027580075817E-01, -9.56237458127739E-01, -9.46806012846268E-01, -9.35409070603099E-01, -9.21668554406471E-01, -9.17152335667273E-01, -9.05148253644866E-01, -8.85351648202263E-01, -8.61723159313306E-01, -8.33654607012155E-01, -7.61594155955765E-01, -7.16297870199025E-01, -6.64036770267849E-01, -6.55794202632672E-01, -6.04367777117164E-01, -5.37049566998035E-01, -4.62117157260010E-01, -3.79948962255225E-01, -3.73684747901215E-01, -2.91312612451591E-01, -1.97375320224904E-01, -1.93864558127089E-01, -9.96679946249558E-02, 0.00000000000000E+00, 9.96679946249558E-02, 1.93864558127089E-01, 1.97375320224904E-01, 2.91312612451591E-01, 3.73684747901215E-01, 3.79948962255225E-01, 4.62117157260010E-01, 5.37049566998035E-01, 6.04367777117164E-01, 6.55794202632672E-01, 6.64036770267849E-01, 7.16297870199025E-01, 7.61594155955765E-01, 8.00499021760630E-01, 8.33654607012155E-01, 8.61723159313306E-01, 8.85351648202263E-01, 9.05148253644866E-01, 9.17152335667273E-01, 9.21668554406471E-01, 9.35409070603099E-01, 9.46806012846268E-01, 9.56237458127739E-01, 9.64027580075817E-01, 9.96272076220750E-01, 9.99909204262595E-01, 9.99993025339611E-01, 9.99999995877693E-01, 9.99999999999813E-01, 9.99999999975677E-01, 1.00000000000000E+00, 1.00000000000000E+00, 1.00000000000000E+00, 1.00000000000000E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 28 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := TANH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("TANH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process TANH_TEST; ARCSINH_TEST : process constant ARG1 : REALX_VECTOR := ( -6.28318530717959E+01, -3.14159265358979E+01, -2.51327412287183E+01, -1.25663706143593E+01, -1.00000000000000E+01, -9.50000000000000E+00, -9.00000000000000E+00, -8.50000000000000E+00, -8.00000000000000E+00, -7.50000000000000E+00, -7.00000000000000E+00, -6.50000000000000E+00, -6.28318530717959E+00, -6.00000000000000E+00, -5.50000000000000E+00, -5.00000000000000E+00, -4.50000000000000E+00, -4.00000000000000E+00, -3.50000000000000E+00, -3.14159265358979E+00, -3.00000000000000E+00, -2.50000000000000E+00, -2.00000000000000E+00, -1.57079632679489E+00, -1.50000000000000E+00, -1.00000000000000E+00, -7.85398163397448E-01, -5.00000000000000E-01, -3.92699081698724E-01, -1.96349540849362E-01, 0.00000000000000E+00, 1.96349540849362E-01, 3.92699081698724E-01, 5.00000000000000E-01, 7.85398163397448E-01, 1.00000000000000E+00, 1.50000000000000E+00, 1.57079632679489E+00, 2.00000000000000E+00, 2.50000000000000E+00, 3.00000000000000E+00, 3.14159265358979E+00, 3.50000000000000E+00, 4.00000000000000E+00, 4.50000000000000E+00, 5.00000000000000E+00, 5.50000000000000E+00, 6.00000000000000E+00, 6.28318530717959E+00, 6.50000000000000E+00, 7.00000000000000E+00, 7.50000000000000E+00, 8.00000000000000E+00, 8.50000000000000E+00, 9.00000000000000E+00, 9.50000000000000E+00, 1.00000000000000E+01, 1.25663706143593E+01, 2.51327412287183E+01, 3.14159265358979E+01, 6.28318530717959E+01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -4.83367265968874E+00, -4.14071536617305E+00, -3.91771415919954E+00, -3.22575082468029E+00, -2.99822295029797E+00, -2.94719762257003E+00, -2.89344398588587E+00, -2.83665572896893E+00, -2.77647228072372E+00, -2.71246530518434E+00, -2.64412076105863E+00, -2.57081467809570E+00, -2.53729750137336E+00, -2.49177985264491E+00, -2.40605912529802E+00, -2.31243834127275E+00, -2.20934770861533E+00, -2.09471254726110E+00, -1.96572047164965E+00, -1.86229574331085E+00, -1.81844645923207E+00, -1.64723114637110E+00, -1.44363547517881E+00, -1.23340311751121E+00, -1.19476321728711E+00, -8.81373587019543E-01, -7.21225488726780E-01, -4.81211825059604E-01, -3.83248085039393E-01, -1.95109290972995E-01, 0.00000000000000E+00, 1.95109290972995E-01, 3.83248085039393E-01, 4.81211825059604E-01, 7.21225488726780E-01, 8.81373587019543E-01, 1.19476321728711E+00, 1.23340311751121E+00, 1.44363547517881E+00, 1.64723114637110E+00, 1.81844645923207E+00, 1.86229574331085E+00, 1.96572047164965E+00, 2.09471254726110E+00, 2.20934770861533E+00, 2.31243834127275E+00, 2.40605912529802E+00, 2.49177985264491E+00, 2.53729750137336E+00, 2.57081467809570E+00, 2.64412076105863E+00, 2.71246530518434E+00, 2.77647228072372E+00, 2.83665572896893E+00, 2.89344398588587E+00, 2.94719762257003E+00, 2.99822295029797E+00, 3.22575082468029E+00, 3.91771415919954E+00, 4.14071536617305E+00, 4.83367265968874E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 29 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCSINH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCSINH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCSINH_TEST; ARCCOSH_TEST : process constant ARG1 : REALX_VECTOR := ( 1.00000000000000E+00, 1.50000000000000E+00, 1.57079632679489E+00, 2.00000000000000E+00, 2.50000000000000E+00, 3.00000000000000E+00, 3.14159265358979E+00, 3.50000000000000E+00, 4.00000000000000E+00, 4.50000000000000E+00, 5.00000000000000E+00, 5.50000000000000E+00, 6.00000000000000E+00, 6.28318530717959E+00, 6.50000000000000E+00, 7.00000000000000E+00, 7.50000000000000E+00, 8.00000000000000E+00, 8.50000000000000E+00, 9.00000000000000E+00, 9.50000000000000E+00, 1.00000000000000E+01, 1.25663706143593E+01, 2.51327412287183E+01, 3.14159265358979E+01, 6.28318530717959E+01, 1.00000000000000E+02, 3.00000000000000E+02, 5.00000000000000E+02, 1.00000000000000E+03, 3.00000000000000E+03, 5.00000000000000E+03, 1.00000000000000E+05, 3.00000000000000E+05, 5.00000000000000E+05, 1.00000000000000E+10); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( 0.00000000000000E+00, 9.62423650119207E-01, 1.02322747854755E+00, 1.31695789692482E+00, 1.56679923697241E+00, 1.76274717403909E+00, 1.81152627246085E+00, 1.92484730023841E+00, 2.06343706889556E+00, 2.18464379160511E+00, 2.29243166956118E+00, 2.38952643457422E+00, 2.47788873028848E+00, 2.52463065993347E+00, 2.55897897702861E+00, 2.63391579384963E+00, 2.70357583093140E+00, 2.76865938331357E+00, 2.82973503752439E+00, 2.88727095035762E+00, 2.94165731465119E+00, 2.99322284612638E+00, 3.22258451123829E+00, 3.91692258703901E+00, 4.14020876014649E+00, 4.83354600820749E+00, 5.29829236561049E+00, 6.39692687742679E+00, 6.90775427898064E+00, 7.60090220954199E+00, 8.69951472043241E+00, 9.21034036197618E+00, 1.22060726455052E+01, 1.33046849341955E+01, 1.38155105579633E+01, 2.37189981105004E+01); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 30 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCCOSH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCCOSH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); wait; end process ARCCOSH_TEST; ARCTANH_TEST : process constant ARG1 : REALX_VECTOR := ( -9.99999900000000E-01, -9.99990000000000E-01, -9.99000000000000E-01, -9.90000000000000E-01, -9.80000000000000E-01, -9.70000000000000E-01, -9.60000000000000E-01, -9.50000000000000E-01, -9.00000000000000E-01, -8.50000000000000E-01, -8.00000000000000E-01, -7.85398163397448E-01, -7.50000000000000E-01, -7.00000000000000E-01, -6.50000000000000E-01, -6.00000000000000E-01, -5.50000000000000E-01, -5.00000000000000E-01, -4.50000000000000E-01, -4.00000000000000E-01, -3.92699081698724E-01, -3.50000000000000E-01, -3.00000000000000E-01, -2.50000000000000E-01, -2.00000000000000E-01, -1.96349540849362E-01, -1.90000000000000E-01, -1.80000000000000E-01, -1.70000000000000E-01, -1.60000000000000E-01, -1.50000000000000E-01, -1.40000000000000E-01, -1.30000000000000E-01, -1.20000000000000E-01, -1.10000000000000E-01, -1.00000000000000E-01, 0.00000000000000E+00, 1.00000000000000E-01, 1.10000000000000E-01, 1.20000000000000E-01, 1.30000000000000E-01, 1.40000000000000E-01, 1.50000000000000E-01, 1.60000000000000E-01, 1.70000000000000E-01, 1.80000000000000E-01, 1.90000000000000E-01, 1.96349540849362E-01, 2.00000000000000E-01, 2.50000000000000E-01, 3.00000000000000E-01, 3.50000000000000E-01, 3.92699081698724E-01, 4.00000000000000E-01, 4.50000000000000E-01, 5.00000000000000E-01, 5.50000000000000E-01, 6.00000000000000E-01, 6.50000000000000E-01, 7.00000000000000E-01, 7.50000000000000E-01, 7.85398163397448E-01, 8.00000000000000E-01, 8.50000000000000E-01, 9.00000000000000E-01, 9.50000000000000E-01, 9.60000000000000E-01, 9.70000000000000E-01, 9.80000000000000E-01, 9.90000000000000E-01, 9.99000000000000E-01, 9.99990000000000E-01, 9.99999900000000E-01); constant CORRECT_ANSWERS : REALX_VECTOR(1 to ARG1'length) := ( -8.40562139075913E+00, -6.10303382275884E+00, -3.80020116725020E+00, -2.64665241236225E+00, -2.29755992506729E+00, -2.09229572003494E+00, -1.94591014905531E+00, -1.83178082306482E+00, -1.47221948958322E+00, -1.25615281198806E+00, -1.09861228866811E+00, -1.05930617082324E+00, -9.72955074527657E-01, -8.67300527694053E-01, -7.75298706205584E-01, -6.93147180559945E-01, -6.18381313574464E-01, -5.49306144334055E-01, -4.84700278594052E-01, -4.23648930193602E-01, -4.14987256841989E-01, -3.65443754271396E-01, -3.09519604203112E-01, -2.55412811882995E-01, -2.02732554054082E-01, -1.98932863850063E-01, -1.92337169219545E-01, -1.81982688600706E-01, -1.71666663500579E-01, -1.61386696131526E-01, -1.51140435936467E-01, -1.40925576070494E-01, -1.30739850028878E-01, -1.20581028408444E-01, -1.10446915790097E-01, -1.00335347731076E-01, 0.00000000000000E+00, 1.00335347731076E-01, 1.10446915790097E-01, 1.20581028408444E-01, 1.30739850028878E-01, 1.40925576070494E-01, 1.51140435936467E-01, 1.61386696131526E-01, 1.71666663500579E-01, 1.81982688600706E-01, 1.92337169219545E-01, 1.98932863850063E-01, 2.02732554054082E-01, 2.55412811882995E-01, 3.09519604203112E-01, 3.65443754271396E-01, 4.14987256841989E-01, 4.23648930193602E-01, 4.84700278594052E-01, 5.49306144334055E-01, 6.18381313574464E-01, 6.93147180559945E-01, 7.75298706205584E-01, 8.67300527694053E-01, 9.72955074527657E-01, 1.05930617082324E+00, 1.09861228866811E+00, 1.25615281198806E+00, 1.47221948958322E+00, 1.83178082306482E+00, 1.94591014905531E+00, 2.09229572003494E+00, 2.29755992506729E+00, 2.64665241236225E+00, 3.80020116725020E+00, 6.10303382275884E+00, 8.40562139075913E+00); variable RESULTS : REALX_VECTOR(1 to ARG1'length); variable ACCURACY : INT_VECTOR(1 to ARG1'length); begin wait for 31 ns; -- compute results for I in 1 to ARG1'length loop RESULTS(I) := ARCTANH(ARG1(I)); end loop; -- compute accuracy for I in 1 to ARG1'length loop ACCURACY(I) := COMPARE(CORRECT_ANSWERS(I), RESULTS(I)); end loop; -- print results PRINT_RESULTS("ARCTANH", ARG1, RESULTS, CORRECT_ANSWERS, ACCURACY, FULL_RESULTS); report "MATH_REAL test completed" severity note; wait; end process ARCTANH_TEST; end architecture ARCH; nvc-r1.17.1/test/regress/ieee17.vhd000066400000000000000000000012071504111170000167520ustar00rootroot00000000000000entity ieee17 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of ieee17 is begin -- Corner cases for "=" process is variable v1, v2 : std_logic_vector(50 downto 0); begin for i in 0 to 50 loop for j in 0 to i - 1 loop v1(j) := std_logic'val(j mod 9); v2(j) := std_logic'val(j mod 9); end loop; v1(i) := 'X'; v2(i) := 'U'; assert v1(i - 1 downto 0) = v2(i - 1 downto 0); assert not (v1(i downto 0) = v2(i downto 0)); end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee18.vhd000066400000000000000000000016401504111170000167540ustar00rootroot00000000000000-- Division cases -- library ieee; use ieee.numeric_std.all; entity ieee18 is end entity; architecture test of ieee18 is begin big: process is variable ua, ub, uc : unsigned(199 downto 0); begin ua := to_unsigned(5, 200); ub := to_unsigned(2, 200); uc := ua / ub; assert uc = ub report to_hstring(uc); uc := ua(3 downto 0) rem ub; assert uc = 1 report to_hstring(uc); wait; end process; small: process is variable ua, ub, uc : unsigned(19 downto 0); begin wait for 1 ns; ua := to_unsigned(5, 20); ub := to_unsigned(2, 20); uc := ua / ub; assert uc = ub report to_hstring(uc); uc := ua rem ub; assert uc = 1 report to_hstring(uc); wait for 1 ns; uc := ua / 0; assert uc = 0 report to_hstring(uc); wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee2.vhd000066400000000000000000000020671504111170000166710ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub is port ( clk : out std_logic; cnt : inout integer := 0); end entity; architecture test of sub is signal clk_i : bit := '0'; signal clk_std : std_logic; begin clk_i <= not clk_i after 1 ns; clk_std <= to_stdulogic(clk_i); clk <= clk_std; process (clk_std) is begin if rising_edge(clk_std) then cnt <= cnt + 1; end if; end process; end architecture; ------------------------------------------------------------------------------- entity ieee2 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of ieee2 is signal cnt : integer := 0; signal clk : std_logic; begin sub_i: entity work.sub port map ( clk, cnt ); process (clk) is begin if rising_edge(clk) then report "clock!"; end if; end process; process is begin wait for 10 ns; report integer'image(cnt); assert cnt = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee3.vhd000066400000000000000000000010611504111170000166630ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity ieee3 is end entity; architecture test of ieee3 is begin process is variable x, y, z: unsigned(7 downto 0); begin x := to_unsigned(3, 8); y := to_unsigned(5, 8); assert y > x; assert y >= x; assert x <= y; assert x < y; assert to_integer(x) = 3; assert (x + y) = 8; assert (y - x) = 2; assert (x * y) = 15; assert (y / x) = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee4.vhd000066400000000000000000000044121504111170000166670ustar00rootroot00000000000000entity ieee4 is end entity; library ieee; use ieee.math_real.all; architecture test of ieee4 is function approx(x, y : real; t : real := 0.001) return boolean is begin return abs(x - y) < t; end function; begin process is variable s1, s2 : integer; variable r : real; begin r := 6.8; wait for 0 ns; -- Prevent constant folding assert approx(sign(r), 1.0); r := 5.7; wait for 0 ns; assert approx(ceil(r), 6.0); r := 0.6; wait for 0 ns; assert approx(floor(r), 0.0); r := 0.5; wait for 0 ns; assert approx(round(r), 1.0); r := 6.4999; wait for 0 ns; assert approx(round(r), 6.0); r := 0.999; wait for 0 ns; assert approx(trunc(r), 0.0); r := 4.6; wait for 0 ns; assert approx(r mod 2.7, 1.9); s1 := 6; s2 := 883; uniform(s1, s2, r); assert approx(r, 0.983380); uniform(s1, s2, r); assert approx(r, 0.627369); uniform(s1, s2, r); assert approx(r, 0.883711); uniform(s1, s2, r); assert approx(r, 0.472620); uniform(s1, s2, r); assert approx(r, 0.582179); r := 4.0; wait for 0 ns; assert approx(sqrt(r), 2.0); r := 4.3; wait for 0 ns; assert approx(sqrt(r), 2.0736); r := 612.8; wait for 0 ns; assert approx(cbrt(r), 8.49388); r := 1.2; wait for 0 ns; assert approx(5 ** r, 6.8986); r := 2.0; wait for 0 ns; assert approx(r ** (-1.0), 0.5); r := 2.0; wait for 0 ns; assert approx(exp(r), 7.389056); r := 1.0; wait for 0 ns; assert approx(log(r), 0.0); r := MATH_E; wait for 0 ns; assert approx(log(r), 1.0); r := 5216.72; wait for 0 ns; assert approx(log(r), 8.5596); r := MATH_PI; wait for 0 ns; assert approx(sin(r), 0.0); r := 1.15251; wait for 0 ns; assert approx(cos(r), 0.406195); r := 0.5; wait for 0 ns; assert approx(arctan(r), 0.463648); wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee5.vhd000066400000000000000000000025651504111170000166770ustar00rootroot00000000000000entity should_fold is generic ( X : boolean ); end entity; architecture test of should_fold is begin g: if not X generate -- Error if not constant folded assert X; end generate; end architecture; ------------------------------------------------------------------------------- entity ieee5 is end entity; library ieee; use ieee.math_real.all; architecture test of ieee5 is function approx(x, y : real; t : real := 0.001) return boolean is begin return abs(x - y) < t; end function; begin s1: entity work.should_fold generic map ( approx(sign(6.8), 1.0) ); s2: entity work.should_fold generic map ( approx(ceil(5.7), 6.0) ); s3: entity work.should_fold generic map ( approx(floor(0.6), 0.0) ); s4: entity work.should_fold generic map ( approx(round(0.5), 1.0) ); s5: entity work.should_fold generic map ( approx(round(6.4999), 6.0) ); s6: entity work.should_fold generic map ( approx(trunc(0.999), 0.0) ); s7: entity work.should_fold generic map ( approx(4.6 mod 2.7, 1.9) ); s8: entity work.should_fold generic map ( approx(sin(MATH_PI), 0.0) ); s9: entity work.should_fold generic map ( approx(cos(1.15251), 0.406195) ); s10: entity work.should_fold generic map ( approx(arctan(0.5), 0.463648) ); end architecture; nvc-r1.17.1/test/regress/ieee6.vhd000066400000000000000000000020661504111170000166740ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity sub is port ( result : out std_ulogic_vector(3 downto 0); in1 : in std_ulogic_vector(3 downto 0) ); end entity; architecture test of sub is signal in2 : std_ulogic_vector(2 downto 0); begin assert in1(1 downto 0) = "00"; in2 <= "001"; result <= std_ulogic_vector(unsigned(in1) + unsigned(in2)); end architecture; ------------------------------------------------------------------------------- entity ieee6 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of ieee6 is signal result : std_ulogic_vector(3 downto 0); signal in1 : std_ulogic_vector(1 downto 0); begin uut: entity work.sub port map ( result => result, in1(3 downto 2) => std_ulogic_vector(in1), in1(1 downto 0) => "00" ); stim: process is begin in1 <= "01"; wait for 1 ns; assert result = X"5"; wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee7.vhd000066400000000000000000000013351504111170000166730ustar00rootroot00000000000000entity ieee7 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.fixed_pkg.all; architecture test of ieee7 is begin main: process is variable x, y, z : ufixed(7 downto -3) := (others => '0'); begin z := to_ufixed(0, 7, -3); assert x + y = z; x := to_ufixed(5, 7, -3); y := to_ufixed(6, 7, -3); z := to_ufixed(11, 7, -3); assert x + y = z; assert to_string(z) = "00001011.000" report to_string(z); x := to_ufixed(7, 7, -3); y := to_ufixed(2, 7, -3); z := to_ufixed(3.5, 7, -3); assert x / y = z; assert to_string(z) = "00000011.100" report to_string(z); wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee8.vhd000066400000000000000000000017511504111170000166760ustar00rootroot00000000000000entity ieee8 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.float_pkg.all; use ieee.fixed_pkg.all; architecture test of ieee8 is procedure check(value : in float32; expect : in real) is variable r : real; begin r := to_real(value); assert value > expect - 0.00001; assert value < expect + 0.00001; end procedure; begin main: process is subtype ufixed7 is ufixed (3 downto -3); -- 7 bit variable a, b, c : float32; variable checknum : float32; variable check7uf1, check7uf : ufixed7; begin a := to_float(2.0); b := to_float(3.0); c := a + b; report to_string(to_real(c)); check(c, 5.0); c := a * b; check(c, 6.0); checknum := "00000000000000000000000000000000"; -- 0 check7uf1 := to_ufixed (checknum, check7uf1'high, check7uf1'low); check7uf := "0000000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/ieee9.vhd000066400000000000000000000023231504111170000166730ustar00rootroot00000000000000-- https://github.com/ghdl/ghdl/issues/2097 library IEEE; context IEEE.IEEE_std_context; package my_fixed_pkg is new IEEE.fixed_generic_pkg; --! library IEEE; context IEEE.IEEE_std_context; library work; use work.my_fixed_pkg.all; entity ieee9 is end; architecture arch of ieee9 is begin process subtype stype is sfixed(7 downto -8); -- Subtype not allowed as size_res argument of to_sfixed: -- constant input : std_logic_vector (stype'length-1 downto 0) := to_slv(to_sfixed(-9.96484375, stype)); -- Therefore, a variable needs to be created: variable fmt : stype; constant input : std_logic_vector (stype'length-1 downto 0) := to_slv(to_sfixed(-9.96484375, fmt)); variable sfmt : fmt'subtype; procedure report_sfixed(arg: sfixed) is begin report to_string(to_real(arg)); end procedure; begin report_sfixed(stype(input)); report_sfixed(stype(signed(input))); -- CRASH report_sfixed(fmt'subtype(input)); -- CRASH report_sfixed(fmt'subtype(signed(input))); -- CRASH --report to_string(fmt'subtype); -- However, sfmt, which is declared using fmt'subtype, does work sfmt := stype(input); report_sfixed(sfmt); wait; end process; end; nvc-r1.17.1/test/regress/image1.vhd000066400000000000000000000027631504111170000170460ustar00rootroot00000000000000package p is type enum1 is (A, B); procedure print_char(c : in character); procedure print_enum1(e : in enum1); end package; package body p is procedure print_char(c : in character) is begin report character'image(c); end procedure; procedure print_enum1(e : in enum1) is begin report enum1'image(e); end procedure; end package body; entity image1 is end entity; use work.p.all; architecture test of image1 is type enum2 is (C, D); type my_int is range 1 to 4; type my_phys is range 1 to 100 units UNIT_1; UNIT_2 = 10 UNIT_1; end units; begin process is variable i : integer; variable j : my_int; variable e1 : enum1; variable e2 : enum2; begin report integer'image(4); report integer'image(-42); i := 73; j := 3; report integer'image(i); report "i=" & integer'image(i) & " units"; report character'image('c'); print_char('X'); wait for 10 ps; report time'image(now); e1 := A; e2 := C; wait for 1 ns; report enum1'image(e1); report enum2'image(e2); print_enum1(e1); report my_int'image(j); report my_phys'image(2 UNIT_2); report integer'image(0); report integer'image(10); report integer'image(integer'left); report integer'image(integer'right); wait; end process; end architecture; nvc-r1.17.1/test/regress/image2.vhd000066400000000000000000000027461504111170000170500ustar00rootroot00000000000000entity image2 is end entity; architecture test of image2 is type t_pair is record x, y : integer; end record; type t_nested is record p : t_pair; b : boolean; r : real; end record; type int_vec is array (natural range <>) of integer; type t_enum is (a, b, c); type t_pair_vec is array (t_enum) of t_pair; type t_abc is ('a', 'b', 'c'); type t_abc_vec is array (natural range <>) of t_abc; begin p1: process is variable p : t_pair := (1, 2); variable n : t_nested := ((42, -5), true, 2.5); variable b : bit_vector(1 to 3) := "101"; variable i : int_vec(1 to 4) := (1, 2, -99, 0); variable v : t_pair_vec := ((1, 2), (3, 4), (5, 6)); variable a : t_abc_vec(1 to 4) := "abbc"; begin report t_pair'image(p); report t_nested'image(n); report int_vec'image(i); report t_pair_vec'image(v); report t_abc_vec'image(a); report to_string(a); report bit_vector'image(b); report to_string(b); assert t_pair'image(p) = "(1,2)"; assert t_nested'image(n) = "((42,-5),true,2.5)"; assert int_vec'image(i) = "(1,2,-99,0)"; assert t_pair_vec'image(v) = "((1,2),(3,4),(5,6))"; assert to_string(v) = "((1,2),(3,4),(5,6))"; assert t_abc_vec'image(a) = """abbc"""; assert to_string(a) = "abbc"; assert to_string(b) = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit1.vhd000066400000000000000000000010441504111170000175650ustar00rootroot00000000000000entity implicit1 is end entity; architecture test of implicit1 is signal x : natural; begin x <= 1 after 1 ns, 2 after 2 ns, 3 after 3 ns; process is begin assert x = 0; assert x'delayed = 0; wait for 1 ns; assert x = 1; assert x'delayed = 0; wait for 0 ns; assert x'delayed = 1; assert x'delayed(1 ns) = 0; wait for 1 ns; assert x'delayed = 1; assert x'delayed(1 ns) = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit2.vhd000066400000000000000000000012231504111170000175650ustar00rootroot00000000000000entity implicit2 is end entity; architecture test of implicit2 is signal x : integer; begin x <= 1, 2 after 2 ns, 3 after 4 ns; process is variable t0, t1 : bit; begin t0 := x'transaction; report bit'image(t0); assert t0 = '1'; wait for 1 ns; t1 := x'transaction; report bit'image(t1); assert t0 = not t1; wait for 2 ns; t0 := x'transaction; report bit'image(t0); assert t0 = not t1; wait for 2 ns; t1 := x'transaction; report bit'image(t1); assert t0 = not t1; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit3.vhd000066400000000000000000000012431504111170000175700ustar00rootroot00000000000000entity sub is port ( x : in integer; y : out boolean ); end entity; architecture test of sub is begin y <= x'delayed(5 ns) > x; end architecture; ------------------------------------------------------------------------------- entity implicit3 is end entity; architecture test of implicit3 is signal x : integer := 0; signal y : boolean; begin sub_i: entity work.sub port map (x, y); process is begin x <= 1; wait for 1 ns; assert not y; wait for 5 ns; assert not y; x <= -1; wait for 5 ns; assert y; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit4.vhd000066400000000000000000000013461504111170000175750ustar00rootroot00000000000000entity implicit4 is end entity; architecture test of implicit4 is signal x : integer; begin p1: process is begin assert x'last_active = time'high; assert x'stable; assert x'quiet; assert x'stable(1 hr); assert x'quiet(1 hr); x <= 4; wait for 0 ns; assert not x'stable; assert not x'quiet; wait for 0 ns; assert x'stable; assert x'quiet; assert not x'stable(1 ns); assert not x'quiet(1 ns); wait for 1 ns; assert x'stable(1 ns); assert x'quiet(1 ns); x <= 4; wait for 0 ns; assert x'stable; assert not x'quiet; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit5.vhd000066400000000000000000000015541504111170000175770ustar00rootroot00000000000000entity implicit5 is end entity; architecture test of implicit5 is signal x : bit_vector(1 to 3); begin p1: process is begin x <= "101"; assert x'delayed = "000"; wait for 0 ns; assert x'delayed = "000"; wait for 0 ns; assert x'delayed = "101"; x(2) <= '1'; wait for 0 ns; assert x'delayed = "101"; wait for 0 ns; assert x'delayed = "111"; wait for 1 ns; x <= "000" after 1 ns, "111" after 2 ns, "101" after 3 ns; assert x'delayed(5 ns) = "000"; wait for 5 ns; assert x'delayed(5 ns) = "111"; wait for 1 ns; assert x'delayed(5 ns) = "000"; wait for 1 ns; assert x'delayed(5 ns) = "111"; wait for 1 ns; assert x'delayed(5 ns) = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit6.vhd000066400000000000000000000013111504111170000175670ustar00rootroot00000000000000entity implicit6 is end entity; architecture test of implicit6 is type t_rec is record x, y : integer; end record; signal x : t_rec; begin x <= (1, 1), (2, 2) after 2 ns, (3, 3) after 4 ns; process is variable t0, t1 : bit; begin t0 := x'transaction; report bit'image(t0); wait for 1 ns; t1 := x'transaction; report bit'image(t1); assert t0 = not t1; wait for 2 ns; t0 := x'transaction; report bit'image(t0); assert t0 = not t1; wait for 2 ns; t1 := x'transaction; report bit'image(t1); assert t0 = not t1; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit7.vhd000066400000000000000000000014771504111170000176050ustar00rootroot00000000000000entity implicit7 is end entity; architecture test of implicit7 is signal x : bit_vector(1 to 3); type t_nat_vec is array (natural range <>) of natural; signal count : t_nat_vec(x'range); begin g: for i in x'range generate p: process is begin wait on x(i)'transaction; count(i) <= count(i) + 1; end process; end generate; check: postponed process is begin wait for 1 ns; assert count = (0, 0, 0); x <= "100" after 1 ns; wait for 1 ns; wait for 1 ns; assert count = (1, 1, 1); x <= "100" after 1 ns; wait for 2 ns; assert count = (2, 2, 2); x(3) <= '1' after 1 ns; wait for 2 ns; assert count = (2, 2, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit8.vhd000066400000000000000000000021641504111170000176000ustar00rootroot00000000000000entity implicit8 is generic ( tdelay : delay_length := 5 ps ); end entity; architecture test of implicit8 is signal s : natural; begin gen: process is begin for i in 1 to 10 loop s <= s + 1; wait for 1 ps; end loop; wait; end process; check1: process is begin wait for 9 ps; assert s = 9; assert s'delayed = 9; assert s'delayed(tdelay) = 5; wait for 0 ns; assert s = 10; assert s'delayed = 9; assert s'delayed(tdelay) = 5; wait for 0 ns; assert s = 10; assert s'delayed = 10; assert s'delayed(tdelay) = 5; wait; end process; check2: process is begin wait for 9 ps; assert s = 9; assert s'delayed = 9; assert s'delayed(tdelay) = 5; wait for 0 ns; assert s = 10; assert s'delayed = 9; assert s'delayed(tdelay) = 5; wait for 0 ns; assert s = 10; assert s'delayed = 10; assert s'delayed(tdelay) = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/implicit9.vhd000066400000000000000000000022721504111170000176010ustar00rootroot00000000000000entity implicit9 is end entity; architecture test of implicit9 is signal i1, i2 : natural; signal b1, b2 : boolean; begin delayed1: i2 <= i1'delayed(5 ns); stable1: b1 <= i1'stable; stable2: b2 <= i1'stable(2 ns); check: process is begin i1 <= 4; wait for 0 ns; --assert i1'stable'active; assert b1; assert b2; wait for 0 ns; assert i1'stable'active; assert not b1; assert not b2; wait for 0 ns; assert not i1'stable'active; assert b1; assert not b2; wait for 1 ns; assert not i1'stable'active; assert b1; assert not b2; wait for 3 ns; assert not i1'stable'active; assert b1; assert i2 = 0; wait for 1 ns; assert not i1'stable'active; assert b1; assert i2 = 0; wait for 0 ns; assert not i1'stable'active; assert i2 = 4; assert b1; i1 <= 20; wait for 0 ns; --assert i1'stable'active; assert not i1'stable; wait for 0 ns; assert i1'stable'active; wait; end process; end architecture; nvc-r1.17.1/test/regress/integer1.vhd000066400000000000000000000024301504111170000174100ustar00rootroot00000000000000entity integer1 is end entity; architecture test of integer1 is type int64_t is range -9223372036854775807 - 1 to 9223372036854775807; type array_t is array (int64_t range <>) of int64_t; function get_length (a : array_t) return integer is begin return a'length; end function; function get_array return array_t is begin return (1, 2, 3); end function; begin p1: process is variable x, y : int64_t; begin assert x = -9223372036854775807 - 1; x := 1; y := 5; wait for 1 ns; assert x + y = 6; x := int64_t(integer'high) + 1; report int64_t'image(x); assert int64_t'image(x) = "2147483648"; assert int64_t'value("-9223372036854775807") = -9223372036854775807; wait; end process; p2: process is variable a : array_t(-9223372036854775807 to -9223372036854775800); constant c : array_t := get_array; begin assert a'length = 8; assert get_length(a) = 8; assert c'length = 3; report int64_t'image(a'left); wait for 1 ns; assert c'left = int64_t'left; assert c'right = int64_t'left + 2; assert c(-9223372036854775807) = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/integer2.vhd000066400000000000000000000023271504111170000174160ustar00rootroot00000000000000entity integer2 is end entity; architecture test of integer2 is type array_t is array (integer range <>) of integer; function get_length (a : array_t) return integer is begin return a'length; end function; function get_array return array_t is begin return (1, 2, 3); end function; begin p1: process is variable x, y : integer; begin assert x = -9223372036854775807 - 1; x := 1; y := 5; wait for 1 ns; assert x + y = 6; x := integer(integer'high) + 1; report integer'image(x); assert integer'image(x) = "-9223372036854775808"; assert integer'value("-9223372036854775807") = -9223372036854775807; wait; end process; p2: process is variable a : array_t(-9223372036854775807 to -9223372036854775800); constant c : array_t := get_array; begin assert a'length = 8; assert get_length(a) = 8; assert c'length = 3; report integer'image(a'left); wait for 1 ns; assert c'left = integer'left; assert c'right = integer'left + 2; assert c(-9223372036854775807) = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/integer3.vhd000066400000000000000000000017161504111170000174200ustar00rootroot00000000000000entity integer3 is end entity; architecture test of integer3 is type t_counter is protected procedure increment; impure function value return natural; end protected; type t_counter is protected body variable val : natural := 0; procedure increment is begin val := val + 1; end procedure; impure function value return natural is begin return val; end function; end protected body; shared variable count : t_counter; impure function get_right return integer is begin count.increment; return 42; end function; begin process is variable x : integer range 1 to get_right; variable y : x'subtype; begin y := 5; x := y; assert x = 5; assert y'subtype'right = 42; assert count.value = 5; -- XXX: should be 1 wait; end process; end architecture; nvc-r1.17.1/test/regress/issue10.vhd000066400000000000000000000005451504111170000171700ustar00rootroot00000000000000package test2 is constant C0 : bit_vector(1 downto 0) := '0' & '1'; constant C1 : bit_vector(2 downto 0) := C0 & '1'; end test2; entity issue10 is end entity; use work.test2.all; architecture test of issue10 is begin process is begin assert C0 = "01"; assert C1 = "011"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue101.vhd000066400000000000000000000010661504111170000172500ustar00rootroot00000000000000entity issue101 is end entity; architecture SIGN of issue101 is signal TRIGGER, RESULT: integer := 0; signal signal1: integer :=1; signal signal2: integer :=2; signal signal3: integer :=3; begin process (signal1, signal2, signal3) begin -- wait on TRIGGER; signal1 <= signal2; signal2 <= signal1 + signal3; signal3 <= signal2; RESULT <= signal1 + signal2 + signal3; end process; monitor: process(RESULT) begin report "RESULT = " & integer'image(RESULT); end process; end SIGN; nvc-r1.17.1/test/regress/issue103.vhd000066400000000000000000000010271504111170000172470ustar00rootroot00000000000000use std.textio.all; entity issue103 is end entity; architecture test of issue103 is procedure puts(TAG:inout LINE; MSG:in STRING) is variable text_line : LINE; begin write(text_line, TAG(TAG'range), RIGHT, 10); write(text_line, string'(" ")); write(text_line, MSG); writeline(OUTPUT, text_line); end procedure; begin main: process variable tag : line; begin write(tag , string'(">>")); puts(tag, "test"); wait; end process; end test; nvc-r1.17.1/test/regress/issue1030.vhd000066400000000000000000000015411504111170000173300ustar00rootroot00000000000000package pack is generic ( N : natural ); type t_rec is record x : bit; y : bit_vector(7 downto 0); z : bit_vector(1 to N); end record; type t_rec2 is record f : t_rec; end record; type t_array is array (natural range <>) of t_rec2; impure function get_width return integer; end package; package body pack is impure function get_width return integer is begin return N; end function; end package body; package pack8 is new work.pack generic map (8); entity issue1030 is end entity; use work.pack8.all; architecture test of issue1030 is signal s : t_array(1 to 2); begin b: block is port ( p : in bit_vector(get_width - 1 downto 0) ); port map ( s(1).f.z ); begin end block; s(1) <= (f => ('1', X"01", X"02")) after 1 ns; end architecture; nvc-r1.17.1/test/regress/issue1035.vhd000066400000000000000000000005131504111170000173330ustar00rootroot00000000000000entity issue1035 is end entity; architecture tb of issue1035 is type unconstrainedRecord is record a : bit; b : bit_vector; end record; subtype uRecConstrained is unconstrainedRecord ( b(1 downto 0) ); signal uRec : unconstrainedRecord(b(1 downto 0)); signal uRecC: uRecConstrained; begin end tb; nvc-r1.17.1/test/regress/issue1036.vhd000066400000000000000000000031631504111170000173400ustar00rootroot00000000000000entity issue1036 is end entity; architecture test of issue1036 is type int2d is array (natural range <>, natural range <>) of integer; procedure many_args ( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 : inout bit_vector; a12, a13, a14, a15, a16, a17, a18, a19 : inout integer; a20, a21, a22, a23, a24, a25, a26 : inout int2d; a27 : inout integer; signal a28 : inout bit_vector ) is begin assert a5 = X"05"; assert a11 = X"1010"; assert a25 = (0 => (0 => 42)); assert a26(0, 0) = 99; assert a27 = 251; assert a28 = X"f0"; a25(0, 0) := 77; a26(0, 0) := 55; a27 := 999; a28 <= not a28; wait for 0 ns; end procedure; signal s : bit_vector(7 downto 0) := X"f0"; begin process is variable v0, v1, v2, v3, v4, v5 : bit_vector(7 downto 0); variable v6, v7, v8, v9, v10, v11 : bit_vector(15 downto 0); variable v12, v13, v14, v15, v16, v17, v18, v19 : integer; variable v20, v21, v22, v23, v24, v25, v26 : int2d(0 to 0, 0 to 0); variable v27 : integer; begin v5 := X"05"; v11 := X"1010"; v25 := (0 => (0 => 42)); v26(0, 0) := 99; v27 := 251; many_args(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, s); assert v25 = (0 => (0 => 77)); assert v26(0, 0) = 55; assert v27 = 999; assert s = X"0f"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue104.vhd000066400000000000000000000011161504111170000172470ustar00rootroot00000000000000ENTITY dummy IS PORT( i : IN bit; o : OUT bit ); END ENTITY dummy; ARCHITECTURE arch OF dummy IS BEGIN o <= i; END ARCHITECTURE arch; ENTITY issue104 IS END ENTITY issue104; ARCHITECTURE arch OF issue104 IS SIGNAL v : bit_vector(4 DOWNTO 0); BEGIN fold : FOR i IN 0 TO 3 GENERATE BEGIN dummy : ENTITY work.dummy PORT MAP( i => v(i+1), o => v(i) ); END GENERATE fold; process is begin v(4) <= '1'; wait for 1 ns; assert v(0) = '1'; wait; end process; END ARCHITECTURE arch; nvc-r1.17.1/test/regress/issue1043.vhd000066400000000000000000000012051504111170000173310ustar00rootroot00000000000000entity issue1043 is end entity; architecture test of issue1043 is type t_rec is record x : integer; y : real; end record; type t_array is array (natural range <>) of t_rec; signal s : t_rec := (6, 42.0); signal t : t_array(1 to 3) := (others => (0, 0.0)); begin process is begin assert s'last_value = (6, 42.0); assert t'last_value(1) = (0, 0.0); s <= (4, 22.0); wait for 1 ns; assert s'last_value.x = 6; t(3) <= (8, 55.0); wait for 1 ns; assert t'last_value = (1 to 3 => (0, 0.0)); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1044.v000066400000000000000000000010361504111170000170200ustar00rootroot00000000000000 module clk_gate_n ( CLK, E, GCLK, SE ); input CLK; input E; input SE; output GCLK; wire CLK; wire E; wire SE; wire GCLK; reg en1; always @ (CLK or E or SE) begin if (CLK == 1) en1 = SE | E; end assign GCLK = CLK | !en1; endmodule // clk_gate_n module clk_gate_p ( CLK, E, GCLK, SE ); input CLK; input E; input SE; output GCLK; wire CLK; wire E; wire SE; wire GCLK; reg en1; always @ (CLK or E or SE) begin if (CLK == 0) en1 = SE | E; end assign GCLK = CLK & en1; endmodule // clk_gate_p nvc-r1.17.1/test/regress/issue1044.vhd000066400000000000000000000026101504111170000173330ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue1044 is end entity; architecture arch of issue1044 is component clk_gate_p is port ( CLK : in std_logic; E : in std_logic; GCLK : out std_logic; SE : in std_logic); end component; component clk_gate_n is port ( CLK : in std_logic; E : in std_logic; GCLK : out std_logic; SE : in std_logic); end component; signal CLK, SE, E, GCLK_p, GCLK_n : std_logic; begin u0 : clk_gate_p port map ( CLK => clk, E => e, GCLK => gclk_p, SE => se); u1 : clk_gate_n port map ( CLK => clk, E => e, GCLK => gclk_n, SE => se); se <= '0'; process is begin CLK <= '0'; E <= '0'; wait for 1 ps; CLK <= '1'; wait for 1 ps; assert gclk_p = '0' severity failure; assert gclk_n = '1' severity failure; CLK <= '0'; wait for 1 ps; assert gclk_p = '0' severity failure; assert gclk_n = '1' severity failure; E <= '1'; wait for 1 ps; assert gclk_p = '0' severity failure; assert gclk_n = '1' severity failure; CLK <= '1'; wait for 1 ps; assert gclk_p = '1' severity failure; assert gclk_n = '1' severity failure; CLK <= '0'; wait for 1 ps; assert gclk_p = '0' severity failure; assert gclk_n = '0' severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1045.vhd000066400000000000000000000005241504111170000173360ustar00rootroot00000000000000entity issue1045 is end entity; architecture test of issue1045 is type t_rec is record b : bit_vector(1 to 3); i : integer; end record; signal s : t_rec; begin s <= ("101", 5) after 1 ns, ("111", 5) after 2 ns, ("000", 6) after 3 ns, ("010", 999) after 4 ns; end architecture; nvc-r1.17.1/test/regress/issue1057.vhd000066400000000000000000000003131504111170000173350ustar00rootroot00000000000000entity issue1057 is end issue1057; architecture tb of issue1057 is type my_rec is array (7 downto 0) of bit_vector; signal sigA : my_rec(open)(0 downto 0); -- OK begin sigA(0)(0) <= '0'; end tb; nvc-r1.17.1/test/regress/issue106.vhd000066400000000000000000000065721504111170000172640ustar00rootroot00000000000000-- sliced_array.vhdl use std.textio.all; package foo_const is constant foo1_c : integer := 0; constant foo2_c : integer := 7; constant addr1_c : bit_vector(foo2_c downto foo1_c) := x"02"; constant addr2_c : bit_vector(foo2_c downto foo1_c) := x"03"; constant addr3_c : bit_vector(foo2_c downto foo1_c) := x"04"; end foo_const; use std.textio.all; use work.foo_const.all; entity SLICED_ARRAY is port( IN1 : in bit_vector(7 downto 0); OUT1 : out bit_vector(7 downto 0) ); end SLICED_ARRAY; architecture BEHAVIOUR of SLICED_ARRAY is begin PR1: process( IN1 ) variable l : line; begin case IN1 is -- when addr1_c => write(l, string'("OK")); writeline(output, l); -- OK when addr2_c(7 downto 0) => write(l, string'("OK addr2_c")); writeline(output, l); -- fails when addr3_c(foo2_c downto foo1_c) => write(l, string'("OK addr3_c")); writeline(output, l); -- fails when others => write(l, string'("other")); writeline(output, l); end case; end process; end BEHAVIOUR; ------------------------------------------------------------------------------- -- sliced_array_test.vhdl use std.textio.all; entity issue106 is begin end entity issue106 ; architecture BEHAVIOUR of issue106 is component SLICED_ARRAY is port( IN1 : in bit_vector(7 downto 0); OUT1 : out bit_vector(7 downto 0) ); end component SLICED_ARRAY; signal S1 : bit_vector(7 downto 0); signal S2 : bit_vector(7 downto 0); begin SLICED_ARRAY_INST : SLICED_ARRAY port map ( IN1 => S1, OUT1 => S2 ); process variable l : line; begin S1 <= x"10"; wait for 1 ns; S1 <= x"03"; wait for 1 ns; S1 <= x"04"; wait; end process; other: process is constant c1 : bit_vector(7 downto 0) := "11110000"; constant c2 : bit_vector(0 to 7) := "11001100"; constant c3 : bit_vector(15 downto 8) := "11110000"; variable v1, v2, v3 : bit_vector(3 downto 0); begin v1 := "1100"; case v1 is when c1(5 downto 2) => report "ok1"; when others => assert false; end case; v1 := "1111"; case v1 is when c1(7 downto 4) => report "ok2"; when others => assert false; end case; v2 := "1100"; case v2 is when c2(4 to 7) => report "ok3"; when others => assert false; end case; v2 := "0110"; case v2 is when c2(3 to 6) => report "ok4"; when others => assert false; end case; v3 := "1100"; case v3 is when c3(13 downto 10) => report "ok5"; when others => assert false; end case; v3 := "1111"; case v3 is when c3(15 downto 12) => report "ok6"; when others => assert false; end case; wait; end process; end architecture BEHAVIOUR; nvc-r1.17.1/test/regress/issue1060.vhd000066400000000000000000000001331504111170000173270ustar00rootroot00000000000000entity issue1060 is end entity; architecture test of issue1060 is begin end architecture; nvc-r1.17.1/test/regress/issue1062.vhd000066400000000000000000000014261504111170000173370ustar00rootroot00000000000000entity nvc_crash is end entity nvc_crash; architecture rtl of nvc_crash is signal test_signal : natural; begin test_signal <= 1 after 1 ns, 2 after 2 ns; end architecture rtl; entity issue1062 is generic( ENABLE_EXTERNAL_NAME : boolean := true ); end entity; architecture rtl of issue1062 is signal test_signal : natural; begin g_external_name : if ENABLE_EXTERNAL_NAME generate begin test_signal <= <>; end generate g_external_name; i_nvc_crash : entity work.nvc_crash; check: process is begin wait for 1 ns; assert test_signal = 0; wait for 0 ns; assert test_signal = 1; wait for 5 ns; assert test_signal = 2; wait; end process; end architecture rtl; nvc-r1.17.1/test/regress/issue1071.vhd000066400000000000000000000011511504111170000173320ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use std.env.finish; entity issue1071 is end issue1071; architecture sim of issue1071 is subtype A is unsigned(7 downto 0); type B is array (natural range <>) of A; signal C : B(0 to 1) := (others => (others => '0')); type D is array (0 to 0) of B(0 to 1); signal E : D := (others => (others => (others => '0'))); begin E(0) <= C; process begin wait for 10 ns; for i in C'range loop C(i) <= to_unsigned(C'length - i, A'length); end loop; wait for 10 ns; finish; end process; end architecture; nvc-r1.17.1/test/regress/issue1074.vhd000066400000000000000000000025131504111170000173400ustar00rootroot00000000000000package test_pkg is type test_record is record sig1 : bit; sig2 : bit; end record; view source of test_record is sig1 : out; sig2 : out; end view; alias sink is source'converse; end package; use work.test_pkg.all; entity test_source is port ( src : view source ); end entity; architecture rtl of test_source is begin src <= ('1', '0') after 1 ns, ('0', '1') after 2 ns, ('1', '1') after 3 ns; end architecture; use work.test_pkg.all; entity test_sink is port ( snk : view sink ); end entity; architecture rtl of test_sink is begin process is begin wait for 1 ns; assert snk = ('1', '0'); wait for 1 ns; assert snk = ('0', '1'); wait for 1 ns; assert snk = ('1', '1'); wait; end process; end architecture; use work.test_pkg.all; use work.test_source; use work.test_sink; entity issue1074 is end entity; architecture rtl of issue1074 is signal s1 : bit; signal s2 : bit; begin test_source_inst: entity work.test_source port map( src.sig1 => s1, src.sig2 => s2 ); test_sink_inst: entity work.test_sink port map( snk.sig1 => s1, snk.sig2 => s2 ); end architecture; nvc-r1.17.1/test/regress/issue1079.vhd000066400000000000000000000011301504111170000173370ustar00rootroot00000000000000library std; use std.textio.all; entity issue1079 is end entity; architecture tb of issue1079 is procedure log(msg : string) is variable o : line; file OUTPUT: TEXT open WRITE_MODE is "STD_OUTPUT"; begin write(o,string'("::")); write(o,msg); writeline(output,o); end procedure; begin main: process begin log ("hello world 1"); -- OK log ("hello world 2"); -- abort with fatal log ("hello world 3"); log ("hello world 4"); log ("hello world 5"); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue109.vhd000066400000000000000000000011271504111170000172560ustar00rootroot00000000000000package pack is procedure proc (x : out integer); end package; package body pack is procedure proc (x : out integer) is begin x := 5; end procedure; end package body; ------------------------------------------------------------------------------- entity issue109 is end entity; use work.pack.all; architecture test of issue109 is function func return integer is variable r : integer; begin proc(r); return r; end function; begin process is begin assert func = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1094.vhd000066400000000000000000000020721504111170000173420ustar00rootroot00000000000000entity A is port (din : BIT_VECTOR(4 downto 0)); end A; architecture arch of A is begin check: process is begin assert din = "11110" report to_string(din); wait for 1 ns; assert din = "11101" report to_string(din); wait; end process; end architecture; package pkg_B is function init return natural; end pkg_B; package body pkg_B is function init return natural is begin return 1; end init; end pkg_B; use work.pkg_B.init; package pkg_C is type bar is record field : BIT_VECTOR(init downto 0); end record; end package pkg_C; use work.pkg_C.bar; entity issue1094 is end entity issue1094; architecture rtl of issue1094 is signal foo : bar := ( field => "10" ); function bar_to_bitvector(bar_obj: bar) return BIT_VECTOR is variable r : bit_vector(4 downto 0) := (others => '1'); begin r(bar_obj.field'length - 1 downto 0) := bar_obj.field; return r; end; begin test_inst: entity work.A port map(din => bar_to_bitvector(foo)); foo.field <= "01" after 1 ns; end architecture; nvc-r1.17.1/test/regress/issue110.vhd000066400000000000000000000010621504111170000172440ustar00rootroot00000000000000entity issue110 is end entity; use std.textio.all; architecture test of issue110 is impure function write_func(x : integer) return integer is variable l : line; begin write(l, x); writeline(output, l); return x; end function; procedure write_proc(x : integer) is variable l : line; begin write(l, x); writeline(output, l); end procedure; begin process is begin assert write_func(4) = 4; write_proc(5); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue111.vhd000066400000000000000000000023611504111170000172500ustar00rootroot00000000000000entity t1 is port( A,B,C : in bit; D : out bit ); end t1; architecture rtl of t1 is begin D<='1' when A='1' and B='1' and C='1' else '0'; end rtl; entity test is port( A,B,C : in bit_vector(7 downto 0); D : out bit_vector(7 downto 0) ); end test; architecture rtl of test is begin ADD_GEN: for I in 0 to 7 generate L: if I=0 generate--failure is here U0: entity work.t1 port map(A(I),B(I),'0',D(I)); end generate L; U: if I>0 generate UX: entity work.t1 port map(A(I),B(I),C(I-1),D(I)); end generate U; end generate ADD_GEN; end rtl; entity issue111 is end entity; architecture test of issue111 is signal A, B, C : bit_vector(7 downto 0); signal D : bit_vector(7 downto 0); begin uut: entity work.test port map ( A => A, B => B, C => C, D => D ); process is begin wait for 1 ns; assert D = X"00"; A <= X"ff"; wait for 1 ns; assert D = X"00"; B <= X"0f"; C <= X"0c"; wait for 1 ns; assert D = X"08"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1117.vhd000066400000000000000000000011221504111170000173310ustar00rootroot00000000000000entity issue1117 is end entity; architecture test of issue1117 is signal clk, x, y : bit; signal running : boolean := true; -- psl default clock is rising_edge(clk); begin -- psl assert never x and y report "x and y both 1"; clkgen: clk <= not clk after 10 ns when running; check: process is begin wait until rising_edge(clk); x <= '1'; y <= '1'; wait for 1 ns; -- No failure here x <= '0'; wait until rising_edge(clk); running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue112.vhd000066400000000000000000000057631504111170000172620ustar00rootroot00000000000000entity t1 is port( A,B,C : in bit; D : out bit ); end t1; architecture rtl of t1 is begin D<='1' when A='1' and B='1' and C='1' else '0'; end rtl; entity test2 is port( A,B,C : in bit_vector(7 downto 0); D0 : out bit_vector(7 downto 0); D1 : out bit_vector(7 downto 0); D2 : out bit_vector(7 downto 0); D3 : out bit_vector(7 downto 0); D4 : out bit_vector(7 downto 0); D5 : out bit_vector(7 downto 0); D6 : out bit_vector(7 downto 0); D7 : out bit_vector(7 downto 0) ); end test2; architecture rtl of test2 is type T_IN_DSP_PC_ARR is array(0 to 7,0 to 7) of bit; signal s_pout : T_IN_DSP_PC_ARR; begin D0 <= s_pout(0,7)&s_pout(0,6)&s_pout(0,5)&s_pout(0,4)&s_pout(0,3)&s_pout(0,2)&s_pout(0,1)&s_pout(0,0); D1 <= s_pout(1,7)&s_pout(1,6)&s_pout(1,5)&s_pout(1,4)&s_pout(1,3)&s_pout(1,2)&s_pout(1,1)&s_pout(1,0); D2 <= s_pout(2,7)&s_pout(2,6)&s_pout(2,5)&s_pout(2,4)&s_pout(2,3)&s_pout(2,2)&s_pout(2,1)&s_pout(2,0); D3 <= s_pout(3,7)&s_pout(3,6)&s_pout(3,5)&s_pout(3,4)&s_pout(3,3)&s_pout(3,2)&s_pout(3,1)&s_pout(3,0); D4 <= s_pout(4,7)&s_pout(4,6)&s_pout(4,5)&s_pout(4,4)&s_pout(4,3)&s_pout(4,2)&s_pout(4,1)&s_pout(4,0); D5 <= s_pout(5,7)&s_pout(5,6)&s_pout(5,5)&s_pout(5,4)&s_pout(5,3)&s_pout(5,2)&s_pout(5,1)&s_pout(5,0); D6 <= s_pout(6,7)&s_pout(6,6)&s_pout(6,5)&s_pout(6,4)&s_pout(6,3)&s_pout(6,2)&s_pout(6,1)&s_pout(6,0); D7 <= s_pout(7,7)&s_pout(7,6)&s_pout(7,5)&s_pout(7,4)&s_pout(7,3)&s_pout(7,2)&s_pout(7,1)&s_pout(7,0); VGEN: for V in 0 to 7 generate UGEN: for I in 0 to 7 generate signal C_C :bit; begin process (C) is begin if I=0 then C_C <= '0'; else C_C <= C(I-1); end if; end process; UX: entity work.t1 port map(A(I),B(I),C_C,s_pout(V,I)); end generate UGEN; end generate VGEN; end rtl; entity issue112 is end entity; architecture test of issue112 is signal A, B, C : bit_vector(7 downto 0); signal D0 : bit_vector(7 downto 0); signal D1 : bit_vector(7 downto 0); signal D2 : bit_vector(7 downto 0); signal D3 : bit_vector(7 downto 0); signal D4 : bit_vector(7 downto 0); signal D5 : bit_vector(7 downto 0); signal D6 : bit_vector(7 downto 0); signal D7 : bit_vector(7 downto 0); begin test2_1: entity work.test2 port map ( A => A, B => B, C => C, D0 => D0, D1 => D1, D2 => D2, D3 => D3, D4 => D4, D5 => D5, D6 => D6, D7 => D7); process is begin wait for 1 ns; assert D0 = X"00"; A <= X"0f"; B <= X"03"; C <= X"01"; wait for 1 ns; assert D0 = X"02"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1125.vhd000066400000000000000000000051511504111170000173360ustar00rootroot00000000000000ENTITY issue1125 IS END ENTITY; ARCHITECTURE arch OF issue1125 IS BEGIN gen_if : IF true GENERATE ASSERT gen_if'simple_name = "gen_if"; ASSERT gen_if'path_name = ":issue1125:gen_if:"; END GENERATE; -- *_name attributes in if generate with alternative labels not supported: -- f : FOR i IN 0 TO 2 GENERATE -- gen_if : IF gen_if_0 : i = 0 GENERATE -- ASSERT gen_if'simple_name = "gen_if"; -- ASSERT gen_if'path_name = ":issue1125:f(0):gen_if:"; -- -- ASSERT gen_if_0'simple_name = "gen_if_0"; -- ASSERT gen_if_0'path_name = ":issue1125:f(0):gen_if_0:"; -- -- ELSIF gen_if_1 : i = 1 GENERATE -- ASSERT gen_if'simple_name = "gen_if"; -- ASSERT gen_if'path_name = ":issue1125:f(1):gen_if:"; -- -- ASSERT gen_if_1'simple_name = "gen_if_1"; -- ASSERT gen_if_1'path_name = ":issue1125:f(1):gen_if_1:"; -- -- ELSE GENERATE -- ASSERT gen_if'simple_name = "gen_if"; -- ASSERT gen_if'path_name = ":issue1125:f(2):gen_if:"; -- END GENERATE; -- -- ASSERT gen_if'simple_name = "gen_if"; -- ASSERT gen_if'path_name = ":issue1125:f(" & INTEGER'image(i) & "):gen_if:"; -- END GENERATE; ASSERT gen_if'simple_name = "gen_if"; -- Error, currently resolves to ":issue1125:" -- ASSERT gen_if'path_name = ":issue1125:gen_if:"; gen_for : FOR i IN 0 TO 1 GENERATE ASSERT gen_for'simple_name = "gen_for"; ASSERT gen_for'path_name = ":issue1125:gen_for(" & INTEGER'image(i) & "):"; END GENERATE; ASSERT gen_for'simple_name = "gen_for"; -- Error, currently resolves to ":issue1125:" -- ASSERT gen_for'path_name = ":issue1125:gen_for:"; gen_case : CASE true GENERATE WHEN true => ASSERT gen_case'simple_name = "gen_case"; ASSERT gen_case'path_name = ":issue1125:gen_case:"; WHEN false => END GENERATE; ASSERT gen_case'simple_name = "gen_case"; -- Error, currently resolves to ":issue1125:" -- ASSERT gen_case'path_name = ":issue1125:gen_case:"; -- *_name attributes in case generate with alternative labels not supported: -- gen_case : CASE true GENERATE -- WHEN gen_case_true : true => -- ASSERT gen_case'simple_name = "gen_case"; -- ASSERT gen_case'path_name = ":issue1125:gen_case:"; -- -- ASSERT gen_case_true'simple_name = "gen_case_true"; -- ASSERT gen_case_true'path_name = ":issue1125:gen_case_true:"; -- WHEN false => -- END GENERATE; END ARCHITECTURE; nvc-r1.17.1/test/regress/issue1137.vhd000066400000000000000000000012141504111170000173350ustar00rootroot00000000000000entity issue1137 is end entity; architecture test of issue1137 is type t_rec is record x : integer; y : bit_vector(1 to 0); -- Null z : integer; end record; signal s : t_rec := (42, "", 55); begin process is variable v : t_rec := (666, "", 12); begin assert s.x = 42; assert s.y = ""; assert s.z = 55; v.y := ""; s.y <= ""; wait for 1 ns; assert s.x = 42; assert s.y = v.y; assert s.z = 55; assert v.x = 666; assert v.y = ""; assert v.z = 12; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1143.vhd000066400000000000000000000015671504111170000173450ustar00rootroot00000000000000entity issue1143 is end entity; architecture test of issue1143 is signal x : character; impure function get_pos return integer is begin return character'pos(x); end function; begin b: block is port ( p1, p2 : in integer ); port map ( p1 => character'pos(x), p2 => get_pos); begin check: process is begin assert p1 = integer'left; --assert p2 = integer'left; wait for 0 ns; assert p1 = 0; --assert p2 = 0; wait for 0 ns; assert p1 = 97; --assert p2 = 97; wait for 1 ns; wait for 0 ns; assert p1 = 98; --assert p2 = 98; wait; end process; end block; x <= 'a', 'b' after 1 ns, 'c' after 2 ns; end architecture; nvc-r1.17.1/test/regress/issue115.vhd000066400000000000000000000010501504111170000172460ustar00rootroot00000000000000entity issue115 is end issue115; architecture behav of issue115 is signal PC_OUT_bus : BIT_VECTOR (7 DOWNTO 0); signal tmp : BIT_VECTOR (7 DOWNTO 0); begin process procedure pc_read (signal register_data : out bit_vector(7 downto 0)) is begin register_data <= PC_OUT_bus; end procedure pc_read; begin PC_OUT_BUS <= X"ab"; wait for 1 ns; pc_read(tmp); wait for 1 ns; assert tmp = X"ab"; wait; end process; end behav; nvc-r1.17.1/test/regress/issue1150.vhd000066400000000000000000000007601504111170000173350ustar00rootroot00000000000000entity issue1150 is end entity; architecture test of issue1150 is signal s : integer; signal clk : bit; impure function func (x : integer) return boolean is begin return x > 10; end function; -- psl default clock is clk'event; begin -- OR has control flow -- psl assert always s = 5 or func(s); process is begin s <= 5; clk <= not clk; s <= 11; clk <= not clk; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue116.vhd000066400000000000000000000011051504111170000172500ustar00rootroot00000000000000entity issue116 is end issue116; architecture behav of issue116 is signal intstat : BIT_VECTOR (7 DOWNTO 0); ALIAS INT_int : BIT is intstat(7); begin INT_int <= '1' when (intstat(6 downto 0) and "1111111") /= "0000000"; --intstat(7) <= '1' when (intstat(6 downto 0) and "1111111") /= "0000000"; process begin assert intstat(7) = '0'; intstat(6 downto 0) <= "0000001"; wait for 1 ns; assert INT_int = '1'; intstat(6 downto 0) <= "0000000"; wait for 1 ns; assert INT_int = '1'; wait; end process; end behav; nvc-r1.17.1/test/regress/issue1161.vhd000066400000000000000000000030261504111170000173350ustar00rootroot00000000000000entity issue1161 is end entity; architecture test of issue1161 is type ArrayOfSigned is array (natural range <>) of bit_vector; subtype ArrayOfSigned16 is ArrayOfSigned(open)(15 downto 0); type InterlacedSignal is record Data : ArrayOfSigned; Valid : bit; end record; type ArrayOfInterlacedSignals is array (natural range <>) of InterlacedSignal; subtype ArrayOfInterlaced16bSignals is ArrayOfInterlacedSignals(open)(Data(open)(15 downto 0)); -- Should not generate a bounds var subtype Interlaced16bSignal is InterlacedSignal(Data(open)(15 downto 0)); type p_rec is record x, y : integer; end record; constant p : p_rec := (x => 8, y => 16); -- type ArrayOfInterlacedSignal is array (natural range <>) of InterlacedSignal(Data(open)(p.x - 1 downto 0)); signal SomeArr : ArrayOfSigned16(0 to p.x - 1); signal Valid : bit; signal SomeRec : InterlacedSignal(Data(0 to 15)(7 downto 0)); begin b: block is generic ( IN_LANES, IN_WIDTH : integer ); generic map ( IN_LANES => p.x, IN_WIDTH => 16 ); port ( DataIn : in InterlacedSignal(Data(0 to IN_LANES - 1)(IN_WIDTH - 1 downto 0)); DataOut : out InterlacedSignal ); port map ( DataIn.Data => SomeArr, DataIn.Valid => Valid, DataOut => SomeRec ); signal AIn : ArrayOfInterlaced16bSignals(0 to IN_WIDTH - 1)(Data(0 to IN_LANES - 1)); signal s : datain.data'element; begin end block; end architecture; nvc-r1.17.1/test/regress/issue1164.vhd000066400000000000000000000020161504111170000173360ustar00rootroot00000000000000entity issue1164 is end entity; architecture arch of issue1164 is type rec_part is record a : bit; end record; type rec_part_array is array (natural range <>) of rec_part; type t_rec is record rec_part_a : rec_part; arr : rec_part_array(1 to 2); b : bit; end record t_rec; signal rec_sig : t_rec; begin detect : process is variable var_time : time; begin var_time := rec_sig'last_event; assert var_time = time'high; var_time := rec_sig.b'last_event; -- okay assert var_time = time'high; var_time := rec_sig.rec_part_a'last_event; -- not okay assert var_time = time'high; var_time := rec_sig.rec_part_a'delayed(0 ns)'last_event; -- not okay assert var_time = time'high; rec_sig.rec_part_a.a <= '1'; wait for 1 ns; assert rec_sig'last_event = 1 ns; assert rec_sig.rec_part_a'last_event = 1 ns; assert rec_sig.rec_part_a'delayed(2 ns)'last_event = time'high; assert rec_sig'last_active = 1 ns; wait; end process; end architecture arch; nvc-r1.17.1/test/regress/issue1171.vhd000066400000000000000000000046231504111170000173420ustar00rootroot00000000000000PACKAGE test_pkg IS TYPE t_unconstraint IS RECORD a : bit_vector; b : bit_vector; END RECORD; FUNCTION from_slv(x : bit_vector; dwidth : integer) RETURN t_unconstraint; FUNCTION to_slv(x : t_unconstraint) RETURN bit_vector; END PACKAGE; PACKAGE BODY test_pkg IS FUNCTION from_slv(x : bit_vector; dwidth : integer) RETURN t_unconstraint IS VARIABLE tmp : t_unconstraint( a(dwidth - 1 DOWNTO 0), b(dwidth - 1 DOWNTO 0) ); BEGIN tmp.a := x(dwidth - 1 DOWNTO 0); tmp.b := x(2 * dwidth - 1 DOWNTO dwidth); RETURN tmp; END FUNCTION; FUNCTION to_slv(x : t_unconstraint) RETURN bit_vector IS BEGIN RETURN x.b & x.a; END FUNCTION; END PACKAGE BODY; -------------------------------------------------------- USE work.test_pkg.ALL; ENTITY test IS PORT ( ir_unconstraint : IN t_unconstraint; or_unconstraint : OUT t_unconstraint ); END ENTITY test; ARCHITECTURE rtl OF test IS BEGIN or_unconstraint <= ir_unconstraint after 1 ns; END ARCHITECTURE rtl; -------------------------------------------------------- ENTITY slv IS GENERIC ( DWIDTH : integer ); PORT ( iv_data : IN bit_vector(DWIDTH*2 - 1 DOWNTO 0); ov_data : OUT bit_vector(DWIDTH*2 - 1 DOWNTO 0) ); END ENTITY slv; ARCHITECTURE rtl OF slv IS BEGIN ov_data <= NOT iv_data after 1 ns; END ARCHITECTURE rtl; -------------------------------------------------------- USE work.test_pkg.ALL; use std.env.all; ENTITY issue1171 IS END ENTITY issue1171; ARCHITECTURE sim OF issue1171 IS CONSTANT DWIDTH : integer := 8; SUBTYPE t_constraint IS t_unconstraint( a(DWIDTH - 1 DOWNTO 0), b(DWIDTH - 1 DOWNTO 0) ); FUNCTION from_slv(x : bit_vector) RETURN t_constraint IS BEGIN RETURN from_slv(x, DWIDTH); END FUNCTION; SIGNAL test_to_slv : t_constraint; SIGNAL slv_to_test : bit_vector(DWIDTH*2 - 1 DOWNTO 0); BEGIN dut1 : ENTITY work.test PORT MAP( ir_unconstraint => from_slv(slv_to_test), or_unconstraint => test_to_slv ); dut2 : ENTITY work.slv GENERIC MAP(DWIDTH => DWIDTH) PORT MAP( iv_data => to_slv(test_to_slv), ov_data => slv_to_test ); check: process is begin wait for 1 ns; finish; wait; end process; END ARCHITECTURE sim; nvc-r1.17.1/test/regress/issue1175.vhd000066400000000000000000000007441504111170000173460ustar00rootroot00000000000000entity issue1175 is end entity; architecture test of issue1175 is signal s : bit_vector(1 to 3); signal i : bit; begin b: block is port ( i : in bit; p : out bit_vector ); port map ( i, s ); begin p <= (others => i); end block; process is begin i <= '1'; wait for 1 ns; assert s = "111"; i <= '0'; wait for 1 ns; assert s = "000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1177.vhd000066400000000000000000000010541504111170000173430ustar00rootroot00000000000000entity issue1177 is end entity; architecture behave of issue1177 is signal test : bit := '0'; --signal test_stable : boolean := false; begin -- test_stable <= test'stable(50 ns); process begin test <= '0'; wait for 10 ns; test <= '1'; wait for 10 ns; test <= '0'; wait for 10 ns; test <= '0'; for i in 0 to 6 loop wait for 10 ns; if test'stable(50 ns) then assert now >= 70 ns; end if; end loop; assert test'stable(50 ns); wait; end process; end architecture behave; nvc-r1.17.1/test/regress/issue1185.vhd000066400000000000000000000030561504111170000173460ustar00rootroot00000000000000entity issue1185 is end entity issue1185; architecture behav of issue1185 is type t_enum is ( T_SRC_UNKNOWN, T_SRC_A_0, T_SRC_A_1, T_SRC_B_0, T_SRC_B_1, T_SRC_C ); signal tgt : t_enum; signal sel_a, sel_const : boolean; signal a,b : t_enum; begin process begin wait for 1 ns; a <= T_SRC_A_1; wait for 1 ns; a <= T_SRC_A_0; wait for 20 ns; b <= T_SRC_B_1; wait for 1 ns; b <= T_SRC_B_0; wait for 1 ns; b <= T_SRC_B_1; wait; end process; process begin sel_a <= true; wait for 10 ns; sel_a <= false; sel_const <= false; wait for 30 ns; sel_const <= true; wait for 20 ns; wait; end process; check: postponed process is begin assert now = 0 ns; assert tgt = t_src_unknown; wait on tgt; assert now = 1 ns; assert tgt = t_src_a_1; wait on tgt; assert now = 2 ns; assert tgt = t_src_a_0; wait on tgt; assert now = 10 ns; assert tgt = t_src_unknown; wait on tgt; assert now = 22 ns; assert tgt = t_src_b_1; wait on tgt; assert now = 23 ns; assert tgt = t_src_b_0; wait on tgt; assert now = 24 ns; assert tgt = t_src_b_1; wait on tgt; assert now = 40 ns; assert tgt = t_src_c; wait; end process; process(all)begin tgt <= force a when sel_a else T_SRC_C when sel_const else b; report "Target value is" & t_enum'image(tgt); end process; end architecture; nvc-r1.17.1/test/regress/issue1186.vhd000066400000000000000000000014561504111170000173510ustar00rootroot00000000000000use std.env.stop; entity issue1186 is end entity; architecture tb of issue1186 is type std8 is array(natural range<>) of bit_vector( 7 downto 0); constant x : std8(0 to 3) := (0=>x"55", 1=>x"AA", 2=>x"55",3=>x"AA"); function f_make( pyld : std8 := (0=>x"00")) return std8 is variable hdr : std8(0 to 11) := (others=>(others=>'0')); -- variable hdr_pyld : std8(0 to hdr'length+pyld'length-1) := hdr & pyld; also doesn't work begin return hdr & pyld; -- return hdr_pyld; end; procedure pkt_report( constant data : in std8) is begin for i in 0 to data'length-1 loop report to_string(data(i)) severity note; end loop; end; begin test_runner : process begin pkt_report(f_make(x)); stop; end process; end architecture; nvc-r1.17.1/test/regress/issue1192.vhd000066400000000000000000000004361504111170000173430ustar00rootroot00000000000000entity issue1192 is end entity; architecture test of issue1192 is type t_int_ptr is access integer; type t_rec; type t_rec_ptr is access t_rec; type t_rec is record x, y : integer; end record; type t_file is file of integer; begin end architecture; nvc-r1.17.1/test/regress/issue1208.vhd000066400000000000000000000022571504111170000173440ustar00rootroot00000000000000entity issue1208 is end entity; architecture test of issue1208 is type bus_t is record valid : bit; ack : bit; end record; view bus_master of bus_t is valid : out; ack : in; end view; alias bus_slave is bus_master'converse; type doublebus_t is record slave, master : bus_t; end record; view double_master of doublebus_t is slave : view bus_slave; master : view bus_master; end view; signal bs, bm : bus_t; begin b : block is port (double : view double_master); port map ( double.slave => bs, double.master => bm ); begin double.slave.ack <= double.slave.valid after 1 ps; double.master.valid <= double.master.ack after 1 ps; end block; check: process is begin wait for 1 ns; assert bm.valid = '0'; assert bs.ack = '0'; bm.ack <= '1'; wait for 1 ns; assert bm.valid = '1'; assert bs.ack = '0'; bs.valid <= '1'; wait for 1 ns; assert bm.valid = '1'; assert bs.ack = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue121.vhd000066400000000000000000000021571504111170000172540ustar00rootroot00000000000000package A is procedure PROC_A(I:in integer; O:out integer; Z:out boolean); procedure PROC_B(I:in integer; O:out integer; Z:out boolean); procedure PROC_C(I:in integer; O:out integer; Z:out boolean); end package; package body A is procedure PROC_A(I:in integer; O:out integer; Z:out boolean) is begin -- Used to abort calling forward-declared procedure PROC_B(I,O,Z); end procedure; procedure PROC_B(I:in integer; O:out integer; Z:out boolean) is begin PROC_C(I,O,Z); end procedure; procedure PROC_C(I:in integer; O:out integer; Z:out boolean) is begin O := I; Z := (I = 0); end procedure; end package body; ------------------------------------------------------------------------------- entity issue121 is end entity; use work.A.all; architecture test of issue121 is begin process is variable o : integer; variable z : boolean; begin proc_a(1, o, z); assert o = 1; assert not z; proc_a(0, o, z); assert o = 0; assert z; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1213.vhd000066400000000000000000000013111504111170000173260ustar00rootroot00000000000000entity issue1213 is generic ( PARAM : string := "hello" ); port ( a, b : in bit; c : out bit ); end entity; architecture test of issue1213 is component and_gate is port ( a, b : in bit; c : out bit ); end component; begin ifgen_label: if PARAM = "hello" generate and_gate_inst: and_gate port map (a, b, c); else generate assert false report "entity not instantiated" severity failure; end generate; casegen_label: case PARAM generate when "hello" => when others => assert false report "wrong case branch" severity failure; end generate; end architecture; nvc-r1.17.1/test/regress/issue1218.vhd000066400000000000000000000010211504111170000173310ustar00rootroot00000000000000entity issue1218 is end entity; library nvc; use nvc.cover_pkg.all; architecture test of issue1218 is begin -- These should be no-ops when coverage not enabled process is variable scope : t_scope_handle; variable item : t_item_handle; begin create_cover_scope(scope, "foo"); set_cover_scope_name(scope, "bar"); add_cover_item(scope, item, "item", 0, ( (1 to 0 => (others => 0)))); increment_cover_item(scope, item); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue122.vhd000066400000000000000000000013341504111170000172510ustar00rootroot00000000000000package nested_function_bug is procedure proc(param : integer; result : out integer); end package; package body nested_function_bug is procedure proc(param : integer; result : out integer) is impure function nested_function return integer is begin return param * 2; end; variable bar : natural := nested_function; begin result := bar; end; end package body; ------------------------------------------------------------------------------- entity issue122 is end entity; use work.nested_function_bug.all; architecture test of issue122 is begin process is variable r : integer; begin proc(5, r); assert r = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1229.vhd000066400000000000000000000022771504111170000173510ustar00rootroot00000000000000use std.textio.all; package pkg is impure function f1( path : string ) return string; impure function f1( file f : text ) return string; end package pkg; package body pkg is impure function f1( path : string ) return string is file f : text open read_mode is path; begin return f1(f); end function; impure function f1( file f : text ) return string is variable ef : boolean := false; begin ef := endfile(f); if (ef = TRUE) then return "true"; else return "false"; end if; end function; end package body pkg; ------------------------------------------------------------------------------- use std.textio.all; library work; use work.pkg.all; entity issue1229 is end entity; architecture RTL of issue1229 is procedure test is constant STRING_INPUT : string := f1("file.txt"); begin assert STRING_INPUT = "true"; end procedure; begin process is file f : text; begin file_open(f, "file.txt", WRITE_MODE); file_close(f); test; wait; end process; end architecture RTL; nvc-r1.17.1/test/regress/issue123.vhd000066400000000000000000000013611504111170000172520ustar00rootroot00000000000000package nested_function_bug is procedure proc(param : integer; result : out integer); end package; package body nested_function_bug is procedure proc(param : integer; result : out integer) is variable foo : bit_vector(0 to param); impure function nested_function return integer is begin return foo'length; end; begin result := nested_function; end; end package body; ------------------------------------------------------------------------------- entity issue123 is end entity; use work.nested_function_bug.all; architecture test of issue123 is begin process is variable result : integer; begin proc(5, result); assert result = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1231.vhd000066400000000000000000000031651504111170000173370ustar00rootroot00000000000000entity issue1231 is end entity issue1231; architecture rtl of issue1231 is -- This function should shift a vector left or right by a specific amount. -- Due to a slice mismatch occurring in line 29, it instead returns some random characters?? function expected_shift ( input_vec : bit_vector; shift : integer ) return bit_vector is constant len : natural := input_vec'length; variable temp : bit_vector(len-1 downto 0); variable input_vector : bit_vector(len-1 downto 0) := input_vec; variable abs_shift : natural; begin abs_shift := abs(shift); if abs_shift >= len then temp := (others => '0'); else if shift >= 0 then -- Left shift temp := input_vec(len-1-abs_shift downto 0) & (abs_shift-1 downto 0 => '0'); else -- Right shift temp := (abs_shift-1 downto 0 => '0') & input_vec(len-1 downto abs_shift); end if; end if; return temp; end function; begin MAGIC : process begin -- I assume the directly written bit_vector is a "to" instead of "downto" type, thus causing the mismatch report "Surprise 1 " & to_string(expected_shift("00000000", 0)); report "Surprise 2 " & to_string(expected_shift("11111111", 0)); report "Surprise 3 " & to_string(expected_shift("10101010", -1)); report "Surprise 4 " & to_string(expected_shift("01010101", 1)); -- but instead of failing with a loud bang, it results in weird, random characters with no warnings or errors. wait; end process; end architecture; nvc-r1.17.1/test/regress/issue1233.vhd000066400000000000000000000015031504111170000173330ustar00rootroot00000000000000ENTITY issue1233 IS BEGIN END ENTITY; ARCHITECTURE arch OF issue1233 IS PROCEDURE intout (i : OUT INTEGER) IS BEGIN REPORT "ERROR: foreign subprogram 'vhpi_intout' not called" SEVERITY failure; END PROCEDURE; ATTRIBUTE foreign OF intout : PROCEDURE IS "VHPI vhpi.so vhpi_intout"; -- PROCEDURE rangedintout (i : OUT INTEGER RANGE 0 TO 5) IS BEGIN REPORT "ERROR: foreign subprogram 'vhpi_rangedintout' not called" SEVERITY failure; END PROCEDURE; ATTRIBUTE foreign OF rangedintout : PROCEDURE IS "VHPI vhpi.so vhpi_rangedintout"; BEGIN test : PROCESS IS VARIABLE i : INTEGER := 0; VARIABLE j : INTEGER := 0; BEGIN intout(i); ASSERT i = 1; rangedintout(j); ASSERT j = 1; -- fails WAIT; END PROCESS; END ARCHITECTURE; nvc-r1.17.1/test/regress/issue1240.vhd000066400000000000000000000020341504111170000173310ustar00rootroot00000000000000package funcs is function get_params return integer_vector; function sum (x : integer_vector) return integer; end package; package body funcs is function get_params return integer_vector is begin return (1, 2, 3); end function; function sum (x : integer_vector) return integer is variable r : integer := 0; begin for i in x'range loop r := r + x(i); end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.funcs.all; package types is constant params : integer_vector := get_params; constant width : integer := sum(params); end package; ------------------------------------------------------------------------------- entity issue1240 is end entity; use work.types.all; architecture test of issue1240 is type t1 is array (natural range <>) of bit_vector(width - 1 downto 0); type t2 is array (1 to 3) of bit_vector(width - 1 downto 0); begin end architecture; nvc-r1.17.1/test/regress/issue126.vhd000066400000000000000000000010021504111170000172450ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned."-"; --use ieee.std_logic_arith.all; -- Uncommenting fixed issue entity issue126 is end issue126; architecture structural of issue126 is signal clk_count : std_logic_vector (2 downto 0); begin process begin clk_count <= "110"; wait for 1 us; clk_count <= clk_count - 1; wait for 1 us; assert clk_count = "101" severity error; wait; end process; end architecture structural; nvc-r1.17.1/test/regress/issue13.vhd000066400000000000000000000007201504111170000171660ustar00rootroot00000000000000entity issue13 is end entity; architecture test of issue13 is constant c0: bit_vector(7 downto 0) := "10101010"; type t_array is array (1 downto 0) of bit_vector(7 downto 0); constant c1 : t_array := ( 1 => c0, --error 0 => "10101010"); begin process is variable cmp : bit_vector(7 downto 0) := "10101010"; begin assert c1(1) = c0; assert c1(0) = cmp; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue141.vhd000066400000000000000000000021631504111170000172530ustar00rootroot00000000000000package protected_type_pkg is type protected_t is protected impure function get_value return integer; end protected; end package; package body protected_type_pkg is type other_protected_t is protected impure function get_value return integer; end protected; type other_protected_t is protected body variable value : integer := 5; impure function get_value return integer is begin return value; end function; end protected body; type protected_t is protected body variable other_protected : other_protected_t; impure function get_value return integer is begin return other_protected.get_value; end function; end protected body; end package body; use work.protected_type_pkg.protected_t; package pkg is shared variable prot : protected_t; end package; ------------------------------------------------------------------------------- entity issue141 is end entity; use work.pkg.all; architecture test of issue141 is begin process is begin assert prot.get_value = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue143.vhd000066400000000000000000000033031504111170000172520ustar00rootroot00000000000000package access_field_through_function_pkg is type record_t is record field : integer; end record; type protected_t is protected function fun return record_t; end protected; function fun return record_t; function fun(param : integer) return record_t; function access_field_fun1 return integer; function access_field_fun2 return integer; function access_field_fun3 return integer; end package; package body access_field_through_function_pkg is type protected_t is protected body function fun return record_t is begin return (field => 0); end function; end protected body; function fun return record_t is begin return (field => 0); end function; function fun(param : integer) return record_t is begin return (field => param); end function; function access_field_fun1 return integer is begin return fun.field; -- <-- does not work end function; function access_field_fun2 return integer is variable x : integer := 10; begin return fun(x).field; -- <-- works end function; function access_field_fun3 return integer is variable prot : protected_t; begin return prot.fun.field; -- <-- does not work end function; end package body; ------------------------------------------------------------------------------- entity issue143 is end entity; use work.access_field_through_function_pkg.all; architecture test of issue143 is begin process is variable x : integer := 4; begin assert fun.field = 0; assert fun(x).field = 4; assert access_field_fun1 = 0; assert access_field_fun2 = 10; assert access_field_fun3 = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue146.vhd000066400000000000000000000017321504111170000172610ustar00rootroot00000000000000package A_NG is type A_NG_TYPE is record debug : integer; end record; procedure PROC_B(B_ARG:inout A_NG_TYPE; B_VAL:out integer); end A_NG; package body A_NG is procedure PROC_A(A_ARG:inout A_NG_TYPE) is begin A_ARG.debug := A_ARG.debug + 1; end procedure; procedure PROC_B(B_ARG:inout A_NG_TYPE; B_VAL:out integer) is procedure PROC_C(C_VAL:out integer) is begin PROC_A(B_ARG); C_VAL := B_ARG.debug; end procedure; begin PROC_C(B_VAL); end procedure; end A_NG; ------------------------------------------------------------------------------- entity issue146 is end entity; use work.a_ng.all; architecture test of issue146 is begin process is variable a_arg : a_ng_type := ( debug => 4 ); variable c_val : integer; begin proc_b(a_arg, c_val); assert c_val = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue148.vhd000066400000000000000000000020261504111170000172600ustar00rootroot00000000000000package A_NG is type A_NG_TYPE is record debug : integer; end record; procedure PROC_B(B_ARG:inout A_NG_TYPE; B_VAL:out integer); end A_NG; package body A_NG is procedure PROC_A(A_ARG:inout A_NG_TYPE) is begin null; end procedure; procedure PROC_B(B_ARG:inout A_NG_TYPE; B_VAL:out integer) is variable b_var : integer; procedure PROC_C(C_ARG:in integer;C_VAL:out integer) is begin PROC_A(B_ARG); C_VAL := B_ARG.debug + C_ARG; end procedure; begin b_var := 1; PROC_C(b_var,B_VAL); end procedure; end A_NG; ------------------------------------------------------------------------------- entity issue148 is end entity; use work.a_ng.all; architecture test of issue148 is begin process is variable a_ng : a_ng_type; variable tmp : integer; begin a_ng.debug := 2; proc_b(a_ng, tmp); assert tmp = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue152.vhd000066400000000000000000000015631504111170000172600ustar00rootroot00000000000000package pkg is type integer_vector is array (natural range <>) of integer; type integer_vector_ptr is access integer_vector; procedure get(variable vec : in integer_vector_ptr; sum : inout integer); end package; package body pkg is procedure get(variable vec : in integer_vector_ptr; sum : inout integer) is begin sum := 0; for i in vec.all'range loop sum := sum + vec.all(i); end loop; end procedure; end package body; ------------------------------------------------------------------------------- entity issue152 is end entity; use work.pkg.all; architecture test of issue152 is begin process is variable sum : integer; variable vec : integer_vector_ptr; begin vec := new integer_vector'(1, 2, 3, 4, 5); get(vec, sum); assert sum = 15; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue153.vhd000066400000000000000000000041671504111170000172640ustar00rootroot00000000000000entity test_inst is generic( G_ROUND : natural := 0; G_ROUND_ENABLE : boolean := false ); port( i_value : in bit_vector(7 downto 0); o_ena : out bit; o_value : out bit_vector(7 downto 0) ); end test_inst; architecture rtl of test_inst is begin o_ena <='1' when G_ROUND_ENABLE else '0'; o_value <=(others=>'1') when G_ROUND=1 and G_ROUND_ENABLE else not i_value; end architecture rtl; entity issue153 is end entity issue153; architecture beh of issue153 is constant G_ROUND_ENABLE:boolean:=true; constant C_ADDROUND : bit_vector(7 downto 0):="00001111"; constant C_ZERO8 : bit_vector(7 downto 0):=(others=>'0'); signal s_ena:bit_vector(7 downto 0); type T_IN_DATA is array(integer range<>) of bit_vector(7 downto 0); --signal s_value: T_IN_DATA(7 downto -1);-- this should work anyway, uncomment this to compare with ghdl for bug 2 signal s_value: T_IN_DATA(7 downto 0);--this is for bug 1, nvc should report error begin GEN_MACS_V : for v in 0 to 7 generate signal C :bit_vector(7 downto 0); signal D :bit_vector(7 downto 0); begin --should fail here, but doesn't --GHDL failed here with "bound check failure" -- ghdl drives correct values on each instances, nvc doesn't --C <= C_ADDROUND when v=0 and G_ROUND_ENABLE else s_value(v-1);--bug 1 -- below is workaround, but I am lazy enough to not use it :)))) c_gen: if v=0 and G_ROUND_ENABLE generate C <= C_ADDROUND; end generate c_gen; nc_gen: if v>0 generate C <= s_value(v-1); end generate nc_gen; test_i : entity work.test_inst generic map( G_ROUND => 1 ) port map( i_value => C, o_ena => s_ena(v), o_value => s_value(v) ); end generate GEN_MACS_V; process begin wait for 1 ns; assert s_value(0) = not C_ADDROUND; assert s_value(1) = C_ADDROUND; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue16.vhd000066400000000000000000000010551504111170000171730ustar00rootroot00000000000000entity sub is port ( x : in bit_vector(7 downto 0); y : out bit_vector(7 downto 0) ); end entity; architecture test of sub is begin y <= x; end architecture; ------------------------------------------------------------------------------- entity issue16 is end entity; architecture test of issue16 is signal y : bit_vector(7 downto 0); begin sub_i: entity work.sub port map ( X"ab", y ); process is begin wait for 1 ns; assert y = X"ab"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue163.vhd000066400000000000000000000024011504111170000172520ustar00rootroot00000000000000package wait_until_pkg is procedure wait_until(signal sig : in boolean; val : boolean); procedure wait_until(signal sig : in bit_vector; val : bit_vector); end package; package body wait_until_pkg is procedure wait_until(signal sig : in boolean; val : boolean) is begin wait until sig = val; -- This does not work end procedure; function fun(x : bit_vector) return bit_vector is begin return x; end function; procedure wait_until(signal sig : in bit_vector; val : bit_vector) is begin wait until sig = fun(val); end procedure; end package body; ------------------------------------------------------------------------------- entity issue163 is end entity; use work.wait_until_pkg.all; architecture test of issue163 is signal s : boolean; signal v : bit_vector(7 downto 0); begin s <= true after 1 ns, false after 2 ns; process is begin wait_until(s, true); assert now = 1 ns; wait_until(s, false); assert now = 2 ns; wait; end process; v <= X"10" after 1 ns, X"bc" after 2 ns; process is begin wait_until(v, X"10"); assert now = 1 ns; wait_until(v, X"bc"); assert now = 2 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue169.vhd000066400000000000000000000005141504111170000172630ustar00rootroot00000000000000entity issue169 is end entity; architecture a of issue169 is begin main : process procedure proc(x : natural) is begin if x > 0 then wait for 1 ns; proc(x - 1); end if; end procedure; begin proc(5); assert now = 5 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue18.vhd000066400000000000000000000016041504111170000171750ustar00rootroot00000000000000entity sub is port ( x, y : in bit_vector(3 downto 0); z : out bit_vector(3 downto 0) ); end entity; architecture test of sub is begin z <= x and y; end architecture; ------------------------------------------------------------------------------- entity issue18 is end entity; architecture test of issue18 is signal s : bit_vector(7 downto 0); constant c : bit_vector(7 downto 0) := X"AA"; begin sub_i: entity work.sub port map ( x => c(3 downto 0), y => s(3 downto 0), z => s(7 downto 4) ); process is begin s(3 downto 0) <= X"A"; wait for 1 ns; assert s = X"AA"; s(3 downto 0) <= X"0"; wait for 1 ns; assert s = X"00"; s(3 downto 0) <= X"F"; wait for 1 ns; assert s = X"AF"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue183.vhd000066400000000000000000000022531504111170000172610ustar00rootroot00000000000000package pkg is function fun(constant s : string) return string; impure function ifun(constant s : string) return bit_vector; end package; package body pkg is function fun(constant s : string) return string is function nested_fun return integer is begin if s'length = 0 then return 1; else return s'length; end if; end function; variable ret_val : string(1 to nested_fun); begin return ret_val; end; impure function ifun(constant s : string) return bit_vector is -- Renaming to nested_fun2 makes it work function nested_fun return integer is begin if s'length = 0 then return 1; else return s'length; end if; end function; variable ret_val : bit_vector(1 to nested_fun); begin return ret_val; end; end package body; ------------------------------------------------------------------------------- entity issue183 is end entity; use work.pkg.all; architecture test of issue183 is begin process is variable s : string(1 to 2); begin assert fun(s) = s; assert ifun(s) = "00"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue185.vhd000066400000000000000000000023531504111170000172640ustar00rootroot00000000000000entity issue185 is end entity; architecture a of issue185 is type record_t is record field : natural; end record; procedure proc_rec(constant value : in record_t := (field => 0)) is begin report integer'image(value.field); wait for 0 ns; report integer'image(value.field); end procedure; procedure proc_integer(constant value : in integer := 0) is begin report integer'image(value); wait for 0 ns; report integer'image(value); end procedure; procedure proc_string(constant value : in string := "hello") is begin report value; wait for 0 ns; report value; end procedure; procedure proc_bit_vector(constant value : in bit_vector := "0") is begin report bit'image(value(0)); wait for 0 ns; report bit'image(value(0)); end procedure; begin main : process begin report "record parameter does not work"; proc_rec; proc_rec(value => (field => 1)); report "integer parameter works"; proc_integer; proc_integer(value => 1); report "string parameter works"; proc_string; proc_string(value => "foobar"); report "bit_vector parameter works"; proc_bit_vector; proc_bit_vector(value => "1"); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue186.vhd000066400000000000000000000013561504111170000172670ustar00rootroot00000000000000package pkg is procedure proc; end package; package body pkg is procedure proc is begin report "Hello"; end procedure; end package body; ------------------------------------------------------------------------------- -- use work.pkg.proc; Put use clause here and it will work package other_pkg is procedure calling_proc; end package; use work.pkg.proc; package body other_pkg is procedure calling_proc is begin proc; end procedure; end package body; ------------------------------------------------------------------------------- use work.other_pkg.calling_proc; entity issue186 is end entity; architecture a of issue186 is begin main : process begin calling_proc; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue187.vhd000066400000000000000000000005551504111170000172700ustar00rootroot00000000000000entity issue187 is end entity; architecture a of issue187 is function expensive_function_returning_false return boolean is begin report "This cost much"; return false; end function; begin main : process begin assert (not (expensive_function_returning_false or expensive_function_returning_false)); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue194.vhd000066400000000000000000000013221504111170000172570ustar00rootroot00000000000000-- -*- mode: vhdl; vhdl-basic-offset: 2 -*- package pkg is function other_fun(x : integer) return integer; function fun(x : integer) return integer; end package; package body pkg is function other_fun(x : integer) return integer is begin return x; end function; function fun(x : integer) return integer is function nested(x : integer) return integer is begin return other_fun(x); end; begin return nested(x); end function; end package body; use work.pkg.all; entity issue194 is end entity; architecture a of issue194 is begin main : process variable x : integer; begin x := 0; wait for 1 ns; assert fun(x) = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue196.vhd000066400000000000000000000021661504111170000172700ustar00rootroot00000000000000package pkg is procedure proc(s : string); end package; package body pkg is procedure proc(s : string) is begin end procedure; end package body; ------------------------------------------------------------------------------- use work.pkg.all; entity issue196 is end entity; architecture tb of issue196 is type rec_t is record field : natural; end record; procedure proc is begin proc("" & LF); wait for 0 ns; proc("------------------------------------------------------------" & LF); end; procedure proc2 ( constant var : in rec_t := (others => 0)) is begin wait for 0 ns; report integer'image(var.field); assert var = (others => 0); proc("--------------------------------abcd" & LF); -- abcd corrupts var -- var.field was overwritten by "abcd" report integer'image(var.field) & " = " & integer'image((((character'pos('d')*256 + character'pos('c'))*256 + character'pos('b'))*256 + character'pos('a'))); assert var = (others => 0); -- Should still be 0 end procedure; begin main : process begin proc; proc2; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue197.vhd000066400000000000000000000010351504111170000172630ustar00rootroot00000000000000entity entity_attr is constant MIN_DELAY : NATURAL := 42; attribute DELAY : NATURAL; attribute DELAY of entity_attr : entity is MIN_DELAY; end entity; architecture foo of entity_attr is begin end architecture; entity issue197 is end entity; architecture foe of issue197 is constant fumble: natural := work.entity_attr'DELAY; begin alu_div_0: entity work.entity_attr ; MONITOR: process begin assert fumble = 42; assert work.entity_attr'DELAY = 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue200.vhd000066400000000000000000000011221504111170000172410ustar00rootroot00000000000000package pkg is procedure proc(length : integer); end package; package body pkg is procedure proc(length : integer) is -- Runtime error variable bv : bit_vector(length-1 downto 0) := (others => '0'); begin report integer'image(bv'length); end procedure; end package body; use work.pkg.all; entity issue200 is end entity; architecture a of issue200 is begin main : process -- Static error variable bv : bit_vector(-1 downto 0) := (others => '0'); begin report integer'image(bv'length); proc(0); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue201.vhd000066400000000000000000000016351504111170000172530ustar00rootroot00000000000000package pkg is type prot_t is protected procedure proc(x : out integer); end protected; end package; package body pkg is type prot_t is protected body procedure proc(x : out integer) is function nested_fun return integer is begin return 5; end function; procedure nested_proc is begin x := nested_fun; end procedure; function nested_ifun return integer is begin return 0; end function; begin nested_proc; end procedure; end protected body; end package body; ------------------------------------------------------------------------------- entity issue201 is end entity; use work.pkg.all; architecture test of issue201 is shared variable p : prot_t; begin process is variable x : integer; begin p.proc(x); assert x = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue202.vhd000066400000000000000000000010701504111170000172450ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue202 is end entity; architecture a of issue202 is type rec_t is record field : std_logic; field2 : std_logic_vector(1 downto 0); end record; signal sig : rec_t; begin p1 : process begin sig <= ('0', "0Z"); wait; end process; p2 : process begin sig <= ('1', "10"); wait; end process; monitor : process (sig) begin report std_logic'image(sig.field); report std_logic'image(sig.field2(1)) & std_logic'image(sig.field2(0)); end process; end architecture; nvc-r1.17.1/test/regress/issue204.vhd000066400000000000000000000003441504111170000172520ustar00rootroot00000000000000entity issue204 is end entity; architecture a of issue204 is type enum_t is (a, b); begin main : process begin assert enum_t'leftof(b) = a; assert enum_t'rightof(a) = b; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue206.vhd000066400000000000000000000005471504111170000172610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue206 is end entity; architecture a of issue206 is begin main : process variable u : unsigned(31 downto 0) := (others => '0'); begin for i in 0 to 1023 loop --report integer'image(i); u := u / 10; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue217.vhd000066400000000000000000000015371504111170000172630ustar00rootroot00000000000000entity SUB is port ( USER_I : in bit_vector(1 downto 0); RESULT : out boolean ); end SUB; architecture MODEL of SUB is procedure match(user:in bit_vector; ok: out boolean) is begin ok := (user(USER_I'range) = USER_I); end procedure; begin process(USER_I) variable ok : boolean; constant user : bit_vector(1 downto 0) := "01"; begin match(user, ok); RESULT <= ok; end process; end MODEL; entity issue217 is end issue217; architecture MODEL of issue217 is signal USER : bit_vector(1 downto 0); signal OK : boolean; begin U: entity WORK.SUB port map ( USER_I => USER, RESULT => OK ); user <= "01"; process is begin assert not ok; wait on ok; assert ok; wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue225.vhd000066400000000000000000000021201504111170000172470ustar00rootroot00000000000000-- use std.textio.all; -- this does work entity issue225 is -- use std.textio.all; -- doesn't work end entity issue225; -- use std.textio.all; -- this does work architecture test of issue225 is use std.textio.all; -- doesn't work begin g1: if true generate -- use std.textio.all; -- doesn't work (this one doesn't compile unless parse.c's p_generate_statement's call to scan() is amended to include pUSE (issue 223) begin b1: block -- use std.textio.all; -- doesn't work begin p1: process -- use std.textio.all; -- doesn't work procedure doit is -- use std.textio.all; -- doesn't work begin write(OUTPUT, "ok" & LF); wait; end procedure doit; begin doit; end process p1; end block b1; end generate g1; end architecture test; nvc-r1.17.1/test/regress/issue227.vhd000066400000000000000000000022541504111170000172610ustar00rootroot00000000000000entity issue227 is end entity issue227; use std.textio.all; architecture test of issue227 is procedure proc( delay : time := 0 ns; a,b : integer := 1) is begin wait for delay; write(OUTPUT, integer'image(a) & integer'image(b) & LF); end procedure proc; function func(a,b : integer := 1) return integer is begin return 10*a+b; end function func; begin proc; -- all unassociated proc(1 ns, 2, b => open); -- named OPEN proc(2 ns, open, b => 2); -- positional OPEN proc(3 ns, a => 2); -- one unassociated process begin wait for 4 ns; proc; -- all unassociated proc(0 ns, 2, b => open); -- named OPEN proc(0 ns, open, b => 2); -- positional OPEN proc(0 ns, a => 2); -- one unassociated write(OUTPUT, integer'image(func) & LF); write(OUTPUT, integer'image(func(a => 2, b => open)) & LF); write(OUTPUT, integer'image(func(open, b => 2)) & LF); write(OUTPUT, integer'image(func(a => 2)) & LF); wait; end process; end architecture test; nvc-r1.17.1/test/regress/issue229.vhd000066400000000000000000000005511504111170000172610ustar00rootroot00000000000000use std.textio.all; entity issue229 is end entity issue229; architecture test of issue229 is begin process begin for ii in 1 to 2049 loop write(OUTPUT, integer'image(1)); end loop; wait; end process; -- Alternatively, delete the for loop and the wait statement -- it fails the same way end architecture test; nvc-r1.17.1/test/regress/issue234.vhd000066400000000000000000000006231504111170000172550ustar00rootroot00000000000000entity subent is end entity subent; architecture subentarch of subent is signal a : boolean; -- commenting this out eliminates the assertion begin proc: process begin report "ok"; wait; end process; end architecture; entity issue234 is end entity issue234; architecture testarch of issue234 is begin ent1: entity work.subent; ent2: entity work.subent; end architecture; nvc-r1.17.1/test/regress/issue262.vhd000066400000000000000000000054011504111170000172550ustar00rootroot00000000000000package textio is type line is access string; end package; use work.textio.all; package PKG is procedure SCAN( variable TEXT_LINE : inout LINE; TEXT_END : in integer; START_POS : in integer; FOUND : out boolean; FOUND_LEN : out integer ); end package; use work.textio.all; package body PKG is procedure SCAN( variable TEXT_LINE : inout LINE; TEXT_END : in integer; START_POS : in integer; FOUND : out boolean; FOUND_LEN : out integer ) is variable len : integer; variable char : character; begin len := 1; for pos in START_POS+1 to text_end loop char := text_line(pos); case char is when NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL| BS |HT |LF |VT |FF |CR |SO |SI | DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB| CAN|EM |SUB|ESC|FSP|GSP|RSP|USP|DEL => exit; when '['|']'|'{'|'}'|',' => for prev_pos in pos-1 downto START_POS loop exit when (text_line(prev_pos) /= ' '); len := len - 1; end loop; exit; when ':'=> for prev_pos in pos-1 downto START_POS loop exit when (text_line(prev_pos) /= ' '); len := len - 1; end loop; exit; when '#' => for prev_pos in pos-1 downto START_POS loop exit when (text_line(prev_pos) /= ' '); len := len - 1; end loop; exit; when others => null; end case; len := len + 1; end loop; FOUND := TRUE; FOUND_LEN := len; end procedure; end package body; use work.textio.all; library WORK; use WORK.PKG.all; entity issue262 is end issue262; architecture MODEL of issue262 is begin process variable text_line : LINE; variable text_end : integer; variable found : boolean; variable found_len : integer; begin --write(text_line, string'("{A:1}")); text_line := new string'("{A:1}"); text_end := 4; SCAN(text_line, text_end, 1, found, found_len); report boolean'image(found); report integer'image(found_len); assert found; assert found_len = 2; wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue284.vhd000066400000000000000000000011331504111170000172570ustar00rootroot00000000000000use std.textio.all; package issue284_pkg is procedure check_it; end package issue284_pkg; package body issue284_pkg is file my_file : text; procedure check_it is variable contents : line; begin file_open(my_file, "test.txt", WRITE_MODE); write(contents, string'("hello")); writeline(my_file, contents); file_close(my_file); end procedure check_it; end package body issue284_pkg; entity issue284 is end entity issue284; use work.issue284_pkg.all; architecture test of issue284 is begin process begin check_it; wait; end process; end architecture test; nvc-r1.17.1/test/regress/issue29.vhd000066400000000000000000000014011504111170000171720ustar00rootroot00000000000000entity sub is generic ( width : integer ); port ( x : in bit_vector(width - 1 downto 0); y : in bit_vector; z : out bit_vector(width - 1 downto 0) ); end entity; architecture test of sub is begin z <= x and y after 1 us; end architecture; ------------------------------------------------------------------------------- entity issue29 is end entity; architecture rtl of issue29 is signal z : bit_vector(7 downto 0); begin sub_i: entity work.sub generic map ( width => 8 ) port map ( x => X"ab", y => X"cd", z => z ); process is begin wait for 2 us; assert z = "10001001"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue293.vhd000066400000000000000000000005341504111170000172630ustar00rootroot00000000000000library IEEE; use IEEE.std_logic_1164.all; use IEEE.math_real.all; entity issue293 is end issue293; architecture behv of issue293 is constant AWIDTH : natural := integer(ceil(log2(real(4)))); signal a : std_logic_vector (AWIDTH downto 0); begin process is begin assert a'left = 2; wait; end process; end behv; nvc-r1.17.1/test/regress/issue308.vhd000066400000000000000000000020311504111170000172520ustar00rootroot00000000000000use std.textio.all; entity issue308 is generic (TIME_WIDTH : integer := 13); end issue308; architecture MODEL of issue308 is begin process variable text_line : LINE; procedure p(T:in time;M:in string) is begin if (TIME_WIDTH > 0) then WRITE(text_line, T, RIGHT, TIME_WIDTH); elsif (TIME_WIDTH < 0) then WRITE(text_line, T, LEFT , -TIME_WIDTH); end if; WRITE(text_line, string'(" ") & M); WRITELINE(OUTPUT, text_line); end procedure; begin p(Now, string'("Simulation Start.")); wait for 100 ns; p(Now, string'("Simulation Phase 1.")); wait for 100 ns; p(Now, string'("Simulation Phase 2.")); wait for 1947 ns; p(Now, string'("Simulation Phase 3.")); wait for 1 ns; p(Now, string'("Simulation Phase 4.")); wait for 1 ns; p(Now, string'("Simulation Done.")); wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue309.vhd000066400000000000000000000021751504111170000172640ustar00rootroot00000000000000-- test_ng.vhd use std.textio.all; entity issue309 is end issue309; architecture MODEL of issue309 is begin process constant org_data : bit_vector(31 downto 0) := "01110110010101000011001000010000"; variable val_data : bit_vector(31 downto 0); variable text_line : LINE; begin val_data := (others => '0'); for i in 7 downto 0 loop write(text_line, string'("val_data=")); write(text_line, val_data); val_data(31 downto 4) := val_data(27 downto 0); val_data( 3 downto 0) := org_data(i*4+3 downto i*4); write(text_line, string'("=>")); write(text_line, val_data); writeline(OUTPUT, text_line); end loop; if (val_data /= org_data) then write(text_line, string'("NG:org_data=")); write(text_line, org_data); writeline(OUTPUT, text_line); write(text_line, string'(" val_data=")); write(text_line, val_data); writeline(OUTPUT, text_line); assert false; end if; wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue315.vhd000066400000000000000000000040751504111170000172620ustar00rootroot00000000000000-- test_sync.vhd entity TEST_SYNC is generic ( BITS : integer := 1 ); port ( I : in bit_vector(BITS-1 downto 0); O : out bit_vector(BITS-1 downto 0) ); end TEST_SYNC; architecture MODEL of TEST_SYNC is begin O <= I; end MODEL; -- test_ng.vhd entity TEST_NG is generic ( DATA_BITS : integer := 32 ); port ( I_DATA : in bit_vector(DATA_BITS-1 downto 0); O_DATA : out bit_vector(DATA_BITS-1 downto 0) ); end TEST_NG; architecture RTL of TEST_NG is component TEST_SYNC generic (BITS: integer := 1); port( I: in bit_vector(BITS-1 downto 0); O: out bit_vector(BITS-1 downto 0) ); end component; type INFO_TYPE is record DATA_LO : integer; DATA_HI : integer; BITS : integer; end record; function SET_INFO return INFO_TYPE is variable info : INFO_TYPE; variable index : integer; begin index := 0; info.DATA_LO := index; info.DATA_HI := index + DATA_BITS - 1; index := index + DATA_BITS; info.BITS := index; return info; end function; constant INFO : INFO_TYPE := SET_INFO; signal i_info : bit_vector(INFO.BITS-1 downto 0); signal o_info : bit_vector(INFO.BITS-1 downto 0); begin i_info(INFO.DATA_HI downto INFO.DATA_LO) <= I_DATA; SYNC: TEST_SYNC generic map ( BITS => INFO.BITS ) port map( I => i_info, O => o_info ); O_DATA <= o_info(INFO.DATA_HI downto INFO.DATA_LO); end RTL; ------------------------------------------------------------------------------- entity issue315 is end entity; architecture test of issue315 is signal i, o : bit_vector(31 downto 0); begin uut: entity work.test_ng port map (i, o ); process is begin i <= X"12345678"; wait for 1 ns; assert o = X"12345678"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue323.vhd000066400000000000000000000017651504111170000172640ustar00rootroot00000000000000entity issue323 is end entity; architecture test of issue323 is type intfile is protected procedure iwrite(x : in integer); procedure iread(x : out integer); end protected; type intfile is protected body type ft is file of integer; file f : ft; constant FNAME : string := "data"; procedure iwrite(x : in integer) is begin file_open(f, FNAME, WRITE_MODE); write(f, x); file_close(f); end procedure; procedure iread(x : out integer) is begin file_open(f, FNAME, READ_MODE); read(f, x); file_close(f); end procedure; end protected body; shared variable f : intfile; begin p0: process is begin f.iwrite(42); wait; end process; p1: process is variable x : integer; begin wait for 1 ns; f.iread(x); assert x = 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue327.vhd000066400000000000000000000037371504111170000172710ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use ieee.math_real.log2; use ieee.math_real.ceil; package test_pkg is function min_bits (val : positive) return integer; end test_pkg; package body test_pkg is function min_bits (val : positive) return integer is variable rv : integer; begin rv := integer(ceil(log2(real(val)))); if rv = 0 then rv := 1; end if; return rv; end; end test_pkg; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity counter is generic ( MAX_VAL : positive; WIDTH : positive ); port ( clk : in std_logic; rst : in std_logic; val_o : out unsigned(WIDTH-1 downto 0) ); end entity counter; architecture rtl of counter is signal val : unsigned(val_o'range); begin -- architecture rtl val_o <= val; process is begin -- process wait until rising_edge(clk); val <= val + 1; if rst = '1' then val <= (others => '0'); end if; end process; end architecture rtl; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity issue327 is end entity issue327; architecture tb of issue327 is constant MAX_VAL : positive := 5; constant WIDTH : positive := min_bits(MAX_VAL); signal clk : std_logic := '1'; signal rst : std_logic := '1'; signal val_o : unsigned(WIDTH-1 downto 0); signal val_o_d : unsigned(WIDTH-1 downto 0); begin -- architecture tb DUT : entity work.counter generic map ( MAX_VAL => MAX_VAL, WIDTH => WIDTH) port map ( clk => clk, rst => rst, val_o => val_o); process is begin assert WIDTH = 3; clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; assert val_o = "000"; rst <= '0'; clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; assert val_o = "001"; wait; end process; end architecture tb; nvc-r1.17.1/test/regress/issue335.vhd000066400000000000000000000011751504111170000172620ustar00rootroot00000000000000entity issue335 is end entity; use std.textio.all; architecture a of issue335 is begin main : process is variable tmp : integer; variable l : line; begin l := new string'("1"); report integer'image(l.all'length) & ", '" & l.all & "'"; assert l.all = "1"; read(l, tmp); assert tmp = 1; l := new string'("22"); report integer'image(l.all'length) & ", '" & l.all & "'"; assert l.all = "22"; -- Uncomment this to make it work l := new string'("333"); report integer'image(l.all'length) & ", '" & l.all & "'"; assert l.all = "333"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue338.vhd000066400000000000000000000137431504111170000172710ustar00rootroot00000000000000entity issue338 is end entity; architecture a of issue338 is signal pos : natural := 4; signal divisor : natural := 0; begin pure_function : process function fail return boolean is begin assert false report "Should never be reached" severity failure; return true; end; procedure proc(value : boolean; expected : boolean) is begin assert value = expected severity failure; end; variable count : natural := 0; variable value : boolean; begin while false and fail loop assert false report "Should never happen" severity error; count := count + 1; end loop; while true or fail loop count := count + 2; exit; end loop; if false and fail then assert false report "Should never happen" severity error; count := count + 4; end if; if true or fail then count := count + 8; end if; loop exit when true or fail; count := count + 16; end loop; loop exit when false and fail; count := count + 32; exit; end loop; proc(false and fail, false); proc(true or fail, true); value := true or fail; assert value; value := false and fail; assert not value; assert true or fail; assert not (false and fail); report integer'image(count); assert count = 2+8+32 severity failure; report "Finished"; wait; end process; impure_function : process variable retval : boolean := false; impure function fail return boolean is begin assert false report "Should never be reached" severity failure; retval := not retval; return retval; end; procedure proc(value : boolean; expected : boolean) is begin assert value = expected severity failure; end; variable count : natural := 0; variable value : boolean; begin while false and fail loop assert false report "Should never happen" severity error; count := count + 1; end loop; while true or fail loop count := count + 2; exit; end loop; if false and fail then assert false report "Should never happen" severity error; count := count + 4; end if; if true or fail then count := count + 8; end if; loop exit when true or fail; count := count + 16; end loop; loop exit when false and fail; count := count + 32; exit; end loop; proc(false and fail, false); proc(true or fail, true); value := true or fail; assert value; value := false and fail; assert not value; assert true or fail; assert not (false and fail); report integer'image(count); assert count = 2+8+32 severity failure; report "Finished"; wait; end process; access_out_of_range : process constant s : string := "123"; procedure proc(value : boolean; expected : boolean) is begin assert value = expected severity failure; end; variable count : natural := 0; variable value : boolean; begin while false and s(pos) = '1' loop assert false report "Should never happen" severity error; count := count + 1; end loop; while true or s(pos) = '1' loop count := count + 2; exit; end loop; if false and s(pos) = '1' then assert false report "Should never happen" severity error; count := count + 4; end if; if true or s(pos) = '1' then count := count + 8; end if; loop exit when true or s(pos) = '1'; count := count + 16; end loop; loop exit when false and s(pos) = '1'; count := count + 32; exit; end loop; proc(false and s(pos) = '1', false); proc(true or s(pos) = '1', true); value := true or s(pos) = '1'; assert value; value := false and s(pos) = '1'; assert not value; assert true or s(pos) = '1'; assert not (false and s(pos) = '1'); report integer'image(count); assert count = 2+8+32 severity failure; report "Finished"; wait; end process; non_static_access_out_of_range : process constant s : string := "123"; procedure proc(value : boolean; expected : boolean) is begin assert value = expected severity failure; end; variable count : natural := 0; variable value : boolean; variable pos : natural; begin pos := 4; while pos < 4 and s(pos) = '1' loop assert false report "Should never happen" severity error; count := count + 1; end loop; while pos = 4 or s(pos) = '1' loop count := count + 2; exit; end loop; if pos < 4 and s(pos) = '1' then assert false report "Should never happen" severity error; count := count + 4; end if; if pos = 4 or s(pos) = '1' then count := count + 8; end if; loop exit when pos = 4 or s(pos) = '1'; count := count + 16; end loop; loop exit when pos < 4 and s(pos) = '1'; count := count + 32; exit; end loop; proc(pos < 4 and s(pos) = '1', false); proc(pos = 4 or s(pos) = '1', true); value := pos = 4 or s(pos) = '1'; assert value; value := pos < 4 and s(pos) = '1'; assert not value; assert pos = 4 or s(pos) = '1'; assert not (pos < 4 and s(pos) = '1'); report integer'image(count); assert count = 2+8+32 severity failure; report "Finished"; wait; end process; divide_by_zero : process begin assert true or 7/divisor = 1; assert not (false and 7/divisor = 1); wait; end process; pure_but_expensive : process function expensive return boolean is variable result : integer; begin for i in 0 to 2**29 loop for j in 0 to 2**29 loop for k in 0 to 2*29 loop result := ((result+k-i+j) mod 2**19) * (k mod 2**10); end loop; end loop; end loop; return (result mod 16) = 0; end; begin assert true or expensive; assert not (false and expensive); wait; end process; end; nvc-r1.17.1/test/regress/issue338b.vhd000066400000000000000000000012401504111170000174200ustar00rootroot00000000000000entity issue338b is end entity; architecture a of issue338b is begin main : process procedure proc(s : string; variable value : out integer) is begin if s = "" then value := 0; else value := 1; end if; end; function func(s : string) return integer is begin if s = "" then return 0; end if; return 1; end; constant s1 : string := "foobar"; constant s0 : string := ""; variable value : integer; begin assert func(s1) = 1; assert func(s0) = 0; proc(s1, value); assert value = 1; proc(s0, value); assert value = 0; wait; end process; end; nvc-r1.17.1/test/regress/issue340.vhd000066400000000000000000000021311504111170000172470ustar00rootroot00000000000000entity submodule is port ( sig : in bit); end entity; architecture a of submodule is begin main : process begin wait for 1 ns; assert sig = '1'; report "Success"; wait; end process; end; entity issue340 is end entity; architecture a of issue340 is signal sig_vector : bit_vector(0 to 1) := "00"; alias sig_bit_alias : bit is sig_vector(0); signal sig : bit := '0'; alias sig_alias : bit is sig; procedure drive(signal value : out bit) is begin value <= '1'; end; begin main : process begin drive(sig_alias); drive(sig_bit_alias); wait for 1 ns; assert sig_vector(0) = '1'; assert sig = '1'; assert sig_alias = '1'; assert sig_bit_alias = '1'; report "Success"; wait; end process; submodule0_inst : entity work.submodule port map ( sig => sig_alias); submodule1_inst : entity work.submodule port map ( sig => sig_bit_alias); submodule2_inst : entity work.submodule port map ( sig => sig); submodule3_inst : entity work.submodule port map ( sig => sig_vector(0)); end; nvc-r1.17.1/test/regress/issue348.vhd000066400000000000000000000002511504111170000172600ustar00rootroot00000000000000entity issue348 is end entity; architecture a of issue348 is begin main : process begin std.env.stop(0); assert False severity failure; end process; end; nvc-r1.17.1/test/regress/issue349.vhd000066400000000000000000000012141504111170000172610ustar00rootroot00000000000000entity issue349 is end issue349; architecture RTL of issue349 is type WORD_TYPE is record DATA : bit_vector(7 downto 0); VAL : boolean; end record; constant WORD_NULL : WORD_TYPE := (DATA => (others => '0'), VAL => TRUE); type WORD_VECTOR is array (INTEGER range <>) of WORD_TYPE; signal curr_queue : WORD_VECTOR(0 to 1); begin curr_queue <= (others => WORD_NULL); process is begin wait for 1 ns; assert curr_queue = (0 to 1 => WORD_NULL); wait; end process; end RTL; nvc-r1.17.1/test/regress/issue351.vhd000066400000000000000000000026641504111170000172640ustar00rootroot00000000000000use std.textio.all; entity ISSUE351 is end ISSUE351; architecture RTL of ISSUE351 is type WORD_TYPE is record KEY : integer; VALUE : integer; end record; constant WORD_NULL : WORD_TYPE := (KEY => 0, VALUE => 0); type WORD_VECTOR is array (INTEGER range <>) of WORD_TYPE; procedure dump_words(WORDS: in WORD_VECTOR) is variable text_line : LINE; begin for i in WORDS'range loop WRITE(text_line, string'(" | ")); WRITE(text_line, i, LEFT, 5); WRITE(text_line, string'(" | ")); WRITE(text_line, WORDS(i).KEY , LEFT, 10); WRITE(text_line, string'(" | ")); WRITE(text_line, WORDS(i).VALUE, LEFT, 10); WRITELINE(OUTPUT, text_line); end loop; end procedure; begin process variable curr_queue : WORD_VECTOR(0 to 3); variable text_line : LINE; begin for i in curr_queue'range loop curr_queue(i).KEY := i; curr_queue(i).VALUE := i; end loop; for i in curr_queue'range loop WRITE(text_line, i); WRITE(text_line, string'(" to ")); WRITE(text_line, curr_queue'length-1); WRITELINE(OUTPUT, text_line); dump_words(curr_queue(i to curr_queue'length-1)); -- Bug? end loop; wait; end process; end RTL; nvc-r1.17.1/test/regress/issue352.vhd000066400000000000000000000022311504111170000172530ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; -- use ieee.numeric_std.all; -- use ieee.std_logic_unsigned.all; entity issue352 is end entity; architecture arch of issue352 is signal FixRealKCM_F400_uid2_Rtemp : std_logic_vector(4 downto 0) := "11111"; signal R :std_logic_vector(5 downto 0); function check_dims(x : unsigned) return unsigned is alias ax : unsigned(1 to x'length) is x; variable s : string(1 to x'length); begin assert x'low >= unsigned'low; assert x'high <= unsigned'high; for i in 1 to x'length loop s(i) := std_logic'image(ax(i))(2); end loop; report s; return x; end function; begin -- R <= "000000" - (FixRealKCM_F400_uid2_Rtemp(4) & FixRealKCM_F400_uid2_Rtemp(4 downto 0)); R <= std_logic_vector(unsigned'(unsigned'("00000") - check_dims(unsigned (FixRealKCM_F400_uid2_Rtemp(4) & FixRealKCM_F400_uid2_Rtemp(4 downto 0))))); process is begin wait for 1 ns; assert R = "000001"; assert FixRealKCM_F400_uid2_Rtemp'last_event = time'high; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue354.vhd000066400000000000000000000007531504111170000172640ustar00rootroot00000000000000entity issue354 is end issue354; architecture behav of issue354 is signal byte : bit_vector(7 downto 0); signal byte_too : bit_vector(7 downto 0); begin -- nvc doesn't like the byte_too(1) in the next line byte(1 downto 0) <= (1 => byte_too(1), 0 => '0') when true else (others => '0'); process begin byte_too(0) <= '0'; byte_too(1) <= '1'; wait for 100ns; assert byte(0) = '0'; assert byte(1) = '1'; assert false report "end of test" severity note; wait; end process; end behav; nvc-r1.17.1/test/regress/issue367.vhd000066400000000000000000000013011504111170000172560ustar00rootroot00000000000000package r is function r1(a:bit_vector) return bit_vector; end package; package body r is function r1(a:bit_vector) return bit_vector is variable ret : bit_vector(a'range); variable i : integer range a'range; -- Error here begin loop report integer'image(i); ret(i) := not a(i); exit when i = i'right; i := i + 1; end loop; return ret; end r1; end r; entity issue367 is end entity; use work.r.r1; architecture test of issue367 is begin process is variable b : bit_vector(1 to 3) := "101"; begin assert r1(b) = "010"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue369.vhd000066400000000000000000000006221504111170000172650ustar00rootroot00000000000000entity issue369 is end entity; architecture foo of issue369 is begin THIS_PROCESS: process type twovalue is ('0', '1'); subtype string4 is string(1 to 4); attribute a: string4; attribute a of '1' : literal is "TRUE"; begin assert THIS_PROCESS.'1''a = "TRUE"; assert THIS_PROCESS.'1''a'RIGHT = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue370.vhd000066400000000000000000000070531504111170000172620ustar00rootroot00000000000000-- -*- vhdl-basic-offset: 2 -*- package run_types_pkg is type runner_phase_unresolved_t is (test_runner_entry, test_runner_setup, test_suite_setup, test_case_setup, test_case, test_case_cleanup, test_suite_cleanup, test_runner_cleanup, test_runner_exit, multiple_drivers); type runner_phase_unresolved_array_t is array (integer range <>) of runner_phase_unresolved_t; function resolve_runner_phase ( constant values : runner_phase_unresolved_array_t) return runner_phase_unresolved_t; subtype runner_phase_t is resolve_runner_phase runner_phase_unresolved_t; type phase_locks_unresolved_t is record entry_is_locked : boolean; exit_is_locked : boolean; end record phase_locks_unresolved_t; type phase_locks_unresolved_array_t is array (integer range <>) of phase_locks_unresolved_t; function resolve_phase_locks ( constant values : phase_locks_unresolved_array_t) return phase_locks_unresolved_t; subtype phase_locks_t is resolve_phase_locks phase_locks_unresolved_t; type phase_locks_array_t is array (runner_phase_t range <>) of phase_locks_t; type boolean_array_t is array (integer range <>) of boolean; function resolve_runner_flag ( constant values : boolean_array_t) return boolean; subtype runner_flag_t is resolve_runner_flag boolean; type runner_sync_t is record phase : runner_phase_t; locks : phase_locks_array_t(test_runner_setup to test_runner_cleanup); exit_without_errors : runner_flag_t; end record runner_sync_t; end package; package body run_types_pkg is function resolve_runner_phase ( constant values : runner_phase_unresolved_array_t) return runner_phase_unresolved_t is variable n_set_values : natural := 0; variable result : runner_phase_unresolved_t := test_runner_entry; begin report "resolve_runner_phase called"; for i in values'range loop if values(i) = test_runner_exit then return test_runner_exit; elsif values(i) /= test_runner_entry then result := values(i); n_set_values := n_set_values + 1; end if; end loop; if n_set_values > 1 then result := multiple_drivers; end if; return result; end; function resolve_phase_locks ( constant values : phase_locks_unresolved_array_t) return phase_locks_unresolved_t is variable result : phase_locks_t; begin report "resolve_phase_locks called"; result.entry_is_locked := false; result.exit_is_locked := false; for i in values'range loop if values(i).entry_is_locked then result.entry_is_locked := true; end if; if values(i).exit_is_locked then result.exit_is_locked := true; end if; end loop; return result; end; function resolve_runner_flag ( constant values : boolean_array_t) return boolean is begin for i in values'range loop if values(i) = true then return true; end if; end loop; return false; end; end package body run_types_pkg; use work.run_types_pkg.all; entity issue370 is end entity; architecture a of issue370 is signal runner : runner_sync_t; procedure drive(signal runner: inout runner_sync_t; value : boolean) is begin runner.exit_without_errors <= value; end; begin p0 : process begin drive(runner, false); wait; end process; p1 : process begin drive(runner, true); wait; end process; p2 : process begin drive(runner, false); wait; end process; check_p: process is begin wait for 1 ns; assert runner.exit_without_errors; wait; end process; end; nvc-r1.17.1/test/regress/issue371.vhd000066400000000000000000000034521504111170000172620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue371 is end issue371; architecture behav of issue371 is signal clock : std_logic; signal chip_select_sig : std_logic; signal address_sig : std_logic_vector(2 downto 0); signal write_sig : std_logic; signal host_data_bus_sig : std_logic_vector(7 downto 0); procedure wait_for_ticks (num_clock_cycles : in integer) is begin for i in 1 to num_clock_cycles loop wait until rising_edge(clock); end loop; end procedure wait_for_ticks; procedure host_write (addr: in std_logic_vector; byte : in std_logic_vector; signal clock : in std_logic; signal chip_select : out std_logic; signal address : out std_logic_vector; signal write : out std_logic; signal host_data_bus : out std_logic_vector; invert_cs_etc : in std_logic ) is begin wait until rising_edge(clock); write <= '1' xor invert_cs_etc; chip_select <= '1' xor invert_cs_etc; address <= addr; host_data_bus <= byte; wait_for_ticks(1); write <= '0' xor invert_cs_etc; chip_select <= '0' xor invert_cs_etc; for i in address'LOW to address'HIGH loop address(i) <= '0'; end loop; for i in host_data_bus'LOW to host_data_bus'HIGH loop host_data_bus(i) <= '0'; end loop; wait until rising_edge(clock); end procedure host_write; begin process begin for i in 0 to 10 loop clock <= '0'; wait for 1 us; clock <= '1'; wait for 1 us; end loop; wait; end process; process begin host_write("001", X"aa", clock, chip_select_sig, address_sig, write_sig, host_data_bus_sig, '0'); for i in address_sig'LOW to address_sig'HIGH loop assert address_sig(i) = '0'; end loop; for i in host_data_bus_sig'LOW to host_data_bus_sig'HIGH loop assert host_data_bus_sig(i) = '0'; end loop; wait; end process; end behav; nvc-r1.17.1/test/regress/issue376.vhd000066400000000000000000000036361504111170000172730ustar00rootroot00000000000000entity decoder is port( i_bcd : in bit_vector(3 downto 0); -- bcd input o_display : out bit_vector(6 downto 0) -- display output ); end entity; library ieee; use ieee.numeric_bit.all; architecture rtl of decoder is constant D_ZERO : bit_vector(6 downto 0) := "1111110"; constant D_ONE : bit_vector(6 downto 0) := "0110000"; constant D_TWO : bit_vector(6 downto 0) := "1101101"; constant D_THREE : bit_vector(6 downto 0) := "1111001"; constant D_FOUR : bit_vector(6 downto 0) := "0110011"; constant D_FIVE : bit_vector(6 downto 0) := "1011011"; constant D_SIX : bit_vector(6 downto 0) := "1011111"; constant D_SEVEN : bit_vector(6 downto 0) := "1110000"; constant D_EIGHT : bit_vector(6 downto 0) := "1111111"; constant D_NINE : bit_vector(6 downto 0) := "1111011"; constant D_E : bit_vector(6 downto 0) := "1111001"; type t_decoder_arr is array (0 to 15) of bit_vector(6 downto 0); constant decoder_arr : t_decoder_arr := (D_ZERO, D_ONE, D_TWO, D_THREE, D_FOUR, D_FIVE, D_SIX, D_SEVEN, D_EIGHT, D_NINE, D_E, D_E, D_E, D_E, D_E, D_E); begin -- architecture with to_integer(unsigned(i_bcd)) select o_display <= decoder_arr(to_integer(unsigned(i_bcd))) when 0 to 15, D_E when others; end architecture; ------------------------------------------------------------------------------- entity issue376 is end entity; architecture test of issue376 is signal i_bcd : bit_vector(3 downto 0); signal o_display : bit_vector(6 downto 0); begin decoder_1: entity work.decoder port map ( i_bcd => i_bcd, o_display => o_display); process is begin i_bcd <= "0000"; wait for 1 ns; assert o_display = "1111110"; i_bcd <= "0001"; wait for 1 ns; assert o_display = "0110000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue377.vhd000066400000000000000000000013041504111170000172620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; entity issue377 is end entity; architecture test of issue377 is signal sticky : std_logic; signal shiftedFracY_d1 : std_logic_vector(49 downto 0); begin update: sticky <= '0' when (shiftedFracY_d1(23 downto 0)=CONV_STD_LOGIC_VECTOR(0,23)) else '1'; stim: process is begin wait for 1 ns; assert sticky = '1'; shiftedFracY_d1(19 downto 0) <= X"00000"; wait for 1 ns; assert sticky = '1'; shiftedFracY_d1(24 downto 20) <= "00000"; wait for 1 ns; assert sticky = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue38.vhd000066400000000000000000000014721504111170000172020ustar00rootroot00000000000000package p is function f (i : bit) return integer; end package p; package body p is function f (i : bit) return integer is begin report f'instance_name; assert f'instance_name = ":work:p:f:"; assert f'path_name = ":work:p:f:"; return 0; end function f; end package body p; ------------------------------------------------------------------------------- entity issue38 is begin end entity issue38; use work.p.all; architecture a of issue38 is function g (i : bit) return integer is begin assert g'instance_name = ":issue38(a):g:"; assert g'path_name = ":issue38:g:"; assert f'instance_name = ":work:p:f:" report f'instance_name; return 0; end function g; begin assert (f('1') = 0); assert (g('1') = 0); end architecture a; nvc-r1.17.1/test/regress/issue397.vhd000066400000000000000000000014111504111170000172630ustar00rootroot00000000000000library IEEE; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use ieee.math_real.all; entity issue397 is end issue397; architecture behav of issue397 is begin process variable i: integer; variable r: real; begin r := 0.9; i := integer(r); assert i = 1 report real'image(r) & " cast to integer gives " & integer'image(i); r := 0.3; i := integer(r); assert i = 0 report real'image(r) & " cast to integer gives " & integer'image(i); report real'image(log2(real(8))); r := floor(log2(real(8))); i := integer(r); assert i = 3 report "floor(log2(real(8))) cast to integer gives " & integer'image(i) severity warning; -- TODO wait; end process; end behav; nvc-r1.17.1/test/regress/issue405.vhd000066400000000000000000000035611504111170000172610ustar00rootroot00000000000000entity buf is port ( a : in bit; y : out bit ); end entity; architecture test of buf is begin y <= a after 1 ns; end architecture; ------------------------------------------------------------------------------- entity fanout_tree is generic ( h : natural; d : positive ); port ( input : in bit; output : out bit_vector (0 to d**h - 1) ); end fanout_tree; architecture recursive of fanout_tree is component buf port ( a : in bit; y : out bit ); end component; component fanout_tree generic ( h : natural; d : positive ); port ( input : in bit; output : out bit_vector(0 to d**h - 1) ); end component; signal buffered_input : bit_vector(0 to d - 1); begin degenerate_tree : if h = 0 generate output(0) <= input; end generate degenerate_tree; compound_tree : if h > 0 generate subtree_array : for i in 0 to d - 1 generate the_buffer : buf port map ( a => input, y => buffered_input(i) ); the_subtree : fanout_tree generic map ( h => h - 1, d => d ) port map ( input => buffered_input(i), output => output(i * d**(h-1) to (i+1) * d**(h-1) -1) ); end generate subtree_array; end generate compound_tree; end recursive; ------------------------------------------------------------------------------- entity issue405 is end entity; architecture test of issue405 is signal input : bit; signal output : bit_vector(0 to 4**3 - 1); begin top_i: entity work.fanout_tree generic map ( h => 3, d => 4 ) port map ( input, output ); check: process is begin wait for 5 ns; assert output = (output'range => '0'); input <= '1'; wait for 5 ns; assert output = (output'range => '1'); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue407.vhd000066400000000000000000000025231504111170000172600ustar00rootroot00000000000000PACKAGE ecc_top_pkg is constant engnum : integer:=8; subtype engrange is integer range 0 to engnum-1; type bit_array is array(engrange) of bit; type byte_array is array(engrange) of bit_vector(7 downto 0); END PACKAGE; entity issue407 is end entity; use work.ecc_top_pkg.all; architecture test of issue407 is type mode_t is (RDBMG, C2ENC, C2DEC, C1DEC, WRBMG); type mode_arr_t is array (natural range <>) of mode_t; constant ECC_RD_DATA_VAL : bit := '1'; signal buf_ce : bit_vector(engrange); signal bufmode : mode_arr_t(0 to 0); signal index : natural := 0; signal c2enc_ce, c2dec_ce, c1dec_ce : bit_vector(engrange); signal task4_ce : bit := '1'; begin ce: with bufmode(index) select buf_ce <= (engrange => ECC_RD_DATA_VAL) WHEN RDBMG, -- Line 412 c2enc_ce when C2ENC, c2dec_ce WHEN C2DEC, c1dec_ce WHEN C1DEC, (engrange => task4_ce) WHEN WRBMG, -- Line 416 (engrange => '0') WHEN others; -- Line 417 stim: process is begin bufmode(0) <= C2DEC; wait for 1 ns; assert buf_ce = X"00"; bufmode(0) <= RDBMG; wait for 1 ns; assert buf_ce = X"FF"; bufmode(0) <= WRBMG; task4_ce <= '0'; wait for 1 ns; assert buf_ce = X"00"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue412.vhd000066400000000000000000000024111504111170000172500ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue412 is end issue412; architecture behavioral of issue412 is signal clk : std_logic := '0'; signal running : boolean := true; begin process (clk, running) begin if running then clk <= not clk after 5 ns; end if; end process; process -- Overloading the name is not the issue. procedure wr_data(data : signed) is begin -- A delay here seems to be necessary to cause the issue. wait until clk = '1'; -- wait for 10 ns; end; -- Calling from this function to the next seems -- to be required for the crash. procedure wr_data(data : integer) is begin wr_data(to_signed(data, 32)); end; variable data : signed(31 downto 0); begin -- Loop to 2000 works with line A below. -- for n in 1 to 2000 loop -- Loop to 3000 does not work with line A below. for n in 1 to 3000 loop -- Loop to 3000000 works fine with lines B below. -- for n in 1 to 3000000 loop wr_data(n); -- A -- data := to_signed(n, 32); -- B -- wr_data(data); -- B end loop; assert false report "Test OK" severity note; running <= false; wait; end process; end behavioral; nvc-r1.17.1/test/regress/issue414.vhd000066400000000000000000000031471504111170000172610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue414 is end issue414; architecture behavioral of issue414 is signal clk : std_logic := '0'; signal addr : std_logic_vector(55 downto 0); signal wdata : std_logic_vector(31 downto 0); subtype uword64 is unsigned(63 downto 0); signal running : boolean := true; begin process (clk, running) begin if running then clk <= not clk after 5 ns; end if; end process; process procedure wr_data(address_in : std_logic_vector; data : std_logic_vector; do_wait : boolean) is -- Without this things work! constant address : std_logic_vector(address_in'length - 1 downto 0) := address_in; begin -- Without this I get, for high enough loop counts (1000000+): -- zsh: segmentation fault nvc -a bug4.vhd -e bug4 -r if do_wait then wait until clk = '1'; end if; end; procedure wr_data(address : unsigned; data : unsigned; do_wait : boolean) is begin wr_data(std_logic_vector(address), std_logic_vector(data), do_wait); end; variable addr : unsigned(55 downto 0) := (others => '0'); variable slvdata : unsigned(31 downto 0) := (others => '0'); begin -- 1000 is OK for n in 0 to 4000 loop wr_data(addr, slvdata, do_wait => true); -- SIGBUS crash end loop; for n in 0 to 1000000 loop wr_data(addr, slvdata, do_wait => false); -- Stack overflow end loop; assert false report "Test OK" severity warning; running <= false; wait; end process; end behavioral; nvc-r1.17.1/test/regress/issue415.vhd000066400000000000000000000041161504111170000172570ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity bug5 is port( clk : in std_logic; addr : std_logic_vector ); end bug5; architecture behavioral of bug5 is -- This complains with stack trace: -- Fatal: signal cannot have unconstrained array type signal last_addr_s : std_logic_vector(addr'range); -- This is fine -- signal last_addr : std_logic_vector(addr'high downto addr'low); begin process(clk) -- This causes SIGABRT variable last_addr : std_logic_vector(addr'range); -- This is fine -- variable last_addr : std_logic_vector(addr'high downto addr'low); type int_arr is array (integer range <>) of integer; type chunk_item is record memory : boolean; data : int_arr(0 to 1); end record; constant chunk_empty : chunk_item := (false, (others => -1)); type mem_arr is array (integer range <>) of chunk_item; -- The line below complains with stack trace: -- Fatal: attempt to add to already finished block 0 variable mem2 : mem_arr(0 to 1) := (others => chunk_empty); -- This is fine (including with the assigment below) -- variable mem2 : mem_arr(0 to 1); begin if rising_edge(clk) then if addr = (addr'range => '0') then mem2 := (others => chunk_empty); end if; last_addr_s <= addr; end if; end process; check: process is begin wait for 5 ns; assert last_addr_s = X"00000000000001"; wait; end process; end behavioral; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue415 is end issue415; architecture behavioral of issue415 is signal clk : std_logic := '0'; signal addr : std_logic_vector(55 downto 0); begin bug2_i: entity work.bug5 port map ( clk => clk, addr => addr ); stim: process is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; addr <= X"00000000000001"; wait for 1 ns; clk <= '1'; wait for 1 ns; wait; end process; end behavioral; nvc-r1.17.1/test/regress/issue420.vhd000066400000000000000000000016331504111170000172540ustar00rootroot00000000000000package globals is signal COMMAND_FILE_ENDIAN : bit; signal COMMAND_FILE_NAME : string(1 to 1024); signal COMMAND_FILE_NAMELEN : integer; signal COMMAND_FILE_TARGET : integer; signal COMMAND_FILE_START : bit; signal COMMAND_FILE_ACK : bit; procedure change (signal what : out bit); end package globals; package body globals is procedure change (signal what : out bit) is begin what <= '1'; end procedure; end package body; ------------------------------------------------------------------------------- entity issue420 is end entity; use work.globals.all; architecture test of issue420 is begin check: process is begin assert COMMAND_FILE_ACK = '0'; assert COMMAND_FILE_NAME = (1 to 1024 => NUL); change(COMMAND_FILE_ACK); wait for 1 ns; assert COMMAND_FILE_ACK = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue423.vhd000066400000000000000000000005461504111170000172610ustar00rootroot00000000000000entity issue423 is end entity issue423; architecture rtl of issue423 is signal sig : bit := '0'; begin process begin sig <= '0' after 1 ps; wait for 3 ps; assert sig'last_active = 3 ps - 1 ps report "Signal should have been active" severity warning; assert sig'last_active = 3 ps - 1 ps; wait; end process; end architecture rtl; nvc-r1.17.1/test/regress/issue428.vhd000066400000000000000000000105141504111170000172620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package SYNC is constant SYNC_MAX_PLUG_SIZE : integer := 4; subtype SYNC_PLUG_NUM_TYPE is integer range 1 to SYNC_MAX_PLUG_SIZE; subtype SYNC_SIG_TYPE is std_logic_vector(1 to SYNC_MAX_PLUG_SIZE); subtype SYNC_REQ_TYPE is integer; subtype SYNC_ACK_TYPE is std_logic; type SYNC_REQ_VECTOR is array (INTEGER range <>) of SYNC_REQ_TYPE; type SYNC_ACK_VECTOR is array (INTEGER range <>) of SYNC_ACK_TYPE; component SYNC_SIG_DRIVER generic ( PLUG_NUM : SYNC_PLUG_NUM_TYPE := 1 ); port ( SYNC : inout SYNC_SIG_TYPE := (others => 'Z'); -- Was 'U' REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end component; end package; library ieee; use ieee.std_logic_1164.all; library WORK; use WORK.SYNC.all; entity SYNC_SIG_DRIVER_SUB_UNIT is port ( SYNC_I : in SYNC_SIG_TYPE; SYNC_O : out std_logic; REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end SYNC_SIG_DRIVER_SUB_UNIT; architecture MODEL of SYNC_SIG_DRIVER_SUB_UNIT is function ALL_ONE(SYNC : SYNC_SIG_TYPE) return boolean is variable sync_vec : SYNC_SIG_TYPE; constant all_1 : SYNC_SIG_TYPE := (others => '1'); begin for i in SYNC'range loop if (SYNC(i) = '0') then sync_vec(i) := '0'; else sync_vec(i) := '1'; end if; end loop; if (sync_vec = all_1) then return true; else return false; end if; end function; begin process begin SYNC_O <= 'Z'; ACK <= '0'; SYNC_LOOP: loop if (REQ > 0) then SYNC_O <= 'H'; wait until (ALL_ONE(SYNC_I)); -- This line causes an error SYNC_O <= '0'; ACK <= '1'; wait until (REQ = 0); ACK <= '0'; elsif (REQ = 0) then SYNC_O <= '0'; else SYNC_O <= 'Z'; end if; wait on REQ; end loop; end process; end MODEL; library ieee; use ieee.std_logic_1164.all; use std.textio.all; library WORK; use WORK.SYNC.all; entity SYNC_SIG_DRIVER is generic ( PLUG_NUM : SYNC_PLUG_NUM_TYPE := 1 ); port ( SYNC : inout SYNC_SIG_TYPE := (others => 'Z'); -- Was 'U' REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end SYNC_SIG_DRIVER; architecture MODEL of SYNC_SIG_DRIVER is component SYNC_SIG_DRIVER_SUB_UNIT is port ( SYNC_I : in SYNC_SIG_TYPE; SYNC_O : out std_logic; REQ : in SYNC_REQ_TYPE; ACK : out SYNC_ACK_TYPE ); end component; begin U: SYNC_SIG_DRIVER_SUB_UNIT port map( SYNC_I => SYNC, SYNC_O => SYNC(PLUG_NUM), REQ => REQ, ACK => ACK ); end MODEL; library ieee; use ieee.std_logic_1164.all; library WORK; use WORK.SYNC.all; entity issue428 is end issue428; architecture MODEL of issue428 is constant PLUG_SIZE : integer := 2; signal SYNC : SYNC_SIG_TYPE; signal REQ : SYNC_REQ_VECTOR(1 to PLUG_SIZE); signal ACK : SYNC_ACK_VECTOR(1 to PLUG_SIZE); begin PLUG : for i in 1 to PLUG_SIZE generate DRIVER : SYNC_SIG_DRIVER generic map (PLUG_NUM => i) port map (SYNC => SYNC, REQ => REQ(i), ACK => ACK(i)); end generate; process begin REQ(1) <= 0; wait; end process; process begin assert sync = "UUUU"; wait for 0 ns; assert sync = "UUUU"; wait for 5 ns; REQ(2) <= 1; wait for 10 ns; report std_logic'image(sync(1)); report std_logic'image(sync(2)); report std_logic'image(sync(3)); report std_logic'image(sync(4)); assert sync = "XX11"; -- Aldec has UXUU (with SYNC default of -- 'U') assert ack(2) = '1'; wait; end process; sync <= (others => '1') after 10 ns; end MODEL; nvc-r1.17.1/test/regress/issue429.vhd000066400000000000000000000020111504111170000172540ustar00rootroot00000000000000entity sub is port ( i : in integer; o : out integer ); end entity; architecture test of sub is procedure function_that_dies_with_this(x : in integer; y : out integer) is procedure read_val(val: out integer) is begin val := x; end procedure; begin read_val(y); -- Would crash during cgen here end procedure; begin process (i) is variable tmp : integer; begin function_that_dies_with_this(i, tmp); o <= tmp; end process; end architecture; ------------------------------------------------------------------------------- entity issue429 is end entity; architecture test of issue429 is signal i1, i2, i3, o : integer; begin a: entity work.sub port map (i1, i2); b: entity work.sub port map (i2, i3); c: entity work.sub port map (i3, o); p1: process is begin i1 <= 1; wait for 1 ns; assert o = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue430.vhd000066400000000000000000000343741504111170000172650ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package TYPES is constant ADDR_MAX_WIDTH : integer := 64; constant DATA_MAX_WIDTH : integer := 1024; type CHANNEL_TYPE is ( CHANNEL_AR, CHANNEL_AW, CHANNEL_DR, CHANNEL_DW, CHANNEL_M ); type ADDR_CHANNEL_SIGNAL_TYPE is record ADDR : std_logic_vector(ADDR_MAX_WIDTH -1 downto 0); WRITE : std_logic; VALID : std_logic; READY : std_logic; end record; type DATA_CHANNEL_SIGNAL_TYPE is record DATA : std_logic_vector(DATA_MAX_WIDTH-1 downto 0); LAST : std_logic; VALID : std_logic; READY : std_logic; end record; type CHANNEL_SIGNAL_TYPE is record AR : ADDR_CHANNEL_SIGNAL_TYPE; DR : DATA_CHANNEL_SIGNAL_TYPE; AW : ADDR_CHANNEL_SIGNAL_TYPE; DW : DATA_CHANNEL_SIGNAL_TYPE; end record; end package; ----------------------------------------------------------------------------------- --! @brief CHANNEL_PLAYER : ----------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; library WORK; use WORK.TYPES.all; entity CHANNEL_PLAYER is generic ( CHANNEL : CHANNEL_TYPE; MASTER : boolean := FALSE; SLAVE : boolean := FALSE; READ_ENABLE : boolean := TRUE; WRITE_ENABLE : boolean := TRUE; ADDR_WIDTH : integer := 32; DATA_WIDTH : integer := 32 ); port( ACLK : in std_logic; ARESETn : in std_logic; ARADDR_I : in std_logic_vector(ADDR_WIDTH-1 downto 0); ARADDR_O : out std_logic_vector(ADDR_WIDTH-1 downto 0); ARVALID_I : in std_logic; ARVALID_O : out std_logic; ARREADY_I : in std_logic; ARREADY_O : out std_logic; RVALID_I : in std_logic; RVALID_O : out std_logic; RLAST_I : in std_logic; RLAST_O : out std_logic; RDATA_I : in std_logic_vector(DATA_WIDTH-1 downto 0); RDATA_O : out std_logic_vector(DATA_WIDTH-1 downto 0); RREADY_I : in std_logic; RREADY_O : out std_logic; AWADDR_I : in std_logic_vector(ADDR_WIDTH-1 downto 0); AWADDR_O : out std_logic_vector(ADDR_WIDTH-1 downto 0); AWVALID_I : in std_logic; AWVALID_O : out std_logic; AWREADY_I : in std_logic; AWREADY_O : out std_logic; WLAST_I : in std_logic; WLAST_O : out std_logic; WDATA_I : in std_logic_vector(DATA_WIDTH-1 downto 0); WDATA_O : out std_logic_vector(DATA_WIDTH-1 downto 0); WVALID_I : in std_logic; WVALID_O : out std_logic; WREADY_I : in std_logic; WREADY_O : out std_logic; FINISH : out std_logic ); end CHANNEL_PLAYER; architecture MODEL of CHANNEL_PLAYER is procedure function_that_dies_with_this(signals : inout CHANNEL_SIGNAL_TYPE) is procedure read_val(val: out std_logic_vector) is constant null_val : std_logic_vector(val'length-1 downto 0) := (others => '0'); begin val := null_val; end procedure; begin read_val(signals.AR.ADDR(ADDR_WIDTH-1 downto 0)); end procedure; begin gCHANNEL_M: if (CHANNEL = CHANNEL_M) generate PROCESS_M: process begin FINISH <= '1'; wait; end process; end generate; gCHANNEL_A:if (CHANNEL = CHANNEL_AW or CHANNEL = CHANNEL_AR) generate PROCESS_A: process procedure execute_output is begin if (MASTER and WRITE_ENABLE and CHANNEL = CHANNEL_AW) then AWADDR_O <= (others => '0'); AWVALID_O <= '0'; end if; if (MASTER and READ_ENABLE and CHANNEL = CHANNEL_AR) then ARADDR_O <= (others => '0'); ARVALID_O <= '0'; end if; if (SLAVE and WRITE_ENABLE and CHANNEL = CHANNEL_AW) then AWREADY_O <= '0'; end if; if (SLAVE and READ_ENABLE and CHANNEL = CHANNEL_AR) then ARREADY_O <= '0'; end if; end procedure; begin FINISH <= '1'; wait; end process; end generate; gCHANNEL_D:if (CHANNEL = CHANNEL_DW or CHANNEL = CHANNEL_DR) generate PROCESS_D: process procedure execute_output is begin if (MASTER and WRITE_ENABLE and CHANNEL = CHANNEL_DW) then WDATA_O <= (others => '0'); WLAST_O <= '0'; WVALID_O <= '0'; end if; if (MASTER and READ_ENABLE and CHANNEL = CHANNEL_DR) then RREADY_O <= '0'; end if; if (SLAVE and WRITE_ENABLE and CHANNEL = CHANNEL_DW) then WREADY_O <= '0'; end if; if (SLAVE and READ_ENABLE and CHANNEL = CHANNEL_DR) then RDATA_O <= (others => '0'); RLAST_O <= '0'; RVALID_O <= '0'; end if; end procedure; begin execute_output; -- ! add this line. FINISH <= '1'; wait; end process; end generate; end MODEL; ----------------------------------------------------------------------------------- -- ----------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; library WORK; use WORK.TYPES.all; entity ISSUE430 is end ISSUE430; architecture MODEL of ISSUE430 is constant READ_ENABLE : boolean := TRUE; constant WRITE_ENABLE : boolean := TRUE; constant ADDR_WIDTH : integer := 32; constant DATA_WIDTH : integer := 32; signal ACLK : std_logic; signal ARESETn : std_logic; signal ARADDR : std_logic_vector(ADDR_WIDTH-1 downto 0); signal ARVALID : std_logic; signal ARREADY : std_logic; signal RLAST : std_logic; signal RDATA : std_logic_vector(DATA_WIDTH-1 downto 0); signal RVALID : std_logic; signal RREADY : std_logic; signal AWADDR : std_logic_vector(ADDR_WIDTH-1 downto 0); signal AWVALID : std_logic; signal AWREADY : std_logic; signal WLAST : std_logic; signal WDATA : std_logic_vector(DATA_WIDTH-1 downto 0); signal WVALID : std_logic; signal WREADY : std_logic; signal FINISH : std_logic; begin M: entity WORK.CHANNEL_PLAYER generic map ( CHANNEL => CHANNEL_M , MASTER => FALSE , SLAVE => FALSE , READ_ENABLE => READ_ENABLE , WRITE_ENABLE => WRITE_ENABLE , ADDR_WIDTH => ADDR_WIDTH , DATA_WIDTH => DATA_WIDTH ) port map( ACLK => ACLK , ARESETn => ARESETn , ARADDR_I => ARADDR , ARVALID_I => ARVALID , ARREADY_I => ARREADY , RVALID_I => RVALID , RLAST_I => RLAST , RDATA_I => RDATA , RREADY_I => RREADY , AWADDR_I => AWADDR , AWVALID_I => AWVALID , AWREADY_I => AWREADY , WVALID_I => WVALID , WLAST_I => WLAST , WDATA_I => WDATA , WREADY_I => WREADY , FINISH => FINISH ); AR: entity WORK.CHANNEL_PLAYER generic map ( CHANNEL => CHANNEL_AR , MASTER => TRUE , SLAVE => FALSE , READ_ENABLE => READ_ENABLE , WRITE_ENABLE => WRITE_ENABLE , ADDR_WIDTH => ADDR_WIDTH , DATA_WIDTH => DATA_WIDTH ) port map( ACLK => ACLK , ARESETn => ARESETn , ARADDR_I => ARADDR , ARADDR_O => ARADDR , ARVALID_I => ARVALID , ARVALID_O => ARVALID , ARREADY_I => ARREADY , RVALID_I => RVALID , RLAST_I => RLAST , RDATA_I => RDATA , RREADY_I => RREADY , AWADDR_I => AWADDR , AWVALID_I => AWVALID , AWREADY_I => AWREADY , WVALID_I => WVALID , WLAST_I => WLAST , WDATA_I => WDATA , WREADY_I => WREADY ); DR: entity WORK.CHANNEL_PLAYER generic map ( CHANNEL => CHANNEL_DR , MASTER => TRUE , SLAVE => FALSE , READ_ENABLE => READ_ENABLE , WRITE_ENABLE => WRITE_ENABLE , ADDR_WIDTH => ADDR_WIDTH , DATA_WIDTH => DATA_WIDTH ) port map( ACLK => ACLK , ARESETn => ARESETn , ARADDR_I => ARADDR , ARVALID_I => ARVALID , ARREADY_I => ARREADY , RVALID_I => RVALID , RLAST_I => RLAST , RDATA_I => RDATA , RREADY_I => RREADY , RREADY_O => RREADY , AWADDR_I => AWADDR , AWVALID_I => AWVALID , AWREADY_I => AWREADY , WVALID_I => WVALID , WLAST_I => WLAST , WDATA_I => WDATA , WREADY_I => WREADY ); AW: entity WORK.CHANNEL_PLAYER generic map ( CHANNEL => CHANNEL_AW , MASTER => TRUE , SLAVE => FALSE , READ_ENABLE => READ_ENABLE , WRITE_ENABLE => WRITE_ENABLE , ADDR_WIDTH => ADDR_WIDTH , DATA_WIDTH => DATA_WIDTH ) port map( ACLK => ACLK , ARESETn => ARESETn , ARADDR_I => ARADDR , ARVALID_I => ARVALID , ARREADY_I => ARREADY , RVALID_I => RVALID , RLAST_I => RLAST , RDATA_I => RDATA , RREADY_I => RREADY , AWADDR_I => AWADDR , AWADDR_O => AWADDR , AWVALID_I => AWVALID , AWVALID_O => AWVALID , AWREADY_I => AWREADY , WVALID_I => WVALID , WLAST_I => WLAST , WDATA_I => WDATA , WREADY_I => WREADY ); DW: entity WORK.CHANNEL_PLAYER generic map ( CHANNEL => CHANNEL_DW , MASTER => TRUE , SLAVE => FALSE , READ_ENABLE => READ_ENABLE , WRITE_ENABLE => WRITE_ENABLE , ADDR_WIDTH => ADDR_WIDTH , DATA_WIDTH => DATA_WIDTH ) port map( ACLK => ACLK , ARESETn => ARESETn , ARADDR_I => ARADDR , ARVALID_I => ARVALID , ARREADY_I => ARREADY , RVALID_I => RVALID , RLAST_I => RLAST , RDATA_I => RDATA , RREADY_I => RREADY , AWADDR_I => AWADDR , AWVALID_I => AWVALID , AWREADY_I => AWREADY , WVALID_I => WVALID , WVALID_O => WVALID , WLAST_I => WLAST , WLAST_O => WLAST , WDATA_I => WDATA , WDATA_O => WDATA , WREADY_I => WREADY ); process is begin wait until finish = '1' for 100 ns; assert finish = '1'; assert wdata = (wdata'range => '0'); assert rvalid = 'U'; assert wvalid = '0'; wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue432.vhd000066400000000000000000000034211504111170000172540ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use std.textio.all; entity SYNC_DRIVER is generic (NAME : STRING := ""; DELAY : time := 10 ns; EOT : time := 10 ns); port (SYNC : inout std_logic); end SYNC_DRIVER; architecture MODEL of SYNC_DRIVER is begin process begin SYNC <= 'Z'; wait for 0 ns; SYNC <= '0'; wait for DELAY; SYNC <= 'H'; assert FALSE report NAME & " WAIT SYNC START" severity NOTE; wait until (SYNC = '1' or SYNC = 'H'); SYNC <= '0'; assert FALSE report NAME & " WAIT SYNC DONE " severity NOTE; assert (Now = EOT) report NAME & " SYNC TIME ERROR" severity ERROR; wait; end process; end MODEL; library ieee; use ieee.std_logic_1164.all; entity SYNC_A is port(SYNC: inout std_logic); end entity; architecture MODEL of SYNC_A is begin U: entity WORK.SYNC_DRIVER generic map (string'("SYNC_A"), 10 ns, 30 ns) port map(SYNC); end MODEL; library ieee; use ieee.std_logic_1164.all; entity SYNC_B is port(SYNC: inout std_logic); end entity; architecture MODEL of SYNC_B is begin U: entity WORK.SYNC_DRIVER generic map (string'("SYNC_B"), 20 ns, 30 ns) port map(SYNC); end MODEL; library ieee; use ieee.std_logic_1164.all; entity SYNC_C is port(SYNC: inout std_logic); end entity; architecture MODEL of SYNC_C is begin U: entity WORK.SYNC_DRIVER generic map (string'("SYNC_C"), 30 ns, 30 ns) port map(SYNC); end MODEL; library ieee; use ieee.std_logic_1164.all; entity issue432 is end issue432; architecture MODEL of issue432 is signal SYNC : std_logic; begin U_SYNC_A: entity WORK.SYNC_A port map(SYNC); U_SYNC_B: entity WORK.SYNC_B port map(SYNC); U_SYNC_C: entity WORK.SYNC_C port map(SYNC); end MODEL; nvc-r1.17.1/test/regress/issue433.vhd000066400000000000000000000016461504111170000172640ustar00rootroot00000000000000entity SAMPLE is generic (NAME: string := ""; delay : delay_length); end entity; architecture MODEL of SAMPLE is begin process begin wait for delay; assert (FALSE) report NAME & ":OK" severity NOTE; wait; end process; end MODEL; entity SAMPLE_NG is generic (NAME: string := ""; delay : delay_length); end entity; architecture MODEL of SAMPLE_NG is component SAMPLE generic(NAME: STRING := ""; delay : delay_length); end component; begin U: SAMPLE generic map (NAME => NAME & "(" & ")", delay => delay); end MODEL; entity issue433 is generic (NAME: string := "TEST_NG"); end entity; architecture MODEL of issue433 is component SAMPLE_NG generic(NAME: STRING := ""; delay : delay_length); end component; begin U1: SAMPLE_NG generic map(NAME => NAME & string'(":U1"), delay => 1 ns); U2: SAMPLE_NG generic map(NAME => NAME & string'(":U2"), delay => 2 ns); end MODEL; nvc-r1.17.1/test/regress/issue434.vhd000066400000000000000000000067151504111170000172670ustar00rootroot00000000000000-- test_ng.vhd library ieee; use ieee.std_logic_1164.all; entity SAMPLE is generic ( WORD_BITS : integer := 8; STRB_BITS : integer := 1; O_WIDTH : integer := 1; QUEUE_SIZE : integer := 3 ); port ( CLK : in std_logic; RST : in std_logic; O_DATA : out std_logic_vector(O_WIDTH*WORD_BITS-1 downto 0); O_STRB : out std_logic_vector(O_WIDTH*STRB_BITS-1 downto 0); O_VAL : out std_logic; O_RDY : in std_logic ); end entity; architecture RTL of SAMPLE is type WORD_TYPE is record DATA : std_logic_vector(WORD_BITS-1 downto 0); STRB : std_logic_vector(STRB_BITS-1 downto 0); VAL : boolean; end record; constant WORD_NULL : WORD_TYPE := (DATA => (others => '0'), STRB => (others => '0'), VAL => FALSE); type WORD_VECTOR is array (INTEGER range <>) of WORD_TYPE; signal curr_queue : WORD_VECTOR(0 to QUEUE_SIZE-1); begin curr_queue <= (others => WORD_NULL); process (curr_queue) begin for i in 0 to O_WIDTH-1 loop O_DATA((i+1)*WORD_BITS-1 downto i*WORD_BITS) <= curr_queue(i).DATA; O_STRB((i+1)*STRB_BITS-1 downto i*STRB_BITS) <= curr_queue(i).STRB; end loop; end process; end RTL; library ieee; use ieee.std_logic_1164.all; entity issue434 is end entity; architecture MODEL of issue434 is constant PERIOD : time := 10 ns; constant DELAY : time := 1 ns; constant WORD_BITS : integer := 8; constant STRB_BITS : integer := WORD_BITS/8; constant O_WIDTH : integer := 2; constant QUEUE_SIZE : integer := 4; signal CLK_ENA : std_logic; signal CLK : std_logic; signal RST : std_logic; signal O_DATA : std_logic_vector(O_WIDTH*WORD_BITS-1 downto 0); signal O_STRB : std_logic_vector(O_WIDTH*STRB_BITS-1 downto 0); signal O_VAL : std_logic; signal O_RDY : std_logic; begin DUT: entity WORK.SAMPLE generic map ( WORD_BITS => WORD_BITS , STRB_BITS => STRB_BITS , O_WIDTH => O_WIDTH , QUEUE_SIZE => QUEUE_SIZE ) port map( CLK => CLK , RST => RST , O_DATA => O_DATA , O_STRB => O_STRB , O_VAL => O_VAL , O_RDY => O_RDY ); process begin loop CLK <= '1'; wait for PERIOD/2; CLK <= '0'; wait for PERIOD/2; exit when(CLK_ENA = '0'); end loop; CLK <= '0'; wait; end process; process procedure WAIT_CLK(CNT:integer) is begin if (CNT > 0) then for i in 1 to CNT loop wait until (CLK'event and CLK = '1'); end loop; end if; wait for DELAY; end WAIT_CLK; begin CLK_ENA <= '1'; RST <= '1'; O_RDY <= '0'; WAIT_CLK(1); RST <= '0'; WAIT_CLK(10); CLK_ENA <= '0'; assert o_data = X"0000"; wait; end process; end MODEL; nvc-r1.17.1/test/regress/issue447.vhd000066400000000000000000000014001504111170000172550ustar00rootroot00000000000000entity issue447 is end entity; architecture test of issue447 is procedure assign(v : out bit_vector; b : in bit) is variable canary : integer := 42; begin v := (v'range => b); report integer'image(canary); end procedure; procedure proc (x : natural) is type rec is record f : bit_vector(1 to x); end record; variable v : rec; begin wait for 1 ns; assert v.f = (1 to x => '0'); wait for 1 ns; assign(v.f, '1'); wait for 1 ns; assert v.f = (1 to x => '1'); end procedure; begin main: process is begin proc(12); -- This call would clobber stack wait; end process; end architecture; nvc-r1.17.1/test/regress/issue45.vhd000066400000000000000000000004431504111170000171750ustar00rootroot00000000000000entity issue45 is begin end entity issue45; architecture a of issue45 is begin b: block is begin p : process begin report p'instance_name; report b'instance_name; wait; end process p; end block; end architecture a; nvc-r1.17.1/test/regress/issue454.sh000066400000000000000000000002751504111170000171150ustar00rootroot00000000000000set -xe pwd which nvc which fstdump nvc -a $TESTDIR/regress/issue454.vhd -e issue454 -r -w fstdump issue454.fst > issue454.dump diff -u $TESTDIR/regress/gold/issue454.dump issue454.dump nvc-r1.17.1/test/regress/issue454.vhd000066400000000000000000000014301504111170000172560ustar00rootroot00000000000000package pack is type rec is record x, y : integer; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( r : in rec ); -- This signal gets optimised out in -- FST dump end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity issue454 is end entity; architecture test of issue454 is signal r : rec; begin uut: entity work.sub port map ( r ); main: process is begin r.x <= 5; wait for 1 ns; r.y <= 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue460.vhd000066400000000000000000000012631504111170000172570ustar00rootroot00000000000000entity issue460 is end entity; architecture test of issue460 is signal a, b : bit; signal x : natural; begin p1: process (a, b) is begin case bit_vector'(a & b) is when "10" => x <= 1; when "01" => x <= 2; when others => x <= 3; end case; end process; check: process is begin wait for 0 ns; assert x = 3; a <= '1'; wait for 1 ns; assert x = 1; b <= '1'; wait for 1 ns; assert x = 3; a <= '0'; wait for 1 ns; assert x = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue467.vhd000066400000000000000000000020411504111170000172610ustar00rootroot00000000000000entity issue467 is end entity; architecture test of issue467 is type int_array is array (natural range <>) of integer_vector; function sum_all (x : int_array) return integer is variable result : integer := 0; begin for i in x'range loop for j in x(i)'range loop result := result + x(i)(j); end loop; end loop; return result; end function; function get_slice (x : int_array; l, r : natural) return int_array is begin return x(l to r); end function; signal s1 : int_array(1 to 3)(1 to 2) := ( (1, 2), (3, 4), (5, 6) ); begin p1: process is begin assert sum_all(s1) = 21; assert get_slice(s1, 1, 2) = ( (1, 2), (3, 4) ); assert get_slice(s1, 3, 3) = ( 0 => (5, 6) ); assert get_slice(s1, 3, 0) = ( 1 to 0 => (1, 1) ); assert get_slice(s1, 1, 2)(2) = ( (3, 4) ); s1(2)(2) <= 10; wait for 1 ns; assert sum_all(s1) = 27; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue469.vhd000066400000000000000000000011711504111170000172660ustar00rootroot00000000000000package test_pkg is shared variable shared_var : boolean := false; procedure log( va1 : boolean := shared_var ); end package; package body test_pkg is procedure log( va1 : boolean := shared_var ) is begin report "va1 is " & boolean'image(va1); end procedure; end package body; ------------------------------------------------------------------------------- entity issue469 is end entity; use work.test_pkg.all; architecture test of issue469 is begin p1: process is begin log; shared_var := true; log; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue472.sh000066400000000000000000000005301504111170000171070ustar00rootroot00000000000000set -xe pwd which nvc nvc --std=2019 -a $TESTDIR/regress/wait1.vhd # This should set the default standard from the analysed unit nvc -e wait1 -r # This should error if nvc --std=1993 -e wait1 -r; then echo "expected error"; exit 1 fi # Likewise if nvc -a $TESTDIR/regress/assert1.vhd -e wait1 -r; then echo "expected error"; exit 1 fi nvc-r1.17.1/test/regress/issue481.vhd000066400000000000000000000004721504111170000172630ustar00rootroot00000000000000entity issue481 is end entity; architecture beh of issue481 is signal sig_1 : bit; begin process begin assert sig_1 = '0'; sig_1 <= force '1'; wait for 1 ps; assert sig_1 = '1' report "signal val is not 1 " & to_string(sig_1) severity failure; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue483.vhd000066400000000000000000000006111504111170000172600ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package test_pkg is signal glob_sig : std_logic := '1'; end package; library ieee; use ieee.std_logic_1164.all; use work.test_pkg.all; entity issue483 is end entity; architecture rtl of issue483 is signal C_CONST : std_logic := glob_sig; begin p_proc : process begin assert C_CONST = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue484.vhd000066400000000000000000000015671504111170000172740ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue484 is end entity; architecture beh of issue484 is type t_data is record sig1 : std_logic; sig2 : std_logic_vector(7 downto 0); sig3 : std_logic; end record; type t_data_array is array (natural range <>) of t_data; signal sr : t_data_array(0 to 2) := (others => ('1', x"ff", '1')); begin process begin for i in 1 to 3 loop sr <= sr(sr'low + 1 to sr'high) & t_data'('0', x"00", '0'); wait for 1 ns; end loop; wait; end process; process is begin wait for 1 ns; assert sr(0).sig1 = '1'; assert sr(0).sig2 = x"ff"; assert sr(2).sig1 = '0'; assert sr(2).sig2 = x"00"; wait for 5 ns; assert sr(0).sig1 = '0'; assert sr(0).sig2 = x"00"; assert sr(2).sig1 = '0'; assert sr(2).sig2 = x"00"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue493.sh000066400000000000000000000013071504111170000171150ustar00rootroot00000000000000set -xe pwd which nvc nvc --work=test3 -a - < open); p_proc : process begin report "Test2"; wait; end process; end architecture; EOF nvc -L. -a - <>; begin assert sig = "00"; sig <= force "11"; wait for 1 ns; assert sig = "11"; sig <= release; wait for 1 ns; assert sig = "00"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue502.vhd000066400000000000000000000015141504111170000172530ustar00rootroot00000000000000entity sub is generic ( n : integer); end entity; architecture test of sub is type rec is record f : integer range 1 to n; end record; function func1 (x : integer) return rec; function func2 (x : integer) return rec is begin return func1(x); end function; function func1 (x : integer) return rec is begin return (f => x * 2); end function; signal s, t : integer := 0; begin p1: t <= func2(s).f; p2: process is begin wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue502 is end entity; architecture test of issue502 is begin g: for i in 1 to 3 generate begin u: entity work.sub generic map ( i ); end generate; end architecture; nvc-r1.17.1/test/regress/issue507.sh000066400000000000000000000011001504111170000171000ustar00rootroot00000000000000set -xe pwd which nvc nvc -a - <) of bit_vector; signal sig1 : t_slv_array(1 downto 0)(2 downto 0); type rec is record x, y : integer; end record; type recv is array (natural range <>) of rec; type recvv is array (natural range <>) of recv; function el_len(sig : t_slv_array) return natural is begin return sig'element'length; end function; function el_len(sig : recvv) return natural is begin return sig'element'length; end function; begin process variable v : t_slv_array(1 to 2)(5 to 6); variable vv : recvv(1 to 3)(1 to 7); begin assert el_len(sig1) = 3 severity failure; assert el_len(v) = 2 severity failure; assert el_len(vv) = 7 severity failure; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue516.vhd000066400000000000000000000063001504111170000172560ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue516 is end entity; architecture beh of issue516 is type t_event_ctrl_unresolved is record val : std_logic; ack : std_logic; end record; type t_event_ctrl_drivers is array (natural range <> ) of t_event_ctrl_unresolved; function resolved_event_ctrl(input_vector : t_event_ctrl_drivers) return t_event_ctrl_unresolved; subtype t_event_ctrl is resolved_event_ctrl t_event_ctrl_unresolved; type t_events_unresolved is record flag1 : t_event_ctrl; flag2 : t_event_ctrl; end record; type t_events_drivers is array (natural range <> ) of t_events_unresolved; function resolved_events(input_vector : t_events_drivers) return t_events_unresolved; subtype t_events is resolved_events t_events_unresolved; function resolved_event_ctrl( input_vector : t_event_ctrl_drivers ) return t_event_ctrl_unresolved is variable ret : t_event_ctrl_unresolved := (others => '0'); begin if input_vector'length = 0 THEN return ret; else for i in input_vector'range loop if input_vector(i).val = '1' then ret.val := '1'; end if; if input_vector(i).ack = '1' then ret.ack := '1'; end if; end loop; return ret; end if; end function resolved_event_ctrl; function resolved_events( input_vector : t_events_drivers ) return t_events_unresolved is variable ret : t_events_unresolved := (others => (others => '0')); begin if input_vector'length = 0 THEN return ret; else for i in input_vector'range loop ret.flag1 := resolved_event_ctrl(t_event_ctrl_drivers'(ret.flag1, input_vector(i).flag2)); ret.flag2 := resolved_event_ctrl(t_event_ctrl_drivers'(ret.flag2, input_vector(i).flag2)); end loop; return ret; end if; end function resolved_events; signal events : t_events; signal passed : boolean; begin p_events : process begin events <= (others => (others => '0')); loop wait on events.flag2.val; report "Got val" severity note; if rising_edge(events.flag2.val) then report "Sending ack" severity note; events.flag2.ack <= '1' after 1 us, '0' after 1.1 us; end if; if falling_edge(events.flag2.val) then report "Resetting ack" severity note; events.flag2.ack <= '1', '0' after 1 ns; end if; end loop; end process p_events; process procedure com2(signal flag : inout t_event_ctrl) is begin events.flag2.val <= '1'; report "Send val 1" severity note; wait until events.flag2.ack = '1'; report "Got ack" severity note; report "Send val 0" severity note; events.flag2.val <= '1'; wait until events.flag2.ack = '0'; report "Got ack 0" severity note; end procedure; procedure com(signal flag_event : inout t_events) is begin com2(flag_event.flag2); end procedure; begin wait for 1 us; report "Running" severity note; com(events); passed <= true; wait; end process; check: process is begin wait for 5 us; assert passed; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue519.vhd000066400000000000000000000077201504111170000172700ustar00rootroot00000000000000package test_pkg is type t_axi_wr_slave_in_if is record awid : bit_vector; awaddr : bit_vector; awlen : bit_vector(7 downto 0); awsize : bit_vector(2 downto 0); awburst : bit_vector(1 downto 0); awlock : bit; awcache : bit_vector(3 downto 0); awprot : bit_vector(2 downto 0); awqos : bit_vector(3 downto 0); awregion : bit_vector(3 downto 0); awuser : bit_vector; awvalid : bit; wdata : bit_vector; wstrb : bit_vector; wlast : bit; wuser : bit_vector; wvalid : bit; bready : bit; end record; end package; use work.test_pkg.all; entity test2 is port ( wr_port_in : in t_axi_wr_slave_in_if ); end entity test2; architecture beh of test2 is begin process is begin wait for 1 ns; assert wr_port_in.wdata = (31 downto 0 => '1'); wait; end process; end architecture beh; use work.test_pkg.all; entity issue519 is end entity issue519; architecture beh of issue519 is type t_axi_write_address_channel is record awid : bit_vector; awaddr : bit_vector; awlen : bit_vector(7 downto 0); awsize : bit_vector(2 downto 0); awburst : bit_vector(1 downto 0); awlock : bit; awcache : bit_vector(3 downto 0); awprot : bit_vector(2 downto 0); awqos : bit_vector(3 downto 0); awregion : bit_vector(3 downto 0); awuser : bit_vector; awvalid : bit; awready : bit; end record; type t_axi_write_data_channel is record wdata : bit_vector; wstrb : bit_vector; wlast : bit; wuser : bit_vector; wvalid : bit; wready : bit; end record; type t_axi_write_response_channel is record bid : bit_vector; bresp : bit_vector(1 downto 0); buser : bit_vector; bvalid : bit; bready : bit; end record; type t_axi_if is record write_address_channel : t_axi_write_address_channel; write_data_channel : t_axi_write_data_channel; write_response_channel : t_axi_write_response_channel; end record; signal axi_if : t_axi_if( write_address_channel( awid( 8 -1 downto 0), awaddr( 32-1 downto 0), awuser( 8 -1 downto 0)), write_data_channel( wdata( 32-1 downto 0), wstrb( 4 -1 downto 0), wuser( 8 -1 downto 0)), write_response_channel(bid( 8 -1 downto 0), buser( 8 -1 downto 0))); begin i_test : entity work.test2 port map ( wr_port_in.awid => axi_if.write_address_channel.awid, wr_port_in.awaddr => axi_if.write_address_channel.awaddr, wr_port_in.awlen => axi_if.write_address_channel.awlen, wr_port_in.awsize => axi_if.write_address_channel.awsize, wr_port_in.awburst => axi_if.write_address_channel.awburst, wr_port_in.awlock => axi_if.write_address_channel.awlock, wr_port_in.awcache => axi_if.write_address_channel.awcache, wr_port_in.awprot => axi_if.write_address_channel.awprot, wr_port_in.awqos => axi_if.write_address_channel.awqos, wr_port_in.awregion => axi_if.write_address_channel.awregion, wr_port_in.awuser => axi_if.write_address_channel.awuser, wr_port_in.awvalid => axi_if.write_address_channel.awvalid, wr_port_in.wdata => axi_if.write_data_channel.wdata, wr_port_in.wstrb => axi_if.write_data_channel.wstrb, wr_port_in.wlast => axi_if.write_data_channel.wlast, wr_port_in.wuser => axi_if.write_data_channel.wuser, wr_port_in.wvalid => axi_if.write_data_channel.wvalid, wr_port_in.bready => axi_if.write_response_channel.bready ); process begin axi_if.write_data_channel.wdata <= X"ffffffff"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue520.vhd000066400000000000000000000017741504111170000172630ustar00rootroot00000000000000package test_pkg is generic (type t_element; function to_string_element(element : t_element) return string ); end package; entity issue520 is end entity issue520; architecture beh of issue520 is type t_record is record address : bit_vector(7 downto 0); data : bit_vector(7 downto 0); end record t_record; function record_to_string( constant rec_data : t_record ) return string is begin return "address: " & to_string(rec_data.address) & ", data: " & to_string(rec_data.data); end function record_to_string; package record_pkg is new work.test_pkg generic map (t_element => t_record, to_string_element => record_to_string); use record_pkg.all; begin process variable v_input : t_record := (x"AA", x"BB"); begin report "Val is " & to_string_element(v_input) severity note; wait for 1 ns; assert to_string_element(v_input) = "address: 10101010, data: 10111011"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue521.vhd000066400000000000000000000004471504111170000172600ustar00rootroot00000000000000entity issue521 is end entity; architecture test of issue521 is signal i : natural; signal j : natural; begin p1: process is begin i <= i + 1; wait for 0 ns; end process; p2: process (i) is begin j <= i; end process; end architecture; nvc-r1.17.1/test/regress/issue524.sh000066400000000000000000000002741504111170000171120ustar00rootroot00000000000000set -xe pwd which nvc which fstdump nvc -a $TESTDIR/regress/issue524.vhd -e issue524 -r -w fstdump issue524.fst > issue524.dump diff -u $TESTDIR/regress/gold/issue524.dump issue524.dump nvc-r1.17.1/test/regress/issue524.vhd000066400000000000000000000004311504111170000172540ustar00rootroot00000000000000entity issue524 is end entity; architecture test of issue524 is signal s : real := 0.0; begin main: process is begin for i in 1 to 5 loop s <= s + 0.5; wait for 1 ns; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue527.vhd000066400000000000000000000007671504111170000172730ustar00rootroot00000000000000library ieee; use ieee.math_real.all; entity issue527 is end entity; architecture test of issue527 is signal s : bit; begin p1: process (s) is variable s1, s2 : positive := 12345; impure function random (x, y : delay_length) return delay_length is variable r : real; begin uniform(s1, s2, r); return x + r * (y - x); end function; begin s <= not s after random(1 ns, 2 ns); end process; end architecture; nvc-r1.17.1/test/regress/issue53.vhd000066400000000000000000000006711504111170000171770ustar00rootroot00000000000000entity c is generic (e : bit); port (i : in bit); begin assert i = e; end entity c; architecture a of c is begin end architecture a; entity issue53 is begin end entity issue53; architecture a of issue53 is component c is generic (e : bit); port (i : in bit); end component c; begin u0 : c generic map ('0') port map (i => '0'); u1 : c generic map ('1') port map (i => '1'); end architecture a; nvc-r1.17.1/test/regress/issue536.vhd000066400000000000000000000006321504111170000172620ustar00rootroot00000000000000entity issue536 is end entity; architecture test of issue536 is subtype uint8_t is integer range 0 to 255; type uint8_array_t is array(natural range <>) of uint8_t; signal ttx_data : uint8_array_t(0 to 127); begin p1: process is begin wait for 1 ns; ttx_data(5) <= 2; wait for 5 ns; ttx_data(100) <= 55; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue539.vhd000066400000000000000000000023451504111170000172700ustar00rootroot00000000000000package my_package is type slv_1_t is array (natural range <>) of bit_vector; function addslvreg_f(arg0 : slv_1_t; arg1 : bit_vector) return slv_1_t; end package my_package; package body my_package is function addslvreg_f(arg0 : slv_1_t; arg1 : bit_vector) return slv_1_t is variable cb_v : bit_vector(0 downto 0); variable arg_v,retval : arg0'subtype; constant W : integer := arg0(0)'length-1; begin return retval; end function addslvreg_f; end package body; ------------------------------------------------------------------------------- entity issue539 is end entity; use work.my_package.all; architecture test of issue539 is function get_elt_left (x : slv_1_t) return integer is begin return x(x'left)'left; end function; function get_elt_left_2 (x : slv_1_t) return integer is begin return x'element'left; end function; begin p1: process is variable v1 : slv_1_t(0 to 3)(5 to 6); variable v2 : slv_1_t(0 to 3)(6 to 5); begin assert v1(1)'left = 5; assert v2(5)'left = 6; assert get_elt_left(v1) = 5; assert get_elt_left(v2) = 6; assert get_elt_left_2(v1) = 5; assert get_elt_left_2(v2) = 6; assert addslvreg_f(v1, "101") = v1; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue540.vhd000066400000000000000000000006121504111170000172530ustar00rootroot00000000000000entity issue540 is end entity; architecture beh of issue540 is procedure test( round_time : time) is variable v_overshoot : time := now rem round_time; begin wait for (round_time - v_overshoot); end; begin process is begin wait for 7 ns; test(10 ns); assert now = 10 ns; assert 5 ns mod 2 ns = 1 ns; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue542.vhd000066400000000000000000000006731504111170000172640ustar00rootroot00000000000000entity issue542 is end entity; architecture beh of issue542 is signal s : bit_vector(1 to 3); begin p_proc : process procedure proc( signal target : inout bit_vector) is begin target(target'range) <= (others => '0'); -- Issue is here end; begin s <= "111"; wait for 1 ns; proc(s); assert s = "111"; wait for 0 ns; assert s = "000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue543.vhd000066400000000000000000000013221504111170000172550ustar00rootroot00000000000000entity test2 is port( sig1 : in bit; sig2 : in bit_vector(2 downto 0) ); end entity test2; architecture beh of test2 is begin process is begin wait for 0 ns; assert sig1 = '1'; assert sig2 = "010"; wait; end process; end architecture beh; entity issue543 is end entity issue543; architecture beh of issue543 is type t_rec is record sig1 : bit; sig2 : bit_vector; end record; signal sig_if : t_rec(sig2(2 downto 0)); begin i_test2 : entity work.test2 port map( sig1 => sig_if.sig1, sig2 => sig_if.sig2 ); process begin sig_if.sig1 <= '1'; sig_if.sig2 <= "010"; wait for 1 ns; report "OK"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue544.vhd000066400000000000000000000207701504111170000172660ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package test_pkg is type t_axi_wr_slave_in_if is record awid : std_logic_vector; awaddr : std_logic_vector; awlen : std_logic_vector(7 downto 0); awsize : std_logic_vector(2 downto 0); awburst : std_logic_vector(1 downto 0); awlock : std_logic; awcache : std_logic_vector(3 downto 0); awprot : std_logic_vector(2 downto 0); awqos : std_logic_vector(3 downto 0); awregion : std_logic_vector(3 downto 0); awuser : std_logic_vector; awvalid : std_logic; wdata : std_logic_vector; wstrb : std_logic_vector; wlast : std_logic; wuser : std_logic_vector; wvalid : std_logic; bready : std_logic; end record; type t_axi_wr_slave_out_if is record awready : std_logic; wready : std_logic; bid : std_logic_vector; bresp : std_logic_vector(1 downto 0); buser : std_logic_vector; bvalid : std_logic; end record; type t_axi_rd_slave_in_if is record arid : std_logic_vector; araddr : std_logic_vector; arlen : std_logic_vector(7 downto 0); arsize : std_logic_vector(2 downto 0); arburst : std_logic_vector(1 downto 0); arlock : std_logic; arcache : std_logic_vector(3 downto 0); arprot : std_logic_vector(2 downto 0); arqos : std_logic_vector(3 downto 0); arregion : std_logic_vector(3 downto 0); aruser : std_logic_vector; arvalid : std_logic; rready : std_logic; end record; type t_axi_rd_slave_out_if is record arready : std_logic; rid : std_logic_vector; rdata : std_logic_vector; rresp : std_logic_vector(1 downto 0); rlast : std_logic; ruser : std_logic_vector; rvalid : std_logic; end record; end package; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity test2 is port ( wr_port_in : in t_axi_wr_slave_in_if; wr_port_out : out t_axi_wr_slave_out_if; rd_port_in : in t_axi_rd_slave_in_if; rd_port_out : out t_axi_rd_slave_out_if ); end entity test2; architecture beh of test2 is begin end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity issue544 is end entity; architecture beh of issue544 is type t_axi_write_address_channel is record awid : std_logic_vector; awaddr : std_logic_vector; awlen : std_logic_vector(7 downto 0); awsize : std_logic_vector(2 downto 0); awburst : std_logic_vector(1 downto 0); awlock : std_logic; awcache : std_logic_vector(3 downto 0); awprot : std_logic_vector(2 downto 0); awqos : std_logic_vector(3 downto 0); awregion : std_logic_vector(3 downto 0); awuser : std_logic_vector; awvalid : std_logic; awready : std_logic; end record; type t_axi_write_data_channel is record wdata : std_logic_vector; wstrb : std_logic_vector; wlast : std_logic; wuser : std_logic_vector; wvalid : std_logic; wready : std_logic; end record; type t_axi_write_response_channel is record bid : std_logic_vector; bresp : std_logic_vector(1 downto 0); buser : std_logic_vector; bvalid : std_logic; bready : std_logic; end record; type t_axi_read_address_channel is record -- Source: Master arid : std_logic_vector; araddr : std_logic_vector; arlen : std_logic_vector(7 downto 0); arsize : std_logic_vector(2 downto 0); arburst : std_logic_vector(1 downto 0); arlock : std_logic; arcache : std_logic_vector(3 downto 0); arprot : std_logic_vector(2 downto 0); arqos : std_logic_vector(3 downto 0); arregion : std_logic_vector(3 downto 0); aruser : std_logic_vector; arvalid : std_logic; -- Source: Slave arready : std_logic; end record; type t_axi_read_data_channel is record -- Source: Slave rid : std_logic_vector; rdata : std_logic_vector; rresp : std_logic_vector(1 downto 0); rlast : std_logic; ruser : std_logic_vector; rvalid : std_logic; -- Source: Master rready : std_logic; end record; type t_axi_if is record write_address_channel : t_axi_write_address_channel; write_data_channel : t_axi_write_data_channel; write_response_channel : t_axi_write_response_channel; read_address_channel : t_axi_read_address_channel; read_data_channel : t_axi_read_data_channel; end record; signal axi_if : t_axi_if( write_address_channel( awid( 8 -1 downto 0), awaddr( 32-1 downto 0), awuser( 8 -1 downto 0)), write_data_channel( wdata( 32-1 downto 0), wstrb( 4 -1 downto 0), wuser( 8 -1 downto 0)), write_response_channel(bid( 8 -1 downto 0), buser( 8 -1 downto 0)), read_address_channel( arid( 8 -1 downto 0), araddr( 32-1 downto 0), aruser( 8-1 downto 0)), read_data_channel( rid( 8-1 downto 0), rdata( 32-1 downto 0), ruser( 8-1 downto 0))); begin i_test : entity work.test2 port map ( wr_port_in.awid => axi_if.write_address_channel.awid, wr_port_in.awaddr => axi_if.write_address_channel.awaddr, wr_port_in.awlen => axi_if.write_address_channel.awlen, wr_port_in.awsize => axi_if.write_address_channel.awsize, wr_port_in.awburst => axi_if.write_address_channel.awburst, wr_port_in.awlock => axi_if.write_address_channel.awlock, wr_port_in.awcache => axi_if.write_address_channel.awcache, wr_port_in.awprot => axi_if.write_address_channel.awprot, wr_port_in.awqos => axi_if.write_address_channel.awqos, wr_port_in.awregion => axi_if.write_address_channel.awregion, wr_port_in.awuser => axi_if.write_address_channel.awuser, wr_port_in.awvalid => axi_if.write_address_channel.awvalid, wr_port_in.wdata => axi_if.write_data_channel.wdata, wr_port_in.wstrb => axi_if.write_data_channel.wstrb, wr_port_in.wlast => axi_if.write_data_channel.wlast, wr_port_in.wuser => axi_if.write_data_channel.wuser, wr_port_in.wvalid => axi_if.write_data_channel.wvalid, wr_port_in.bready => axi_if.write_response_channel.bready, rd_port_in.arid => axi_if.read_address_channel.arid, rd_port_in.araddr => axi_if.read_address_channel.araddr, rd_port_in.arlen => axi_if.read_address_channel.arlen, rd_port_in.arsize => axi_if.read_address_channel.arsize, rd_port_in.arburst => axi_if.read_address_channel.arburst, rd_port_in.arlock => axi_if.read_address_channel.arlock, rd_port_in.arcache => axi_if.read_address_channel.arcache, rd_port_in.arprot => axi_if.read_address_channel.arprot, rd_port_in.arqos => axi_if.read_address_channel.arqos, rd_port_in.arregion => axi_if.read_address_channel.arregion, rd_port_in.aruser => axi_if.read_address_channel.aruser, rd_port_in.arvalid => axi_if.read_address_channel.arvalid, rd_port_in.rready => axi_if.read_data_channel.rready, wr_port_out.awready => axi_if.write_address_channel.awready, wr_port_out.wready => axi_if.write_data_channel.wready, wr_port_out.bid => axi_if.write_response_channel.bid, wr_port_out.bresp => axi_if.write_response_channel.bresp, wr_port_out.buser => axi_if.write_response_channel.buser, wr_port_out.bvalid => axi_if.write_response_channel.bvalid, rd_port_out.arready => axi_if.read_address_channel.arready, rd_port_out.rid => axi_if.read_data_channel.rid, rd_port_out.rdata => axi_if.read_data_channel.rdata, rd_port_out.rresp => axi_if.read_data_channel.rresp, rd_port_out.rlast => axi_if.read_data_channel.rlast, rd_port_out.ruser => axi_if.read_data_channel.ruser, rd_port_out.rvalid => axi_if.read_data_channel.rvalid ); process begin report "OK"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue547.vhd000066400000000000000000000011401504111170000172570ustar00rootroot00000000000000entity sub is signal x : bit; end entity; architecture test of sub is begin x <= '1'; process is begin assert x = '0'; wait for 0 ns; assert x = '1'; wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue547 is signal s : natural; end entity; architecture test of issue547 is begin u: entity work.sub; p1: process is begin assert s = 0; s <= 1; wait for 1 ns; assert s = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue548.sh000066400000000000000000000002521504111170000171140ustar00rootroot00000000000000set -xe pwd which nvc mkdir empty nvc --work=empty --init 2>errors grep "directory empty already exists" errors [ -f empty/_NVC_LIB ] grep "^nvc 1\." empty/_NVC_LIB nvc-r1.17.1/test/regress/issue549.vhd000066400000000000000000000014631504111170000172710ustar00rootroot00000000000000package pack is constant C : integer; end package; package body pack is constant C : integer := 4; end package body; ------------------------------------------------------------------------------- entity issue549 is end entity; use work.pack.all; architecture test of issue549 is type rec is record x : integer; y : bit_vector(1 to C); end record; constant def : rec := (x => 0, y => "0000"); procedure modify (variable arg : inout rec) is begin arg.y(1) := '1'; end procedure; procedure test (arg : in rec) is variable copy : rec := def; begin copy.y := arg.y; modify(copy); assert def.y = "0000"; assert copy.y = "1110"; end procedure; begin p1: test((x => 1, y => "0110")); end architecture; nvc-r1.17.1/test/regress/issue550.vhd000066400000000000000000000071031504111170000172560ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package test_pkg is type t_avalon_mm_if is record reset : std_logic; address : std_logic_vector; begintransfer : std_logic; byte_enable : std_logic_vector; chipselect : std_logic; write : std_logic; writedata : std_logic_vector; read : std_logic; lock : std_logic; readdata : std_logic_vector; response : std_logic_vector(1 downto 0); waitrequest : std_logic; readdatavalid : std_logic; irq : std_logic; end record; function init_avalon_mm_if_signals( addr_width : natural; data_width : natural; lock_value : std_logic := '0' ) return t_avalon_mm_if; end package; package body test_pkg is function init_avalon_mm_if_signals( addr_width : natural; data_width : natural; lock_value : std_logic := '0' ) return t_avalon_mm_if is variable result : t_avalon_mm_if(address(addr_width - 1 downto 0), byte_enable((data_width/8) - 1 downto 0), writedata(data_width - 1 downto 0), readdata(data_width-1 downto 0)); begin result.reset := '0'; result.address := (result.address'range => '0'); result.begintransfer := '0'; result.byte_enable := (result.byte_enable'range => '1'); result.chipselect := '0'; result.write := '0'; result.writedata := (result.writedata'range => '0'); result.read := '0'; result.lock := lock_value; result.readdata := (result.readdata'range => 'Z'); result.response := (result.response'range => 'Z'); result.waitrequest := 'Z'; result.readdatavalid := 'Z'; result.irq := 'Z'; return result; end function; end package body; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity test2 is generic ( GC_ADDR_WIDTH : integer range 1 to 64 := 8; -- Avalon MM address bus GC_DATA_WIDTH : integer range 1 to 64 := 32 -- Avalon MM data bus ); port ( clk : in std_logic; avalon_mm_vvc_master_if : inout t_avalon_mm_if := init_avalon_mm_if_signals(GC_ADDR_WIDTH, GC_DATA_WIDTH) ); begin end entity test2; architecture beh of test2 is signal avalon_mm_vvc_master_if_pd : t_avalon_mm_if(address(GC_ADDR_WIDTH-1 downto 0), byte_enable((GC_DATA_WIDTH/8)-1 downto 0), writedata(GC_DATA_WIDTH-1 downto 0), readdata(GC_DATA_WIDTH-1 downto 0)) := avalon_mm_vvc_master_if; begin end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity issue550 is end entity issue550; architecture beh of issue550 is signal clk : std_logic; signal avalon_mm_if : t_avalon_mm_if(address(31 downto 0), byte_enable(3 downto 0), writedata(31 downto 0), readdata(31 downto 0)); begin i_test : entity work.test2 generic map( GC_ADDR_WIDTH => 32, GC_DATA_WIDTH => 32 ) port map ( clk => clk, avalon_mm_vvc_master_if => avalon_mm_if ); process begin report "OK"; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue551.vhd000066400000000000000000000012621504111170000172570ustar00rootroot00000000000000entity issue551 is end entity; use std.textio.all; architecture test of issue551 is begin p1: process is file f : text; variable l : line; begin file_open(f, "out.txt", WRITE_MODE); write(l, string'("hello")); writeline(f, l); file_close(f); file_open(f, "out.txt", APPEND_MODE); write(l, string'("world")); writeline(f, l); file_close(f); file_open(f, "out.txt", READ_MODE); readline(f, l); assert l.all = "hello"; readline(f, l); assert l.all = "world"; assert endfile(f); file_close(f); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue552.vhd000066400000000000000000000012351504111170000172600ustar00rootroot00000000000000package test_pkg is type t_if is record clk : bit; txd : bit_vector(7 downto 0); txen : bit; end record; end package; use work.test_pkg.all; entity test1 is end entity; architecture beh of test1 is signal sig : t_if; begin end architecture; use work.test_pkg.all; entity issue552 is end entity; architecture beh of issue552 is begin i_test : entity work.test1; p_proc : process alias sig is <>; begin wait until sig.txen = '1' for 1.1 us; assert sig.txen = '0'; sig <= force ('1', X"00", '1'); wait for 0 ns; assert sig.txen = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue56.vhd000066400000000000000000000005641504111170000172030ustar00rootroot00000000000000entity issue56 is generic ( x : integer := 5; y : bit_vector := "110" ); port ( pi : in integer := 2; po : out bit ); end entity; architecture test of issue56 is begin process is begin assert x = 5; assert y = "110"; assert pi = 2; wait; end process; po <= '1'; end architecture; nvc-r1.17.1/test/regress/issue560.vhd000066400000000000000000000240021504111170000172540ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package test_pkg is type t_axi_wr_slave_in_if is record awid : std_logic_vector; awaddr : std_logic_vector; awlen : std_logic_vector(7 downto 0); awsize : std_logic_vector(2 downto 0); awburst : std_logic_vector(1 downto 0); awlock : std_logic; awcache : std_logic_vector(3 downto 0); awprot : std_logic_vector(2 downto 0); awqos : std_logic_vector(3 downto 0); awregion : std_logic_vector(3 downto 0); awuser : std_logic_vector; awvalid : std_logic; wdata : std_logic_vector; wstrb : std_logic_vector; wlast : std_logic; wuser : std_logic_vector; wvalid : std_logic; bready : std_logic; end record; type t_axi_wr_slave_out_if is record awready : std_logic; wready : std_logic; bid : std_logic_vector; bresp : std_logic_vector(1 downto 0); buser : std_logic_vector; bvalid : std_logic; end record; type t_axi_rd_slave_in_if is record arid : std_logic_vector; araddr : std_logic_vector; arlen : std_logic_vector(7 downto 0); arsize : std_logic_vector(2 downto 0); arburst : std_logic_vector(1 downto 0); arlock : std_logic; arcache : std_logic_vector(3 downto 0); arprot : std_logic_vector(2 downto 0); arqos : std_logic_vector(3 downto 0); arregion : std_logic_vector(3 downto 0); aruser : std_logic_vector; arvalid : std_logic; rready : std_logic; end record; type t_axi_rd_slave_out_if is record arready : std_logic; rid : std_logic_vector; rdata : std_logic_vector; rresp : std_logic_vector(1 downto 0); rlast : std_logic; ruser : std_logic_vector; rvalid : std_logic; end record; type t_axi_write_address_channel is record awid : std_logic_vector; awaddr : std_logic_vector; awlen : std_logic_vector(7 downto 0); awsize : std_logic_vector(2 downto 0); awburst : std_logic_vector(1 downto 0); awlock : std_logic; awcache : std_logic_vector(3 downto 0); awprot : std_logic_vector(2 downto 0); awqos : std_logic_vector(3 downto 0); awregion : std_logic_vector(3 downto 0); awuser : std_logic_vector; awvalid : std_logic; awready : std_logic; end record; type t_axi_write_data_channel is record wdata : std_logic_vector; wstrb : std_logic_vector; wlast : std_logic; wuser : std_logic_vector; wvalid : std_logic; wready : std_logic; end record; type t_axi_write_response_channel is record bid : std_logic_vector; bresp : std_logic_vector(1 downto 0); buser : std_logic_vector; bvalid : std_logic; bready : std_logic; end record; type t_axi_read_address_channel is record arid : std_logic_vector; araddr : std_logic_vector; arlen : std_logic_vector(7 downto 0); arsize : std_logic_vector(2 downto 0); arburst : std_logic_vector(1 downto 0); arlock : std_logic; arcache : std_logic_vector(3 downto 0); arprot : std_logic_vector(2 downto 0); arqos : std_logic_vector(3 downto 0); arregion : std_logic_vector(3 downto 0); aruser : std_logic_vector; arvalid : std_logic; arready : std_logic; end record; type t_axi_read_data_channel is record rid : std_logic_vector; rdata : std_logic_vector; rresp : std_logic_vector(1 downto 0); rlast : std_logic; ruser : std_logic_vector; rvalid : std_logic; rready : std_logic; end record; type t_axi_if is record write_address_channel : t_axi_write_address_channel; write_data_channel : t_axi_write_data_channel; write_response_channel : t_axi_write_response_channel; read_address_channel : t_axi_read_address_channel; read_data_channel : t_axi_read_data_channel; end record; end package; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity test2 is port ( wr_port_in : in t_axi_wr_slave_in_if; wr_port_out : out t_axi_wr_slave_out_if; rd_port_in : in t_axi_rd_slave_in_if; rd_port_out : out t_axi_rd_slave_out_if ); end entity test2; architecture beh of test2 is signal clk : std_logic; signal reset_n : std_logic := '1'; begin p1: process(clk, reset_n) begin if reset_n = '1' then wr_port_out.bid <= (wr_port_out.bid'range => '0'); rd_port_out.rid <= (rd_port_out.rid'range => '0'); elsif rising_edge(clk) then null; end if; end process; end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity test3 is generic( GC_ADDR_WIDTH_1 : natural := 32; GC_DATA_WIDTH_1 : natural := 32; GC_ID_WIDTH_1 : natural := 8; GC_USER_WIDTH_1 : natural := 8 ); end entity test3; architecture beh of test3 is signal axi_if : t_axi_if( write_address_channel( awid( GC_ID_WIDTH_1 -1 downto 0), awaddr( GC_ADDR_WIDTH_1-1 downto 0), awuser( GC_USER_WIDTH_1 -1 downto 0)), write_data_channel( wdata( GC_DATA_WIDTH_1-1 downto 0), wstrb( GC_DATA_WIDTH_1/8 -1 downto 0), wuser( GC_USER_WIDTH_1 -1 downto 0)), write_response_channel(bid( GC_ID_WIDTH_1 -1 downto 0), buser( GC_USER_WIDTH_1 -1 downto 0)), read_address_channel( arid( GC_ID_WIDTH_1 -1 downto 0), araddr( GC_ADDR_WIDTH_1-1 downto 0), aruser( GC_USER_WIDTH_1-1 downto 0)), read_data_channel( rid( GC_ID_WIDTH_1-1 downto 0), rdata( GC_DATA_WIDTH_1-1 downto 0), ruser( GC_USER_WIDTH_1-1 downto 0))); begin i_test : entity work.test2 port map ( --aclk => clk, --aresetn => aresetn, -- Inputs -- write address channel wr_port_in.awid => axi_if.write_address_channel.awid, wr_port_in.awaddr => axi_if.write_address_channel.awaddr, wr_port_in.awlen => axi_if.write_address_channel.awlen, wr_port_in.awsize => axi_if.write_address_channel.awsize, wr_port_in.awburst => axi_if.write_address_channel.awburst, wr_port_in.awlock => axi_if.write_address_channel.awlock, wr_port_in.awcache => axi_if.write_address_channel.awcache, wr_port_in.awprot => axi_if.write_address_channel.awprot, wr_port_in.awqos => axi_if.write_address_channel.awqos, wr_port_in.awregion => axi_if.write_address_channel.awregion, wr_port_in.awuser => axi_if.write_address_channel.awuser, wr_port_in.awvalid => axi_if.write_address_channel.awvalid, -- write data channel wr_port_in.wdata => axi_if.write_data_channel.wdata, wr_port_in.wstrb => axi_if.write_data_channel.wstrb, wr_port_in.wlast => axi_if.write_data_channel.wlast, wr_port_in.wuser => axi_if.write_data_channel.wuser, wr_port_in.wvalid => axi_if.write_data_channel.wvalid, -- write response channel wr_port_in.bready => axi_if.write_response_channel.bready, -- read address channel rd_port_in.arid => axi_if.read_address_channel.arid, rd_port_in.araddr => axi_if.read_address_channel.araddr, rd_port_in.arlen => axi_if.read_address_channel.arlen, rd_port_in.arsize => axi_if.read_address_channel.arsize, rd_port_in.arburst => axi_if.read_address_channel.arburst, rd_port_in.arlock => axi_if.read_address_channel.arlock, rd_port_in.arcache => axi_if.read_address_channel.arcache, rd_port_in.arprot => axi_if.read_address_channel.arprot, rd_port_in.arqos => axi_if.read_address_channel.arqos, rd_port_in.arregion => axi_if.read_address_channel.arregion, rd_port_in.aruser => axi_if.read_address_channel.aruser, rd_port_in.arvalid => axi_if.read_address_channel.arvalid, -- read data channel rd_port_in.rready => axi_if.read_data_channel.rready, -- Outputs -- write address channel wr_port_out.awready => axi_if.write_address_channel.awready, -- write data channel wr_port_out.wready => axi_if.write_data_channel.wready, -- write response channel wr_port_out.bid => axi_if.write_response_channel.bid, wr_port_out.bresp => axi_if.write_response_channel.bresp, wr_port_out.buser => axi_if.write_response_channel.buser, wr_port_out.bvalid => axi_if.write_response_channel.bvalid, -- read address channel rd_port_out.arready => axi_if.read_address_channel.arready, -- read data channel rd_port_out.rid => axi_if.read_data_channel.rid, rd_port_out.rdata => axi_if.read_data_channel.rdata, rd_port_out.rresp => axi_if.read_data_channel.rresp, rd_port_out.rlast => axi_if.read_data_channel.rlast, rd_port_out.ruser => axi_if.read_data_channel.ruser, rd_port_out.rvalid => axi_if.read_data_channel.rvalid ); process begin report "OK"; wait; end process; end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.test_pkg.all; entity issue560 is end entity issue560; architecture beh of issue560 is constant C_ADDR_WIDTH_1 : natural := 32; constant C_DATA_WIDTH_1 : natural := 32; constant C_ID_WIDTH_1 : natural := 0; constant C_USER_WIDTH_1 : natural := 8; begin i_test3 : entity work.test3 generic map ( GC_ADDR_WIDTH_1 => C_ADDR_WIDTH_1, GC_DATA_WIDTH_1 => C_DATA_WIDTH_1, GC_ID_WIDTH_1 => C_ID_WIDTH_1, GC_USER_WIDTH_1 => C_USER_WIDTH_1 ); end architecture; nvc-r1.17.1/test/regress/issue57.vhd000066400000000000000000000012321504111170000171750ustar00rootroot00000000000000package issueH is constant c : bit_vector; end package issueH; package body issueH is pure function f ( i : bit_vector; l : integer range 1 to integer'high ) return bit_vector is variable v : bit_vector(i'length-1 downto 0); begin v := i; return v(l-1 downto 0); end function f; constant c : bit_vector := f(X"1F", 5); end package body issueH; entity issue57 is end entity; use work.issueH.all; architecture test of issue57 is begin process is begin assert not c'ascending; assert c'length = 5; assert c = "11111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue570.vhd000066400000000000000000000012561504111170000172630ustar00rootroot00000000000000package pack is function "=" (L: bit; R: bit) return bit; end package; package body pack is function "=" (L: bit; R: bit) return bit is begin if L = R then return '1'; else return '0'; end if; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity issue570 is end entity; architecture test of issue570 is signal x : bit := '1'; begin p1: process is begin assert (bit'( '1' ) = bit'( '1' )) = '1'; if x = '0' then assert false; end if; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue571.vhd000066400000000000000000000043121504111170000172600ustar00rootroot00000000000000package pack is type sl2d_t is array(natural range <>, natural range <>) of bit; type slv_7_0_t is array(natural range <>) of bit_vector(7 downto 0); constant size_log2 : integer := 15; subtype ram_bank_t is slv_7_0_t(0 to (2**size_log2) - 1); type ram_t is array(0 to 0) of ram_bank_t; constant ram_init : ram_t := ( -- 4 banks... 0 => ( -- 32768 bytes per bank... X"11",X"22",X"33",X"44",X"55",X"66",X"77",X"88",others => X"00")); end package; ------------------------------------------------------------------------------- use work.pack.all; entity dpram is generic ( width : integer; depth_log2 : integer; init : sl2d_t := (0 downto 1 => (0 downto 1 => '0')) ); end entity; architecture test of dpram is subtype ram_word_t is bit_vector(width-1 downto 0); type ram_t is array(natural range <>) of ram_word_t; function ram_init return ram_t is variable r : ram_t(0 to (2**depth_log2)-1); begin r := (others => (others => '0')); if init'high = r'high then for i in 0 to r'length-1 loop for j in 0 to width-1 loop r(i)(j) := init(i, j); end loop; end loop; end if; return r; end function ram_init; shared variable ram : ram_t(0 to (2**depth_log2)-1) := ram_init; begin check: process is begin assert ram(0) = X"11"; assert ram(1) = X"22"; assert ram(2) = X"33"; wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue571 is end entity; use work.pack.all; architecture test of issue571 is function rambank2sl2d (constant x : ram_bank_t) return sl2d_t is variable r : sl2d_t(0 to (2**(size_log2))-1, 7 downto 0); begin for i in 0 to r'length-1 loop for j in 0 to 7 loop r(i,j) := x(i)(j); end loop; end loop; return r; end function rambank2sl2d; begin g: for i in 0 to 0 generate u: entity work.dpram generic map ( width => 8, depth_log2 => size_log2, init => rambank2sl2d(ram_init(i)) ); end generate; end architecture; nvc-r1.17.1/test/regress/issue577.vhd000066400000000000000000000010641504111170000172670ustar00rootroot00000000000000entity issue577 is end entity; architecture test of issue577 is type mem_t is array (natural range <>) of bit_vector; type mem_ptr_t is access mem_t; function init_mem return mem_t is variable mem : mem_t(1 to 3)(1 to 5); begin return mem; end function; begin p1: process is variable ptr : mem_ptr_t; begin ptr := new mem_t'(init_mem); ptr(2)(2) := '1'; wait for 1 ns; assert ptr(2)(2) = '1'; assert ptr(2)(3) = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue586.sh000066400000000000000000000003071504111170000171170ustar00rootroot00000000000000set -xe pwd which nvc which fstdump nvc --std=2008 -a $TESTDIR/regress/issue586.vhd -e issue586 -r -w fstdump issue586.fst > issue586.dump diff -u $TESTDIR/regress/gold/issue586.dump issue586.dump nvc-r1.17.1/test/regress/issue586.vhd000066400000000000000000000016441504111170000172730ustar00rootroot00000000000000package pack is type rec_t is record x : bit_vector; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( r : in rec_t ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity issue586 is end entity; use work.pack.all; architecture test of issue586 is signal s : bit_vector(1 to 3); type rec2_t is record x : bit_vector; end record; type rec3_t is record r : rec2_t; end record; signal r : rec3_t(r(x(1 to 5))); begin u1: entity work.sub port map ( r.x => s ); u2: entity work.sub port map ( r.x => r.r.x ); stim: process is begin wait for 1 ns; r.r.x(3) <= '1'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue589.vhd000066400000000000000000000024661504111170000173010ustar00rootroot00000000000000package pack is type pt is protected procedure increment; procedure add (other : inout pt); impure function get return integer; end protected; procedure increment (p : inout pt); end package; package body pack is type pt is protected body variable val : integer := 0; procedure increment is begin val := val + 1; end procedure; impure function get return integer is begin return val; end function; procedure add (other : inout pt) is begin val := val + other.get; end procedure; end protected body; procedure increment (p : inout pt) is begin p.increment; end procedure; procedure add (p, q : inout pt) is begin p.add(q); end procedure; end package body; ------------------------------------------------------------------------------- entity issue589 is end entity; use work.pack.all; architecture test of issue589 is shared variable p, q : pt; begin p1: process is begin increment(p); wait for 1 ns; increment(p); wait for 1 ns; assert p.get = 2; q.add(p); wait for 1 ns; assert q.get = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue59.vhd000066400000000000000000000013601504111170000172010ustar00rootroot00000000000000package p is pure function f( i : boolean ) return integer; end package p; package body p is pure function f( i : boolean ) return integer is begin if (i = false) then return 0; else return 1; end if; end function f; end package body p; ------------------------------------------------------------------------------- use work.p.all; package q is constant d : integer := f(true) + 1; end package q; package body q is end package body q; ------------------------------------------------------------------------------- use work.q.all; entity issue59 is begin assert (d = 2); end entity issue59; architecture a of issue59 is begin end architecture a; nvc-r1.17.1/test/regress/issue590.vhd000066400000000000000000000003751504111170000172660ustar00rootroot00000000000000entity issue590 is end entity; architecture test of issue590 is begin p1: process is begin report time'image(time'low); assert time'image(time'low) = "-9223372036854775808 fs"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue592.vhd000066400000000000000000000013431504111170000172640ustar00rootroot00000000000000-- -*- vhdl-basic-offset: 2 -*- entity issue592 is end entity issue592; architecture beh of issue592 is begin process variable v_len : natural := 31; variable zero : integer := 0; variable zero1 : natural := 0; begin wait for 1 ns; -- This does not overflow as it uses the universal_integer overload if 0 > 2 ** v_len - 1 then report "error" severity error; end if; if zero < -(2 ** (v_len - 1)) then -- Uses the integer overload report "error" severity error; end if; zero := -(2 ** (v_len - 20)); -- Needs to truncate the result wait for 1 ns; assert zero = -2048; zero1 := -(2 ** (v_len - 20)); -- Error wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue595.vhd000066400000000000000000000016221504111170000172670ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity test1 is port ( inp : in std_logic_vector(0 to 1) ); end entity test1; architecture beh of test1 is begin process begin wait for 1 ps; assert not is_X(inp(0)) report "inp0 is X" severity error; assert not is_X(inp(1)) report "inp1 is X" severity error; assert inp(0) = '1' report "inp0 is not 1" severity error; assert inp(1) = '0' report "inp1 is not 0" severity error; wait; end process; end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue595 is end entity issue595; architecture beh of issue595 is signal inp0 : std_logic; signal inp1 : std_logic; begin i_test : entity work.test1 port map( inp => (inp1, inp0) ); process begin inp0 <= '0'; inp1 <= '1'; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue597.vhd000066400000000000000000000023211504111170000172660ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package pack is type rec2_t is record x : std_logic; end record; type rec_t is record r : rec2_t; y : std_logic_vector(1 to 3); end record; end package; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.pack.all; entity sub is port ( o1 : inout std_logic; o2 : out rec_t; o3 : out std_logic_vector(1 to 2) := "11"; o4 : out std_logic_vector(1 to 2) ); end entity; architecture test of sub is begin o4(1) <= '1'; end architecture; ------------------------------------------------------------------------------- entity issue597 is end entity; library ieee; use ieee.std_logic_1164.all; use work.pack.all; architecture test of issue597 is signal s1 : std_logic; signal s2 : rec_t; signal s3 : std_logic_vector(1 to 2); signal s4 : std_logic_vector(1 to 2); begin u: entity work.sub port map ( s1, s2, s3, s4 ); p1: process is begin s1 <= '1'; s2 <= ( ( x => '1'), y => "111" ); s3 <= s3; s4 <= s4; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue60.vhd000066400000000000000000000020661504111170000171750ustar00rootroot00000000000000package pack is type int_array1 is array (integer range <>) of integer; type int_array2 is array (integer range <>) of integer; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( x : in int_array1(1 downto 0); y : in int_array2(1 downto 0) ); end entity; architecture test of sub is begin process is begin assert y = (1, 2); wait on x; assert x = (4, 5); wait on x; assert x = (6, 7); wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue60 is end entity; use work.pack.all; architecture test of issue60 is signal a : int_array2(1 downto 0); begin sub_i: entity work.sub port map ( x => int_array1(a), y => int_array2(int_array1'(1, 2)) ); process is begin a <= (4, 5); wait for 1 ns; a <= (6, 7); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue603.vhd000066400000000000000000000014641504111170000172610ustar00rootroot00000000000000entity issue603 is end entity; architecture test of issue603 is signal x : bit_vector(1 to 3); begin p1: process is begin assert x(1)'delayed = '0'; assert x(2)'delayed = '0'; x <= "100"; wait for 0 ns; assert x(1)'delayed = '0'; assert x(2)'delayed = '0'; wait for 0 ns; assert x(1)'delayed = '1'; assert x(2)'delayed = '0'; x(2) <= '1'; wait for 0 ns; x(2) <= '0'; wait for 0 ns; assert x(2)'delayed = '1'; wait for 0 ns; assert x(2)'delayed = '0'; wait; end process; g1: for i in 1 to 3 generate begin p2: process is begin assert x(i)'delayed = '0'; wait; end process; end generate; end architecture; nvc-r1.17.1/test/regress/issue609.vhd000066400000000000000000000020621504111170000172620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub is port ( data : inout std_logic_vector(15 downto 0) := (others => 'Z') ); end entity; architecture test of sub is signal data_int : std_logic_vector(15 downto 0); begin p1: data_int <= data; p2: process is begin wait for 1 ns; assert data_int = X"0000"; wait for 1 ns; assert data_int = X"0047"; wait; end process; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity issue609 is end entity; architecture test of issue609 is signal data : std_logic_vector(15 downto 0) := X"0000"; procedure drive_half (signal x : inout std_logic_vector(15 downto 0)) is begin x(7 downto 0) <= X"47"; wait for 1 ns; end procedure; begin u: entity work.sub port map ( data ); p3: process is begin data <= X"0000"; wait for 1 ns; drive_half(data); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue610.vhd000066400000000000000000000046061504111170000172600ustar00rootroot00000000000000package com_if_pkg is constant C_NOM_IDX : natural := 1; constant C_RED_IDX : natural := 2; type t_com_if is (NOM, RED); type t_com_type is (UART); type t_com_interface is protected procedure set(constant value : t_com_if); impure function get return natural; end protected t_com_interface; function to_com( constant value : natural) return t_com_type; end package com_if_pkg; package body com_if_pkg is type t_com_interface is protected body variable priv_idx_val : natural := C_NOM_IDX; procedure set( constant value : t_com_if)is begin case value is when RED => priv_idx_val := C_RED_IDX; when NOM => priv_idx_val := C_NOM_IDX; when others => report "set(if) Unknown com interface" severity error; end case; end procedure set; impure function get return natural is begin return priv_idx_val; end function get; end protected body t_com_interface; function to_com( constant value : natural) return t_com_type is begin case value is when C_RED_IDX => return UART; when C_NOM_IDX => return UART; when others => report "to_com(nat) Unknown com interface" severity error; return UART; end case; end function to_com; end package body com_if_pkg; use work.com_if_pkg.all; package com_if_shared_pkg is shared variable protected_com_if : t_com_interface; end package com_if_shared_pkg; use work.com_if_pkg.all; use work.com_if_shared_pkg.all; package com_pkg is alias t_com_if is work.com_if_pkg.t_com_if; alias protected_com_if is work.com_if_shared_pkg.protected_com_if; procedure read_test( constant msg_id : in natural); end package; package body com_pkg is procedure read_test( constant msg_id : in natural ) is constant C_IDX : natural := protected_com_if.get; constant C_COM : t_com_type := to_com(C_IDX); begin report to_string(C_IDX); case C_COM is when UART => report "OK"; when others => report "read_test() Unknown com interface " & to_string(C_COM) severity error; end case; end procedure; end package body; use work.com_pkg.all; use work.com_if_pkg.all; entity issue610 is end entity; architecture beh of issue610 is begin p_proc : process begin protected_com_if.set(NOM); read_test(1); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue612.vhd000066400000000000000000000031361504111170000172570ustar00rootroot00000000000000entity issue612 is end entity; architecture test of issue612 is procedure many_args (arg0, arg1, arg2, arg3, arg4 : out integer; arg5, arg6, arg7, arg8, arg9 : out integer; arg10, arg11, arg12, arg13, arg14 : out integer; arg15, arg16, arg17, arg18, arg19 : out integer; arg20, arg21, arg22, arg23 : out integer) is begin end procedure; attribute foreign of many_args : procedure is "VHPIDIRECT many_args"; begin p1: process is variable v0, v1, v2, v3, v4 : integer; variable v5, v6, v7, v8 : integer; variable v9, v10, v11, v12 : integer; variable v13, v14, v15, v16 : integer; variable v17, v18, v19, v20 : integer; variable v21, v22, v23 : integer; begin many_args(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23); assert v0 = 0; assert v1 = 1; assert v2 = 2; assert v3 = 3; assert v4 = 4; assert v5 = 5; assert v6 = 6; assert v7 = 7; assert v8 = 8; assert v9 = 9; assert v10 = 10; assert v11 = 11; assert v12 = 12; assert v13 = 13; assert v14 = 14; assert v15 = 15; assert v16 = 16; assert v17 = 17; assert v18 = 18; assert v19 = 19; assert v20 = 20; assert v21 = 21; assert v22 = 22; assert v23 = 23; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue613.vhd000066400000000000000000000007431504111170000172610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity test_port is port( sig : in unsigned ); end entity test_port; architecture beh of test_port is begin assert sig = "0100"; end architecture beh; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue613 is end entity issue613; architecture beh of issue613 is begin i_ent : entity work.test_port port map ( sig => to_unsigned(4, 4) ); end architecture beh; nvc-r1.17.1/test/regress/issue615.vhd000066400000000000000000000026711504111170000172650ustar00rootroot00000000000000-- Test case from Brian Padalino library ieee ; use ieee.std_logic_1164.all ; use ieee.numeric_std.all ; use ieee.math_real.all ; use std.textio.all ; entity issue615 is end entity ; architecture arch of issue615 is constant LUT_DEPTH : positive := 32 ; type cx_t is record re : signed ; im : signed ; end record ; function to_string(x : cx_t) return string is begin return "(" & to_string(to_integer(x.re)) & "," & to_string(to_integer(x.im)) & ")" ; end function ; subtype c18_t is cx_t( re(17 downto 0), im(17 downto 0) ); type c18s_t is array(natural range <>) of c18_t ; function sincos(n : positive) return c18s_t is variable rv : c18s_t(0 to n-1) ; begin for idx in 0 to n-1 loop rv(idx).re := to_signed(integer(round(32768.0*cos(2.0*MATH_PI*real(idx)/real(n)))), 18) ; rv(idX).im := to_signed(integer(round(32768.0*sin(2.0*MATH_PI*real(idx)/real(n)))), 18) ; end loop ; return rv ; end function ; constant sincos_lut : c18s_t(0 to LUT_DEPTH-1) := sincos(LUT_DEPTH) ; begin tb : process variable l : line ; begin for idx in sincos_lut'range loop write(l, to_string(sincos_lut(idx))) ; writeline(output, l) ; end loop ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue616.vhd000066400000000000000000000023331504111170000172610ustar00rootroot00000000000000library ieee ; use ieee.numeric_std.all ; entity issue616 is end entity ; architecture arch of issue616 is type cx_t is record re : signed ; im : signed ; end record ; subtype c16_t is cx_t( re(15 downto 0), im(15 downto 0) ) ; subtype c18_t is cx_t( re(17 downto 0), im(17 downto 0) ) ; subtype c34_t is cx_t( re(33 downto 0), im(33 downto 0) ) ; function "*"(a : c16_t ; b : c18_t) return c34_t is variable rv : c34_t ; begin rv.re := a.re*b.re - a.im*b.re ; rv.im := a.im*b.re + a.re*b.im ; return rv ; end function ; begin tb : process constant a : c16_t := ( re => to_signed(4567, 16), im => to_signed(3210, 16) ) ; constant b : c18_t := ( re => to_signed(4096, 18), im => to_signed(1234, 18) ) ; -- Incorrect assignment sizes constant c : c16_t := ( re => to_signed(1111, 17), im => to_signed(2222, 16) ) ; variable result : c34_t ; --variable n : natural ; begin -- Same argument sizes result := a * b ; -- wait for 10 ns ; -- Opposite argument sizes --result := b * a ; wait for 10 ns ; wait; end process ; end architecture ; nvc-r1.17.1/test/regress/issue617.vhd000066400000000000000000000013461504111170000172650ustar00rootroot00000000000000entity issue617 is end entity; architecture rtl of issue617 is type sfixed is array (integer range <>) of bit; procedure func (y: in bit_vector) is begin wait for 0 ns; end procedure; procedure test (constant l, r : in integer) is variable example : sfixed(l downto r); begin func(bit_vector(example)); end procedure; begin process variable example : sfixed(31 downto -32); variable null_range : sfixed(-33 downto -32); begin test(-33, -32); -- OK test(31, -32); -- Error --func(bit_vector(example)); -- Error --func(bit_vector(null_range)); -- OK wait; end process; end rtl; nvc-r1.17.1/test/regress/issue618.vhd000066400000000000000000000005011504111170000172560ustar00rootroot00000000000000library ieee ; use ieee.std_logic_1164.all ; entity issue618 is generic ( A : std_logic := '0' ; B : std_logic := '1' ) ; end entity; architecture test of issue618 is begin p1: process is begin assert A = '1'; assert B = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue620.vhd000066400000000000000000000034201504111170000172520ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity dff is generic ( function edge(signal s : std_ulogic) return boolean ) ; port ( clock : in std_ulogic ; d : in std_ulogic ; q : out std_ulogic ) ; end entity ; architecture arch of dff is begin process(clock) begin if edge(clock) then q <= d ; end if ; end process ; end architecture ; library ieee ; use ieee.std_logic_1164.all; entity dff_top is port ( clock : in std_ulogic ; d : in std_ulogic_vector(1 downto 0) ; q : out std_ulogic_vector(1 downto 0) ) ; end entity ; architecture arch of dff_top is begin U_dff0 : entity work.dff generic map ( edge => falling_edge ) port map ( clock => clock, d => d(0), q => q(0) ) ; U_dff1 : entity work.dff generic map ( edge => rising_edge ) port map ( clock => clock, d => d(1), q => q(1) ) ; end architecture ; library ieee ; use ieee.std_logic_1164.all; entity issue620 is end entity; architecture test of issue620 is signal clock : std_ulogic := '0'; signal d : std_ulogic_vector(1 downto 0) ; signal q : std_ulogic_vector(1 downto 0); begin u: entity work.dff_top port map ( clock, d, q ); stim: process is begin d <= "11"; wait for 1 ns; clock <= '1'; wait for 1 ns; assert q = "1U"; clock <= '0'; wait for 1 ns; assert q = "11"; d <= "01"; clock <= '1'; wait for 1 ns; assert q = "01"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue63.vhd000066400000000000000000000004011504111170000171670ustar00rootroot00000000000000package pack0 is constant v : bit_vector := "10"; end package; entity issue63 is end entity; use work.all; architecture test of issue63 is begin process is begin assert pack0.v = "10"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue640.vhd000066400000000000000000000014341504111170000172570ustar00rootroot00000000000000ENTITY issue640 IS END ENTITY issue640; ARCHITECTURE issue640_arch of issue640 IS TYPE t_cmd IS (IDLE, READ, WRITE); SIGNAL cmd: t_cmd := IDLE; signal state : natural; BEGIN bfm: PROCESS IS BEGIN WAIT ON cmd'TRANSACTION; IF cmd = IDLE THEN state <= 0; ELSIF cmd = READ THEN state <= 1; ELSIF cmd = WRITE THEN state <= 2; END IF; END PROCESS bfm; sim: PROCESS IS BEGIN cmd <= IDLE; WAIT FOR 10 ns; assert state = 0; cmd <= READ; WAIT FOR 10 ns; assert state = 1; cmd <= WRITE; wait for 0 ns; assert state = 1; wait for 0 ns; assert state = 2; WAIT; END PROCESS sim; END ARCHITECTURE; nvc-r1.17.1/test/regress/issue643.vhd000066400000000000000000000013571504111170000172660ustar00rootroot00000000000000library ieee ; use ieee.std_logic_1164.all ; entity issue643 is end entity; architecture arch of issue643 is function check_case(x : std_logic_vector) return boolean is begin case? x is when "1--" => return true ; when "01-" => return true ; when "001" => return true ; when others => return false ; end case? ; end function; begin tb: process is begin --assert check_case("1--") = true ; -- illegal but should be caught at runtime? assert check_case("110") = true ; assert check_case("100") = true ; assert check_case("101") = true ; assert check_case("000") = false ; wait; end process ; end architecture ; nvc-r1.17.1/test/regress/issue644.vhd000066400000000000000000000034721504111170000172670ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package mux is generic ( MUX_DATA_SIZE : natural ); subtype mux_data is std_logic_vector(MUX_DATA_SIZE-1 downto 0); type mux_data_array is array (natural range <>) of mux_data; end package; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity multiplexer is generic ( MUX_DATA_SIZE : natural; MUX_CTRL_SIZE : natural; package mux_g is new work.mux generic map(MUX_DATA_SIZE => MUX_DATA_SIZE) ); port ( MUX_CTRL : in std_logic_vector(MUX_CTRL_SIZE-1 downto 0); MUX_IN : in mux_g.mux_data_array(0 to 2**MUX_CTRL_SIZE-1); MUX_OUT : out mux_g.mux_data ); end entity; architecture multiplexer_arch of multiplexer is begin MUX_OUT <= MUX_IN(to_integer(unsigned(MUX_CTRL))); end architecture; library ieee ; use ieee.std_logic_1164.all; entity issue644 is end entity ; architecture arch of issue644 is constant MUX_DATA_SIZE : natural := 2 ; constant MUX_CTRL_SIZE : natural := 2 ; package mux_g is new work.mux generic map(MUX_DATA_SIZE => MUX_DATA_SIZE) ; signal MUX_CTRL : std_logic_vector(MUX_CTRL_SIZE-1 downto 0) ; signal MUX_IN : mux_g.mux_data_array(0 to 2**MUX_CTRL_SIZE-1) ; signal MUX_OUT : mux_g.mux_data ; begin U_multiplexer : entity work.multiplexer generic map ( MUX_DATA_SIZE => MUX_DATA_SIZE, MUX_CTRL_SIZE => MUX_CTRL_SIZE, mux_g => mux_g ) port map ( MUX_CTRL => MUX_CTRL, MUX_IN => MUX_IN, MUX_OUT => MUX_OUT ) ; check: process is begin mux_ctrl <= "10"; mux_in <= ("00", "01", "10", "11"); wait for 1 ns; assert mux_out = "10"; mux_ctrl <= "00"; wait for 1 ns; assert mux_out = "00"; wait; end process; end architecture ; nvc-r1.17.1/test/regress/issue646.vhd000066400000000000000000000005771504111170000172740ustar00rootroot00000000000000entity issue646 is end entity; architecture test of issue646 is function get_init (x : integer; y : bit_vector) return integer is begin assert x = 42; assert y = "000"; return 55; end function; signal x : integer := 42; signal y : bit_vector(1 to 3); signal z : integer := get_init(x, y); begin assert z = 55; end architecture; nvc-r1.17.1/test/regress/issue653.vhd000066400000000000000000000041741504111170000172670ustar00rootroot00000000000000library ieee ; use ieee.std_logic_1164.all ; package axi4s is type axis_t is record data : std_ulogic_vector ; dest : std_ulogic_vector ; id : std_ulogic_vector ; strb : std_ulogic_vector ; keep : std_ulogic_vector ; user : std_ulogic_vector ; last : std_ulogic ; valid : std_ulogic ; ready : std_ulogic ; end record ; type axis_array_t is array(natural range <>) of axis_t ; package make is generic ( DATA_BYTES : positive := 4 ; DEST_WIDTH : natural := 0 ; ID_WIDTH : natural := 0 ; USER_WIDTH : natural := 0 ) ; subtype DATA_RANGE is natural range DATA_BYTES*8-1 downto 0 ; subtype DEST_RANGE is natural range DEST_WIDTH-1 downto 0 ; subtype ID_RANGE is natural range ID_WIDTH-1 downto 0 ; subtype KEEP_RANGE is natural range DATA_BYTES-1 downto 0 ; subtype USER_RANGE is natural range USER_WIDTH-1 downto 0 ; subtype axis_t is axi4s.axis_t( data(DATA_RANGE), dest(DEST_RANGE), id(ID_RANGE), keep(KEEP_RANGE), strb(KEEP_RANGE), user(USER_RANGE) ) ; end package ; end package ; package axis32 is new work.axi4s.make ; entity test is port ( clock : in bit ; reset : in bit ; rx : inout work.axis32.axis_t ; tx : inout work.axi4s.axis_t(data(31 downto 0), dest(-1 downto 0), id(-1 downto 0), keep(3 downto 0), strb(-1 downto 0), user(-1 downto 0)) ) ; end entity ; architecture arch of test is begin -- do nothing for now end architecture ; ------------------------------------------------------------------------------- entity issue653 is end entity; use work.axis32.all; library ieee; use ieee.std_logic_1164.all; architecture test of issue653 is signal rx : axis_t; signal clk, reset : bit := '1'; begin u: entity work.test port map ( clk, reset, rx, open ); -- rx.data <= X"01020304", X"0708090a" after 1 ns; end architecture; nvc-r1.17.1/test/regress/issue654.vhd000066400000000000000000000045321504111170000172660ustar00rootroot00000000000000library ieee ; use ieee.std_logic_1164.std_logic ; use ieee.std_logic_1164.std_ulogic ; use ieee.std_logic_1164."not"; package frequency is type frequency is range 0 to 2e9 units Hz ; kHz = 1000 Hz ; MHz = 1000 kHz ; GHz = 1000 MHz ; THz = 1000 GHz ; end units ; function half_period(freq : frequency) return time ; function period(freq : frequency) return time ; procedure generate_clock generic ( type t ; function "not"(x : t) return t is <> ) parameter (signal clock : inout t ; freq : frequency ; count : natural := 0) ; procedure generate_clock is new generate_clock generic map(t => std_ulogic) ; --procedure generate_clock is new generate_clock generic map(t => std_logic) ; procedure generate_clock is new generate_clock generic map(t => bit) ; end package ; package body frequency is function period(freq : frequency) return time is begin return 1 sec / frequency'pos(freq) ; end function ; function half_period(freq : frequency) return time is begin return period(freq) / 2.0 ; end function ; procedure generate_clock generic( type t ; function "not"(x : t) return t is <> ) parameter ( signal clock : inout t ; freq : frequency ; count : natural := 0 ) is constant hp : time := half_period(freq) ; variable downcount : natural := count ; begin -- count = 0 means forever, otherwise we look at the downcount while count = 0 or downcount > 0 loop clock <= not clock; wait for hp; clock <= not clock; wait for hp; downcount := downcount - 1 ; end loop ; end procedure ; end package body ; ------------------------------------------------------------------------------- entity issue654 is end entity; use work.frequency.all; architecture test of issue654 is signal clk : bit; begin clkgen: process is begin generate_clock(clk, 1 GHz, 100); assert now = 100 ns; wait; end process; check: process is begin for i in 1 to 100 loop wait for 0.5 ns; assert clk = '1'; wait for 0.5 ns; assert clk = '0'; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue655.vhd000066400000000000000000000043511504111170000172660ustar00rootroot00000000000000library ieee ; use ieee.numeric_std.all ; entity saturate is port ( x : in signed(31 downto 0) ; y : out signed(15 downto 0) ) ; end entity ; architecture ifarch of saturate is constant sat_high : signed := to_signed(2**(y'length-1) - 1, y'length) ; constant sat_low : signed := to_signed(-(2**(y'length-1)), y'length) ; constant too_high : integer := to_integer(sat_high) ; constant too_low : integer := to_integer(sat_low) ; begin process(all) begin if( x >= too_high ) then y <= sat_high ; elsif( x <= sat_low ) then y <= sat_low ; else y <= resize(x, y'length) ; end if ; end process ; end architecture ; architecture casearch of saturate is subtype too_high is integer range 2**(y'length-1)-1 to integer'high ; subtype too_low is integer range integer'low to -(2**(y'length-1)) ; constant sat_high : signed := to_signed(2**y'length - 1, y'length) ; constant sat_low : signed := to_signed(0, y'length) - sat_high - to_signed(1, y'length) ; begin process(all) begin case to_integer(x) is when too_high => y <= sat_high ; when too_low => y <= sat_low ; when others => y <= resize(x, y'length) ; end case ; end process ; end architecture ; entity issue655 is end entity; library ieee ; use ieee.numeric_std.all ; use ieee.std_logic_1164.all ; architecture test of issue655 is signal x : signed(31 downto 0) := X"00000000"; signal y1, y2 : signed(15 downto 0); begin u1: entity work.saturate(ifarch) port map (x, y1); u2: entity work.saturate(ifarch) port map (x, y2); p1: process is begin x <= to_signed(-(2 ** 30), 32); wait for 1 ns; assert y1 = X"8000" report to_hstring(y1); assert y2 = X"8000" report to_hstring(y2); x <= to_signed(55, 32); wait for 1 ns; assert y1 = X"0037" report to_hstring(y1); assert y2 = X"0037" report to_hstring(y2); x <= to_signed(2 ** 24, 32); wait for 1 ns; assert y1 = X"7fff" report to_hstring(y1); assert y2 = X"7fff" report to_hstring(y2); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue658.vhd000066400000000000000000000024101504111170000172630ustar00rootroot00000000000000package pack is generic ( type t ; function "="(l, r : t) return boolean is <>; function "/="(l, r : t) return boolean is <> ) ; function equal(l, r : t) return boolean ; function notequal(l, r : t) return boolean ; end package ; package body pack is function equal(l, r : t) return boolean is begin return l = r ; end function ; function notequal(l, r : t) return boolean is begin return l /= r ; end function ; end package body ; ------------------------------------------------------------------------------- entity issue658 is end entity; architecture test of issue658 is function eq42 (x, y : integer) return boolean is begin return x = 42 and y = 42; end function; package pint is new work.pack generic map ( integer ); package pstrange is new work.pack generic map ( integer, "=" => eq42 ); package pbv is new work.pack generic map ( bit_vector ); begin check: process is begin assert pint.equal(1, 1); assert pint.notequal(1, 2); assert pbv.equal("101", "101"); assert pbv.notequal("101", "110"); assert pstrange.equal(42, 42); assert not pstrange.equal(13, 13); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue668.vhd000066400000000000000000000026661504111170000173010ustar00rootroot00000000000000library ieee; use ieee.numeric_std.all; use ieee.std_logic_1164.all; entity sub is generic ( WAYS : integer ); end entity; architecture test of sub is type setting_t is record ways_bits : integer; end record; impure function init return setting_t is begin return (ways_bits => 5); end function; constant setting : setting_t := init; begin g: for channel in 0 to WAYS-1 generate function popcount_channel return integer is constant vec : std_logic_vector(SETTING.WAYS_BITS-1 downto 0) := std_logic_vector(to_unsigned(channel, SETTING.WAYS_BITS)); variable num : integer; variable idx : integer; begin num := 0; for i in vec'range loop if (vec(i) = '1') then num := num + 1; end if; end loop; return num; end function; constant k : integer := popcount_channel; begin p1: process is begin wait for channel * ns; report integer'image(channel) & " ==> " & integer'image(k); wait; end process; end generate; end architecture; ------------------------------------------------------------------------------- entity issue668 is end entity; architecture test of issue668 is begin u: entity work.sub generic map ( 3 ); end architecture; nvc-r1.17.1/test/regress/issue670.vhd000066400000000000000000000022321504111170000172570ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity priority_encoder is port ( inp : in std_logic_vector(2 downto 0); outp : out std_logic_vector(2 downto 0)); end priority_encoder; architecture arch of priority_encoder is begin process(all) begin case? inp is when "1--" => outp <= "100"; when "01-" => outp <= "010"; when "001" => outp <= "001"; when others => outp <= "000"; end case?; end process; end architecture; ------------------------------------------------------------------------------- entity issue670 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue670 is signal inp : std_logic_vector(2 downto 0); signal outp : std_logic_vector(2 downto 0); begin u: entity work.priority_encoder port map (inp, outp); stim: process is begin inp <= "100"; wait for 1 ns; assert outp = "100"; inp <= "110"; wait for 1 ns; assert outp = "100"; inp <= "010"; wait for 1 ns; assert outp = "010"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue674.vhd000066400000000000000000000013331504111170000172640ustar00rootroot00000000000000entity top is generic (clk_period : time); end top; architecture str of top is signal rst : bit := '1'; begin RELEASE_RESET : process begin wait for clk_period * 10; rst <= '0'; wait for clk_period * 1; wait; end process; end architecture; use std.env.finish; entity issue674 is end issue674; architecture sim of issue674 is constant clk_hz : integer := 100e6; constant clk_period : time := 1 sec / clk_hz; begin DUT : entity work.top(str) generic map(clk_period => clk_period); SEQUENCER_PROC : process begin wait until << signal dut.rst : bit >>= '0'; assert now = 100 ns; finish; end process; end architecture; nvc-r1.17.1/test/regress/issue675.vhd000066400000000000000000000034741504111170000172750ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package pkg is type t is protected procedure f(k : string); procedure g(signal a : out std_logic_vector); end protected; end package; package body pkg is type t is protected body type char_type is file of character; file h : char_type; impure function d(n : integer) return string is variable s : string(1 to n); begin for i in 1 to n loop read(h, s(i)); end loop; return s; end function; impure function d(n : integer) return std_logic_vector is constant s : string := d(n); variable v : std_logic_vector(n * 8 - 1 downto 0); begin for i in 1 to n loop v((i*8) - 1 downto (i-1) * 8) := std_logic_vector(to_unsigned(character'pos(s(i)), 8)); end loop; return v; end function; procedure f(k : string) is variable j : file_open_status; begin file_open(j, h, k, read_mode); end procedure; procedure g(signal a : out std_logic_vector) is begin a <= d(4); end procedure; end protected body; end package body; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.pkg.all; entity issue675 is end entity; architecture sim of issue675 is shared variable a : t; signal c : std_logic_vector(31 downto 0); begin process procedure d(b : string) is begin a.f(b); a.g(c); end procedure; type char_type is file of character; file h : char_type; begin file_open(h, "tmp.bin", write_mode); write(h, '2'); write(h, 'F'); write(h, '2'); write(h, 'F'); file_close(h); d("tmp.bin"); wait for 0 ns; assert c = X"46324632"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue676.vhd000066400000000000000000000013701504111170000172670ustar00rootroot00000000000000entity issue676 is end entity; architecture test of issue676 is signal x, y : natural; begin p1: process (all) is variable tmp1, tmp2 : natural; begin loop exit when tmp1 > x; tmp1 := tmp1 + 1; next when tmp1 rem 2 = 0; tmp2 := tmp2 + 1; if tmp1 > 100 then exit; end if; end loop; y <= tmp2; end process; check: process is begin x <= 2; wait for 0 ns; assert y = 1; wait for 0 ns; assert y = 2; x <= 10; wait for 1 ns; assert y = 6; x <= 1000; wait for 1 ns; assert y = 51; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue677.vhd000066400000000000000000000030551504111170000172720ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity unaffected_ff is port ( clk : in std_logic; sel : in std_logic_vector(1 downto 0); a, b : in std_logic; y: out std_logic ); end unaffected_ff; architecture behavioral of unaffected_ff is begin P1 : process(clk) begin if rising_edge(clk) then case to_integer(unsigned(sel)) is when 0 => y <= a; when 1 => y <= b; when others => y <= unaffected; end case; end if; end process; end architecture; ------------------------------------------------------------------------------- entity issue677 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue677 is signal clk : std_logic := '0'; signal sel : std_logic_vector(1 downto 0); signal a, b : std_logic; signal y : std_logic; signal running : boolean := true; begin u: entity work.unaffected_ff port map ( clk => clk, sel => sel, a => a, b => b, y => y ); clkgen: clk <= not clk after 5 ns when running else unaffected; stim: process is begin wait until falling_edge(clk); sel <= "00"; a <= '1'; b <= '0'; wait until falling_edge(clk); assert y = '1'; sel <= "01"; wait until falling_edge(clk); assert y = '0'; sel <= "10"; wait until falling_edge(clk); assert y = '0'; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue681.vhd000066400000000000000000000031011504111170000172550ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package test_pkg is signal sig_pkg : std_logic := '0'; end package test_pkg; library ieee; use ieee.std_logic_1164.all; use work.test_pkg.all; entity issue681 is end entity; architecture beh of issue681 is signal sig : std_logic := '0'; begin process alias sig_a is sig_pkg; procedure force_pulse( signal target : out std_logic) is begin target <= force '1'; wait for 1 ps; target <= release; wait for 1 ps; end procedure; begin assert sig = '0' report "Init value" severity failure; sig <= force '1'; wait for 1 ps; assert sig = '1' report "Force 1" severity failure; sig <= release; wait for 1 ps; assert sig = '0' report "Release value " & to_string(sig) severity failure; assert sig_pkg = '0' report "Init value pkg" severity failure; sig_pkg <= force '1'; wait for 1 ps; assert sig_pkg = '1' report "Force 1 pkg" severity failure; sig_pkg <= release; wait for 1 ps; assert sig_pkg = '0' report "Release pkg value " & to_string(sig_pkg) severity failure; assert sig_a = '0' report "Init value alias" severity failure; sig_a <= force '1'; wait for 1 ps; assert sig_a = '1' report "Force 1 alias" severity failure; sig_a <= release; wait for 1 ps; assert sig_a = '0' report "Release alias value " & to_string(sig_a) severity failure; force_pulse(sig_a); assert sig_a = '0' report "Release procedure value " & to_string(sig_a) severity failure; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue69.vhd000066400000000000000000000010211504111170000171740ustar00rootroot00000000000000entity issue69 is end entity; architecture test of issue69 is function flip(x : bit_vector) return bit_vector is variable r : bit_vector(x'reverse_range); begin for i in x'reverse_range loop r(i) := x(i); end loop; return r; end function; begin process is variable v : bit_vector(1 to 4); begin v := "1100"; assert flip(v) = "0011"; v := "0101"; assert flip(v) = "1010"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue690.vhd000066400000000000000000000025271504111170000172700ustar00rootroot00000000000000package test_module_pkg is type entry is record field : integer; end record; type array_of_entries is array (0 to 5) of entry; type array_of_array is array (natural range<>) of array_of_entries; end package; ------------------------------------------------------------------------------- use work.test_module_pkg.all; entity test_module is port ( input : out array_of_array(7 downto 0) ); end entity test_module; architecture rtl of test_module is begin fill_array : for i in 0 to 7 generate fill_record : for j in 0 to 5 generate input(i)(j).field <= j; end generate; end generate; end architecture; ------------------------------------------------------------------------------- use work.test_module_pkg.all; entity issue690 is end entity issue690; architecture rtl of issue690 is signal test_array : array_of_array(7 downto 0); begin dut : entity work.test_module port map( input => test_array ); test_process : process begin wait for 1 ns; for i in 0 to 7 loop for j in 0 to 5 loop assert test_array(i)(j).field = j report "array wasn't filled properly" severity failure; end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue70.vhd000066400000000000000000000010101504111170000171620ustar00rootroot00000000000000entity issue70 is end; architecture test of issue70 is procedure my_write(value : in bit_vector) is variable s: bit_vector(1 to value'length); variable m: bit_vector(1 to value'length) := value; begin for i in 1 to value'length loop s(i) := m(i); end loop; wait for 1 ns; assert s = m; end procedure; begin process is variable count : bit_vector(3 downto 0); begin my_write(count); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue700.vhd000066400000000000000000000005111504111170000172470ustar00rootroot00000000000000use std.textio.all ; entity issue700 is end entity ; architecture arch of issue700 is begin tb : process variable s : string(1 to 6) ; begin s(3 to 4) := "Hi" ; s(5) := SOH; s(6) := DEL; report s ; write(output, s) ; wait; end process ; end architecture ; nvc-r1.17.1/test/regress/issue701.vhd000066400000000000000000000012141504111170000172510ustar00rootroot00000000000000entity issue701 is end entity; architecture test of issue701 is type sample is array (natural range <>) of integer; type dozen_samples is array (1 to 12) of sample; subtype dozen_short_samples is dozen_samples(open)(0 to 9); signal my_dozen: dozen_short_samples; begin p1: process is variable index : natural; begin my_dozen(1)(0) <= 4; my_dozen(12) <= (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); index := 10; wait for 0 ns; assert my_dozen(1)(0) = 4; assert my_dozen(12)(2) = 3; my_dozen(6)(index) <= 4; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/issue703.vhd000066400000000000000000000014531504111170000172600ustar00rootroot00000000000000package pack is type pair is record x, y : integer; end record; type pair_array is array (natural range <>) of pair; end package; ------------------------------------------------------------------------------- entity sub is end entity; use work.pack.all; architecture test of sub is type rec is record p : pair; f : bit; end record; signal r : rec; begin r <= ((1, 2), '1') after 1 ns, ((5, 55), '0') after 5 ns; end architecture; ------------------------------------------------------------------------------- entity issue703 is end entity; use work.pack.all; architecture test of issue703 is signal s : bit := '1'; signal t : pair_array(1 to 3); begin s <= not s after 2 ns when s = '1'; u: entity work.sub; end architecture; nvc-r1.17.1/test/regress/issue704.vhd000066400000000000000000000012101504111170000172500ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : in rec_t; o : out rec_t ); end entity; architecture test of sub is begin o <= i after 1 ns; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity issue704 is end entity; architecture test of issue704 is signal x, y : rec_t; begin u: entity work.sub port map ( x, y ); x <= (1, 2) after 1 ns, (5, 6) after 2 ns; end architecture; nvc-r1.17.1/test/regress/issue705.vhd000066400000000000000000000025021504111170000172560ustar00rootroot00000000000000entity issue705 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue705 is signal x : std_logic_vector(1 to 3); signal y : natural; signal p : std_logic; signal q : natural; signal r : bit_vector(1 to 3); signal s : natural; begin with x select? y <= 1 when "111", 2 when "000", 3 when "1--", 4 when "0--", 5 when "--0", 6 when others; p2: process is begin x <= "000"; wait for 1 ns; assert y = 2; x <= "XXX"; wait for 1 ns; assert y = 6; x <= "110"; wait for 1 ns; assert y = 3; x <= "U10"; wait for 1 ns; assert y = 5; p <= '0'; wait for 1 ns; assert q = 99; p <= '1'; wait for 1 ns; assert q = 99; p <= 'X'; wait for 1 ns; assert q = 3; p <= 'U'; wait for 1 ns; assert q = 3; r <= "010"; wait for 1 ns; assert s = 6; r <= "111"; wait for 1 ns; assert s = 1; wait; end process; with p select? q <= 99 when '0' to '1', 3 when '-'; with r select? s <= 1 when "111", 2 when "000", 6 when others; end architecture; nvc-r1.17.1/test/regress/issue712.vhd000066400000000000000000000015031504111170000172540ustar00rootroot00000000000000entity issue712 is end; architecture rtl of issue712 is signal a : character; signal b : character; signal c : character; signal k : string(1 to 5); begin process variable y : string(1 to 8); begin y := "abcdefgh"; (1 => a, 2 => b, 3 => c, 4 to 8 => k) <= y; wait for 1 ns; report a & " " & b & " " & c & " " & k; assert a = 'a'; assert b = 'b'; assert c = 'c'; assert k = "defgh"; wait; end process; process variable a : character; variable b : character; variable c : character; variable k : string(1 to 5); variable y : string(1 to 8); begin y := "abcdefgh"; (1 => a, 2 => b, 3 => c, 4 to 8 => k) := y; wait for 1 ns; assert a = 'a'; assert b = 'b'; assert c = 'c'; assert k = "defgh"; wait; end process; end rtl; nvc-r1.17.1/test/regress/issue714.vhd000066400000000000000000000011751504111170000172630ustar00rootroot00000000000000entity sub is port ( p : in bit_vector ); end entity; architecture test of sub is begin process is begin assert p = "10"; assert p'left = 0; assert p'right = 1; assert p'length = 2; wait for 5 ns; assert p = "11"; wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue714 is end entity; architecture test of issue714 is signal x : bit; begin u: entity work.sub port map ( p(0) => '1', p(1) => x ); x <= '1' after 4 ns; end architecture; nvc-r1.17.1/test/regress/issue715.sh000066400000000000000000000006151504111170000171130ustar00rootroot00000000000000set -xe pwd which nvc cat >test.vhd <test.vhd < par1(3 downto 2) ); s2(0 downto 0) <= ( 0 => par1(1 downto 0) ); process is begin wait for 1 ns; assert s1 = ( "11", "11" ); assert s2 = ( "11", "11" ); wait; end process; end architecture; entity issue72 is end entity; architecture topi of issue72 is begin subi: entity work.arraysub generic map(par1=>"1111"); end architecture; nvc-r1.17.1/test/regress/issue724.vhd000066400000000000000000000012311504111170000172550ustar00rootroot00000000000000use std.textio.all ; entity issue724 is end entity ; architecture arch of issue724 is constant FNAME : string := "./dummy.txt" ; begin tb : process file fin : text ; variable l : line ; variable a, b : integer ; variable count : natural := 0 ; begin file_open(fin, FNAME, write_mode) ; write(l, string'("hello, world")); writeline(fin, l); file_close(fin); file_open(fin, FNAME, read_mode) ; readline(fin, l) ; assert l.all /= "" report "Empty line read" severity failure ; file_close(fin) ; std.env.stop ; end process ; end architecture; nvc-r1.17.1/test/regress/issue726.vhd000066400000000000000000000042001504111170000172560ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package types_pkg is type t_slv_array is array (natural range <>) of std_logic_vector; subtype t_word is std_logic_vector(15 downto 0); subtype t_word_array is t_slv_array(open)(t_word'range); subtype t_addr is natural range 1 to 30; type t_data is array (t_addr) of t_word_array(0 to 31); end package types_pkg; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.types_pkg.all; package protected_pkg is type t_config_interface is protected impure function get_val return t_data; end protected t_config_interface; end package protected_pkg; package body protected_pkg is type t_config_interface is protected body variable v_data : t_data := (others => (others => (others => '0'))); impure function get_val return t_data is begin return v_data; end function get_val; end protected body t_config_interface; end package body; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.protected_pkg.all; package shared_variables_pkg is shared variable shared_config : t_config_interface; end package shared_variables_pkg; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.types_pkg.all; use work.shared_variables_pkg.all; package test_pkg is impure function randomize(constant val : t_word_array) return t_word_array; end package test_pkg; package body test_pkg is impure function randomize(constant val : t_word_array) return t_word_array is begin return val; end function; end package body; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.types_pkg.all; use work.shared_variables_pkg.all; use work.test_pkg.all; entity issue726 is end entity issue726; architecture str of issue726 is begin process variable v_data : t_word_array(0 to 31); constant C_VAL : unsigned(4 downto 0) := "00010"; begin v_data := randomize(shared_config.get_val(to_integer(C_VAL))); for i in v_data'range loop assert v_data(i) = X"0000"; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue730.vhd000066400000000000000000000023111504111170000172520ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity module_ref_label is generic ( G_PATH : string := "None" ); port ( clk : in std_logic; print : in std_logic ); end entity module_ref_label; architecture rtl of module_ref_label is begin process (clk) begin if rising_edge(clk) then if print = '1' then report G_PATH; end if; end if; end process; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use std.env.finish; entity issue730 is end entity issue730; architecture sim of issue730 is signal clk : std_logic := '0'; signal print : std_logic; begin clk <= not clk after 5 ns; test_mod : entity work.module_ref_label generic map ( G_PATH => test_mod'path_name ) port map( clk => clk, print => print ); test_proc : process is begin report test_proc'path_name; wait until rising_edge(clk); print <= '1'; wait until rising_edge(clk); print <= '0'; finish; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue731.vhd000066400000000000000000000010221504111170000172510ustar00rootroot00000000000000library ieee ; entity issue731 is end entity ; architecture arch of issue731 is signal bi : ieee.numeric_bit.unsigned(186 downto 0) := d"98234789237429847239487234982347239487239487238947492783" ; begin tb : process begin assert ieee.numeric_bit.to_string(bi) = "1000000000110011110011110100101110010110101110101110010010011111001001000000111010010001101101101100010111111110011101110101101011111100001110111010010110111101111010100000101001110101111"; wait; end process ; end architecture ; nvc-r1.17.1/test/regress/issue732.vhd000066400000000000000000000012021504111170000172520ustar00rootroot00000000000000package test_pkg is type test_t is record data : bit_vector ; end record ; type config_t is record width : positive ; end record ; constant DEFAULT_CONFIG : config_t := config_t'(width => 10) ; package make is generic ( CONFIG : config_t := DEFAULT_CONFIG ) ; subtype sub_test_t is test_t(data(CONFIG.WIDTH-1 downto 0)) ; end package ; end package ; package newtest is new work.test_pkg.make ; entity issue732 is end entity ; architecture arch of issue732 is signal x : work.newtest.sub_test_t ; begin assert x.data'length = 10; end architecture ; nvc-r1.17.1/test/regress/issue734.vhd000066400000000000000000000004561504111170000172660ustar00rootroot00000000000000entity issue734 is end entity ; architecture arch of issue734 is signal val : bit_vector(0 downto 1) ; begin tb : process variable n : integer := 0; begin wait for 1 ns; val(n) <= '0' ; -- Error wait ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue744.vhd000066400000000000000000000006671504111170000172730ustar00rootroot00000000000000library ieee; use ieee.math_real.all; package pack is function clog2(x: positive) return natural; end package; package body pack is function clog2(x: positive) return natural is begin return natural(ceil(log2(real(x)))); end; end package body; use work.pack.all; entity issue744 is end; architecture test of issue744 is subtype u is bit_vector(clog2(50) - 1 downto 0); signal b : u; begin end architecture; nvc-r1.17.1/test/regress/issue747.vhd000066400000000000000000000006541504111170000172720ustar00rootroot00000000000000entity issue747 is generic ( L : natural := 1 ); end entity; architecture test of issue747 is signal s : bit_vector(L-1 downto 0); begin process begin wait for 1 ns; s(10) <= '0'; -- no check done for out of bound s(12 downto 11) <= "11"; -- check is done here wait for 1 ns; report "SIMULATION ENDED" severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue750.vhd000066400000000000000000000031731504111170000172630ustar00rootroot00000000000000package constants is constant c_byte_width : natural; end package; package body constants is constant c_byte_width : natural := 8; end package body; ------------------------------------------------------------------------------- package pack is generic ( type t_element; c_default : t_element; c_size : natural ); type t_array is protected procedure put (idx : positive; elem : t_element); impure function get (idx : positive) return t_element; end protected; end package; package body pack is type t_array is protected body type t_array is array (1 to c_size) of t_element; variable f_array : t_array := (others => c_default); procedure put (idx : positive; elem : t_element) is begin f_array(idx) := elem; end procedure; impure function get (idx : positive) return t_element is begin return f_array(idx); end function; end protected body; end package body; ------------------------------------------------------------------------------- use work.constants.all; entity issue750 is end entity; architecture test of issue750 is subtype t_byte is bit_vector(c_byte_width - 1 downto 0); constant c_default : t_byte := X"42"; package bv_pack is new work.pack generic map ( t_element => t_byte, c_default => c_default, c_size => 10 ); use bv_pack.all; shared variable pt : t_array; begin tb: process is begin assert pt.get(5) = X"42"; pt.put(5, X"10"); assert pt.get(5) = X"10"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue751.vhd000066400000000000000000000010771504111170000172650ustar00rootroot00000000000000entity issue751 is end entity; architecture test of issue751 is type t_rec is record x : integer; y : string(1 to 5); end record; impure function get_rec return t_rec is begin return (1, "hello"); end function; constant k : t_rec := get_rec; begin -- This process has no label process is function get_x return integer is begin return k.x + 1; end function; constant c : integer := get_x; begin assert c = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue752.sh000066400000000000000000000007551504111170000171210ustar00rootroot00000000000000set -xe pwd which nvc # The pragmas would cause a crash when reading a serialised design unit nvc -a - 2>log < '1'); begin for i in 0 to WIDTH - 1 loop pt.put(i, w); end loop; wait for 1 ns; for i in 0 to WIDTH - 1 loop assert pt.get(i) = w; end loop; wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue766 is end entity; architecture test of issue766 is begin u: entity work.sub generic map ( 8, 16 ); end architecture; nvc-r1.17.1/test/regress/issue769.sh000066400000000000000000000003451504111170000171240ustar00rootroot00000000000000set -xe pwd which nvc for i in 1 2; do nvc -a - < '0'); o <= i & s0; end architecture; entity issue787 is end entity issue787; architecture rtl of issue787 is constant M : natural := 7; constant W : natural := 0; signal i : bit_vector(M-1 downto 0); signal o : bit_vector(M+W-1 downto 0); signal o_l : bit_vector(W-1 downto 0); signal o_h : bit_vector(M-1 downto 0); begin process begin i <= (others => '1'); wait for 0 ns; wait for 0 ns; assert o = (M+W-1 downto 0 => '1'); wait; end process; ent2_inst : entity work.ent2 generic map ( M => M, W => W ) port map ( i => i, o => o ); o_l <= o(W-1 downto 0); o_h <= o(M+W-1 downto W); end architecture; nvc-r1.17.1/test/regress/issue79.vhd000066400000000000000000000017201504111170000172030ustar00rootroot00000000000000package access_bug is type integer_access is access integer; type integer_access_array is array (natural range <>) of integer_access; end package; package body access_bug is function bug_function return integer_access_array is variable bug_here : integer_access_array(0 to 0); begin return bug_here; end function; end package body; entity issue79 is end entity; use work.access_bug.all; architecture test of issue79 is function make_ptrs(init : integer) return integer_access_array is variable r : integer_access_array(1 to 5); begin for i in r'range loop r(i) := new integer'(init); end loop; return r; end function; begin process is variable p : integer_access_array(1 to 5); begin assert p = (1 to 5 => null); p := make_ptrs(2); for i in p'range loop assert p(i).all = 2; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue790.vhd000066400000000000000000000006701504111170000172660ustar00rootroot00000000000000entity issue790 is end entity; architecture test of issue790 is begin p1: process is variable s : string(1 to 100) := (others => 'x'); variable e : natural := 0; begin s(1 to 5) := "12345"; wait for 1 ns; while e < s'length and s(e + 1) /= 'x' loop e := e + 1; end loop; assert integer'value(s(1 to e)) = 12345; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue791.vhd000066400000000000000000000010221504111170000172570ustar00rootroot00000000000000entity issue791 is end entity; architecture beh of issue791 is type t_slv_array is array (natural range <>) of bit_vector; procedure read_mem is -- This shouldn't be allocated on the stack variable v_memory : t_slv_array(0 to (8 * 131072)-1)(7 downto 0) := (others => x"FF"); begin wait for 1 ns; v_memory(v_memory'right) := X"ab"; wait for 1 ns; assert v_memory(v_memory'right) = X"ab"; end procedure; begin p_proc : process begin read_mem; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue794.vhd000066400000000000000000000005721504111170000172730ustar00rootroot00000000000000entity ent is end entity; architecture test of ent is signal c : integer := 42; begin process is begin assert << signal .ent.c : integer >> = 42; wait; end process; end architecture; ------------------------------------------------------------------------------- configuration issue794 of ent is for test end for; end configuration; nvc-r1.17.1/test/regress/issue799.vhd000066400000000000000000000011201504111170000172660ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue799 is end entity; architecture rtl of issue799 is constant C_IBC : natural := 500000; -- 0x07A120 type t_slv_array is array (natural range <>) of std_logic_vector; begin p_proc : process variable v_default_data : t_slv_array(0 to 32)(15 downto 0); begin v_default_data(4) := std_logic_vector(to_unsigned(C_IBC/2, 32)(31 downto 16)) or "0000000001000000"; assert v_default_data(4) = x"0043" report to_string(v_default_data(4)) severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue8.vhd000066400000000000000000000006631504111170000171200ustar00rootroot00000000000000package pack is constant results : bit_vector(1 downto 0):="11"; end package; ------------------------------------------------------------------------------- use work.pack.all; entity issue8 is end entity; architecture test of issue8 is signal bv : bit_vector(1 downto 0); begin bv <= results; process is begin wait for 1 ns; assert bv = "11"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue801.vhd000066400000000000000000000017111504111170000172540ustar00rootroot00000000000000context fifo_proj is library ieee; context ieee.ieee_std_context; use ieee.numeric_std_unsigned.all; end context; library ieee; context ieee.ieee_std_context; package fifo_types is alias logic is std_ulogic; alias logic_vec is std_ulogic_vector; end package; context work.fifo_proj; use work.fifo_types.all; use std.textio.all; entity issue801 is end entity; architecture mixed of issue801 is signal clk : logic := '0'; signal foo : logic_vec (7 downto 0) := (others => '0'); begin foo <= x"00", x"ab" after 10 ns, x"bc" after 30 ns; clock_gen: process is begin clk <= '0'; wait for 5 ns; clk <= '1'; wait for 5 ns; if now > 50 ns then wait; end if; end process; log: postponed process (clk) is alias s is to_string [logic return string]; alias h is to_hex_string [logic_vec return string]; variable l: line; begin swrite(l, "clk: " & s(clk) & ", foo: " & h(foo)); writeline(output, l); end process; end architecture; nvc-r1.17.1/test/regress/issue808.v000066400000000000000000000004101504111170000167420ustar00rootroot00000000000000module issue808; supply0 gnd; supply1 vcc; wire out; assign gnd = vcc; GND uut (out); initial begin #1 $display("%x %x %x", gnd, vcc, out); $finish; end endmodule // issue808 module GND (Y); output Y; supply0 Y ; endmodule // GND nvc-r1.17.1/test/regress/issue809.vhd000066400000000000000000000031331504111170000172640ustar00rootroot00000000000000package test_pkg is type vector_of_vectors is array(natural range <>) of bit_vector ; end package ; use work.test_pkg.vector_of_vectors ; entity test is port ( in_a : in vector_of_vectors ; in_b : in vector_of_vectors ; outs : out vector_of_vectors ) ; end entity ; architecture arch of test is -- Comment these next lines to cause a segfault constant A : natural := in_a'length ; constant B : natural := in_a'element'length ; begin process begin report "A: " & integer'image(A) ; report "B: " & integer'image(B) ; assert A = 2 ; assert B = 21 ; wait ; end process ; process(all) begin for idx in in_a'range loop for x in in_a(idx)'range loop outs(idx)(x) <= in_a(idx)(x) xor in_b(idx)(x) ; end loop ; end loop ; end process ; end architecture ; use work.test_pkg.vector_of_vectors ; entity issue809 is end entity ; architecture arch of issue809 is signal a : vector_of_vectors(1 downto 0)(20 downto 0) ; signal b : vector_of_vectors(1 downto 0)(20 downto 0) ; signal c : vector_of_vectors(1 downto 0)(20 downto 0) ; begin U_test_a : entity work.test port map ( in_a => a, in_b => b, outs => c ) ; tb : process begin a <= (others => (others => '0')); b <= (others => (others => '1')); wait for 100 ns ; assert c = (1 downto 0 => (20 downto 0 => '1')); report "Done" ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue810.vhd000066400000000000000000000735601504111170000172670ustar00rootroot00000000000000library ieee ; use ieee.fixed_pkg.all ; package types is type sfixed_vector is array(natural range <>) of sfixed ; end package ; library ieee ; use ieee.numeric_std.all ; use ieee.math_real.all ; use ieee.fixed_pkg.all ; use ieee.float_pkg.all ; package convert is function from_real(x : in real ; size : in real) return real ; function from_real generic(scale : real := 65536.0) parameter (x : in real ; size : in integer) return integer ; function from_real generic(scale : real := 65536.0) parameter (x : in real ; size : in signed) return signed ; function from_real(x : in real ; size : in sfixed) return sfixed ; function from_real(x : in real ; size : in float) return float ; function resize(x : in real ; size : in real) return real ; function resize(x : in sfixed ; size : in sfixed) return sfixed ; function resize(x : in float ; size : in float) return float ; function to_real(x : in real) return real ; function to_real generic(scale : real := 65536.0) parameter (x : in integer) return real ; function to_real generic(scale : real := 65536.0) parameter (x : in signed) return real ; function to_real(x : in float) return real ; function shift_right(x : in real ; n : in natural) return real ; function shift_right(x : in integer ; n : in natural) return integer ; function shift_right(x : in float ; n : in natural) return float ; end package ; package body convert is function shift_right(x : in float ; n : in natural) return float is begin return x / (2.0**n) ; end function ; function shift_right(x : in real ; n : in natural) return real is begin return x / (2.0**n) ; end function ; function shift_right(x : in integer ; n : in natural) return integer is begin return x / integer(2.0**n) ; end function ; function to_real generic (scale : real := 65536.0 ) parameter (x : in signed) return real is begin return real(to_integer(x))/scale ; end function ; function to_real(x : in float) return real is begin return ieee.float_pkg.to_real(x) ; end function ; function to_real(x : in real) return real is begin return x ; end function ; function to_real generic (scale : real := 65536.0) parameter (x : in integer) return real is begin return real(x)/scale ; end function ; function resize(x : in float ; size : in float) return float is begin return ieee.float_pkg.resize(x, size) ; end function ; function resize(x : in sfixed ; size : in sfixed) return sfixed is begin return ieee.fixed_pkg.resize(x, size) ; end function ; function resize(x : in real ; size : in real) return real is begin return x ; end function ; function from_real(x : in real ; size : in float) return float is begin return to_float(x, size) ; end function ; function from_real(x : in real ; size : in real) return real is begin return x ; end function ; function from_real generic(scale : real := 65536.0) parameter (x : in real ; size : in integer) return integer is begin return integer(round(scale*x)) ; end function ; function from_real generic(scale : real := 65536.0) parameter (x : in real ; size : in signed) return signed is begin return to_signed(integer(scale*x), size'length) ; end function ; function from_real(x : in real ; size : in sfixed) return sfixed is begin return to_sfixed(x, size) ; end function ; end package body ; library work ; use work.convert.to_real ; use work.convert.from_real ; package convert_integer is function from_real_q12 is new from_real[real, integer return integer] generic map (scale => 4096.0) ; function from_real_q15 is new from_real[real, integer return integer] generic map (scale => 32768.0) ; function to_real_q12 is new to_real[integer return real] generic map (scale => 4096.0) ; function to_real_q15 is new to_real[integer return real] generic map (scale => 32768.0) ; function resize(x : in integer ; size : in integer) return integer ; end package ; package body convert_integer is function resize(x : in integer ; size : in integer) return integer is begin return x ; end function ; end package body ; library ieee ; library work ; use ieee.numeric_std.all ; use work.convert.to_real ; use work.convert.from_real ; package convert_signed is function from_real_sc12 is new from_real[real, signed return signed] generic map (scale => 4096.0) ; function from_real_sc15 is new from_real[real, signed return signed] generic map (scale => 32768.0) ; function to_real_sc12 is new to_real[signed return real] generic map (scale => 4096.0) ; function to_real_sc15 is new to_real[signed return real] generic map (scale => 32768.0) ; end package ; package generic_complex_pkg is generic ( type T ; function "+"(l, r : T) return T is <> ; function "-"(l, r : T) return T is <> ; function "*"(l, r : T) return T is <> ; function "/"(l, r : T) return T is <> ; function to_real(x : in T) return real is <> ; function from_real(x : in real ; size : in T) return T is <> ; function to_string(arg : T) return string is <> ; function resize(arg : in T ; size : in T) return T is <> ; function shift_right(arg : in T ; n : in natural) return T is <> ) ; constant COPYRIGHT : string := "Copyright Brian Padalino (bpadalino@gmail.com). Licensed Apache 2.0." ; type complex is record re : T ; im : T ; end record ; type complex_vector is array(natural range <>) of complex ; function "+"(l, r : in complex) return complex ; function "+"(l : in complex ; r : in T) return complex ; function "+"(l : in T ; r : in complex) return complex ; function "-"(l, r : in complex) return complex ; function "-"(l : in complex ; r : in T) return complex ; function "-"(l : in T ; r : in complex) return complex ; function "*"(l, r : in complex) return complex ; function "*"(l : in complex ; r : in T) return complex ; function "*"(l : in T ; r : in complex) return complex ; function "/"(l, r : in complex) return complex ; function "/"(l : in complex ; r : in T) return complex ; function "/"(l : in T ; r : in complex) return complex ; function conj(z : in complex) return complex ; function magsq(z : in complex) return T ; function to_string(arg : complex) return string ; function to_complex(x : in real ; y : in real := 0.0 ; size : complex) return complex ; function to_complex(x : in real ; y : in real := 0.0 ; size : T) return complex ; function resize(arg : in complex ; size : in complex) return complex ; function shift_right(arg : in complex ; n : in natural) return complex ; end package ; package body generic_complex_pkg is function magsq(z : in complex) return T is begin return z.re*z.re + z.im*z.im ; end function ; function shift_right(arg : in complex ; n : in natural) return complex is begin return complex'(shift_right(arg.re, n), shift_right(arg.im, n)) ; end function ; function "+"(l, r : in complex) return complex is begin return complex'(re => (l.re + r.re), im => (l.im + r.im)) ; end function ; function "+"(l : in complex ; r : in T) return complex is begin return l + complex'(re => r, im => from_real(0.0, r)) ; end function ; function "+"(l : in T ; r : in complex) return complex is begin return r + complex'(re => l, im => from_real(0.0, l)) ; end function ; function "-"(l, r : in complex) return complex is begin return complex'(re => (l.re - r.re), im => (l.im - r.im)) ; end function ; function "-"(l : in complex ; r : in T) return complex is begin return l - complex'(re => r, im => from_real(0.0, r)) ; end function ; function "-"(l : in T ; r : in complex) return complex is begin return complex'(re => l, im => from_real(0.0, l)) - r ; end function ; function "*"(l, r : in complex) return complex is begin return complex'(re => (l.re*r.re - l.im*r.im), im => (l.re*r.im + l.im*r.re)) ; end function ; function "*"(l : in complex ; r : in T) return complex is begin return l * complex'(re => r, im => from_real(0.0, r)) ; end function ; function "*"(l : in T ; r : in complex) return complex is begin return complex'(re => l, im => from_real(0.0, l)) * r ; end function ; function "/"(l, r : in complex) return complex is constant temp : T := magsq(r) ; begin if temp = from_real(0.0, temp) then report "Attempt to divide complex by (0.0, 0.0)" severity error ; return complex'(from_real(real'high, temp), from_real(0.0, temp)) ; end if ; return complex'( re => (l.re*r.re + l.im*r.im) / temp, im => (l.im*r.re - l.re*r.im)/temp) ; end function ; function "/"(l : in complex ; r : in T) return complex is begin if r = from_real(0.0, r) then report "Attempt to divide complex by 0.0" severity error ; return complex'(re => from_real(real'high, r), im => from_real(0.0, r)) ; end if ; return complex'(l.re / r, l.im / r) ; end function ; function "/"(l : in T ; r : in complex) return complex is begin if r.re = from_real(0.0, r.re) and r.im = from_real(0.0, r.im) then report "Attempt to divide complex by (0.0, 0.0)" severity error ; return complex'(re => from_real(real'high, r.re), im => from_real(0.0, r.im)) ; end if ; return complex'(l/magsq(r) * r.re, (from_real(0.0, r.im)-(l/magsq(r))) * r.im) ; end function ; function conj(z : in complex) return complex is begin return complex'(re => z.re, im => from_real(0.0, z.im)-z.im) ; end function ; function to_string(arg : complex) return string is begin return "(" & to_string(to_real(arg.re)) & "," & to_string(to_real(arg.im)) & "j)" ; end function ; function to_complex(x : in real ; y : in real := 0.0; size : complex) return complex is begin return complex'(re => from_real(x, size.re), im => from_real(y, size.im)) ; end function ; function to_complex(x : in real ; y : in real := 0.0; size : T) return complex is begin return complex'(re => from_real(x, size), im => from_real(y, size)) ; end function ; function resize(arg : in complex ; size : in complex) return complex is begin return complex'(re => resize(arg.re, size.re), im => resize(arg.im, size.im)) ; end function ; end package body ; library ieee ; library work ; use ieee.fixed_pkg.all ; use work.convert.all ; package complex_sfixed is new work.generic_complex_pkg generic map(T => sfixed, resize => work.convert.resize) ; library ieee ; use ieee.std_logic_1164.all ; use ieee.math_real.all ; use ieee.fixed_pkg.all ; use work.complex_sfixed.all ; use work.types.all ; entity pfb_analysis is generic ( H : sfixed_vector ; N : positive ) ; port ( clock : in std_ulogic ; reset : in std_ulogic ; in_sample : in complex ; in_valid : in std_ulogic ; out_sample : out complex ; out_valid : out std_ulogic ) ; end entity ; architecture arch of pfb_analysis is function clog2(x : in natural) return natural is begin return integer(ceil(log2(real(x)))) ; end function ; constant TAPS_PER_LEG : positive := integer(ceil(real(H'length) / real(N))) ; type taps_t is array(natural range 0 to N-1) of sfixed_vector(0 to TAPS_PER_LEG-1)(H'element'range) ; type state_t is array(natural range 0 to N-1) of complex_vector(0 to TAPS_PER_LEG-1)(re(in_sample.re'range), im(in_sample.im'range)) ; function reshape_taps(h : in sfixed_vector ; n : in positive) return taps_t is variable rv : taps_t ; begin for leg in 0 to N-1 loop for tap in rv(leg)'range loop rv(leg)(tap) := H(leg+tap*TAPS_PER_LEG) ; end loop ; end loop ; return rv ; end function ; constant taps : taps_t := reshape_taps(H, N) ; signal state : state_t ; signal state_valid : std_ulogic ; signal prod_valid : std_ulogic ; signal accum_valid : std_ulogic ; signal retime_valids : std_ulogic_vector(4 downto 0) ; signal state_idx : natural range 0 to N-1 ; signal prod_idx : natural range 0 to N-1 ; --subtype PRODS_RANGE is integer range sfixed_high(H(H'low),'*',in_sample.re) downto sfixed_low(H(H'low),'*',in_sample.re) ; subtype PRODS_RANGE is integer range sfixed_high(H(H'low)'high,H(H'low)'low,'*',in_sample.re'high,in_sample.re'low) + 1 downto sfixed_low(H(H'low)'high,H(H'low)'low,'*',in_sample.re'high,in_sample.re'low) ; signal prods : complex_vector(0 to TAPS_PER_LEG-1)(re(PRODS_RANGE), im(PRODS_RANGE)) ; subtype ACCUM_RANGE is integer range PRODS_RANGE'left+clog2(TAPS_PER_LEG)-1 downto PRODS_RANGE'right ; signal accum : complex(re(ACCUM_RANGE), im(ACCUM_RANGE)) ; signal retimed : complex_vector(retime_valids'range)(re(ACCUM_RANGE), im(ACCUM_RANGE)) ; -- Unknown why this is necessary ... --function "*"(l : in complex ; r : in unresolved_sfixed) return complex is --begin -- return complex'(l.re * r, l.im * r) ; --end function ; begin shift_state : process(clock) begin if( rising_edge(clock) ) then if( reset = '1' ) then state_valid <= '0' ; state_idx <= 0 ; else state_valid <= in_valid ; if( in_valid = '1' ) then state(state_idx) <= in_sample & state(state_idx)(0 to state(state_idx)'high-1) ; state_idx <= (state_idx + 1) mod N ; end if ; end if ; end if ; end process ; multiply_taps : process(clock) variable carry : std_logic; begin if( rising_edge(clock) ) then if( reset = '1' ) then prod_valid <= '0' ; prod_idx <= 0 ; else prod_valid <= state_valid ; if( prod_valid = '1') then for sample_idx in 0 to TAPS_PER_LEG-1 loop --prods(sample_idx) <= state(prod_idx)(sample_idx) * taps(prod_idx)(sample_idx) ; prods(sample_idx) <= state(prod_idx)(sample_idx) * taps(prod_idx)(sample_idx) ; end loop ; prod_idx <= (prod_idx + 1) mod N ; end if ; end if ; end if ; end process ; accumulate : process(clock) variable temp : accum'subtype ; begin if( rising_edge(clock) ) then if( reset = '1' ) then accum_valid <= '0' ; else accum_valid <= prod_valid ; if( prod_valid = '1' ) then for sample_idx in prods'range loop if( sample_idx = 0 ) then temp := resize(prods(sample_idx), temp) ; else temp := resize(temp + prods(sample_idx), temp) ; end if ; accum <= temp ; end loop ; end if ; end if ; end if ; end process ; retime : process(clock) begin if( rising_edge(clock) ) then if( reset = '1' ) then retime_valids <= (others =>'0') ; else retime_valids <= retime_valids(retime_valids'high-1 downto 0) & accum_valid ; if( accum_valid = '1' ) then retimed <= retimed(retimed'high-1 downto 0) & accum ; end if ; end if ; end if ; end process ; present_output : process(clock) begin if( rising_edge(clock) ) then if( reset = '1' ) then out_valid <= '0' ; else out_valid <= retime_valids(retime_valids'high) ; if( retime_valids(retime_valids'high) = '1' ) then out_sample <= resize(retimed(retimed'high), out_sample) ; end if ; end if ; end if ; end process ; end architecture ; library ieee ; use ieee.std_logic_1164.all ; use ieee.fixed_pkg.all ; use work.complex_sfixed.all ; use work.types.all ; entity issue810 is end entity ; architecture test of issue810 is subtype SC16Q12 is integer range 3 downto -12 ; subtype Q18 is integer range 0 downto -18 ; procedure nop(signal clock : in std_ulogic ; count : in natural) is begin for x in 0 to count loop wait until rising_edge(clock) ; end loop ; end procedure ; procedure print(msg : in string) is variable l : std.textio.line ; begin std.textio.write(l, msg) ; std.textio.writeline(std.textio.output, l) ; end procedure ; constant PFB_TAPS_T12_N16 : sfixed_vector(0 to 12*16-1)(Q18) := ( to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.000002354394734, Q18'left, Q18'right), to_sfixed(-0.000006049282409, Q18'left, Q18'right), to_sfixed(-0.000011191187403, Q18'left, Q18'right), to_sfixed(-0.000017772836299, Q18'left, Q18'right), to_sfixed(-0.000025644176017, Q18'left, Q18'right), to_sfixed(-0.000034489118891, Q18'left, Q18'right), to_sfixed(-0.000043811021434, Q18'left, Q18'right), to_sfixed(-0.000052929746121, Q18'left, Q18'right), to_sfixed(-0.000060992757947, Q18'left, Q18'right), to_sfixed(-0.000067002064768, Q18'left, Q18'right), to_sfixed(-0.000069857934829, Q18'left, Q18'right), to_sfixed(-0.000068419246738, Q18'left, Q18'right), to_sfixed(-0.000061579095308, Q18'left, Q18'right), to_sfixed(-0.000048352956784, Q18'left, Q18'right), to_sfixed(-0.000027975389321, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed( 0.000035603655360, Q18'left, Q18'right), to_sfixed( 0.000078363362398, Q18'left, Q18'right), to_sfixed( 0.000127235274775, Q18'left, Q18'right), to_sfixed( 0.000180560205233, Q18'left, Q18'right), to_sfixed( 0.000236052193003, Q18'left, Q18'right), to_sfixed( 0.000290825314666, Q18'left, Q18'right), to_sfixed( 0.000341463132512, Q18'left, Q18'right), to_sfixed( 0.000384133107340, Q18'left, Q18'right), to_sfixed( 0.000414745811064, Q18'left, Q18'right), to_sfixed( 0.000429155962960, Q18'left, Q18'right), to_sfixed( 0.000423399318215, Q18'left, Q18'right), to_sfixed( 0.000393956421716, Q18'left, Q18'right), to_sfixed( 0.000338031386173, Q18'left, Q18'right), to_sfixed( 0.000253831354108, Q18'left, Q18'right), to_sfixed( 0.000140830349878, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.000166010747395, Q18'left, Q18'right), to_sfixed(-0.000352764121257, Q18'left, Q18'right), to_sfixed(-0.000554005738431, Q18'left, Q18'right), to_sfixed(-0.000761733208870, Q18'left, Q18'right), to_sfixed(-0.000966369962076, Q18'left, Q18'right), to_sfixed(-0.001157048331608, Q18'left, Q18'right), to_sfixed(-0.001322000383148, Q18'left, Q18'right), to_sfixed(-0.001449048892038, Q18'left, Q18'right), to_sfixed(-0.001526184553349, Q18'left, Q18'right), to_sfixed(-0.001542209266509, Q18'left, Q18'right), to_sfixed(-0.001487419527549, Q18'left, Q18'right), to_sfixed(-0.001354298943282, Q18'left, Q18'right), to_sfixed(-0.001138184999508, Q18'left, Q18'right), to_sfixed(-0.000837872784442, Q18'left, Q18'right), to_sfixed(-0.000456117651960, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed( 0.000518881455583, Q18'left, Q18'right), to_sfixed( 0.001084416303584, Q18'left, Q18'right), to_sfixed( 0.001676210195279, Q18'left, Q18'right), to_sfixed( 0.002270046104377, Q18'left, Q18'right), to_sfixed( 0.002838581176907, Q18'left, Q18'right), to_sfixed( 0.003352269981135, Q18'left, Q18'right), to_sfixed( 0.003780493181228, Q18'left, Q18'right), to_sfixed( 0.004092858914878, Q18'left, Q18'right), to_sfixed( 0.004260633042833, Q18'left, Q18'right), to_sfixed( 0.004258244554467, Q18'left, Q18'right), to_sfixed( 0.004064804333593, Q18'left, Q18'right), to_sfixed( 0.003665569736097, Q18'left, Q18'right), to_sfixed( 0.003053284446370, Q18'left, Q18'right), to_sfixed( 0.002229323194452, Q18'left, Q18'right), to_sfixed( 0.001204574328861, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.001353176296439, Q18'left, Q18'right), to_sfixed(-0.002813692113246, Q18'left, Q18'right), to_sfixed(-0.004330900201825, Q18'left, Q18'right), to_sfixed(-0.005845858814512, Q18'left, Q18'right), to_sfixed(-0.007292843888749, Q18'left, Q18'right), to_sfixed(-0.008601249731253, Q18'left, Q18'right), to_sfixed(-0.009697826120807, Q18'left, Q18'right), to_sfixed(-0.010509182339391, Q18'left, Q18'right), to_sfixed(-0.010964473380595, Q18'left, Q18'right), to_sfixed(-0.010998171266272, Q18'left, Q18'right), to_sfixed(-0.010552815717736, Q18'left, Q18'right), to_sfixed(-0.009581633925961, Q18'left, Q18'right), to_sfixed(-0.008050919222966, Q18'left, Q18'right), to_sfixed(-0.005942063253905, Q18'left, Q18'right), to_sfixed(-0.003253145754319, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed( 0.003783310043715, Q18'left, Q18'right), to_sfixed( 0.008044643549467, Q18'left, Q18'right), to_sfixed( 0.012714586504025, Q18'left, Q18'right), to_sfixed( 0.017707898760046, Q18'left, Q18'right), to_sfixed( 0.022925572167622, Q18'left, Q18'right), to_sfixed( 0.028257442299265, Q18'left, Q18'right), to_sfixed( 0.033585272831069, Q18'left, Q18'right), to_sfixed( 0.038786210984937, Q18'left, Q18'right), to_sfixed( 0.043736495520700, Q18'left, Q18'right), to_sfixed( 0.048315286392086, Q18'left, Q18'right), to_sfixed( 0.052408477956454, Q18'left, Q18'right), to_sfixed( 0.055912355944827, Q18'left, Q18'right), to_sfixed( 0.058736962404713, Q18'left, Q18'right), to_sfixed( 0.060809042421414, Q18'left, Q18'right), to_sfixed( 0.062074461253546, Q18'left, Q18'right), to_sfixed( 0.062500000000000, Q18'left, Q18'right), to_sfixed( 0.062074461253546, Q18'left, Q18'right), to_sfixed( 0.060809042421414, Q18'left, Q18'right), to_sfixed( 0.058736962404713, Q18'left, Q18'right), to_sfixed( 0.055912355944827, Q18'left, Q18'right), to_sfixed( 0.052408477956454, Q18'left, Q18'right), to_sfixed( 0.048315286392086, Q18'left, Q18'right), to_sfixed( 0.043736495520700, Q18'left, Q18'right), to_sfixed( 0.038786210984937, Q18'left, Q18'right), to_sfixed( 0.033585272831069, Q18'left, Q18'right), to_sfixed( 0.028257442299265, Q18'left, Q18'right), to_sfixed( 0.022925572167622, Q18'left, Q18'right), to_sfixed( 0.017707898760046, Q18'left, Q18'right), to_sfixed( 0.012714586504025, Q18'left, Q18'right), to_sfixed( 0.008044643549467, Q18'left, Q18'right), to_sfixed( 0.003783310043715, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.003253145754319, Q18'left, Q18'right), to_sfixed(-0.005942063253905, Q18'left, Q18'right), to_sfixed(-0.008050919222966, Q18'left, Q18'right), to_sfixed(-0.009581633925961, Q18'left, Q18'right), to_sfixed(-0.010552815717736, Q18'left, Q18'right), to_sfixed(-0.010998171266272, Q18'left, Q18'right), to_sfixed(-0.010964473380595, Q18'left, Q18'right), to_sfixed(-0.010509182339391, Q18'left, Q18'right), to_sfixed(-0.009697826120807, Q18'left, Q18'right), to_sfixed(-0.008601249731253, Q18'left, Q18'right), to_sfixed(-0.007292843888749, Q18'left, Q18'right), to_sfixed(-0.005845858814512, Q18'left, Q18'right), to_sfixed(-0.004330900201825, Q18'left, Q18'right), to_sfixed(-0.002813692113246, Q18'left, Q18'right), to_sfixed(-0.001353176296439, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed( 0.001204574328861, Q18'left, Q18'right), to_sfixed( 0.002229323194452, Q18'left, Q18'right), to_sfixed( 0.003053284446370, Q18'left, Q18'right), to_sfixed( 0.003665569736097, Q18'left, Q18'right), to_sfixed( 0.004064804333593, Q18'left, Q18'right), to_sfixed( 0.004258244554467, Q18'left, Q18'right), to_sfixed( 0.004260633042833, Q18'left, Q18'right), to_sfixed( 0.004092858914878, Q18'left, Q18'right), to_sfixed( 0.003780493181228, Q18'left, Q18'right), to_sfixed( 0.003352269981135, Q18'left, Q18'right), to_sfixed( 0.002838581176907, Q18'left, Q18'right), to_sfixed( 0.002270046104377, Q18'left, Q18'right), to_sfixed( 0.001676210195279, Q18'left, Q18'right), to_sfixed( 0.001084416303584, Q18'left, Q18'right), to_sfixed( 0.000518881455583, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.000456117651960, Q18'left, Q18'right), to_sfixed(-0.000837872784442, Q18'left, Q18'right), to_sfixed(-0.001138184999508, Q18'left, Q18'right), to_sfixed(-0.001354298943282, Q18'left, Q18'right), to_sfixed(-0.001487419527549, Q18'left, Q18'right), to_sfixed(-0.001542209266509, Q18'left, Q18'right), to_sfixed(-0.001526184553349, Q18'left, Q18'right), to_sfixed(-0.001449048892038, Q18'left, Q18'right), to_sfixed(-0.001322000383148, Q18'left, Q18'right), to_sfixed(-0.001157048331608, Q18'left, Q18'right), to_sfixed(-0.000966369962076, Q18'left, Q18'right), to_sfixed(-0.000761733208870, Q18'left, Q18'right), to_sfixed(-0.000554005738431, Q18'left, Q18'right), to_sfixed(-0.000352764121257, Q18'left, Q18'right), to_sfixed(-0.000166010747395, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed( 0.000140830349878, Q18'left, Q18'right), to_sfixed( 0.000253831354108, Q18'left, Q18'right), to_sfixed( 0.000338031386173, Q18'left, Q18'right), to_sfixed( 0.000393956421716, Q18'left, Q18'right), to_sfixed( 0.000423399318215, Q18'left, Q18'right), to_sfixed( 0.000429155962960, Q18'left, Q18'right), to_sfixed( 0.000414745811064, Q18'left, Q18'right), to_sfixed( 0.000384133107340, Q18'left, Q18'right), to_sfixed( 0.000341463132512, Q18'left, Q18'right), to_sfixed( 0.000290825314666, Q18'left, Q18'right), to_sfixed( 0.000236052193003, Q18'left, Q18'right), to_sfixed( 0.000180560205233, Q18'left, Q18'right), to_sfixed( 0.000127235274775, Q18'left, Q18'right), to_sfixed( 0.000078363362398, Q18'left, Q18'right), to_sfixed( 0.000035603655360, Q18'left, Q18'right), to_sfixed( 0, Q18'left, Q18'right), to_sfixed(-0.000027975389321, Q18'left, Q18'right), to_sfixed(-0.000048352956784, Q18'left, Q18'right), to_sfixed(-0.000061579095308, Q18'left, Q18'right), to_sfixed(-0.000068419246738, Q18'left, Q18'right), to_sfixed(-0.000069857934829, Q18'left, Q18'right), to_sfixed(-0.000067002064768, Q18'left, Q18'right), to_sfixed(-0.000060992757947, Q18'left, Q18'right), to_sfixed(-0.000052929746121, Q18'left, Q18'right), to_sfixed(-0.000043811021434, Q18'left, Q18'right), to_sfixed(-0.000034489118891, Q18'left, Q18'right), to_sfixed(-0.000025644176017, Q18'left, Q18'right), to_sfixed(-0.000017772836299, Q18'left, Q18'right), to_sfixed(-0.000011191187403, Q18'left, Q18'right), to_sfixed(-0.000006049282409, Q18'left, Q18'right), to_sfixed(-0.000002354394734, Q18'left, Q18'right) ) ; signal clock : std_ulogic := '1' ; signal reset : std_ulogic := '1' ; signal in_sample : complex(re(SC16Q12), im(SC16Q12)) ; signal in_valid : std_ulogic := '0' ; signal out_sample : complex(re(SC16Q12), im(SC16Q12)) ; signal out_valid : std_ulogic ; begin clock <= not clock after 1 ns ; U_pfb : entity work.pfb_analysis generic map ( H => PFB_TAPS_T12_N16, N => 16 ) port map ( clock => clock, reset => reset, in_sample => in_sample, in_valid => in_valid, out_sample => out_sample, out_valid => out_valid ) ; tb : process begin print("Starting simulation...") ; reset <= '1' ; in_valid <= '0' ; nop(clock, 100) ; reset <= '0' ; nop(clock, 100) ; in_sample <= to_complex(0.0, 0.0, in_sample) ; in_valid <= '1' ; nop(clock, 16*12*2) ; in_sample <= to_complex(1.0, 1.0, in_sample) ; nop(clock, 16*12*2) ; report to_string(out_sample); assert abs(to_real(out_sample.re) - 0.08447265625) < 0.00001; assert abs(to_real(out_sample.im) - 0.08447265625) < 0.00001; in_sample <= to_complex(0.0, 0.0, in_sample) ; nop(clock, 16*12*2) ; in_valid <= '0' ; report to_string(out_sample); assert out_sample.re = 0.0; assert out_sample.im = 0.0; nop(clock, 10) ; print("Done with simulation") ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue815.vhd000066400000000000000000000014531504111170000172640ustar00rootroot00000000000000package bar is function gen_baz(l: positive) return bit_vector; end; package body bar is function gen_baz(l: positive) return bit_vector is begin return 10X"240"; end; end; package qux is generic ( X: positive; BAZ: bit_vector := work.bar.gen_baz(X) ); subtype baz_t is bit_vector(BAZ'high downto BAZ'low); function get_qux(state: baz_t) return baz_t; end; package body qux is function get_qux(state: baz_t) return baz_t is begin return 10D"501"; end; end; entity issue815 is end; architecture test of issue815 is package pkg is new work.qux generic map (X => 10); signal s0: pkg.baz_t; begin process begin s0 <= pkg.baz_t'value(10D"500"); wait for 0 ns; assert s0 = "0111110100"; s0 <= pkg.get_qux(s0); wait for 0 ns; assert s0 = "0111110101"; wait; end process; end; nvc-r1.17.1/test/regress/issue816.vhd000066400000000000000000000020221504111170000172560ustar00rootroot00000000000000entity \foo\ is port ( x : out integer ); end entity; architecture \test\ of \foo\ is begin x <= 1; end architecture; ------------------------------------------------------------------------------- entity \Foo\ is port ( x : out integer ); end entity; architecture \test\ of \Foo\ is begin x <= 2; end architecture; ------------------------------------------------------------------------------- entity issue816 is end entity; architecture test of issue816 is signal a, b : integer; begin u1: entity work.\foo\ port map ( a ); u2: entity work.\Foo\ port map ( b ); check: process is begin wait for 1 ns; assert a = 1 severity failure; assert b = 2 severity failure; wait for 1 ns; -- Make this test fail so that run_regr does analysis/elaboration and -- execution in two separate processes, causing the library units to be -- re-read from disk report "passed" severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue819.vhd000066400000000000000000000022601504111170000172650ustar00rootroot00000000000000package my_logic is type std_ulogic is ('U', '0', '1', 'X'); type std_ulogic_vector is array (natural range <>) of std_ulogic; type unsigned is array (natural range <>) of std_ulogic; type signed is array (natural range <>) of std_ulogic; end package; library ieee; use work.my_logic.all; package uCPUtypes is alias logic is std_ulogic; alias logic_vec is std_ulogic_vector; subtype unsigned_byte is unsigned(7 downto 0); subtype code_word is unsigned(11 downto 0); end package uCPUtypes; ------------------------------------------------------------------------------- library ieee; use work.uCPUtypes.all; use work.my_logic.all; entity issue819 is end entity; architecture test of issue819 is signal rom_data : code_word; alias op : unsigned(2 downto 0) is rom_data(11 downto 9); -- opcode signal alu_arg, alu_res : unsigned_byte; signal alu_c : logic; begin with op(1 downto 0) select (alu_c, alu_res) <= '0' & alu_arg when "00", ('X', x"XX") when others; check: process is begin wait for 1 ns; assert alu_c = 'X'; assert alu_res = X"XX"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue82.vhd000066400000000000000000000013431504111170000171760ustar00rootroot00000000000000package nested_pkg is procedure parent_proc(signal sig : out integer; var : inout integer); end package; package body nested_pkg is procedure parent_proc(signal sig : out integer; var : inout integer) is procedure nested_proc is begin assert var /= 4; sig <= var; var := 4; end procedure; begin nested_proc; end procedure; end package body; entity issue82 is end entity; use work.nested_pkg.all; architecture test of issue82 is signal s : integer; begin process is variable v : integer := 2; begin parent_proc(s, v); wait for 1 ns; assert v = 4; assert s = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue820.vhd000066400000000000000000000051441504111170000172610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue820 is generic ( G_NUM_ARR : integer := 4; G_WIDTH : integer := 4*8 ); port ( clk : in std_logic; o_dout : out std_logic_vector(G_WIDTH-1 downto 0) := (others => '0') ); end issue820; architecture rtl of issue820 is type t_arr_property is array (natural range<>) of natural; function num_arr (g_num_arr : natural) return t_arr_property is variable width_arr : t_arr_property(0 to g_num_arr-1) := (others => 8); begin return(width_arr); end function; function f_bit_low (width_arr : t_arr_property) return t_arr_property is variable arr_bit_low : t_arr_property(width_arr'range) := (others => 0); begin for i in width_arr'range loop if(i=0) then arr_bit_low(i) := 0; else arr_bit_low(i) := arr_bit_low(i-1) + width_arr(i-1); end if; end loop; return(arr_bit_low); end function; function f_bit_high (width_arr : t_arr_property) return t_arr_property is variable arr_bit_high : t_arr_property(width_arr'range) := (others => 0); begin for i in width_arr'range loop if(i=0) then arr_bit_high(i) := -1 + width_arr(i); else arr_bit_high(i) := arr_bit_high(i-1) + width_arr(i); end if; end loop; -- return(arr_bit_high); end function; constant C_WIDTH_ARR : t_arr_property := num_arr(G_NUM_ARR); constant C_BIT_LOW : t_arr_property := f_bit_low(C_WIDTH_ARR); constant C_BIT_HIGH : t_arr_property := f_bit_high(C_WIDTH_ARR); signal s_clk : std_logic := '0'; signal s_dout, s_dout2 : std_logic_vector(G_WIDTH-1 downto 0); begin p_clk: process begin wait for 100 ns; s_clk <= '1'; wait for 100 ns; assert s_dout = X"01010101"; assert s_dout2 = X"01010101"; s_clk <= '0'; wait for 100 ns; s_clk <= '1'; wait for 100 ns; assert s_dout = X"02020202"; assert s_dout2 = X"02020202"; s_clk <= '0'; wait; end process; gen_arr: for i in 0 to G_NUM_ARR-1 generate signal data : unsigned(C_WIDTH_ARR(i)-1 downto 0) := (others => '0'); begin p_dummy: process(s_clk) begin if (rising_edge(s_clk)) then data <= data + 1; end if; end process; -- gen_reg: if(True) generate s_dout(C_BIT_HIGH(i) downto C_BIT_LOW(i)) <= std_logic_vector(data); s_dout2(C_BIT_HIGH(i to i)(i) downto C_BIT_LOW(i to i)(i)) <= std_logic_vector(data); end generate; end generate gen_arr; o_dout <= s_dout; end architecture rtl; nvc-r1.17.1/test/regress/issue824.vhd000066400000000000000000000012251504111170000172610ustar00rootroot00000000000000entity issue824 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue824 is type t_rec is record x, y : std_logic; end record; procedure update (signal r : inout t_rec) is begin r.y <= '1'; end procedure; signal s : t_rec := ('Z', 'Z'); begin p1: process is begin --s.x <= 'Z'; wait for 1 ns; update(s); wait for 1 ns; assert s.x = 'Z'; assert s.y = '1'; wait; end process; b1: block is port ( o : out t_rec ); port map ( s ); begin o <= ('Z', 'Z'); end block; end architecture; nvc-r1.17.1/test/regress/issue825.vhd000066400000000000000000000010171504111170000172610ustar00rootroot00000000000000entity issue825 is end entity; architecture test of issue825 is signal s : bit_vector(1 to 3); signal i : integer range 1 to 3; begin p1: s <= (1 to i => '1') & (i + 1 to 3 => '0'); p2: process is begin assert s = "000"; wait for 0 ns; assert s = "100"; i <= 2; wait for 0 ns; wait for 0 ns; assert s = "110"; i <= 3; wait for 0 ns; wait for 0 ns; assert s = "111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue826.vhd000066400000000000000000000052661504111170000172740ustar00rootroot00000000000000library IEEE ; use ieee.std_logic_1164.all ; use ieee.numeric_std.all ; entity issue826 is end entity ; architecture test of issue826 is constant ZERO : std_logic_vector(7 downto 0) := X"00" ; constant ZERO_UV : unsigned(0 to 7) := X"00" ; begin TestProc : process variable SLV : std_logic_vector(7 downto 0) ; variable SLVR : std_logic_vector(0 to 7) ; variable UV : unsigned(0 to 7) ; variable SL : std_logic ; begin SLV := (others => '0') ; assert SLV = X"00" report to_hstring(SLV); SLV := (7 downto 0 => '0') ; assert SLV = X"00" report to_hstring(SLV); SLV := ('0','0','0','0','0','0','0','0') ; assert SLV = X"00" report to_hstring(SLV); SLV := ((7|6 =>'0', 5 downto 0 =>'0')) ; assert SLV = X"00" report to_hstring(SLV); SLV := (7|6 =>'1', 5 downto 0 =>'0') ; assert SLV = X"C0" report to_hstring(SLV); SLV := (0 to 5 =>'0', 6 =>'1', 7 =>'1') ; assert SLV = X"C0" report to_hstring(SLV); SLVR := (7|6 =>'1', 5 downto 0 =>'0') ; assert SLVR = X"03" report to_hstring(SLV); SLVR := (0 to 5 =>'0', 6 =>'1', 7 =>'1') ; assert SLVR = X"03" report to_hstring(SLV); SLV := not((0 to 5 =>'0', 6 =>'1', 7 =>'1')) ; assert SLV = X"FC" report to_hstring(SLV); UV := not((0 to 5 =>'0', 6 =>'1', 7 =>'1')) ; assert SLV = X"FC" report to_hstring(SLV); SLV := not((7 =>'1', 6 =>'1', 5 downto 0 =>'0')) ; assert SLV = X"FC" report to_hstring(SLV); UV := not((7 =>'1', 6 =>'1', 5 downto 0 =>'0')) ; assert SLV = X"FC" report to_hstring(SLV); SLV := ZERO or (7|6 =>'1', 5 downto 0 =>'0') ; assert SLV = X"03" report to_hstring(SLV); SLV := ZERO or (0 to 5 =>'0', 6 =>'1', 7 =>'1') ; assert SLV = X"03" report to_hstring(SLV); SLV := (0 to 5 =>'0', 6 =>'1', 7 =>'1') or ZERO ; assert SLV = X"03" report to_hstring(SLV); UV := ZERO_UV or (7|6 =>'1', 5 downto 0 =>'0') ; assert UV = X"03" report to_hstring(SLV); UV := ZERO_UV or (0 to 5 =>'0', 6 =>'1', 7 =>'1') ; assert UV = X"03" report to_hstring(SLV); UV := (0 to 5 =>'0', 6 =>'1', 7 =>'1') or ZERO_UV ; assert UV = X"03" report to_hstring(SLV); UV := ZERO_UV + (7|6 =>'1', 5 downto 0 =>'0') ; assert UV = X"03" report to_hstring(SLV); UV := ZERO_UV + (0 to 5 =>'0', 6 =>'1', 7 =>'1') ; assert UV = X"03" report to_hstring(SLV); UV := (0 to 5 =>'0', 6 =>'1', 7 =>'1') + ZERO_UV ; assert UV = X"03" report to_hstring(SLV); SL := "not"(not(std_logic_vector'(0 to 5 =>'0', 6 =>'1', 7 =>'1')))(7) ; assert SL = '1'; SL := "not"(not(unsigned'(0 to 5 =>'0', 6 =>'1', 7 =>'1')))(7) ; assert SL = '0'; wait ; end process TestProc ; end architecture test ; nvc-r1.17.1/test/regress/issue827.vhd000066400000000000000000000013711504111170000172660ustar00rootroot00000000000000library IEEE ; use ieee.std_logic_1164.all ; use ieee.numeric_std.all ; entity issue827 is end entity issue827 ; architecture test of issue827 is begin TestProc : process variable SLV : std_logic_vector(7 downto 0) ; variable UV : unsigned(0 to 7) ; variable SL : std_logic ; type t_byte_array is array (natural range <>) of std_logic_vector(7 downto 0); variable ba : t_byte_array(2 downto 0); begin SLV := (3 downto 0 => X"C", others => '0') ; assert SLV = X"0C" report to_hstring(SLV); SLV := (7 downto 4 => '0') & X"C" ; assert SLV = X"0C" report to_hstring(SLV); SLV := (4 to 7 => '0') & X"C" ; assert SLV = X"0C" report to_hstring(SLV); wait ; end process TestProc ; end architecture test ; nvc-r1.17.1/test/regress/issue829.vhd000066400000000000000000000017071504111170000172730ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue829 is end entity; architecture sim of issue829 is signal a : std_logic bus; disconnect a : std_logic after 5 ns; signal b : boolean; signal c : std_logic := '1'; begin c <= not c after 5 ns when now < 30 ns; BL : block (b) is begin a <= guarded c; end block; process begin assert a = 'U'; wait for 0 ns; assert a = 'U'; wait for 5 ns; assert a = 'Z'; wait for 10 ns; assert a = 'Z'; b <= true; wait for 0 ns; assert a = 'Z'; wait for 5 ns; assert a = '0'; wait for 5 ns; assert a = '1'; wait for 5 ns; assert a = '0'; wait for 10 ns; b <= false; assert a = '1'; wait for 0 ns; assert a = '1'; wait for 5 ns; assert a = 'Z'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue83.vhd000066400000000000000000000007021504111170000171750ustar00rootroot00000000000000 entity read_output is port ( output1, output2 : out integer); end entity; architecture a of read_output is begin output1 <= 5; output2 <= output1 after 1 ns; end architecture; ------------------------------------------------------------------------------- entity issue83 is end entity; architecture test of issue83 is signal x, y : integer; begin sub: entity work.read_output port map ( x, y ); end architecture; nvc-r1.17.1/test/regress/issue831.vhd000066400000000000000000000060611504111170000172620ustar00rootroot00000000000000-- fft_types -------------------------------------------------------------------------- library ieee; use ieee.math_complex.all; use std.textio.all; package fft_types is subtype fft_data_type is complex; type fft_data_vector is array (natural range <>) of fft_data_type; pure function "+" (a, b : fft_data_vector) return fft_data_vector; pure function "*" (a, b : fft_data_vector) return fft_data_vector; end package fft_types; package body fft_types is pure function "+" (a, b : fft_data_vector) return fft_data_vector is variable res : fft_data_vector (a'range); begin for i in a'range loop res(i) := a(i) + b(i); end loop; return res; end function; pure function "*" (a, b : fft_data_vector) return fft_data_vector is variable res : fft_data_vector (a'range); begin for i in a'range loop res(i) := a(i) * b(i); end loop; return res; end function; end package body fft_types; -- fft -------------------------------------------------------------------------------- library ieee; use ieee.math_complex.all; use work.fft_types.all; entity fft is generic ( POW : natural := 4; DIM : positive := 2**POW); port ( x, w : in fft_data_vector (0 to DIM-1); y : out fft_data_vector (0 to DIM-1) := (others => fft_data_type'(0.0,0.0))); end entity fft; architecture recursive of fft is subtype half_array is fft_data_vector (0 to DIM/2-1); signal even, odd, x_e, x_o, w_e : half_array := (others => fft_data_type'(0.0,0.0)); alias w_b : half_array is w(0 to DIM/2-1); alias w_t : half_array is w(DIM/2 to DIM-1); begin stage : if base_case: POW = 1 generate y(0) <= x(0) + x(1); y(1) <= x(0) - x(1); else general_case: generate split_even_odd : for i in half_array'range generate x_e(i) <= x(2*i); x_o(i) <= x(2*i+1); w_e(i) <= w(2*i); end generate; even_fft : entity fft generic map ( POW => POW-1) port map ( x => x_e, w => w_e, y => even); odd_fft : entity fft generic map ( POW => POW-1) port map ( x => x_o, w => w_e, y => odd); y(0 to DIM/2-1) <= even + odd*w_b; y(DIM/2 to DIM-1) <= even + odd*w_t; end generate stage; end architecture recursive; ------------------------------------------------------------------------------- use work.fft_types.all; entity issue831 is generic ( POW : natural := 4; DIM : positive := 2**POW); end entity; architecture test of issue831 is signal x, w, y : fft_data_vector(0 to DIM-1) := (others => (others => 0.0)); begin u: entity work.fft port map ( x, w, y ); check: process is begin x <= (others => fft_data_type'(0.0,0.0)); w <= (others => fft_data_type'(0.0,0.0)); wait for 1 ns; assert y(0).re = 0.0 report to_string(y(0).re); x <= (others => fft_data_type'(1.0,0.0)); w <= (others => fft_data_type'(0.0,1.0)); wait for 1 ns; assert y(0).re = -4.0 report to_string(y(0).re); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue839.vhd000066400000000000000000000010021504111170000172600ustar00rootroot00000000000000entity issue839 is end entity; architecture test of issue839 is type t_rec is record f : integer; end record; type t_array is array (natural range <>) of t_rec; subtype t_sub is t_array; signal s : t_sub(1 to 2); begin check: process is begin -- This would call the wrong helper function assert s = (1 to 2 => (f => integer'left)); s(2).f <= 6; wait for 0 ns; assert s(2) = (f => 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue84.vhd000066400000000000000000000015211504111170000171760ustar00rootroot00000000000000package sem_copy_default_args_bug is type protected_t is protected procedure procedure1(argument : inout boolean); end protected protected_t; end package; package body sem_copy_default_args_bug is type protected_t is protected body procedure procedure2(argument : inout boolean) is begin assert argument; argument := false; end procedure; procedure procedure1(argument : inout boolean) is begin procedure2(argument); end procedure; end protected body; end package body; entity issue84 is end entity; use work.sem_copy_default_args_bug.all; architecture test of issue84 is shared variable v : protected_t; begin process is variable x : boolean; begin x := true; v.procedure1(x); assert not x; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue840.vhd000066400000000000000000000007211504111170000172570ustar00rootroot00000000000000entity issue840 is end entity; architecture test of issue840 is type t_array2d is array (natural range <>, natural range <>) of bit; subtype t_sub is t_array2d(1 to 3, 1 to 3); signal s : t_sub; signal t : integer; begin process is begin s <= ("101", "110", "111"); t <= 1; wait for 1 ns; s <= ("110", "000", "101"); t <= 2; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue842.vhd000066400000000000000000000005601504111170000172620ustar00rootroot00000000000000entity issue842 is end entity; architecture beh of issue842 is constant C_SCOPE : string := "something"; begin p_proc : process constant C_TIME : time := 1 ms; begin report string'("Test " & to_string(C_TIME, ms), C_SCOPE); assert string'("Test " & to_string(C_TIME, ms), C_SCOPE) = "Test 1 mssomething"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue843.vhd000066400000000000000000000102011504111170000172540ustar00rootroot00000000000000library ieee; use ieee.math_real.all; use ieee.float_pkg.all; package fft_pkg is subtype num_type is float32; type data_type is record re, im : num_type; end record; type data_vector is array (natural range <>) of data_type; function "+" (a, b : data_type) return data_type; function "*" (a, b : data_type) return data_type; function even_elem(x : data_vector) return data_vector; function odd_elem(x : data_vector) return data_vector; function weight(n : positive) return data_vector; end package fft_pkg; package body fft_pkg is function "+" (a, b : data_type) return data_type is begin return data_type'(a.re + b.re, a.im + b.im); end function; function "*" (a, b : data_type) return data_type is begin return data_type'(a.re*b.re - a.im*b.im, a.re*b.im + a.im*b.re); end function; function even_elem(x : data_vector) return data_vector is variable res : data_vector (0 to x'length/2-1); begin for i in res'range loop res(i) := x(2*i); end loop; return res; end function; function odd_elem(x : data_vector) return data_vector is variable res : data_vector (0 to x'length/2-1); begin for i in res'range loop res(i) := x(2*i+1); end loop; return res; end function; function weight(n : positive) return data_vector is variable w : data_vector (0 to n-1); variable omega : real; begin omega := math_2_pi/real(n); for k in w'range loop w(k) := data_type'(to_float(cos(omega*real(k))), to_float(-sin(omega*real(k)))); end loop; return w; end function; end package body fft_pkg; library ieee; use ieee.float_pkg.all; use work.fft_pkg.all; entity fft is generic ( POW : natural; DIM : positive := 2**POW; w: data_vector (0 to DIM-1) := weight(DIM)); port ( x : in data_vector (0 to DIM-1); y : out data_vector (0 to DIM-1)); end entity fft; architecture recursive of fft is begin stage_n : if POW > 0 generate subtype half_array is data_vector (0 to DIM/2-1); signal even, odd : half_array; alias w_b : half_array is w(0 to DIM/2-1); alias w_t : half_array is w(DIM/2 to DIM-1); begin even_fft : entity fft generic map ( POW => POW-1, w => even_elem(w)) port map ( x => even_elem(x), y => even); odd_fft : entity fft generic map ( POW => POW-1, w => even_elem(w)) port map ( x => odd_elem(x), y => odd); butterfly : process (all) is begin for i in half_array'range loop y(i) <= even(i) + odd(i) * w_b(i); y(i+DIM/2) <= even(i) + odd(i) * w_t(i); end loop; end process; end generate stage_n; stage_0 : if POW = 0 generate y <= x; end generate stage_0; end architecture recursive; library ieee; use ieee.math_real.all; use ieee.math_complex.all; use ieee.fixed_float_types.all; use ieee.float_pkg.all; use work.fft_pkg.all; entity issue843 is end entity issue843; architecture test of issue843 is constant POW : natural := 2; constant DIM : positive := 2**POW; signal x, y : data_vector (0 to DIM-1) := (others => data_type'(to_float(0.0), to_float(0.0))); type complex_vector is array (0 to DIM-1) of complex; constant stimul : complex_vector := ((0.0, 0.0), ( 1.0, 1.0), ( 2.0, 2.0), (3.0, 3.0)); constant result : complex_vector := ((6.0, 6.0), (-4.0, 0.0), (-2.0, -2.0), (0.0, -4.0)); constant abstol : real := 1.0e-6; begin fft_inst : entity work.fft(recursive) generic map (POW => POW) port map (x => x, y => y); test_proc : process is alias s is to_string [integer return string]; alias s is to_string [real return string]; begin for i in x'range loop x(i) <= data_type'(to_float(stimul(i).re), to_float(stimul(i).im)); end loop; wait for 1 ps; for i in y'range loop assert abs(to_real(y(i).re) - result(i).re) < abstol and abs(to_real(y(i).im) - result(i).im) < abstol report "Inconsistent result detected: y(" & s(i) & ") = (" & s(to_real(y(i).re)) & "," & s(to_real(y(i).im)) & ")" severity failure; end loop; wait; end process; end architecture test; nvc-r1.17.1/test/regress/issue844.vhd000066400000000000000000000010361504111170000172630ustar00rootroot00000000000000entity issue844 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of issue844 is signal s : std_logic_vector(127 downto 0); signal o : std_logic; begin ogen: with unsigned(s) select o <= '1' when to_unsigned(42, 128), '0' when others; check: process is begin assert o = 'U'; wait for 0 ns; assert o = '0'; s <= 128D"42"; wait for 1 ns; assert o = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue850.sh000066400000000000000000000004451504111170000171140ustar00rootroot00000000000000set -xe pwd which nvc nvc -a - -e issue850 <) of bit_vector(31 downto 0); type mock_completer_t is record -- Configuration elements prefix : string; -- Optional prefix used in report messages. -- Internal elements memory : data_array_t; -- Statistics elements read_count : natural; -- Number of read transfers. write_count : natural; -- Number of write transfers. end record; function init (memory_size: natural; prefix: string := "apb: mock completer: ") return mock_completer_t is variable mc : mock_completer_t(prefix(1 to prefix'length), memory(0 to memory_size - 1)); begin mc.prefix := prefix; return mc; end function; signal mc : mock_completer_t := init(memory_size => 8); begin mc.memory(4) <= X"deadbeef" after 2 ns; mc.memory(7) <= X"cafebabe" after 5 ns; end architecture; nvc-r1.17.1/test/regress/issue854.vhd000066400000000000000000000014701504111170000172660ustar00rootroot00000000000000entity issue854 is end entity; architecture test of issue854 is type t_rec1 is record f : integer; end record; type t_rec2 is record a : integer; b : t_rec1; end record; view t_rec2_view of t_rec2 is a : in; b : out; end view; signal s1, s2 : t_rec2; begin b1: block is port ( p : view t_rec2_view); port map ( s1 ); begin p.b.f <= p.a + 1; end block; b2: block is port ( p : view t_rec2_view'converse); port map ( s2 ); begin p.a <= p.b.f * 2; end block; check: process is begin s1.a <= 1; s2.b.f <= 5; wait for 0 ns; wait for 0 ns; assert s1.b.f = 2; assert s2.a = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue856.vhd000066400000000000000000000024131504111170000172660ustar00rootroot00000000000000entity issue856 is end entity; architecture test of issue856 is type t_point is record x, y : integer; end record; type t_point_array is array (natural range <>) of t_point; type t_rec is record f : t_point_array(1 to 3); g : natural; end record; view t_rec_in of t_rec is f : in; g : out; end view; alias t_rec_out is t_rec_in'converse; type t_rec_array is array (natural range <>) of t_rec; procedure do_write (signal s : view t_rec_out) is begin for i in s.f'range loop s.f(i) <= (i*2, i*2 + 1); end loop; end procedure; signal s : t_rec; begin p1: process is begin do_write(s); wait for 1 ns; assert s.g = 27; wait; end process; b: block is port ( p : view (t_rec_in) of t_rec_array ); port map ( p(1) => s ); begin g: for i in p'range generate p2: process (all) variable sum : integer := 0; begin for j in p(i).f'range loop sum := sum + p(i).f(j).x + p(i).f(j).y; end loop; p(i).g <= sum; end process; end generate; end block; end architecture; nvc-r1.17.1/test/regress/issue858.vhd000066400000000000000000000113211504111170000172660ustar00rootroot00000000000000package generic_queue_pkg is generic(type t_generic_element; GC_QUEUE_COUNT_MAX : natural := 1000; GC_QUEUE_COUNT_THRESHOLD : natural := 950); type t_generic_queue is protected procedure add( constant instance : in integer; constant element : in t_generic_element); procedure add( constant element : in t_generic_element); end protected; end package generic_queue_pkg; package body generic_queue_pkg is type t_generic_queue is protected body variable vr_num_elements_in_queue : integer_vector(0 to 1) := (others => 0); variable vr_queue_count_max : integer_vector(0 to 1) := (others => GC_QUEUE_COUNT_MAX); procedure add( constant instance : in integer; constant element : in t_generic_element ) is begin assert vr_num_elements_in_queue(instance) < vr_queue_count_max(instance); end procedure; procedure add( constant element : in t_generic_element ) is begin add(1, element); end procedure; end protected body; end package body generic_queue_pkg; ------------------------------------------------------------------------------- package generic_sb_support_pkg is type t_sb_config is record allow_lossy : boolean; allow_out_of_order : boolean; overdue_check_time_limit : time; ignore_initial_garbage : boolean; end record; type t_sb_config_array is array (integer range <>) of t_sb_config; constant C_SB_CONFIG_DEFAULT : t_sb_config := (allow_lossy => false, allow_out_of_order => false, overdue_check_time_limit => 0 ns, ignore_initial_garbage => false); end package generic_sb_support_pkg; package body generic_sb_support_pkg is end package body generic_sb_support_pkg; ------------------------------------------------------------------------------- use work.generic_sb_support_pkg.all; package generic_sb_pkg is generic(type t_element; constant sb_config_default : t_sb_config := C_SB_CONFIG_DEFAULT; constant GC_QUEUE_COUNT_MAX : natural := 1000; constant GC_QUEUE_COUNT_THRESHOLD : natural := 950); type t_generic_sb is protected procedure add_expected( constant instance : in integer; constant expected_element : in t_element; constant tag : in string); procedure add_expected( constant expected_element : in t_element; constant tag : in string); end protected t_generic_sb; end package generic_sb_pkg; package body generic_sb_pkg is type t_sb_entry is record expected_element : t_element; source : string(1 to 5); tag : string(1 to 5); entry_time : time; end record; package sb_queue_pkg is new work.generic_queue_pkg generic map( t_generic_element => t_sb_entry, GC_QUEUE_COUNT_MAX => GC_QUEUE_COUNT_MAX, GC_QUEUE_COUNT_THRESHOLD => GC_QUEUE_COUNT_THRESHOLD); use sb_queue_pkg.all; type t_generic_sb is protected body variable vr_sb_queue : sb_queue_pkg.t_generic_queue; procedure add_expected( constant instance : in integer; constant expected_element : in t_element; constant tag : in string ) is variable v_sb_entry : t_sb_entry; begin vr_sb_queue.add(0, v_sb_entry); end procedure add_expected; procedure add_expected( constant expected_element : in t_element; constant tag : in string ) is begin add_expected(1, expected_element, tag); end procedure add_expected; end protected body; end package body generic_sb_pkg; ------------------------------------------------------------------------------- use work.generic_sb_support_pkg.all; entity issue858 is end entity; architecture tb of issue858 is constant C_SLV_SB_CONFIG_DEFAULT : t_sb_config := (allow_lossy => false, allow_out_of_order => false, overdue_check_time_limit => 0 ns, ignore_initial_garbage => false); package slv_sb_pkg is new work.generic_sb_pkg generic map(t_element => bit_vector(7 downto 0), sb_config_default => C_SLV_SB_CONFIG_DEFAULT); use slv_sb_pkg.all; shared variable sb_under_test : slv_sb_pkg.t_generic_sb; begin p_main: process begin sb_under_test.add_expected(X"01", "tag added"); wait; end process p_main; end architecture; nvc-r1.17.1/test/regress/issue86.vhd000066400000000000000000000013531504111170000172030ustar00rootroot00000000000000entity issue86 is end entity; architecture test of issue86 is type integer_vector is array (natural range <>) of integer; subtype ElementType is integer ; subtype ArrayofElementType is integer_vector; function inside0 (constant E : ElementType; constant A : in ArrayofElementType) return boolean is begin for i in A'range loop if E = A(i) then return TRUE; end if ; end loop ; return FALSE ; end function inside0; begin process is variable a : ArrayofElementType(1 to 5); begin a(3) := 2; assert not inside0(3, a); assert inside0(2, a); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue862.vhd000066400000000000000000000016571504111170000172740ustar00rootroot00000000000000entity issue862 is end entity ; architecture arch of issue862 is type bv_2d is array(integer range <>, integer range <>) of bit_vector ; constant ROWS : positive := 1 ; constant COLS : positive := 2 ; -- Assume first index is rows, next index is columns signal a : bv_2d(0 to 10, 0 to 10)(9 downto 0) ; procedure print(x : in string) is variable l : std.textio.line ; begin std.textio.write(l, x) ; std.textio.writeline(std.textio.output, l) ; end procedure ; procedure print(name : in string ; x : in bv_2d) is begin print( name & " is matrix " & integer'image(x'length(ROWS)) & " rows and " & integer'image(x'length(COLS)) & " with elements of length " & integer'image(x'element'length) ) ; end procedure ; begin tb : process begin print("a", a) ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue873.vhd000066400000000000000000000024731504111170000172730ustar00rootroot00000000000000entity ent is generic ( DWIDTH : natural := 4; OFFSET : natural := 10 ); port ( enable : in bit; in_data : in bit_vector(DWIDTH+OFFSET-1 downto OFFSET); out_data : out bit_vector(DWIDTH+OFFSET-1 downto OFFSET) ); end entity; architecture arch of ent is function apply_enable(data : bit_vector; en : bit) return bit_vector is variable mask : bit_vector(data'range); variable data_masked : bit_vector(data'range); begin mask := (data'length-1 downto 0 => en); data_masked := data and mask; return data_masked; end function; begin out_data <= apply_enable(in_data, enable); end architecture arch; ------------------------------------------------------------------------------- entity issue873 is end entity; architecture test of issue873 is signal enable : bit; signal in_data : bit_vector(3 downto 0); signal out_data : bit_vector(3 downto 0); begin uut: entity work.ent port map (enable, in_data, out_data); check: process is begin wait for 0 ns; assert out_data = "0000"; in_data <= "1010"; enable <= '1'; wait for 1 ns; assert out_data = "1010"; enable <= '0'; wait for 1 ns; assert out_data = "0000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue874.vhd000066400000000000000000000013051504111170000172650ustar00rootroot00000000000000entity issue874 is end entity; architecture arch of issue874 is constant A : natural := 15; constant B : natural := A-1; type array1 is array (0 to 3) of bit_vector(A-1 downto 0); signal s1 : array1 := (others => (others => '0')); type array2 is array (0 to 3) of bit_vector; signal s2 : array2(open)(B downto 0) := (others => (others => '0')); begin process begin assert s1 = (0 to 3 => (14 downto 0 => '0')); -- Crash assert s1 = (0 to 3 => (B downto 0 => '0')); -- Crash assert s1 = (0 to 3 => (A-1 downto 0 => '0')); -- Crash assert s2 = (0 to 3 => (A-1 downto 0 => '0')); -- Crash wait; end process; end architecture arch; nvc-r1.17.1/test/regress/issue877.vhd000066400000000000000000000015651504111170000173000ustar00rootroot00000000000000entity sub is port ( o : out natural ); end entity; architecture test of sub is signal s : natural; begin o <= s + 1 after 1 ns; end architecture; ------------------------------------------------------------------------------- entity issue877 is end entity; architecture test of issue877 is signal x : natural; begin uut: entity work.sub port map ( x ); update: process (all) is alias s is << signal uut.s : natural >>; begin if x = 10 then s <= release; else s <= force x; end if; end process; check: process is begin wait for 1 ns; assert x = 1; wait for 1 ns; assert x = 2; wait for 8 ns; assert x = 10; wait for 1 ns; assert x = 1; std.env.finish; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue878.vhd000066400000000000000000000007621504111170000172770ustar00rootroot00000000000000entity issue878 is end entity; architecture test of issue878 is type t_rec is record x, y : natural; end record; type t_rec_array is array (natural range <>) of t_rec; type t_rec_array_array is array (natural range <>) of t_rec_array; signal s : t_rec_array_array(1 to 3)(1 to 2); begin stim: process is begin wait for 1 ns; s(2)(1) <= (1, 2); wait for 2 ns; s(3)(2).x <= 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue881.vhd000066400000000000000000000060101504111170000172610ustar00rootroot00000000000000package generic_complex is generic ( type t ; -- default subprograms function "+"(l, r : t) return t is <> ; function to_string(x : t) return string is <> ) ; -- cute way of making an array of type t with indices for re and im parts type complex_parts is (re, im) ; type complex is array(complex_parts) of t ; -- complex summing operation function "+"(l, r : complex) return complex ; -- string representation function to_string(x : complex) return string ; end package ; package body generic_complex is function "+"(l, r : complex) return complex is begin return (re => l(re)+r(re), im => l(im)+r(im)) ; end function ; function to_string(x : complex) return string is begin return "(" & to_string(x(re)) & "," & to_string(x(im)) & ")" ; end function ; end package body ; entity pipelined_complex_sum is generic ( package complex_pkg is new work.generic_complex generic map(<>) ) ; port ( clock : in bit ; a : in complex_pkg.complex ; b : in complex_pkg.complex ; c : out complex_pkg.complex ) ; end entity ; architecture arch of pipelined_complex_sum is use complex_pkg.all ; begin process(clock) begin if( rising_edge(clock) ) then c <= a + b ; end if ; end process ; end architecture ; -- create the two different complex packages package complex_int is new work.generic_complex generic map (t => integer) ; package complex_real is new work.generic_complex generic map (t => real) ; use work.complex_real.all ; use work.complex_int.all ; entity issue881 is end entity ; architecture arch of issue881 is -- signals for real summer signal ar : work.complex_real.complex ; signal br : work.complex_real.complex ; signal cr : work.complex_real.complex ; -- signals for int summer signal ai : work.complex_int.complex ; signal bi : work.complex_int.complex ; signal ci : work.complex_int.complex ; -- clock signal clock : bit ; begin clock <= not clock after 1 ns ; U_real_summer : entity work.pipelined_complex_sum generic map ( complex_pkg => work.complex_real ) port map ( clock => clock, a => ar, b => br, c => cr ) ; U_int_summer : entity work.pipelined_complex_sum generic map ( complex_pkg => work.complex_int ) port map ( clock => clock, a => ai, b => bi, c => ci ) ; tb : process variable val : work.complex_int.complex ; begin for i in 1 to 10 loop val := (i, 42*i) ; ai <= val ; ar <= (real(val(re)), real(val(im))) ; val := (-7*i, 100*i) ; bi <= val ; br <= (real(val(re)), real(val(im))) ; wait until rising_edge(clock) ; end loop ; assert ci = (-54, 1278); std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue884.vhd000066400000000000000000000010201504111170000172600ustar00rootroot00000000000000entity sub is end entity; architecture test of sub is signal x : integer; begin check: process is begin wait for 1 ns; assert x = 42; wait; end process; end architecture; entity issue884 is end entity; architecture test of issue884 is begin uut: entity work.sub; stim: process is procedure proc is begin << signal .issue884.uut.x : integer >> <= 42; end procedure; begin proc; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue885.vhd000066400000000000000000000021671504111170000172760ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity first is port ( a : in std_logic_vector(1 downto 0); b : out std_logic_vector(1 downto 0) ); end entity; architecture rtl of first is signal c : std_logic; begin b <= a; c <= a(0); end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity second is port ( a : in std_logic_vector(1 downto 0); b : out std_logic_vector(1 downto 0) := "00" ); end entity; architecture rtl of second is begin b <= a; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity issue885 is end entity; architecture arch of issue885 is signal b : std_logic_vector(1 downto 0); signal a : std_logic_vector(1 downto 0); begin first : entity work.first(rtl) port map( b => b, a => a ); second : entity work.second(rtl) port map( a => b, b => a ); end architecture; nvc-r1.17.1/test/regress/issue887.vhd000066400000000000000000000013751504111170000173000ustar00rootroot00000000000000entity issue887 is end entity; architecture test of issue887 is function CalcPercentCov( Count : integer ; AtLeast : integer ) return real is variable PercentCov : real ; begin if AtLeast > 0 then return real(Count)*100.0/real(AtLeast) ; elsif AtLeast = 0 then return 100.0 ; else return real'right ; end if ; end function CalcPercentCov ; begin check: process is variable sum : real := 0.0; begin -- Run enough times for JIT to kick in for i in 1 to 1000 loop sum := sum + CalcPercentCov(i, 100); end loop; report real'image(sum); assert sum = 500500.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue890.vhd000066400000000000000000000015521504111170000172670ustar00rootroot00000000000000entity issue890 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue890 is constant A : std_logic_vector(1 to 3) := "101"; constant B : std_logic_vector(1 to 3) := "-1-"; constant C : std_logic_vector(1 to 3) := "000"; signal i : std_logic_vector(1 to 3); signal o : natural; begin gen: process (all) is begin case? i is when A => o <= 5; when B | C => o <= 42; when others => o <= 0; end case?; end process; check: process is begin i <= "000"; wait for 1 ns; assert o = 42; i <= "111"; wait for 1 ns; assert o = 42; i <= "101"; wait for 1 ns; assert o = 5; i <= "001"; wait for 1 ns; assert o = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue894.vhd000066400000000000000000000034011504111170000172660ustar00rootroot00000000000000package QueueP is generic (G_QUEUE_COUNT : positive := 1; G_QUEUE_DEPTH : positive := 4096 / 8 + 5; type G_DATA_TYPE; function G_TO_STRING(data : G_DATA_TYPE) return string); subtype t_queue_count is natural range 0 to G_QUEUE_COUNT - 1; subtype t_test is natural range G_QUEUE_COUNT to 100; type t_rec is record f : t_test; end record; procedure test (x : t_queue_count); end package QueueP; package body QueueP is procedure test (x : t_queue_count) is begin end procedure; end package body; ------------------------------------------------------------------------------- package pack is constant C_QUEUE_COUNT : positive := 4; constant C_QUEUE_MAX_SIZE : positive := 65535; package C2hQueue is new work.QueueP generic map (G_QUEUE_COUNT => C_QUEUE_COUNT, G_QUEUE_DEPTH => C_QUEUE_MAX_SIZE, G_DATA_TYPE => bit_vector(7 downto 0), G_TO_STRING => to_string); end package; ------------------------------------------------------------------------------- entity issue894 is end entity; use work.pack.all; architecture test of issue894 is begin tb: process is type t_array is array (C2hQueue.t_test) of C2hQueue.t_test; variable n : natural := 2; variable v : C2hQueue.t_queue_count; variable t : C2hQueue.t_test; variable a : t_array; variable r : C2hQueue.t_rec; begin C2hQueue.test(n); v := 2; t := 6; a(t) := 5; wait for 1 ns; assert a(6) = 5; -- TODO --assert a(6 to 7) = (5, C2hQueue.t_test'left); assert r.f = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue899.vhd000066400000000000000000000005221504111170000172740ustar00rootroot00000000000000entity issue899 is end entity; architecture beh of issue899 is constant C_TIME_1 : time := 8.2 ms; constant C_TIME_2 : time := 8200 us; begin process begin assert C_TIME_1 = C_TIME_2 report "Not same " & to_string(C_TIME_1) & " /= " & to_string(C_TIME_2) severity error; wait; end process; end architecture beh; nvc-r1.17.1/test/regress/issue9.vhd000066400000000000000000000011411504111170000171110ustar00rootroot00000000000000entity bitand is port ( x, y : in bit; z : out bit ); end entity; architecture test of bitand is begin z <= x and y; end architecture; entity issue9 is end entity; architecture test of issue9 is signal x1, y1, z1 : bit; begin bitand_i: entity work.bitand port map ( x=>x1, y=>'0', --y=>y1 works ! z=>z1 ); process is begin y1 <='1'; x1 <= '0'; wait for 1 ns; assert z1 = '0'; x1<='1'; wait for 1 ns; assert z1 = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue90.vhd000066400000000000000000000007761504111170000172060ustar00rootroot00000000000000entity issue90 is end entity; architecture test of issue90 is procedure proc(x : inout integer) is procedure nested_p1(x : inout integer) is begin x := x + 1; end; procedure nested_p2(x : inout integer) is begin nested_p1(x); x := x + 1; end; begin nested_p2(x); x := x + 1; end procedure; begin process is variable v : integer := 0; begin proc(v); assert v = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue901.vhd000066400000000000000000000005161504111170000172570ustar00rootroot00000000000000package pack is signal x : natural; signal y : bit_vector(2 downto 0); end package; entity issue901 is end entity; use work.pack.all; architecture test of issue901 is signal z : bit; begin x <= 1 after 1 ns, 5 after 2 ns; z <= y(1) after 1 ns; y <= "101" after 6 ns, "110" after 7 ns; end architecture; nvc-r1.17.1/test/regress/issue903.vhd000066400000000000000000000006301504111170000172560ustar00rootroot00000000000000entity issue903 is end entity; architecture test of issue903 is function compare (expected : real; result : real) return integer is begin if expected = result then return 6; end if; return 5; end function; begin check: process is variable r : real; begin assert compare(1.0, r) = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue904.vhd000066400000000000000000000005311504111170000172570ustar00rootroot00000000000000entity issue904 is end entity; architecture test of issue904 is signal x, y, clk : bit; -- psl default clock is clk'event and clk = '1'; begin clk <= not clk after 1 ns when now < 10 ns; x <= '1' after 1 ns, '0' after 3 ns, '1' after 5 ns; y <= '1' after 2 ns; -- psl cover {x = '1' and y = '1'}; end architecture; nvc-r1.17.1/test/regress/issue906.vhd000066400000000000000000000006231504111170000172630ustar00rootroot00000000000000entity issue906 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of issue906 is signal x, y : std_logic_vector(1 to 3); begin b: block is port ( p : in std_logic_vector; q : out std_logic_vector ); port map ( x, y ); begin q <= x after 1 ns; end block; x <= "100" after 1 ns, "111" after 2 ns; end architecture; nvc-r1.17.1/test/regress/issue907.vhd000066400000000000000000000013301504111170000172600ustar00rootroot00000000000000entity A is port ( clk : in bit ); end A; architecture rtl of A is type f is (ONE, TWO); signal e : f; begin end architecture; entity B is end B; architecture sim of B is type f is (ONE, TWO); begin E_PROC : process alias e is <>; begin loop -- elaborates if commented out wait on e; end loop; -- elaborates if commented out end process; end architecture; entity C is end C; architecture sim of C is signal clk : bit := '1'; begin DUT : entity work.A(rtl) port map ( clk => clk ); B : entity work.B(sim); end architecture; entity issue907 is end issue907; architecture sim of issue907 is begin C : entity work.C(sim); process begin wait; end process; end architecture; nvc-r1.17.1/test/regress/issue908.vhd000066400000000000000000000015241504111170000172660ustar00rootroot00000000000000entity issue908 is end entity; architecture sim of issue908 is type t_nat_vec is array (natural range <>) of natural; function count_drivers (inputs : t_nat_vec) return natural is begin return inputs'length; end function; subtype t_rnat is count_drivers natural; type t_queue_dir is (H2C, C2H, CMP); type t_queue_selects is array (t_queue_dir) of t_rnat; signal s_queue_selects : t_queue_selects; begin process (all) is begin for page in 0 to 2 loop -- H2C, C2H, CMP in separate memory pages if (page = 2) then -- The longest static prefix of this expression is s_queue_selects s_queue_selects(t_queue_dir'val(page-1)) <= 0; end if; end loop; end process; check: process is begin assert s_queue_selects = (H2C to CMP => 1); wait; end process; end architecture sim; nvc-r1.17.1/test/regress/issue909.sh000066400000000000000000000007651504111170000171260ustar00rootroot00000000000000set -xe pwd which nvc cat >sub.vhd <top.vhd < 42 ); port ( p : integer ); port map ( p => 66 ); begin end block; check: process is begin assert << constant b.g : integer >> = 42; assert << signal b.p : integer >> = 66; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue923.vhd000066400000000000000000000017571504111170000172730ustar00rootroot00000000000000package pack is generic (type t); type pt is protected impure function get_path return string; end protected; impure function get_path return string; end package; package body pack is type pt is protected body impure function get_path return string is begin return pt'path_name; end function; end protected body; shared variable sv : pt; impure function get_path return string is begin return sv.get_path; end function; end package body; ------------------------------------------------------------------------------- package pack_int is new work.pack generic map (integer); ------------------------------------------------------------------------------- entity issue923 is end entity; use work.pack_int.all; architecture test of issue923 is begin check: process is begin report get_path; assert get_path = ":work:pack_int:sv:"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue924.vhd000066400000000000000000000016751504111170000172730ustar00rootroot00000000000000package testpkg is generic ( type A ; val : A ; function to_string(x : A) return string is <> ; ) ; constant x : A := val ; function doit(l, r : A) return string ; end package ; package body testpkg is function doit(l, r : A) return string is begin return to_string(l) & to_string(r) ; end function ; end package body ; library ieee ; use ieee.std_logic_1164.all ; use ieee.numeric_std.all ; entity issue924 is end entity ; architecture arch of issue924 is --package test_int is new work.testpkg generic map(A => integer, val => 12) ; package test_signed is new work.testpkg generic map (A => signed, val => to_signed(12, 16)) ; begin tb : process begin --report test_int.doit(44, 55) ; assert test_signed.doit(to_signed(44, 16), to_signed(55, 16)) = "00000000001011000000000000110111"; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue925.vhd000066400000000000000000000022471504111170000172700ustar00rootroot00000000000000package generic_pkg is generic (type g_countertype ; g_initval : g_countertype ; function "+" (l : g_countertype ; r : integer) return g_countertype ); subtype countertype is g_countertype; constant initval : g_countertype := g_initval; end package; -------------------------------------------------- entity gentest is generic ( package test_pkg is new work.generic_pkg generic map(<>) ); port ( i : in test_pkg.countertype; o : out test_pkg.countertype := test_pkg.initval ); end entity gentest; architecture test of gentest is use test_pkg.all; begin o <= i + 1; end test; -------------------------------------------------- entity issue925 is end; architecture test of issue925 is package test_pkg is new work.generic_pkg generic map (g_countertype => integer, g_initval => 0, "+" => "+"); use test_pkg.all; signal x, y : countertype := initval; begin u_gentest : entity work.gentest generic map (test_pkg) port map (x, y); check: process is begin for i in 1 to 10 loop x <= i; wait for 1 ns; assert y = i + 1; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue931.vhd000066400000000000000000000013031504111170000172550ustar00rootroot00000000000000package nvc_bug_pkg is constant C_SLV_SIZE : integer := 16; end package nvc_bug_pkg; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; library work; use work.nvc_bug_pkg.all; entity issue931 is generic ( GC_SLV : std_logic_vector(C_SLV_SIZE-1 downto 0) := x"8008" ); end entity; architecture test of issue931 is begin p_nvc_bug : process begin assert GC_SLV(C_SLV_SIZE-1 downto 0) = x"8008" report "Mismatch. Expected 8008, got " & to_hstring(GC_SLV(C_SLV_SIZE-1 downto 0)) severity failure; report "Test succeeded"; wait; end process p_nvc_bug; end architecture test; nvc-r1.17.1/test/regress/issue932.vhd000066400000000000000000000040171504111170000172630ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity issue932 is end entity issue932; architecture test of issue932 is type t_slv_array is array(natural range <>) of std_logic_vector; function get_first_element ( slv_array : t_slv_array ) return std_logic_vector is constant slv_array_normalized : t_slv_array(0 to slv_array'length-1) := slv_array; begin return slv_array_normalized(0); end function get_first_element; function get_first_element_var ( slv_array : t_slv_array ) return std_logic_vector is variable slv_array_normalized : t_slv_array(0 to slv_array'length-1) := slv_array; begin return slv_array_normalized(0); end function get_first_element_var; function get_first_element_alias ( slv_array : t_slv_array ) return std_logic_vector is alias slv_array_normalized : t_slv_array(0 to slv_array'length-1) is slv_array; begin return slv_array_normalized(0); end function get_first_element_alias; constant c_slv_array : t_slv_array(0 to 3)(7 downto 0) := (others=>(others=>'0')); signal slv_array_normalized_sig : t_slv_array(0 to c_slv_array'length-1) := c_slv_array; begin p_nvc_bug : process variable v_slv_array : t_slv_array(0 to 3)(7 downto 0) := (others=>(others=>'0')); begin report "SLV array element 0 (const): " & to_hstring(get_first_element(v_slv_array(1 to 3))); report "SLV array element 0 (var): " & to_hstring(get_first_element_var(v_slv_array(1 to 3))); report "SLV array element 0 (alias): " & to_hstring(get_first_element_alias(v_slv_array(1 to 3))); report "SLV array element 0 (signal): " & to_hstring(slv_array_normalized_sig(0)); assert get_first_element(v_slv_array(1 to 3)) = X"00"; assert get_first_element_var(v_slv_array(1 to 3)) = X"00"; assert get_first_element_alias(v_slv_array(1 to 3)) = X"00"; assert slv_array_normalized_sig(0) = X"00"; wait; end process p_nvc_bug; end architecture test; nvc-r1.17.1/test/regress/issue94.vhd000066400000000000000000000013711504111170000172020ustar00rootroot00000000000000package pkg is function func (dataw : integer; shiftw : integer)return bit_vector; end pkg; package body pkg is function func (dataw : integer; shiftw : integer) return bit_vector is constant max_shift : integer := shiftw; type bit_vector_array is array (natural range <>) of bit_vector(dataw-1 downto 0); variable y_temp : bit_vector_array (0 to max_shift); begin y_temp(0):=(others=>'1'); -- Error with LLVM asserts build y_temp(1):=(others => '0'); return y_temp(0); end func; end pkg; entity issue94 is end entity; use work.pkg.all; architecture test of issue94 is begin process is begin assert func(4, 4) = "1111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue941.vhd000066400000000000000000000011071504111170000172600ustar00rootroot00000000000000entity sub is port ( x : in bit; y : out bit ); end entity; architecture test of sub is begin y <= not x after 1 ns; end architecture; ------------------------------------------------------------------------------- entity issue941 is end entity; architecture test of issue941 is component comp is port ( x : in bit; y : out bit ); end component; for all : comp use entity work.sub; signal a, b : bit; begin a <= '1' after 2 ns, '0' after 5 ns; u1: component comp port map ( a, b ); end architecture; nvc-r1.17.1/test/regress/issue943.vhd000066400000000000000000000024741504111170000172720ustar00rootroot00000000000000package genpack is generic (type t); type pt is protected impure function get return t; impure function get_str return string; procedure put (val : t); end protected; end package; package body genpack is constant str : string := "hello world"; type pt is protected body variable cur : t; impure function get return t is begin return cur; end function; procedure put (val : t) is begin cur := val; end procedure; impure function get_str return string is begin return str; -- Accesses parent package end function; end protected body; end package body; ------------------------------------------------------------------------------- package testpack is package int_pack is new work.genpack generic map ( t => integer ); use int_pack.all; end package; ------------------------------------------------------------------------------- entity issue943 is end entity; use work.testpack.all; architecture test of issue943 is shared variable sv : int_pack.pt; begin check: process is begin sv.put(5); assert sv.get = 5; assert sv.get_str = "hello world"; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue946.vhd000066400000000000000000000016051504111170000172700ustar00rootroot00000000000000package pack is generic ( width : natural ); type t_rec is record f : integer_vector(1 to width); end record; signal s : t_rec; alias a is s.f; procedure get (index : positive; result : out integer); end package; package body pack is procedure get (index : positive; result : out integer) is begin result := a(index); end procedure; end package body; ------------------------------------------------------------------------------- entity issue946 is end entity; architecture test of issue946 is package pack6 is new work.pack generic map ( 3 ); use pack6.all; begin check: process is variable result : integer; begin a <= (1, 2, 3); wait for 0 ns; for i in 1 to 3 loop get(i, result); assert result = i; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue95.vhd000066400000000000000000000014311504111170000172000ustar00rootroot00000000000000entity issue95 is end entity; architecture behav of issue95 is type point is record x : integer; y : integer; z : boolean; end record point; type point_array is array (natural range <>) of point; signal points : point_array(1 to 4) := (others => (x => 1, y => 1, z => true)); procedure update(signal pa : out point_array) is begin pa(3).x <= 7; end procedure; begin p1: process begin assert points(3).x = 1; points(2).y <= 4; wait for 2 ns; update(points); wait; end process; p2: process is begin wait for 1 ns; assert points(2) = (1, 4, true); wait for 2 ns; assert points(3) = (7, 1, true); wait; end process; end behav; nvc-r1.17.1/test/regress/issue950.vhd000066400000000000000000000007631504111170000172670ustar00rootroot00000000000000entity issue950 is end entity; architecture test of issue950 is type t_base is record f : integer_vector; end record; subtype t_rec is t_base; signal s : t_rec(f(1 to 3)) := (f => (others => -1)); begin b: block is port ( p : inout t_rec ); port map ( s ); begin p <= (f => (1, 2, 3)); end block; check: process is begin wait for 1 ns; assert s.f = (1, 2, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/issue954.vhd000066400000000000000000000007051504111170000172670ustar00rootroot00000000000000entity issue954 is end entity; architecture test of issue954 is type StringArray_t is array (natural range <>) of string; constant MyStringArray_c : StringArray_t(0 to 1) := ( 0 => "TEST 0", 1 => "TEST 1" ); begin process is begin for i in 0 to 1 loop assert MyStringArray_c(i) = "TEST " & integer'image(i); end loop; wait; end process; end architecture test; nvc-r1.17.1/test/regress/issue957.vhd000066400000000000000000000036041504111170000172730ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity test is port ( clk : in std_logic; dataIn : in std_logic_vector(15 downto 0); sel : in unsigned(1 downto 0); en : in std_logic ); end test; architecture rtl of test is type v_slv_t is array (natural range<>) of std_logic_vector; signal test : v_slv_t(2 downto 0)(15 downto 0) := (others => (others => '0')); begin test_reg : process (clk) begin if rising_edge(clk) then if en then test(to_integer(sel)) <= dataIn; end if; end if; end process; end rtl; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity issue957 is end issue957; architecture rtl of issue957 is signal clk_period : time := 20 ns; signal clk : std_logic := '0'; signal dataIn : std_logic_vector(15 downto 0) := (others => '0'); signal sel : unsigned(1 downto 0) := (others => '0'); signal en : std_logic := '0'; begin clk <= not clk after clk_period / 2; uut : entity work.test port map( clk => clk, dataIn => dataIn, sel => sel, en => en ); process begin wait for 100 ns; wait until rising_edge(clk); dataIn <= std_logic_vector(to_unsigned(16#1111#, dataIn'length)); sel <= to_unsigned(16#0#, sel'length); en <= '1'; wait until rising_edge(clk); en <= '0'; wait for 100 ns; wait until rising_edge(clk); dataIn <= std_logic_vector(to_unsigned(16#3333#, dataIn'length)); sel <= to_unsigned(16#2#, sel'length); en <= '1'; wait until rising_edge(clk); en <= '0'; wait for 100 ns; wait until rising_edge(clk); dataIn <= std_logic_vector(to_unsigned(16#2222#, dataIn'length)); sel <= to_unsigned(16#1#, sel'length); en <= '1'; wait until rising_edge(clk); en <= '0'; wait for 100 ns; std.env.stop; end process; end rtl; nvc-r1.17.1/test/regress/issue96.vhd000066400000000000000000000012111504111170000171750ustar00rootroot00000000000000entity issue96 is end entity; architecture foo of issue96 is function "&" (l: string; r: natural) return string is begin report "called the user function"; assert r <= 255 report "&, natural " & natural'IMAGE(r) & " argument out of character range" severity ERROR; return l & character'VAL(r); end function; constant a: string := "abcd"; constant b: string := "efgh"; begin assert FALSE report "concatenated string is " & a & -- Line 18 character'VAL(16#42#) & b & " " & a & 16#42# & b severity NOTE; end architecture; nvc-r1.17.1/test/regress/issue960.vhd000066400000000000000000000012301504111170000172560ustar00rootroot00000000000000entity issue960 is end entity; architecture arch of issue960 is type T_RECORD is record EL : bit; end record T_RECORD; type T_ARRAY is array (1 downto 0) of T_RECORD; signal array_sig : T_ARRAY; signal stable_sig : boolean; begin stable_sig <= array_sig'stable; check: process is begin assert not stable_sig; wait for 0 ns; assert stable_sig; array_sig(1).el <= '1' after 1 ns; wait for 1 ns; assert stable_sig; wait for 0 ns; assert not stable_sig; wait for 0 ns; assert stable_sig; wait; end process; end architecture arch; nvc-r1.17.1/test/regress/issue962.vhd000066400000000000000000000014211504111170000172620ustar00rootroot00000000000000package function_pkg is function get_width return natural; end function_pkg; package body function_pkg is function get_width return natural is begin return 5; end get_width; end function_pkg; use work.function_pkg.all; package foo is type t_record is record descriptor: bit_vector(get_width-1 downto 0); end record; type t_array is array (natural range<>) of t_record; end package foo; use work.foo.all; entity issue962 is end entity; architecture rtl of issue962 is signal i_channel_states : t_array(0 to 1); begin stim: process is begin wait for 1 ns; i_channel_states(1) <= (descriptor => "10110"); wait for 1 ns; i_channel_states(0).descriptor(0) <= '1'; wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue963.vhd000066400000000000000000000034711504111170000172720ustar00rootroot00000000000000entity issue963 is end entity; library ieee; use ieee.numeric_bit.all; architecture test of issue963 is type t_enum is (A, B, C); type t_inner is record x : t_enum; y : integer; end record; type t_outer is record pad : bit; inner : t_inner; end record; subtype t_vec is bit_vector(33 downto 0); type t_padded_vec is record pad : bit; vec : t_vec; end record; signal r1, r2 : t_outer; signal v1, v2 : t_vec; function to_bits (arg : t_inner) return t_vec is variable result : bit_vector(33 downto 0); begin result(31 downto 0) := bit_vector(to_signed(arg.y, 32)); result(33 downto 32) := bit_vector(to_unsigned(t_enum'pos(arg.x), 2)); return result; end function; function from_bits (arg : t_vec) return t_inner is variable result : t_inner; begin result.x := t_enum'val(to_integer(unsigned(arg(33 downto 32)))); result.y := to_integer(signed(arg(31 downto 0))); return result; end function; begin u1: block is port ( i : in t_vec; o : out t_vec ); port map ( i => to_bits(r1.inner), o => v1 ); begin o <= i; end block; u2: block is port ( io : inout t_vec := "01" & X"FFFFFFFF" ); port map ( from_bits(io) => to_bits(r2.inner) ); begin assert io = "01" & X"FFFFFFFF"; end block; check: process is begin wait for 1 ns; assert v1 = "00" & X"80000000"; r1.inner.x <= C; wait for 0 ns; wait for 0 ns; assert v1 = "10" & X"80000000"; r1.inner.y <= 42; wait for 1 ns; assert v1 = "10" & X"0000002a"; assert r2.inner.x = B; assert r2.inner.y = -1; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue968.vhd000066400000000000000000000014451504111170000172760ustar00rootroot00000000000000entity issue968 is end entity; architecture tb of issue968 is -- changing this to bit does not crash signal foo: bit_vector(1 downto 0); signal done : boolean; begin assign: foo(0) <= '1'; stim: process is begin wait until foo'stable; report "foo is stable"; wait for 1 ns; foo(1) <= '1'; wait for 0 ns; assert not foo'stable; wait for 1 ns; assert foo'stable; done <= true; end process; check: process is begin report "0"; assert foo'stable; wait for 0 ns; report "1"; assert not foo'stable; wait for 0 ns; report "2"; assert foo'stable; wait for 5 ns; assert done; wait; end process; end architecture tb; nvc-r1.17.1/test/regress/issue970.vhd000066400000000000000000000053401504111170000172650ustar00rootroot00000000000000-- Test case from Brian Padalino library ieee ; use ieee.std_logic_1164.all ; entity issue970 is end entity ; architecture arch of issue970 is -- note: can't get this to parse with rivieria --function reverse parameter(x : array(type is (<>)) of type is private) return x'subtype; -- naive generic reverse algorithm function reverse generic ( type t is array(type is (<>)) of type is private ) parameter(x : t) return t is subtype idx is x'index ; variable rv : x'subtype := x ; variable inidx : idx := x'right ; begin -- null or single element arrays are the same as the original if x'length < 2 then return rv ; end if ; -- fill in right -> left for outidx in x'range loop rv(inidx) := x(outidx) ; -- only increment if we aren't done -- note: /= not passed in via generics if inidx /= x'left then if x'ascending = true then inidx := idx'pred(inidx) ; else inidx := idx'succ(inidx) ; end if ; end if ; end loop ; return rv ; end function ; procedure display generic ( type t is array(type is (<>)) of type is private ; function to_string(x : t'element) return string is <> ) parameter (x : t) is use std.textio.all ; variable l : line ; begin swrite(l, "(") ; for idx in x'range loop write(l, to_string(idx) & "=>" & to_string(x(idx))) ; if idx /= x'high then swrite(l, ", ") ; end if ; end loop ; swrite(l, ")") ; writeline(output, l) ; end procedure ; begin tb : process variable x : integer_vector := (1, 2, 3, 4, 5, 6, 7, 8) ; variable y : integer_vector := reverse generic map(x'subtype)(x) ; variable a : std_logic_vector(15 to 20) := ('X', '-', 'U', '0', '1', 'L') ; variable b : a'subtype := reverse generic map(a'subtype)(a) ; variable c : std_logic_vector(9 to 9) := (9 => '1') ; variable d : c'subtype := reverse generic map(c'subtype)(c) ; variable n : std_logic_vector(1 to 0) ; variable m : n'subtype := reverse generic map(n'subtype)(n) ; variable p : integer_vector(4 to 5) := (1, 2) ; variable q : p'subtype := reverse generic map(p'subtype)(p) ; begin display generic map (y'subtype)(y) ; display generic map (b'subtype)(b) ; display generic map (d'subtype)(d) ; display generic map (m'subtype)(m) ; display generic map (q'subtype)(q) ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/issue971.vhd000066400000000000000000000027571504111170000172770ustar00rootroot00000000000000entity mre_conversion is port (din : in bit_vector(63 downto 0)); end entity mre_conversion; architecture arch of mre_conversion is begin check: process is begin assert din = X"0000_0000_0000_0000"; wait for 2 ns; assert din = X"0000_1234_0000_0000"; wait for 5 ns; assert din = X"6666_1234_0000_0000"; wait; end process; end arch; entity issue971 is end entity issue971; architecture arch of issue971 is type T_RECORD is record element : bit_vector(15 downto 0); end record T_RECORD; type T_COMPOUND is array (3 downto 0) of T_RECORD; type T_COMPOUND_SINGLE is array (3 downto 0) of bit_vector(15 downto 0); function f1(inp : T_COMPOUND_SINGLE) return bit_vector is variable result : bit_vector(63 downto 0); begin for i in inp'range loop result((i + 1) * 16 - 1 downto i * 16) := inp(i); end loop; return result; end function f1; function f2(inp : T_COMPOUND) return T_COMPOUND_SINGLE is variable result : t_compound_single; begin for i in inp'range loop result(i) := inp(i).element; end loop; return result; end function f2; signal input_signal: T_COMPOUND; begin mre_conversion_inst: entity work.mre_conversion port map ( din => f1(f2(input_signal)) ); stim: process is begin wait for 1 ns; input_signal(2).element <= X"1234"; wait for 5 ns; input_signal(3).element <= X"6666"; wait; end process; end architecture arch; nvc-r1.17.1/test/regress/issue972.vhd000066400000000000000000000010571504111170000172700ustar00rootroot00000000000000entity issue972 is end entity; architecture a of issue972 is type t_rec is record f : natural; end record; type t_array is array (natural range <>) of t_rec; subtype t_ports is natural range 0 to 1; signal x, y : t_array(t_ports'high downto 0); begin x <= (0 => (f => 0), 1 => (f => 1)) after 1 ns, (0 => (f => 0), 1 => (f => 2)) after 2 ns; b: block is generic ( type t ); generic map ( t => t_array ); port ( i : in t; o : out t ); port map ( x, y ); begin o <= i after 1 ns; end block; end architecture; nvc-r1.17.1/test/regress/issue978.vhd000066400000000000000000000005271504111170000172770ustar00rootroot00000000000000entity issue978 is end entity; architecture test of issue978 is constant period : delay_length := 20 ns; -- VHPI error here type t_int64 is range -9223372036854775807 - 1 to 9223372036854775807; constant one : t_int64 := 1; subtype t_sub is t_int64 range 1 to 100; constant two : t_sub := 42; begin end architecture; nvc-r1.17.1/test/regress/issue979.vhd000066400000000000000000000006011504111170000172710ustar00rootroot00000000000000entity foo is port ( rd_data : out bit ); end entity foo; architecture rtl of foo is begin rd_data <= '0'; end architecture; entity issue979 is end entity issue979; architecture tb of issue979 is signal wrb_data : bit; begin process begin std.env.finish; end process; foo_inst: entity work.foo port map ( rd_data => wrb_data ); end architecture tb; nvc-r1.17.1/test/regress/issue98.vhd000066400000000000000000000010721504111170000172040ustar00rootroot00000000000000entity issue98 is end entity; architecture foo of issue98 is begin p1: process is begin -- 'POS returns universal integer -- 'VAL parameter is any integer type (including universal integer) assert False report "Time'HIGH = " & Time'IMAGE(Time'VAL(Time'POS(Time'HIGH))) severity NOTE; assert False report "should produce 9223372036854775807" severity NOTE; assert Time'VAL(Time'POS(Time'HIGH)) = 9223372036854775807 fs; wait; end process; end architecture; nvc-r1.17.1/test/regress/issue983.vhd000066400000000000000000000006171504111170000172730ustar00rootroot00000000000000entity foo is generic ( a: natural ); end entity foo; architecture rtl of foo is begin process is begin assert a = 5; wait; end process; end architecture; entity issue983 is end entity; architecture tb of issue983 is signal a_actual : natural := 5; begin foo_inst: entity work.foo generic map ( a => a_actual ); end architecture tb; nvc-r1.17.1/test/regress/issue985.vhd000066400000000000000000000012511504111170000172700ustar00rootroot00000000000000entity issue985 is generic ( DATA_WIDTH: integer := 4; FIFO_SIZE: integer := 36 ); end entity; architecture sim of issue985 is function GetWidth ( rdwr_width : in integer ) return integer is variable func_width : integer; begin return rdwr_width; end; constant mem_width : integer := GetWidth(DATA_WIDTH); type Two_D_array_type is array (1 downto 0) of bit_vector((mem_width - 1) downto 0); signal mem : Two_D_array_type; begin process begin mem(0) <= (others => '1'); wait for 1 ns; mem(0) <= (others => '0'); mem(1) <= (0 => '1', others => '0'); wait for 1 ns; std.env.finish; end process; end architecture; nvc-r1.17.1/test/regress/issue988.vhd000066400000000000000000000012501504111170000172720ustar00rootroot00000000000000entity issue988 is end entity; architecture test of issue988 is function init return integer is begin report "should not call this" severity failure; end function; attribute foreign of init : function is "VHPI issue988 init"; function init_direct return integer is begin report "should not call this" severity failure; end function; attribute foreign of init_direct : function is "VHPIDIRECT __vhpi_init_direct"; constant c1 : integer := init; constant c2 : integer := init_direct; begin check: process is begin assert c1 = 42; assert c2 = 66; wait; end process; end architecture; nvc-r1.17.1/test/regress/ivtest1.v000066400000000000000000000035521504111170000167630ustar00rootroot00000000000000// // Copyright (c) 2002 Steven Wilson (steve@ka6s.com) // // This source code is free software; you can redistribute it // and/or modify it in source code form under the terms of the GNU // General Public License as published by the Free Software // Foundation; either version 2 of the License, or (at your option) // any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA // // SDW: Synth of basic reg form // // module basicreg ( clk, d, q); input clk, d; output [2:0] q; reg [2:0] q; (* ivl_synthesis_on *) always @(posedge clk) begin q[0] <= d; q[1] <= d; q[2] <= d; end endmodule module ivtest1 ; reg clk, d; wire [2:0] q; basicreg u_reg (clk,d,q); (* ivl_synthesis_off *) initial begin // $dumpfile("test.vcd"); // $dumpvars(0,test); clk = 0; d = 0; # 1; clk = 1; # 1; if (q !== 3'b0) begin $display("FAILED - Q isn't 0 on first edge"); $finish; end d = 1; # 1; clk = 0; # 1; if (q !== 3'b0) begin $display("FAILED - Q isn't 0 after first falling edge"); $finish; end # 1; clk = 1; # 1; if (q !== 3'b111) begin #1 ; $display("FAILED - Q isn't 1 2nd raising edge"); $finish; end # 1; clk = 0; # 1; if (q !== 3'b111) begin $display("FAILED - Q isn't 1 after 2nd falling edge"); $finish; end $display("PASSED"); end endmodule nvc-r1.17.1/test/regress/ivtest2.v000066400000000000000000000025751504111170000167700ustar00rootroot00000000000000// From Icarus Verilog ivtest/ivltests/delay.v `timescale 1ns/100ps module ivtest2; reg clk; reg cat1; reg cat2; reg cat3; reg cat4; reg foo1; reg foo2; reg foo3; reg foo4; reg bar1; reg bar2; reg bar3; reg bar4; initial begin clk = 0; #100 $finish(0); end always begin clk = 0; #50; clk = 1; #50; end always @(posedge clk) begin cat1 = #1 1; cat2 = #1 1; cat3 = #1 1; cat4 = #1 1; foo1 = #1 1; foo2 = #1 1; foo3 = #1 1; foo4 = #1 1; bar1 <= #1 1; bar2 <= #1 1; bar3 <= #1 1; bar4 <= #1 1; end always @(cat1) $write("time=%0t, cat1=%0h\n", $time, cat1); always @(cat2) $write("time=%04d, cat2=%0h\n", $time, cat2); always @(cat3) $write("time=%04d, cat3=%0h\n", $time, cat3); always @(cat4) $write("time=%04d, cat4=%0h\n", $time, cat4); always @(foo1) $write("time=%04d, foo1=%0h\n", $time, foo1); always @(foo2) $write("time=%04d, foo2=%0h\n", $time, foo2); always @(foo3) $write("time=%04d, foo3=%0h\n", $time, foo3); always @(foo4) $write("time=%04d, foo4=%0h\n", $time, foo4); always @(bar1) $write("time=%04d, bar1=%0h\n", $time, bar1); always @(bar2) $write("time=%04d, bar2=%0h\n", $time, bar2); always @(bar3) $write("time=%04d, bar3=%0h\n", $time, bar3); always @(bar4) $write("time=%04d, bar4=%0h\n", $time, bar4); endmodule nvc-r1.17.1/test/regress/ivtest3.v000066400000000000000000000023551504111170000167650ustar00rootroot00000000000000/* * Copyright (c) 2000 Stephen Williams (steve@icarus.com) * * This source code is free software; you can redistribute it * and/or modify it in source code form under the terms of the GNU * General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ module ivtest3; wire [31:0] A; wire [24:0] B; reg [15:0] C; assign A = B; assign B = C; initial begin C = 0; #1 if (A !== 32'h0) begin $display("FAILED -- A === %h", A); $finish; end C = -1; #1 if (A !== 32'h00_00_ff_ff) begin $display("FAILED -- A == %h instead of 0000ffff", A); $finish; end $display("PASSED"); end endmodule nvc-r1.17.1/test/regress/ivtest4.v000066400000000000000000000014701504111170000167630ustar00rootroot00000000000000module ivtest4; reg cp; reg d; wire q; dff ff(q, cp, d); always begin #5 cp=0; #5 cp=1; end always begin @(negedge cp) d <= ~d; @(posedge cp) if (q !== 'bx && d === q) begin $display("FAILED, d=%b, q=%b", d, q); #1 $finish; end end initial begin #1 d = 1; #22; $display("PASSED"); $finish; end initial $monitor($time,,cp,,d,,q); endmodule primitive dff(q, cp, d); output q; input cp, d; reg q; table // (cp) d : q : q ; ? * : ? : - ; (?0) ? : ? : - ; (1x) ? : ? : - ; (x1) 0 : 0 : 0 ; (x1) 1 : 1 : 1 ; (0x) 0 : 0 : 0 ; (0x) 1 : 1 : 1 ; (01) 0 : ? : 0 ; (01) 1 : ? : 1 ; endtable endprimitive nvc-r1.17.1/test/regress/ivtest5.v000066400000000000000000000020001504111170000167520ustar00rootroot00000000000000 module ivtest5; reg [7:0] val; initial begin val = 120; if (8'd5 < val) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (8'd5 <= val) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (8'd121 > val) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (8'd121 >= val) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (val > 8'd5) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (val >= 8'd5) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (val < 8'd121) begin $display("OK"); end else begin $display("FAILED"); $finish; end if (val <= 8'd121) begin $display("OK"); end else begin $display("FAILED"); $finish; end $display("PASSED"); end endmodule // main nvc-r1.17.1/test/regress/ivtest6.v000066400000000000000000000010771504111170000167700ustar00rootroot00000000000000// From Icarus Verilog ivtest/ivltests/case1.v module ivtest6; reg [3:0] cond; reg [2:0] t; always @* case (cond&4'b1110) 'h0: t = 7; 'h2: t = 6; 'h4: t = 5; 'h6: t = 4; 'h8: t = 3; 'ha: t = 2; 'hc: t = 1; 'he: t = 0; endcase integer i; initial begin for (i = 0 ; i < 8 ; i = i + 1) begin cond = i << 1; #1 if (t !== (7 - i)) begin $display("FAILED -- i=%d, cond=%b, t=%b", i, cond, t); $finish; end end $display("PASSED"); end endmodule // main nvc-r1.17.1/test/regress/jcore1.vhd000066400000000000000000000014631504111170000170620ustar00rootroot00000000000000entity sub is generic ( N : integer ); function addN(x : integer) return integer is begin return x + N; end function; end entity; architecture test of sub is signal x : integer := 4; begin process is begin assert addN(x) = x + N; wait; end process; end architecture; ------------------------------------------------------------------------------- entity jcore1 is function add2(x : integer) return integer is begin return x + 2; end function; end entity; architecture test of jcore1 is signal x : integer := 4; begin process is begin assert add2(x) = 6; wait; end process; sub_i: entity work.sub generic map ( 6 ); sub2_i: entity work.sub generic map ( 7 ); end architecture; nvc-r1.17.1/test/regress/jcore2.vhd000066400000000000000000000045201504111170000170600ustar00rootroot00000000000000package data_bus_pkg is type data_bus_device_t is ( DEV_NONE ,DEV_PIO ,DEV_SPI ,DEV_AIC ,DEV_UART0 ,DEV_UART1 ,DEV_UARTGPS ,DEV_SRAM ,DEV_DDR ,DEV_BL0 ,DEV_EMAC ,DEV_I2C ); type ext_bus_device_t is ( DEV_BL0, DEV_EMAC, DEV_I2C, DEV_DDR ); type ext_to_int_data_bus_t is array(ext_bus_device_t'left to ext_bus_device_t'right) of data_bus_device_t; -- arrays for mapping mcu_lib's data bus and irq ports to the internal versions constant ext_to_int_data : ext_to_int_data_bus_t := ( DEV_BL0 => DEV_BL0, DEV_EMAC => DEV_EMAC, DEV_I2C => DEV_I2C, DEV_DDR => DEV_NONE ); end data_bus_pkg; ------------------------------------------------------------------------------- package monitor_pkg is type timeout_t is record cnt : integer range 0 to 10; end record; type cnt_reg_t is record a : bit; cnt : integer range 0 to 10; end record; constant CNT_REG_RESET : cnt_reg_t := ('0',0); end package; ------------------------------------------------------------------------------- use work.monitor_pkg.all; entity timeout_cnt is port( clk : in bit; rst : in bit; timeout : out timeout_t ); end timeout_cnt; architecture structure of timeout_cnt is signal this_c : cnt_reg_t; signal this_r : cnt_reg_t := CNT_REG_RESET; begin counter_r0 : process(clk, rst) begin if rst = '1' then this_r <= CNT_REG_RESET; elsif clk = '1' and clk'event then report integer'image(this_c.cnt); this_c.cnt <= this_c.cnt + 1; this_r <= this_c; end if; end process; timeout.cnt <= this_r.cnt; end structure; ------------------------------------------------------------------------------- use work.monitor_pkg.all; use work.data_bus_pkg.all; entity jcore2 is end; architecture behaviour of jcore2 is signal clk : bit := '1'; signal rst : bit := '1'; signal timeout : timeout_t; begin timeout_cnt_i: entity work.timeout_cnt port map(clk => clk, rst => rst, timeout => timeout); process is begin wait for 1 ns; assert timeout.cnt = 0; rst <= '0'; clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; wait for 1 ns; clk <= '1'; wait for 1 ns; assert timeout.cnt = 1; wait; end process; end; nvc-r1.17.1/test/regress/jcore3.vhd000066400000000000000000000006651504111170000170670ustar00rootroot00000000000000entity jcore3 is end entity; architecture test of jcore3 is signal x, y : integer; begin a: process (x, y) is variable count : integer := 0; begin report "wakeup"; count := count + 1; assert count <= 2; end process; b: process is begin x <= 1; wait; end process; c: process is begin y <= 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/jcore4.vhd000066400000000000000000000010001504111170000170500ustar00rootroot00000000000000entity jcore4 is end entity; architecture test of jcore4 is type rt is record x : bit_vector(1 to 3); end record; type at is array (integer range <>) of rt; signal a : at(1 to 3); signal c : integer := 0; begin p1: process (a) is begin report "wakeup"; c <= c + 1; end process; p2: process is begin wait for 1 ns; a(3).x(3) <= '1'; wait for 1 ns; assert c = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/jcore5.vhd000066400000000000000000000022761504111170000170710ustar00rootroot00000000000000package cpu2j0_pack is type cpu_debug_o_t is record ack : bit; d : bit_vector(31 downto 0); rdy : bit; end record; constant bits_exp : natural := 5; constant bits : natural := 2**bits_exp; type bus_val_t is record en : bit; d : bit_vector(bits-1 downto 0); end record; constant BUS_VAL_RESET : bus_val_t := ('0', (others => '0')); type ybus_val_pipeline_t is array (2 downto 0) of bus_val_t; type datapath_reg_t is record debug_o : cpu_debug_o_t; ybus_override : ybus_val_pipeline_t; end record; constant DATAPATH_RESET : datapath_reg_t := ( debug_o => (ack => '0', d => (others => '0'), rdy => '0'), ybus_override => (others => BUS_VAL_RESET) ); end package; ------------------------------------------------------------------------------- entity jcore5 is end entity; use work.cpu2j0_pack.all; architecture test of jcore5 is signal x : datapath_reg_t := DATAPATH_RESET; begin process is begin assert x = ( debug_o => (ack => '0', d => (others => '0'), rdy => '0'), ybus_override => (others => BUS_VAL_RESET) ); wait; end process; end architecture; nvc-r1.17.1/test/regress/jcore6.vhd000066400000000000000000000011661504111170000170670ustar00rootroot00000000000000entity jcore6 is end entity; architecture test of jcore6 is procedure update(signal x : in bit_vector(1 downto 0); sel : in integer; signal y : out bit) is begin y <= x(sel); end procedure; signal s_sel : integer range 0 to 1; signal s_x : bit_vector(1 downto 0); signal s_y : bit; begin update(s_x, s_sel, s_y); process is begin s_x <= "10"; s_sel <= 1; wait for 1 ns; assert s_y = '1'; s_sel <= 0; wait for 1 ns; assert s_y = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/lfsr.vhd000066400000000000000000000026741504111170000166520ustar00rootroot00000000000000entity lfsr16 is generic ( WIDTH : positive := 16; TAP : natural := 3 ); port ( clk : in bit; reset : in bit; -- Asynchronous en : in bit; value : out bit_vector(15 downto 0) ); end entity; architecture rtl of lfsr16 is signal state_r : bit_vector(WIDTH - 1 downto 0); begin value <= state_r; process (clk, reset) is begin if reset = '1' then state_r <= (others => '0'); elsif clk'event and clk = '1' then if en = '1' then state_r(WIDTH - 1 downto 1) <= state_r(WIDTH - 2 downto 0); state_r(0) <= state_r(WIDTH - 1) xnor state_r(TAP); end if; end if; end process; end architecture; ------------------------------------------------------------------------------- entity lfsr is end entity; architecture test of lfsr is constant PERIOD : delay_length := 10 ns; signal clk, en : bit := '0'; signal reset : bit := '1'; signal value : bit_vector(15 downto 0); begin clk <= not clk after PERIOD / 2; reset <= '0' after 10 ns; en <= '1' after 30 ns; uut: entity work.lfsr16 port map ( clk, reset, en, value ); check: process is begin wait for 500 ns; assert value = ('0','1','1','1','1','1','1','1', '1','1','1','1','1','0','0','0'); wait; end process; end architecture; nvc-r1.17.1/test/regress/libdir1.sh000066400000000000000000000010111504111170000170430ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/signal1.vhd nvc --work=work:other -a $TESTDIR/regress/wait1.vhd ls -l work ls -l other [ -f work/WORK.SIGNAL1 ] || exit 1 [ -f other/WORK.WAIT1 ] || exit 1 [ -f other/WORK.SIGNAL1 ] && exit 1 [ -f work/WORK.WAIT1 ] && exit 1 nvc --work=/foo/bar:baz && exit 1 # Invalid character in lib name nvc --work= foo && exit 1 # Empty library name (issue #778) nvc --work $(pwd)/somelib -a $TESTDIR/regress/wait2.vhd ls -l somelib [ -f somelib/SOMELIB.WAIT2 ] || exit 1 nvc-r1.17.1/test/regress/libdir2.sh000066400000000000000000000006711504111170000170570ustar00rootroot00000000000000set -xe pwd which nvc cat >mypack.vhd <ent.vhd <ent.vhd <arch.vhd <msgs if ! grep "is older than its source file ent.vhd" msgs; then echo "missing expected message" exit 1 fi nvc-r1.17.1/test/regress/libdir4.sh000066400000000000000000000011221504111170000170510ustar00rootroot00000000000000set -xe pwd which nvc cat >pack.vhd <test.vhd <) of integer; type rec is record data : int_vec(1 to 100); end record; impure function make_rec return rec; constant r : rec; constant s : string := "hello"; function get_string return string; end package; package body pack is impure function make_rec return rec is variable r : rec; begin for i in 1 to 100 loop for j in 1 to 100 loop r.data(j) := r.data(j) + 1; end loop; end loop; return r; end function; function get_string return string is begin return s; end function; constant r : rec := make_rec; end package body; ------------------------------------------------------------------------------- entity link4 is end entity; use work.pack.all; architecture test of link4 is begin p1: process is begin assert get_string = s; -- OK assert get_string = s; -- OK (failed spuriously) wait; end process; end architecture; nvc-r1.17.1/test/regress/logical1.vhd000066400000000000000000000020571504111170000173720ustar00rootroot00000000000000entity logical1 is end entity; architecture test of logical1 is signal x : bit; begin process is begin x <= '0'; wait for 1 ns; assert (x and '0') = '0'; assert (x and '1') = '0'; assert (x or '0') = '0'; assert (x or '1') = '1'; assert (x xor '0') = '0'; assert (x xor '1') = '1'; assert (x xnor '0') = '1'; assert (x xnor '1') = '0'; assert (x nand '0') = '1'; assert (x nand '1') = '1'; assert (x nor '0') = '1'; assert (x nor '1') = '0'; x <= '1'; wait for 1 ns; assert (x and '0') = '0'; assert (x and '1') = '1'; assert (x or '0') = '1'; assert (x or '1') = '1'; assert (x xor '0') = '1'; assert (x xor '1') = '0'; assert (x xnor '0') = '0'; assert (x xnor '1') = '1'; assert (x nand '0') = '1'; assert (x nand '1') = '0'; assert (x nor '0') = '0'; assert (x nor '1') = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/logical2.vhd000066400000000000000000000047161504111170000173770ustar00rootroot00000000000000entity logical2 is end entity; architecture test of logical2 is signal x : bit; signal one : bit := '1'; signal zero : bit := '0'; signal vec : bit_vector(0 to 1) := ('0', '1'); begin process is variable v : boolean := true; begin x <= '0'; wait for 1 ns; assert (x and zero) = zero; assert (x and one) = zero; assert (x or zero) = zero; assert (x or one) = one; assert (x xor zero) = zero; assert (x xor one) = one; assert (x xnor zero) = one; assert (x xnor one) = zero; assert (x nand zero) = one; assert (x nand one) = one; assert (x nor zero) = one; assert (x nor one) = zero; x <= '1'; wait for 1 ns; assert (x and zero) = zero; assert (x and one) = one; assert (x or zero) = one; assert (x or one) = one; assert (x xor zero) = one; assert (x xor one) = zero; assert (x xnor zero) = zero; assert (x xnor one) = one; assert (x nand zero) = one; assert (x nand one) = zero; assert (x nor zero) = zero; assert (x nor one) = zero; v := v and v; assert v; v := v or v; assert v; v := v nand v; assert not v; v := v nor v; assert v; v := v xor v; assert not v; v := v xnor v; assert v; v := v xnor v; assert v; -- This tests short circuiting x <= '0'; wait for 1 ns; assert (x and vec(0)) = zero; assert (x and vec(1)) = zero; assert (x or vec(0)) = zero; assert (x or vec(1)) = one; assert (x xor vec(0)) = zero; assert (x xor vec(1)) = one; assert (x xnor vec(0)) = one; assert (x xnor vec(1)) = zero; assert (x nand vec(0)) = one; assert (x nand vec(1)) = one; assert (x nor vec(0)) = one; assert (x nor vec(1)) = zero; x <= '1'; wait for 1 ns; assert (x and vec(0)) = zero; assert (x and vec(1)) = one; assert (x or vec(0)) = one; assert (x or vec(1)) = one; assert (x xor vec(0)) = one; assert (x xor vec(1)) = zero; assert (x xnor vec(0)) = zero; assert (x xnor vec(1)) = one; assert (x nand vec(0)) = one; assert (x nand vec(1)) = zero; assert (x nor vec(0)) = zero; assert (x nor vec(1)) = zero; wait; end process; end architecture; nvc-r1.17.1/test/regress/logical3.vhd000066400000000000000000000011401504111170000173640ustar00rootroot00000000000000entity logical3 is end entity; architecture test of logical3 is signal v : bit_vector(1 to 3); begin process is begin v <= "110"; wait for 1 ns; assert and v = '0'; assert nand v = '1'; assert or v = '1'; assert nor v = '0'; assert xor v = '0'; assert xnor v = '1'; v <= "111"; wait for 1 ns; assert and v = '1'; assert nand v = '0'; assert or v = '1'; assert nor v = '0'; assert xor v = '1'; assert xnor v = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/loop1.vhd000066400000000000000000000017121504111170000167260ustar00rootroot00000000000000entity loop1 is end entity; architecture test of loop1 is begin process is variable a, b, c : integer; begin a := 0; loop exit when a = 10; a := a + 1; end loop; assert a = 10; a := 0; b := 0; loop a := a + 1; next when (a mod 2) = 0; b := b + 1; exit when b = 10; end loop; assert b = 10; assert a = 19; a := 0; b := 0; loop a := a + 1; if (a mod 2) = 0 then next; end if; b := b + 1; exit when b = 10; end loop; assert b = 10; assert a = 19; a := 0; outer: loop for i in 1 to 10 loop a := a + 1; exit outer when a = 50; end loop; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/mixed1.v000066400000000000000000000001341504111170000165440ustar00rootroot00000000000000`timescale 1ps/1ps module clkbuf (input i, output o); assign o = i; endmodule // clkmux nvc-r1.17.1/test/regress/mixed1.vhd000066400000000000000000000013361504111170000170650ustar00rootroot00000000000000entity mixed1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mixed1 is component clkbuf is port ( i : in std_logic; o : out std_logic ); end component; signal i, o : std_logic; begin u: component clkbuf port map (i, o); test: process is begin assert o = 'U'; i <= '1'; wait for 1 ns; assert o = '1'; i <= 'H'; wait for 1 ns; assert o = '1'; i <= 'L'; wait for 1 ns; assert o = '0'; i <= 'Z'; wait for 1 ns; assert o = 'Z'; i <= '-'; wait for 1 ns; assert o = 'U'; wait; end process; end architecture; nvc-r1.17.1/test/regress/mixed2.v000066400000000000000000000004461504111170000165530ustar00rootroot00000000000000primitive multiplexer (mux, control, dataA, dataB); output mux; input control, dataA, dataB; table // control dataA dataB mux 0 1 ? : 1 ; // ? = 0 1 x 0 0 ? : 0 ; 1 ? 1 : 1 ; 1 ? 0 : 0 ; endtable endprimitive nvc-r1.17.1/test/regress/mixed2.vhd000066400000000000000000000014131504111170000170620ustar00rootroot00000000000000entity mixed2 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mixed2 is component multiplexer is port ( mux : out std_logic; control, dataA, dataB : in std_logic ); end component; signal mux, control, dataA, dataB : std_logic; begin uut: component multiplexer port map ( mux, control, dataA, dataB); check: process is begin wait for 0 ns; assert mux = 'U'; dataA <= '1'; dataB <= '0'; control <= '0'; wait for 1 ns; assert mux = '1'; control <= '1'; wait for 1 ns; assert mux = '0'; dataB <= '1'; wait for 1 ns; assert mux = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/mixed3.v000066400000000000000000000006431504111170000165530ustar00rootroot00000000000000primitive dff(q, cp, d); output q; input cp, d; reg q; initial q = 1'b1; table // (cp) d : q : q ; ? * : ? : - ; (?0) ? : ? : - ; (1x) ? : ? : - ; (x1) 0 : 0 : 0 ; (x1) 1 : 1 : 1 ; (0x) 0 : 0 : 0 ; (0x) 1 : 1 : 1 ; (01) 0 : ? : 0 ; (01) 1 : ? : 1 ; endtable endprimitive nvc-r1.17.1/test/regress/mixed3.vhd000066400000000000000000000012711504111170000170650ustar00rootroot00000000000000entity mixed3 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mixed3 is component dff is port ( q : out std_logic; cp, d : in std_logic ); end component; signal q, cp, d : std_logic := '0'; signal running : boolean; begin uut: component dff port map ( q, cp, d ); clkgen: cp <= not cp after 5 ns when running; check: process is begin assert q = '1'; wait for 0 ns; assert q = '1'; wait until falling_edge(cp); assert q = '0'; wait for 1 ps; assert q = '0'; d <= '1'; wait for 1 ps; assert q = '0'; wait until falling_edge(cp); assert q = '1'; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/mixed4.v000066400000000000000000000003301504111170000165450ustar00rootroot00000000000000module extend(i, o); parameter WIDTH; input i; output [WIDTH-1:0] o; assign o = {WIDTH{i}}; endmodule module combine(i, o); parameter WIDTH; input [WIDTH-1:0] i; output o; assign o = |i; endmodule nvc-r1.17.1/test/regress/mixed4.vhd000066400000000000000000000023461504111170000170720ustar00rootroot00000000000000entity mixed4 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mixed4 is component extend is generic ( WIDTH : integer ); port ( i : in std_logic; o : out std_logic_vector(WIDTH - 1 downto 0) ); end component; component combine is generic ( WIDTH : integer ); port ( i : in std_logic_vector(WIDTH - 1 downto 0); o : out std_logic ); end component; signal i1, o2 : std_logic; signal o1, i2 : std_logic_vector(7 downto 0); begin u1: component extend generic map (8) port map (i1, o1); u2: component combine generic map (8) port map (i2, o2); check: process is begin i1 <= '1'; wait for 1 ns; assert o1 = X"ff"; i1 <= '0'; wait for 1 ns; assert o1 = X"00"; i1 <= 'U'; wait for 1 ns; -- TODO: X is not propagated -- assert o = (7 downto 0 => 'U'); i2 <= X"00"; wait for 1 ns; assert o2 = '0'; i2 <= X"10"; wait for 1 ns; assert o2 = '1'; i2 <= X"AA"; wait for 1 ns; assert o2 = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/null1.vhd000066400000000000000000000022201504111170000167220ustar00rootroot00000000000000entity null1 is end entity; architecture test of null1 is type int_array is array (integer range <>) of integer; function get_null return int_array is variable b : int_array(7 to -999999) := (others => 0); begin return b; end function; function get_left(x : int_array) return integer is begin return x'left; end function; function get_right(x : int_array) return integer is begin return x'right; end function; begin process is variable a : int_array(0 to -1) := (others => 0); variable b : int_array(7 to -999999) := (others => 0); variable c : int_array(0 downto 1) := (others => 0); begin report integer'image(a'length); assert a'length = 0; report integer'image(b'length); assert b'length = 0; report integer'image(c'length); assert c'length = 0; a := get_null; assert get_left(b) = 7; -- This is probably wrong according to the LRM but we currently -- normalise the indexes of null arrays assert get_right(b) = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/null2.vhd000066400000000000000000000003571504111170000167340ustar00rootroot00000000000000entity null2 is end entity; architecture test of null2 is signal x : bit_vector(0 downto 1); begin process is begin x <= (others => '0'); assert x'length = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/null3.vhd000066400000000000000000000013671504111170000167370ustar00rootroot00000000000000entity null3 is end entity; architecture test of null3 is type t is (apple, banana, cherry); type ta is array (t range <>) of integer; function encode (d : t) return string is constant offset : natural := 0; begin return (1 => character'val(t'pos(d) + offset)); end function; function encode (a : ta) return string is variable r : string(1 to 2 + a'length); begin assert not a'ascending; r(1 to 1) := encode(a'left); r(2 to 2) := encode(a'right); return r; end function; begin p1: process is variable n : ta(apple downto banana); begin assert encode(n) = (character'val(0), character'val(1)); wait; end process; end architecture; nvc-r1.17.1/test/regress/open1.vhd000066400000000000000000000016741504111170000167250ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity sub is port ( i0 : in std_logic_vector(4 downto 0) := "LLLLL"; o0 : out std_logic_vector(1 downto 0) ); end entity; architecture test of sub is begin p1: process is begin report to_string(i0); assert i0 = "LU0L1"; o0 <= "11"; wait for 1 ns; assert i0 = "L11L1"; wait; end process; end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity open1 is end entity; architecture test of open1 is signal x : std_logic_vector(1 downto 0) := "Z0"; begin u: entity work.sub port map ( i0(4) => open, i0(3 downto 2) => x, i0(0) => '1', o0(1) => x(1), o0(0) => open ); p1: process is begin x <= "Z1"; wait; end process; end architecture; nvc-r1.17.1/test/regress/open2.vhd000066400000000000000000000005641504111170000167230ustar00rootroot00000000000000entity open2 is end entity; architecture test of open2 is begin b: block is port ( s : in string := "hello" ); port map ( open ); begin check: process is begin assert s = "hello"; assert s'left = 1; assert s'right = 5; wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/operator1.vhd000066400000000000000000000007411504111170000176110ustar00rootroot00000000000000entity operator1 is end entity; architecture test of operator1 is type t is (A, B); function "and"(x, y : t) return t is begin if x = y then return A; else return B; end if; end function; begin process is variable x, y : t; begin x := A; y := A; assert (x and y) = A; y := B; assert (x and y) = B; wait; end process; end architecture; nvc-r1.17.1/test/regress/operator2.vhd000066400000000000000000000015331504111170000176120ustar00rootroot00000000000000entity operator2 is end entity; architecture test of operator2 is type t is (A, B); type tv is array (integer range <>) of t; function "and"(x, y : t) return t is begin if x = y then return A; else return B; end if; end function; function "and"(x, y : tv) return tv is variable tmp : tv(x'range); begin for i in x'range loop tmp(i) := x(i) and y(i); end loop; return tmp; end function; begin process is variable x, y : t; variable xv, yv : tv(1 to 2); begin x := A; y := A; assert (x and y) = A; y := B; assert (x and y) = B; xv := (A, B); yv := (B, B); assert (xv and yv) = (B, A); wait; end process; end architecture; nvc-r1.17.1/test/regress/operator3.vhd000066400000000000000000000016461504111170000176200ustar00rootroot00000000000000entity operator3 is end entity; architecture test of operator3 is type int_array is array (integer range <>) of integer; begin process is variable x : int_array(1 to 3); variable y : bit_vector(1 to 3); begin x := (1, 2, 3); assert x < (2, 2, 3); assert x > (0, 0, 0); assert x < (1, 2, 4); assert x < (1, 2, 3, 4); assert not (x < (1, 2)); assert x <= (1, 2, 3); assert x >= (1, 2, 3); assert x >= (1, 1, 1); y := "000"; assert not (y < "000"); assert not (y < "00"); assert not ("000" < y); assert "00" < y; assert y <= "000"; assert not (y <= "00"); assert "000" <= y; assert "00" <= y; assert not (y > "000"); assert not ("000" > y); assert y > "00"; assert not ("00" > y); wait; end process; end architecture; nvc-r1.17.1/test/regress/operator4.vhd000066400000000000000000000007401504111170000176130ustar00rootroot00000000000000entity operator4 is end entity; architecture test of operator4 is type byte_vec is array (integer range <>) of bit_vector(7 downto 0); begin process is variable v : byte_vec(1 to 3); begin v := ( X"01", X"02", X"03" ); assert v = ( X"01", X"02", X"03" ); assert v /= ( X"01", X"02", X"05" ); assert v /= ( X"01", X"02", X"03", X"04" ); assert v /= ( X"01", X"02" ); wait; end process; end architecture; nvc-r1.17.1/test/regress/operator5.vhd000066400000000000000000000014631504111170000176170ustar00rootroot00000000000000package pack is type int_vec2 is array (integer range <>) of integer; type int_vec is array (integer range <>) of integer; function "<"(a, b : int_vec) return boolean; end package; package body pack is function "<"(a, b : int_vec) return boolean is begin return false; end function; end package body; entity operator5 is end entity; use work.pack.all; architecture test of operator5 is function ">="(a, b : int_vec) return boolean is begin return false; end function; begin process is variable x, y : int_vec(1 to 3); begin x := (1, 2, 3); y := (4, 5, 6); assert not (y >= x); assert (int_vec2(y) >= int_vec2(x)); assert not (y < x) and not (x < y); wait; end process; end architecture; nvc-r1.17.1/test/regress/operator6.vhd000066400000000000000000000030601504111170000176130ustar00rootroot00000000000000entity operator6 is end entity; architecture test of operator6 is function "=" (L: bit; R: bit) return bit is begin report "custom bit =" severity failure; return L xnor R; end function "="; function "/=" (L: bit; R: bit) return bit is begin report "custom bit /=" severity failure; return L xor R; end function "/="; function "=" (L: bit_vector; R: bit_vector) return bit is begin report "custom bit_vector =" severity failure; if L = R then return '1'; else return '0'; end if; end function "="; function "/=" (L: bit_vector; R: bit_vector) return bit is begin report "custom bit_vector /=" severity failure; if L /= R then return '1'; else return '0'; end if; end function "/="; constant ID_FLAG_C_SHF : bit_vector(1 to 3) := "100"; constant ID_RMW_SHF : bit := '1'; -- ** Note: 3972750ns+1: Report Note: bad else: s1_id_flag_c = 4 s1_id_rmw = '0' signal s1_id_flag_c : bit_vector(1 to 3) := ID_FLAG_C_SHF; signal s1_id_rmw : bit := '0'; begin p1: process is begin -- report "bad else: s1_id_flag_c = " & integer'image(to_integer(unsigned(s1_id_flag_c))) & " s1_id_rmw = " & bit'image(to_bit(s1_id_rmw)); if s1_id_flag_c = ID_FLAG_C_SHF then report "s1_id_flag_c = ID_FLAG_C_SHF"; end if; if s1_id_rmw /= ID_RMW_SHF then report "s1_id_rmw /= ID_RMW_SHF"; end if; assert s1_id_flag_c = ID_FLAG_C_SHF and s1_id_rmw /= ID_RMW_SHF; wait; end process; end architecture; nvc-r1.17.1/test/regress/order1.vhd000066400000000000000000000007711504111170000170740ustar00rootroot00000000000000package pack1 is type t is (A, B, C); type t_vec is array (natural range <>) of t; end package; package pack1 is type t is (C, B, A); -- Redefine t type t_vec is array (1 to 2) of t; constant x : boolean := t_vec'(A, A) < t_vec'(C, C); -- Should not fold! end package; entity order1 is end entity; use work.pack1.all; architecture test of order1 is begin main: process is begin assert x = false; wait; end process; end architecture; nvc-r1.17.1/test/regress/order2.sh000066400000000000000000000011431504111170000167200ustar00rootroot00000000000000set -xe pwd which nvc nvc -a - <err; then echo "should have failed!" exit 1 fi grep "design unit depends on WORK.PACK with checksum" err || exit 1 nvc-r1.17.1/test/regress/order3.sh000066400000000000000000000002061504111170000167200ustar00rootroot00000000000000set -xe pwd which nvc nvc -a $TESTDIR/regress/elab1.vhd $TESTDIR/regress/elab1.vhd nvc -e elab1 # Would fail with checksum error nvc-r1.17.1/test/regress/order4.sh000066400000000000000000000002661504111170000167270ustar00rootroot00000000000000set -xe pwd which nvc ! nvc -a $TESTDIR/regress/order4.vhd 2>err grep "package WORK.P2 depends on an obsolete" err grep "architecture WORK.ORDER4-TEST depends on an obsolete" err nvc-r1.17.1/test/regress/order4.vhd000066400000000000000000000011721504111170000170730ustar00rootroot00000000000000package p1 is constant c1 : integer := 5; end package; ------------------------------------------------------------------------------- use work.p1.all; package p2 is constant c2 : integer := c1; end package; ------------------------------------------------------------------------------- package p1 is constant c1 : integer := 6; end package; ------------------------------------------------------------------------------- entity order4 is end entity; use work.p1.all; use work.p2.all; architecture test of order4 is begin assert c1 = 6; assert c2 = 6; end architecture; -- Error when saving this file nvc-r1.17.1/test/regress/param1.v000066400000000000000000000005411504111170000165400ustar00rootroot00000000000000module param1; wire [7:0] o1, o2; sub #(42) u1(o1); sub #(55) u2(o2); initial begin #1; $display("%d %d", o1, o2); if (o1 === 42 && o2 == 55) $display("PASSED"); else $display("FAILED"); $finish; end endmodule // param1 module sub(o); output [7:0] o; parameter x = 5; assign o = x; endmodule // sub nvc-r1.17.1/test/regress/predef1.vhd000066400000000000000000000130271504111170000172240ustar00rootroot00000000000000entity predef1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of predef1 is type my_int is range 1 to 10; type my_enum is (X, Y, FOO, BAR); type int_vector is array (natural range <>) of integer; type my_char is ('a', 'b', 'c'); type char_vector is array (natural range <>) of my_char; type my_phs is range 0 to 1000 units u_foo; u_bar = 10 u_foo; end units; signal sa : bit := '0'; signal sb : boolean := true; signal sl : std_logic := '0'; signal sv : bit_vector(1 to 3); signal sx : std_logic_vector(1 to 3); begin main: process is variable b : boolean; variable i : integer; variable m : my_int; variable e : my_enum; variable r : real := 1.23456; variable v : int_vector(1 to 3) := (1, 2, 3); variable c : char_vector(1 to 3) := "bca"; begin ----------------------------------------------------------------------- -- MINIMUM assert minimum(1, 2) = 1; m := 5; b := true; wait for 1 ns; assert minimum(4, m) = 4; assert minimum(b, false) = false; assert minimum(int_vector'(5, -1, 2)) = -1; assert minimum(v) = 1; ----------------------------------------------------------------------- -- MAXIMUM assert maximum(2, 1) = 2; m := 6; wait for 1 ns; assert maximum(4, m) = 6; assert maximum(b, false) = true; assert maximum(int_vector'(5, -1, 2)) = 5; assert maximum(v) = 3; assert maximum(1 ns, 1 hr) = 1 hr; ----------------------------------------------------------------------- -- TO_STRING assert to_string(my_int'(7)) = "7"; assert to_string(m) = "6"; assert to_string(foo) = "foo"; assert to_string(e) = my_enum'image(e); report to_string(now); assert to_string(now) = "2000000 fs"; report to_string(now, ns); assert to_string(now, ns) = "2 ns"; assert to_string(50 ns, unit => us) = "0.05 us"; assert to_string(value => 1 min, unit => hr) = "0.0166666666666667 hr"; assert to_string(1310408750 ps, unit => ns) = "1310408.75 ns"; assert to_string(r)(1 to 7) = "1.23456"; report to_string(r, 2); assert to_string(r, 2) = "1.23"; report to_string(r, 0); assert to_string(r, 0)(1 to 7) = "1.23456"; report to_string(r, "%1.1f"); assert to_string(r, "%1.1f") = "1.2"; r := 0.0000000005; report to_string(value => r, digits => 9); report to_string(char_vector'("abc")); assert to_string(char_vector'("abc")) = "abc"; assert to_string(c) = "bca"; assert to_string(bit_vector'("110")) = "110"; assert to_string(bit_vector'("110")) & "..." = "110..."; assert to_string(1 ns) = "1000000 fs"; assert to_string(1 u_bar) = "10 u_foo"; assert to_string(bit'( '1' )) = "1"; assert to_string(character'( 'X' )) = "X"; ----------------------------------------------------------------------- -- TO_BSTRING assert to_bstring(bit_vector'("101")) = "101"; ----------------------------------------------------------------------- -- TO_HSTRING report to_hstring(bit_vector'("10101111")); assert to_hstring(bit_vector'("10101111")) = "AF"; assert to_hstring(bit_vector'("01100")) = "0C"; assert to_hex_string(bit_vector'("111")) = "7"; ----------------------------------------------------------------------- -- TO_OSTRING report to_ostring(bit_vector'("10101111")); assert to_ostring(bit_vector'("10101111")) = "257"; assert to_ostring(bit_vector'("01100")) = "14"; assert to_octal_string(bit_vector'("0")) = "0"; ----------------------------------------------------------------------- -- RISING_EDGE / FALLING_EDGE sa <= '1'; sb <= false; wait for 0 ns; assert sa'event and sa = '1'; assert rising_edge(sa); assert not falling_edge(sa); assert sb'event and sb = false; assert not rising_edge(sb); assert falling_edge(sb); ----------------------------------------------------------------------- -- Matching comparison sa <= '1'; wait for 0 ns; assert (sa ?= '1') = '1'; assert (sa ?/= '0') = '1'; assert (sa ?< '1') = '0'; assert (sa ?<= '1') = '1'; assert (sa ?> '0') = '1'; assert (sa ?>= '1') = '1'; sl <= '1'; wait for 0 ns; assert (sl ?= '1') = '1'; assert (sl ?/= '0') = '1'; assert (sl ?< '1') = '0'; assert (sl ?<= '1') = '1'; assert (sl ?> '0') = '1'; assert (sl ?>= '1') = '1'; assert (sl ?= 'Z') = 'X'; assert (sl ?< 'H') = '0'; assert ('0' ?<= sl) = '1'; sv <= "111"; wait for 0 ns; assert (sv ?= "111") = '1'; assert (sv ?= "011") = '0'; assert (sv ?/= "000") = '1'; ----------------------------------------------------------------------- -- Mixed array/scalar bit_vector operations sa <= '1'; sv <= "101"; wait for 1 ns; assert (sa and sv) = "101"; assert (sa or sv) = "111"; assert (sv xor sa) = "010"; assert (sv nor sa) = "000"; assert (sv nand sa) = "010"; assert (sa xnor sv) = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/predef2.vhd000066400000000000000000000015321504111170000172230ustar00rootroot00000000000000entity predef2 is end entity; architecture test of predef2 is type int_vector is array (natural range <>) of integer; type bit_vector is array (natural range <>) of bit; begin main: process is variable p, q : int_vector(1 to 3); variable bv1 : bit_vector(3 downto 0); variable iv1 : int_vector(3 downto 0); variable b1 : bit; variable int1 : integer; begin p := (1, 2, 3); q := (4, 5, 6); wait for 1 ns; assert p < q; assert minimum(p, q) = (1, 2, 3); assert maximum(p, q) = (4, 5, 6); bv1 := "0100"; b1 := maximum (bv1); assert b1 = '1' report to_string(b1); iv1 := (5, 4, 30, 2); int1 := minimum(iv1); assert int1 = 2 report to_string(int1); wait; end process; end architecture; nvc-r1.17.1/test/regress/predef3.vhd000066400000000000000000000016621504111170000172300ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity predef3 is end entity; architecture test of predef3 is type sub_t is record f : unsigned(1 to 2); end record; function "=" (x, y : sub_t) return boolean is begin return false; end function; type rec_t is record x : unsigned(7 downto 0); y : integer; z : sub_t; end record; type mem_t is array (natural range <>) of sub_t; begin p1: process is variable r : rec_t; variable m : mem_t(1 to 2); begin r.x := "10X01U-H"; r.y := 5; r.z.f := "0U"; wait for 1 ns; assert r = ("10X01U-H", 5, (f => "0U")); assert r /= ("10X01U-H", 5, (f => "0-")); m(1) := (f => "1U"); m(2) := (f => "10"); wait for 1 ns; assert m = ((f => "1U"), (f => "10")); wait; end process; end architecture; nvc-r1.17.1/test/regress/predef4.vhd000066400000000000000000000010441504111170000172230ustar00rootroot00000000000000entity predef4 is end entity; architecture test of predef4 is type FREQ is range 0 to integer'high units Hz; kHz = 1000 Hz; MHz = 1000 kHz; GHz = 1000 MHz; end units; type T_FREQVEC is array(natural range <>) of FREQ; begin p1: process is variable v : t_freqvec(1 to 3); begin v := ( 1 hz, 10 khz, 3 mhz ); wait for 1 ns; assert minimum(v) = 1 hz; assert maximum(v) = 3 mhz; wait; end process; end architecture; nvc-r1.17.1/test/regress/predef5.vhd000066400000000000000000000012201504111170000172200ustar00rootroot00000000000000package pack is type t_abc is (a, b, c); subtype t_sub is t_abc range a to c; function "=" (x, y : t_abc) return boolean; end package; package body pack is function "=" (x, y : t_abc) return boolean is begin report "called overloaded ="; return true; end function; end package body; ------------------------------------------------------------------------------- use work.pack.t_sub; entity predef5 is end entity; architecture test of predef5 is begin tb: process is variable x : t_sub := a; begin wait for 1 ns; assert x = c; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc1.vhd000066400000000000000000000005741504111170000167250ustar00rootroot00000000000000entity proc1 is end entity; architecture test of proc1 is procedure add1(x : in integer; y : out integer) is begin y := x + 1; end procedure; begin process is variable a, b : integer; begin a := 2; add1(a, b); assert b = 3; add1(5, b); assert b = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc10.vhd000066400000000000000000000011741504111170000170020ustar00rootroot00000000000000entity proc10 is end entity; architecture test of proc10 is begin process is variable x : integer; variable v : bit_vector(7 downto 0); procedure change(b : bit) is begin v(x) := b; end procedure; procedure change_after(b : bit; t : time) is begin wait_here: wait for 1 ns; change: v(x) := b; end procedure; begin v := X"00"; x := 1; change('1'); assert v = X"02"; x := 7; change_after('1', 10 ns); assert v = X"82"; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc11.vhd000066400000000000000000000011631504111170000170010ustar00rootroot00000000000000entity proc11 is end entity; architecture test of proc11 is function count_bits(x : in bit_vector) return natural is variable r : natural := 0; begin for i in x'range loop if x(i) = '1' then r := r + 1; end if; end loop; return r; end function; procedure proc(signal x : in bit_vector) is begin wait for 1 ns; assert count_bits(x) = 0; wait for 5 ns; assert count_bits(x) = 4; end procedure; signal s : bit_vector(1 to 8); begin s <= X"aa" after 2 ns; proc(s); end architecture; nvc-r1.17.1/test/regress/proc12.vhd000066400000000000000000000020341504111170000170000ustar00rootroot00000000000000package pack is procedure check (i, o : integer); procedure debug (i, o : integer); end package; package body pack is procedure check (i, o : integer) is begin assert i < o; end procedure; procedure debug (i, o : integer) is begin report "i=" & integer'image(i) & " o=" & integer'image(o); end procedure; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : in integer; o : out integer := integer'right ); begin debug(i, o); postponed check(i, o); end entity; architecture test of sub is begin o <= i + 1; end architecture; ------------------------------------------------------------------------------- entity proc12 is end entity; architecture test of proc12 is signal i, o : integer; begin u: entity work.sub port map (i, o); p1: process is begin i <= 5; wait for 1 ns; assert o = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc13.vhd000066400000000000000000000017561504111170000170130ustar00rootroot00000000000000package pack is constant def : integer; procedure test1 (x : integer := def); procedure test2 (x : integer := 1 / 0); type pt is protected procedure test3 (x : integer := def); end protected; end package; package body pack is constant def : integer := 42; procedure test1 (x : integer := def) is begin wait for 1 ns; end procedure; procedure test2 (x : integer := 1 / 0) is begin wait for 1 ns; end procedure; type pt is protected body procedure test3 (x : integer := def) is begin end procedure; end protected body; end package body; ------------------------------------------------------------------------------- entity proc13 is end entity; use work.pack.all; architecture test of proc13 is shared variable sv : pt; begin main: process is begin test1; sv.test3; test2; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/proc2.vhd000066400000000000000000000012651504111170000167240ustar00rootroot00000000000000entity proc2 is end entity; architecture test of proc2 is type int_array is array (integer range <>) of integer; procedure fill(a : out int_array) is begin for i in a'range loop a(i) := a'length; end loop; end procedure; procedure fill2(a : out int_array; v : in integer) is begin a := (6, 6, 6); end procedure; begin process is variable x : int_array(1 to 3); variable y : int_array(5 to 6); begin fill(x); assert x = (3, 3, 3); fill(y); assert y = (2, 2); fill2(x, 6); assert x = (6, 6, 6); wait; end process; end architecture; nvc-r1.17.1/test/regress/proc3.vhd000066400000000000000000000027731504111170000167320ustar00rootroot00000000000000package pack is function func(x : in integer) return integer; end package; package body pack is procedure p5(x : in integer; y : out integer) is variable k : integer := x + 1; begin y := k; end procedure; function func(x : in integer) return integer is variable y : integer; begin p5(x, y); return y; end function; end package body; ------------------------------------------------------------------------------- entity proc3 is end entity; use work.pack.all; architecture test of proc3 is procedure p1 is begin wait for 10 ns; wait for 5 ns; end procedure; procedure p2 is begin p1; p1; end procedure; procedure p3(t : in time) is begin loop wait for t; if now >= 100 ns then return; end if; end loop; end procedure; procedure p4(x : in integer; y : out integer) is variable k : integer; begin k := x; for i in 1 to 5 loop k := k + 1; wait for 1 ns; end loop; y := k; end procedure; begin process is variable x : integer; begin p1; assert now = 15 ns; p2; assert now = 45 ns; p3(5 ns); assert now = 100 ns; p4(5, x); assert x = 10; assert now = 105 ns; x := func(x); assert x = 11; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc4.vhd000066400000000000000000000025331504111170000167250ustar00rootroot00000000000000entity proc4 is end entity; architecture rtl of proc4 is procedure test1(x : inout integer) is begin x := x + 1; end procedure; procedure test2(x : inout bit_vector) is begin for i in x'range loop x(i) := not x(i); end loop; end procedure; procedure test3(x : inout bit_vector(3 downto 0)) is begin for i in 3 downto 0 loop x(i) := not x(i); end loop; end procedure; procedure test4(signal x : inout integer) is begin x <= x + 1; end procedure; procedure test5(signal x : inout bit_vector; l : out integer) is begin l := x'length; for i in x'range loop x(i) <= not x(i); end loop; end procedure; signal s : integer; signal k : bit_vector(1 downto 0); begin process is variable v : integer; variable b : bit_vector(3 downto 0); begin k <= "10"; v := 5; test1(v); assert v = 6; b := "1010"; test2(b); assert b = "0101"; test3(b); assert b = "1010"; s <= 5; wait for 1 ns; test4(s); wait for 1 ns; assert s = 6; test5(k, v); wait for 1 ns; assert v = 2; assert k = "01"; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc5.vhd000066400000000000000000000016551504111170000167320ustar00rootroot00000000000000entity proc5 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of proc5 is procedure next_cycle(signal clk : in std_logic; n : in integer := 1) is begin for i in 1 to n loop wait until rising_edge(clk); wait for 1 ns; end loop; end procedure; procedure create_clock ( signal clk : inout std_logic; period : in delay_length; signal running : in boolean ) is begin if running then clk <= not clk after period / 2; end if; end procedure; signal running : boolean := true; signal clk : std_logic := '1'; begin process (clk, running) is begin create_clock(clk, 20 ns, running); end process; process is begin next_cycle(clk, 50); assert now = 1001 ns; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc6.vhd000066400000000000000000000010751504111170000167270ustar00rootroot00000000000000entity proc6 is end entity; architecture test of proc6 is procedure delay(signal x : out integer; signal y : in integer; constant d : in delay_length) is begin x <= y after d; end procedure; signal a, b : integer; begin foo: delay(a, b, 10 ns); check: process is begin b <= 6; wait for 11 ns; assert a = 6; b <= 7; wait for 5 ns; assert a = 6; wait for 5 ns; assert a = 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/proc7.vhd000066400000000000000000000011661504111170000167310ustar00rootroot00000000000000entity proc7 is end entity; architecture test of proc7 is procedure foo(signal b : in bit_vector; i : in integer) is variable c : bit_vector(b'range); begin assert c(c'left) = '0'; --wait for 1 ns; for i in b'range loop c(i) := b(i); end loop; wait for 1 ns; for i in c'range loop report bit'image(c(i)); end loop; end procedure; signal s : bit_vector(1 to 3) := ( '1', '0', '1' ); begin process is begin s <= "110"; foo(s, 1); foo(s, 1); wait; end process; end architecture; nvc-r1.17.1/test/regress/proc8.vhd000066400000000000000000000016711504111170000167330ustar00rootroot00000000000000entity proc8 is end entity; architecture test of proc8 is type int_vec is array (integer range <>) of integer; subtype int_vec4 is int_vec(1 to 4); procedure p1(signal y : in int_vec) is begin for i in y'range loop report integer'image(y(i)); end loop; end procedure; procedure p1b(variable y : in int_vec4) is begin for i in y'range loop report integer'image(y(i)); end loop; end procedure; procedure p2(signal x : in int_vec4) is begin p1(x); end procedure; procedure p3(signal x : out int_vec) is begin x <= (6, 7, 8, 9); end procedure; signal s : int_vec4 := (1, 2, 3, 4); begin process is variable k : int_vec4 := (-1, -2, -3, -4); begin p2(s); p3(s); wait for 1 ns; assert s = (6, 7, 8, 9); p1b(k); wait; end process; end architecture; nvc-r1.17.1/test/regress/proc9.vhd000066400000000000000000000006511504111170000167310ustar00rootroot00000000000000entity proc9 is end entity; architecture test of proc9 is procedure foo (x : in integer; y : out bit_vector) is constant c : bit_vector(1 to x) := (others => '1'); begin wait for 1 ns; y := c; end procedure; begin process is variable b : bit_vector(1 to 5); begin foo(5, b); assert b = (1 to 5 => '1'); wait; end process; end architecture; nvc-r1.17.1/test/regress/protected1.vhd000066400000000000000000000023311504111170000177440ustar00rootroot00000000000000entity protected1 is end entity; architecture test of protected1 is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; type SharedCounter is protected body variable counter: Integer := 0; variable dummy: Integer; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; shared variable x : SharedCounter; begin process is begin assert x.value = 0; x.increment; report "value is now " & integer'image(x.value); x.increment(2); assert x.value = 3; wait; end process; process is begin wait for 1 ns; assert x.value = 3; x.decrement; assert x.value = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected10.vhd000066400000000000000000000025731504111170000200340ustar00rootroot00000000000000entity protected10 is end entity; architecture test of protected10 is type counter_t is protected procedure increment; procedure decrement; impure function value return natural; end protected; type counter_t is protected body variable val : natural := 0; procedure increment is begin val := val + 1; end procedure; procedure decrement is begin val := val - 1; end procedure; impure function value return natural is begin return val; end function; end protected body; type counter_ptr_t is access counter_t; procedure call_increment (p : inout counter_ptr_t; n : in natural) is begin for i in 1 to n loop p.increment; end loop; end procedure; begin p1: process is variable p, p2 : counter_ptr_t; begin p := new counter_t; assert p.all.value = 0; p.increment; assert p.value = 1; call_increment(p, 5); assert p.value = 6; wait for 1 ns; for i in 1 to 10 loop -- Make sure the allocation of P was not in the thread local buffer p2 := new counter_t; end loop; assert p.value = 6; deallocate(p); assert p = null; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected11.vhd000066400000000000000000000020001504111170000200160ustar00rootroot00000000000000entity protected11 is end entity; architecture test of protected11 is procedure do_something; procedure do_wait; type pt is protected procedure proc; end protected; type pt is protected body variable count : natural; procedure proc(arg : integer); procedure proc is begin count := count + 1; assert count = 1; proc(5); assert count = 2; proc(-1); end procedure; procedure proc(arg : integer) is begin count := count + 1; do_something; if arg < 0 then do_wait; -- Error end if; end procedure; end protected body; procedure do_something is begin end procedure; procedure do_wait is begin wait for 1 ns; end procedure; shared variable v : pt; begin tb: process is begin v.proc; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected12.vhd000066400000000000000000000023671504111170000200370ustar00rootroot00000000000000entity protected12 is end entity; architecture test of protected12 is type t_counter is protected procedure increment; impure function get return natural; end protected; type t_counter is protected body variable count : natural; procedure increment is begin count := count + 1; end procedure; impure function get return natural is begin return count; end function; end protected body; type t_test is protected private variable c1 : t_counter; private variable c2 : t_counter; alias inc1 is c1.increment []; alias inc2 is c2.increment []; alias get1 is c1.get [return natural]; alias get2 is c2.get [return natural]; impure function sum return natural; end protected; type t_test is protected body impure function sum return natural is begin return get1 + get2; end function; end protected body; shared variable sv : t_test; begin tb: process is begin sv.inc1; sv.inc2; wait for 1 ns; assert sv.get1 = 1; sv.inc2; assert sv.sum = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected13.vhd000066400000000000000000000014121504111170000200260ustar00rootroot00000000000000entity protected13 is end entity; architecture test of protected13 is type t_test is protected impure function get_path return string; end protected; type t_test is protected body variable v : integer; impure function get_path return string is begin return v'path_name; end function; end protected body; type t_test_ptr is access t_test; impure function make_test return t_test_ptr is begin return new t_test; end function; begin p1: process is begin report make_test.get_path; -- The LRM doesn't seem to specify this assert make_test.get_path = ":protected13:make_test[return t_test_ptr]::v"; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected2.vhd000066400000000000000000000026551504111170000177560ustar00rootroot00000000000000package pack is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; end package; package body pack is type SharedCounter is protected body constant INIT : integer := 5; variable counter: Integer := INIT; variable dummy: Integer; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; end package body; ------------------------------------------------------------------------------- entity protected2 is end entity; use work.pack.all; architecture test of protected2 is shared variable x : SharedCounter; begin process is begin assert x.value = 5; x.increment; report "value is now " & integer'image(x.value); x.increment(2); assert x.value = 8; wait; end process; process is begin wait for 1 ns; assert x.value = 8; x.decrement; assert x.value = 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected3.vhd000066400000000000000000000020611504111170000177460ustar00rootroot00000000000000entity protected3 is end entity; architecture test of protected3 is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; type SharedCounter is protected body variable counter: Integer := 0; variable dummy: Integer; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; procedure do_inc(p : inout SharedCounter) is begin p.increment; end procedure; shared variable x : SharedCounter; begin process is begin do_inc(x); assert x.value = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected4.vhd000066400000000000000000000011161504111170000177470ustar00rootroot00000000000000entity protected4 is end entity; architecture test of protected4 is type p is protected procedure init(path : string); end protected; type p is protected body type ft is file of integer; file f : ft; procedure init(path : string) is begin file_open(f, path, WRITE_MODE); end procedure; end protected body; procedure run_test is variable x : p; begin x.init("data"); end procedure; begin process is begin run_test; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected5.vhd000066400000000000000000000027641504111170000177620ustar00rootroot00000000000000-- The order of design units in the file is significant package pack1 is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is shared variable sv : SharedCounter; end package; ------------------------------------------------------------------------------- entity protected5 is end entity; use work.pack2.all; architecture test of protected5 is begin p1: process is begin sv.increment; sv.increment; wait for 0 ns; assert sv.value = 3; wait; end process; p2: process is begin sv.increment; wait; end process; end architecture; ------------------------------------------------------------------------------- package body pack1 is type SharedCounter is protected body variable counter: Integer := 0; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; end package body; nvc-r1.17.1/test/regress/protected6.vhd000066400000000000000000000021641504111170000177550ustar00rootroot00000000000000entity protected6 is end entity; architecture test of protected6 is type p is protected impure function sum return integer; end protected; type p is protected body type int_vector is array (natural range <>) of integer; variable v : int_vector(1 to 2 ** 20) := (others => 1); variable q : int_vector(1 to 500) := (others => 2); impure function sum return integer is variable r : integer := 0; begin for i in v'range loop r := r + v(i); end loop; for i in q'range loop r := r + q(i); end loop; return r; end function; end protected body; procedure run_test (check : boolean) is -- Quickly exhausts memory if not cleaned up variable x : p; begin if check then assert x.sum = (2 ** 20) + (500 * 2); end if; end procedure; begin process is begin for i in 1 to 10 loop run_test(false); end loop; run_test(true); wait; end process; end architecture; nvc-r1.17.1/test/regress/protected7.vhd000066400000000000000000000025161504111170000177570ustar00rootroot00000000000000package pack is type id_alloc_t is protected impure function next_id return integer; end protected; type rec_t is record id : integer; end record; impure function get_next_rec return rec_t; end package; package body pack is type id_alloc_t is protected body variable counter : integer := 0; impure function next_id return integer is begin counter := counter + 1; return counter; end function; end protected body; shared variable id_alloc : id_alloc_t; impure function get_next_rec return rec_t is begin return (id => id_alloc.next_id); end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r1, r2 : rec_t ); end entity; architecture test of sub is begin p1: process is begin assert r1.id = 1; assert r2.id = 2; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity protected7 is end entity; architecture test of protected7 is constant cr1 : rec_t := get_next_rec; constant cr2 : rec_t := get_next_rec; begin u: entity work.sub generic map ( cr1, cr2 ); end architecture; nvc-r1.17.1/test/regress/protected8.vhd000066400000000000000000000017221504111170000177560ustar00rootroot00000000000000entity protected8 is end entity; architecture test of protected8 is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; type SharedCounter is protected body variable counter: Integer := 0; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; shared variable v : SharedCounter; begin p1: v.increment(n => 5); p2: process is begin wait for 1 ns; assert v.value = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/protected9.vhd000066400000000000000000000025211504111170000177550ustar00rootroot00000000000000package pack is type counter_t is protected procedure increment; impure function get return integer; end protected; end package; package body pack is type counter_t is protected body variable value : natural; procedure increment is begin value := value + 1; end procedure; impure function get return integer is begin return value; end function; end protected body; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( variable sv : inout counter_t ); end entity; architecture test of sub is begin p1: process is begin for i in 1 to 10 loop sv.increment; wait for 1 ns; end loop; wait; end process; end architecture; ------------------------------------------------------------------------------- entity protected9 is end entity; use work.pack.all; architecture test of protected9 is shared variable sv : counter_t; begin u: entity work.sub port map ( sv ); check: postponed process is begin assert sv.get = 1; wait for 5 ns; assert sv.get = 5; wait for 5 ns; assert sv.get = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/psl1.vhd000066400000000000000000000013531504111170000165540ustar00rootroot00000000000000entity psl1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl1 is signal clk : std_logic := '0'; signal x, y : std_logic := '0'; signal running : boolean := true; -- psl default clock is rising_edge(clk); begin -- psl a1: assert always x or y; -- psl a2: assert always x -> next y; clkgen: clk <= not clk after 5 ns when running; stim: process is begin wait until falling_edge(clk); x <= '1'; wait until falling_edge(clk); x <= '0'; y <= '1'; wait until falling_edge(clk); x <= '1'; y <= '0'; wait until falling_edge(clk); running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/psl10.vhd000066400000000000000000000013231504111170000166310ustar00rootroot00000000000000entity psl10 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl10 is signal clk : std_logic := '0'; signal a, b : std_logic := '0'; default clock is rising_edge(clk); procedure pulse (signal clk : out std_logic) is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin iff_impl: assert always a <-> b; stim: process is begin pulse(clk); b <= '1'; a <= '1'; pulse(clk); b <= '0'; a <= '0'; pulse(clk); b <= '1'; pulse(clk); -- Assertion fails here wait; end process; end architecture; nvc-r1.17.1/test/regress/psl11.vhd000066400000000000000000000014141504111170000166330ustar00rootroot00000000000000entity psl11 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl11 is signal clk : std_logic := '0'; signal a, b : std_logic := '0'; default clock is rising_edge(clk); procedure pulse (signal clk : out std_logic) is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin one: assert always a -> (eventually! b); two: assert always a -> (eventually! {not a; not a; b}); stim: process is begin pulse(clk); a <= '1'; pulse(clk); b <= '1'; a <= '0'; pulse(clk); a <= '1'; pulse(clk); std.env.finish; -- Assertion fails here end process; end architecture; nvc-r1.17.1/test/regress/psl12.vhd000066400000000000000000000017171504111170000166420ustar00rootroot00000000000000entity psl12 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl12 is signal clk, reset, areset : std_logic := '0'; signal a, b : std_logic := '0'; default clock is rising_edge(clk); procedure pulse (signal clk : out std_logic) is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin one: assert always (a -> next [2] (b)) sync_abort reset; two: assert (always (a -> next [2] (b))) async_abort areset; three: assert always (a -> next (b before a)); four: assert always (a -> next (not a or (b before_ a))); stim: process is begin a <= '1'; pulse(clk); a <= '0'; pulse(clk); reset <= '1'; -- Not asserted over clock edge areset <= '1'; wait for 1 fs; areset <= '0'; pulse(clk); pulse(clk); wait; end process; end architecture; nvc-r1.17.1/test/regress/psl13.vhd000066400000000000000000000013361504111170000166400ustar00rootroot00000000000000entity psl13 is end entity; architecture tb of psl13 is signal clk : natural; signal a,b,c,d : bit; constant seq_a : bit_vector := "0100" & "1000"; constant seq_b : bit_vector := "0010" & "0100"; constant seq_c : bit_vector := "0000" & "0010"; constant seq_d : bit_vector := "0001" & "0000"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 7; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); -- psl default clock is clk'delayed(0 ns)'event; -- Should fail at: 3 ns and 7 ns -- psl asrt_1 : assert always {a;b} |=> {c;d}; -- Should fail at 2 ns and 5 ns -- psl asrt_2 : assert always {a;b} |-> c; end architecture; nvc-r1.17.1/test/regress/psl14.vhd000066400000000000000000000025361504111170000166440ustar00rootroot00000000000000entity psl14 is end entity; architecture tb of psl14 is signal clk : natural; signal a,b,c,d,e : bit; constant seq_a : bit_vector := "1010101000000000"; constant seq_b : bit_vector := "0101010100000000"; constant seq_c : bit_vector := "0000000011100000"; constant seq_d : bit_vector := "0000011111110000"; constant seq_e : bit_vector := "0000000011111110"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 15; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); egen: e <= seq_e(clk); -- psl default clock is clk'event; -- Should be hit at: -- 6 ns - 3 repetitions (started at 0 ns) -- 8 ns - 4 repetitions (started at 0 ns) -- 8 ns - 3 repetitions (started at 2 ns) -- psl cov_1 : cover {a;b}[*3 to 4] report "cov_1 hit"; -- Should be hit at: -- 10 ns - First two ones from "111" in seq_c -- 11 ns - Last two ones from "111" in seq_c -- psl cov_2 : cover {c;c}[+] report "cov_2 hit"; -- Should be hit at: -- 12 ns - Sequence of "1111111" from seq_d -- psl cov_3 : cover {d}[*7] report "cov_3 hit"; -- Should be hit at: -- 13 ns - After 5 repetitions -- 14 ns - After 6 repetitions -- 15 ns - After 7 repetitions -- psl cov_5 : cover {e}[*5 to inf] report "cov_5 hit"; end architecture; nvc-r1.17.1/test/regress/psl15.vhd000066400000000000000000000061511504111170000166420ustar00rootroot00000000000000entity psl15 is end entity; architecture tb of psl15 is signal clk : natural; signal a,b,c,d,e,f,g,h,i,j,k,l : bit; -- Parts A B C constant seq_a : bit_vector := "1000" & "10000" & "1000000000"; constant seq_b : bit_vector := "0110" & "01010" & "0010100100"; constant seq_c : bit_vector := "0001" & "00001" & "0000001110"; -- Parts A B C constant seq_d : bit_vector := "1000" & "100000000" & "100000"; constant seq_e : bit_vector := "0110" & "001000100" & "011100"; constant seq_f : bit_vector := "0011" & "000100001" & "001010"; -- Parts A B constant seq_g : bit_vector := "100000000" & "1000000000"; constant seq_h : bit_vector := "001010100" & "0111000000"; constant seq_i : bit_vector := "000000010" & "0000010000"; -- Parts A constant seq_j : bit_vector := "1000000000000000000"; constant seq_k : bit_vector := "0101001001100100100"; constant seq_l : bit_vector := "0010100100010010000"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 18; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); egen: e <= seq_e(clk); fgen: f <= seq_f(clk); ggen: g <= seq_g(clk); hgen: h <= seq_h(clk); igen: i <= seq_i(clk); jgen: j <= seq_j(clk); kgen: k <= seq_k(clk); lgen: l <= seq_l(clk); -- psl default clock is clk'event; -- Should be covered at: -- 4 ns - Part A - Consecutive repeat -- 9 ns - Part B - Empty cycle in the middle -- 16 ns - Part C - Empty cycle in the start and back -- 17 ns - Part C - Same as previous, continuation of c -- Should not be covered at 18 ns, since b occured again at 17 ns. -- psl cov_1 : cover {a;b[=2];c} report "cov_1 hit"; -- Should be covered at: -- 3 ns - Part A - Due to 1 repetition of e and f in next cycle -- 4 ns - Part A - Due to 2 repetitions of e and f in next cycle -- 8 ns - Part B - Due to 1 repetition of e and f in next cycle -- 13 ns - Part B - Due to 2 repetitions of e and f in next cycle -- 16 ns - Part C - Due to 1 repetition of e and f in next cycle -- Should not be covered later since e was repeated 3 times before -- another f -- psl cov_2 : cover {d;e[=1 to 2];f} report "cov_2 hit"; -- Should be covered at: -- 8 ns - Part A - 3 repetitions of h followed by i in the next cycle -- Should not be covered in part B since there is one cycle gap -- after last h before i is high -- psl cov_3 : cover {g;h[->3];i} report "cov_3 hit"; -- Should be covered at: -- 5 ns - After 2 repetitions of k and l in next cycle -- 8 ns - After 3 repetitions of k and l in next cycle -- 12 ns - After 5 repetitions of k and l in next cycle -- 15 ns - After 6 repetitions of k and l in next cycle -- Should not be covered after 4 and 7 repetitions of k since l is -- not active in the next cycle -- psl cov_4 : cover {j;k[->2 to inf];l} report "cov_4 hit"; end architecture; nvc-r1.17.1/test/regress/psl16.vhd000066400000000000000000000022541504111170000166430ustar00rootroot00000000000000entity psl16 is end entity; architecture tb of psl16 is signal clk : natural; signal a,b,c,d,e,f : bit; -- Parts A B C constant seq_a : bit_vector := "011" & "10000" & "10000"; constant seq_b : bit_vector := "011" & "01000" & "01000"; constant seq_c : bit_vector := "110" & "00100" & "01000"; constant seq_d : bit_vector := "100" & "00100" & "00100"; constant seq_e : bit_vector := "010" & "00010" & "00100"; constant seq_f : bit_vector := "001" & "00001" & "00010"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 12; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); egen: e <= seq_e(clk); fgen: f <= seq_f(clk); -- psl default clock is clk'event; -- Should be covered at 2ns since a,b,c are high at the same time. -- Should not be covered at 1ns or 3 ns. -- psl cov_1 : cover {a:b:c} report "cov_1 hit"; -- Should be covered at 8 ns. -- psl cov_2 : cover {{a;b;c}:{d;e;f}} report "cov_2_hit"; -- Should be covered at 12 ns. -- psl cov_3 : cover {a;b:c;d:e;f} report "cov_3_hit"; end architecture; nvc-r1.17.1/test/regress/psl17.vhd000066400000000000000000000013401504111170000166370ustar00rootroot00000000000000entity psl17 is end entity; architecture tb of psl17 is signal clk : natural; signal a,b,c,d : bit; constant seq_a : bit_vector := "0100" & "1000"; constant seq_b : bit_vector := "0110" & "0100"; constant seq_c : bit_vector := "0001" & "0100"; constant seq_d : bit_vector := "0001" & "0000"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 7; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); -- psl default clock is clk'delayed(0 ns)'event; -- Covered at 3ns -- psl one: cover {{a;b;c} && {b;b;c}} report "one"; -- Covered at 5ns -- psl two: cover {{b[=3]} && {c[=1]; (not c)[+]; c}} report "two"; end architecture; nvc-r1.17.1/test/regress/psl18.vhd000066400000000000000000000015611504111170000166450ustar00rootroot00000000000000entity psl18 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl18 is signal clk : std_logic := '0'; signal i : integer := 0; signal x : bit_vector(1 to 3) := "101"; default clock is rising_edge(clk); procedure pulse (signal clk : out std_logic) is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin one: assert always i = prev(i) + 1; -- Fails at 7ns two: assert always x = not prev(x); -- Fails at 5ns stim: process is begin i <= i + 1; x <= not x; pulse(clk); x <= not x; i <= i + 1; pulse(clk); i <= i + 1; pulse(clk); -- Error x <= not x; pulse(clk); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/psl19.vhd000066400000000000000000000025141504111170000166450ustar00rootroot00000000000000entity psl19 is end entity; architecture tb of psl19 is signal clk : natural; signal a,b,c : bit; signal v : bit_vector(15 downto 0); constant seq_a : bit_vector := "01110000"; constant seq_b : bit_vector := "01101000"; constant seq_c : bit_vector := "01000010"; type t_matrix is array (0 to 7) of bit_vector(15 downto 0); constant seq_v : t_matrix := ( (x"0000"), (x"0000"), (x"0000"), (x"EEEE"), (x"DDDD"), (x"CCCC"), (x"BBBB"), (x"AAAA") ); begin clkgen: clk <= clk + 1 after 1 ns when clk < 7; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); vgen: v <= seq_v(clk); -- psl default clock is clk'delayed(0 ns)'event; -- Covered at 2 ns and 3 ns -- psl one: cover {a and prev(a)} report "one"; -- Covered at 4 ns -- psl two: cover {b and prev(b,2)} report "two"; -- Covered at 6 ns -- psl three: cover {c and prev(c,5)} report "three"; -- Covered at 7 ns -- psl four: cover { v = x"AAAA" and -- prev(v ) = x"BBBB" and -- prev(v,2) = x"CCCC" and -- prev(v,3) = x"DDDD" and -- prev(v,4) = x"EEEE"} report "four"; end architecture; nvc-r1.17.1/test/regress/psl2.vhd000066400000000000000000000015621504111170000165570ustar00rootroot00000000000000-- Adapted from: https://github.com/tmeissner/psl_with_ghdl/blob/master/src/psl_sere.vhd -- License: GPL-3.0-or-later library ieee; use ieee.std_logic_1164.all; entity psl2 is end entity psl2; architecture psl of psl2 is constant seq_a : std_logic_vector := "110000"; constant seq_b : std_logic_vector := "010000"; signal a, b : std_logic; signal clk : natural; -- All is sensitive to rising edge of clk -- psl default clock is clk'delayed(0 ns)'event; begin clkgen: clk <= clk + 1 after 1 ns when clk < 5; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); -- This assertion holds -- psl SERE_0_a : assert {a}; -- This assertion holds -- psl SERE_1_a : assert {a; a}; -- This assertion holds -- psl SERE_2_a : assert {a; a and b}; -- This assertion doesn't hold at cycle 2 -- psl SERE_3_a : assert always {a; a}; end architecture psl; nvc-r1.17.1/test/regress/psl20.vhd000066400000000000000000000011521504111170000166320ustar00rootroot00000000000000entity psl20 is end entity; architecture tb of psl20 is signal clk : natural; signal a : bit; constant seq_a : bit_vector := "00111010"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 7; agen: a <= seq_a(clk); -- psl default clock is clk'delayed(0 ns)'event; -- Covered at 2 ns and 6 ns -- psl one: cover {rose(a)} report "ROSE"; -- Covered at 5 ns and 7 ns -- psl two: cover {fell(a)} report "FELL"; -- Covered at 3 ns and 4 ns -- TODO: should be covered at 1 ns too! Why isn't it ? -- psl three: cover {stable(a)} report "STABLE"; end architecture; nvc-r1.17.1/test/regress/psl21.vhd000066400000000000000000000020671504111170000166410ustar00rootroot00000000000000entity psl21 is end entity; architecture tb of psl21 is signal clk : natural; signal a : bit := '0'; signal b : bit := '1'; signal c : bit := '0'; signal d : bit := '1'; signal num1 : natural := 1; signal num2 : natural := 2; signal bv1 : bit_vector(3 downto 0) := "0101"; signal bv2 : bit_vector(3 downto 0) := "1110"; begin clkgen: clk <= clk + 1 after 1 ns when clk < 10; -- psl default clock is clk'delayed(0 ns)'event; -- Checked with seed=1 to give 1 at: -- These assertions are covered random number of times deterministic -- based on the seed -- psl one: cover {a union b union c union d} report "one"; -- psl two: cover {(num1 union num2) = 1} report "two"; -- psl three: cover {countones(bv1 union bv2) = 3} report "three"; -- This assertion should never be covered -- psl four: cover {countones(bv1 union bv2) = 4} report "four"; -- Note: Since there is one global randomizer for all PSL assertions, -- removing one, affects gold result of others end architecture; nvc-r1.17.1/test/regress/psl3.vhd000066400000000000000000000016711504111170000165610ustar00rootroot00000000000000-- Adapted from: https://github.com/tmeissner/psl_with_ghdl/blob/master/src/psl_next.vhd -- License: GPL-3.0-or-later library ieee; use ieee.std_logic_1164.all; entity psl3 is end entity psl3; architecture psl of psl3 is constant seq_a : std_logic_vector := "01001100100"; constant seq_b : std_logic_vector := "01100110011"; constant seq_c : std_logic_vector := "01001100100"; constant seq_d : std_logic_vector := "01100100011"; signal a, b : std_logic; signal c, d : std_logic; signal clk : natural; -- All is sensitive to rising edge of clk default clock is clk'delayed(0 ns)'event; begin clkgen: clk <= clk + 1 after 1 ns when clk < 10; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); -- This assertion holds NEXT_0_a : assert always (a -> next b); -- This assertion doesn't hold at cycle 6 NEXT_1_a : assert always (c -> next d); end architecture psl; nvc-r1.17.1/test/regress/psl4.vhd000066400000000000000000000050401504111170000165540ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity psl4 is end entity psl4; architecture psl of psl4 is signal oh : std_logic_vector(3 downto 0) := "0001"; signal iu : std_logic_vector(3 downto 0) := "0000"; signal co1 : std_logic_vector(7 downto 0) := "00000000"; signal co2 : std_logic_vector(7 downto 0) := "00000001"; signal co3 : std_logic_vector(7 downto 0) := "11111111"; signal co4 : std_logic_vector(7 downto 0) := "1HHH0LLL"; signal co5 : std_logic_vector(7 downto 0) := "10101010"; signal clk : std_logic := '1'; -- psl default clock is rising_edge(clk); begin process begin wait for 5 ns; clk <= '0'; wait for 5 ns; clk <= '1'; end process; process begin --------------------------------------------------------------------------- -- Test "onehot" and "onehot0" --------------------------------------------------------------------------- wait until falling_edge(clk); oh <= "0010"; wait until falling_edge(clk); oh <= "0100"; wait until falling_edge(clk); oh <= "1000"; wait until falling_edge(clk); oh <= "0000"; wait until falling_edge(clk); oh <= "1111"; wait until falling_edge(clk); oh <= "1000"; --------------------------------------------------------------------------- -- Test "isuknown" --------------------------------------------------------------------------- iu <= "000Z"; wait until falling_edge(clk); iu <= "11X0"; wait until falling_edge(clk); iu <= "10U0"; wait until falling_edge(clk); iu <= "W011"; wait until falling_edge(clk); iu <= "1-00"; wait until falling_edge(clk); iu <= "HLHL"; wait until falling_edge(clk); --------------------------------------------------------------------------- -- Test "countones" --------------------------------------------------------------------------- co5 <= "01010101"; wait until falling_edge(clk); co5 <= "00000000"; wait until falling_edge(clk); std.env.finish; end process; -- psl asrt_onehot : assert always (onehot(oh)); -- psl asrt_onehot0 : assert always (onehot0(oh)); -- psl asrt_is_unknwon : assert always (isunknown(iu) = false); -- psl asrt_count_ones_1 : assert always (countones(co1) = 0); -- psl asrt_count_ones_2 : assert always (countones(co2) = 1); -- psl asrt_count_ones_3 : assert always (countones(co3) = 8); -- psl asrt_count_ones_4 : assert always (countones(co4) = 4); -- psl asrt_count_ones_5 : assert always (countones(co5) = 4); end architecture psl; nvc-r1.17.1/test/regress/psl5.vhd000066400000000000000000000025471504111170000165660ustar00rootroot00000000000000-- Adapted from: https://github.com/tmeissner/psl_with_ghdl/blob/master/src/psl_next_3.vhd -- License: GPL-3.0-or-later library ieee; use ieee.std_logic_1164.all; entity psl5 is end entity psl5; architecture psl of psl5 is constant seq_a : std_logic_vector := "00101000000"; constant seq_b : std_logic_vector := "00000101000"; constant seq_c : std_logic_vector := "00101000000"; constant seq_d : std_logic_vector := "00000100000"; constant seq_e : std_logic_vector := "00101000000"; constant seq_f : std_logic_vector := "00000111110"; signal a, b : std_logic; signal c, d : std_logic; signal e, f : std_logic; signal clk : natural; -- All is sensitive to rising edge of clk -- psl default clock is clk'delayed(0 ns)'event; begin clkgen: clk <= clk + 1 after 1 ns when clk < 10; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); egen: e <= seq_e(clk); fgen: f <= seq_f(clk); -- This assertion holds -- psl NEXT_0_a : assert always (a -> next[3] (b)); -- This assertion doesn't hold at cycle 7 -- psl NEXT_1_a : assert always (c -> next[3] (d)); -- This assertion holds -- psl NEXT_2_a : assert always (e -> next[3] (f)); -- This assertion holds -- psl dummy1: assert always (e -> next[0] (e)); -- psl dummy2: assert always (e -> next[-1] (e)); end architecture psl; nvc-r1.17.1/test/regress/psl6.vhd000066400000000000000000000034001504111170000165540ustar00rootroot00000000000000-- Adapted from: https://github.com/tmeissner/psl_with_ghdl/blob/master/src/psl_until.vhd -- License: GPL-3.0-or-later library ieee; use ieee.std_logic_1164.all; entity psl6 is end entity; architecture psl of psl6 is constant seq_a : std_logic_vector := "01000100000"; constant seq_b : std_logic_vector := "00110011110"; constant seq_c : std_logic_vector := "00001000001"; constant seq_d : std_logic_vector := "01000100000"; constant seq_e : std_logic_vector := "00111011111"; constant seq_f : std_logic_vector := "00001000001"; constant seq_g : std_logic_vector := "01000000000"; constant seq_h : std_logic_vector := "00000000000"; constant seq_i : std_logic_vector := "00100000000"; signal a, b, c : std_logic; signal d, e, f : std_logic; signal g, h, i : std_logic; signal clk : natural; -- All is sensitive to rising edge of clk -- psl default clock is clk'delayed(0 ns)'event; begin clkgen: clk <= clk + 1 after 1 ns when clk < 10; agen: a <= seq_a(clk); bgen: b <= seq_b(clk); cgen: c <= seq_c(clk); dgen: d <= seq_d(clk); egen: e <= seq_e(clk); fgen: f <= seq_f(clk); ggen: g <= seq_g(clk); hgen: h <= seq_h(clk); igen: i <= seq_i(clk); -- This assertion holds -- psl UNTIL_0_a : assert always (a -> next (b until c)); -- This assertion holds -- psl UNTIL_1_a : assert always (d -> next (e until f)); -- This assertion holds -- psl UNTIL_2_a : assert always (g -> next (h until i)); -- This assertion doesn't hold at cycle 4 -- psl UNTIL_3_a : assert always (a -> next (b until_ c)); -- This assertion holds -- psl UNTIL_4_a : assert always (d -> next (e until_ f)); -- This assertion doesn't hold at cycle 2 -- psl UNTIL_5_a : assert always (g -> next (h until_ i)); end architecture psl; nvc-r1.17.1/test/regress/psl7.vhd000066400000000000000000000013251504111170000165610ustar00rootroot00000000000000entity psl7 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl7 is signal clk : std_logic := '0'; signal x, y : std_logic; begin -- psl default clock is rising_edge(clk); -- psl one: cover {x and y} report "one"; -- psl two: cover {[*]; x and y} report "two"; -- psl three: cover {x; not x and not y; y} report "three"; clkgen: clk <= not clk after 5 ns when now < 50 ns; seq: process is begin x <= '1'; wait for 1 ns; y <= '1'; wait for 6 ns; y <= '0'; wait for 10 ns; x <= '0'; wait for 10 ns; y <= '1'; wait for 10 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/psl8.vhd000066400000000000000000000010631504111170000165610ustar00rootroot00000000000000entity psl8 is end entity; architecture test of psl8 is signal clk : bit; -- psl default clock is clk'event and clk = '1'; signal x, y : bit; begin -- psl assert never ((x = '1') and y = '1'); stim: process is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; x <= '1'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; y <= '1'; wait for 1 ns; clk <= '1'; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/psl9.vhd000066400000000000000000000014021504111170000165570ustar00rootroot00000000000000entity psl9 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of psl9 is signal clk : std_logic := '0'; signal a, b, c : std_logic := '0'; default clock is rising_edge(clk); procedure pulse (signal clk : out std_logic) is begin wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; end procedure; begin hdl_impl: assert always (a -> b or c); stim: process is begin pulse(clk); b <= '1'; pulse(clk); a <= '1'; pulse(clk); c <= '1'; pulse(clk); b <= '0'; pulse(clk); c <= '0'; pulse(clk); -- Assertion fails here wait; end process; end architecture; nvc-r1.17.1/test/regress/ram1.vhd000066400000000000000000000044211504111170000165340ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity memory is generic ( WIDTH : integer ); port ( clk : in std_logic; addr : in unsigned(7 downto 0); din : in std_logic_vector(WIDTH - 1 downto 0); dout : out std_logic_vector(WIDTH - 1 downto 0); we : in std_logic ); end entity; architecture rtl of memory is type ram_t is array (0 to 255) of std_logic_vector(WIDTH - 1 downto 0); signal addr_r : unsigned(7 downto 0); signal ram : ram_t; begin reg: process (clk) is begin if rising_edge(clk) then addr_r <= addr; if we = '1' then ram(to_integer(addr)) <= din; end if; end if; end process; dout <= ram(to_integer(addr_r)); end architecture; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity ram1 is end entity; architecture test of ram1 is constant ITERS : integer := 1; constant WIDTH : integer := 8; signal clk : std_logic := '0'; signal addr : unsigned(7 downto 0); signal din : std_logic_vector(WIDTH - 1 downto 0); signal dout : std_logic_vector(WIDTH - 1 downto 0); signal we : std_logic := '1'; signal running : boolean := true; begin clk <= not clk after 5 ns when running else '0'; uut: entity work.memory generic map ( WIDTH => WIDTH ) port map ( clk => clk, addr => addr, din => din, dout => dout, we => we ); stim: process is begin for j in 1 to ITERS loop wait for 20 ns; we <= '1'; for i in 0 to 255 loop addr <= to_unsigned(i, 8); din <= std_logic_vector(to_unsigned((i + j) mod 256, WIDTH)); wait for 10 ns; end loop; we <= '0'; for i in 0 to 255 loop addr <= to_unsigned(i, 8); wait for 10 ns; assert dout = std_logic_vector(to_unsigned((i + j) mod 256, WIDTH)); end loop; end loop; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/rand1.vhd000066400000000000000000000010541504111170000167000ustar00rootroot00000000000000entity rand1 is end entity; library nvc; use nvc.random.all; architecture test of rand1 is begin -- Assumes --seed=123 process is begin assert get_random = 2991312382; assert get_random = 3062119789; assert get_random = 1228959102; assert get_random = 1840268610; assert get_random = 974319580; assert get_random = 2967327842; assert get_random; assert not get_random; assert not get_random; assert get_random; wait; end process; end architecture; nvc-r1.17.1/test/regress/range1.vhd000066400000000000000000000035201504111170000170500ustar00rootroot00000000000000package index is subtype myRange is natural range 7 downto 0; constant my_range: bit_vector (myRange) := (others => '0'); function "+" (l: bit_vector; stride: natural) return bit_vector; end package; package body index is function "+" (l: bit_vector; stride: natural) return bit_vector is variable retval: bit_vector( l'LEFT + l'LENGTH * stride downto l'RIGHT + l'LENGTH * stride ); begin -- report "stride = " & INTEGER'IMAGE(stride); -- report "retval'LEFT = " & INTEGER'IMAGE(retval'LEFT); -- report "retval'RIGHT = " & INTEGER'IMAGE(retval'RIGHT); return retval; end function; end package body; ------------------------------------------------------------------------------- use work.index.all; entity range1 is end entity; architecture foo of range1 is signal big_range: bit_vector (63 downto 0) := x"feedfacedeadbeef"; signal little_range: bit_vector (myRange); function to_string(inp: bit_vector) return string is variable image_str: string (1 to inp'length); alias input_str: bit_vector (1 to inp'length) is inp; begin for i in input_str'range loop image_str(i) := character'VALUE(bit'IMAGE(input_str(i))); end loop; -- report "image_str = " & image_str; return image_str; end; begin STIMULUS: process begin wait for 1 ns; for stride in myRange loop report "stride = " & INTEGER'IMAGE(stride); little_range <= big_range( "+"(my_range, stride)'RANGE ); wait for 1 ns; end loop; wait; end process; MONITOR: process (little_range) begin report "little_range = " & to_string (little_range); end process; end architecture; nvc-r1.17.1/test/regress/range2.vhd000066400000000000000000000022211504111170000170460ustar00rootroot00000000000000package pack is type rec_t is record x : integer_vector; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( p : in rec_t; o : out integer ); end entity; architecture test of sub is begin p1: process (p) is variable local_s : p'subtype; variable result : integer := 0; begin local_s := p; for i in local_s.x'reverse_range loop if local_s.x(i) > 0 then result := local_s.x(i); exit; end if; end loop; o <= result; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity range2 is end entity; architecture test of range2 is signal s : rec_t(x(1 to 5)) := (x => (1, 2, 3, 0, 0)); signal o : integer; begin u: entity work.sub port map (s, o); check: process is begin wait for 1 ns; assert o = 3; s.x(4) <= 222; wait for 1 ns; assert o = 222; wait; end process; end architecture; nvc-r1.17.1/test/regress/range3.vhd000066400000000000000000000020531504111170000170520ustar00rootroot00000000000000entity range3 is end entity; architecture test of range3 is type t_rec is record x : bit_vector; end record; type t_rec_array is array (natural range <>) of t_rec; signal s1 : t_rec(x(1 to 3)); signal s2 : t_rec_array(1 to 2)(x(1 to 3)); begin b1: block is port ( p : out t_rec ); port map ( s1 ); begin g: for i in p.x'range generate begin p.x(i) <= '1'; end generate; end block; b2: block is port ( p : out t_rec_array ); port map ( s2 ); begin g: for i in p'range generate begin p(i).x <= "111"; end generate; end block; b3: block is port ( p : in t_rec_array ); port map ( s2 ); signal s3 : p'subtype; begin s3 <= s2; assert s3(1).x'length = 3; end block; check: process is begin wait for 1 ns; assert s1 = (x => "111"); assert s2 = (1 to 2 => (x => "111")); wait; end process; end architecture; nvc-r1.17.1/test/regress/real1.vhd000066400000000000000000000014451504111170000167030ustar00rootroot00000000000000entity real1 is end entity; architecture test of real1 is begin process is variable r : real; begin assert r = real'left; r := 1.0; r := r + 1.4; assert r > 2.0; assert r < 3.0; assert r >= real'low; assert r <= real'high; assert r /= 5.0; r := 2.0; r := r * 3.0; assert r > 5.99999; assert r < 6.00001; assert integer(r) = 6; r := real(5); report real'image(r); r := real(-5.262e2); report real'image(r); r := real(1.23456); report real'image(r); r := real(2.0); report real'image(r ** (-1)); report real'image(real'low); report real'image(real'high); wait; end process; end architecture; nvc-r1.17.1/test/regress/real2.vhd000066400000000000000000000007511504111170000167030ustar00rootroot00000000000000entity real2 is end entity; architecture test of real2 is type real_vec is array (integer range <>) of real; type real_rec is record x, y : real; end record; begin process is variable a, b : real_vec(1 to 3); variable r : real_rec; begin a := (1.0, 1.2, 3.4); b := (0.9, 0.2, 4.1); assert a /= b; r.x := 2.0; r.y := 3.0; assert r = (2.0, 3.0); wait; end process; end architecture; nvc-r1.17.1/test/regress/real3.vhd000066400000000000000000000005621504111170000167040ustar00rootroot00000000000000entity real3 is end real3; architecture Behavioral of real3 is signal value_real : real := -523467.0; signal value_integer : integer; begin process begin report "real: " & real'image(value_real); value_integer <= integer(value_real); wait for 0 ns; report "integer: " & integer'image(value_integer); wait; end process; end Behavioral; nvc-r1.17.1/test/regress/real4.vhd000066400000000000000000000004231504111170000167010ustar00rootroot00000000000000entity real4 is end entity; architecture test of real4 is begin p1: process is variable x, y : real; begin x := 1.0; y := 0.0; wait for 1 ns; x := x / y; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/real5.vhd000066400000000000000000000007041504111170000167040ustar00rootroot00000000000000entity real5 is end entity; architecture test of real5 is type real_array is array (natural range <>) of real; begin p1: process is variable v : real_array(1 to 3); begin v := (1.0, 2.0, 3.0); assert v < (2.0, 3.0, 4.0); assert v <= v; assert v > (0 => 1.0); assert v >= v; assert maximum(v) = 3.0; assert minimum(v) = 1.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/real6.vhd000066400000000000000000000033201504111170000167020ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3170.vhd,v 1.2 2001-10-26 16:29:52 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY real6 IS END real6; ARCHITECTURE c14s01b00x00p17n01i03170arch OF real6 IS constant L : REAL := -10.0; constant R : REAL := 10.0; type RT1 is range L to R; BEGIN TESTING: PROCESS BEGIN assert NOT( RT1'right = RT1(R) ) report "***PASSED TEST: c14s01b00x00p17n01i03170" severity NOTE; assert ( RT1'right = RT1(R) ) report "***FAILED TEST: c14s01b00x00p17n01i03170 - Predefined attribute RIGHT for floating point type test failed." severity ERROR; wait; END PROCESS TESTING; END c14s01b00x00p17n01i03170arch; nvc-r1.17.1/test/regress/real7.vhd000066400000000000000000000005511504111170000167060ustar00rootroot00000000000000entity real7 is end entity; architecture test of real7 is begin process is variable r1, r2, r3 : real; variable a1 : real_vector(0 to 1); begin a1 := (r1 * r1, 0.0); -- Error r3 := a1(0) * 0.0; -- Should not be NaN report real'image(r3); wait; end process; end architecture; nvc-r1.17.1/test/regress/record1.vhd000066400000000000000000000013501504111170000172310ustar00rootroot00000000000000entity record1 is end entity; architecture test of record1 is type r1 is record x, y : integer; end record; constant k : r1 := (62, 75); begin process is variable a : r1; variable b : r1 := (1, 2); variable c : r1 := (x => 10, y => 2); variable d : r1 := (others => 99); begin assert a.x = integer'left; assert (b.x = 1) and (b.y = 2); assert (c.x / c.y) = 5; assert (d.x = 99) and (d.y = 99); a.x := 5; assert a.x = 5; a := b; assert (a.x = 1) and (a.y = 2); a := k; assert (a.x = k.x) and (a.y = k.y); assert a = k; assert a /= b; wait; end process; end architecture; nvc-r1.17.1/test/regress/record10.vhd000066400000000000000000000012161504111170000173120ustar00rootroot00000000000000entity record10 is end entity; architecture test of record10 is type rec1 is record x, y : integer; end record; type rec2 is record x : integer; y : bit_vector(1 to 3); end record; begin process is variable r1 : rec1; variable r2 : rec2; variable a, b : integer; variable c : bit_vector(1 to 3); begin a := 1; b := 2; r1 := rec1'(x => a, y => b); assert r1.x = 1; assert r1.y = 2; r2 := rec2'(x => a, y => c); assert r2.x = 1; assert r2.y = "000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record11.vhd000066400000000000000000000012701504111170000173130ustar00rootroot00000000000000entity record11 is end entity; architecture test of record11 is type rec is record x, y : bit; end record; signal r : rec; signal a, b : bit; begin process is begin r <= ( '1', '0' ); wait for 0 ns; assert r.x'event; assert not r.y'event; assert r.y'active; assert r'event; wait for 1 ns; assert a'event; assert not b'event; assert b'active; assert a = '1'; assert b = '0'; r.y <= '1'; wait for 1 ns; assert b = '1'; wait; end process; update_a: a <= r.x after 1 ns; update_b: b <= r.y after 1 ns; end architecture; nvc-r1.17.1/test/regress/record12.vhd000066400000000000000000000007361504111170000173220ustar00rootroot00000000000000entity record12 is end entity; architecture test of record12 is type rec is record a, b : integer; end record; type rec2 is record x, y : rec; end record; constant r1 : rec := (1, 2); constant r2 : rec := (3, 4); constant r3 : rec2 := (r1, r2); begin process is begin assert r1.a = 1; assert r3.x = r1; assert r3.y = r2; assert r3.y.a = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/record13.vhd000066400000000000000000000021601504111170000173140ustar00rootroot00000000000000entity record13 is end entity; architecture test of record13 is type rec is record t : character; -- Three bytes padding x, y : integer; end record; type rec_array is array (positive range <>) of rec; function resolve(x : rec_array) return rec is variable r : rec := ('0', 0, 0); begin assert x'left = 1; assert x'right = x'length; for i in x'range loop report "x(" & integer'image(i) & ") = (" & integer'image(x(i).x) & ", " & integer'image(x(i).y) & ")"; r.x := r.x + x(i).x; r.y := r.y + x(i).y; end loop; return r; end function; subtype resolved_rec is resolve rec; signal sig : resolved_rec := ('0', 0, 0); begin p1: process is begin sig <= ('a', 1, 2); wait for 1 ns; sig.x <= 5; wait; end process; p2: process is begin sig <= ('b', 4, 5); wait for 1 ns; assert sig = ('0', 5, 7); wait for 1 ns; assert sig = ('0', 9, 7); wait; end process; end architecture; nvc-r1.17.1/test/regress/record14.vhd000066400000000000000000000031301504111170000173130ustar00rootroot00000000000000entity sub is generic ( N : natural ); end entity; architecture test of sub is type rec is record x : natural; y : bit_vector(1 to N); z : natural; end record; type rec2 is record x : natural; y : rec; z : natural; end record; function func (q : bit_vector) return natural is type rec3 is record x : natural; y : bit_vector(1 to q'length); z : natural; end record; variable r : rec3; begin r := ( 1, q, q'length ); r.y(1) := '1'; for i in r.y'range loop if i = 1 then assert r.y(i) = '1'; else assert r.y(i) = '0'; end if; end loop; return r.z; end function; signal s : rec; signal s2 : rec2; begin p1: process is variable r : rec; begin assert r = (0, (1 to N => '0'), 0); r.y(1) := '1'; assert r.y = (1 => '1', 2 to 4 => '0'); assert func(r.y) = N; assert s = (0, (1 to N => '0'), 0); s.y(1) <= '1'; wait for 1 ns; assert s.y = (1 => '1', 2 to 4 => '0'); assert s2 = (0, (0, (1 to N => '0'), 0), 0); s2.y.y(1) <= '1'; wait for 1 ns; assert s2.y.y = (1 => '1', 2 to 4 => '0'); wait; end process; end architecture; ------------------------------------------------------------------------------- entity record14 is end entity; architecture test of record14 is begin sub_i: entity work.sub generic map ( 4 ); end architecture; nvc-r1.17.1/test/regress/record15.vhd000066400000000000000000000015541504111170000173240ustar00rootroot00000000000000package pack is type rec is record x : integer; y : bit; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( r : in rec; x : out integer; y : out bit ); end entity; architecture test of sub is begin x <= r.x; y <= r.y; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity record15 is end entity; architecture test of record15 is signal x : integer; signal y : bit; begin sub_i: entity work.sub port map ( r => (123, '1'), x => x, y => y ); process is begin wait for 1 ns; assert x = 123; assert y = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/record16.vhd000066400000000000000000000012461504111170000173230ustar00rootroot00000000000000entity record16 is end entity; architecture test of record16 is type rec is record x : bit; y : integer; end record; signal r : rec := ('1', 0); procedure drive(signal s : out integer; value : in integer) is begin s <= value; end procedure; procedure read(signal s : in integer; value : out integer) is begin value := s; end procedure; begin process is variable x : integer; begin drive(r.y, 123); wait for 1 ns; assert r.y = 123; read(r.y, x); --report integer'image(x); --assert x = 123; wait; end process; end architecture; nvc-r1.17.1/test/regress/record17.vhd000066400000000000000000000010551504111170000173220ustar00rootroot00000000000000entity record17 is end entity; architecture test of record17 is type rec is record x : boolean; y : natural; z : real; end record; type rec_3x3 is array (1 to 3, 1 to 3) of rec; signal s : rec_3x3; begin p1: process is begin assert s(2, 2).z = real'left; s(2, 2).y <= 123; wait for 1 ns; assert s(2, 2) = (false, 123, real'left); s(3, 3) <= (true, 456, 1.0); wait for 1 ns; assert s(3, 3).x = true; wait; end process; end architecture; nvc-r1.17.1/test/regress/record18.vhd000066400000000000000000000021521504111170000173220ustar00rootroot00000000000000package pack is type rec is record x : integer; y : integer; z : boolean; end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r : rec ); port ( i : in bit_vector(1 to r.y); o : out bit ); end entity; architecture test of sub is begin g1: if r.z generate o <= i(r.x); end generate; g2: if not r.z generate o <= '1'; end generate; end architecture; ------------------------------------------------------------------------------- entity record18 is end entity; use work.pack.all; architecture test of record18 is constant r1 : rec := (1, 2, true); constant r2 : rec := (0, 0, false); signal o1, o2 : bit; begin sub1_i: entity work.sub generic map (r1) port map ( "10", o1 ); sub2_i: entity work.sub generic map (r2) port map ( (others => '0'), o2 ); process is begin wait for 1 ns; assert o1 = '1'; assert o2 = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/record19.vhd000066400000000000000000000015301504111170000173220ustar00rootroot00000000000000entity record19 is end entity; architecture test of record19 is type data_t is record x, y : bit; end record; type data_vector is array (natural range <>) of data_t; procedure mux (signal data_i : in data_vector(1 to 7); selected : in integer; signal data_o : out data_t ) is variable tmp : data_t; begin tmp := data_i(selected); data_o <= tmp; end procedure; signal di : data_vector(1 to 7); signal do : data_t; begin main: process is begin di <= ( 2 => ('1', '1'), others => ('0', '0') ); wait for 1 ns; mux(di, 1, do); wait for 1 ns; assert do = ( '0', '0' ); mux(di, 2, do); wait for 1 ns; assert do = ( '1', '1' ); wait; end process; end architecture; nvc-r1.17.1/test/regress/record2.vhd000066400000000000000000000007241504111170000172360ustar00rootroot00000000000000entity record2 is end entity; architecture test of record2 is type rec is record x, y : integer; end record; procedure set_to(variable r : inout rec; constant n : in integer) is begin r.x := n; r.y := r.x; end procedure; begin process is variable r : rec; begin set_to(r, 5); assert r.x = 5; assert r.y = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/record20.vhd000066400000000000000000000007371504111170000173220ustar00rootroot00000000000000entity record20 is end entity; architecture test of record20 is type rec is record x : bit_vector(7 downto 0); end record; signal s : rec; signal t : bit_vector(3 downto 0); begin p1: t <= s.x(5 downto 2); main: process is begin s <= ( x => X"ff" ); wait for 1 ns; assert t = X"f"; s.x(7 downto 4) <= X"0"; wait for 1 ns; assert t = "0011"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record21.vhd000066400000000000000000000023041504111170000173130ustar00rootroot00000000000000entity record21 is end entity; architecture test of record21 is type rec is record t : character; -- Three bytes padding x, y : integer; z : character; -- Three bytes padding end record; type rec_array is array (positive range <>) of rec; function resolve(x : rec_array) return rec is variable r : rec := ('0', 0, 0, 'q'); begin assert x'left = 1; assert x'right = x'length; for i in x'range loop report "x(" & integer'image(i) & ") = (" & integer'image(x(i).x) & ", " & integer'image(x(i).y) & ")"; r.x := r.x + x(i).x; r.y := r.y + x(i).y; end loop; return r; end function; subtype resolved_rec is resolve rec; signal sig : resolved_rec := ('0', 0, 0, '0'); begin p1: process is begin sig <= ('a', 1, 2, 'x'); wait for 1 ns; sig.x <= 5; wait; end process; p2: process is begin sig <= ('b', 4, 5, 'y'); wait for 1 ns; assert sig = ('0', 5, 7, 'q'); wait for 1 ns; assert sig = ('0', 9, 7, 'q'); wait; end process; end architecture; nvc-r1.17.1/test/regress/record22.vhd000066400000000000000000000025141504111170000173170ustar00rootroot00000000000000package pack is type r1 is record x : integer; y : character; end record; type r1_vec is array (natural range <>) of r1; type r2 is record p : r1; q : r1_vec(1 to 2); end record; type r2_vec is array (natural range <>) of r2; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( x : in r2; y : out r2_vec(1 to 3) ); end entity; architecture test of sub is begin p1: process is begin wait for 1 ns; assert x = ( ( 1, '2' ), ( ( 3, '4' ), ( 5, '6' ) ) ); y(3) <= ( ( 7, 'a' ), ( ( 8, 'b' ), ( 9, 'c' ) ) ); wait on x; assert x = ( ( 1, '2' ), ( ( 42, '4' ), ( 5, '6' ) ) ); wait; end process; end architecture; ------------------------------------------------------------------------------- entity record22 is end entity; use work.pack.all; architecture test of record22 is signal s : r2; signal t : r2_vec(1 to 3); begin uut: entity work.sub port map ( s, t ); main: process is begin s <= ( ( 1, '2' ), ( ( 3, '4' ), ( 5, '6' ) ) ); wait for 2 ns; assert t(3) = ( ( 7, 'a' ), ( ( 8, 'b' ), ( 9, 'c' ) ) ); s.q(1).x <= 42; wait; end process; end architecture; nvc-r1.17.1/test/regress/record23.vhd000066400000000000000000000007611504111170000173220ustar00rootroot00000000000000entity record23 is end entity; architecture test of record23 is type rec1 is record x, y : integer; end record; type rec2 is record r : rec1; end record; signal s1 : rec1; signal s2 : rec2; begin main: process is begin s1 <= (3, 4); wait for 1 ns; s2 <= (r => s1); -- Error here wait for 1 ns; assert s2.r.x = 3; assert s2.r.y = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/record24.vhd000066400000000000000000000026661504111170000173310ustar00rootroot00000000000000package directmap2_pack is type rec is record x : integer; y : bit; z : bit_vector(1 to 3); end record; end package; ------------------------------------------------------------------------------- use work.directmap2_pack.all; entity bot1 is port ( r : in rec ); end entity; architecture test of bot1 is begin p1: process is begin wait for 1 ns; assert r = ( 5, '1', "101" ); wait; end process; end architecture; ------------------------------------------------------------------------------- use work.directmap2_pack.all; entity bot2 is port ( r : in rec ); end entity; architecture test of bot2 is begin p1: process is begin wait for 1 ns; assert r = ( 6, '1', "101" ); wait; end process; end architecture; ------------------------------------------------------------------------------- use work.directmap2_pack.all; entity record24 is end entity; architecture test of record24 is signal p : bit; signal q : bit_vector(1 to 3); signal i : integer; begin uut1: entity work.bot1 port map ( r.x => 5, r.y => p, r.z => q ); uut2: entity work.bot2 port map ( r.x => i, r.y => p, r.z => q ); main: process is begin i <= 6; p <= '1'; q <= "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record25.vhd000066400000000000000000000007651504111170000173300ustar00rootroot00000000000000entity record25 is end entity; architecture test of record25 is type rec is record x, y: integer; end record; type rec_array is array (natural range <>) of rec; procedure check (signal x : in rec_array) is begin assert x = ( (1, 2), (3, 4) ); end procedure; signal s1 : rec_array(1 to 2); begin main: process is begin s1 <= ( (1, 2), (3, 4) ); wait for 1 ns; check(s1); wait; end process; end architecture; nvc-r1.17.1/test/regress/record26.vhd000066400000000000000000000015451504111170000173260ustar00rootroot00000000000000package config is constant width : integer; end package; ------------------------------------------------------------------------------- use work.config.all; package types is type rec is record x : bit_vector(1 to width); -- OK end record; end package; ------------------------------------------------------------------------------- package body config is constant width : integer := 6; end package body; ------------------------------------------------------------------------------- entity record26 is end entity; use work.types.all; architecture test of record26 is signal r : rec; begin main: process is begin assert r.x'length = 6; assert r = ( x => "000000" ); r.x <= "101000"; wait for 1 ns; assert r = ( x => "101000" ); wait; end process; end architecture; nvc-r1.17.1/test/regress/record27.vhd000066400000000000000000000021571504111170000173270ustar00rootroot00000000000000package config is constant width : integer; end package; ------------------------------------------------------------------------------- use work.config.all; package types is type pair is record x, y : integer; end record; type pair_vec is array (natural range <>) of pair; type rec is record v : pair_vec(1 to width); -- OK end record; end package; ------------------------------------------------------------------------------- package body config is constant width : integer := 2; end package body; ------------------------------------------------------------------------------- entity record27 is end entity; use work.types.all; architecture test of record27 is signal r : rec; begin main: process is begin assert r.v'length = 2; assert r = ( v => (others => (integer'left, integer'left) ) ); r.v <= ( (1, 2), (3, 4) ); wait for 1 ns; assert r = ( v => ( (1, 2), (3, 4) ) ); r.v(2).x <= 7; wait for 1 ns; assert r = ( v => ( (1, 2), (7, 4) ) ); wait; end process; end architecture; nvc-r1.17.1/test/regress/record28.vhd000066400000000000000000000020111504111170000173150ustar00rootroot00000000000000package config is constant width : integer; end package; ------------------------------------------------------------------------------- use work.config.all; package types is -- type pair is record -- x, y : integer; -- end record; -- type pair_vec is array (natural range <>) of pair; type rec is record v : bit_vector(1 to width); -- OK end record; end package; ------------------------------------------------------------------------------- package body config is constant width : integer := 2; end package body; ------------------------------------------------------------------------------- entity record28 is end entity; use work.types.all; architecture test of record28 is signal r, s : rec; begin main: process is begin assert r.v'length = 2; r <= ( v => "10" ) after 1 ns; wait for 2 ns; assert s.v = "10"; wait; end process; process (r) is begin s <= r; end process; end architecture; nvc-r1.17.1/test/regress/record29.vhd000066400000000000000000000010161504111170000173220ustar00rootroot00000000000000entity record29 is end entity; architecture test of record29 is type rec is record x : bit_vector; end record; signal s : rec(x(1 to 3)); begin main: process is begin assert s.x = "000"; assert s = (x => "000"); s.x <= "101"; wait for 1 ns; assert s.x = "101"; assert s = (x => "101"); s <= (x => "111"); wait for 1 ns; assert s.x = "111"; assert s = (x => "111"); wait; end process; end architecture; nvc-r1.17.1/test/regress/record3.vhd000066400000000000000000000007541504111170000172420ustar00rootroot00000000000000entity record3 is end entity; architecture test of record3 is procedure add1(x : inout integer) is begin x := x + 1; end procedure; type rec is record a, b : integer; end record; procedure foo(r : inout rec) is begin add1(r.a); add1(r.b); end procedure; begin process is variable r : rec; begin r := (1, 2); foo(r); assert r.a = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/record30.vhd000066400000000000000000000013221504111170000173120ustar00rootroot00000000000000entity record30 is end entity; architecture test of record30 is type int_ptr is access integer; type pair is record x, y : natural; end record; type rec is record x : bit_vector; y : int_ptr; z : pair; end record; begin main: process is variable s : rec(x(1 to 3)); begin assert s.x = "000"; assert s = (x => "000", y => null, z => (0, 0)); s.x := "101"; assert s.x = "101"; assert s = (x => "101", y => null, z => (0, 0)); s := (x => "111", y => null, z => (0, 0)); assert s.x = "111"; assert s = (x => "111", y => null, z => (0, 0)); wait; end process; end architecture; nvc-r1.17.1/test/regress/record31.vhd000066400000000000000000000015141504111170000173160ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package pack is type rec is record f : std_logic_vector; end record; subtype rec4 is rec(f(1 to 4)); end package; ------------------------------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; use work.pack.all; entity record31 is port ( r : inout rec4 ); end entity; architecture test of record31 is begin p1: process is begin r.f <= "ZZZZ"; wait for 1 ns; assert r.f = "1010"; r.f <= "Z1ZZ"; wait for 1 ns; assert r.f = "1X10"; wait; end process; p2: process is begin r.f <= "1010"; wait for 1 ns; assert r.f = "1010"; wait for 1 ns; assert r.f = "1X10"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record32.vhd000066400000000000000000000004501504111170000173150ustar00rootroot00000000000000entity record32 is end entity; architecture test of record32 is type rec1 is record f1 : integer_vector; end record; type rec2 is record r : rec1; f2 : integer_vector; end record; signal s : rec2(f2(1 to 3), r(f1(2 to 5))); begin end architecture; nvc-r1.17.1/test/regress/record33.vhd000066400000000000000000000034531504111170000173240ustar00rootroot00000000000000entity record33 is end entity; architecture test of record33 is type t_list; type t_list_ptr is access t_list; type t_data is record msg : string; end record; type t_list is record seq : natural; data : t_data; chain : t_list_ptr; end record; type t_shared_queue is protected procedure push (data : in t_data); procedure pop (data : out t_data; seq : out natural); end protected; type t_shared_queue is protected body variable head, tail : t_list_ptr; variable next_seq : natural; procedure push (data : in t_data) is variable elt : t_list_ptr; begin elt := new t_list'(seq => next_seq, data => data, chain => null); next_seq := next_seq + 1; if head = null then head := elt; tail := elt; else tail.chain := elt; tail := elt; end if; end procedure; procedure pop (data : out t_data; seq : out natural) is begin assert head /= null; data := head.data; seq := head.seq; head := head.chain; end procedure; end protected body; shared variable queue : t_shared_queue; begin p1: process is variable data : t_data(msg(1 to 5)); variable seq : natural; variable msg : string(1 to 5); begin data.msg := "hello"; queue.push(data); data.msg := "world"; queue.push(data); wait for 1 ns; queue.pop(data, seq); assert seq = 0; assert data.msg = "hello"; queue.pop(data, seq); assert seq = 1; assert data.msg = "world"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record34.vhd000066400000000000000000000012101504111170000173120ustar00rootroot00000000000000entity record34 is end entity; architecture test of record34 is type rec is record x : bit_vector; y : natural; end record; type rec_array is array (natural range <>) of rec; type wrapper is record f : rec_array(1 to 3)(x(1 to 2)); end record; signal s : wrapper; begin p1: process is begin s.f(1) <= (x => "10", y => 1); wait for 1 ns; assert s.f = (1 => ("10", 1), 2 to 3 => ("00", 0)); s.f(2).x(1) <= '1'; wait for 1 ns; assert s.f = (1 => ("10", 1), 2 => ("10", 0), 3 => ("00", 0)); wait; end process; end architecture; nvc-r1.17.1/test/regress/record35.vhd000066400000000000000000000034411504111170000173230ustar00rootroot00000000000000-- Test case from Brian Padalino -- library ieee; use ieee.std_logic_1164.all; package abc is type Parameters_t is record BW : natural; PAIRS : natural; end record; type Indices_t is array (natural range <>) of std_logic_vector; type Bus_t is record Indices : Indices_t; end record; function Test( abc_bus : Bus_t ) return Bus_t; function Test( abc_bus : Bus_t; indices : Indices_t ) return Bus_t; end package; package body abc is function Test( abc_bus : Bus_t; indices : Indices_t ) return Bus_t is variable result : Bus_t( Indices(abc_bus.Indices'range)(abc_bus.Indices'element'range) ) := Test(abc_bus); begin return result; end function; function Test( abc_bus : Bus_t ) return Bus_t is variable result : Bus_t( Indices(abc_bus.Indices'range)(abc_bus.Indices'element'range) ) := abc_bus; begin return result; end function; end package body; library ieee; use ieee.std_logic_1164.all; use work.abc; use work.abc.all; use std.env.finish; entity record35 is end entity; architecture sim of record35 is constant CLK_PERIOD : time := 10 ns; signal clk : std_ulogic := '0'; constant abc_BUS_SETTINGS : abc.Parameters_t := ( BW => 8, PAIRS => 2 ); signal abc_bus : abc.Bus_t( Indices(abc_BUS_SETTINGS.PAIRS - 1 downto 0)(abc_BUS_SETTINGS.BW - 1 downto 0) ); begin clk <= not clk after CLK_PERIOD / 2; test_runner : process begin abc_bus <= abc.Test( abc_bus, ( 0 => std_logic_vector'(x"00"), 1 => std_logic_vector'(x"01") ) ); wait for CLK_PERIOD; finish; end process test_runner; end architecture sim; nvc-r1.17.1/test/regress/record36.vhd000066400000000000000000000011321504111170000173170ustar00rootroot00000000000000entity record36 is end entity; architecture test of record36 is type rec is record s : string; end record; procedure test (r : inout rec) is variable rr : r'subtype; begin rr := r; for i in rr.s'range loop rr.s(i) := 'X'; end loop; r := rr; end procedure; begin p1: process is variable r : rec(s(1 to 3)); begin r := (s => "abc"); test(r); assert r.s = "XXX"; r.s := "foo"; test(r); assert r.s = "XXX"; wait; end process; end architecture; nvc-r1.17.1/test/regress/record37.vhd000066400000000000000000000014751504111170000173320ustar00rootroot00000000000000package pack is type rec is record x : bit_vector(1 to 3); y : integer; end record; type rec_array is array (natural range <>) of rec; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( n : positive ); end entity; architecture test of sub is signal s : rec_array(1 to n); begin p1: process is begin assert s = ( 1 to n => (x => "000", y => integer'low) ); wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity record37 is end entity; architecture test of record37 is begin u1: entity work.sub generic map ( 4 ); u2: entity work.sub generic map ( 5 ); end architecture; nvc-r1.17.1/test/regress/record38.vhd000066400000000000000000000013411504111170000173230ustar00rootroot00000000000000entity record38 is end entity; architecture test of record38 is type rec1_t is record x : integer_vector; end record; type rec1_array is array (natural range <>) of rec1_t; type rec2_t is record a : rec1_array; end record; begin p1: process is variable v : rec2_t(a(1 to 2)(x(1 to 3))); constant k : rec2_t(a(1 to 2)(x(1 to 3))) := (a => (others => (x => (100, 200, 300)))); begin assert v.a(1).x(1) = integer'left; v.a(1).x := (1, 2, 3); wait for 1 ns; assert v.a(1).x(2) = 2; v := (a => k.a); v.a(1).x(1) := 999; wait for 1 ns; assert k.a(1).x(1) = 100; wait; end process; end architecture; nvc-r1.17.1/test/regress/record39.vhd000066400000000000000000000007771504111170000173400ustar00rootroot00000000000000entity record39 is end entity; architecture test of record39 is type t_rec is record x, y : integer; end record; type t_rec_array is array (natural range <>) of t_rec; signal s : t_rec_array(1 to 2); begin b: block is port ( p : out t_rec_array ); port map ( s ); begin p <= ((1, 2), (3, 4)); end block; check: process is begin wait for 1 ns; assert s = ((1, 2), (3, 4)); wait; end process; end architecture; nvc-r1.17.1/test/regress/record4.vhd000066400000000000000000000015631504111170000172420ustar00rootroot00000000000000entity record4 is end entity; architecture test of record4 is type rec is record x, y : integer; end record; type rec_array is array (natural range <>) of rec; function sum(r : in rec) return integer is begin return r.x + r.y; end function; function double(x : in integer) return integer is begin return x * 2; end function; function sum_all(a : in rec_array) return integer is variable s : integer := 0; begin for i in a'range loop s := s + sum(a(i)); end loop; return s; end function; begin process is variable ra : rec_array(0 to 1) := ( ( 1, 2 ), ( 3, 4 ) ); begin assert sum(ra(0)) = 3; assert double(ra(0).x) = 2; assert sum_all(ra) = 10; wait; end process; end architecture; nvc-r1.17.1/test/regress/record5.vhd000066400000000000000000000013721504111170000172410ustar00rootroot00000000000000entity record5 is end entity; architecture test of record5 is type rec is record b : bit_vector(1 to 8); i : integer; end record; type rec_array is array (natural range <>) of rec; function reduce_or(x : bit_vector) return bit is variable r : bit := '0'; begin for i in x'range loop r := r or x(i); end loop; return r; end function; function foo(a : rec_array) return bit is begin return reduce_or(a(0).b); end function; begin process is variable ra : rec_array(0 to 1) := ( ( b => X"05", i => 6 ), ( b => X"1a", i => 1 ) ); begin assert foo(ra) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/record6.vhd000066400000000000000000000024771504111170000172510ustar00rootroot00000000000000entity record6 is end entity; architecture test of record6 is type rec is record x : bit_vector(1 to 3); y : integer; end record; type rec_array is array (natural range <>) of rec; function make_rec(x : bit_vector(1 to 3); y : integer) return rec is variable r : rec; begin r.x := x; r.y := y; return r; end function; function make_rec_array(x : rec; l, r : natural) return rec_array is variable ra : rec_array(l to r) := (others => x); begin return ra; end function; function get_bit(v : in rec) return bit is begin return v.x(v.y); end function; begin process is variable r : rec; variable one : integer := 1; -- Prevent constant folding begin r.x := "101"; r.y := 1; assert get_bit(r) = '1'; r.y := 2; assert get_bit(r) = '0'; assert get_bit(make_rec("011", one + 1)) = '1'; r.x := make_rec("010", one).x; assert r.x = "010"; r.y := make_rec("010", one).y; assert r.y = 1; r := make_rec("010", one); assert make_rec_array(r, 1, 2) = ( ("010", 1), ("010", 1) ); assert make_rec_array(("111", 5), one, 2) = ( ("111", 5), ("111", 5) ); wait; end process; end architecture; nvc-r1.17.1/test/regress/record7.vhd000066400000000000000000000007431504111170000172440ustar00rootroot00000000000000entity record7 is end entity; architecture test of record7 is type rec is record x, y : integer; end record; signal s : rec; begin process is begin assert s = (integer'left, integer'left); s <= (1, 2); wait for 1 ns; assert s = (1, 2); assert s.x = 1; assert s.y = 2; s.x <= 3; s.y <= 4; wait for 1 ns; assert s = (3, 4); wait; end process; end architecture; nvc-r1.17.1/test/regress/record8.vhd000066400000000000000000000013711504111170000172430ustar00rootroot00000000000000entity record8 is end entity; architecture test of record8 is type small_int is range 0 to 5; type sub_rec is record var : small_int; end record; type rec is record vec : bit_vector(1 to 3); num : integer; sub : sub_rec; end record; signal r : rec; begin process is begin assert r = ("000", integer'left, ( var => 0 ) ); r.vec <= "101"; wait for 1 ns; assert r = ("101", integer'left, ( var => 0 ) ); assert r.vec = "101"; assert r.vec(3) = '1'; r.num <= 5; wait for 1 ns; assert r.num = 5; r.sub.var <= 2; wait for 1 ns; assert r.sub.var = 2; wait; end process; end architecture; nvc-r1.17.1/test/regress/record9.vhd000066400000000000000000000016441504111170000172470ustar00rootroot00000000000000entity sub is end entity; architecture test of sub is type rec is record x : integer; end record; constant c : rec := (x => 2); signal ss : rec := c; function add1(x : integer) return integer is begin return x + 1; end function; begin process is variable r : rec := c; begin r.x := add1(ss.x); assert r.x = 3; wait; end process; end architecture; ------------------------------------------------------------------------------- entity record9 is end entity; architecture test of record9 is type rec is record x : bit_vector(1 to 3); end record; constant c : rec := (x => "101"); signal s : rec := c; begin uut: entity work.sub; s.x <= "111"; process is begin assert s = c; wait for 1 ns; assert s = (x => "111"); wait; end process; end architecture; nvc-r1.17.1/test/regress/reflect1.vhd000066400000000000000000000055001504111170000174000ustar00rootroot00000000000000entity reflect1 is end entity; use std.reflection.all; architecture test of reflect1 is begin p1: process is variable v1 : integer := 42; variable v2 : integer_vector(1 to 3) := (1, 2, 3); variable v3 : real := 1.234; variable vm : value_mirror; variable ivm : integer_value_mirror; variable avm : array_value_mirror; variable fvm : floating_value_mirror; variable evm : enumeration_value_mirror; variable stm : subtype_mirror; variable istm : integer_subtype_mirror; variable astm : array_subtype_mirror; variable fstm : floating_subtype_mirror; variable estm : enumeration_subtype_mirror; begin vm := v1'reflect; assert vm.get_value_class = CLASS_INTEGER; ivm := vm.to_integer; assert ivm.value = 42; v1 := 100; wait for 1 ns; assert ivm.value = 42; assert ivm.image = "42"; assert v1'reflect.all.to_integer.value = 100; assert ivm.to_value_mirror = vm; stm := vm.get_subtype_mirror; assert stm.get_type_class = CLASS_INTEGER; istm := stm.to_integer; assert istm.simple_name = "INTEGER"; assert istm.to_subtype_mirror = stm; assert ivm.get_subtype_mirror = istm; assert istm.ascending; assert istm.length = 0; -- XXX: should be an error assert istm.low.value = integer'left; assert istm.high.value = integer'right; assert istm.left = istm.low; assert istm.right = istm.high; assert integer'reflect = stm; vm := v2'reflect; assert vm.get_value_class = CLASS_ARRAY; avm := vm.to_array; assert avm.get(1).to_integer.value = 1; assert avm.get(2).to_integer.value = 2; assert avm.get((1 => 3)).to_integer.value = 3; astm := avm.get_subtype_mirror; assert astm.dimensions = 1; assert astm.index_subtype = natural'reflect; assert astm.element_subtype = integer'reflect; assert astm.length = 3; assert astm.left = 1; assert astm.right = 3; assert astm.ascending; assert astm.low = 1; assert astm.high = 3; fvm := v3'reflect.to_floating; assert fvm.value = 1.234; assert fvm.get_subtype_mirror.to_subtype_mirror = real'reflect; evm := true'reflect.to_enumeration; assert evm.pos = 1; assert evm.image = "true"; estm := evm.get_subtype_mirror; assert estm.length = 2; assert estm.ascending; assert estm.left.image = "false"; assert estm.right.pos = 1; assert character'reflect.to_enumeration.enumeration_literal(72).image = "'H'"; assert estm.enumeration_literal("true").pos = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/reflect2.vhd000066400000000000000000000037261504111170000174110ustar00rootroot00000000000000entity reflect2 is end entity; use std.reflection.all; architecture test of reflect2 is procedure test_int (constant l, r : in integer) is subtype my_int is integer range l to r; variable v1 : my_int := 7; variable vm : value_mirror; variable ivm : integer_value_mirror; variable stm : subtype_mirror; variable istm : integer_subtype_mirror; begin vm := v1'reflect; assert vm.get_value_class = CLASS_INTEGER; ivm := vm.to_integer; assert ivm.value = 7; v1 := 0; wait for 1 ns; assert ivm.value = 7; assert ivm.image = "7"; assert v1'reflect.all.to_integer.value = 0; assert ivm.to_value_mirror = vm; stm := vm.get_subtype_mirror; assert stm.get_type_class = CLASS_INTEGER; istm := stm.to_integer; assert istm.simple_name = "MY_INT"; assert istm.to_subtype_mirror = stm; -- These two are both incorrect, just documenting the behaviour assert istm.left.value = integer'left; assert istm.right.value = integer'right; end procedure; procedure test_array (constant l, r : in integer) is variable a : integer_vector(l to r); variable vm : value_mirror; variable stm : subtype_mirror; variable astm : array_subtype_mirror; begin vm := a'reflect; stm := vm.get_subtype_mirror; astm := stm.to_array; assert astm.left = index(l); assert astm.right = index(r); assert astm.length = index(maximum(r - l + 1, 0)); end procedure; begin p1: process is type small_int is range 1 to 10; type small_real is range 0.0 to 1.0; begin assert small_int'reflect.to_integer.right.value = 10; assert small_real'reflect.to_floating.left.value = 0.0; test_int(-10, 10); test_array(1, 10); test_array(2, 3); wait; end process; end architecture; nvc-r1.17.1/test/regress/reflect3.vhd000066400000000000000000000023471504111170000174100ustar00rootroot00000000000000entity reflect3 is end entity; use std.reflection.all; architecture test of reflect3 is type rec1 is record a, b : natural; c : string(1 to 3); end record; begin p1: process is variable v1 : rec1 := (1, 2, "abc"); variable vm : value_mirror; variable rvm : record_value_mirror; variable rstm : record_subtype_mirror; variable astm : array_subtype_mirror; begin vm := v1'reflect; rvm := vm.to_record; rstm := rvm.get_subtype_mirror; assert rstm.length = 3; assert rstm.element_name(0) = "A"; assert rstm.element_name(1) = "B"; assert rstm.element_name(2) = "C"; assert rstm.element_index("B") = 1; assert rstm.element_subtype("A") = natural'reflect; assert rstm.element_subtype("C").get_type_class = class_array; assert rstm.to_subtype_mirror = rec1'reflect; -- Should cache assert rvm.get(0).to_integer.value = 1; assert rvm.get("b").to_integer.value = 2; astm := rstm.element_subtype("C").to_array; assert astm.length = 3; assert rvm.get("c").to_array.get(1).to_enumeration.image = "'a'"; wait; end process; end architecture; nvc-r1.17.1/test/regress/reflect4.vhd000066400000000000000000000024731504111170000174110ustar00rootroot00000000000000entity reflect4 is end entity; use std.reflection.all; architecture test of reflect4 is type rec1 is record a, b : integer; c : string; end record; begin p1: process is variable v1 : rec1 := (1, 2, "abc"); variable vm : value_mirror; variable rvm : record_value_mirror; variable rstm : record_subtype_mirror; variable astm : array_subtype_mirror; begin vm := v1'reflect; rvm := vm.to_record; rstm := rvm.get_subtype_mirror; assert rstm.length = 3; assert rstm.element_name(0) = "A"; assert rstm.element_name(1) = "B"; assert rstm.element_name(2) = "C"; assert rstm.element_index("B") = 1; assert rstm.element_subtype("A") = integer'reflect; assert rstm.element_subtype("C").get_type_class = class_array; assert rvm.get(0).to_integer.value = 1; assert rvm.get("b").to_integer.value = 2; astm := rstm.element_subtype("C").to_array; assert astm.length = 3; assert astm.left = 1; assert astm.right = 3; assert astm.ascending; assert rvm.get("c").to_array.get(1).to_enumeration.image = "'a'"; assert rvm.get("c").to_array.get(3).to_enumeration.image = "'c'"; wait; end process; end architecture; nvc-r1.17.1/test/regress/reflect5.vhd000066400000000000000000000054231504111170000174100ustar00rootroot00000000000000entity reflect5 is end entity; use std.reflection.all; use std.textio.all; architecture test of reflect5 is function basename(path : string) return string is begin for i in path'reverse_range loop if path(i) = '\' or path(i) = '/' then return path(i + 1 to path'length); end if; end loop; return path; end function; type pt is protected procedure proc; end protected; type pt is protected body procedure proc is begin end procedure; end protected body; begin p1: process is variable stm : subtype_mirror; variable fstm : file_subtype_mirror; variable astm : access_subtype_mirror; variable fvm : file_value_mirror; variable avm : access_value_mirror; variable pstm : physical_subtype_mirror; variable pvm : physical_value_mirror; file f : text; variable ptr : line; variable d : delay_length; variable p : pt; begin stm := text'reflect; assert stm.get_type_class = CLASS_FILE; fstm := stm.to_file; assert fstm.designated_subtype.simple_name = "STRING"; file_open(f, "temp.txt", WRITE_MODE); fvm := f'reflect.to_file; assert fvm.get_file_open_kind = WRITE_MODE; assert basename(fvm.get_file_logical_name) = "temp.txt"; fvm := std.textio.output'reflect.to_file; assert fvm.get_file_open_kind = WRITE_MODE; assert basename(fvm.get_file_logical_name) = "STD_OUTPUT"; stm := line'reflect; assert stm.get_type_class = CLASS_ACCESS; astm := stm.to_access; assert astm.designated_subtype.simple_name = "STRING"; avm := ptr'reflect.to_access; assert avm.is_null; ptr := new string'("hello"); avm := ptr'reflect.to_access; assert not avm.is_null; assert avm.get.to_array.get_subtype_mirror.length = 5; assert avm.get.to_array.get(1).to_enumeration.image= "'h'"; assert avm.get.to_array.get(5).to_enumeration.image= "'o'"; stm := time'reflect; assert stm.get_type_class = CLASS_PHYSICAL; pstm := stm.to_physical; assert pstm.units_length = 8; assert pstm.unit_index("ns") = 3; assert pstm.unit_name(5) = "MS"; assert pstm.scale("fs") = 1; assert pstm.scale("ns") = 1000000; d := 20 ns; pvm := d'reflect.to_physical; assert pvm.value = 20000000; assert pvm.image = "20000000 FS"; stm := pt'reflect; assert stm.get_type_class = CLASS_PROTECTED; assert stm.to_protected.to_subtype_mirror = stm; assert p'reflect.get_value_class = CLASS_PROTECTED; wait; end process; end architecture; nvc-r1.17.1/test/regress/select1.v000066400000000000000000000007671504111170000167310ustar00rootroot00000000000000module select1(); reg [7:0] x; reg b; // Out-of-range bit select initial begin x = 42; b = x[1]; if (b !== 1) begin $display("FAILED (1) -- %d !== 1", b); $finish; end b = x[8]; if (b !== 1'bx) begin $display("FAILED (2) -- %d !== 1", b); $finish; end b = x[123512632]; if (b !== 1'bx) begin $display("FAILED (3) -- %d !== 1", b); $finish; end $display("PASSED"); $finish; end endmodule // vlog15 nvc-r1.17.1/test/regress/select2.v000066400000000000000000000005731504111170000167250ustar00rootroot00000000000000module select2(); reg [67:60] x; reg [1:0] y; reg b; initial begin x = 42; y = x[61:60]; if (y !== 2) begin $display("FAILED (1) -- %x !== 2", y); $finish; end y = x[66:65]; if (y !== 1) begin $display("FAILED (2) -- %x !== 1", y); $finish; end $display("PASSED"); $finish; end endmodule // vlog15 nvc-r1.17.1/test/regress/select3.v000066400000000000000000000007641504111170000167300ustar00rootroot00000000000000module select3; reg [7:0] in, idx; wire out; assign out = in[idx]; initial begin in = 'h42; idx = 0; #1 if (out !== 0) begin $display("FAILED (1) -- %d !== 0", out); $finish; end idx = 1; #1 if (out !== 1) begin $display("FAILED (2) -- %d !== 1", out); $finish; end idx = 100; #1 if (out !== 1'bx) begin $display("FAILED (3) -- %d !== x", out); $finish; end $display("PASSED"); end endmodule // select3 nvc-r1.17.1/test/regress/select4.v000066400000000000000000000007271504111170000167300ustar00rootroot00000000000000module select4; reg [8:1] x = 0; reg [15:0] idx; initial begin x[0] = 1; if (x !== 0) begin $display("FAILED (1) -- %x !== 0", x); $finish; end x[8] = 1; if (x !== 8'h80) begin $display("FAILED (2) -- %x !== 80", x); $finish; end idx = 10000; #1 x[idx] = 1; if (x !== 8'h80) begin $display("FAILED (3) -- %x !== 80", x); $finish; end $display("PASSED"); end endmodule // select4 nvc-r1.17.1/test/regress/select5.v000066400000000000000000000011341504111170000167220ustar00rootroot00000000000000module select5; reg [7:0] array [0:3]; initial begin array[1] = 42; if (array[1] !== 42) begin $display("FAILED (1) -- %d !== 42", array[1]); $finish; end array[4] = 55; if (array[1] !== 42) begin $display("FAILED (2) -- %d !== 42", array[1]); $finish; end array[1][0] = 1; if (array[1] !== 43) begin $display("FAILED (3) -- %d !== 43", array[1]); $finish; end else if (array[1][1] !== 1) begin $display("FAILED (4) -- %x !== 1", array[1][2]); $finish; end $display("PASSED"); end endmodule // select5 nvc-r1.17.1/test/regress/select6.v000066400000000000000000000010371504111170000167250ustar00rootroot00000000000000module select6; reg [7:0] array [0:3][1:2]; reg [7:0] cnt = 0; always @(array[2][2][3]) cnt = cnt + 1; initial begin array[2][1] = 7; array[2][2] = 8; array[3][2] = 8; array[66][1] = 6; if (array[2][1] !== 7 || array[2][2] !== 8) begin $display("FAILED (1) -- %x %x %x", array[2][1], array[2][2], array[0][1]); $finish; end array[3][2] = 0; #1 if (cnt !== 1) begin $display("FAILED (2) -- %d", cnt); $finish; end $display("PASSED"); end endmodule // select6 nvc-r1.17.1/test/regress/select7.v000066400000000000000000000010201504111170000167160ustar00rootroot00000000000000module select7; reg [7:0] x; wire [1:0] y; assign y = x[5:4]; assign z = x[5:4]; // Implicit net always @(x) $display("===> %x", x); initial begin x[7:0] = 8'h42; #1 if (y !== 2'b0) begin $display("FAILED (1) -- %x", y); $finish; end x[5:3] = 3'b111; #1 if (y !== 2'b11) begin $display("FAILED (2) -- %x", y); $finish; end if (z !== 1) begin $display("FAILED (3) -- %x", z); $finish; end $display("PASSED"); end endmodule // select7 nvc-r1.17.1/test/regress/seqblock1.vhd000066400000000000000000000007611504111170000175630ustar00rootroot00000000000000entity seqblock1 is end entity; architecture test of seqblock1 is begin process is variable a : natural; begin for i in 1 to 100 loop a := i; block is constant c : natural := a + 1; variable a : integer := 99; begin wait for 1 ns; assert c = i + 1; assert a = 99; end block; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/seqblock2.vhd000066400000000000000000000011361504111170000175610ustar00rootroot00000000000000-- https://gitlab.com/IEEE-P1076/VHDL-Issues/-/issues/281 entity seqblock2 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of seqblock2 is signal x : std_logic_vector(1 to 3) := "ZZZ"; begin process is begin for i in 1 to 3 loop block is constant c : natural := i; begin x(c) <= '1'; end block; end loop; wait; end process; x(1) <= '0'; process is begin wait for 1 ns; assert x = "X11"; wait; end process; end architecture; nvc-r1.17.1/test/regress/shared1.vhd000066400000000000000000000013561504111170000172270ustar00rootroot00000000000000package p is shared variable pglobal : integer := 2; end package; ------------------------------------------------------------------------------- entity shared1 is end entity; use work.p.all; architecture test of shared1 is shared variable global : integer := 5; procedure check_it(constant expect : in integer) is begin assert global = expect; end procedure; procedure set_it(constant set : in integer) is begin global := set; end procedure; begin process is begin assert global = 5; global := 6; check_it(6); set_it(7); assert global = 7; assert pglobal = 2; pglobal := 51; wait; end process; end architecture; nvc-r1.17.1/test/regress/shared2.vhd000066400000000000000000000011511504111170000172210ustar00rootroot00000000000000entity shared2 is end entity; architecture test of shared2 is type ram_t is array (integer range <>) of bit_vector(7 downto 0); shared variable ram : ram_t(1 to 8) := ( 1 => X"11", 2 => X"22", 3 => X"33", others => X"00" ); begin update: process is begin wait for 1 ns; ram(5) := X"aa"; wait; end process; check: process is begin assert ram(1) = X"11"; assert ram(2) = X"22"; assert ram(5) = X"00"; wait for 5 ns; assert ram(5) = X"aa"; wait; end process; end architecture; nvc-r1.17.1/test/regress/shared3.vhd000066400000000000000000000006161504111170000172270ustar00rootroot00000000000000entity shared3 is shared variable x : integer; end entity; architecture test of shared3 is begin p1: process is begin assert x = integer'left; x := 5; wait for 6 ns; assert x = 7; wait; end process; p2: process is begin wait for 1 ns; assert x = 5; x := 7; wait; end process; end architecture; nvc-r1.17.1/test/regress/shared4.vhd000066400000000000000000000011031504111170000172200ustar00rootroot00000000000000-- Test shared variables in -2008 with --relax=shared entity shared4 is end entity; architecture test of shared4 is shared variable x : natural; begin g0: for i in 1 to 10 generate begin p1: process is begin for i in 1 to 1000 loop x := x + 1; -- Racy! end loop; wait; end process; end generate; p2: process is begin wait for 1 ns; assert x = 10 * 1000; -- May fail multithreaded sim wait; end process; end architecture; nvc-r1.17.1/test/regress/shift1.vhd000066400000000000000000000026311504111170000170730ustar00rootroot00000000000000entity shift1 is end entity; architecture test of shift1 is type my_bit_vector is array (integer range <>) of bit; begin process is variable b : my_bit_vector(3 downto 0); variable c : my_bit_vector(0 to 3); variable d : my_bit_vector(0 to -1); begin b := "1011"; c := "1011"; wait for 1 ns; assert (b sll 1) = "0110"; assert (c sll 1) = "0110"; assert (b srl 1) = "0101"; assert (c srl 1) = "0101"; assert (b sla 1) = "0111"; assert (c sla 1) = "0111"; assert (b sra 1) = "1101"; assert (c sra 1) = "1101"; assert (b rol 2) = "1110"; assert (c rol 2) = "1110"; assert (b ror 1) = "1101"; assert (c ror 1) = "1101"; assert (b srl -1) = "0110"; assert (c srl -1) = "0110"; assert (b sll -1) = "0101"; assert (c sll -1) = "0101"; assert (b sra -1) = "0111"; assert (c sra -1) = "0111"; assert (b sla -1) = "1101"; assert (c sla -1) = "1101"; assert (b ror -2) = "1110"; assert (c ror -2) = "1110"; assert (b rol -1) = "1101"; assert (c rol -1) = "1101"; assert (c rol -5) = "1101"; assert (d sll 1) = d; -- Null array b := "0001"; wait for 1 ns; assert (b sll -4) = "0000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/shift2.vhd000066400000000000000000000073051504111170000170770ustar00rootroot00000000000000entity shift2 is end entity; architecture test of shift2 is signal input : bit_vector(4 downto 0) := "11100"; begin assert bit_vector'(input) ror -8 = "00111" report "ror -8 is broken" severity error; assert bit_vector'(input) ror -7 = "10011" report "ror -7 is broken" severity error; assert bit_vector'(input) ror -6 = "11001" report "ror -6 is broken" severity error; assert bit_vector'(input) ror -5 = input report "ror -5 is broken" severity error; assert bit_vector'(input) ror -4 = "01110" report "ror -4 is broken" severity error; assert bit_vector'(input) ror -3 = "00111" report "ror -3 is broken" severity error; assert bit_vector'(input) ror -2 = "10011" report "ror -2 is broken" severity error; assert bit_vector'(input) ror -1 = "11001" report "ror -1 is broken" severity error; assert bit_vector'(input) ror 0 = input report "ror 0 is broken" severity error; assert bit_vector'(input) ror 1 = "01110" report "ror 1 is broken" severity error; assert bit_vector'(input) ror 2 = "00111" report "ror 2 is broken" severity error; assert bit_vector'(input) ror 3 = "10011" report "ror 3 is broken" severity error; assert bit_vector'(input) ror 4 = "11001" report "ror 4 is broken" severity error; assert bit_vector'(input ror 5) = input report "ror 5 is broken" severity error; assert bit_vector'(input) ror 6 = "01110" report "ror 6 is broken" severity error; assert bit_vector'(input) ror 7 = "00111" report "ror 7 is broken" severity error; assert bit_vector'(input) ror 8 = "10011" report "ror 8 is broken" severity error; -- ROL assert bit_vector'(input) rol -8 = "10011" report "rol -8 is broken" severity error; assert bit_vector'(input) rol -7 = "00111" report "rol -7 is broken" severity error; assert bit_vector'(input) rol -6 = "01110" report "rol -6 is broken" severity error; assert bit_vector'(input rol -5) = input report "rol -5 is broken" severity error; assert bit_vector'(input) rol -4 = "11001" report "rol -4 is broken" severity error; assert bit_vector'(input) rol -3 = "10011" report "rol -3 is broken" severity error; assert bit_vector'(input) rol -2 = "00111" report "rol -2 is broken" severity error; assert bit_vector'(input) rol -1 = "01110" report "rol -1 is broken" severity error; assert bit_vector'(input) rol 0 = input report "rol 0 is broken" severity error; assert bit_vector'(input) rol 1 = "11001" report "rol 1 is broken" severity error; assert bit_vector'(input) rol 2 = "10011" report "rol 2 is broken" severity error; assert bit_vector'(input) rol 3 = "00111" report "rol 3 is broken" severity error; assert bit_vector'(input) rol 4 = "01110" report "rol 4 is broken" severity error; assert bit_vector'(input) rol 5 = input report "rol 5 is broken" severity error; assert bit_vector'(input) rol 6 = "11001" report "rol 6 is broken" severity error; assert bit_vector'(input) rol 7 = "10011" report "rol 7 is broken" severity error; assert bit_vector'(input) rol 8 = "00111" report "rol 8 is broken" severity error; end architecture; nvc-r1.17.1/test/regress/shuffle1.vhd000066400000000000000000000026371504111170000174200ustar00rootroot00000000000000entity shuffle1 is end entity; architecture test of shuffle1 is type t_order is protected impure function get return natural; end protected; type t_order is protected body variable last : time := time'high; variable count : natural; impure function get return natural is variable r : natural; begin if now /= last then last := now; count := 0; end if; r := count; count := count + 1; return r; end function; end protected body; shared variable global : t_order; type order_vector is array (natural range <>) of natural; constant ITERS : natural := 100; begin g: for i in 1 to 5 generate p: process is variable history : order_vector(1 to ITERS); variable order : natural; variable shuffled : boolean := false; begin for j in 1 to ITERS loop order := global.get; --report p'instance_name & " ==> " & integer'image(order); history(j) := order; wait for 1 ns; end loop; for j in 2 to ITERS loop shuffled := shuffled or (history(j) /= history(j - 1)); end loop; assert shuffled; wait; end process; end generate; end architecture; nvc-r1.17.1/test/regress/signal1.vhd000066400000000000000000000007241504111170000172340ustar00rootroot00000000000000entity signal1 is end entity; architecture test of signal1 is signal x : integer := 5; begin process is begin assert x = 5 report "initial value not 5"; x <= 6; assert x = 5 report "x changed after nb assign"; wait for 1 ns; assert x = 6 report "x not updated"; x <= 7; wait for 0 ns; assert x = 7 report "x not updated after delta cycle"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal10.vhd000066400000000000000000000013541504111170000173140ustar00rootroot00000000000000entity signal10 is end entity; architecture test of signal10 is signal x, y, z : bit; signal u : bit_vector(1 to 3); signal v : bit_vector(2 downto 0); begin process is begin (x, y, z) <= bit_vector'("011"); wait for 1 ns; assert x = '0'; assert y = '1'; assert z = '1'; u <= bit_vector'("011"); wait for 1 ns; (x, y, z) <= u; wait for 1 ns; assert x = '0'; assert y = '1'; assert z = '1'; v <= bit_vector'("011"); wait for 1 ns; (x, y, z) <= v; wait for 1 ns; assert x = '0'; assert y = '1'; assert z = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal11.vhd000066400000000000000000000021201504111170000173050ustar00rootroot00000000000000package pack is signal x, y : integer := 0; procedure inc(signal s : out integer); end package; package body pack is procedure inc(signal s : out integer) is begin s <= x + 1; end procedure; procedure bar(signal s : in integer) is begin end procedure; procedure foo is begin bar(x); end procedure; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is end entity; architecture test of sub is begin process is begin report x'path_name; report x'instance_name; wait; end process; end architecture; ------------------------------------------------------------------------------- entity signal11 is end entity; use work.pack.all; architecture test of signal11 is begin process is begin assert x = 0; inc(x); wait for 1 ns; assert x = 1; wait for 1 ns; assert y = 2; wait; end process; y <= x + 1; sub_i: entity work.sub; end architecture; nvc-r1.17.1/test/regress/signal12.vhd000066400000000000000000000011111504111170000173050ustar00rootroot00000000000000entity signal12 is end entity; architecture test of signal12 is type byte_vec is array (integer range <>) of bit_vector(7 downto 0); signal a : bit_vector(7 downto 0); signal b : byte_vec(1 to 3); begin assign: b <= (others => a); process is begin a <= X"01"; wait for 1 ns; assert b(1) = X"01"; assert b(2) = X"01"; assert b(3) = X"01"; a <= X"f0"; wait for 1 ns; assert b(1) = X"f0"; assert b(2) = X"f0"; assert b(3) = X"f0"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal13.vhd000066400000000000000000000005741504111170000173220ustar00rootroot00000000000000entity signal13 is end entity; architecture test of signal13 is function invert(signal x : in bit) return bit is begin return not x; end function; signal vec : bit_vector(1 to 3) := "101"; begin process is begin assert invert(vec(1)) = '0'; assert invert(vec(2 to 3)(2)) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal14.vhd000066400000000000000000000012401504111170000173120ustar00rootroot00000000000000package pack is signal reset : bit := '1'; end package; ------------------------------------------------------------------------------- entity buf is port ( i : in bit; o : out bit ); end entity; architecture behav of buf is begin o <= i after 1 ns; end architecture; entity signal14 is end entity; use work.pack.all; architecture test of signal14 is signal reset_o : bit; begin u1: entity work.buf port map ( i => reset, o => reset_o ); process is begin assert reset_o = '0'; wait for 2 ns; assert reset_o = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal15.vhd000066400000000000000000000026511504111170000173220ustar00rootroot00000000000000-- VHDL 2008 element resolution entity signal15 is end entity; architecture test of signal15 is type my_utype is (a, b, c); type my_utype_vector is array (natural range <>) of my_utype; type my_utype_vector_vector is array (natural range <>) of my_utype_vector(1 to 3); function resolved (s : my_utype_vector) return my_utype; subtype my_type is resolved my_utype; subtype my_type_vector is (resolved) my_utype_vector; subtype my_type_vector_vector is ((resolved)) my_utype_vector_vector; function resolved (s : my_utype_vector) return my_utype is variable result : my_utype := s(s'low); begin for i in s'range loop if my_utype'pos(s(i)) > my_utype'pos(result) then result := s(i); end if; end loop; return result; end function; signal x : my_type; signal y : my_type_vector(1 to 3); signal z : my_type_vector_vector(1 to 3); begin x <= b; y <= (a, b, c); z <= (others => (a, b, c)); process is begin x <= a; wait for 1 ns; assert x = b; x <= c; wait for 1 ns; assert x = c; y <= (b, b, b); wait for 1 ns; assert y = (b, b, c); z <= ((a, a, a), (b, b, b), (c, c, c)); wait for 1 ns; assert z = ((a, b, c), (b, b, c), (c, c, c)); wait for 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal16.vhd000066400000000000000000000012031504111170000173130ustar00rootroot00000000000000entity signal16 is end entity; architecture test of signal16 is signal x : bit_vector(15 downto 0); signal y : natural range 0 to 14; signal z : bit_vector(3 downto 0); begin p1: process (y, z) is begin x(y+1 downto y) <= z(1 downto 0); end process; p2: process is begin assert x = "0000000000000000"; y <= 14; z <= "1111"; wait for 0 ns; assert x = "0000000000000000"; y <= 1; wait for 0 ns; assert x = "1100000000000000"; wait for 0 ns; assert x = "1100000000000110"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal17.vhd000066400000000000000000000023031504111170000173160ustar00rootroot00000000000000entity signal17 is end entity; architecture test of signal17 is type rec1 is record x : bit; y : bit_vector(1 to 3); z : integer; end record; type rec2 is record x : rec1; y : character; end record; type bv2d is array (natural range <>) of bit_vector(1 to 2); signal a : bit; signal b : bit_vector(1 to 3); signal c : integer; signal d : character; signal p, q, r : bit; begin p1: process is variable r1 : rec1; variable r2 : rec2; begin r1 := ('1', "010", 42); (a, b, c) <= r1; wait for 1 ns; assert a = '1'; assert b = "010"; assert c = 42; r2 := (('0', "100", 72), 'Z'); ((a, b, c), d) <= r2; wait for 1 ns; assert a = '0'; assert b = "100"; assert c = 72; assert d = 'Z'; (a, (p, q, r), c) <= r1; wait for 1 ns; assert a = '1'; assert p = '0'; assert q = '1'; assert r = '0'; assert c = 42; (b(1 to 2), (q, r)) <= bv2d'( "10", "01" ); wait for 1 ns; assert b = "100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal18.vhd000066400000000000000000000005701504111170000173230ustar00rootroot00000000000000entity signal18 is end entity; architecture test of signal18 is signal x, y : integer; begin p1: process (x, y) is begin x <= 1 when y > 10 else 0; end process; main: process is begin wait for 1 ns; assert x = 0; y <= 15; wait for 1 ns; assert x = 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal19.vhd000066400000000000000000000015671504111170000173330ustar00rootroot00000000000000entity sub is port ( o : out bit_vector(1 to 3) ); end entity; architecture test of sub is procedure write1(signal x : out bit) is begin x <= '1'; end procedure; begin p1: process is begin write1(o(1)); wait for 1 ns; write1(o(3)); wait; end process; end architecture; ------------------------------------------------------------------------------- entity signal19 is end entity; architecture test of signal19 is signal x : bit_vector(1 to 3); begin uut: entity work.sub port map ( x ); main: process is begin wait on x for 100 ns; assert now = 0 ns; wait on x for 100 ns; assert now = 1 ns; assert x'active; assert not x(1)'active; assert x(3)'active; assert x = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal2.vhd000066400000000000000000000011701504111170000172310ustar00rootroot00000000000000entity signal2 is end entity; architecture test of signal2 is signal x : bit := '0'; begin process is begin assert not x'event report "a"; assert not x'active report "b"; wait for 1 ns; x <= '1'; assert not x'event report "c"; wait for 0 ns; assert x'event; assert x'active; wait for 0 ns; assert not x'event; wait for 1 ns; assert not x'event; assert not x'active; x <= '1'; wait for 0 ns; assert not x'event; assert x'active; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal20.vhd000066400000000000000000000011451504111170000173130ustar00rootroot00000000000000entity signal20 is end entity; architecture test of signal20 is signal x : integer_vector(4 downto 0); signal y : integer_vector(1 downto 0); signal z : integer_vector(2 downto 0); signal i0, i1 : integer; begin main: process is begin x <= (1, 2, 3, 4, 5); wait for 1 ns; (y, z) <= x; wait for 1 ns; assert y = (1, 2); assert z = (3, 4, 5); wait for 1 ns; (i0, z, i1) <= x; wait for 1 ns; assert i0 = 1; assert z = (2, 3, 4); assert i1 = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal21.vhd000066400000000000000000000032421504111170000173140ustar00rootroot00000000000000package pack is type nat_vector is array (natural range <>) of natural; end package; ------------------------------------------------------------------------------- entity sub1 is port ( x : out natural ); end entity; architecture test of sub1 is begin p1: process is begin x <= 1; wait for 0 ns; assert x'event; assert x'active; wait for 0 ns; x <= 5; wait for 0 ns; assert x'event; assert x'active; x <= 5; assert x'active; wait for 0 ns; assert x'active; wait; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity sub2 is port ( z : in nat_vector(1 to 3) ); end entity; architecture test of sub2 is begin p2: process is begin assert z = (0, 2, 3); wait for 0 ns; assert z = (1, 2, 3); assert z'active; assert z'event; assert z(1)'event; wait for 0 ns ; assert not z'active; assert not z'event; wait for 0 ns; assert z = (5, 2, 3); assert z'active; assert z'event; wait for 0 ns ; assert z'active; assert not z'event; wait; end process; end architecture; ------------------------------------------------------------------------------- entity signal21 is end entity; architecture test of signal21 is signal y : natural; begin u1: entity work.sub1 port map ( y ); u2: entity work.sub2 port map ( z(1) => y, z(2) => 2, z(3) => 3 ); end architecture; nvc-r1.17.1/test/regress/signal22.vhd000066400000000000000000000014021504111170000173110ustar00rootroot00000000000000entity signal22 is end entity; architecture test of signal22 is function check_event (signal x : bit_vector) return boolean is begin return x'event; end function; function get_last_value (signal x : bit_vector) return bit_vector is begin return x'last_value; end function; signal s : bit_vector(1 to 3); begin s <= "101" after 1 ns, "011" after 2 ns; p1: process is begin assert not check_event(s); wait for 1 ns; assert check_event(s); assert get_last_value(s) = "000"; wait for 1 ns; assert check_event(s); assert get_last_value(s) = "101"; wait for 0 ns; assert not check_event(s); wait; end process; end architecture; nvc-r1.17.1/test/regress/signal23.vhd000066400000000000000000000036001504111170000173140ustar00rootroot00000000000000-- Test case from Brian Padalino -- library ieee ; use ieee.std_logic_1164.all ; package pack is type iface_t is record cs : std_logic ; addr : std_logic_vector ; rdata : std_logic_vector ; wdata : std_logic_vector ; end record ; function init_iface_signals(addr_width : natural ; data_width : natural) return iface_t; end package ; package body pack is function init_iface_signals(addr_width : natural ; data_width : natural) return iface_t is variable rv : iface_t(addr(addr_width-1 downto 0), wdata(data_width-1 downto 0), rdata(data_width-1 downto 0)) ; begin rv.cs := '0' ; rv.addr := (rv.addr'range => '0') ; rv.wdata := (rv.wdata'range => '0') ; rv.rdata := (rv.rdata'range => '0') ; return rv ; end function ; end package body ; library ieee ; use ieee.std_logic_1164.all ; use work.pack.all ; entity master is port ( clock : in std_logic ; iface : inout iface_t := init_iface_signals(16, 32) ) ; end entity ; architecture arch of master is begin end architecture ; library ieee ; use ieee.std_logic_1164.all ; use work.pack.all ; entity signal23 is end entity ; architecture arch of signal23 is signal clock : std_logic := '0' ; signal iface : iface_t(addr(15 downto 0), rdata(31 downto 0), wdata(31 downto 0)) ; begin clock <= not clock after 1 ns ; U_master : entity work.master port map ( clock => clock, iface => iface ) ; tb : process begin report LF & "if:" & LF & " cs: " & std_logic'image(iface.cs) & LF & " addr: " & to_hstring(iface.addr) & LF & " rdata: " & to_hstring(iface.rdata) & LF & " wdata: " & to_hstring(iface.wdata) ; std.env.stop ; end process ; end architecture ; nvc-r1.17.1/test/regress/signal24.vhd000066400000000000000000000006711504111170000173220ustar00rootroot00000000000000entity signal24 is end entity; architecture test of signal24 is type rec is record x : integer; z : bit_vector(1 to 3); end record; type rec_array is array (natural range <>) of rec; signal s : rec_array(1 to 2); begin p1: process is begin s(2) <= (5, "101"); wait for 1 ns; assert s = ((integer'left, "000"), (5, "101")); wait; end process; end architecture; nvc-r1.17.1/test/regress/signal25.vhd000066400000000000000000000006561504111170000173260ustar00rootroot00000000000000entity signal25 is end entity; architecture test of signal25 is type rec is record f : bit_vector; end record; signal v : bit_vector(1 to 3); signal r : rec(f(1 to 2)); begin p0: v(1 to r.f'right) <= (others => '1'); p1: v(r.f'right + 1 to 3) <= (others => '0'); check: process is begin wait for 1 ns; assert v = "110"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal26.vhd000066400000000000000000000011071504111170000173170ustar00rootroot00000000000000entity signal26 is end entity; architecture test of signal26 is function func (x : integer) return integer is begin return x / 2; end function; constant w : integer := 4; type rec is record f : bit_vector(func(w) - 1 downto 0); end record; signal v : bit_vector(w - 1 downto 0); signal r : rec; begin v(w-1 downto r.f'left + 1) <= (others => '1'); v(r.f'left downto 0) <= (others => '0'); check: process is begin wait for 1 ns; assert v = "1100"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal27.vhd000066400000000000000000000013241504111170000173210ustar00rootroot00000000000000entity signal27 is end entity; architecture test of signal27 is type rec is record x, y : integer; z : bit_vector(1 to 3); end record; procedure update(signal r : inout rec) is begin r <= (r.x + 1, r.y + 1, not r.z); wait for 1 ns; end procedure; signal a : integer := 0; signal b : integer := 5; signal c : bit_vector(1 to 3) := "101"; begin p1: process is begin update(r.x => a, r.y => b, r.z => c); assert a = 1; assert b = 6; assert c = "010"; update(r.x => b, r.y => a, r.z => c); assert a = 2; assert b = 7; assert c = "101"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal28.vhd000066400000000000000000000006771504111170000173340ustar00rootroot00000000000000entity signal28 is end entity; architecture test of signal28 is procedure set_bit (signal x : out bit) is begin x <= '1'; end procedure; signal s : bit_vector(1 to 7); begin p1: process is begin for i in s'range loop set_bit(s(i)); -- OK with relaxed rules end loop; wait for 1 ns; assert s = "1111111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal29.vhd000066400000000000000000000004351504111170000173250ustar00rootroot00000000000000entity signal29 is end entity; architecture test of signal29 is signal x : integer; begin p1: process is variable delay : time; begin delay := -10 ps; wait for 1 ns; x <= 1, 2 after delay; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal3.vhd000066400000000000000000000014031504111170000172310ustar00rootroot00000000000000entity signal3 is end entity; architecture test of signal3 is signal v : bit_vector(3 downto 0); begin proc1: process is begin assert not v'active; assert not v'event; wait for 1 ns; v(2) <= '1'; wait for 0 ns; assert v'event and v'active; wait; end process; proc2: process is begin wait for 1 ns; wait for 0 ns; assert v'event and v'active; wait for 1 ns; v(0) <= '1'; assert not v'event; wait for 0 ns; assert v'event and v'active; wait for 1 ns; assert not v'event; v(0) <= '1'; wait for 0 ns; assert not v'event and v'active; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal30.vhd000066400000000000000000000006221504111170000173130ustar00rootroot00000000000000entity signal30 is end entity; architecture test of signal30 is procedure proc (signal x : inout bit_vector) is begin x <= not x; wait for 1 ns; end procedure; signal s : bit := '0'; begin p1: process is begin proc(x(0) => s); assert s = '1'; proc(x(6) => s); assert s = '0'; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal31.vhd000066400000000000000000000006211504111170000173130ustar00rootroot00000000000000entity signal31 is end entity; architecture test of signal31 is type bv_array_t is array (natural range <>) of bit_vector; type rec_t is record f : bv_array_t; end record; signal s : rec_t(f(1 to 3)(1 to 2)); begin p1: process is begin s.f(2) <= "10"; wait for 1 ns; assert s.f(2)(1) = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal32.vhd000066400000000000000000000015751504111170000173250ustar00rootroot00000000000000-- LCS 2016-019 entity signal32 is end entity; architecture test of signal32 is type rec_t is record x : integer_vector; end record; function get_rec return rec_t is begin return (x => (5, 6)); end function; signal s1 : integer_vector := (1, 2, 3); signal s2 : rec_t := get_rec; begin p1: process is variable v1 : integer_vector := (1, 2, 3); variable v2 : rec_t := get_rec; begin assert s1'length = 3; assert s1'left = 0; assert s1(1) = 2; s1(2) <= 5; wait for 1 ns; assert s1 = (1, 2, 5); assert v1'length = 3; assert v1(2) = 3; assert s2.x'length = 2; assert s2.x = (5, 6); assert v2.x'length = 2; assert v2.x = (5, 6); v2.x(1) := 9; assert v2.x = (5, 9); wait; end process; end architecture; nvc-r1.17.1/test/regress/signal33.vhd000066400000000000000000000006431504111170000173210ustar00rootroot00000000000000entity signal33 is end entity; architecture test of signal33 is signal x : bit := '0'; begin p1: process is begin assert not x'event; assert not x'active; x <= '1'; wait for 0 ns; assert x'event; assert x'active; x <= '1'; wait for 0 ns; assert not x'event; assert x'active; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal35.vhd000066400000000000000000000011261504111170000173200ustar00rootroot00000000000000entity signal35 is end entity; architecture test of signal35 is signal s : integer := 1000; begin s <= 1 after 1 ns, 5 after 2 ns; b: block is port ( p : in integer := 0); port map ( p => inertial s ); begin check: process is begin assert p = 0; wait for 1 ns; assert p = 1000; wait for 0 ns; assert p = 1; wait for 1 ns; assert p = 1; wait for 0 ns; assert p = 5; wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/signal36.vhd000066400000000000000000000013141504111170000173200ustar00rootroot00000000000000entity signal36 is end entity; architecture test of signal36 is type t_rec is record x, y : natural; end record; signal s : t_rec := (1000, 1000); begin s <= (3, 4) after 1 ns, (5, 6) after 2 ns; b: block is port ( p : in t_rec := (42, 42) ); port map ( p => inertial s ); begin check: process is begin assert p = (42, 42); wait for 1 ns; assert p = (1000, 1000); wait for 0 ns; assert p = (3, 4); wait for 1 ns; assert p = (3, 4); wait for 0 ns; assert p = (5, 6); wait; end process; end block; end architecture; nvc-r1.17.1/test/regress/signal37.vhd000066400000000000000000000011031504111170000173150ustar00rootroot00000000000000entity signal37 is end entity; architecture test of signal37 is type t_rec is record f : bit; end record; type t_array is array (1 to 2) of t_rec; signal s : t_array; begin check: process is begin assert not s'event; s <= (others => (f => '1')); wait for 0 ns; assert s'event; wait for 0 ns; assert not s'event; s(1).f <= '0' after 1 ns; wait for 1 ns; assert s'event; wait for 0 ns; assert not s'event; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal4.vhd000066400000000000000000000013301504111170000172310ustar00rootroot00000000000000entity signal4 is end entity; architecture test of signal4 is signal s : bit_vector(3 downto 0) := (1 => '1', others => '0'); begin process is variable v : bit_vector(3 downto 0) := (others => '1'); begin assert s(0) = '0'; assert s(1) = '1'; assert v(1) = '1'; v(2) := s(3); assert v(2) = '0'; s(0) <= v(3); assert s(0) = '0'; wait for 1 ns; assert v(3) = '1'; assert s(0) = v(3); assert v = ( '1', '0', '1', '1' ); s <= v; assert s = ( '0', '0', '1', '1' ) report "one"; wait for 1 ns; assert s = ( '1', '0', '1', '1' ) report "two"; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal5.vhd000066400000000000000000000005051504111170000172350ustar00rootroot00000000000000entity signal5 is end entity; architecture test of signal5 is signal x, y : integer; begin update_y: y <= x + 4; stim: process is begin x <= 1; wait for 1 ns; assert y = 5; x <= 10; wait on y; assert y = 14; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal6.vhd000066400000000000000000000004741504111170000172430ustar00rootroot00000000000000entity signal6 is end entity; architecture test of signal6 is signal x : integer := 0; begin process is begin x <= 1, 2 after 3 ns, 4 after 5 ns, 8 after 9 ns; wait; end process; process (x) is begin report integer'image(x); end process; end architecture; nvc-r1.17.1/test/regress/signal7.vhd000066400000000000000000000005671504111170000172470ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity signal7 is end entity; architecture test of signal7 is signal x, y : unsigned(7 downto 0); begin process is begin x <= to_unsigned(5, 8); wait for 1 ns; y <= x + 1; wait for 1 ns; assert y = 6; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal8.vhd000066400000000000000000000015521504111170000172430ustar00rootroot00000000000000entity signal8 is end entity; architecture test of signal8 is type int_array is array (integer range <>) of integer; type int_array_Nx4 is array (integer range <>) of int_array(1 to 4); signal a : int_array_Nx4(1 to 4) := ( 1 => ( 1, 2, 3, 4 ), 2 => ( 5, 6, 7, 8 ), 3 => ( 9, 10, 11, 12 ), 4 => ( 13, 14, 15, 16 ) ); begin process is variable b : int_array(1 to 4); begin a(1)(2) <= 99; wait for 1 ns; b := a(1); --for i in b'range loop -- report "b(" & integer'image(i) & ") = " & integer'image(b(i)); --end loop; assert b = ( 1, 99, 3, 4 ); assert a(1)(2) = 99; a(1) <= ( 21, 22, 23, 24 ); wait for 1 ns; assert a(1)(1) = 21; assert a(1)(3) = 23; wait; end process; end architecture; nvc-r1.17.1/test/regress/signal9.vhd000066400000000000000000000011151504111170000172370ustar00rootroot00000000000000entity signal9 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of signal9 is signal vec : std_logic_vector(7 downto 0); begin assign_p: vec <= X"52"; count_p: process is variable ctr : unsigned(7 downto 0) := X"00"; begin wait for 1 ns; loop ctr := ctr + 1; exit when vec = std_logic_vector(ctr); end loop; loop ctr := ctr + 1; exit when unsigned(vec) = ctr; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/signed1.v000066400000000000000000000004221504111170000167070ustar00rootroot00000000000000module sub1(o); output o; parameter X = -5; if (X > 0) assign o = 1; else if (X < 0) assign o = 0; endmodule // sub1 module sub2(o); output o; parameter X = -5; if (X >= 0) assign o = 1; else if (X <= -5) assign o = 0; endmodule // sub2 nvc-r1.17.1/test/regress/signed1.vhd000066400000000000000000000017241504111170000172310ustar00rootroot00000000000000entity signed1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of signed1 is component sub1 is generic ( X : integer ); port ( o : out std_logic ); end component; component sub2 is generic ( X : integer ); port ( o : out std_logic ); end component; signal o1, o2, o3, o4, o5 : std_logic; begin u1: component sub1 generic map ( -5 ) port map ( o1 ); u2: component sub1 generic map ( 66 ) port map ( o2 ); u3: component sub1 generic map ( 0 ) port map ( o3 ); u4: component sub2 generic map ( -5 ) port map ( o4 ); u5: component sub2 generic map ( 0 ) port map ( o5 ); process is begin wait for 1 ns; assert o1 = '0'; assert o2 = '1'; assert o3 = 'U'; assert o4 = '0'; assert o5 = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/slice1.vhd000066400000000000000000000014521504111170000170550ustar00rootroot00000000000000entity slice1 is end entity; architecture test of slice1 is type int_vector is array (integer range <>) of integer; signal x : int_vector(0 to 3); begin process is variable u : int_vector(5 downto 2); variable v : int_vector(0 to 3); begin v := ( 1, 2, 3, 4 ); v(1 to 2) := ( 6, 7 ); assert v = ( 1, 6, 7, 4 ); assert v(2 to 3) = ( 7, 4 ); x <= ( 1, 2, 3, 4 ); wait for 1 ns; x(1 to 2) <= ( 6, 7 ); wait for 1 ns; assert x = ( 1, 6, 7, 4 ); assert x(2 to 3) = ( 7, 4 ); u := ( 1, 2, 3, 4); assert u = ( 1, 2, 3, 4); u(4 downto 3) := ( 6, 7 ); assert u = ( 1, 6, 7, 4 ); assert u(3 downto 2) = ( 7, 4 ); wait; end process; end architecture; nvc-r1.17.1/test/regress/slice2.vhd000066400000000000000000000015261504111170000170600ustar00rootroot00000000000000entity slice2 is end entity; architecture test of slice2 is procedure set_it(signal v : out bit_vector(7 downto 0); x, y : in integer; k : in bit_vector) is begin v(x downto y) <= k; end procedure; procedure set_it2(signal v : out bit_vector; x, y : in integer; k : in bit_vector) is begin v(x downto y) <= k; end procedure; signal vec : bit_vector(7 downto 0); begin process is begin set_it(vec, 3, 0, X"a"); wait for 1 ns; assert vec = X"0a"; set_it(vec, 4, 1, X"f"); wait for 1 ns; assert vec = X"1e"; set_it2(vec, 7, 4, X"f"); wait for 1 ns; assert vec = X"fe"; wait; end process; end architecture; nvc-r1.17.1/test/regress/slice3.vhd000066400000000000000000000011151504111170000170530ustar00rootroot00000000000000entity slice3 is end entity; architecture test of slice3 is type bvv is array (integer range <>) of bit_vector(7 downto 0); signal x : bvv(1 downto 0); signal y : bit_vector(3 downto 0); begin process (y) is begin for i in x'range loop x(i)(3 downto 0) <= y; x(i)(7 downto 4) <= X"0"; end loop; end process; process is begin wait for 1 ns; assert x = ( X"00", X"00" ); y <= X"f"; wait for 1 ns; assert x = ( X"0f", X"0f" ); wait; end process; end architecture; nvc-r1.17.1/test/regress/slice4.vhd000066400000000000000000000011561504111170000170610ustar00rootroot00000000000000entity slice4 is end entity; architecture test of slice4 is procedure proc1(x : in string) is begin report x; report integer'image(x'left); report integer'image(x'right); report boolean'image(x'ascending); assert x'left = 1; assert x'right = 5; assert x'ascending; assert x = "hello"; end procedure; procedure proc2(x : in string) is begin proc1(x(x'range)); end procedure; begin process is variable s : string(1 to 5) := "hello"; begin proc2(s); wait; end process; end architecture; nvc-r1.17.1/test/regress/slice5.vhd000066400000000000000000000011061504111170000170550ustar00rootroot00000000000000entity slice5 is end entity; architecture test of slice5 is type int_vec is array (natural range <>) of integer; begin p1: process is variable v : int_vec(1 to 8) := (1, 2, 3, 4, 5, 6, 7, 8); begin v(1 to 2) := v(2 to 3); assert v(1 to 2) = (2, 3); v(4 to 5) := v(3 to 4); assert v(4 to 5) = (3, 4); wait for 1 ns; v(1 to 7) := v(2 to 8); assert v = (3, 3, 3, 4, 6, 7, 8, 8); v(2 to 8) := v(1 to 7); assert v = (3, 3, 3, 3, 4, 6, 7, 8); wait; end process; end architecture; nvc-r1.17.1/test/regress/stack1.vhd000066400000000000000000000006601504111170000170630ustar00rootroot00000000000000entity stack1 is end entity; architecture arch of stack1 is signal clk : bit; begin process variable cnt : natural; begin if(clk='0') then clk <= '1'; else clk <= '0'; end if; if now < 50 ns then wait for 2 ns; end if; cnt := cnt + 1; if cnt = 1000000 then wait; end if; end process; end arch; nvc-r1.17.1/test/regress/stdenv1.vhd000066400000000000000000000024221504111170000172570ustar00rootroot00000000000000entity stdenv1 is end entity; use std.env.all; use std.textio.all; architecture test of stdenv1 is begin p1: process is -- GETENV variable l : line; begin report getenv("PATH"); report getenv("HOME"); assert getenv("FOO") = "123"; l := getenv("FOO"); assert l.all = "123"; assert getenv("TOOL_TYPE") = TOOL_TYPE; assert getenv("VHDL_VERSION") = VHDL_VERSION; assert getenv("NOT_HERE") = ""; l := getenv("NOT_HERE"); assert l = null; wait; end process; p2: process is -- VHDL_VERSION, etc. begin assert vhdl_version = "2019"; assert tool_type = "SIMULATION"; report tool_version; wait; end process; p3: process is -- EPOCH, time functions variable tr : time_record; begin report "time: " & to_string(epoch); assert epoch > 1660068924.0; -- 9th August 2022 assert epoch < 4294967396.0; -- 19th January 2038 tr := localtime; report to_string(tr); assert tr.year >= 2022; tr := gmtime; report to_string(tr, 3); assert tr.year >= 2022; wait; end process; end architecture; nvc-r1.17.1/test/regress/stdenv2.vhd000066400000000000000000000022241504111170000172600ustar00rootroot00000000000000entity stdenv2 is end entity; use std.env.all; use std.textio.all; architecture test of stdenv2 is begin p1: process is variable open_status : dir_open_status; variable create_status : dir_create_status; file f : text; begin report dir_workingdir; assert not dir_itemisdir("tmp") report "remove tmp directory first" severity failure; dir_createdir("tmp", false, create_status); assert create_status = STATUS_OK; assert dir_createdir("tmp") = STATUS_ITEM_EXISTS; assert dir_workingdir("tmp") = STATUS_OK; report dir_workingdir; dir_workingdir("/not/here", open_status); assert open_status = STATUS_NOT_FOUND; assert dir_itemexists("."); assert not dir_itemexists("file"); file_open(f, "file", write_mode); file_close(f); assert dir_itemexists("file"); assert dir_itemisfile("file"); assert not dir_itemisfile("not.here"); assert not dir_itemisfile("."); assert not dir_itemisdir("file"); assert dir_itemisdir(".."); wait; end process; end architecture; nvc-r1.17.1/test/regress/stdenv3.vhd000066400000000000000000000022361504111170000172640ustar00rootroot00000000000000entity stdenv3 is end entity; use std.env.all; architecture test of stdenv3 is procedure proc1 is variable stack : call_path_vector_ptr; begin stack := get_call_path; assert stack'length = 4; report to_string(stack); end procedure; procedure proc2 is begin proc1; end procedure; procedure proc3 is begin proc2; assert file_name = "stdenv3.vhd" report file_name; report file_path; assert file_line = 27; assert file_line = "28"; end procedure; begin p1: process is variable stack : call_path_vector_ptr; function ends_with(x, y : string) return boolean is begin return x'length >= y'length and x(x'right - y'length + 1 to x'right) = y; end function; begin stack := get_call_path; assert stack'length = 1; assert stack(0).name.all = "P1"; assert stack(0).file_name.all = "stdenv3.vhd"; assert stack(0).file_line = 41; proc3; report file_path; assert not ends_with(file_path, "stdenv3.vhd"); wait; end process; end architecture; nvc-r1.17.1/test/regress/stdenv4.vhd000066400000000000000000000013031504111170000172570ustar00rootroot00000000000000entity stdenv4 is end entity; use std.env.all; architecture test of stdenv4 is procedure check_real (have, expect : real; tolerance : real := 0.00001) is begin assert have > expect - tolerance; assert have < expect + tolerance; end procedure; begin p1: process is variable r : real := 1.0; begin check_real(time_to_seconds(now), 0.0); check_real(time_to_seconds(now + 1 ms), 0.001); check_real(time_to_seconds(now + 1 hr), 3600.0); check_real(time_to_seconds(now + 2.5 hr), 9000.0); assert seconds_to_time(r) = 1 sec; assert seconds_to_time(r / 2.0) = 500 ms; wait; end process; end architecture; nvc-r1.17.1/test/regress/stdenv5.vhd000066400000000000000000000025561504111170000172730ustar00rootroot00000000000000entity stdenv5 is end entity; use std.env.all; architecture test of stdenv5 is begin p1: process is variable t1, t2, t3 : time_record; begin t1 := gmtime; report "GMTIME: " & to_string(t1); t2 := localtime(t1); report "LOCALTIME: " & to_string(t2); assert t1.microsecond = t2.microsecond; assert t1.second = t2.second; assert abs (t1.year - t2.year) <= 1; assert abs (t1.hour - t2.hour) <= 24; assert abs (t1.day - t2.day) <= 1; assert abs (t1.month - t2.month) <= 1; report "Recovered GMTIME: " & to_string(gmtime(t2)); assert gmtime(t2) = t1; assert epoch(t1) > 0.0; assert abs(epoch(t2) - epoch(t1)) < real(24 * 3600.0); t3 := t1 + 1.0; report to_string(t1) & " + 1.0 ==> " & to_string(t3); assert t3.second = (t1.second + 1) mod 60; t3 := t1 + 0.999999999; report to_string(t1) & " + 0.99999999 ==> " & to_string(t3); assert t3.second = (t1.second + 1) mod 60; t3 := t1 - 3.0; report to_string(t1) & " - 3.0 ==> " & to_string(t3); assert t3.second = (t1.second - 3) mod 60; t3 := t1 - 0.999999999; report to_string(t1) & " - 0.99999999 ==> " & to_string(t3); assert t3.second = (t1.second - 1) mod 60; wait; end process; end architecture; nvc-r1.17.1/test/regress/stdenv6.vhd000066400000000000000000000031731504111170000172700ustar00rootroot00000000000000entity stdenv6 is end entity; use std.env.all; use std.textio.all; architecture test of stdenv6 is begin p1: process is file f : text; variable status : file_delete_status; variable dir : directory; variable found : boolean; begin file_open(f, "tmp.txt", write_mode); file_close(f); assert dir_itemexists("tmp.txt"); assert dir_open(dir, ".") = STATUS_OK; for i in dir.items'range loop report dir.items(i).all; if dir.items(i).all = "tmp.txt" then assert not found; found := true; end if; end loop; assert found report "missing tmp.txt"; report dir.name.all; dir_close(dir); dir_deletefile("tmp.txt", status); assert status = STATUS_OK; assert not dir_itemexists("tmp.txt"); assert dir_deletefile("tmp.txt") = STATUS_NO_FILE; assert dir_createdir("testdir") = STATUS_OK; assert dir_itemisdir("testdir"); assert dir_deletedir("testdir") = STATUS_OK; assert dir_deletedir("nothere") = STATUS_NO_DIRECTORY; assert dir_createdir("testdir") = STATUS_OK; file_open(f, "testdir/tmp.txt", write_mode); file_close(f); assert dir_createdir("testdir/sub") = STATUS_OK; file_open(f, "testdir/sub/sub.txt", write_mode); file_close(f); assert dir_deletedir("testdir") = STATUS_NOT_EMPTY; assert dir_deletedir("testdir", recursive => true) = STATUS_OK; assert not dir_itemexists("testdir"); wait; end process; end architecture; nvc-r1.17.1/test/regress/stop1.vhd000066400000000000000000000003661504111170000167460ustar00rootroot00000000000000entity stop1 is end entity; library std; use std.env.all; architecture test of stop1 is begin process is begin stop(0); report "should not print this" severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/synopsys1.vhd000066400000000000000000000010461504111170000176640ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; entity synopsys1 is end entity; architecture test of synopsys1 is begin process is variable x, y, z : std_logic_vector(7 downto 0); begin x := conv_std_logic_vector(5, 8); y := conv_std_logic_vector(3, 8); z := x + y; assert conv_integer(z) = 8; z := x - y; assert conv_integer(z) = 2; assert conv_integer(x * y) = 15; wait; end process; end architecture; nvc-r1.17.1/test/regress/synopsys2.vhd000066400000000000000000000104401504111170000176630ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; entity synopsys2 is end entity; architecture test of synopsys2 is begin test_unsigned_plus: process is variable x, y : unsigned(15 downto 0); variable a, b : unsigned(0 to 15); begin x := X"0005"; y := X"0001"; assert x + y = 6; x := X"6005"; y := X"0001"; assert x + y(1 downto 0) = 24582; assert x(3 downto 0) + y(1 downto 0) = 6; assert x(5 downto 0) + y = 6; x := X"U000"; assert x + y = std_logic_vector'(X"XXXX"); x := X"ffff"; y := X"0002"; assert x + y = 1; a := X"001f"; b := X"0010"; assert a + b = 47; assert a + y = 33; assert a + '0' = a; assert '1' + a = 32; wait; end process; test_unsigned_minus: process is variable x, y : unsigned(15 downto 0); variable a, b : unsigned(0 to 15); begin x := X"0005"; y := X"0001"; assert x - y = 4; x := X"6005"; y := X"0001"; assert x - y(1 downto 0) = 24580; assert x(3 downto 0) - y(1 downto 0) = 4; assert x(5 downto 0) - y = 4; x := X"U000"; assert x - y = std_logic_vector'(X"XXXX"); x := X"0000"; y := X"0002"; assert x - y = 65534; a := X"001f"; b := X"0010"; assert a - b = 15; assert b - y = 14; wait; end process; test_unsigned_mul: process is variable x, y : unsigned(15 downto 0); variable a, b : unsigned(0 to 15); begin x := X"0005"; y := X"0002"; assert x * y = 10; x := 16d"0122"; y := 16d"0005"; assert x * y = 610; y := 16d"2512"; assert x * y = std_logic_vector'(X"0004ad20"); a := X"001f"; b := X"0010"; assert a * b = std_logic_vector'(X"000001f0"); assert x * a(8 to 15) = std_logic_vector'(X"000ec6"); wait; end process; test_signed_mul: process is variable x, y : signed(15 downto 0); variable a, b : signed(0 to 15); begin x := X"0005"; y := X"0002"; assert x * y = 10; x := 16d"0122"; y := 16d"0005"; assert x * y = 610; y := 16d"2512"; assert x * y = std_logic_vector'(X"0004ad20"); a := X"001f"; b := X"0010"; assert a * b = std_logic_vector'(X"000001f0"); assert x * a(8 to 15) = std_logic_vector'(X"000ec6"); x := X"0005"; y := X"ffff"; assert x * y = -5; wait; end process; test_signed_plus: process is variable x, y : signed(15 downto 0); variable a, b : signed(0 to 15); begin x := X"0005"; y := X"0001"; assert x + y = 6; x := X"6005"; y := X"0001"; assert x + y(1 downto 0) = 24582; assert x(3 downto 0) + y(1 downto 0) = 6; assert x(5 downto 0) + y = 6; x := X"U000"; assert x + y = std_logic_vector'(X"XXXX"); x := X"ffff"; y := X"0002"; assert x + y = 1; a := X"001f"; b := X"0010"; assert a + b = 47; assert a + y = 33; assert a + '0' = a; assert '1' + a = 32; wait; end process; test_unsigned_eql: process is variable x, y : unsigned(15 downto 0); variable a, b : unsigned(0 to 15); begin x := X"0005"; y := X"0002"; assert not (x = y); y := X"f005"; assert not (x = y); assert x = y(7 downto 0); a := X"0005"; b := X"0002"; assert not (a = b); b := X"f005"; assert not (a = b); assert a = b(8 to 15); wait; end process; test_signed_eql: process is variable x, y : signed(15 downto 0); variable a, b : signed(0 to 15); begin x := X"0005"; y := X"0002"; assert not (x = y); y := X"f005"; assert not (x = y); assert x = y(7 downto 0); a := X"fff5"; b := X"fff2"; assert not (a = b); b := X"0ff5"; assert not (a = b); assert a = b(8 to 15); wait; end process; end architecture; nvc-r1.17.1/test/regress/synopsys3.vhd000066400000000000000000000007341504111170000176710ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; entity synopsys3 is end entity; architecture test of synopsys3 is begin test_unsigned_plus: process is variable x, y : unsigned(15 downto 0); begin x := X"ffff"; y := X"0002"; assert x + y = 1; -- This should fall back to the interpreter assert x(0 downto 1) + y(0 downto 1) = unsigned'(""); wait; end process; end architecture; nvc-r1.17.1/test/regress/tcl1.tcl000066400000000000000000000007131504111170000165400ustar00rootroot00000000000000proc assert condition { if {![uplevel 1 $condition]} { return -code error "assertion failed: $condition" } } set testdir [file dirname [file normalize [info script]]] puts "$now +$deltas" assert {expr $now == 0} assert {expr $deltas == 0} run puts "$now +$deltas" assert {expr $now == 1000000} assert {expr $deltas == 1} set sigs [find signals /*] puts $sigs assert {expr [llength $sigs] == 1} assert {string equal [lindex $sigs 0] "/x"} nvc-r1.17.1/test/regress/tcl1.vhd000066400000000000000000000003661504111170000165430ustar00rootroot00000000000000entity tcl1 is end entity; architecture test of tcl1 is signal x : integer := 5; begin process is begin x <= 6; wait for 1 ns; x <= 7; wait for 0 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/tcl2.tcl000066400000000000000000000006411504111170000165410ustar00rootroot00000000000000proc assert condition { if {![uplevel 1 $condition]} { return -code error "assertion failed: $condition" } } set testdir [file dirname [file normalize [info script]]] set sigs [find signals /*] puts $sigs assert {expr [exa /x] == -2147483648} run assert {expr [exa /x] == 2} restart puts [exa /x] assert {expr [exa /x] == -2147483648} assert {expr $now == 0} run assert {expr [exa /x] == 2} nvc-r1.17.1/test/regress/tcl2.vhd000066400000000000000000000012071504111170000165370ustar00rootroot00000000000000entity tcl2_bot is port ( i : in integer; o : out integer ); end entity; architecture test of tcl2_bot is begin process (i) is begin o <= i + 1; end process; end architecture; ------------------------------------------------------------------------------- entity tcl2 is end entity; architecture test of tcl2 is signal x, y : integer; begin uut: entity work.tcl2_bot port map ( x, y ); process is begin x <= 0; wait for 1 ns; assert y = 1; x <= 2; wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/tcl3.tcl000066400000000000000000000001121504111170000165330ustar00rootroot00000000000000proc proc2 args { error "boo" } proc proc1 args { proc2 } proc1 nvc-r1.17.1/test/regress/testlist.txt000066400000000000000000000723601504111170000176140ustar00rootroot00000000000000wait1 normal assert1 gold,fail assign1 normal wait2 gold,normal arith1 normal signal1 normal attr1 normal signal2 normal signal3 normal assign2 normal assign3 normal signal4 normal wait3 normal wait4 normal wait5 normal elab1 normal image1 gold,normal cond1 gold,normal counter normal,stop=50ns,gold cond2 gold,normal vecorder1 normal elab2 normal func1 normal signal5 normal while1 gold,normal signal6 gold,normal slice1 normal logical1 normal lfsr normal,stop=510ns link1 normal for1 gold,normal operator1 normal fact gold,fail func2 normal alias1 gold,normal alias2 gold,normal func3 normal func4 normal operator2 normal array1 normal agg1 normal agg2 normal case1 normal func5 normal ieee1 normal ieee2 normal,stop=15ns cond3 normal concat1 normal concat2 normal null1 normal agg3 normal proc1 normal alias3 normal proc2 normal operator3 normal agg4 normal ieee3 normal default1 normal generic1 normal signal7 normal synopsys1 normal block1 normal elab3 normal,gold func6 normal case2 normal case3 normal wait6 normal,gold elab4 normal elab5 normal signal8 normal ram1 normal wait7 normal const1 normal driver1 normal driver2 normal delay1 normal record1 normal proc3 normal access1 normal,gold proc4 normal file1 normal real1 normal,gold shared1 normal proc5 normal proc6 normal assert2 normal,gold concat3 normal const2 normal func7 normal func8 normal ieee4 normal bounds1 gold,fail bounds2 gold,fail bounds3 gold,fail bounds4 gold,fail signal9 normal bounds5 gold,fail loop1 normal record2 normal access2 normal func9 normal record3 normal issue8 normal issue9 normal record4 normal record5 normal const3 normal,gold proc7 normal,gold attr2 normal func10 normal attr3 normal,gold proc8 normal,gold wait8 normal func11 normal const4 normal shift1 normal wait9 normal wait10 normal attr4 normal bounds6 gold,fail elab6 normal elab7 normal bounds7 gold,fail arith2 gold,fail attr5 normal attr6 normal elab8 normal arith3 normal bounds8 gold,fail bounds9 gold,fail bounds10 gold,fail access3 normal access4 normal textio1 normal,gold proc9 normal elab9 normal,gold elab10 normal,gold conv1 normal elab11 normal link2 normal driver3 normal elab12 normal issue10 normal elab13 normal,gold delay2 normal issue13 normal attr7 normal shift2 normal case4 normal signal10 normal signal11 normal,gold wait11 normal bounds11 gold,fail wait12 normal,gold array2 normal driver4 normal comp1 normal bitvec normal elab14 normal operator4 normal issue16 normal elab15 normal const5 normal issue18 normal elab16 normal signal12 normal const6 normal func12 normal agg5 normal elab17 normal null2 normal func13 normal proc10 normal array3 normal slice2 normal attr8 normal value1 normal bounds12 gold,fail bounds13 gold,fail access5 normal record6 normal agg6 normal func14 normal operator5 normal alias4 normal alias5 normal,gold alias6 normal alias7 normal const7 normal bounds15 gold,fail bounds16 gold,fail bounds17 gold,fail signal13 normal elab18 normal wait13 normal shared2 normal func15 normal elab19 normal concat4 normal issue29 normal assert3 normal,gold alias8 normal textio2 normal elab20 normal issue38 normal stop1 normal,gold,2008 record7 normal record8 normal elab21 normal record9 normal record10 normal real2 normal issue45 normal,gold for2 normal,gold issue57 normal attr10 normal assert4 normal issue56 normal issue53 normal issue59 normal issue60 normal record11 normal issue63 normal driver5 normal textio3 normal record12 normal attr11 normal implicit1 normal implicit2 normal file2 normal case5 gold,fail toplevel1 normal vhpi1 gold,vhpi,+foo=bar vhpi2 normal,vhpi issue69 normal issue70 normal elab22 normal array4 normal issue72 normal protected1 normal,2000 protected2 normal,2000 slice3 normal alias9 normal issue79 normal issue84 normal,2000 issue82 normal,O2 issue86 normal issue94 normal access6 gold,fail issue90 normal issue104 normal proc11 normal elab23 normal issue91 normal,2000 issue109 normal issue110 normal,gold concat5 normal issue111 normal issue115 normal issue116 normal issue112 normal cover1 cover=statement,gold issue121 normal issue122 normal issue95 normal func16 normal issue123 normal issue126 normal range1 normal,gold slice4 normal issue103 normal,gold access7 normal implicit3 normal protected3 normal,2000 issue146 normal issue148 normal issue152 normal issue83 normal,2008 issue153 normal issue143 normal,2000 issue141 normal,2000 issue163 normal issue169 normal case6 normal issue183 normal issue185 normal,gold toplevel2 normal,gI=2,gS=2 issue186 normal issue194 normal issue196 normal issue201 normal,2000 issue200 normal issue204 normal issue206 normal issue187 normal func17 normal elab24 normal elab25 normal logical2 normal attr12 normal,gold issue229 normal issue217 normal issue234 normal,gold issue227 normal,gold real3 normal,gold for3 normal,gold issue197 normal issue225 normal,gold issue262 normal issue284 normal jcore1 normal jcore2 normal assert5 normal jcore3 normal jcore4 normal jcore5 normal vhpi3 normal,vhpi jcore6 normal issue106 normal,2008 case7 normal,2008 ieee5 normal issue309 normal issue308 normal,gold issue315 normal issue323 normal,2000 protected4 normal,2000 textio4 normal issue327 normal issue335 normal file3 normal issue338 normal issue338b normal textio5 normal,2008,gold issue349 normal signal14 normal issue352 normal issue354 normal issue351 normal,gold issue367 normal issue369 normal issue293 normal issue340 normal issue348 normal,2008 issue202 normal issue371 normal record13 normal issue370 normal issue376 normal stack1 normal issue377 gold,normal,relax=prefer-explicit issue397 normal issue96 gold,normal wait14 normal block2 normal issue407 normal issue412 normal issue414 normal,slow issue415 normal predef1 normal,2008 signal15 normal,2008 logical3 normal,2008 debug1 normal,gold,O0 assign4 normal vests1 normal wait15 normal grlib1 normal issue420 normal debug2 normal,gold,O0 alias10 normal record14 normal alias11 normal bounds18 fail,gold bounds19 fail,gold ieee6 normal attr13 normal,work=lib record15 normal record16 normal signal16 normal record17 normal issue405 normal issue423 normal driver6 normal driver7 fail,gold issue428 normal protected5 normal,2000 issue429 normal record18 normal issue98 normal issue430 normal libdir1 shell vests2 normal vests3 normal vests4 normal vests5 normal vests6 normal vests7 normal vests8 normal signal17 normal assign5 normal bounds20 fail,gold vests9 normal vests10 normal vests11 normal vests12 normal vests13 normal elab26 normal conv2 normal conv3 normal conv4 normal conv5 normal bounds22 fail,gold bounds23 fail,gold vests14 normal conv6 normal driver8 normal vests15 normal elab27 normal conf1 normal,gold conf2 normal,gold vests16 normal file4 normal vests17 normal vests18 normal vests19 normal protected6 normal,2000,slow vests20 normal vests21 normal guard1 normal guard2 normal vests22 normal vests23 normal func18 normal file5 normal case8 normal textio6 normal,2008 predef2 normal,2008 file6 normal,2008,!windows elab28 normal vests24 normal record19 normal conf3 normal vests25 normal vests26 normal vests27 normal order1 normal textio7 normal vests28 normal vests29 normal vests30 normal vests31 normal vests32 normal vests33 normal buffer1 normal file7 normal vests34 normal vests35 normal issue432 normal vests36 normal issue433 normal,gold vests37 normal vests38 normal debug3 fail,2000,gold,O0 file8 fail,gold concat6 normal issue434 normal bounds24 fail,gold bounds25 fail,gold bounds26 fail,gold bounds27 fail,gold bounds28 fail,gold assert6 normal,gold assign6 normal bitstr1 normal,2008 elab29 normal,2008 signal18 normal,2008 genpack1 normal,2008 ieee7 normal,2008 wave1 wave wave2 shell wave3 wave,gtkw,stop-time=1us wave4 wave,dump-arrays wave5 wave,gtkw record20 normal attr14 normal vhpi4 normal,vhpi,!windows wait16 normal default2 normal vests39 normal libdir2 shell bounds29 fail,gold gentype1 normal,2008 gentype2 normal,2008 gentype3 normal,2008 gentype4 normal,2008 genpack2 normal,2008 genpack3 normal,2008 genpack4 normal,2008 genpack5 normal,2008 genpack6 normal,2008 genpack7 normal,2008 ieee8 normal,2008 array5 normal vests40 normal issue447 normal bounds30 fail,gold wait17 normal wait18 normal wait19 normal record21 normal record22 normal case9 normal vests41 normal conv7 normal conv8 normal driver9 fail,gold record23 normal vests42 normal wait20 normal signal19 normal record24 normal record25 normal record26 normal bounds31 fail,gold record27 normal record28 normal vests43 normal record29 normal,2008 record30 normal,2008 bounds32 fail,gold,2008 bounds33 fail,gold,2008 for4 normal alias12 fail,gold alias13 normal,2008 issue454 shell agg7 normal,2008 bounds34 fail,gold,2008 assign7 normal,2008 signal20 normal,2008 bounds35 fail,gold,2008 bounds36 fail,gold,2008 bounds37 fail,gold,2008 case10 normal record31 normal,2008 genpack8 normal,2008 wave6 wave,2008 issue101 fail,gold vests44 normal force1 normal,2008 ename1 normal,2008 ename2 fail,gold,2008 wait21 normal,2008 driver10 normal case11 normal,2008 driver11 normal signal21 normal,2008 vests45 normal elab30 normal,2008 shared3 normal assign8 normal,2008 func19 fail,gold issue460 normal,2008 case13 fail,gold,2008 access8 fail,gold access9 normal access10 fail,gold,H=1m record32 normal,2008 alias14 normal,2008 link3 shell proc12 normal,2008 bounds38 fail,gold attr15 normal,2008 attr16 normal,2008 cmdline1 shell cmdline2 shell order2 shell array6 normal,2008 array7 normal,2008 protected7 normal,2000 shared4 normal,2008,relax=shared elab31 normal,2000 access11 normal issue467 normal,2008 issue469 normal,relaxed,gold ieee9 normal,gold,2008 issue472 shell textio8 normal gensub1 normal,2008 gensub2 normal,2008 gensub3 normal,2008 gensub4 normal,2008 elab32 normal gensub5 normal,2008 vhpi5 gold,vhpi,2008 gensub6 normal,2008 concat7 normal,2008 func20 normal array8 normal,2008 array9 normal,2008 signal22 normal genpack9 normal,2008 file9 normal array10 normal wait22 normal,2008 array11 normal,2008 array12 normal,2008 array13 normal,relaxed const8 normal,2008 wait23 normal genpack10 normal,2008 attr17 normal,2002,gold signal23 normal,gold,2008 driver12 normal record33 normal,2008 const9 normal driver13 normal,2008 record34 normal,2008 elab33 normal,2008 agg8 normal,2008 record35 normal,2008 array14 normal,2008 array15 fail,gold,2008 signal24 normal,2008 issue481 normal,2008 issue484 normal ename3 normal,2008 issue483 normal,relaxed cmdline3 shell issue493 shell issue494 fail,gold record36 normal,2008 issue497 normal,2008 implicit4 normal genpack11 normal,2008 signal25 normal,2008 wait24 normal agg9 normal agg10 normal,2008 signal26 normal,2008 file10 normal stdenv1 normal,2019,$FOO=123 issue502 normal elab34 normal,2008 issue507 shell issue508 normal,2008 record37 normal func21 normal issue521 fail,gold issue552 normal,2008 stdenv2 normal,2019 driver14 normal issue516 normal libdir3 shell elab35 normal issue524 shell issue527 normal,stop=1us ieee10 normal,slow driver15 normal,gold issue520 normal,2008 wave7 shell vests46 normal vests47 normal vests48 normal signal27 normal issue519 normal,2008 delay3 fail,gold issue536 wave,dump-arrays wait25 normal issue539 normal,2008 issue542 normal issue540 normal,2008 guard3 normal issue543 normal,2008 issue547 normal protected8 normal,2002 issue551 normal issue544 normal,2008 issue550 normal,2008,relaxed ename4 normal,2008 genpack12 normal,2008 wave8 wave signal28 normal,relaxed issue549 normal case14 normal,2008 cmdline4 shell issue560 normal,2008 issue570 normal,2008 issue571 normal,2008,relaxed operator6 normal,2008 vecorder2 normal,2008 cover2 cover=toggle+include-mems cover3 cover=branch cover4 cover=branch cover5 cover,shell cover6 cover,shell issue577 normal,2008 cover7 cover=expression cover8 cover=expression issue586 shell case15 normal,2008 driver16 normal issue589 normal,2000 issue590 normal issue595 normal,2008 cover9 cover,shell issue592 fail,gold cover10 cover,shell cmdline5 shell cmdline6 shell issue597 normal,gold stdenv3 normal,2019 issue603 normal cover11 cover,shell issue609 normal implicit5 normal cover12 cover,shell issue612 normal,vhpi force2 normal,2008 issue618 normal,gA='1',gB='0' issue613 normal,2008 issue615 normal,gold,2008 arith4 fail,gold libdir4 shell const10 normal null3 normal link4 normal predef3 normal wait26 fail,gold signal29 fail,gold file11 normal,2008 issue617 fail,gold bounds39 fail,gold issue610 normal,2008 issue640 normal vests49 normal signal30 normal psl1 fail,psl,gold elab36 normal cover13 cover,shell gentype5 normal,2008 issue620 normal,2008 issue643 normal,2008 file12 normal,2019 driver17 normal cond4 normal,2019,define=USER_DIRECTIVE=VALID_VALUE issue646 normal,relaxed array16 normal,2008 stdenv4 normal,2019 issue655 normal,2008 genpack13 normal,2008 genpack14 normal,2008 slice5 normal access12 normal arith5 fail,gold real4 fail,gold cover14 cover,shell issue616 fail,gold,2008 record38 normal,2008 tcl1 normal,tcl issue668 normal,gold issue670 normal,2008 elab37 normal elab38 normal vital1 normal issue674 normal,2008 integer1 normal integer2 normal,2019 issue675 normal,2000 issue676 normal,2008 issue677 normal issue681 normal,2008 issue658 normal,2008 vlog1 mixed vlog2 verilog,gold issue690 normal issue644 normal,2008 cond5 normal,2019 cond6 normal,2019 cover15 cover,2019 func22 normal,2019 func23 normal,2019 protected9 normal,2019 func24 normal,2019 vhpi6 normal,vhpi cover16 cover,2019 view1 normal,2019 issue701 fail,gold,2008 issue700 normal,gold issue703 wave,gtkw view2 normal,2019 view3 normal,2019 view4 normal,2019 view5 normal,2019 issue705 normal,2008 array17 normal,2008 stdenv5 normal,2019 assert7 fail,gold,2008 vhpi7 normal,2008,vhpi vhpi8 normal,2008,vhpi issue704 wave,no-collapse real5 normal,2019 assign9 normal,2008 cmdline7 shell array18 normal,2002 signal31 normal,2008 range2 normal,2008 issue715 shell issue714 normal elab39 shell issue718 normal,gold,2008 issue726 normal,2008 issue724 normal,2019 issue653 normal,2008 protected10 normal,2019 reflect1 normal,2019 signal32 normal,2019 reflect2 normal,2019 issue734 fail,gold,2008 reflect3 normal,2019 issue712 normal,2008 psl2 fail,gold,psl signal33 normal cmdline8 shell tcl2 normal,tcl psl3 fail,gold,2008 issue731 normal,2008 psl4 fail,psl,gold,2008 cover17 cover,export=cobertura toplevel3 normal,guut.i=2,guut.s=2 predef4 normal,2008 protected11 fail,gold,2002 issue744 normal,vhpi reflect4 normal,2019 reflect5 normal,2019 seqblock1 normal,2019 seqblock2 normal,2019 stdenv6 normal,2019 issue747 fail,gold,gL=10 assert8 fail,2019,gold assert9 fail,2019,gold assert10 fail,2019,gold assert11 normal,2019 assert12 normal image2 normal,2019 value2 normal,2019 value3 fail,2019,gold value4 fail,2019,gold open1 normal,2019 issue750 normal,2008 order3 shell driver18 normal,2008 vhpi9 normal,vhpi issue730 normal,2008 driver19 normal,2008 func25 normal conv9 normal,2019 comp2 normal issue751 normal issue732 normal,2008 genpack15 normal,2008 issue548 shell alias15 normal,2002 protected12 normal,2019 ieee11 normal,gold ieee12 normal,slow ieee13 normal,gold ieee14 normal,gold ieee15 fail,gold issue752 shell predef5 normal,2008 vhpi10 normal,vhpi,2008 bounds40 fail,gold bounds41 fail,gold ieee16 normal shuffle1 normal,2002,shuffle vhpi11 normal,vhpi,2008 attr18 normal,2019 issue762 normal,vhpi vlog3 verilog,gold vlog4 verilog,gold issue766 normal,2002 attr19 normal,2008,gold attr20 normal,2019,work=lib protected13 normal,2019 vlog5 verilog,gold issue769 shell bounds42 fail,gold,2008 conv10 fail,gold,2008 psl5 fail,gold,psl psl6 fail,gold,psl cover18 cover,shell cover19 cover,shell gentype6 normal,2008 mixed1 mixed ename5 fail,gold,2008 ename6 normal,2008 cover20 cover,shell issue787 normal view6 normal,2019 issue790 normal issue791 normal,2008 issue794 normal,2008 psl7 normal,gold,psl cover21 shell issue799 normal,2008 issue801 normal,gold,2008 vlog6 verilog,gold issue809 normal,2008 range3 normal,2008 issue810 normal,2008 elab40 normal,2008 cmdline9 shell,slow genpack16 normal,2008 issue815 normal,2019 issue816 fail,gold gentype7 normal,2019 issue819 normal,2008 issue820 normal issue824 normal issue825 normal issue826 normal,2008 issue827 normal,2008 cover22 shell issue831 normal,2008 issue829 normal issue839 normal issue840 wave issue842 normal,2008 conv11 normal conv12 normal issue843 normal,2008 bounds43 fail,gold signal35 normal,2008 comp3 normal conv13 normal wave9 wave wave10 wave driver20 normal driver21 fail,gold ename7 normal,2008 issue844 normal,2008 conv14 normal,2008 issue850 shell vlog7 verilog,gold wait27 normal issue808 verilog,gold issue851 wave,2008 vlog8 verilog issue852 wave,2019,dump-arrays wave11 wave,2008,dump-arrays ivtest1 verilog issue654 normal,2008 issue854 normal,2019 ename8 normal,2008 issue856 normal,2019,wave,dump-arrays driver22 fail,gold,2019 vhpi12 normal,vhpi issue862 normal,gold,2008,relaxed issue858 normal,2008 vhpi13 normal,vhpi issue873 normal array19 normal issue874 normal,2008 vhpi14 normal,vhpi issue877 normal,2008 issue878 wave,2008,dump-arrays ivtest2 verilog,gold ivtest3 verilog vlog9 verilog issue881 normal,2008 issue884 normal,2008 issue885 fail,gold conf4 normal conf5 normal,2008 gentype8 normal,2008 gentype9 normal,2008 genpack17 normal,2008 genpack18 normal,2008 implicit6 normal bounds44 fail,gold,2008 issue887 normal issue890 normal,2008 vhpi15 normal,vhpi attr21 normal,2002 issue894 normal,2008 real6 normal integer3 normal,2008 wait28 fail,gold guard4 normal signal36 normal,2008 issue899 normal,2008 file13 fail,gold file14 fail,gold file15 normal issue903 cover=branch issue904 normal,psl,wave issue906 cover=toggle implicit7 normal issue908 normal,2008 issue909 shell,cover,gold issue901 wave psl8 fail,gold,psl issue921 normal,2008 open2 normal implicit8 normal issue924 normal,2019 issue925 normal,2008 issue923 normal,2019 record39 normal,2008 force3 fail,gold,2008 issue931 normal,2008 implicit9 normal issue932 normal,2019 bounds45 fail,gold,2008 synopsys2 normal,2008,gold synopsys3 fail,gold cover23 shell issue941 cover mixed2 mixed issue943 normal,2008 mixed3 mixed vlog10 verilog vlog11 verilog issue946 normal,2008 issue954 normal,2008 issue950 normal,2008 issue957 wave,2008,dump-arrays signal37 normal issue960 normal issue962 wave,dump-arrays issue963 normal ename9 fail,gold,2008 ename10 fail,gold,2008 ename11 fail,gold,2008 ename12 fail,gold,2008 ename13 fail,gold,2008 ename14 fail,gold,2008 issue907 fail,gold,2008 ename15 normal,2008 wave12 wave,dump-arrays=3 issue968 normal issue971 normal,2008 ieee17 normal issue978 normal,vhpi issue985 wave,2008,dump-arrays issue970 normal,gold,2019 issue983 normal,relaxed issue972 wave,2008,dump-arrays issue979 wave,2008 cmdline11 shell psl9 fail,gold,2008 psl10 fail,gold,2008 issue988 normal,vhpi psl11 fail,gold,2008 cover24 shell vlog12 verilog conv15 normal cover25 cover=functional issue1035 normal,vhpi,2008 issue1043 normal psl12 normal,2008 psl13 fail,gold,psl issue1045 normal,vhpi issue1044 mixed issue1030 wave,2008,dump-arrays issue1036 normal issue1057 normal,vhpi,2008 issue1062 normal,2008 cmdline12 shell psl14 gold,psl issue1074 normal,2019 psl15 gold,psl psl16 gold,psl issue1071 wave,2008,dump-arrays issue1079 normal,gold ivtest4 verilog psl17 gold,psl ename16 fail,gold,2008 vlog13 verilog issue1094 normal,2008 issue1060 fail,gold,vhpi ivtest5 verilog guard5 normal driver23 normal,2008 conv16 normal,2008 conv17 normal conv18 normal ename17 fail,gold,2008 cmdline13 shell issue1117 normal,psl,2008 issue1125 normal,2008 issue1137 normal tcl3 tcl,fail,gold psl18 fail,gold,2008 psl19 gold,psl psl20 gold,psl cover26 shell debug4 normal,gold issue1150 normal,psl order4 shell issue1161 normal,vhpi,2008 cmdline14 shell conv19 normal,2008 issue1164 normal cmdline15 shell,tcl issue1171 normal,2008 genpack19 normal,2008 rand1 normal,seed=123 psl21 gold,psl,seed=1 agg11 normal,2008 agg12 normal,2008 agg13 normal,2008 agg14 normal,2008 proc13 fail,gold,2002 assert13 normal issue1185 normal,2008 issue1186 normal,2008 issue1177 normal issue1192 normal,vhpi cover27 shell issue1143 normal,2008 real7 fail,gold,2008 vlog14 verilog issue1208 normal,2019 ieee18 fail,gold,2008 issue1213 normal,vhpi,2008 param1 verilog select1 verilog issue1218 normal cmdline16 shell ivtest6 verilog select2 verilog vlog15 verilog mixed4 mixed vlog16 verilog select3 verilog vlog17 verilog issue1229 normal vlog18 verilog select4 verilog select5 verilog select6 verilog select7 verilog vlog19 verilog issue1231 fail,gold,2008 conv20 normal,2008 issue1233 normal,vhpi vlog20 verilog,gold conv21 normal,2008 signed1 mixed issue1240 normal,vhpi,2008 issue1175 normal,relaxed vhpi16 normal,vhpi nvc-r1.17.1/test/regress/textio1.vhd000066400000000000000000000021261504111170000172710ustar00rootroot00000000000000entity textio1 is end entity; use std.textio.all; architecture test of textio1 is begin process is variable l : line; begin write(l, string'("hello, world")); writeline(output, l); assert l'length = 0; write(l, string'("one")); write(l, ' '); write(l, string'("two")); writeline(output, l); write(l, string'("hello"), left, 10); write(l, '|'); write(l, string'("world"), right, 10); writeline(output, l); write(l, bit'( '0' ), left, 4); write(l, bit_vector'("0110101")); writeline(output, l); write(l, true); writeline(output, l); write(l, 10 ns); writeline(output, l); write(l, 50 ns, field => 20, justified => right, unit => us); writeline(output, l); write(l, 1.234); writeline(output, l); write(l, 1.234, digits => 1); writeline(output, l); write(l, 1.234567, digits => 4); writeline(output, l); deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio2.vhd000066400000000000000000000020701504111170000172700ustar00rootroot00000000000000entity textio2 is end entity; use std.textio.all; architecture test of textio2 is begin process is file tmp : text; variable l : line; variable str : string(1 to 5); variable good : boolean; variable ch : character; begin file_open(tmp, "tmp.txt", WRITE_MODE); write(l, string'("hello, world")); writeline(tmp, l); write(l, string'("second")); writeline(tmp, l); deallocate(l); file_close(tmp); file_open(tmp, "tmp.txt", READ_MODE); readline(tmp, l); read(l, str); assert str = "hello"; read(l, str); assert str = ", wor"; read(l, str, good); assert not good; -- Fewer than 5 chars deallocate(l); readline(tmp, l); read(l, str); assert str = "secon"; read(l, ch); assert ch = 'd'; read(l, ch, good); assert not good; deallocate(l); file_close(tmp); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio3.vhd000066400000000000000000000024541504111170000172770ustar00rootroot00000000000000entity textio3 is end entity; use std.textio.all; architecture test of textio3 is procedure check_content(expect : in string) is file tmp : text is "tmp.txt"; variable l : line; variable str : string(1 to expect'length); variable good : boolean; variable ch : character; begin readline(tmp, l); read(l, str, good); assert good; assert str = expect; deallocate(l); end procedure; begin process is file tmp : text; variable l : line; begin file_open(tmp, "tmp.txt", WRITE_MODE); write(l, string'("hello, world")); writeline(tmp, l); file_close(tmp); check_content("hello, world"); -- Check corner case of reading LINE_BUFFER_SIZE characters (issue #393) file_open(tmp, "tmp.txt", WRITE_MODE); write(l, string'("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")); writeline(tmp, l); file_close(tmp); check_content("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio4.vhd000066400000000000000000000126771504111170000173100ustar00rootroot00000000000000entity textio4 is end entity; use std.textio.all; architecture test of textio4 is begin check_int: process is variable l : line; variable x : integer; variable good : boolean; variable c : character; begin l := new string'(" 123,5"); read(l, x, good); assert good; assert x = 123; assert l.all(l'left) = ','; read(l, x, good); assert not good; assert l.all(l'left) = ','; read(l, c, good); assert good; assert c = ','; assert l.all(l'left) = '5'; read(l, x, good); assert good; assert x = 5; assert l.all'length = 0; deallocate(l); report "Negative integers"; l := new string'(" -123,-5"); read(l, x, good); assert good; assert x = -123; assert l.all(l'left) = ','; read(l, x, good); assert not good; assert l.all(l'left) = ','; read(l, c, good); assert good; assert c = ','; assert l.all(l'left) = '-'; read(l, x, good); assert good; assert x = -5; assert l.all'length = 0; deallocate(l); report "Integers min and max"; l := new string'(integer'image(integer'low) & "," & integer'image(integer'high)); read(l, x, good); assert good; assert x = integer'low; read(l, c, good); assert good; read(l, x, good); assert good; assert x = integer'high; assert l.all'length = 0; deallocate(l); report "Negative integer not good with single minus"; l := new string'("-,100"); read(l, x, good); assert not good; assert l.all(1) = '-'; read(l, c, good); assert good; assert c = '-'; read(l, c, good); assert good; assert c = ','; read(l, x, good); assert good; assert x = 100; assert l.all'length = 0; deallocate(l); report "Negative integer with minus in the middle"; l := new string'("10-10"); read(l, x, good); assert good; assert x = 10; read(l, x, good); assert good; assert x = -10; assert l.all'length = 0; deallocate(l); wait; end process; check_bool: process is variable l : line; variable x : boolean; variable good : boolean; variable c : character; begin l := new string'(" true,false"); read(l, x, good); assert good; assert x = true; assert l.all(l'left) = ','; read(l, x, good); assert not good; assert l.all(l'left) = ','; read(l, c, good); assert good; assert c = ','; assert l.all(l'left) = 'f'; read(l, x, good); assert good; assert x = false; assert l.all'length = 0; deallocate(l); wait; end process; check_real: process is variable l : line; variable x : real; variable good : boolean; variable c : character; begin l := new string'(" 5.152,61.4,5."); read(l, x, good); assert good; assert x > 5.151 and x < 5.153; assert l.all(l'left) = ','; read(l, x, good); assert not good; assert l.all(l'left) = ','; read(l, c, good); assert good; assert c = ','; assert l.all(l'left) = '6'; read(l, x, good); assert good; assert x > 61.39 and x < 61.41; read(l, c, good); assert good; assert c = ','; assert l.all(l'left) = '5'; read(l, x, good); assert not good; deallocate(l); wait; end process; check_bit_vector: process is variable l : line; variable x : bit_vector(1 to 4); variable y : bit_vector(7 downto 0); variable good : boolean; variable c : character; begin l := new string'(" 1010 110 11111"); read(l, x, good); assert good; assert x = "1010"; assert l.all(l'left) = ' '; read(l, x(1 to 3), good); assert good; assert l.all(l'left) = ' '; read(l, x, good); assert good; assert x = "1111"; assert l.all(l'left) = '1'; deallocate(l); l := new string'("1 1 0 0 0 0 1 1"); read(l, y, good); assert good; assert y = "11000011"; deallocate(l); wait; end process; check_bit: process is variable l : line; variable b : bit; variable good : boolean; begin l := new string'(" 1 0x"); read(l, b, good); assert good; assert b = '1'; read(l, b); assert good; assert b = '0'; read(l, b, good); assert not good; deallocate(l); wait; end process; check_time: process is variable l : line; variable t : time; variable good : boolean; begin l := new string'(" 1 ns 15 sec 1 HR"); read(l, t, good); assert good; assert t = 1 ns; read(l, t, good); assert good; assert t = 15 sec; read(l, t, good); assert good; assert t = 1 hr; read(l, t, good); assert not good; deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio5.vhd000066400000000000000000000014531504111170000172770ustar00rootroot00000000000000entity textio5 is end entity; use std.textio.all; architecture test of textio5 is begin process is file fptr : text; variable l : line; begin file_open(fptr, "tmp.txt", WRITE_MODE); write(l, string'("0123")); tee(fptr, l); write(l, string'("4567")); tee(fptr, l); assert l'length = 0; file_close(fptr); file_open(fptr, "tmp.txt", READ_MODE); readline(fptr, l); assert l.all = "0123"; readline(fptr, l); assert l.all = "4567"; file_close(fptr); assert justify("hello", right, 7) = " hello"; assert justify("hello", left, 0) = "hello"; assert justify("hello", left, 6) = "hello "; deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio6.vhd000066400000000000000000000057171504111170000173070ustar00rootroot00000000000000entity textio6 is end entity; use std.textio.all; architecture test of textio6 is begin test_sread: process is variable l : line; variable s : string(1 to 5); variable n : natural; begin l := new string'(" word foo bar_baz end"); sread(l, s, n); report s(1 to n); assert n = 4; assert s(1 to n) = "word"; sread(l, s, n); report s(1 to n); assert n = 3; assert s(1 to n) = "foo"; sread(l, s, n); report s(1 to n); assert n = 5; assert s(1 to n) = "bar_b"; sread(l, s, n); report s(1 to n); assert n = 2; assert s(1 to n) = "az"; sread(l, s, n); report s(1 to n); assert n = 3; assert s(1 to n) = "end"; sread(l, s, n); assert n = 0; deallocate(l); wait; end process; test_hread: process is variable l : line; variable b : bit_vector(1 to 16); variable bv4 : bit_vector(12 downto 0); variable bv7 : bit_vector(10 downto 0); variable good : boolean; begin l := new string'(" 1 2 ab23 12_34 dead 12 1__2"); hread(l, b(1 to 4)); assert b(1 to 4) = "0001"; hread(l, b(1 to 4)); assert b(1 to 4) = "0010"; hread(l, b(1 to 16)); assert b(1 to 16) = X"ab23"; hread(l, b(1 to 16)); assert b(1 to 16) = X"1234"; hread(l, b(1 to 16)); assert b(1 to 16) = X"dead"; hread(l, b(1 to 16), good); assert not good; hread(l, b(1 to 8), good); assert not good; deallocate(l); l := new string'("0ABC"); hread (L, bv4, good); assert (good and bv4 = "0101010111100") report "h) short std.textio.hread " & to_string (bv4) severity error; deallocate (l); L := new string'("821"); -- one bit too many hread (L, bv7, good); assert (not good) report "l) std.textio.hread reported good read" severity error; deallocate(l); wait; end process; test_oread: process is variable l : line; variable b : bit_vector(1 to 6); variable good : boolean; begin l := new string'(" 1 2 5_2"); oread(l, b(1 to 3)); assert b(1 to 3) = "001"; oread(l, b(1 to 3)); assert b(1 to 3) = "010"; oread(l, b(1 to 6)); report to_string(b(1 to 6)); assert b(1 to 6) = "101010"; deallocate(l); wait; end process; test_ohwrite: process is variable l : line; begin hwrite(l, "1010", field => 5); assert l.all = " A"; deallocate(l); hwrite(l, X"abc", field => 5, justified => left); assert l.all = "ABC "; deallocate(l); owrite(l, o"77"); assert l.all = "77"; deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio7.vhd000066400000000000000000000023251504111170000173000ustar00rootroot00000000000000-- -- Test READ for real types -- entity textio7 is end entity; use std.textio.all; architecture test of textio7 is procedure check(value, expect : real) is variable l : line; begin assert abs(value - expect) < 0.0001 report "value=" & real'image(value) & " expect=" & real'image(expect) severity failure; write(l, value); writeline(output, l); deallocate(l); end procedure; begin main: process is variable r : real; variable l : line; begin l := new string'("1.23"); read(l, r); check(r, 1.23); deallocate(l); l := new string'("+4"); read(l, r); check(r, 4.0); deallocate(l); l := new string'("-0.001"); read(l, r); check(r, -0.001); deallocate(l); l := new string'("1.23e2"); read(l, r); check(r, 123.0); deallocate(l); l := new string'("1.994500e+03"); read(l, r); check(r, 1994.5); deallocate(l); l := new string'(" 1.994500e+03"); read(l, r); check(r, 1994.5); deallocate(l); wait; end process; end architecture; nvc-r1.17.1/test/regress/textio8.vhd000066400000000000000000000033061504111170000173010ustar00rootroot00000000000000-- -- LINE indexes may not start from 1 -- entity textio8 is end entity; use std.textio.all; architecture test of textio8 is begin p1: process is variable l : line; variable i : integer; variable s : string(5 to 9); variable c : character; variable b : boolean; variable r : real; variable t : time; variable v : bit_vector(8 downto 1); begin l := new string(5 to 10); l.all := "123 45"; read(l, i); assert i = 123; read(l, i); assert i = 45; l := new string(13 downto 3); l.all := "hello world"; read(l, s); assert s = "hello"; read(l, s); assert s = " worl"; read(l, c); assert c = 'd'; l := new string(5 to 8); l.all := "true"; read(l, b); assert b = true; l := new string(5 downto 5); l.all := "x"; read(l, c); assert c = 'x'; l := new string(5 to 9); l.all := "2.000"; read(l, r); assert r = 2.0; l := new string(5 to 9); l.all := "2.0e2"; read(l, r); assert abs(r - 200.0) < 0.0001; l := new string(10 downto 7); l.all := "5 ns"; read(l, t); assert t = 5 ns; l := null; s := "hello"; write(l, s); assert l.all = "hello"; assert l'left = 1; assert s'left = 5; l := new string(80 downto 73); l.all := X"ab"; read(l, v); assert v = X"ab"; l := new string(4 to 9); l.all := "-2.000"; read(l, r); assert r = -2.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/toplevel1.vhd000066400000000000000000000006361504111170000176130ustar00rootroot00000000000000entity toplevel1 is generic ( WIDTH : integer := 6 ); port ( x : in bit_vector(WIDTH - 1 downto 0); y : out bit_vector(WIDTH - 1 downto 0) ); end entity; architecture test of toplevel1 is begin y <= x after 1 ns; process is begin assert x'length = 6; assert y'length = 6; assert x = "000000"; wait; end process; end architecture; nvc-r1.17.1/test/regress/toplevel2.vhd000066400000000000000000000003631504111170000176110ustar00rootroot00000000000000entity toplevel2 is generic ( I : integer; S : string ); end entity; architecture test of toplevel2 is begin process is begin assert I = integer'value(S); wait; end process; end architecture; nvc-r1.17.1/test/regress/toplevel3.vhd000066400000000000000000000007171504111170000176150ustar00rootroot00000000000000entity sub is generic ( I : integer; S : string ); end entity; architecture test of sub is begin process is begin assert I = integer'value(S); wait; end process; end architecture; ------------------------------------------------------------------------------- entity toplevel3 is end entity; architecture test of toplevel3 is begin uut: entity work.sub generic map (4, "500"); end architecture; nvc-r1.17.1/test/regress/value1.vhd000066400000000000000000000031531504111170000170720ustar00rootroot00000000000000entity value1 is end entity; architecture test of value1 is begin process is type my_small_int is range 1 to 10; type my_enum is (A, B, C, D); type my_real is range -5.0 to 5.0; type big_real is range -1.7976931348623157e308 to 1.7976931348623157e308; subtype my_sub is my_enum range B to C; type resistance is range 0 to 10000000 units ohm; kohm = 1000 ohm; mohm = 1000 kohm; end units; begin assert integer'value("1") = 1; assert integer'value("-1") = -1; assert natural'value(" 12_3") = 123; assert my_small_int'value("5 ") = 5; assert boolean'value("true") = true; assert boolean'value("FALSE") = false; assert character'value("'x' ") = 'x'; assert integer'value(integer'image(integer'high)) = integer'high; assert integer'value(integer'image(integer'low)) = integer'low; assert my_enum'value("A") = A; assert my_sub'value(" B ") = B; assert resistance'value("1 ohm") = 1 ohm; assert resistance'value("5 ohm") = 5 ohm; assert resistance'value("1 kohm") = 1000 ohm; assert resistance'value(" 25 kohm ") = 25_000 ohm; assert my_real'value("1.23") = 1.23; assert my_real'value(" 4.2 ") = 4.2; assert my_real'value("-5e-1") = -0.5; assert my_real'value("1.3e-5") = 1.3e-5; assert big_real'value("-623.0001") = -623.0001; assert big_real'value("123456789123.0e2") = 12345678912300.0; wait; end process; end architecture; nvc-r1.17.1/test/regress/value2.vhd000066400000000000000000000017021504111170000170710ustar00rootroot00000000000000entity value2 is end entity; architecture test of value2 is type t_pair is record x, y : integer; end record; type t_int_vec is array (natural range <>) of integer; type t_nested is record p : t_pair; b : boolean; r : real; i : t_int_vec(1 to 2); end record; type t_pair_pair is array (1 to 2) of t_pair; type t_abc is ('a', 'b', 'c'); type t_abc_vec is array (natural range <>) of t_abc; begin process is begin assert t_pair'value("(1,2)") = (1, 2); assert t_pair'value("( 4, 6 )") = (4, 6); assert t_nested'value("((1, 2), true, 1.5, (5, 6))") = ((1, 2), true, 1.5, (5, 6)); assert t_int_vec'value("(1,2,3)") = (1, 2, 3); assert t_pair_pair'value("((1,2), (3, 4))") = ((1,2), (3,4)); assert t_abc_vec'value("abc") = "abc"; assert t_abc_vec'value(" bbc ") = "bbc"; wait; end process; end architecture; nvc-r1.17.1/test/regress/value3.vhd000066400000000000000000000005621504111170000170750ustar00rootroot00000000000000entity value3 is end entity; architecture test of value3 is type t_pair is record x, y : integer; end record; type t_pair_pair is array (1 to 2) of t_pair; begin process is begin assert t_pair_pair'value("((1,2), (3, 4), (5, 6))") = ((1,2), (3,4)); -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/value4.vhd000066400000000000000000000004441504111170000170750ustar00rootroot00000000000000entity value4 is end entity; architecture test of value4 is type t_abc is ('a', 'b', 'c'); type t_abc_vec is array (natural range <>) of t_abc; begin process is begin assert t_abc_vec'value("abX") = "abc"; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/vecorder1.vhd000066400000000000000000000025351504111170000175720ustar00rootroot00000000000000entity vecorder1 is end entity; architecture test of vecorder1 is type int_array is array (integer range <>) of integer; signal s : int_array(0 to 1) := ( 0 => 0, 1 => 1 ); begin process is variable x : int_array(0 to 1) := ( 0 => 0, 1 => 1 ); variable y : int_array(1 downto 0) := ( 0 => 0, 1 => 1 ); begin assert x(0) = 0 report "one"; assert x(1) = 1 report "two"; assert x = ( 0, 1 ); x := ( 2, 3 ); report integer'image(x(0)); report integer'image(x(1)); assert x(0) = 2 report "three"; assert x(1) = 3 report "four"; assert x = ( 2, 3 ) report "five"; assert ( 2, 3 ) = x report "six"; assert s(0) = 0 report "s one"; assert s(1) = 1 report "s two"; s <= ( 2, 3 ); wait for 0 ns; report integer'image(s(0)); report integer'image(s(1)); assert s(0) = 2 report "s three"; assert s(1) = 3 report "s four"; assert y(0) = 0 report "y one"; assert y(1) = 1 report "y two"; assert y = ( 1, 0 ); y := ( 2, 3 ); report integer'image(y(0)); report integer'image(y(1)); assert y(0) = 3 report "y three"; assert y(1) = 2 report "y four"; assert y = ( 2, 3 ) report "y five"; wait; end process; end architecture; nvc-r1.17.1/test/regress/vecorder2.vhd000066400000000000000000000027421504111170000175730ustar00rootroot00000000000000library ieee; use ieee.numeric_std.all; use ieee.std_logic_1164.all; entity vecorder2 is end vecorder2; architecture rtl of vecorder2 is signal c_a : std_logic_vector(11 downto 0) := x"FAE"; signal c_b : std_logic_vector(11 downto 0) := x"182"; signal s_expected_vector : std_logic_vector(31 downto 0); signal s_resulting_vector : std_logic_vector(31 downto 0); begin -- Compute expected value using intermediate variables for padding expected_value : process variable v_a_padded : std_logic_vector(15 downto 0); variable v_b_padded : std_logic_vector(15 downto 0); begin v_a_padded := (15 downto 12 => c_a(11), 11 downto 0 => c_a); v_b_padded := (15 downto 12 => c_b(11), 11 downto 0 => c_b); s_expected_vector <= v_a_padded & v_b_padded; wait for 1 ns; report "Expected result " & to_hstring(s_expected_vector) severity note; wait; end process; -- Perform the concatenation and the padding in 1 line resulting_value : process begin s_resulting_vector <= (15 downto 12 => c_a(11), 11 downto 0 => c_a) & (15 downto 12 => c_b(11), 11 downto 0 => c_b); wait for 2 ns; report "Actual result " & to_hstring(s_resulting_vector) severity note; wait; end process; checker : process begin wait for 3 ns; assert s_resulting_vector = s_expected_vector severity failure; wait; end process; end rtl; nvc-r1.17.1/test/regress/vests1.vhd000066400000000000000000001422431504111170000171260ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc520.vhd,v 1.2 2001-10-26 16:29:56 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- PACKAGE c03s03b00x00p03n04i00520pkg IS -- -- Index types for array declarations -- SUBTYPE st_ind1 IS INTEGER RANGE 1 TO 8; -- index from 1 (POSITIVE) SUBTYPE st_ind2 IS INTEGER RANGE 0 TO 3; -- index from 0 (NATURAL) SUBTYPE st_ind3 IS CHARACTER RANGE 'a' TO 'd'; -- non-INTEGER index SUBTYPE st_ind4 IS INTEGER RANGE 0 DOWNTO -3; -- descending range -- -- Scalar type for subelements -- SUBTYPE st_scl1 IS CHARACTER ; SUBTYPE st_scl3 IS INTEGER RANGE 1 TO INTEGER'HIGH; SUBTYPE st_scl4 IS REAL RANGE 0.0 TO 1024.0; -- ----------------------------------------------------------------------------------------- -- Composite type declarations -- ----------------------------------------------------------------------------------------- -- -- Records of scalars -- TYPE t_scre_1 IS RECORD left : st_scl1; second : TIME; third : st_scl3; right : st_scl4; END RECORD; -- -- Unconstrained arrays of scalars -- TYPE t_usa1_1 IS ARRAY (st_ind1 RANGE <>) OF st_scl1; TYPE t_usa1_2 IS ARRAY (st_ind2 RANGE <>) OF TIME; TYPE t_usa1_3 IS ARRAY (st_ind3 RANGE <>) OF st_scl3; TYPE t_usa1_4 IS ARRAY (st_ind4 RANGE <>) OF st_scl4; TYPE t_usa2_1 IS ARRAY (st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; TYPE t_usa3_1 IS ARRAY (st_ind3 RANGE <>, st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; TYPE t_usa4_1 IS ARRAY (st_ind4 RANGE <>, st_ind3 RANGE <>, st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; -- -- -- Constrained arrays of scalars (make compatable with unconstrained types -- SUBTYPE t_csa1_1 IS t_usa1_1 (st_ind1 ); SUBTYPE t_csa1_2 IS t_usa1_2 (st_ind2 ); SUBTYPE t_csa1_3 IS t_usa1_3 (st_ind3 ); SUBTYPE t_csa1_4 IS t_usa1_4 (st_ind4 ); SUBTYPE t_csa2_1 IS t_usa2_1 (st_ind2 , -- ( i2, i1 ) of CHAR st_ind1 ); SUBTYPE t_csa3_1 IS t_usa3_1 (st_ind3 , -- ( i3, i2, i1) of CHAR st_ind2 , st_ind1 ); SUBTYPE t_csa4_1 IS t_usa4_1 (st_ind4 , -- ( i4, i3, i2, i1 ) of CHAR st_ind3 , st_ind2 , st_ind1 ); -- -- -- constrained arrays of composites -- TYPE t_cca1_1 IS ARRAY (st_ind1) OF t_scre_1; -- ( i1 ) is RECORD of scalar TYPE t_cca1_2 IS ARRAY (st_ind2) OF t_csa1_1; -- ( i2 )( i1 ) is CHAR TYPE t_cca1_3 IS ARRAY (st_ind3) OF t_cca1_2; -- ( i3 )( i2 )( i1 ) is CHAR TYPE t_cca1_4 IS ARRAY (st_ind4) OF t_cca1_3; -- ( i4 )( i3 )( i2 )( i1 ) is CHAR TYPE t_cca2_1 IS ARRAY (st_ind3) OF t_csa2_1; -- ( i3 )( i2, i1 ) is CHAR TYPE t_cca2_2 IS ARRAY (st_ind4, -- ( i4, i3 )( i2, i1 ) of CHAR st_ind3) OF t_csa2_1; TYPE t_cca3_1 IS ARRAY (st_ind4, -- ( i4, i3, i2 )( i1 ) of CHAR st_ind3, st_ind2) OF t_csa1_1; TYPE t_cca3_2 IS ARRAY (st_ind4) OF t_csa3_1; -- ( i4 )( i3, i2, i1 ) is CHAR -- -- Records of composites -- TYPE t_cmre_1 IS RECORD left : t_csa1_1; -- .fN(i1) is CHAR second : t_scre_1; -- .fN.fN END RECORD; TYPE t_cmre_2 IS RECORD left , second , third , right : t_csa1_1; -- .fN(i1) is CHAR END RECORD; -- -- Mixed Records/arrays -- TYPE t_cca1_7 IS ARRAY (st_ind3) OF t_cmre_2; -- (i3).fN(i1) is CHAR TYPE t_cmre_3 IS RECORD left , second , third , right : t_cca1_7; -- .fN(i3).fN(i1) is CHAR END RECORD; -- -- TYPE declarations for resolution function (Constrained types only) -- TYPE t_scre_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_scre_1; TYPE t_csa1_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_1; TYPE t_csa1_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_2; TYPE t_csa1_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_3; TYPE t_csa1_4_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_4; TYPE t_csa2_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa2_1; TYPE t_csa3_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa3_1; TYPE t_csa4_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa4_1; TYPE t_cca1_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_1; TYPE t_cca1_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_2; TYPE t_cca1_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_3; TYPE t_cca1_4_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_4; TYPE t_cca2_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca2_1; TYPE t_cca2_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca2_2; TYPE t_cca3_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca3_1; TYPE t_cca3_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca3_2; TYPE t_cmre_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_1; TYPE t_cmre_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_2; TYPE t_cca1_7_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_7; TYPE t_cmre_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_3; -- -- Declaration of Resolution Functions -- FUNCTION rf_scre_1 ( v: t_scre_1_vct ) RETURN t_scre_1; FUNCTION rf_csa1_1 ( v: t_csa1_1_vct ) RETURN t_csa1_1; FUNCTION rf_csa1_2 ( v: t_csa1_2_vct ) RETURN t_csa1_2; FUNCTION rf_csa1_3 ( v: t_csa1_3_vct ) RETURN t_csa1_3; FUNCTION rf_csa1_4 ( v: t_csa1_4_vct ) RETURN t_csa1_4; FUNCTION rf_csa2_1 ( v: t_csa2_1_vct ) RETURN t_csa2_1; FUNCTION rf_csa3_1 ( v: t_csa3_1_vct ) RETURN t_csa3_1; FUNCTION rf_csa4_1 ( v: t_csa4_1_vct ) RETURN t_csa4_1; FUNCTION rf_cca1_1 ( v: t_cca1_1_vct ) RETURN t_cca1_1; FUNCTION rf_cca1_2 ( v: t_cca1_2_vct ) RETURN t_cca1_2; FUNCTION rf_cca1_3 ( v: t_cca1_3_vct ) RETURN t_cca1_3; FUNCTION rf_cca1_4 ( v: t_cca1_4_vct ) RETURN t_cca1_4; FUNCTION rf_cca2_1 ( v: t_cca2_1_vct ) RETURN t_cca2_1; FUNCTION rf_cca2_2 ( v: t_cca2_2_vct ) RETURN t_cca2_2; FUNCTION rf_cca3_1 ( v: t_cca3_1_vct ) RETURN t_cca3_1; FUNCTION rf_cca3_2 ( v: t_cca3_2_vct ) RETURN t_cca3_2; FUNCTION rf_cmre_1 ( v: t_cmre_1_vct ) RETURN t_cmre_1; FUNCTION rf_cmre_2 ( v: t_cmre_2_vct ) RETURN t_cmre_2; FUNCTION rf_cca1_7 ( v: t_cca1_7_vct ) RETURN t_cca1_7; FUNCTION rf_cmre_3 ( v: t_cmre_3_vct ) RETURN t_cmre_3; -- -- Resolved SUBTYPE declaration -- SUBTYPE rst_scre_1 IS rf_scre_1 t_scre_1 ; SUBTYPE rst_csa1_1 IS rf_csa1_1 t_csa1_1 ; SUBTYPE rst_csa1_2 IS rf_csa1_2 t_csa1_2 ; SUBTYPE rst_csa1_3 IS rf_csa1_3 t_csa1_3 ; SUBTYPE rst_csa1_4 IS rf_csa1_4 t_csa1_4 ; SUBTYPE rst_csa2_1 IS rf_csa2_1 t_csa2_1 ; SUBTYPE rst_csa3_1 IS rf_csa3_1 t_csa3_1 ; SUBTYPE rst_csa4_1 IS rf_csa4_1 t_csa4_1 ; SUBTYPE rst_cca1_1 IS rf_cca1_1 t_cca1_1 ; SUBTYPE rst_cca1_2 IS rf_cca1_2 t_cca1_2 ; SUBTYPE rst_cca1_3 IS rf_cca1_3 t_cca1_3 ; SUBTYPE rst_cca1_4 IS rf_cca1_4 t_cca1_4 ; SUBTYPE rst_cca2_1 IS rf_cca2_1 t_cca2_1 ; SUBTYPE rst_cca2_2 IS rf_cca2_2 t_cca2_2 ; SUBTYPE rst_cca3_1 IS rf_cca3_1 t_cca3_1 ; SUBTYPE rst_cca3_2 IS rf_cca3_2 t_cca3_2 ; SUBTYPE rst_cmre_1 IS rf_cmre_1 t_cmre_1 ; SUBTYPE rst_cmre_2 IS rf_cmre_2 t_cmre_2 ; SUBTYPE rst_cca1_7 IS rf_cca1_7 t_cca1_7 ; SUBTYPE rst_cmre_3 IS rf_cmre_3 t_cmre_3 ; -- -- Functions declarations for multi-dimensional comosite values -- FUNCTION F_csa2_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa2_1 ; FUNCTION F_csa3_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa3_1 ; FUNCTION F_csa4_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa4_1 ; FUNCTION F_cca2_2 ( v0,v2 : IN t_csa2_1 ) RETURN t_cca2_2 ; FUNCTION F_cca3_1 ( v0,v2 : IN t_csa1_1 ) RETURN t_cca3_1 ; -- ------------------------------------------------------------------------------------------- -- Data values for Composite Types -- ------------------------------------------------------------------------------------------- CONSTANT CX_scl1 : st_scl1 := 'X' ; CONSTANT C0_scl1 : st_scl1 := st_scl1'LEFT ; CONSTANT C1_scl1 : st_scl1 := 'A' ; CONSTANT C2_scl1 : st_scl1 := 'Z' ; CONSTANT CX_scl2 : TIME := 99 fs ; CONSTANT C0_scl2 : TIME := TIME'LEFT ; CONSTANT C1_scl2 : TIME := 0 fs; CONSTANT C2_scl2 : TIME := 2 ns; CONSTANT CX_scl3 : st_scl3 := 15 ; CONSTANT C0_scl3 : st_scl3 := st_scl3'LEFT ; CONSTANT C1_scl3 : st_scl3 := 6 ; CONSTANT C2_scl3 : st_scl3 := 8 ; CONSTANT CX_scl4 : st_scl4 := 99.9 ; CONSTANT C0_scl4 : st_scl4 := st_scl4'LEFT ; CONSTANT C1_scl4 : st_scl4 := 1.0 ; CONSTANT C2_scl4 : st_scl4 := 2.1 ; CONSTANT CX_scre_1 : t_scre_1 := ( CX_scl1, CX_scl2, CX_scl3, CX_scl4 ); CONSTANT C0_scre_1 : t_scre_1 := ( C0_scl1, C0_scl2, C0_scl3, C0_scl4 ); CONSTANT C1_scre_1 : t_scre_1 := ( C1_scl1, C1_scl2, C1_scl3, C1_scl4 ); CONSTANT C2_scre_1 : t_scre_1 := ( C2_scl1, C0_scl2, C0_scl3, C2_scl4 ); CONSTANT CX_csa1_1 : t_csa1_1 := ( OTHERS=>CX_scl1); CONSTANT C0_csa1_1 : t_csa1_1 := ( OTHERS=>C0_scl1); CONSTANT C1_csa1_1 : t_csa1_1 := ( OTHERS=>C1_scl1); CONSTANT C2_csa1_1 : t_csa1_1 := ( t_csa1_1'LEFT|t_csa1_1'RIGHT=>C2_scl1, OTHERS =>C0_scl1); CONSTANT CX_csa1_2 : t_csa1_2 := ( OTHERS=>CX_scl2); CONSTANT C0_csa1_2 : t_csa1_2 := ( OTHERS=>C0_scl2); CONSTANT C1_csa1_2 : t_csa1_2 := ( OTHERS=>C1_scl2); CONSTANT C2_csa1_2 : t_csa1_2 := ( t_csa1_2'LEFT|t_csa1_2'RIGHT=>C2_scl2, OTHERS =>C0_scl2); CONSTANT CX_csa1_3 : t_csa1_3 := ( OTHERS=>CX_scl3); CONSTANT C0_csa1_3 : t_csa1_3 := ( OTHERS=>C0_scl3); CONSTANT C1_csa1_3 : t_csa1_3 := ( OTHERS=>C1_scl3); CONSTANT C2_csa1_3 : t_csa1_3 := ( t_csa1_3'LEFT|t_csa1_3'RIGHT=>C2_scl3, OTHERS =>C0_scl3); CONSTANT CX_csa1_4 : t_csa1_4 := ( OTHERS=>CX_scl4); CONSTANT C0_csa1_4 : t_csa1_4 := ( OTHERS=>C0_scl4); CONSTANT C1_csa1_4 : t_csa1_4 := ( OTHERS=>C1_scl4); CONSTANT C2_csa1_4 : t_csa1_4 := ( t_csa1_4'LEFT|t_csa1_4'RIGHT=>C2_scl4, OTHERS =>C0_scl4); -- CONSTANT CX_csa2_1 : t_csa2_1 ; CONSTANT C0_csa2_1 : t_csa2_1 ; CONSTANT C1_csa2_1 : t_csa2_1 ; CONSTANT C2_csa2_1 : t_csa2_1 ; CONSTANT CX_csa3_1 : t_csa3_1 ; CONSTANT C0_csa3_1 : t_csa3_1 ; CONSTANT C1_csa3_1 : t_csa3_1 ; CONSTANT C2_csa3_1 : t_csa3_1 ; CONSTANT CX_csa4_1 : t_csa4_1 ; CONSTANT C0_csa4_1 : t_csa4_1 ; CONSTANT C1_csa4_1 : t_csa4_1 ; CONSTANT C2_csa4_1 : t_csa4_1 ; -- CONSTANT CX_cca1_1 : t_cca1_1 := ( OTHERS=>CX_scre_1 ); CONSTANT C0_cca1_1 : t_cca1_1 := ( OTHERS=>C0_scre_1 ); CONSTANT C1_cca1_1 : t_cca1_1 := ( OTHERS=>C1_scre_1 ); CONSTANT C2_cca1_1 : t_cca1_1 := ( C2_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C2_scre_1 ); CONSTANT CX_cca1_2 : t_cca1_2 := ( OTHERS=>CX_csa1_1 ); CONSTANT C0_cca1_2 : t_cca1_2 := ( OTHERS=>C0_csa1_1 ); CONSTANT C1_cca1_2 : t_cca1_2 := ( OTHERS=>C1_csa1_1 ); CONSTANT C2_cca1_2 : t_cca1_2 := ( C2_csa1_1, C0_csa1_1, C0_csa1_1, C2_csa1_1 ); CONSTANT CX_cca1_3 : t_cca1_3 := ( OTHERS=>CX_cca1_2 ); CONSTANT C0_cca1_3 : t_cca1_3 := ( OTHERS=>C0_cca1_2 ); CONSTANT C1_cca1_3 : t_cca1_3 := ( OTHERS=>C1_cca1_2 ); CONSTANT C2_cca1_3 : t_cca1_3 := ( C2_cca1_2, C0_cca1_2, C0_cca1_2, C2_cca1_2 ); CONSTANT CX_cca1_4 : t_cca1_4 := ( OTHERS=>CX_cca1_3 ); CONSTANT C0_cca1_4 : t_cca1_4 := ( OTHERS=>C0_cca1_3 ); CONSTANT C1_cca1_4 : t_cca1_4 := ( OTHERS=>C1_cca1_3 ); CONSTANT C2_cca1_4 : t_cca1_4 := ( C2_cca1_3, C0_cca1_3, C0_cca1_3, C2_cca1_3 ); CONSTANT CX_cca2_1 : t_cca2_1 ; CONSTANT C0_cca2_1 : t_cca2_1 ; CONSTANT C1_cca2_1 : t_cca2_1 ; CONSTANT C2_cca2_1 : t_cca2_1 ; -- CONSTANT CX_cca2_2 : t_cca2_2 ; CONSTANT C0_cca2_2 : t_cca2_2 ; CONSTANT C1_cca2_2 : t_cca2_2 ; CONSTANT C2_cca2_2 : t_cca2_2 ; CONSTANT CX_cca3_1 : t_cca3_1 ; CONSTANT C0_cca3_1 : t_cca3_1 ; CONSTANT C1_cca3_1 : t_cca3_1 ; CONSTANT C2_cca3_1 : t_cca3_1 ; -- CONSTANT CX_cca3_2 : t_cca3_2 ; CONSTANT C0_cca3_2 : t_cca3_2 ; CONSTANT C1_cca3_2 : t_cca3_2 ; CONSTANT C2_cca3_2 : t_cca3_2 ; CONSTANT CX_cmre_1 : t_cmre_1 := ( CX_csa1_1, CX_scre_1 ); CONSTANT C0_cmre_1 : t_cmre_1 := ( C0_csa1_1, C0_scre_1 ); CONSTANT C1_cmre_1 : t_cmre_1 := ( C1_csa1_1, C1_scre_1 ); CONSTANT C2_cmre_1 : t_cmre_1 := ( C2_csa1_1, C0_scre_1 ); CONSTANT CX_cmre_2 : t_cmre_2 := ( OTHERS=>CX_csa1_1 ); CONSTANT C0_cmre_2 : t_cmre_2 := ( OTHERS=>C0_csa1_1 ); CONSTANT C1_cmre_2 : t_cmre_2 := ( OTHERS=>C1_csa1_1 ); CONSTANT C2_cmre_2 : t_cmre_2 := ( left|right=>C2_csa1_1, OTHERS=>C0_csa1_1 ); CONSTANT CX_cca1_7 : t_cca1_7 := ( OTHERS=>CX_cmre_2 ); CONSTANT C0_cca1_7 : t_cca1_7 := ( OTHERS=>C0_cmre_2 ); CONSTANT C1_cca1_7 : t_cca1_7 := ( OTHERS=>C1_cmre_2 ); CONSTANT C2_cca1_7 : t_cca1_7 := ( C2_cmre_2, C0_cmre_2, C0_cmre_2, C2_cmre_2 ); CONSTANT CX_cmre_3 : t_cmre_3 := ( OTHERS=>CX_cca1_7 ); CONSTANT C0_cmre_3 : t_cmre_3 := ( OTHERS=>C0_cca1_7 ); CONSTANT C1_cmre_3 : t_cmre_3 := ( OTHERS=>C1_cca1_7 ); CONSTANT C2_cmre_3 : t_cmre_3 := ( left|right=>C2_cca1_7, OTHERS=>C0_cca1_7 ); -- -------------------------------------------------------------------------------------------- -- Functions for mapping from integer test values to/from values of the Test types -- -------------------------------------------------------------------------------------------- FUNCTION val_t ( i : INTEGER ) RETURN st_scl1; FUNCTION val_t ( i : INTEGER ) RETURN TIME; FUNCTION val_t ( i : INTEGER ) RETURN st_scl3; FUNCTION val_t ( i : INTEGER ) RETURN st_scl4; FUNCTION val_t ( i : INTEGER ) RETURN t_scre_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_2; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_3; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_4; FUNCTION val_t ( i : INTEGER ) RETURN t_csa2_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa3_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa4_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_3; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_4; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_7; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_3; FUNCTION val_i ( i : st_scl1 ) RETURN INTEGER; FUNCTION val_i ( i : TIME ) RETURN INTEGER; FUNCTION val_i ( i : st_scl3 ) RETURN INTEGER; FUNCTION val_i ( i : st_scl4 ) RETURN INTEGER; FUNCTION val_i ( i : t_scre_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_3 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_4 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa2_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa3_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa4_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_3 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_4 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca2_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca2_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca3_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca3_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_7 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_3 ) RETURN INTEGER; FUNCTION val_s ( i : st_scl1 ) RETURN STRING; FUNCTION val_s ( i : TIME ) RETURN STRING; FUNCTION val_s ( i : st_scl3 ) RETURN STRING; FUNCTION val_s ( i : st_scl4 ) RETURN STRING; FUNCTION val_s ( i : t_scre_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_2 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_3 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_4 ) RETURN STRING; FUNCTION val_s ( i : t_csa2_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa3_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa4_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_3 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_4 ) RETURN STRING; FUNCTION val_s ( i : t_cca2_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca2_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca3_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca3_2 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_1 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_7 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_3 ) RETURN STRING; END; PACKAGE BODY c03s03b00x00p03n04i00520pkg IS -- -- Functions to provide values for multi-dimensional composites -- FUNCTION F_csa2_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa2_1 IS VARIABLE res : t_csa2_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP res(i,j) := v0; END LOOP; END LOOP; res(res'left (1),res'left (2)) := v2; res(res'left (1),res'right(2)) := v2; res(res'right(1),res'left (2)) := v2; res(res'right(1),res'right(2)) := v2; RETURN res; END; FUNCTION F_csa3_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa3_1 IS VARIABLE res : t_csa3_1; BEGIN FOR i IN res'RANGE(1) LOOP -- i: st_ind3 (character) FOR j IN res'RANGE(2) loop -- j: st_ind2 (integer) FOR k IN res'RANGE(3) loop -- k: st_ind1 (integer) res(i,j,k) := v0; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3)) := v2; res(res'right(1),res'left (2),res'left (3)) := v2; res(res'left (1),res'right(2),res'left (3)) := v2; res(res'right(1),res'right(2),res'left (3)) := v2; res(res'left (1),res'left (2),res'right(3)) := v2; res(res'right(1),res'left (2),res'right(3)) := v2; res(res'left (1),res'right(2),res'right(3)) := v2; res(res'right(1),res'right(2),res'right(3)) := v2; RETURN res; END; FUNCTION F_csa4_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa4_1 IS VARIABLE res : t_csa4_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP FOR k IN res'RANGE(3) LOOP FOR l IN res'RANGE(4) LOOP res(i,j,k,l) := v0; END LOOP; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3),res'left (4)) := v2; res(res'right(1),res'left (2),res'left (3),res'left (4)) := v2; res(res'left (1),res'right(2),res'left (3),res'left (4)) := v2; res(res'right(1),res'right(2),res'left (3),res'left (4)) := v2; res(res'left (1),res'left (2),res'right(3),res'left (4)) := v2; res(res'right(1),res'left (2),res'right(3),res'left (4)) := v2; res(res'left (1),res'right(2),res'right(3),res'left (4)) := v2; res(res'right(1),res'right(2),res'right(3),res'left (4)) := v2; res(res'left (1),res'left (2),res'left (3),res'right(4)) := v2; res(res'right(1),res'left (2),res'left (3),res'right(4)) := v2; res(res'left (1),res'right(2),res'left (3),res'right(4)) := v2; res(res'right(1),res'right(2),res'left (3),res'right(4)) := v2; res(res'left (1),res'left (2),res'right(3),res'right(4)) := v2; res(res'right(1),res'left (2),res'right(3),res'right(4)) := v2; res(res'left (1),res'right(2),res'right(3),res'right(4)) := v2; res(res'right(1),res'right(2),res'right(3),res'right(4)) := v2; RETURN res; END; FUNCTION F_cca2_2 ( v0,v2 : IN t_csa2_1 ) RETURN t_cca2_2 IS VARIABLE res : t_cca2_2; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP res(i,j) := v0; END LOOP; END LOOP; res(res'left (1),res'left (2)) := v2; res(res'left (1),res'right(2)) := v2; res(res'right(1),res'left (2)) := v2; res(res'right(1),res'right(2)) := v2; RETURN res; END; FUNCTION F_cca3_1 ( v0,v2 : IN t_csa1_1 ) RETURN t_cca3_1 IS VARIABLE res : t_cca3_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP FOR k IN res'RANGE(3) LOOP res(i,j,k) := v0; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3)) := v2; res(res'right(1),res'left (2),res'left (3)) := v2; res(res'left (1),res'right(2),res'left (3)) := v2; res(res'right(1),res'right(2),res'left (3)) := v2; res(res'left (1),res'left (2),res'right(3)) := v2; res(res'right(1),res'left (2),res'right(3)) := v2; res(res'left (1),res'right(2),res'right(3)) := v2; res(res'right(1),res'right(2),res'right(3)) := v2; RETURN res; END; -- -- Resolution Functions -- FUNCTION rf_scre_1 ( v: t_scre_1_vct ) RETURN t_scre_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_scre_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_1 ( v: t_csa1_1_vct ) RETURN t_csa1_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_2 ( v: t_csa1_2_vct ) RETURN t_csa1_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_3 ( v: t_csa1_3_vct ) RETURN t_csa1_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_3; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_4 ( v: t_csa1_4_vct ) RETURN t_csa1_4 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_4; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa2_1 ( v: t_csa2_1_vct ) RETURN t_csa2_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa2_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa3_1 ( v: t_csa3_1_vct ) RETURN t_csa3_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa3_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa4_1 ( v: t_csa4_1_vct ) RETURN t_csa4_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa4_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_1 ( v: t_cca1_1_vct ) RETURN t_cca1_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_2 ( v: t_cca1_2_vct ) RETURN t_cca1_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_3 ( v: t_cca1_3_vct ) RETURN t_cca1_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_3; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_4 ( v: t_cca1_4_vct ) RETURN t_cca1_4 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_4; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca2_1 ( v: t_cca2_1_vct ) RETURN t_cca2_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca2_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca2_2 ( v: t_cca2_2_vct ) RETURN t_cca2_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca2_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca3_1 ( v: t_cca3_1_vct ) RETURN t_cca3_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca3_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca3_2 ( v: t_cca3_2_vct ) RETURN t_cca3_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca3_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_1 ( v: t_cmre_1_vct ) RETURN t_cmre_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_2 ( v: t_cmre_2_vct ) RETURN t_cmre_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_7 ( v: t_cca1_7_vct ) RETURN t_cca1_7 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_7; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_3 ( v: t_cmre_3_vct ) RETURN t_cmre_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_3; ELSE RETURN v(1); END IF; END; CONSTANT CX_csa2_1 : t_csa2_1 := F_csa2_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa2_1 : t_csa2_1 := F_csa2_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa2_1 : t_csa2_1 := F_csa2_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa2_1 : t_csa2_1 := F_csa2_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_csa3_1 : t_csa3_1 := F_csa3_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa3_1 : t_csa3_1 := F_csa3_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa3_1 : t_csa3_1 := F_csa3_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa3_1 : t_csa3_1 := F_csa3_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_csa4_1 : t_csa4_1 := F_csa4_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa4_1 : t_csa4_1 := F_csa4_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa4_1 : t_csa4_1 := F_csa4_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa4_1 : t_csa4_1 := F_csa4_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_cca2_1 : t_cca2_1 := ( OTHERS=>CX_csa2_1 ); CONSTANT C0_cca2_1 : t_cca2_1 := ( OTHERS=>C0_csa2_1 ); CONSTANT C1_cca2_1 : t_cca2_1 := ( OTHERS=>C1_csa2_1 ); CONSTANT C2_cca2_1 : t_cca2_1 := ( C2_csa2_1, C0_csa2_1, C0_csa2_1, C2_csa2_1 ); CONSTANT CX_cca2_2 : t_cca2_2 := F_cca2_2 ( CX_csa2_1, CX_csa2_1 ); CONSTANT C0_cca2_2 : t_cca2_2 := F_cca2_2 ( C0_csa2_1, C0_csa2_1 ); CONSTANT C1_cca2_2 : t_cca2_2 := F_cca2_2 ( C1_csa2_1, C1_csa2_1 ); CONSTANT C2_cca2_2 : t_cca2_2 := F_cca2_2 ( C0_csa2_1, C2_csa2_1 ); CONSTANT CX_cca3_1 : t_cca3_1 := F_cca3_1 ( CX_csa1_1, CX_csa1_1 ); CONSTANT C0_cca3_1 : t_cca3_1 := F_cca3_1 ( C0_csa1_1, C0_csa1_1 ); CONSTANT C1_cca3_1 : t_cca3_1 := F_cca3_1 ( C1_csa1_1, C1_csa1_1 ); CONSTANT C2_cca3_1 : t_cca3_1 := F_cca3_1 ( C0_csa1_1, C2_csa1_1 ); CONSTANT CX_cca3_2 : t_cca3_2 := ( OTHERS=>CX_csa3_1 ); CONSTANT C0_cca3_2 : t_cca3_2 := ( OTHERS=>C0_csa3_1 ); CONSTANT C1_cca3_2 : t_cca3_2 := ( OTHERS=>C1_csa3_1 ); CONSTANT C2_cca3_2 : t_cca3_2 := ( C2_csa3_1, C0_csa3_1, C0_csa3_1, C2_csa3_1 ); -- -- FUNCTION val_t ( i : INTEGER ) RETURN st_scl1 IS BEGIN IF i = 0 THEN RETURN C0_scl1; END IF; IF i = 1 THEN RETURN C1_scl1; END IF; IF i = 2 THEN RETURN C2_scl1; END IF; RETURN CX_scl1; END; FUNCTION val_t ( i : INTEGER ) RETURN TIME IS BEGIN IF i = 0 THEN RETURN C0_scl2; END IF; IF i = 1 THEN RETURN C1_scl2; END IF; IF i = 2 THEN RETURN C2_scl2; END IF; RETURN CX_scl2; END; FUNCTION val_t ( i : INTEGER ) RETURN st_scl3 IS BEGIN IF i = 0 THEN RETURN C0_scl3; END IF; IF i = 1 THEN RETURN C1_scl3; END IF; IF i = 2 THEN RETURN C2_scl3; END IF; RETURN CX_scl3; END; FUNCTION val_t ( i : INTEGER ) RETURN st_scl4 IS BEGIN IF i = 0 THEN RETURN C0_scl4; END IF; IF i = 1 THEN RETURN C1_scl4; END IF; IF i = 2 THEN RETURN C2_scl4; END IF; RETURN CX_scl4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_scre_1 IS BEGIN IF i = 0 THEN RETURN C0_scre_1; END IF; IF i = 1 THEN RETURN C1_scre_1; END IF; IF i = 2 THEN RETURN C2_scre_1; END IF; RETURN CX_scre_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_1 IS BEGIN IF i = 0 THEN RETURN C0_csa1_1; END IF; IF i = 1 THEN RETURN C1_csa1_1; END IF; IF i = 2 THEN RETURN C2_csa1_1; END IF; RETURN CX_csa1_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_2 IS BEGIN IF i = 0 THEN RETURN C0_csa1_2; END IF; IF i = 1 THEN RETURN C1_csa1_2; END IF; IF i = 2 THEN RETURN C2_csa1_2; END IF; RETURN CX_csa1_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_3 IS BEGIN IF i = 0 THEN RETURN C0_csa1_3; END IF; IF i = 1 THEN RETURN C1_csa1_3; END IF; IF i = 2 THEN RETURN C2_csa1_3; END IF; RETURN CX_csa1_3; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_4 IS BEGIN IF i = 0 THEN RETURN C0_csa1_4; END IF; IF i = 1 THEN RETURN C1_csa1_4; END IF; IF i = 2 THEN RETURN C2_csa1_4; END IF; RETURN CX_csa1_4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa2_1 IS BEGIN IF i = 0 THEN RETURN C0_csa2_1; END IF; IF i = 1 THEN RETURN C1_csa2_1; END IF; IF i = 2 THEN RETURN C2_csa2_1; END IF; RETURN CX_csa2_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa3_1 IS BEGIN IF i = 0 THEN RETURN C0_csa3_1; END IF; IF i = 1 THEN RETURN C1_csa3_1; END IF; IF i = 2 THEN RETURN C2_csa3_1; END IF; RETURN CX_csa3_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa4_1 IS BEGIN IF i = 0 THEN RETURN C0_csa4_1; END IF; IF i = 1 THEN RETURN C1_csa4_1; END IF; IF i = 2 THEN RETURN C2_csa4_1; END IF; RETURN CX_csa4_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_1 IS BEGIN IF i = 0 THEN RETURN C0_cca1_1; END IF; IF i = 1 THEN RETURN C1_cca1_1; END IF; IF i = 2 THEN RETURN C2_cca1_1; END IF; RETURN CX_cca1_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_2 IS BEGIN IF i = 0 THEN RETURN C0_cca1_2; END IF; IF i = 1 THEN RETURN C1_cca1_2; END IF; IF i = 2 THEN RETURN C2_cca1_2; END IF; RETURN CX_cca1_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_3 IS BEGIN IF i = 0 THEN RETURN C0_cca1_3; END IF; IF i = 1 THEN RETURN C1_cca1_3; END IF; IF i = 2 THEN RETURN C2_cca1_3; END IF; RETURN CX_cca1_3; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_4 IS BEGIN IF i = 0 THEN RETURN C0_cca1_4; END IF; IF i = 1 THEN RETURN C1_cca1_4; END IF; IF i = 2 THEN RETURN C2_cca1_4; END IF; RETURN CX_cca1_4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_1 IS BEGIN IF i = 0 THEN RETURN C0_cca2_1; END IF; IF i = 1 THEN RETURN C1_cca2_1; END IF; IF i = 2 THEN RETURN C2_cca2_1; END IF; RETURN CX_cca2_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_2 IS BEGIN IF i = 0 THEN RETURN C0_cca2_2; END IF; IF i = 1 THEN RETURN C1_cca2_2; END IF; IF i = 2 THEN RETURN C2_cca2_2; END IF; RETURN CX_cca2_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_1 IS BEGIN IF i = 0 THEN RETURN C0_cca3_1; END IF; IF i = 1 THEN RETURN C1_cca3_1; END IF; IF i = 2 THEN RETURN C2_cca3_1; END IF; RETURN CX_cca3_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_2 IS BEGIN IF i = 0 THEN RETURN C0_cca3_2; END IF; IF i = 1 THEN RETURN C1_cca3_2; END IF; IF i = 2 THEN RETURN C2_cca3_2; END IF; RETURN CX_cca3_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_1 IS BEGIN IF i = 0 THEN RETURN C0_cmre_1; END IF; IF i = 1 THEN RETURN C1_cmre_1; END IF; IF i = 2 THEN RETURN C2_cmre_1; END IF; RETURN CX_cmre_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_2 IS BEGIN IF i = 0 THEN RETURN C0_cmre_2; END IF; IF i = 1 THEN RETURN C1_cmre_2; END IF; IF i = 2 THEN RETURN C2_cmre_2; END IF; RETURN CX_cmre_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_7 IS BEGIN IF i = 0 THEN RETURN C0_cca1_7; END IF; IF i = 1 THEN RETURN C1_cca1_7; END IF; IF i = 2 THEN RETURN C2_cca1_7; END IF; RETURN CX_cca1_7; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_3 IS BEGIN IF i = 0 THEN RETURN C0_cmre_3; END IF; IF i = 1 THEN RETURN C1_cmre_3; END IF; IF i = 2 THEN RETURN C2_cmre_3; END IF; RETURN CX_cmre_3; END; -- -- FUNCTION val_i ( i : st_scl1 ) RETURN INTEGER IS BEGIN IF i = C0_scl1 THEN RETURN 0; END IF; IF i = C1_scl1 THEN RETURN 1; END IF; IF i = C2_scl1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : TIME ) RETURN INTEGER IS BEGIN IF i = C0_scl2 THEN RETURN 0; END IF; IF i = C1_scl2 THEN RETURN 1; END IF; IF i = C2_scl2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : st_scl3 ) RETURN INTEGER IS BEGIN IF i = C0_scl3 THEN RETURN 0; END IF; IF i = C1_scl3 THEN RETURN 1; END IF; IF i = C2_scl3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : st_scl4 ) RETURN INTEGER IS BEGIN IF i = C0_scl4 THEN RETURN 0; END IF; IF i = C1_scl4 THEN RETURN 1; END IF; IF i = C2_scl4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_scre_1 ) RETURN INTEGER IS BEGIN IF i = C0_scre_1 THEN RETURN 0; END IF; IF i = C1_scre_1 THEN RETURN 1; END IF; IF i = C2_scre_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_1 THEN RETURN 0; END IF; IF i = C1_csa1_1 THEN RETURN 1; END IF; IF i = C2_csa1_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_2 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_2 THEN RETURN 0; END IF; IF i = C1_csa1_2 THEN RETURN 1; END IF; IF i = C2_csa1_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_3 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_3 THEN RETURN 0; END IF; IF i = C1_csa1_3 THEN RETURN 1; END IF; IF i = C2_csa1_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_4 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_4 THEN RETURN 0; END IF; IF i = C1_csa1_4 THEN RETURN 1; END IF; IF i = C2_csa1_4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa2_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa2_1 THEN RETURN 0; END IF; IF i = C1_csa2_1 THEN RETURN 1; END IF; IF i = C2_csa2_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa3_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa3_1 THEN RETURN 0; END IF; IF i = C1_csa3_1 THEN RETURN 1; END IF; IF i = C2_csa3_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa4_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa4_1 THEN RETURN 0; END IF; IF i = C1_csa4_1 THEN RETURN 1; END IF; IF i = C2_csa4_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_1 THEN RETURN 0; END IF; IF i = C1_cca1_1 THEN RETURN 1; END IF; IF i = C2_cca1_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_2 THEN RETURN 0; END IF; IF i = C1_cca1_2 THEN RETURN 1; END IF; IF i = C2_cca1_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_3 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_3 THEN RETURN 0; END IF; IF i = C1_cca1_3 THEN RETURN 1; END IF; IF i = C2_cca1_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_4 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_4 THEN RETURN 0; END IF; IF i = C1_cca1_4 THEN RETURN 1; END IF; IF i = C2_cca1_4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca2_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca2_1 THEN RETURN 0; END IF; IF i = C1_cca2_1 THEN RETURN 1; END IF; IF i = C2_cca2_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca2_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca2_2 THEN RETURN 0; END IF; IF i = C1_cca2_2 THEN RETURN 1; END IF; IF i = C2_cca2_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca3_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca3_1 THEN RETURN 0; END IF; IF i = C1_cca3_1 THEN RETURN 1; END IF; IF i = C2_cca3_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca3_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca3_2 THEN RETURN 0; END IF; IF i = C1_cca3_2 THEN RETURN 1; END IF; IF i = C2_cca3_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_1 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_1 THEN RETURN 0; END IF; IF i = C1_cmre_1 THEN RETURN 1; END IF; IF i = C2_cmre_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_2 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_2 THEN RETURN 0; END IF; IF i = C1_cmre_2 THEN RETURN 1; END IF; IF i = C2_cmre_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_7 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_7 THEN RETURN 0; END IF; IF i = C1_cca1_7 THEN RETURN 1; END IF; IF i = C2_cca1_7 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_3 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_3 THEN RETURN 0; END IF; IF i = C1_cmre_3 THEN RETURN 1; END IF; IF i = C2_cmre_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_s ( i : st_scl1 ) RETURN STRING IS BEGIN IF i = C0_scl1 THEN RETURN "C0_scl1"; END IF; IF i = C1_scl1 THEN RETURN "C1_scl1"; END IF; IF i = C2_scl1 THEN RETURN "C2_scl1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : TIME ) RETURN STRING IS BEGIN IF i = C0_scl2 THEN RETURN "C0_scl2"; END IF; IF i = C1_scl2 THEN RETURN "C1_scl2"; END IF; IF i = C2_scl2 THEN RETURN "C2_scl2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : st_scl3 ) RETURN STRING IS BEGIN IF i = C0_scl3 THEN RETURN "C0_scl3"; END IF; IF i = C1_scl3 THEN RETURN "C1_scl3"; END IF; IF i = C2_scl3 THEN RETURN "C2_scl3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : st_scl4 ) RETURN STRING IS BEGIN IF i = C0_scl4 THEN RETURN "C0_scl4"; END IF; IF i = C1_scl4 THEN RETURN "C1_scl4"; END IF; IF i = C2_scl4 THEN RETURN "C2_scl4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_scre_1 ) RETURN STRING IS BEGIN IF i = C0_scre_1 THEN RETURN "C0_scre_1"; END IF; IF i = C1_scre_1 THEN RETURN "C1_scre_1"; END IF; IF i = C2_scre_1 THEN RETURN "C2_scre_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_1 ) RETURN STRING IS BEGIN IF i = C0_csa1_1 THEN RETURN "C0_csa1_1"; END IF; IF i = C1_csa1_1 THEN RETURN "C1_csa1_1"; END IF; IF i = C2_csa1_1 THEN RETURN "C2_csa1_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_2 ) RETURN STRING IS BEGIN IF i = C0_csa1_2 THEN RETURN "C0_csa1_2"; END IF; IF i = C1_csa1_2 THEN RETURN "C1_csa1_2"; END IF; IF i = C2_csa1_2 THEN RETURN "C2_csa1_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_3 ) RETURN STRING IS BEGIN IF i = C0_csa1_3 THEN RETURN "C0_csa1_3"; END IF; IF i = C1_csa1_3 THEN RETURN "C1_csa1_3"; END IF; IF i = C2_csa1_3 THEN RETURN "C2_csa1_3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_4 ) RETURN STRING IS BEGIN IF i = C0_csa1_4 THEN RETURN "C0_csa1_4"; END IF; IF i = C1_csa1_4 THEN RETURN "C1_csa1_4"; END IF; IF i = C2_csa1_4 THEN RETURN "C2_csa1_4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa2_1 ) RETURN STRING IS BEGIN IF i = C0_csa2_1 THEN RETURN "C0_csa2_1"; END IF; IF i = C1_csa2_1 THEN RETURN "C1_csa2_1"; END IF; IF i = C2_csa2_1 THEN RETURN "C2_csa2_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa3_1 ) RETURN STRING IS BEGIN IF i = C0_csa3_1 THEN RETURN "C0_csa3_1"; END IF; IF i = C1_csa3_1 THEN RETURN "C1_csa3_1"; END IF; IF i = C2_csa3_1 THEN RETURN "C2_csa3_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa4_1 ) RETURN STRING IS BEGIN IF i = C0_csa4_1 THEN RETURN "C0_csa4_1"; END IF; IF i = C1_csa4_1 THEN RETURN "C1_csa4_1"; END IF; IF i = C2_csa4_1 THEN RETURN "C2_csa4_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_1 ) RETURN STRING IS BEGIN IF i = C0_cca1_1 THEN RETURN "C0_cca1_1"; END IF; IF i = C1_cca1_1 THEN RETURN "C1_cca1_1"; END IF; IF i = C2_cca1_1 THEN RETURN "C2_cca1_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_2 ) RETURN STRING IS BEGIN IF i = C0_cca1_2 THEN RETURN "C0_cca1_2"; END IF; IF i = C1_cca1_2 THEN RETURN "C1_cca1_2"; END IF; IF i = C2_cca1_2 THEN RETURN "C2_cca1_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_3 ) RETURN STRING IS BEGIN IF i = C0_cca1_3 THEN RETURN "C0_cca1_3"; END IF; IF i = C1_cca1_3 THEN RETURN "C1_cca1_3"; END IF; IF i = C2_cca1_3 THEN RETURN "C2_cca1_3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_4 ) RETURN STRING IS BEGIN IF i = C0_cca1_4 THEN RETURN "C0_cca1_4"; END IF; IF i = C1_cca1_4 THEN RETURN "C1_cca1_4"; END IF; IF i = C2_cca1_4 THEN RETURN "C2_cca1_4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca2_1 ) RETURN STRING IS BEGIN IF i = C0_cca2_1 THEN RETURN "C0_cca2_1"; END IF; IF i = C1_cca2_1 THEN RETURN "C1_cca2_1"; END IF; IF i = C2_cca2_1 THEN RETURN "C2_cca2_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca2_2 ) RETURN STRING IS BEGIN IF i = C0_cca2_2 THEN RETURN "C0_cca2_2"; END IF; IF i = C1_cca2_2 THEN RETURN "C1_cca2_2"; END IF; IF i = C2_cca2_2 THEN RETURN "C2_cca2_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca3_1 ) RETURN STRING IS BEGIN IF i = C0_cca3_1 THEN RETURN "C0_cca3_1"; END IF; IF i = C1_cca3_1 THEN RETURN "C1_cca3_1"; END IF; IF i = C2_cca3_1 THEN RETURN "C2_cca3_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca3_2 ) RETURN STRING IS BEGIN IF i = C0_cca3_2 THEN RETURN "C0_cca3_2"; END IF; IF i = C1_cca3_2 THEN RETURN "C1_cca3_2"; END IF; IF i = C2_cca3_2 THEN RETURN "C2_cca3_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_1 ) RETURN STRING IS BEGIN IF i = C0_cmre_1 THEN RETURN "C0_cmre_1"; END IF; IF i = C1_cmre_1 THEN RETURN "C1_cmre_1"; END IF; IF i = C2_cmre_1 THEN RETURN "C2_cmre_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_2 ) RETURN STRING IS BEGIN IF i = C0_cmre_2 THEN RETURN "C0_cmre_2"; END IF; IF i = C1_cmre_2 THEN RETURN "C1_cmre_2"; END IF; IF i = C2_cmre_2 THEN RETURN "C2_cmre_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_7 ) RETURN STRING IS BEGIN IF i = C0_cca1_7 THEN RETURN "C0_cca1_7"; END IF; IF i = C1_cca1_7 THEN RETURN "C1_cca1_7"; END IF; IF i = C2_cca1_7 THEN RETURN "C2_cca1_7"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_3 ) RETURN STRING IS BEGIN IF i = C0_cmre_3 THEN RETURN "C0_cmre_3"; END IF; IF i = C1_cmre_3 THEN RETURN "C1_cmre_3"; END IF; IF i = C2_cmre_3 THEN RETURN "C2_cmre_3"; END IF; RETURN "UNKNOWN"; END; END c03s03b00x00p03n04i00520pkg; USE work.c03s03b00x00p03n04i00520pkg.ALL; ENTITY vests1 IS END vests1; ARCHITECTURE c03s03b00x00p03n04i00520arch OF vests1 IS -- -- Access type declarations -- TYPE at_usa1_1 IS ACCESS t_usa1_1 ; TYPE at_usa1_2 IS ACCESS t_usa1_2 ; TYPE at_usa1_3 IS ACCESS t_usa1_3 ; TYPE at_usa1_4 IS ACCESS t_usa1_4 ; TYPE at_csa1_1 IS ACCESS t_csa1_1 ; TYPE at_csa1_2 IS ACCESS t_csa1_2 ; TYPE at_csa1_3 IS ACCESS t_csa1_3 ; TYPE at_csa1_4 IS ACCESS t_csa1_4 ; -- -- BEGIN TESTING: PROCESS -- -- ACCESS VARIABLE declarations -- VARIABLE AV0_usa1_1 : at_usa1_1 ; VARIABLE AV2_usa1_1 : at_usa1_1 ; VARIABLE AV0_usa1_2 : at_usa1_2 ; VARIABLE AV2_usa1_2 : at_usa1_2 ; VARIABLE AV0_usa1_3 : at_usa1_3 ; VARIABLE AV2_usa1_3 : at_usa1_3 ; VARIABLE AV0_usa1_4 : at_usa1_4 ; VARIABLE AV2_usa1_4 : at_usa1_4 ; VARIABLE AV0_csa1_1 : at_csa1_1 ; VARIABLE AV2_csa1_1 : at_csa1_1 ; VARIABLE AV0_csa1_2 : at_csa1_2 ; VARIABLE AV2_csa1_2 : at_csa1_2 ; VARIABLE AV0_csa1_3 : at_csa1_3 ; VARIABLE AV2_csa1_3 : at_csa1_3 ; VARIABLE AV0_csa1_4 : at_csa1_4 ; VARIABLE AV2_csa1_4 : at_csa1_4 ; -- -- BEGIN -- -- Allocation of access values -- AV0_usa1_1 := NEW t_usa1_1 (st_ind1 ) ; AV0_usa1_2 := NEW t_usa1_2 (st_ind2 ) ; AV0_usa1_3 := NEW t_usa1_3 (st_ind3 ) ; AV0_usa1_4 := NEW t_usa1_4 (st_ind4 ) ; AV0_csa1_1 := NEW t_csa1_1 ; AV0_csa1_2 := NEW t_csa1_2 ; AV0_csa1_3 := NEW t_csa1_3 ; AV0_csa1_4 := NEW t_csa1_4 ; --- AV2_usa1_1 := NEW t_usa1_1 ' ( C2_csa1_1 ) ; AV2_usa1_2 := NEW t_usa1_2 ' ( C2_csa1_2 ) ; AV2_usa1_3 := NEW t_usa1_3 ' ( C2_csa1_3 ) ; AV2_usa1_4 := NEW t_usa1_4 ' ( C2_csa1_4 ) ; AV2_csa1_1 := NEW t_csa1_1 ' ( C2_csa1_1 ) ; AV2_csa1_2 := NEW t_csa1_2 ' ( C2_csa1_2 ) ; AV2_csa1_3 := NEW t_csa1_3 ' ( C2_csa1_3 ) ; AV2_csa1_4 := NEW t_csa1_4 ' ( C2_csa1_4 ) ; -- -- ASSERT AV0_usa1_1.all = C0_csa1_1 REPORT "Improper initialization of AV0_usa1_1" SEVERITY FAILURE; ASSERT AV2_usa1_1.all = C2_csa1_1 REPORT "Improper initialization of AV2_usa1_1" SEVERITY FAILURE; ASSERT AV0_usa1_2.all = C0_csa1_2 REPORT "Improper initialization of AV0_usa1_2" SEVERITY FAILURE; ASSERT AV2_usa1_2.all = C2_csa1_2 REPORT "Improper initialization of AV2_usa1_2" SEVERITY FAILURE; ASSERT AV0_usa1_3.all = C0_csa1_3 REPORT "Improper initialization of AV0_usa1_3" SEVERITY FAILURE; ASSERT AV2_usa1_3.all = C2_csa1_3 REPORT "Improper initialization of AV2_usa1_3" SEVERITY FAILURE; ASSERT AV0_usa1_4.all = C0_csa1_4 REPORT "Improper initialization of AV0_usa1_4" SEVERITY FAILURE; ASSERT AV2_usa1_4.all = C2_csa1_4 REPORT "Improper initialization of AV2_usa1_4" SEVERITY FAILURE; ASSERT AV0_csa1_1.all = C0_csa1_1 REPORT "Improper initialization of AV0_csa1_1" SEVERITY FAILURE; ASSERT AV2_csa1_1.all = C2_csa1_1 REPORT "Improper initialization of AV2_csa1_1" SEVERITY FAILURE; ASSERT AV0_csa1_2.all = C0_csa1_2 REPORT "Improper initialization of AV0_csa1_2" SEVERITY FAILURE; ASSERT AV2_csa1_2.all = C2_csa1_2 REPORT "Improper initialization of AV2_csa1_2" SEVERITY FAILURE; ASSERT AV0_csa1_3.all = C0_csa1_3 REPORT "Improper initialization of AV0_csa1_3" SEVERITY FAILURE; ASSERT AV2_csa1_3.all = C2_csa1_3 REPORT "Improper initialization of AV2_csa1_3" SEVERITY FAILURE; ASSERT AV0_csa1_4.all = C0_csa1_4 REPORT "Improper initialization of AV0_csa1_4" SEVERITY FAILURE; ASSERT AV2_csa1_4.all = C2_csa1_4 REPORT "Improper initialization of AV2_csa1_4" SEVERITY FAILURE; -- -- assert NOT( ( AV0_usa1_1.all = C0_csa1_1 ) and ( AV2_usa1_1.all = C2_csa1_1 ) and ( AV0_usa1_2.all = C0_csa1_2 ) and ( AV2_usa1_2.all = C2_csa1_2 ) and ( AV0_usa1_3.all = C0_csa1_3 ) and ( AV2_usa1_3.all = C2_csa1_3 ) and ( AV0_usa1_4.all = C0_csa1_4 ) and ( AV2_usa1_4.all = C2_csa1_4 ) and ( AV0_csa1_1.all = C0_csa1_1 ) and ( AV2_csa1_1.all = C2_csa1_1 ) and ( AV0_csa1_2.all = C0_csa1_2 ) and ( AV2_csa1_2.all = C2_csa1_2 ) and ( AV0_csa1_3.all = C0_csa1_3 ) and ( AV2_csa1_3.all = C2_csa1_3 ) and ( AV0_csa1_4.all = C0_csa1_4 ) and ( AV2_csa1_4.all = C2_csa1_4 )) report "***PASSED TEST: c03s03b00x00p03n04i00520" severity NOTE; assert ( ( AV0_usa1_1.all = C0_csa1_1 ) and ( AV2_usa1_1.all = C2_csa1_1 ) and ( AV0_usa1_2.all = C0_csa1_2 ) and ( AV2_usa1_2.all = C2_csa1_2 ) and ( AV0_usa1_3.all = C0_csa1_3 ) and ( AV2_usa1_3.all = C2_csa1_3 ) and ( AV0_usa1_4.all = C0_csa1_4 ) and ( AV2_usa1_4.all = C2_csa1_4 ) and ( AV0_csa1_1.all = C0_csa1_1 ) and ( AV2_csa1_1.all = C2_csa1_1 ) and ( AV0_csa1_2.all = C0_csa1_2 ) and ( AV2_csa1_2.all = C2_csa1_2 ) and ( AV0_csa1_3.all = C0_csa1_3 ) and ( AV2_csa1_3.all = C2_csa1_3 ) and ( AV0_csa1_4.all = C0_csa1_4 ) and ( AV2_csa1_4.all = C2_csa1_4 )) report "***FAILED TEST: c03s03b00x00p03n04i00520 - Each access value designates an object of the subtype defined by the subtype indication of the access type definition." severity ERROR; wait; END PROCESS TESTING; END c03s03b00x00p03n04i00520arch; nvc-r1.17.1/test/regress/vests10.vhd000066400000000000000000000037421504111170000172060ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc80.vhd,v 1.2 2001-10-26 16:30:00 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests10 IS END vests10; ARCHITECTURE c04s03b01x02p12n01i00080arch OF vests10 IS type arrbit is array (1 to 3) of bit; type comp_vect is array (positive range <>) of arrbit; function F(BB: comp_vect) return arrbit is begin return "111"; end; signal X : F arrbit ; signal P : bit := '1'; signal Q : bit := '1'; signal R : bit := '1'; BEGIN TESTING: PROCESS(P,Q,R) BEGIN X(1) <= P; -- No_failure_here X(2) <= Q; -- No_failure_here X(3) <= R; -- No_failure_here assert NOT(X="111") report "***PASSED TEST: c04s03b01x02p12n01i00080" severity NOTE; assert (X="111") report "***FAILED TEST:c04s03b01x02p12n01i00080 - All of the subelements of the signal should have a driver in a process." severity ERROR; END PROCESS TESTING; END c04s03b01x02p12n01i00080arch; nvc-r1.17.1/test/regress/vests11.vhd000066400000000000000000000132701504111170000172040ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc485.vhd,v 1.2 2001-10-26 16:29:55 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c03s02b01x01p19n01i00485ent_a IS PORT ( F1: OUT integer := 3; F2: INOUT integer := 3; F3: IN integer ); END c03s02b01x01p19n01i00485ent_a; architecture c03s02b01x01p19n01i00485ent_a of c03s02b01x01p19n01i00485ent_a is begin process begin wait for 1 ns; assert F3= 3 report"wrong initialization of F3 through type conversion" severity failure; assert F2 = 3 report"wrong initialization of F2 through type conversion" severity failure; wait; end process; end; ENTITY vests11 IS END vests11; ARCHITECTURE c03s02b01x01p19n01i00485arch OF vests11 IS type column is range 1 to 2; type row is range 1 to 8; type s2boolean_cons_vector is array (row,column) of boolean; type s2bit_cons_vector is array (row,column) of bit; type s2char_cons_vector is array (row,column) of character; type s2severity_level_cons_vector is array (row,column) of severity_level; type s2integer_cons_vector is array (row,column) of integer; type s2real_cons_vector is array (row,column) of real; type s2time_cons_vector is array (row,column) of time; type s2natural_cons_vector is array (row,column) of natural; type s2positive_cons_vector is array (row,column) of positive; type record_2cons_array is record a:s2boolean_cons_vector; b:s2bit_cons_vector; c:s2char_cons_vector; d:s2severity_level_cons_vector; e:s2integer_cons_vector; f:s2real_cons_vector; g:s2time_cons_vector; h:s2natural_cons_vector; i:s2positive_cons_vector; end record; constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; constant C41 : s2boolean_cons_vector := (others => (others => C1)); constant C42 : s2bit_cons_vector := (others => (others => C2)); constant C43 : s2char_cons_vector := (others => (others => C3)); constant C44 : s2severity_level_cons_vector := (others => (others => C4)); constant C45 : s2integer_cons_vector := (others => (others => C5)); constant C46 : s2real_cons_vector := (others => (others => C6)); constant C47 : s2time_cons_vector := (others => (others => C7)); constant C48 : s2natural_cons_vector := (others => (others => C8)); constant C49 : s2positive_cons_vector := (others => (others => C9)); constant C52 : record_2cons_array := (C41,C42,C43,C44,C45,C46,C47,C48,C49); type array_rec_2cons is array (integer range <>) of record_2cons_array; function resolution12(i:in array_rec_2cons) return record_2cons_array is variable temp : record_2cons_array := C52; begin return temp; end resolution12; subtype array_rec_2cons_state is resolution12 record_2cons_array; constant C66 : array_rec_2cons_state:= C52; function complex_scalar(s : array_rec_2cons_state) return integer is begin return 3; end complex_scalar; function scalar_complex(s : integer) return array_rec_2cons_state is begin return C66; end scalar_complex; component c03s02b01x01p19n01i00485ent_a1 PORT ( F1: OUT integer; F2: INOUT integer; F3: IN integer ); end component; for T1 : c03s02b01x01p19n01i00485ent_a1 use entity work.c03s02b01x01p19n01i00485ent_a(c03s02b01x01p19n01i00485ent_a); signal S1 : array_rec_2cons_state; signal S2 : array_rec_2cons_state; signal S3 : array_rec_2cons_state:= C66; BEGIN T1: c03s02b01x01p19n01i00485ent_a1 port map ( scalar_complex(F1) => S1, scalar_complex(F2) => complex_scalar(S2), F3 => complex_scalar(S3) ); TESTING: PROCESS BEGIN wait for 1 ns; assert NOT((S1 = C66) and (S2 = C66)) report "***PASSED TEST: c03s02b01x01p19n01i00485" severity NOTE; assert ((S1 = C66) and (S2 = C66)) report "***FAILED TEST: c03s02b01x01p19n01i00485 - For an interface object of mode out, buffer, inout, or linkage, if the formal part includes a type conversion function, then the parameter subtype of that function must be a constrained array subtype." severity ERROR; wait; END PROCESS TESTING; END c03s02b01x01p19n01i00485arch; nvc-r1.17.1/test/regress/vests12.vhd000066400000000000000000001577321504111170000172210ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc754.vhd,v 1.2 2001-10-26 16:30:00 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s01b01x01p05n02i00754pkg is subtype hi_to_low_range is integer range 0 to 7; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; subtype boolean_vector_st is boolean_vector(0 to 15); subtype severity_level_vector_st is severity_level_vector(0 to 15); subtype integer_vector_st is integer_vector(0 to 15); subtype real_vector_st is real_vector(0 to 15); subtype time_vector_st is time_vector(0 to 15); subtype natural_vector_st is natural_vector(0 to 15); subtype positive_vector_st is positive_vector(0 to 15); type boolean_cons_vector is array (15 downto 0) of boolean; type severity_level_cons_vector is array (15 downto 0) of severity_level; type integer_cons_vector is array (15 downto 0) of integer; type real_cons_vector is array (15 downto 0) of real; type time_cons_vector is array (15 downto 0) of time; type natural_cons_vector is array (15 downto 0) of natural; type positive_cons_vector is array (15 downto 0) of positive; type boolean_cons_vectorofvector is array (0 to 15) of boolean_cons_vector; type severity_level_cons_vectorofvector is array (0 to 15) of severity_level_cons_vector; type integer_cons_vectorofvector is array (0 to 15) of integer_cons_vector ; type real_cons_vectorofvector is array (0 to 15) of real_cons_vector; type time_cons_vectorofvector is array (0 to 15) of time_cons_vector; type natural_cons_vectorofvector is array (0 to 15) of natural_cons_vector; type positive_cons_vectorofvector is array (0 to 15) of positive_cons_vector; type record_std_package is record a: boolean; b: bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; j:string(1 to 7); k:bit_vector(0 to 3); end record; type record_array_st is record a:boolean_vector_st; b:severity_level_vector_st; c:integer_vector_st; d:real_vector_st; e:time_vector_st; f:natural_vector_st; g:positive_vector_st; end record; type record_cons_array is record a:boolean_cons_vector; b:severity_level_cons_vector; c:integer_cons_vector; d:real_cons_vector; e:time_cons_vector; f:natural_cons_vector; g:positive_cons_vector; end record; type record_cons_arrayofarray is record a:boolean_cons_vectorofvector; b:severity_level_cons_vectorofvector; c:integer_cons_vectorofvector; d:real_cons_vectorofvector; e:time_cons_vectorofvector; f:natural_cons_vectorofvector; g:positive_cons_vectorofvector; end record; type record_array_new is record a:boolean_vector(0 to 15); b:severity_level_vector(0 to 15); c:integer_vector(0 to 15); d:real_vector(0 to 15); e:time_vector(0 to 15); f:natural_vector(0 to 15); g:positive_vector(0 to 15); end record; type record_of_records is record a: record_std_package; c: record_cons_array; g: record_cons_arrayofarray; i: record_array_st; j: record_array_new; end record; subtype boolean_vector_range is boolean_vector(hi_to_low_range); subtype severity_level_vector_range is severity_level_vector(hi_to_low_range); subtype integer_vector_range is integer_vector(hi_to_low_range); subtype real_vector_range is real_vector(hi_to_low_range); subtype time_vector_range is time_vector(hi_to_low_range); subtype natural_vector_range is natural_vector(hi_to_low_range); subtype positive_vector_range is positive_vector(hi_to_low_range); type array_rec_std is array (integer range <>) of record_std_package; type array_rec_cons is array (integer range <>) of record_cons_array; type array_rec_rec is array (integer range <>) of record_of_records; subtype array_rec_std_st is array_rec_std (hi_to_low_range); subtype array_rec_cons_st is array_rec_cons (hi_to_low_range); subtype array_rec_rec_st is array_rec_rec (hi_to_low_range); type record_of_arr_of_record is record a: array_rec_std(0 to 7); b: array_rec_cons(0 to 7); c: array_rec_rec(0 to 7); end record; type current is range -2147483647 to +2147483647 units nA; uA = 1000 nA; mA = 1000 uA; A = 1000 mA; end units; type current_vector is array (natural range <>) of current; subtype current_vector_range is current_vector(hi_to_low_range); type resistance is range -2147483647 to +2147483647 units uOhm; mOhm = 1000 uOhm; Ohm = 1000 mOhm; KOhm = 1000 Ohm; end units; type resistance_vector is array (natural range <>) of resistance; subtype resistance_vector_range is resistance_vector(hi_to_low_range); type byte is array(0 to 7) of bit; subtype word is bit_vector(0 to 15); --constrained array constant size :integer := 7; type primary_memory is array(0 to size) of word; --array of an array type primary_memory_module is --record with field record --as an array enable:bit; memory_number:primary_memory; end record; type whole_memory is array(0 to size) of primary_memory_module; --array of a complex record subtype delay is integer range 1 to 10; constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; constant C10 : string := "shishir"; constant C11 : bit_vector := B"0011"; constant C12 : boolean_vector := (C1,false); constant C13 : severity_level_vector := (C4,error); constant C14 : integer_vector := (1,2,3,4); constant C15 : real_vector := (1.0,2.0,C6,4.0); constant C16 : time_vector := (1 ns, 2 ns,C7, 4 ns); constant C17 : natural_vector := (1,2,3,4); constant C18 : positive_vector := (1,2,3,4); constant C19 : boolean_cons_vector := (others => C1); constant C20 : severity_level_cons_vector := (others => C4); constant C21 : integer_cons_vector := (others => C5); constant C22 : real_cons_vector := (others => C6); constant C23 : time_cons_vector := (others => C7); constant C24 : natural_cons_vector := (others => C8); constant C25 : positive_cons_vector := (others => C9); constant C26 : boolean_cons_vectorofvector := (others => (others => C1)); constant C27 : severity_level_cons_vectorofvector := (others => (others => C4)); constant C28 : integer_cons_vectorofvector := (others => (others => C5)); constant C29 : real_cons_vectorofvector := (others => (others => C6)); constant C30 : time_cons_vectorofvector := (others => (others => C7)); constant C31 : natural_cons_vectorofvector := (others => (others => C8)); constant C32 : positive_cons_vectorofvector := (others => (others => C9)); constant C50 : record_std_package := (C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11); constant C51 : record_cons_array := (C19,C20,C21,C22,C23,C24,C25); constant C53 : record_cons_arrayofarray := (C26,C27,C28,C29,C30,C31,C32); constant C70 : boolean_vector_st :=(others => C1); constant C71 : severity_level_vector_st:= (others => C4); constant C72 : integer_vector_st:=(others => C5); constant C73 : real_vector_st:=(others => C6); constant C74 : time_vector_st:=(others => C7); constant C75 : natural_vector_st:=(others => C8); constant C76 : positive_vector_st:=(others => C9); constant C77 : record_array_st := (C70,C71,C72,C73,C74,C75,C76); constant C54a : record_array_st := (C70,C71,C72,C73,C74,C75,C76); constant C54b : record_array_new:= (C70,C71,C72,C73,C74,C75,C76); constant C55 : record_of_records := (C50,C51,C53,C77,C54b); constant C60 : byte := (others => '0'); constant C61 : word := (others =>'0' ); constant C64 : primary_memory := (others => C61); constant C65 : primary_memory_module := ('1',C64); constant C66 : whole_memory := (others => C65); constant C67 : current := 1 A; constant C68 : resistance := 1 Ohm; constant C69 : delay := 2; constant C78 : boolean_vector_range := (others => C1); constant C79 : severity_level_vector_range := (others => C4) ; constant C80 : integer_vector_range :=(others => C5) ; constant C81 : real_vector_range :=(others => C6); constant C82 : time_vector_range :=(others => C7); constant C83 : natural_vector_range :=(others => C8); constant C84 : positive_vector_range :=(others => C9); constant C85 : array_rec_std(0 to 7) :=(others => C50) ; constant C86 : array_rec_cons (0 to 7) :=(others => C51); constant C88 : array_rec_rec(0 to 7) :=(others => C55); constant C102 : record_of_arr_of_record:= (C85,C86,C88); end c01s01b01x01p05n02i00754pkg; use work.c01s01b01x01p05n02i00754pkg.all; ENTITY vests12 IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15; C1 : boolean := true; C2 : bit := '1'; C3 : character := 's'; C4 : severity_level := note; C5 : integer := 3; C6 : real := 3.0; C7 : time := 3 ns; C8 : natural := 1; C9 : positive := 1; C10 : string := "shishir"; C11 : bit_vector := B"0011" ); port( S1 : boolean_vector(zero to fifteen); S2 : severity_level_vector(zero to fifteen); S3 : integer_vector(zero to fifteen); S4 : real_vector(zero to fifteen); S5 : time_vector (zero to fifteen); S6 : natural_vector(zero to fifteen); S7 : positive_vector(zero to fifteen); S8 : boolean_cons_vector; S9 : severity_level_cons_vector ; S10 : integer_cons_vector; S11 : real_cons_vector; S12 : time_cons_vector ; S13 : natural_cons_vector ; S14 : positive_cons_vector ; S15 : boolean_cons_vectorofvector; S16 : severity_level_cons_vectorofvector; S17 : integer_cons_vectorofvector; S18 : real_cons_vectorofvector; S19 : time_cons_vectorofvector; S20 : natural_cons_vectorofvector; S21 : positive_cons_vectorofvector; S22 : record_std_package; S23 : record_cons_array; S24 : record_cons_arrayofarray ; S25 : boolean_vector_st; S26 : severity_level_vector_st; S27 : integer_vector_st; S28 : real_vector_st; S29 : time_vector_st; S30 : natural_vector_st; S31 : positive_vector_st; S32 : record_array_st; S33 : record_array_st; S34 : record_array_new; S35 : record_of_records; S36 : byte; S37 : word; S38 : current_vector(zero to three); S39 : resistance_vector(zero to three); S40 : delay; S41 : boolean_vector_range; S42 : severity_level_vector_range ; S43 : integer_vector_range ; S44 : real_vector_range ; S45 : time_vector_range ; S46 : natural_vector_range ; S47 : positive_vector_range ; S48 : array_rec_std(zero to seven); S49 : array_rec_cons(zero to seven); S50 : array_rec_rec(zero to seven); S51 : record_of_arr_of_record ); END vests12; ARCHITECTURE c01s01b01x01p05n02i00754arch OF vests12 IS BEGIN assert (S1'left = 0) report " boolean_vector(zero to fifteen) error in the left generic value" severity error; assert (S2'left = 0) report " severity_level_vector(zero to fifteen) error in the left generic value" severity error; assert (S3'left = 0) report " integer_vector(zero to fifteen) error in the left generic value" severity error; assert (S4'left = 0) report " real_vector(zero to fifteen) error in the left generic value" severity error; assert (S5'left = 0) report " time_vector (zero to fifteen) error in the left generic value" severity error; assert (S6'left = 0) report " natural_vector(zero to fifteen) error in the left generic value" severity error; assert (S7'left = 0) report " positive_vector(zero to fifteen) error in the left generic value" severity error; assert (S8'left = 15) report " boolean_cons_vector error in the left generic value" severity error; assert (S9'left = 15) report " severity_level_cons_vector error in the left generic value" severity error; assert (S10'left = 15) report " integer_cons_vector error in the left generic value" severity error; assert (S11'left = 15) report " real_cons_vector error in the left generic value" severity error; assert (S12'left = 15) report " time_cons_vector error in the left generic value" severity error; assert (S13'left = 15) report " natural_cons_vector error in the left generic value" severity error; assert (S14'left = 15) report " positive_cons_vector error in the left generic value" severity error; assert (S15'left = 0) report " boolean_cons_vectorofvector error in the left generic value" severity error; assert (S16'left = 0) report " severity_level_cons_vectorofvector error in the left generic value" severity error; assert (S17'left = 0) report " integer_cons_vectorofvector error in the left generic value" severity error; assert (S18'left = 0) report " real_cons_vectorofvector error in the left generic value" severity error; assert (S19'left = 0) report " time_cons_vectorofvector error in the left generic value" severity error; assert (S20'left = 0) report " natural_cons_vectorofvector error in the left generic value" severity error; assert (S21'left = 0) report " positive_cons_vectorofvector error in the left generic value" severity error; assert (S22.j'left = 1) report " record_std_package error in the left generic value" severity error; assert (S22.k'left = 0) report " record_std_package error in the left generic value" severity error; assert (S23.a'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.b'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.c'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.d'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.e'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.f'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S23.g'left = 15) report " record_cons_array error in the left generic value" severity error; assert (S24.a'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.b'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.c'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.d'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.e'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.f'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S24.g'left = 0) report " record_cons_arrayofarray error in the left generic value" severity error; assert (S25'left = 0) report " boolean_vector_st error in the left generic value" severity error; assert (S26'left = 0) report " severity_level_vector_st error in the left generic value" severity error; assert (S27'left = 0) report " integer_vector_st error in the left generic value" severity error; assert (S28'left = 0) report " real_vector_st error in the left generic value" severity error; assert (S29'left = 0) report " time_vector_st error in the left generic value" severity error; assert (S30'left = 0) report " natural_vector_st error in the left generic value" severity error; assert (S31'left = 0) report " positive_vector_st error in the left generic value" severity error; assert (S32.a'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.b'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.c'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.d'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.e'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.f'left = 0) report " record_array_st error in the left generic value" severity error; assert (S32.g'left = 0) report " record_array_st error in the left generic value" severity error; assert (S34.a'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.b'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.c'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.d'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.e'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.f'left = 0) report " record_array_new error in the left generic value" severity error; assert (S34.g'left = 0) report " record_array_new error in the left generic value" severity error; assert (S36'left = 0) report " byte error in the left generic value" severity error; assert (S37'left = 0) report " word error in the left generic value" severity error; assert (S38'left = 0) report " current_vector(zero to three) error in the left generic value" severity error; assert (S39'left = 0) report " resistance_vector(zero to three) error in the left generic value" severity error; --assert (S40'left = 1) report " delay error in the left generic value" severity error; assert (S41'left = 0) report " boolean_vector_range error in the left generic value" severity error; assert (S42'left = 0) report " severity_level_vector_range error in the left generic value" severity error; assert (S43'left = 0) report " integer_vector_range error in the left generic value" severity error; assert (S44'left = 0) report " real_vector_range error in the left generic value" severity error; assert (S45'left = 0) report " time_vector_range error in the left generic value" severity error; assert (S46'left = 0) report " natural_vector_range error in the left generic value" severity error; assert (S47'left = 0) report " positive_vector_range error in the left generic value" severity error; assert (S48'left = 0) report " array_rec_std(zero to seven) error in the left generic value" severity error; assert (S49'left = 0) report " array_rec_cons(zero to seven) error in the left generic value" severity error; assert (S50'left = 0) report " array_rec_rec(zero to seven) error in the left generic value" severity error; assert (S51.a'left = 0) report " record_of_arr_of_record error in the left generic value" severity error; assert (S51.b'left = 0) report " record_of_arr_of_record error in the left generic value" severity error; assert (S51.c'left = 0) report " record_of_arr_of_record error in the left generic value" severity error; assert (S1'right = 15) report " boolean_vector(zero to fifteen) error in the right generic value" severity error; assert (S2'right = 15) report " severity_level_vector(zero to fifteen) error in the right generic value" severity error; assert (S3'right = 15) report " integer_vector(zero to fifteen) error in the right generic value" severity error; assert (S4'right = 15) report " real_vector(zero to fifteen) error in the right generic value" severity error; assert (S5'right = 15) report " time_vector (zero to fifteen) error in the right generic value" severity error; assert (S6'right = 15) report " natural_vector(zero to fifteen) error in the right generic value" severity error; assert (S7'right = 15) report " positive_vector(zero to fifteen) error in the right generic value" severity error; assert (S8'right = 0) report " boolean_cons_vector error in the right generic value" severity error; assert (S9'right = 0) report " severity_level_cons_vector error in the right generic value" severity error; assert (S10'right = 0) report " integer_cons_vector error in the right generic value" severity error; assert (S11'right = 0) report " real_cons_vector error in the right generic value" severity error; assert (S12'right = 0) report " time_cons_vector error in the right generic value" severity error; assert (S13'right = 0) report " natural_cons_vector error in the right generic value" severity error; assert (S14'right = 0) report " positive_cons_vector error in the right generic value" severity error; assert (S15'right = 15) report " boolean_cons_vectorofvector error in the right generic value" severity error; assert (S16'right = 15) report " severity_level_cons_vectorofvector error in the right generic value" severity error; assert (S17'right = 15) report " integer_cons_vectorofvector error in the right generic value" severity error; assert (S18'right = 15) report " real_cons_vectorofvector error in the right generic value" severity error; assert (S19'right = 15) report " time_cons_vectorofvector error in the right generic value" severity error; assert (S20'right = 15) report " natural_cons_vectorofvector error in the right generic value" severity error; assert (S21'right = 15) report " positive_cons_vectorofvector error in the right generic value" severity error; assert (S22.j'right = 7) report " record_std_package error in the right generic value" severity error; assert (S22.k'right = 3) report " record_std_package error in the right generic value" severity error; assert (S23.a'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.b'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.c'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.d'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.e'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.f'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S23.g'right = 0) report " record_cons_array error in the right generic value" severity error; assert (S24.a'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.b'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.c'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.d'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.e'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.f'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S24.g'right = 15) report " record_cons_arrayofarray error in the right generic value" severity error; assert (S25'right = 15) report " boolean_vector_st error in the right generic value" severity error; assert (S26'right = 15) report " severity_level_vector_st error in the right generic value" severity error; assert (S27'right = 15) report " integer_vector_st error in the right generic value" severity error; assert (S28'right = 15) report " real_vector_st error in the right generic value" severity error; assert (S29'right = 15) report " time_vector_st error in the right generic value" severity error; assert (S30'right = 15) report " natural_vector_st error in the right generic value" severity error; assert (S31'right = 15) report " positive_vector_st error in the right generic value" severity error; assert (S32.a'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.b'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.c'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.d'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.e'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.f'right = 15) report " record_array_st error in the right generic value" severity error; assert (S32.g'right = 15) report " record_array_st error in the right generic value" severity error; assert (S34.a'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.b'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.c'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.d'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.e'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.f'right = 15) report " record_array_new error in the right generic value" severity error; assert (S34.g'right = 15) report " record_array_new error in the right generic value" severity error; assert (S36'right = 7) report " byte error in the right generic value" severity error; assert (S37'right = 15) report " word error in the right generic value" severity error; assert (S38'right = 3) report " current_vector(zero to three) error in the right generic value" severity error; assert (S39'right = 3) report " resistance_vector(zero to three) error in the right generic value" severity error; --assert (S40'right = 1) report " delay error in the right generic value" severity error; assert (S41'right = 7) report " boolean_vector_range error in the right generic value" severity error; assert (S42'right = 7) report " severity_level_vector_range error in the right generic value" severity error; assert (S43'right = 7) report " integer_vector_range error in the right generic value" severity error; assert (S44'right = 7) report " real_vector_range error in the right generic value" severity error; assert (S45'right = 7) report " time_vector_range error in the right generic value" severity error; assert (S46'right = 7) report " natural_vector_range error in the right generic value" severity error; assert (S47'right = 7) report " positive_vector_range error in the right generic value" severity error; assert (S48'right = 7) report " array_rec_std(zero to seven) error in the right generic value" severity error; assert (S49'right = 7) report " array_rec_cons(zero to seven) error in the right generic value" severity error; assert (S50'right = 7) report " array_rec_rec(zero to seven) error in the right generic value" severity error; assert (S51.a'right = 7) report " record_of_arr_of_record error in the right generic value" severity error; assert (S51.b'right = 7) report " record_of_arr_of_record error in the right generic value" severity error; assert (S51.c'right = 7) report " record_of_arr_of_record error in the right generic value" severity error; assert (S1'length = 16) report " boolean_vector(zero to fifteen) error in the length generic value" severity error; assert (S2'length = 16) report " severity_level_vector(zero to fifteen) error in the length generic value" severity error; assert (S3'length = 16) report " integer_vector(zero to fifteen) error in the length generic value" severity error; assert (S4'length = 16) report " real_vector(zero to fifteen) error in the length generic value" severity error; assert (S5'length = 16) report " time_vector (zero to fifteen) error in the length generic value" severity error; assert (S6'length = 16) report " natural_vector(zero to fifteen) error in the length generic value" severity error; assert (S7'length = 16) report " positive_vector(zero to fifteen) error in the length generic value" severity error; assert (S8'length = 16) report " boolean_cons_vector error in the length generic value" severity error; assert (S9'length = 16) report " severity_level_cons_vector error in the length generic value" severity error; assert (S10'length = 16) report " integer_cons_vector error in the length generic value" severity error; assert (S11'length = 16) report " real_cons_vector error in the length generic value" severity error; assert (S12'length = 16) report " time_cons_vector error in the length generic value" severity error; assert (S13'length = 16) report " natural_cons_vector error in the length generic value" severity error; assert (S14'length = 16) report " positive_cons_vector error in the length generic value" severity error; assert (S15'length = 16) report " boolean_cons_vectorofvector error in the length generic value" severity error; assert (S16'length = 16) report " severity_level_cons_vectorofvector error in the length generic value" severity error; assert (S17'length = 16) report " integer_cons_vectorofvector error in the length generic value" severity error; assert (S18'length = 16) report " real_cons_vectorofvector error in the length generic value" severity error; assert (S19'length = 16) report " time_cons_vectorofvector error in the length generic value" severity error; assert (S20'length = 16) report " natural_cons_vectorofvector error in the length generic value" severity error; assert (S21'length = 16) report " positive_cons_vectorofvector error in the length generic value" severity error; assert (S22.j'length = 7) report " record_std_package error in the length generic value" severity error; assert (S22.k'length = 4) report " record_std_package error in the length generic value" severity error; assert (S23.a'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.b'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.c'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.d'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.e'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.f'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S23.g'length = 16) report " record_cons_array error in the length generic value" severity error; assert (S24.a'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.b'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.c'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.d'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.e'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.f'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S24.g'length = 16) report " record_cons_arrayofarray error in the length generic value" severity error; assert (S25'length = 16) report " boolean_vector_st error in the length generic value" severity error; assert (S26'length = 16) report " severity_level_vector_st error in the length generic value" severity error; assert (S27'length = 16) report " integer_vector_st error in the length generic value" severity error; assert (S28'length = 16) report " real_vector_st error in the length generic value" severity error; assert (S29'length = 16) report " time_vector_st error in the length generic value" severity error; assert (S30'length = 16) report " natural_vector_st error in the length generic value" severity error; assert (S31'length = 16) report " positive_vector_st error in the length generic value" severity error; assert (S32.a'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.b'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.c'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.d'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.e'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.f'length = 16) report " record_array_st error in the length generic value" severity error; assert (S32.g'length = 16) report " record_array_st error in the length generic value" severity error; assert (S34.a'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.b'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.c'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.d'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.e'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.f'length = 16) report " record_array_new error in the length generic value" severity error; assert (S34.g'length = 16) report " record_array_new error in the length generic value" severity error; assert (S36'length = 8) report " byte error in the length generic value" severity error; assert (S37'length = 16) report " word error in the length generic value" severity error; assert (S38'length = 4) report " current_vector(zero to three) error in the length generic value" severity error; assert (S39'length = 4) report " resistance_vector(zero to three) error in the length generic value" severity error; --assert (S40'length = 1) report " delay error in the length generic value" severity error; assert (S41'length = 8) report " boolean_vector_range error in the length generic value" severity error; assert (S42'length = 8) report " severity_level_vector_range error in the length generic value" severity error; assert (S43'length = 8) report " integer_vector_range error in the length generic value" severity error; assert (S44'length = 8) report " real_vector_range error in the length generic value" severity error; assert (S45'length = 8) report " time_vector_range error in the length generic value" severity error; assert (S46'length = 8) report " natural_vector_range error in the length generic value" severity error; assert (S48'length = 8) report " positive_vector_range error in the length generic value" severity error; assert (S48'length = 8) report " array_rec_std(zero to seven) error in the length generic value" severity error; assert (S49'length = 8) report " array_rec_cons(zero to seven) error in the length generic value" severity error; assert (S50'length = 8) report " array_rec_rec(zero to seven) error in the length generic value" severity error; assert (S51.a'length = 8) report " record_of_arr_of_record error in the length generic value" severity error; assert (S51.b'length = 8) report " record_of_arr_of_record error in the length generic value" severity error; assert (S51.c'length = 8) report " record_of_arr_of_record error in the length generic value" severity error; TESTING: PROCESS BEGIN assert NOT( (S1'left = 0) and (S2'left = 0) and (S3'left = 0) and (S4'left = 0) and (S5'left = 0) and (S6'left = 0) and (S7'left = 0) and (S8'left = 15) and (S9'left = 15) and (S10'left = 15) and (S11'left = 15) and (S12'left = 15) and (S13'left = 15) and (S14'left = 15) and (S15'left = 0) and (S16'left = 0) and (S17'left = 0) and (S18'left = 0) and (S19'left = 0) and (S20'left = 0) and (S21'left = 0) and (S22.j'left = 1) and (S22.k'left = 0) and (S23.a'left = 15) and (S23.b'left = 15) and (S23.c'left = 15) and (S23.d'left = 15) and (S23.e'left = 15) and (S23.f'left = 15) and (S23.g'left = 15) and (S24.a'left = 0) and (S24.b'left = 0) and (S24.c'left = 0) and (S24.d'left = 0) and (S24.e'left = 0) and (S24.f'left = 0) and (S24.g'left = 0) and (S25'left = 0) and (S26'left = 0) and (S27'left = 0) and (S28'left = 0) and (S29'left = 0) and (S30'left = 0) and (S31'left = 0) and (S32.a'left = 0) and (S32.b'left = 0) and (S32.c'left = 0) and (S32.d'left = 0) and (S32.e'left = 0) and (S32.f'left = 0) and (S32.g'left = 0) and (S34.a'left = 0) and (S34.b'left = 0) and (S34.c'left = 0) and (S34.d'left = 0) and (S34.e'left = 0) and (S34.f'left = 0) and (S34.g'left = 0) and (S36'left = 0) and (S37'left = 0) and (S38'left = 0) and (S39'left = 0) and -- (S40'left = 1) and (S42'left = 0) and (S43'left = 0) and (S44'left = 0) and (S45'left = 0) and (S46'left = 0) and (S47'left = 0) and (S48'left = 0) and (S49'left = 0) and (S50'left = 0) and (S51.a'left = 0) and (S51.b'left = 0) and (S51.c'left = 0) and (S1'right = 15) and (S2'right = 15) and (S3'right = 15) and (S4'right = 15) and (S5'right = 15) and (S6'right = 15) and (S7'right = 15) and (S8'right = 0) and (S9'right = 0) and (S10'right = 0)and (S11'right = 0) and (S12'right = 0) and (S13'right = 0) and (S14'right = 0) and (S15'right = 15) and (S16'right = 15) and (S17'right = 15) and (S18'right = 15) and (S19'right = 15) and (S20'right = 15) and (S21'right = 15) and (S22.j'right = 7) and (S22.k'right = 3) and (S23.a'right = 0) and (S23.b'right = 0) and (S23.c'right = 0) and (S23.d'right = 0) and (S23.e'right = 0) and (S23.f'right = 0) and (S23.g'right = 0) and (S24.a'right = 15) and (S24.b'right = 15) and (S24.c'right = 15) and (S24.d'right = 15) and (S24.e'right = 15) and (S24.f'right = 15) and (S24.g'right = 15) and (S25'right = 15) and (S26'right = 15) and (S27'right = 15) and (S28'right = 15) and (S29'right = 15) and (S30'right = 15) and (S31'right = 15) and (S32.a'right = 15) and (S32.b'right = 15) and (S32.c'right = 15) and (S32.d'right = 15) and (S32.e'right = 15) and (S32.f'right = 15) and (S32.g'right = 15) and (S34.a'right = 15) and (S34.b'right = 15) and (S34.c'right = 15) and (S34.d'right = 15) and (S34.e'right = 15) and (S34.f'right = 15) and (S34.g'right = 15) and (S36'right = 7) and (S37'right = 15) and (S38'right = 3) and (S39'right = 3) and -- (S40'right = 1) and (S41'right = 7) and (S42'right = 7) and (S43'right = 7) and (S44'right = 7) and (S45'right = 7) and (S46'right = 7) and (S47'right = 7) and (S48'right = 7) and (S49'right = 7) and (S50'right = 7) and (S51.a'right = 7) and (S51.b'right = 7) and (S51.c'right = 7) and (S1'length = 16) and (S2'length = 16) and (S3'length = 16) and (S4'length = 16) and (S5'length = 16) and (S6'length = 16) and (S7'length = 16) and (S8'length = 16) and (S9'length = 16) and (S10'length = 16) and (S11'length = 16) and (S12'length = 16) and (S13'length = 16) and (S14'length = 16) and (S15'length = 16) and (S16'length = 16) and (S17'length = 16) and (S18'length = 16) and (S19'length = 16) and (S20'length = 16) and (S21'length = 16) and (S22.j'length = 7)and (S22.k'length = 4) and (S23.a'length = 16) and (S23.b'length = 16) and (S23.c'length = 16) and (S23.d'length = 16) and (S23.e'length = 16) and (S23.f'length = 16) and (S23.g'length = 16) and (S24.a'length = 16) and (S24.b'length = 16) and (S24.c'length = 16) and (S24.d'length = 16) and (S24.e'length = 16) and (S24.f'length = 16) and (S24.g'length = 16) and (S25'length = 16) and (S26'length = 16) and (S27'length = 16) and (S28'length = 16) and (S29'length = 16) and (S30'length = 16) and (S31'length = 16) and (S32.a'length = 16) and (S32.b'length = 16) and (S32.c'length = 16) and (S32.d'length = 16) and (S32.e'length = 16) and (S32.f'length = 16) and (S32.g'length = 16) and (S34.a'length = 16) and (S34.b'length = 16) and (S34.c'length = 16) and (S34.d'length = 16) and (S34.e'length = 16) and (S34.f'length = 16) and (S34.g'length = 16) and (S36'length = 8) and (S37'length = 16) and (S38'length = 4) and (S39'length = 4) and -- (S40'length = 1) and (S41'length = 8) and (S42'length = 8) and (S43'length = 8) and (S44'length = 8) and (S45'length = 8) and (S46'length = 8) and (S48'length = 8) and (S48'length = 8) and (S49'length = 8) and (S50'length = 8) and (S51.a'length = 8) and (S51.b'length = 8) and (S51.c'length = 8) ) report "***PASSED TEST: c01s01b01x01p05n02i00754" severity NOTE; assert ((S1'left = 0) and (S2'left = 0) and (S3'left = 0) and (S4'left = 0) and (S5'left = 0) and (S6'left = 0) and (S7'left = 0) and (S8'left = 15) and (S9'left = 15) and (S10'left = 15) and (S11'left = 15) and (S12'left = 15) and (S13'left = 15) and (S14'left = 15) and (S15'left = 0) and (S16'left = 0) and (S17'left = 0) and (S18'left = 0) and (S19'left = 0) and (S20'left = 0) and (S21'left = 0) and (S22.j'left = 1) and (S22.k'left = 0) and (S23.a'left = 15) and (S23.b'left = 15) and (S23.c'left = 15) and (S23.d'left = 15) and (S23.e'left = 15) and (S23.f'left = 15) and (S23.g'left = 15) and (S24.a'left = 0) and (S24.b'left = 0) and (S24.c'left = 0) and (S24.d'left = 0) and (S24.e'left = 0) and (S24.f'left = 0) and (S24.g'left = 0) and (S25'left = 0) and (S26'left = 0) and (S27'left = 0) and (S28'left = 0) and (S29'left = 0) and (S30'left = 0) and (S31'left = 0) and (S32.a'left = 0) and (S32.b'left = 0) and (S32.c'left = 0) and (S32.d'left = 0) and (S32.e'left = 0) and (S32.f'left = 0) and (S32.g'left = 0) and (S34.a'left = 0) and (S34.b'left = 0) and (S34.c'left = 0) and (S34.d'left = 0) and (S34.e'left = 0) and (S34.f'left = 0) and (S34.g'left = 0) and (S36'left = 0) and (S37'left = 0) and (S38'left = 0) and (S39'left = 0) and -- (S40'left = 1) and (S42'left = 0) and (S43'left = 0) and (S44'left = 0) and (S45'left = 0) and (S46'left = 0) and (S47'left = 0) and (S48'left = 0) and (S49'left = 0) and (S50'left = 0) and (S51.a'left = 0) and (S51.b'left = 0) and (S51.c'left = 0) and (S1'right = 15) and (S2'right = 15) and (S3'right = 15) and (S4'right = 15) and (S5'right = 15) and (S6'right = 15) and (S7'right = 15) and (S8'right = 0) and (S9'right = 0) and (S10'right = 0)and (S11'right = 0) and (S12'right = 0) and (S13'right = 0) and (S14'right = 0) and (S15'right = 15) and (S16'right = 15) and (S17'right = 15) and (S18'right = 15) and (S19'right = 15) and (S20'right = 15) and (S21'right = 15) and (S22.j'right = 7) and (S22.k'right = 3) and (S23.a'right = 0) and (S23.b'right = 0) and (S23.c'right = 0) and (S23.d'right = 0) and (S23.e'right = 0) and (S23.f'right = 0) and (S23.g'right = 0) and (S24.a'right = 15) and (S24.b'right = 15) and (S24.c'right = 15) and (S24.d'right = 15) and (S24.e'right = 15) and (S24.f'right = 15) and (S24.g'right = 15) and (S25'right = 15) and (S26'right = 15) and (S27'right = 15) and (S28'right = 15) and (S29'right = 15) and (S30'right = 15) and (S31'right = 15) and (S32.a'right = 15) and (S32.b'right = 15) and (S32.c'right = 15) and (S32.d'right = 15) and (S32.e'right = 15) and (S32.f'right = 15) and (S32.g'right = 15) and (S34.a'right = 15) and (S34.b'right = 15) and (S34.c'right = 15) and (S34.d'right = 15) and (S34.e'right = 15) and (S34.f'right = 15) and (S34.g'right = 15) and (S36'right = 7) and (S37'right = 15) and (S38'right = 3) and (S39'right = 3) and -- (S40'right = 1) and (S41'right = 7) and (S42'right = 7) and (S43'right = 7) and (S44'right = 7) and (S45'right = 7) and (S46'right = 7) and (S47'right = 7) and (S48'right = 7) and (S49'right = 7) and (S50'right = 7) and (S51.a'right = 7) and (S51.b'right = 7) and (S51.c'right = 7) and (S1'length = 16) and (S2'length = 16) and (S3'length = 16) and (S4'length = 16) and (S5'length = 16) and (S6'length = 16) and (S7'length = 16) and (S8'length = 16) and (S9'length = 16) and (S10'length = 16) and (S11'length = 16) and (S12'length = 16) and (S13'length = 16) and (S14'length = 16) and (S15'length = 16) and (S16'length = 16) and (S17'length = 16) and (S18'length = 16) and (S19'length = 16) and (S20'length = 16) and (S21'length = 16) and (S22.j'length = 7)and (S22.k'length = 4) and (S23.a'length = 16) and (S23.b'length = 16) and (S23.c'length = 16) and (S23.d'length = 16) and (S23.e'length = 16) and (S23.f'length = 16) and (S23.g'length = 16) and (S24.a'length = 16) and (S24.b'length = 16) and (S24.c'length = 16) and (S24.d'length = 16) and (S24.e'length = 16) and (S24.f'length = 16) and (S24.g'length = 16) and (S25'length = 16) and (S26'length = 16) and (S27'length = 16) and (S28'length = 16) and (S29'length = 16) and (S30'length = 16) and (S31'length = 16) and (S32.a'length = 16) and (S32.b'length = 16) and (S32.c'length = 16) and (S32.d'length = 16) and (S32.e'length = 16) and (S32.f'length = 16) and (S32.g'length = 16) and (S34.a'length = 16) and (S34.b'length = 16) and (S34.c'length = 16) and (S34.d'length = 16) and (S34.e'length = 16) and (S34.f'length = 16) and (S34.g'length = 16) and (S36'length = 8) and (S37'length = 16) and (S38'length = 4) and (S39'length = 4) and -- (S40'length = 1) and (S41'length = 8) and (S42'length = 8) and (S43'length = 8) and (S44'length = 8) and (S45'length = 8) and (S46'length = 8) and (S48'length = 8) and (S48'length = 8) and (S49'length = 8) and (S50'length = 8) and (S51.a'length = 8) and (S51.b'length = 8) and (S51.c'length = 8) ) report "***FAILED TEST: c01s01b01x01p05n02i00754 - Generic can be used to specify the size of ports." severity ERROR; wait; END PROCESS TESTING; END c01s01b01x01p05n02i00754arch; nvc-r1.17.1/test/regress/vests13.vhd000066400000000000000000000147221504111170000172110ustar00rootroot00000000000000-- -*- vhdl-basic-offset: 2 -*- -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1363.vhd,v 1.2 2001-10-26 16:29:40 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests13 IS END vests13; ARCHITECTURE c08s05b00x00p03n01i01363arch OF vests13 IS BEGIN TESTING: PROCESS -- -- Define constants for package -- constant lowb : integer := 1 ; constant highb : integer := 5 ; constant lowb_i2 : integer := 0 ; constant highb_i2 : integer := 1000 ; constant lowb_p : integer := -100 ; constant highb_p : integer := 1000 ; constant lowb_r : real := 0.0 ; constant highb_r : real := 1000.0 ; constant lowb_r2 : real := 8.0 ; constant highb_r2 : real := 80.0 ; constant c_boolean_1 : boolean := false ; constant c_boolean_2 : boolean := true ; -- -- bit constant c_bit_1 : bit := '0' ; constant c_bit_2 : bit := '1' ; -- severity_level constant c_severity_level_1 : severity_level := NOTE ; constant c_severity_level_2 : severity_level := WARNING ; -- -- character constant c_character_1 : character := 'A' ; constant c_character_2 : character := 'a' ; -- integer types -- predefined constant c_integer_1 : integer := lowb ; constant c_integer_2 : integer := highb ; -- -- user defined integer type type t_int1 is range 0 to 100 ; constant c_t_int1_1 : t_int1 := 0 ; constant c_t_int1_2 : t_int1 := 10 ; subtype st_int1 is t_int1 range 8 to 60 ; constant c_st_int1_1 : st_int1 := 8 ; constant c_st_int1_2 : st_int1 := 9 ; -- -- physical types -- predefined constant c_time_1 : time := 1 ns ; constant c_time_2 : time := 2 ns ; -- -- -- floating point types -- predefined constant c_real_1 : real := 0.0 ; constant c_real_2 : real := 1.0 ; -- -- simple record type t_rec1 is record f1 : integer range lowb_i2 to highb_i2 ; f2 : time ; f3 : boolean ; f4 : real ; end record ; constant c_t_rec1_1 : t_rec1 := (c_integer_1, c_time_1, c_boolean_1, c_real_1) ; constant c_t_rec1_2 : t_rec1 := (c_integer_2, c_time_2, c_boolean_2, c_real_2) ; subtype st_rec1 is t_rec1 ; constant c_st_rec1_1 : st_rec1 := c_t_rec1_1 ; constant c_st_rec1_2 : st_rec1 := c_t_rec1_2 ; -- -- more complex record type t_rec2 is record f1 : boolean ; f2 : st_rec1 ; f3 : time ; end record ; constant c_t_rec2_1 : t_rec2 := (c_boolean_1, c_st_rec1_1, c_time_1) ; constant c_t_rec2_2 : t_rec2 := (c_boolean_2, c_st_rec1_2, c_time_2) ; subtype st_rec2 is t_rec2 ; constant c_st_rec2_1 : st_rec2 := c_t_rec2_1 ; constant c_st_rec2_2 : st_rec2 := c_t_rec2_2 ; -- -- simple array type t_arr1 is array (integer range <>) of st_int1 ; subtype t_arr1_range1 is integer range lowb to highb ; subtype st_arr1 is t_arr1 (t_arr1_range1) ; constant c_st_arr1_1 : st_arr1 := (others => c_st_int1_1) ; constant c_st_arr1_2 : st_arr1 := (others => c_st_int1_2) ; constant c_t_arr1_1 : st_arr1 := c_st_arr1_1 ; constant c_t_arr1_2 : st_arr1 := c_st_arr1_2 ; -- -- more complex array type t_arr2 is array (integer range <>, boolean range <>) of st_arr1 ; subtype t_arr2_range1 is integer range lowb to highb ; subtype t_arr2_range2 is boolean range false to true ; subtype st_arr2 is t_arr2 (t_arr2_range1, t_arr2_range2); constant c_st_arr2_1 : st_arr2 := (others => (others => c_st_arr1_1)) ; constant c_st_arr2_2 : st_arr2 := (others => (others => c_st_arr1_2)) ; constant c_t_arr2_1 : st_arr2 := c_st_arr2_1 ; constant c_t_arr2_2 : st_arr2 := c_st_arr2_2 ; -- -- most complex record type t_rec3 is record f1 : boolean ; f2 : st_rec2 ; f3 : st_arr2 ; end record ; constant c_t_rec3_1 : t_rec3 := (c_boolean_1, c_st_rec2_1, c_st_arr2_1) ; constant c_t_rec3_2 : t_rec3 := (c_boolean_2, c_st_rec2_2, c_st_arr2_2) ; subtype st_rec3 is t_rec3 ; constant c_st_rec3_1 : st_rec3 := c_t_rec3_1 ; constant c_st_rec3_2 : st_rec3 := c_t_rec3_2 ; -- -- most complex array type t_arr3 is array (integer range <>, boolean range <>) of st_rec3 ; subtype t_arr3_range1 is integer range lowb to highb ; subtype t_arr3_range2 is boolean range true downto false ; subtype st_arr3 is t_arr3 (t_arr3_range1, t_arr3_range2) ; constant c_st_arr3_1 : st_arr3 := (others => (others => c_st_rec3_1)) ; constant c_st_arr3_2 : st_arr3 := (others => (others => c_st_rec3_2)) ; constant c_t_arr3_1 : st_arr3 := c_st_arr3_1 ; constant c_t_arr3_2 : st_arr3 := c_st_arr3_2 ; -- variable v_st_rec3 : st_rec3 := c_st_rec3_1 ; -- BEGIN assert c_st_rec3_2.f3(st_arr2'Right(1),st_arr2'Right(2)) = c_st_arr1_2; v_st_rec3.f3(st_arr2'Left(1),st_arr2'Left(2)) := c_st_rec3_2.f3(st_arr2'Right(1),st_arr2'Right(2)); assert NOT(v_st_rec3.f3(st_arr2'Left(1),st_arr2'Left(2)) = c_st_arr1_2) report "***PASSED TEST: c08s05b00x00p03n01i01363" severity NOTE; assert (v_st_rec3.f3(st_arr2'Left(1),st_arr2'Left(2)) = c_st_arr1_2) report "***FAILED TEST: c08s05b00x00p03n01i01363 - The types of the variable and the assigned variable must match." severity ERROR; wait; END PROCESS TESTING; END c08s05b00x00p03n01i01363arch; nvc-r1.17.1/test/regress/vests14.vhd000066400000000000000000000076561504111170000172220ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3068.vhd,v 1.2 2001-10-26 16:29:51 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c12s06b02x00p06n01i03068pkg is type severity_level_cons_vector is array (15 downto 0) of severity_level; constant C19 : severity_level_cons_vector := (others => note); end c12s06b02x00p06n01i03068pkg; use work.c12s06b02x00p06n01i03068pkg.all; ENTITY c12s06b02x00p06n01i03068ent_a IS PORT ( F1: OUT integer ; F3: IN severity_level_cons_vector; FF: OUT integer := 0 ); END c12s06b02x00p06n01i03068ent_a; ARCHITECTURE c12s06b02x00p06n01i03068arch_a OF c12s06b02x00p06n01i03068ent_a IS BEGIN TESTING: PROCESS begin F1 <= 3; wait for 0 ns; assert F3'active = true report"no activity on F3 when there is activity on actual" severity failure; if (not(F3'active = true)) then F1 <= 11; end if; assert F3(0)'active = true report"no activity on F3 when there is activity on actual" severity failure; if (not(F3(0)'active = true)) then F1 <= 11; end if; assert F3(15)'active = true report"no activity on F3 when there is activity on actual" severity failure; if (not(F3(15)'active = true)) then F1 <= 11; end if; wait; END PROCESS; END c12s06b02x00p06n01i03068arch_a; use work.c12s06b02x00p06n01i03068pkg.all; ENTITY vests14 IS END vests14; ARCHITECTURE c12s06b02x00p06n01i03068arch OF vests14 IS function scalar_complex(s : integer) return severity_level_cons_vector is begin return C19; end scalar_complex; component model PORT ( F1: OUT integer; F3: IN severity_level_cons_vector; FF: OUT integer ); end component; for T1 : model use entity work.c12s06b02x00p06n01i03068ent_a(c12s06b02x00p06n01i03068arch_a); signal S1 : severity_level_cons_vector; signal S3 : integer; signal SS : integer := 0; BEGIN T1: model port map ( scalar_complex(F1) => S1, F3 => scalar_complex(S3), FF => SS ); TESTING: PROCESS BEGIN S3 <= 3; wait for 0 ns; assert S1'active = true report"no activity on F3 when there is activity on actual" severity failure; assert S1(0)'active = true report"no activity on F3 when there is activity on actual" severity failure; assert S1(15)'active = true report"no activity on F3 when there is activity on actual" severity failure; assert NOT(S1'active = true and S1(0)'active = true and S1(15)'active = true and SS = 0) report "***PASSED TEST: c12s06b02x00p06n01i03068" severity NOTE; assert (S1'active = true and S1(0)'active = true and S1(15)'active = true and SS = 0) report "***FAILED TEST: c12s06b02x00p06n01i03068 - Not every scalar subelement is active if the source itself is active." severity ERROR; wait; END PROCESS TESTING; END c12s06b02x00p06n01i03068arch; nvc-r1.17.1/test/regress/vests15.vhd000066400000000000000000000112601504111170000172050ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2959.vhd,v 1.2 2001-10-26 16:29:50 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c02s03b00x00p02n01i02959pkg is FUNCTION boo ( PARM_VAL : bit_vector) RETURN bit; FUNCTION boo ( PARM_VAL : bit_vector) RETURN bit_vector; FUNCTION boo ( PARM_VAL : bit_vector) RETURN boolean; FUNCTION boo ( PARM_VAL : bit_vector) RETURN character; FUNCTION boo ( PARM_VAL : bit_vector) RETURN integer; FUNCTION boo ( PARM_VAL : bit_vector) RETURN real; FUNCTION boo ( PARM_VAL : bit_vector) RETURN string; FUNCTION boo ( PARM_VAL : bit_vector) RETURN time; end c02s03b00x00p02n01i02959pkg; package body c02s03b00x00p02n01i02959pkg is FUNCTION boo ( PARM_VAL : bit_vector) RETURN time IS BEGIN assert false report "boo with TIME returned" severity note; RETURN 10 ns; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN string IS BEGIN assert false report "boo with STRING returned" severity note; RETURN "STRING"; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN real IS BEGIN assert false report "boo with REAL returned" severity note; RETURN 10.01; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN integer IS BEGIN assert false report "boo with INTEGER returned" severity note; RETURN 55; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN character IS BEGIN assert false report "boo with CHARACTER returned" severity note; RETURN 'Z'; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN boolean IS BEGIN assert false report "boo with BOOLEAN returned" severity note; RETURN TRUE; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN bit_vector IS BEGIN assert false report "boo with BIT_VECTOR returned" severity note; RETURN "1010"; END; FUNCTION boo ( PARM_VAL : bit_vector) RETURN bit IS BEGIN assert false report "boo with BIT returned" severity note; RETURN '1'; END; end c02s03b00x00p02n01i02959pkg; ENTITY vests15 IS PORT (bb: INOUT bit; bv: INOUT bit_vector(0 TO 3); bo: INOUT boolean; cc: INOUT character; ii: INOUT integer; rr: INOUT real; ss: INOUT string(1 TO 6); tt: INOUT time); SUBTYPE bv_4 IS bit_vector(1 TO 4); SUBTYPE bv_6 IS bit_vector(1 TO 6); FUNCTION foo ( PARM_VAL : bv_4) RETURN bit_vector IS BEGIN assert false report "function foo in entity e" severity note; RETURN PARM_VAL; END; END vests15; use work.c02s03b00x00p02n01i02959pkg.all; ARCHITECTURE c02s03b00x00p02n01i02959arch OF vests15 IS SIGNAL c1 : bv_4; BEGIN TESTING: PROCESS BEGIN WAIT FOR 1 ns; c1 <= boo ( bv_6'(OTHERS => '1')); bb <= boo (c1); bv <= boo (c1); bo <= boo (c1); cc <= boo (c1); ii <= boo (c1); rr <= boo (c1); ss <= boo (c1); tt <= boo (c1); WAIT FOR 1 ns; assert NOT( (c1 = "1010") AND (bb = '1') AND (bv = "1010") AND (bo = TRUE) AND (cc = 'Z') AND (ii = 55) AND (rr = 10.01) AND (ss = "STRING") AND (tt = 10 ns)) report "***PASSED TEST: c02s03b00x00p02n01i02959" severity NOTE; assert ( (c1 = "1010") AND (bb = '1') AND (bv = "1010") AND (bo = TRUE) AND (cc = 'Z') AND (ii = 55) AND (rr = 10.01) AND (ss = "STRING") AND (tt = 10 ns)) report "***FAILED TEST: c02s03b00x00p02n01i02959 - Overloaded functions test failed." severity ERROR; wait; END PROCESS TESTING; END c02s03b00x00p02n01i02959arch; nvc-r1.17.1/test/regress/vests16.vhd000066400000000000000000000265221504111170000172150ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc871.vhd,v 1.2 2001-10-26 16:30:01 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s03b01x00p12n01i00871pkg is constant low_number : integer := 0; constant hi_number : integer := 3; subtype hi_to_low_range is integer range low_number to hi_number; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; end record; type array_rec_std is array (natural range <>) of record_std_package; type four_value is ('Z','0','1','X'); --enumerated type constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; signal Sin1 : bit_vector(0 to 5) ; signal Sin2 : boolean_vector(0 to 5) ; signal Sin4 : severity_level_vector(0 to 5) ; signal Sin5 : integer_vector(0 to 5) ; signal Sin6 : real_vector(0 to 5) ; signal Sin7 : time_vector(0 to 5) ; signal Sin8 : natural_vector(0 to 5) ; signal Sin9 : positive_vector(0 to 5) ; signal Sin10: array_rec_std(0 to 5) ; end c01s03b01x00p12n01i00871pkg; use work.c01s03b01x00p12n01i00871pkg.all; entity test is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test of test is begin sigout1 <= sigin1; sigout2 <= sigin2; sigout4 <= sigin4; sigout5 <= sigin5; sigout6 <= sigin6; sigout7 <= sigin7; sigout8 <= sigin8; sigout9 <= sigin9; sigout10 <= sigin10; end; configuration testbench of test is for test end for; end; use work.c01s03b01x00p12n01i00871pkg.all; entity test1 is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test1 of test1 is begin sigout1 <= false; sigout2 <= '0'; sigout4 <= error; sigout5 <= 6; sigout6 <= 6.0; sigout7 <= 6 ns; sigout8 <= 6; sigout9 <= 6; sigout10 <= (false,'0','h',error,6,6.0,6 ns,6,6); end; configuration test1bench of test1 is for test1 end for; end; use work.c01s03b01x00p12n01i00871pkg.all; ENTITY c01s03b01x00p12n01i00871ent IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15); port( dumy : inout bit_vector(zero to three)); END c01s03b01x00p12n01i00871ent; ARCHITECTURE c01s03b01x00p12n01i00871arch OF c01s03b01x00p12n01i00871ent IS component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; begin Sin1(zero) <='1'; Sin2(zero) <= true; Sin4(zero) <= note; Sin5(zero) <= 3; Sin6(zero) <= 3.0; Sin7(zero) <= 3 ns; Sin8(zero) <= 1; Sin9(zero) <= 1; Sin10(zero) <= (C1,C2,C3,C4,C5,C6,C7,C8,C9); K:block BEGIN T5 : test port map ( Sin2(4),Sin2(5), Sin1(4),Sin1(5), Sin4(4),Sin4(5), Sin5(4),Sin5(5), Sin6(4),Sin6(5), Sin7(4),Sin7(5), Sin8(4),Sin8(5), Sin9(4),Sin9(5), Sin10(4),Sin10(5) ); G: for i in zero to three generate T1:test port map ( Sin2(i),Sin2(i+1), Sin1(i),Sin1(i+1), Sin4(i),Sin4(i+1), Sin5(i),Sin5(i+1), Sin6(i),Sin6(i+1), Sin7(i),Sin7(i+1), Sin8(i),Sin8(i+1), Sin9(i),Sin9(i+1), Sin10(i),Sin10(i+1) ); end generate; end block; TESTING: PROCESS variable dumb : bit_vector(zero to three); BEGIN wait for 1 ns; assert Sin1(0) = Sin1(4) report "assignment of Sin1(0) to Sin1(4) is invalid through entity port" severity failure; assert Sin2(0) = Sin2(4) report "assignment of Sin2(0) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(0) = Sin4(4) report "assignment of Sin4(0) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(0) = Sin5(4) report "assignment of Sin5(0) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(0) = Sin6(4) report "assignment of Sin6(0) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(0) = Sin7(4) report "assignment of Sin7(0) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(0) = Sin8(4) report "assignment of Sin8(0) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(0) = Sin9(4) report "assignment of Sin9(0) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(0) = Sin10(4) report "assignment of Sin10(0) to Sin10(4) is invalid through entity port" severity failure; assert Sin1(5) = '0' report "assignment of Sin1(5) to Sin1(4) is invalid through entity port: " & bit'image(Sin1(5)) severity failure; assert Sin2(5) = false report "assignment of Sin2(5) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(5) = error report "assignment of Sin4(5) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(5) = 6 report "assignment of Sin5(5) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(5) = 6.0 report "assignment of Sin6(5) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(5) = 6 ns report "assignment of Sin7(5) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(5) = 6 report "assignment of Sin8(5) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(5) = 6 report "assignment of Sin9(5) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(5) = (false,'0','h',error,6,6.0,6 ns,6,6) report "assignment of Sin15(5) to Sin15(4) is invalid through entity port" severity failure; assert NOT( Sin1(0) = sin1(4) and Sin2(0) = Sin2(4) and Sin4(0) = Sin4(4) and Sin5(0) = Sin5(4) and Sin6(0) = Sin6(4) and Sin7(0) = Sin7(4) and Sin8(0) = Sin8(4) and Sin9(0) = Sin9(4) and Sin10(0)= Sin10(4) and Sin1(5) = '0' and Sin2(5) = FALSE and Sin4(5) = error and Sin5(5) = 6 and Sin6(5) = 6.0 and Sin7(5) = 6 ns and Sin8(5) = 6 and Sin9(5) = 6 and Sin10(5)=(False,'0','h',error,6,6.0,6 ns,6,6)) report "***PASSED TEST: c01s03b01x00p12n01i00871" severity NOTE; assert ( Sin1(0) = sin1(4) and Sin2(0) = Sin2(4) and Sin4(0) = Sin4(4) and Sin5(0) = Sin5(4) and Sin6(0) = Sin6(4) and Sin7(0) = Sin7(4) and Sin8(0) = Sin8(4) and Sin9(0) = Sin9(4) and Sin10(0)= Sin10(4) and Sin1(5) = '0' and Sin2(5) = FALSE and Sin4(5) = error and Sin5(5) = 6 and Sin6(5) = 6.0 and Sin7(5) = 6 ns and Sin8(5) = 6 and Sin9(5) = 6 and Sin10(5)=(False,'0','h',error,6,6.0,6 ns,6,6)) report "***FAILED TEST: c01s03b01x00p12n01i00871 - If such a block configuration contains an index specification that is a discrete range, then the block configuration applies to those implicit block statements that are generated for the specified range of values of the corresponding generate index." severity ERROR; wait; END PROCESS TESTING; END c01s03b01x00p12n01i00871arch; configuration vests16 of c01s03b01x00p12n01i00871ent is for c01s03b01x00p12n01i00871arch for K for all:test use configuration work.test1bench; end for; for G(0 to 3) for T1 :test use configuration work.testbench; end for; end for; end for; end for; end; nvc-r1.17.1/test/regress/vests17.vhd000066400000000000000000000236171504111170000172200ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc856.vhd,v 1.2 2001-10-26 16:30:01 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s03b01x00p12n01i00856pkg_b is constant zero : integer ; constant one : integer ; constant two : integer ; constant three: integer ; constant four : integer ; constant five : integer ; constant six : integer ; constant seven: integer ; constant eight: integer ; constant nine : integer ; constant fifteen: integer; end c01s03b01x00p12n01i00856pkg_b; package body c01s03b01x00p12n01i00856pkg_b is constant zero : integer := 0; constant one : integer := 1; constant two : integer := 2; constant three: integer := 3; constant four : integer := 4; constant five : integer := 5; constant six : integer := 6; constant seven: integer := 7; constant eight: integer := 8; constant nine : integer := 9; constant fifteen:integer:= 15; end c01s03b01x00p12n01i00856pkg_b; use work.c01s03b01x00p12n01i00856pkg_b.all; package c01s03b01x00p12n01i00856pkg_a is constant low_number : integer := 0; constant hi_number : integer := 3; subtype hi_to_low_range is integer range low_number to hi_number; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; end record; type array_rec_std is array (natural range <>) of record_std_package; type four_value is ('Z','0','1','X'); --enumerated type constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; constant dumy : bit_vector(zero to three) := "1010"; signal Sin1 : bit_vector(zero to five) ; signal Sin2 : boolean_vector(zero to five) ; signal Sin4 : severity_level_vector(zero to five) ; signal Sin5 : integer_vector(zero to five) ; signal Sin6 : real_vector(zero to five) ; signal Sin7 : time_vector(zero to five) ; signal Sin8 : natural_vector(zero to five) ; signal Sin9 : positive_vector(zero to five) ; signal Sin10: array_rec_std(zero to five) ; end c01s03b01x00p12n01i00856pkg_a; use work.c01s03b01x00p12n01i00856pkg_a.all; use work.c01s03b01x00p12n01i00856pkg_b.all; entity test is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test of test is begin sigout1 <= sigin1; sigout2 <= sigin2; sigout4 <= sigin4; sigout5 <= sigin5; sigout6 <= sigin6; sigout7 <= sigin7; sigout8 <= sigin8; sigout9 <= sigin9; sigout10 <= sigin10; end; configuration testbench of test is for test end for; end; use work.c01s03b01x00p12n01i00856pkg_a.all; use work.c01s03b01x00p12n01i00856pkg_b.all; ENTITY c01s03b01x00p12n01i00856ent IS END c01s03b01x00p12n01i00856ent; ARCHITECTURE c01s03b01x00p12n01i00856arch OF c01s03b01x00p12n01i00856ent IS component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; begin Sin1(zero) <='1'; Sin2(zero) <= true; Sin4(zero) <= note; Sin5(zero) <= 3; Sin6(zero) <= 3.0; Sin7(zero) <= 3 ns; Sin8(zero) <= 1; Sin9(zero) <= 1; Sin10(zero) <= (C1,C2,C3,C4,C5,C6,C7,C8,C9); K:block component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; BEGIN T5 : test port map ( Sin2(4),Sin2(5), Sin1(4),Sin1(5), Sin4(4),Sin4(5), Sin5(4),Sin5(5), Sin6(4),Sin6(5), Sin7(4),Sin7(5), Sin8(4),Sin8(5), Sin9(4),Sin9(5), Sin10(4),Sin10(5) ); G: for i in zero to three generate T1:test port map ( Sin2(i),Sin2(i+1), Sin1(i),Sin1(i+1), Sin4(i),Sin4(i+1), Sin5(i),Sin5(i+1), Sin6(i),Sin6(i+1), Sin7(i),Sin7(i+1), Sin8(i),Sin8(i+1), Sin9(i),Sin9(i+1), Sin10(i),Sin10(i+1) ); end generate; end block; TESTING: PROCESS BEGIN wait for 1 ns; assert Sin1(0) = Sin1(5) report "assignment of Sin1(0) to Sin1(4) is invalid through entity port" severity failure; assert Sin2(0) = Sin2(5) report "assignment of Sin2(0) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(0) = Sin4(5) report "assignment of Sin4(0) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(0) = Sin5(5) report "assignment of Sin5(0) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(0) = Sin6(5) report "assignment of Sin6(0) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(0) = Sin7(5) report "assignment of Sin7(0) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(0) = Sin8(5) report "assignment of Sin8(0) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(0) = Sin9(5) report "assignment of Sin9(0) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(0) = Sin10(5) report "assignment of Sin10(0) to Sin10(4) is invalid through entity port" severity failure; assert NOT( Sin1(0) = sin1(5) and Sin2(0) = Sin2(5) and Sin4(0) = Sin4(5) and Sin5(0) = Sin5(5) and Sin6(0) = Sin6(5) and Sin7(0) = Sin7(5) and Sin8(0) = Sin8(5) and Sin9(0) = Sin9(5) and Sin10(0)= Sin10(0) ) report "***PASSED TEST: c01s03b01x00p12n01i00856" severity NOTE; assert ( Sin1(0) = sin1(5) and Sin2(0) = Sin2(5) and Sin4(0) = Sin4(5) and Sin5(0) = Sin5(5) and Sin6(0) = Sin6(5) and Sin7(0) = Sin7(5) and Sin8(0) = Sin8(5) and Sin9(0) = Sin9(5) and Sin10(0)= Sin10(0) ) report "***FAILED TEST: c01s03b01x00p12n01i00856 - If such a block configuration contains an index specification that is a discrete range, then the block configuration applies to those implicit block statements that are generated for the specified range of values of the corresponding generate index." severity ERROR; wait; END PROCESS TESTING; END c01s03b01x00p12n01i00856arch; configuration vests17 of c01s03b01x00p12n01i00856ent is for c01s03b01x00p12n01i00856arch for K for T5:test use configuration work.testbench; end for; for G(hi_to_low_range) for T1:test use configuration work.testbench; end for; end for; end for; end for; end; nvc-r1.17.1/test/regress/vests18.vhd000066400000000000000000000071201504111170000172100ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc743.vhd,v 1.2 2001-10-26 16:29:59 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s01b01x01p04n01i00743pkg is type arrtype is array (1 to 5) of bit; constant defcon1 : bit; constant defcon2 : integer; constant defcon3 : arrtype; constant defcon4 : boolean; component comp1 generic ( constant dgc1 : bit := defcon1; constant dgc2 : integer := defcon2; constant dgc3 : arrtype := defcon3; constant dgc4 : boolean := defcon4 ); port ( signal dcent1 : inout bit := dgc1; signal dcent2 : inout integer := dgc2; signal dcent3 : inout arrtype := dgc3; signal dcent4 : inout boolean := dgc4 ); end component; end c01s01b01x01p04n01i00743pkg; package body c01s01b01x01p04n01i00743pkg is constant defcon1 : bit := '1'; constant defcon2 : integer := 113; constant defcon3 : arrtype := ('1','0','1','0','1'); constant defcon4 : boolean := TRUE; end c01s01b01x01p04n01i00743pkg; use work.c01s01b01x01p04n01i00743pkg.all; entity c01s01b01x01p04n01i00743ent_a is generic ( constant gc1 : bit; constant gc2 : integer; constant gc3 : arrtype; constant gc4 : boolean ); port ( signal cent1 : inout bit; signal cent2 : inout integer; signal cent3 : inout arrtype; signal cent4 : inout boolean ); end c01s01b01x01p04n01i00743ent_a; architecture c01s01b01x01p04n01i00743arch_a of c01s01b01x01p04n01i00743ent_a is begin p0: process begin wait for 1 ns; if (gc1='1') and (gc2=113) and (gc3=('1','0','1','0','1')) and (gc4) then assert FALSE report "***PASSED TEST: c01s01b01x01p04n01i00743" severity NOTE; else assert FALSE report "***FAILED TEST: c01s01b01x01p04n01i00743 - Generic default to deferred constants." severity ERROR; end if; wait; end process; end c01s01b01x01p04n01i00743arch_a; use work.c01s01b01x01p04n01i00743pkg.all; ENTITY vests18 IS generic ( constant gen_con : integer := 1334 ); port ( signal ee1 : inout boolean := TRUE; signal ee2 : inout bit; signal ee3 : inout integer; signal ee4 : inout arrtype ); END vests18; ARCHITECTURE c01s01b01x01p04n01i00743arch OF vests18 IS for u1 : comp1 use entity work.c01s01b01x01p04n01i00743ent_a(c01s01b01x01p04n01i00743arch_a) generic map ( dgc1, dgc2, dgc3, dgc4 ) port map ( dcent1, dcent2, dcent3, dcent4 ); BEGIN u1 : comp1; END c01s01b01x01p04n01i00743arch; nvc-r1.17.1/test/regress/vests19.vhd000066400000000000000000000043111504111170000172100ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc921.vhd,v 1.2 2001-10-26 16:30:02 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- entity c10s03b00x00p16n01i00921ent_a is generic ( x : integer; y : real ); end c10s03b00x00p16n01i00921ent_a; architecture c10s03b00x00p16n01i00921arch_a of c10s03b00x00p16n01i00921ent_a is begin TESTING : PROCESS BEGIN assert NOT( real(x)=y ) report "***PASSED TEST: c10s03b00x00p16n01i00921" severity NOTE; assert ( real(x)=y ) report "***FAILED TEST: c10s03b00x00p16n01i00921 - Named associated formal generic can be made visible by selection." severity ERROR; wait; END PROCESS TESTING; end c10s03b00x00p16n01i00921arch_a; ENTITY c10s03b00x00p16n01i00921ent IS END c10s03b00x00p16n01i00921ent; ARCHITECTURE c10s03b00x00p16n01i00921arch OF c10s03b00x00p16n01i00921ent IS component d end component; BEGIN instance : d; END c10s03b00x00p16n01i00921arch; configuration vests19 of c10s03b00x00p16n01i00921ent is for c10s03b00x00p16n01i00921arch for instance : d use entity work.c10s03b00x00p16n01i00921ent_a(c10s03b00x00p16n01i00921arch_a) generic map ( x => 10, y => 10.0 ); end for; end for; end vests19; nvc-r1.17.1/test/regress/vests2.vhd000066400000000000000000000044211504111170000171220ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2132.vhd,v 1.2 2001-10-26 16:29:46 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests2 IS END vests2; ARCHITECTURE c07s02b04x00p21n01i02132arch OF vests2 IS TYPE simple_record is record data_1 : integer; data_2 : integer; end record; TYPE record_v is array (integer range <>) of simple_record; SUBTYPE record_5 is record_v (1 to 5); SUBTYPE record_4 is record_v (1 to 4); BEGIN TESTING: PROCESS variable result : record_5; variable l_operand : simple_record := (12,34) ; variable r_operand : record_4 := ((12,34), (56,78), (12,34), (56,78)); BEGIN -- -- The element is treated as an implicit single element array ! -- result := l_operand & r_operand; wait for 5 ns; assert NOT( result = ((12,34), (12,34), (56,78), (12,34), (56,78))) report "***PASSED TEST: c07s02b04x00p21n01i02132" severity NOTE; assert ( result = ((12,34), (12,34), (56,78), (12,34), (56,78))) report "***FAILED TEST:c07s02b04x00p21n01i02132 - Concatenation of element and RECORD array failed." severity ERROR; wait; END PROCESS TESTING; END c07s02b04x00p21n01i02132arch; nvc-r1.17.1/test/regress/vests20.vhd000066400000000000000000000277701504111170000172160ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc870.vhd,v 1.2 2001-10-26 16:30:01 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s03b01x00p12n01i00870pkg is constant low_number : integer := 0; constant hi_number : integer := 3; subtype hi_to_low_range is integer range low_number to hi_number; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; end record; type array_rec_std is array (natural range <>) of record_std_package; type four_value is ('Z','0','1','X'); --enumerated type constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; subtype dumy is integer range 0 to 3; signal Sin1 : bit_vector(0 to 5) ; signal Sin2 : boolean_vector(0 to 5) ; signal Sin4 : severity_level_vector(0 to 5) ; signal Sin5 : integer_vector(0 to 5) ; signal Sin6 : real_vector(0 to 5) ; signal Sin7 : time_vector(0 to 5) ; signal Sin8 : natural_vector(0 to 5) ; signal Sin9 : positive_vector(0 to 5) ; signal Sin10: array_rec_std(0 to 5) ; end c01s03b01x00p12n01i00870pkg; use work.c01s03b01x00p12n01i00870pkg.all; entity test is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test of test is begin sigout1 <= sigin1; sigout2 <= sigin2; sigout4 <= sigin4; sigout5 <= sigin5; sigout6 <= sigin6; sigout7 <= sigin7; sigout8 <= sigin8; sigout9 <= sigin9; sigout10 <= sigin10; end; configuration testbench of test is for test end for; end; use work.c01s03b01x00p12n01i00870pkg.all; entity test1 is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test1 of test1 is begin sigout1 <= false; sigout2 <= '0'; sigout4 <= error; sigout5 <= 6; sigout6 <= 6.0; sigout7 <= 6 ns; sigout8 <= 6; sigout9 <= 6; sigout10 <= (false,'0','h',error,6,6.0,6 ns,6,6); end; configuration test1bench of test1 is for test1 end for; end; use work.c01s03b01x00p12n01i00870pkg.all; ENTITY c01s03b01x00p12n01i00870ent IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15); port( dumy : inout bit_vector(zero to three)); END c01s03b01x00p12n01i00870ent; ARCHITECTURE c01s03b01x00p12n01i00870arch OF c01s03b01x00p12n01i00870ent IS component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; begin Sin1(zero) <='1'; Sin2(zero) <= true; Sin4(zero) <= note; Sin5(zero) <= 3; Sin6(zero) <= 3.0; Sin7(zero) <= 3 ns; Sin8(zero) <= 1; Sin9(zero) <= 1; Sin10(zero) <= (C1,C2,C3,C4,C5,C6,C7,C8,C9); K:block component test1 port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; BEGIN T5 : test1 port map ( Sin2(4),Sin2(5), Sin1(4),Sin1(5), Sin4(4),Sin4(5), Sin5(4),Sin5(5), Sin6(4),Sin6(5), Sin7(4),Sin7(5), Sin8(4),Sin8(5), Sin9(4),Sin9(5), Sin10(4),Sin10(5) ); G: for i in zero to three generate T1:test port map ( Sin2(i),Sin2(i+1), Sin1(i),Sin1(i+1), Sin4(i),Sin4(i+1), Sin5(i),Sin5(i+1), Sin6(i),Sin6(i+1), Sin7(i),Sin7(i+1), Sin8(i),Sin8(i+1), Sin9(i),Sin9(i+1), Sin10(i),Sin10(i+1) ); end generate; end block; TESTING: PROCESS variable dumb : bit_vector(zero to three); BEGIN wait for 1 ns; assert Sin1(0) = Sin1(4) report "assignment of Sin1(0) to Sin1(4) is invalid through entity port" severity failure; assert Sin2(0) = Sin2(4) report "assignment of Sin2(0) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(0) = Sin4(4) report "assignment of Sin4(0) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(0) = Sin5(4) report "assignment of Sin5(0) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(0) = Sin6(4) report "assignment of Sin6(0) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(0) = Sin7(4) report "assignment of Sin7(0) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(0) = Sin8(4) report "assignment of Sin8(0) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(0) = Sin9(4) report "assignment of Sin9(0) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(0) = Sin10(4) report "assignment of Sin10(0) to Sin10(4) is invalid through entity port" severity failure; assert Sin1(5) = '0' report "assignment of Sin1(5) to Sin1(4) is invalid through entity port" severity failure; assert Sin2(5) = false report "assignment of Sin2(5) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(5) = error report "assignment of Sin4(5) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(5) = 6 report "assignment of Sin5(5) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(5) = 6.0 report "assignment of Sin6(5) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(5) = 6 ns report "assignment of Sin7(5) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(5) = 6 report "assignment of Sin8(5) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(5) = 6 report "assignment of Sin9(5) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(5) = (false,'0','h',error,6,6.0,6 ns,6,6) report "assignment of Sin15(5) to Sin15(4) is invalid through entity port" severity failure; assert NOT( Sin1(0) = sin1(4) and Sin2(0) = Sin2(4) and Sin4(0) = Sin4(4) and Sin5(0) = Sin5(4) and Sin6(0) = Sin6(4) and Sin7(0) = Sin7(4) and Sin8(0) = Sin8(4) and Sin9(0) = Sin9(4) and Sin10(0)= Sin10(4) and Sin1(5) = '0' and Sin2(5) = FALSE and Sin4(5) = error and Sin5(5) = 6 and Sin6(5) = 6.0 and Sin7(5) = 6 ns and Sin8(5) = 6 and Sin9(5) = 6 and Sin10(5)=(False,'0','h',error,6,6.0,6 ns,6,6)) report "***PASSED TEST: c01s03b01x00p12n01i00870" severity NOTE; assert ( Sin1(0) = sin1(4) and Sin2(0) = Sin2(4) and Sin4(0) = Sin4(4) and Sin5(0) = Sin5(4) and Sin6(0) = Sin6(4) and Sin7(0) = Sin7(4) and Sin8(0) = Sin8(4) and Sin9(0) = Sin9(4) and Sin10(0)= Sin10(4) and Sin1(5) = '0' and Sin2(5) = FALSE and Sin4(5) = error and Sin5(5) = 6 and Sin6(5) = 6.0 and Sin7(5) = 6 ns and Sin8(5) = 6 and Sin9(5) = 6 and Sin10(5)=(False,'0','h',error,6,6.0,6 ns,6,6)) report "***FAILED TEST: c01s03b01x00p12n01i00870 - If such a block configuration contains an index specification that is a discrete range, then the block configuration applies to those implicit block statements that are generated for the specified range of values of the corresponding generate index." severity ERROR; wait; END PROCESS TESTING; END c01s03b01x00p12n01i00870arch; configuration vests20 of c01s03b01x00p12n01i00870ent is for c01s03b01x00p12n01i00870arch for K for others:test1 use configuration work.test1bench; end for; for G(0 to 3) for all :test use configuration work.testbench; end for; end for; end for; end for; end; nvc-r1.17.1/test/regress/vests21.vhd000066400000000000000000000245121504111170000172060ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc860.vhd,v 1.2 2001-10-26 16:30:01 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s03b01x00p12n01i00860pkg_b is constant zero : integer ; constant one : integer ; constant two : integer ; constant three: integer ; constant four : integer ; constant five : integer ; constant six : integer ; constant seven: integer ; constant eight: integer ; constant nine : integer ; constant fifteen: integer; end c01s03b01x00p12n01i00860pkg_b; package body c01s03b01x00p12n01i00860pkg_b is constant zero : integer := 0; constant one : integer := 1; constant two : integer := 2; constant three: integer := 3; constant four : integer := 4; constant five : integer := 5; constant six : integer := 6; constant seven: integer := 7; constant eight: integer := 8; constant nine : integer := 9; constant fifteen:integer:= 15; end c01s03b01x00p12n01i00860pkg_b; use work.c01s03b01x00p12n01i00860pkg_b.all; package c01s03b01x00p12n01i00860pkg_a is constant low_number : integer := 0; constant hi_number : integer := 3; subtype hi_to_low_range is integer range low_number to hi_number; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; end record; type array_rec_std is array (natural range <>) of record_std_package; type four_value is ('Z','0','1','X'); --enumerated type constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; constant dumy : bit_vector(zero to three) := "1010" ; signal Sin1 : bit_vector(zero to six) ; signal Sin2 : boolean_vector(zero to six) ; signal Sin4 : severity_level_vector(zero to six) ; signal Sin5 : integer_vector(zero to six) ; signal Sin6 : real_vector(zero to six) ; signal Sin7 : time_vector(zero to six) ; signal Sin8 : natural_vector(zero to six) ; signal Sin9 : positive_vector(zero to six) ; signal Sin10: array_rec_std(zero to six) ; end c01s03b01x00p12n01i00860pkg_a; use work.c01s03b01x00p12n01i00860pkg_a.all; use work.c01s03b01x00p12n01i00860pkg_b.all; entity test is port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end; architecture test of test is begin sigout1 <= sigin1; sigout2 <= sigin2; sigout4 <= sigin4; sigout5 <= sigin5; sigout6 <= sigin6; sigout7 <= sigin7; sigout8 <= sigin8; sigout9 <= sigin9; sigout10 <= sigin10; end; configuration testbench of test is for test end for; end; use work.c01s03b01x00p12n01i00860pkg_a.all; use work.c01s03b01x00p12n01i00860pkg_b.all; ENTITY c01s03b01x00p12n01i00860ent IS END c01s03b01x00p12n01i00860ent; ARCHITECTURE c01s03b01x00p12n01i00860arch OF c01s03b01x00p12n01i00860ent IS component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; begin Sin1(zero) <='1'; Sin2(zero) <= true; Sin4(zero) <= note; Sin5(zero) <= 3; Sin6(zero) <= 3.0; Sin7(zero) <= 3 ns; Sin8(zero) <= 1; Sin9(zero) <= 1; Sin10(zero) <= (C1,C2,C3,C4,C5,C6,C7,C8,C9); K:block component test port( sigin1 : in boolean ; sigout1 : out boolean ; sigin2 : in bit ; sigout2 : out bit ; sigin4 : in severity_level ; sigout4 : out severity_level ; sigin5 : in integer ; sigout5 : out integer ; sigin6 : in real ; sigout6 : out real ; sigin7 : in time ; sigout7 : out time ; sigin8 : in natural ; sigout8 : out natural ; sigin9 : in positive ; sigout9 : out positive ; sigin10 : in record_std_package ; sigout10 : out record_std_package ); end component; BEGIN Gif : if fifteen = 15 generate T5 : test port map ( Sin2(4),Sin2(5), Sin1(4),Sin1(5), Sin4(4),Sin4(5), Sin5(4),Sin5(5), Sin6(4),Sin6(5), Sin7(4),Sin7(5), Sin8(4),Sin8(5), Sin9(4),Sin9(5), Sin10(4),Sin10(5) ); end generate; G: for i in zero to three generate T1:test port map ( Sin2(i),Sin2(i+1), Sin1(i),Sin1(i+1), Sin4(i),Sin4(i+1), Sin5(i),Sin5(i+1), Sin6(i),Sin6(i+1), Sin7(i),Sin7(i+1), Sin8(i),Sin8(i+1), Sin9(i),Sin9(i+1), Sin10(i),Sin10(i+1) ); end generate; end block; TESTING: PROCESS BEGIN wait for 1 ns; assert Sin1(0) = Sin1(5) report "assignment of Sin1(0) to Sin1(4) is invalid through entity port" severity failure; assert Sin2(0) = Sin2(5) report "assignment of Sin2(0) to Sin2(4) is invalid through entity port" severity failure; assert Sin4(0) = Sin4(5) report "assignment of Sin4(0) to Sin4(4) is invalid through entity port" severity failure; assert Sin5(0) = Sin5(5) report "assignment of Sin5(0) to Sin5(4) is invalid through entity port" severity failure; assert Sin6(0) = Sin6(5) report "assignment of Sin6(0) to Sin6(4) is invalid through entity port" severity failure; assert Sin7(0) = Sin7(5) report "assignment of Sin7(0) to Sin7(4) is invalid through entity port" severity failure; assert Sin8(0) = Sin8(5) report "assignment of Sin8(0) to Sin8(4) is invalid through entity port" severity failure; assert Sin9(0) = Sin9(5) report "assignment of Sin9(0) to Sin9(4) is invalid through entity port" severity failure; assert Sin10(0) = Sin10(5) report "assignment of Sin10(0) to Sin10(4) is invalid through entity port" severity failure; assert NOT( Sin1(0) = sin1(5) and Sin2(0) = Sin2(5) and Sin4(0) = Sin4(5) and Sin5(0) = Sin5(5) and Sin6(0) = Sin6(5) and Sin7(0) = Sin7(5) and Sin8(0) = Sin8(5) and Sin9(0) = Sin9(5) and Sin10(0)= Sin10(0) ) report "***PASSED TEST: c01s03b01x00p12n01i00860" severity NOTE; assert ( Sin1(0) = sin1(5) and Sin2(0) = Sin2(5) and Sin4(0) = Sin4(5) and Sin5(0) = Sin5(5) and Sin6(0) = Sin6(5) and Sin7(0) = Sin7(5) and Sin8(0) = Sin8(5) and Sin9(0) = Sin9(5) and Sin10(0)= Sin10(0) ) report "***FAILED TEST: c01s03b01x00p12n01i00860 - If such a block configuration contains an index specification that is a discrete range, then the block configuration applies to those implicit block statements that are generated for the specified range of values of the corresponding generate index." severity ERROR; wait; END PROCESS TESTING; END c01s03b01x00p12n01i00860arch; configuration vests21 of c01s03b01x00p12n01i00860ent is for c01s03b01x00p12n01i00860arch for K for GIF for T5:test use configuration work.testbench; end for; end for; for G(zero) for T1:test use configuration work.testbench; end for; end for; for G(one) for T1:test use configuration work.testbench; end for; end for; for G(two) for T1:test use configuration work.testbench; end for; end for; for G(three) for T1:test use configuration work.testbench; end for; end for; end for; end for; end; nvc-r1.17.1/test/regress/vests22.vhd000066400000000000000000000113321504111170000172030ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc472.vhd,v 1.2 2001-10-26 16:29:55 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY model IS PORT ( F1: OUT integer := 3; F2: INOUT integer := 3; F3: IN integer ); END model; architecture model of model is begin process begin wait for 1 ns; assert F3= 3 report"wrong initialization of F3 through type conversion" severity failure; assert F2 = 3 report"wrong initialization of F2 through type conversion" severity failure; wait; end process; end; ENTITY vests22 IS END vests22; ARCHITECTURE c03s02b01x01p19n01i00472arch OF vests22 IS type boolean_cons_vector is array (15 downto 0) of boolean; type severity_level_cons_vector is array (15 downto 0) of severity_level; type integer_cons_vector is array (15 downto 0) of integer; type real_cons_vector is array (15 downto 0) of real; type time_cons_vector is array (15 downto 0) of time; type natural_cons_vector is array (15 downto 0) of natural; type positive_cons_vector is array (15 downto 0) of positive; type record_cons_array is record a:boolean_cons_vector; b:severity_level_cons_vector; c:integer_cons_vector; d:real_cons_vector; e:time_cons_vector; f:natural_cons_vector; g:positive_cons_vector; end record; type array_rec_cons is array (integer range <>) of record_cons_array; constant C1 : boolean := true; constant C2 : bit := '1'; constant C3 : character := 's'; constant C4 : severity_level := note; constant C5 : integer := 3; constant C6 : real := 3.0; constant C7 : time := 3 ns; constant C8 : natural := 1; constant C9 : positive := 1; constant C19 : boolean_cons_vector := (others => C1); constant C20 : severity_level_cons_vector := (others => C4); constant C21 : integer_cons_vector := (others => C5); constant C22 : real_cons_vector := (others => C6); constant C23 : time_cons_vector := (others => C7); constant C24 : natural_cons_vector := (others => C8); constant C25 : positive_cons_vector := (others => C9); constant C51 : record_cons_array := (C19,C20,C21,C22,C23,C24,C25); constant C66 : array_rec_cons (0 to 7) := (others => C51); function complex_scalar(s : array_rec_cons(0 to 7)) return integer is begin return 3; end complex_scalar; function scalar_complex(s : integer) return array_rec_cons is begin return C66; end scalar_complex; component model1 PORT ( F1: OUT integer; F2: INOUT integer; F3: IN integer ); end component; for T1 : model1 use entity work.model(model); signal S1 : array_rec_cons(0 to 7); signal S2 : array_rec_cons(0 to 7); signal S3 : array_rec_cons(0 to 7):= C66; BEGIN T1: model1 port map ( scalar_complex(F1) => S1, scalar_complex(F2) => complex_scalar(S2), F3 => complex_scalar(S3) ); TESTING: PROCESS BEGIN wait for 1 ns; assert NOT((S1 = C66) and (S2 = C66)) report "***PASSED TEST: c03s02b01x01p19n01i00472" severity NOTE; assert s1 = c66; assert ((S1 = C66) and (S2 = C66)) report "***FAILED TEST: c03s02b01x01p19n01i00472 - For an interface object of mode out, buffer, inout, or linkage, if the formal part includes a type conversion function, then the parameter subtype of that function must be a constrained array subtype." severity ERROR; wait; END PROCESS TESTING; END c03s02b01x01p19n01i00472arch; nvc-r1.17.1/test/regress/vests23.vhd000066400000000000000000000547111504111170000172140ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc749.vhd,v 1.2 2001-10-26 16:29:59 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests23 IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15; C1 : boolean := true; C2 : bit := '1'; C3 : character := 's'; C4 : severity_level:= note; C5 : integer := 3; C6 : real := 3.0; C7 : time := 3 ns; C8 : natural := 1; C9 : positive := 1; C10 : string := "shishir"; C11 : bit_vector := B"0011" ); END vests23; ARCHITECTURE c01s01b01x01p05n02i00749arch OF vests23 IS subtype hi_to_low_range is integer range zero to seven; type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; subtype boolean_vector_st is boolean_vector(zero to fifteen); subtype severity_level_vector_st is severity_level_vector(zero to fifteen); subtype integer_vector_st is integer_vector(zero to fifteen); subtype real_vector_st is real_vector(zero to fifteen); subtype time_vector_st is time_vector(zero to fifteen); subtype natural_vector_st is natural_vector(zero to fifteen); subtype positive_vector_st is positive_vector(zero to fifteen); type boolean_cons_vector is array (fifteen downto zero) of boolean; type severity_level_cons_vector is array (fifteen downto zero) of severity_level; type integer_cons_vector is array (fifteen downto zero) of integer; type real_cons_vector is array (fifteen downto zero) of real; type time_cons_vector is array (fifteen downto zero) of time; type natural_cons_vector is array (fifteen downto zero) of natural; type positive_cons_vector is array (fifteen downto zero) of positive; type boolean_cons_vectorofvector is array (zero to fifteen) of boolean_cons_vector; type severity_level_cons_vectorofvector is array (zero to fifteen) of severity_level_cons_vector; type integer_cons_vectorofvector is array (zero to fifteen) of integer_cons_vector ; type real_cons_vectorofvector is array (zero to fifteen) of real_cons_vector; type time_cons_vectorofvector is array (zero to fifteen) of time_cons_vector; type natural_cons_vectorofvector is array (zero to fifteen) of natural_cons_vector; type positive_cons_vectorofvector is array (zero to fifteen) of positive_cons_vector; type record_std_package is record a:boolean; b:bit; c:character; d:severity_level; e:integer; f:real; g:time; h:natural; i:positive; j:string(one to seven); k:bit_vector(zero to three); end record; type record_array_st is record a:boolean_vector_st; b:severity_level_vector_st; c:integer_vector_st; d:real_vector_st; e:time_vector_st; f:natural_vector_st; g:positive_vector_st; end record; type record_cons_array is record a:boolean_cons_vector; b:severity_level_cons_vector; c:integer_cons_vector; d:real_cons_vector; e:time_cons_vector; f:natural_cons_vector; g:positive_cons_vector; end record; type record_cons_arrayofarray is record a:boolean_cons_vectorofvector; b:severity_level_cons_vectorofvector; c:integer_cons_vectorofvector; d:real_cons_vectorofvector; e:time_cons_vectorofvector; f:natural_cons_vectorofvector; g:positive_cons_vectorofvector; end record; type record_array_new is record a:boolean_vector(zero to fifteen); b:severity_level_vector(zero to fifteen); c:integer_vector(zero to fifteen); d:real_vector(zero to fifteen); e:time_vector(zero to fifteen); f:natural_vector(zero to fifteen); g:positive_vector(zero to fifteen); end record; type record_of_records is record a: record_std_package; c: record_cons_array; g: record_cons_arrayofarray; i: record_array_st; j: record_array_new; end record; subtype boolean_vector_range is boolean_vector(hi_to_low_range); subtype severity_level_vector_range is severity_level_vector(hi_to_low_range); subtype integer_vector_range is integer_vector(hi_to_low_range); subtype real_vector_range is real_vector(hi_to_low_range); subtype time_vector_range is time_vector(hi_to_low_range); subtype natural_vector_range is natural_vector(hi_to_low_range); subtype positive_vector_range is positive_vector(hi_to_low_range); type array_rec_std is array (integer range <>) of record_std_package; type array_rec_cons is array (integer range <>) of record_cons_array; type array_rec_rec is array (integer range <>) of record_of_records; subtype array_rec_std_st is array_rec_std (hi_to_low_range); subtype array_rec_cons_st is array_rec_cons (hi_to_low_range); subtype array_rec_rec_st is array_rec_rec (hi_to_low_range); type record_of_arr_of_record is record a: array_rec_std(zero to seven); b: array_rec_cons(zero to seven); c: array_rec_rec(zero to seven); end record; type current is range -2147483647 to +2147483647 units nA; uA = 1000 nA; mA = 1000 uA; A = 1000 mA; end units; type current_vector is array (natural range <>) of current; subtype current_vector_range is current_vector(hi_to_low_range); type resistance is range -2147483647 to +2147483647 units uOhm; mOhm = 1000 uOhm; Ohm = 1000 mOhm; KOhm = 1000 Ohm; end units; type resistance_vector is array (natural range <>) of resistance; subtype resistance_vector_range is resistance_vector(hi_to_low_range); type byte is array(zero to seven) of bit; subtype word is bit_vector(zero to fifteen); --constrained array constant size :integer := seven; type primary_memory is array(zero to size) of word; --array of an array type primary_memory_module is --record with field record --as an array enable:bit; memory_number:primary_memory; end record; type whole_memory is array(0 to size) of primary_memory_module; --array of a complex record subtype delay is integer range one to 10; constant C12 : boolean_vector := (C1,false); constant C13 : severity_level_vector := (C4,error); constant C14 : integer_vector := (one,two,three,four); constant C15 : real_vector := (1.0,2.0,C6,4.0); constant C16 : time_vector := (1 ns, 2 ns,C7, 4 ns); constant C17 : natural_vector := (one,2,3,4); constant C18 : positive_vector := (one,2,3,4); constant C19 : boolean_cons_vector := (others => C1); constant C20 : severity_level_cons_vector := (others => C4); constant C21 : integer_cons_vector := (others => C5); constant C22 : real_cons_vector := (others => C6); constant C23 : time_cons_vector := (others => C7); constant C24 : natural_cons_vector := (others => C8); constant C25 : positive_cons_vector := (others => C9); constant C26 : boolean_cons_vectorofvector := (others => (others => C1)); constant C27 : severity_level_cons_vectorofvector := (others => (others => C4)); constant C28 : integer_cons_vectorofvector := (others => (others => C5)); constant C29 : real_cons_vectorofvector := (others => (others => C6)); constant C30 : time_cons_vectorofvector := (others => (others => C7)); constant C31 : natural_cons_vectorofvector := (others => (others => C8)); constant C32 : positive_cons_vectorofvector := (others => (others => C9)); constant C50 : record_std_package := (C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11); constant C51 : record_cons_array := (C19,C20,C21,C22,C23,C24,C25); constant C53 : record_cons_arrayofarray := (C26,C27,C28,C29,C30,C31,C32); constant C70 : boolean_vector_st :=(others => C1); constant C71 : severity_level_vector_st := (others => C4); constant C72 : integer_vector_st:=(others => C5); constant C73 : real_vector_st :=(others => C6); constant C74 : time_vector_st :=(others => C7); constant C75 : natural_vector_st:=(others => C8); constant C76 : positive_vector_st:=(others => C9); constant C77 : record_array_st := (C70,C71,C72,C73,C74,C75,C76); constant C54a :record_array_st := (C70,C71,C72,C73,C74,C75,C76); constant C54b: record_array_new := (C70,C71,C72,C73,C74,C75,C76); constant C55 : record_of_records:= (C50,C51,C53,C77,C54b); constant C60 : byte := (others => '0'); constant C61 : word := (others =>'0' ); constant C64 : primary_memory := (others => C61); constant C65 : primary_memory_module := ('1',C64); constant C66 : whole_memory := (others => C65); constant C67 : current := 1 A; constant C68 : resistance := 1 Ohm; constant C69 : delay := 2; constant C78: boolean_vector_range := (others => C1); constant C79: severity_level_vector_range := (others => C4) ; constant C80: integer_vector_range :=(others => C5) ; constant C81: real_vector_range :=(others => C6); constant C82: time_vector_range :=(others => C7); constant C83: natural_vector_range :=(others => C8); constant C84: positive_vector_range :=(others => C9); constant C85: array_rec_std(0 to 7) :=(others => C50) ; constant C86: array_rec_cons (0 to 7) :=(others => C51); constant C88: array_rec_rec(0 to 7) :=(others => C55); constant C102: record_of_arr_of_record := (C85,C86,C88); signal V1 : boolean_vector(zero to fifteen) ; signal V2 : severity_level_vector(zero to fifteen); signal V3 : integer_vector(zero to fifteen) ; signal V4 : real_vector(zero to fifteen) ; signal V5 : time_vector (zero to fifteen); signal V6 : natural_vector(zero to fifteen); signal V7 : positive_vector(zero to fifteen); signal V8 : boolean_cons_vector; signal V9 : severity_level_cons_vector ; signal V10 : integer_cons_vector; signal V11 : real_cons_vector; signal V12 : time_cons_vector ; signal V13 : natural_cons_vector ; signal V14 : positive_cons_vector ; signal V15 : boolean_cons_vectorofvector ; signal V16 : severity_level_cons_vectorofvector; signal V17 : integer_cons_vectorofvector; signal V18 : real_cons_vectorofvector; signal V19 : time_cons_vectorofvector; signal V20 : natural_cons_vectorofvector; signal V21 : positive_cons_vectorofvector; signal V22 : record_std_package; signal V23 : record_cons_array ; signal V24 : record_cons_arrayofarray ; signal V25 : boolean_vector_st ; signal V26 : severity_level_vector_st ; signal V27 : integer_vector_st ; signal V28 : real_vector_st ; signal V29 : time_vector_st ; signal V30 : natural_vector_st ; signal V31 : positive_vector_st ; signal V32 : record_array_st ; signal V33 : record_array_st ; signal V34 : record_array_new ; signal V35 : record_of_records ; signal V36 : byte ; signal V37 : word ; signal V41 : boolean_vector_range ; signal V42 : severity_level_vector_range ; signal V43 : integer_vector_range ; signal V44 : real_vector_range ; signal V45 : time_vector_range ; signal V46 : natural_vector_range ; signal V47 : positive_vector_range ; signal V48 : array_rec_std(zero to seven) ; signal V49 : array_rec_cons(zero to seven) ; signal V50 : array_rec_rec(zero to seven) ; signal V51 : record_of_arr_of_record ; BEGIN V1 <= (zero to fifteen => C1); V2 <= (zero to fifteen => C4); V3 <= (zero to fifteen => C5); V4 <= (zero to fifteen => C6); V5 <= (zero to fifteen => C7); V6 <= (zero to fifteen => C8); V7 <= (zero to fifteen => C9); V8 <= C19; V9 <= C20; V10 <= C21; V11 <= C22; V12 <= C23; V13 <= C24; V14 <= C25; V15 <= C26; V16 <= C27; V17 <= C28; V18 <= C29; V19 <= C30; V20 <= C31; V21 <= C32; V22 <= C50; V23 <= C51; V24 <= C53; V25 <= C70; V26 <= C71; V27 <= C72; V28 <= C73; V29 <= C74; V30 <= C75; V31 <= C76; V32 <= C54a; V33 <= C54a; V34 <= C54b; V35 <= C55; V36 <= C60; V37 <= C61; V41 <= C78; V42 <= C79; V43 <= C80; V44 <= C81; V45 <= C82; V46 <= C83; V47 <= C84; V48 <= C85; V49 <= C86; V50 <= C88; V51 <= C102; TESTING: PROCESS BEGIN wait for 1 ns; assert (V1(0) = C1) report " error in initializing S1" severity error; assert (V2(0) = C4) report " error in initializing S2" severity error; assert (V3(0) = C5) report " error in initializing S3" severity error; assert (V4(0) = C6) report " error in initializing S4" severity error; assert (V5(0) = C7) report " error in initializing S5" severity error; assert (V6(0) = C8) report " error in initializing S6" severity error; assert (V7(0) = C9) report " error in initializing S7" severity error; assert V8 = C19 report " error in initializing S8" severity error; assert V9 = C20 report " error in initializing S9" severity error; assert V10 = C21 report " error in initializing S10" severity error; assert V11 = C22 report " error in initializing S11" severity error; assert V12 = C23 report " error in initializing S12" severity error; assert V13 = C24 report " error in initializing S13" severity error; assert V14 = C25 report " error in initializing S14" severity error; assert V15 = C26 report " error in initializing S15" severity error; assert V16 = C27 report " error in initializing S16" severity error; assert V17 = C28 report " error in initializing S17" severity error; assert V18 = C29 report " error in initializing S18" severity error; assert V19 = C30 report " error in initializing S19" severity error; assert V20 = C31 report " error in initializing S20" severity error; assert V21 = C32 report " error in initializing S21" severity error; assert V22 = C50 report " error in initializing S22" severity error; assert V23 = C51 report " error in initializing S23" severity error; assert V24 = C53 report " error in initializing S24" severity error; assert V25 = C70 report " error in initializing S25" severity error; assert V26 = C71 report " error in initializing S26" severity error; assert V27 = C72 report " error in initializing S27" severity error; assert V28 = C73 report " error in initializing S28" severity error; assert V29 = C74 report " error in initializing S29" severity error; assert V30 = C75 report " error in initializing S30" severity error; assert V31 = C76 report " error in initializing S31" severity error; assert V32 = C54a report " error in initializing S32" severity error; assert V33 = C54a report " error in initializing S33" severity error; assert V34= C54b report " error in initializing S34" severity error; assert V35 = C55 report " error in initializing S35" severity error; assert V36 = C60 report " error in initializing S36" severity error; assert V37 = C61 report " error in initializing S37" severity error; assert V41= C78 report " error in initializing S41" severity error; assert V42= C79 report " error in initializing S42" severity error; assert V43= C80 report " error in initializing S43" severity error; assert V44= C81 report " error in initializing S44" severity error; assert V45= C82 report " error in initializing S45" severity error; assert V46= C83 report " error in initializing S46" severity error; assert V47= C84 report " error in initializing S47" severity error; assert V48= C85 report " error in initializing S48" severity error; assert V49= C86 report " error in initializing S49" severity error; assert V50= C88 report " error in initializing S50" severity error; assert V51= C102 report " error in initializing S51" severity error; assert NOT( (V1(0) = C1) and (V2(0) = C4) and (V3(0) = C5) and (V4(0) = C6) and (V5(0) = C7) and (V6(0) = C8) and (V7(0) = C9) and V8 = C19 and V9 = C20 and V10 = C21 and V11 = C22 and V12 = C23 and V13 = C24 and V14 = C25 and V15 = C26 and V16 = C27 and V17 = C28 and V18 = C29 and V19 = C30 and V20 = C31 and V21 = C32 and V22 = C50 and V23 = C51 and V24 = C53 and V25 = C70 and V26 = C71 and V27 = C72 and V28 = C73 and V29 = C74 and V30 = C75 and V31 = C76 and V32 = C54a and V33 = C54a and V34= C54b and V35 = C55 and V36 = C60 and V37 = C61 and V41= C78 and V42= C79 and V43= C80 and V44= C81 and V45= C82 and V46= C83 and V47= C84 and V48= C85 and V49= C86 and V50= C88 and V51= C102 ) report "***PASSED TEST: c01s01b01x01p05n02i00749" severity NOTE; assert ( (V1(0) = C1) and (V2(0) = C4) and (V3(0) = C5) and (V4(0) = C6) and (V5(0) = C7) and (V6(0) = C8) and (V7(0) = C9) and V8 = C19 and V9 = C20 and V10 = C21 and V11 = C22 and V12 = C23 and V13 = C24 and V14 = C25 and V15 = C26 and V16 = C27 and V17 = C28 and V18 = C29 and V19 = C30 and V20 = C31 and V21 = C32 and V22 = C50 and V23 = C51 and V24 = C53 and V25 = C70 and V26 = C71 and V27 = C72 and V28 = C73 and V29 = C74 and V30 = C75 and V31 = C76 and V32 = C54a and V33 = C54a and V34= C54b and V35 = C55 and V36 = C60 and V37 = C61 and V41= C78 and V42= C79 and V43= C80 and V44= C81 and V45= C82 and V46= C83 and V47= C84 and V48= C85 and V49= C86 and V50= C88 and V51= C102 ) report "***FAILED TEST: c01s01b01x01p05n02i00749 - Generic can be used to specify the size of ports." severity ERROR; wait; END PROCESS TESTING; END c01s01b01x01p05n02i00749arch; nvc-r1.17.1/test/regress/vests24.vhd000066400000000000000000000043411504111170000172070ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3144.vhd,v 1.2 2001-10-26 16:29:52 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c05s02b02x00p10n01i03144ent_a IS generic ( g1 : real := 22.0 ); END c05s02b02x00p10n01i03144ent_a; ARCHITECTURE c05s02b02x00p10n01i03144arch_a OF c05s02b02x00p10n01i03144ent_a IS BEGIN TESTING: PROCESS BEGIN assert NOT( g1 = 22.0 ) report "***PASSED TEST: c05s02b02x00p10n01i03144" severity NOTE; assert ( g1 = 22.0 ) report "***FAILED TEST: c05s02b02x00p10n01i03144 - The formal generics take on implicit OPENs." severity ERROR; wait; END PROCESS TESTING; END c05s02b02x00p10n01i03144arch_a; -- ENTITY c05s02b02x00p10n01i03144ent IS END c05s02b02x00p10n01i03144ent; ARCHITECTURE c05s02b02x00p10n01i03144arch OF c05s02b02x00p10n01i03144ent IS component c05s02b02x00p10n01i03144ent_a end component; for comp1 : c05s02b02x00p10n01i03144ent_a use entity work.c05s02b02x00p10n01i03144ent_a(c05s02b02x00p10n01i03144arch_a) generic map(OPEN); BEGIN comp1 : c05s02b02x00p10n01i03144ent_a; END c05s02b02x00p10n01i03144arch; configuration vests24 of c05s02b02x00p10n01i03144ent is for c05s02b02x00p10n01i03144arch end for; end vests24; nvc-r1.17.1/test/regress/vests25.vhd000066400000000000000000000043731504111170000172150ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc99.vhd,v 1.2 2001-10-26 16:30:02 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c04s03b02x00p29n02i00099ent_a IS END c04s03b02x00p29n02i00099ent_a; ARCHITECTURE c04s03b02x00p29n02i00099arch_a OF c04s03b02x00p29n02i00099ent_a IS PROCEDURE p1 ( prm_in : IN INTEGER ) IS ATTRIBUTE attr1 : INTEGER; ATTRIBUTE attr1 OF prm_in : constant IS 300; BEGIN ASSERT prm_in'attr1 = 300 REPORT "ERROR: Bad value for prm_in'attr1" SEVERITY FAILURE; assert NOT(prm_in'attr1 = 300) report "***PASSED TEST: c04s03b02x00p29n02i00099" severity NOTE; assert (prm_in'attr1 = 300) report "***FAILED TEST: c04s03b02x00p29n02i00099 - Attribute reading in subprogram fail." severity ERROR; END; BEGIN PROCESS BEGIN -- p1 ( 0 ); -- wait; END PROCESS; END c04s03b02x00p29n02i00099arch_a; ENTITY vests25 IS END vests25; ARCHITECTURE c04s03b02x00p29n02i00099arch OF vests25 IS COMPONENT c04s03b02x00p29n02i00099ent_a END COMPONENT; FOR cmp1 : c04s03b02x00p29n02i00099ent_a USE ENTITY work.c04s03b02x00p29n02i00099ent_a(c04s03b02x00p29n02i00099arch_a); SIGNAL s : INTEGER; BEGIN cmp1 : c04s03b02x00p29n02i00099ent_a; END c04s03b02x00p29n02i00099arch; nvc-r1.17.1/test/regress/vests26.vhd000066400000000000000000000237171504111170000172210ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc992.vhd,v 1.2 2001-10-26 16:30:02 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- PACKAGE c06s03b00x00p08n01i00992pkg IS -- -- This packages contains declarations of User attributes -- -- ---------------------------------------------------------------------- -- TYPE RESISTANCE IS RANGE 0 TO 1E9 UNITS pf; nf = 1000 pf; mf = 1000 nf; END UNITS; TYPE t_logic IS ( U, D, Z0, Z1, ZDX, DZX, ZX, W0, W1, WZ0, WZ1, WDX, DWX, WZX, ZWX, WX, R0, R1, RW0, RW1, RZ0, RZ1, RDX, DRX, RZX, ZRX, RWX, WRX, RX, F0, F1, FR0, FR1, FW0, FW1, FZ0, FZ1, FDX, DFX, FZX, ZFX, FWX, WFX, FRX, RFX, FX ); -- -- Scalar types Declarations -- SUBTYPE st_scl1 IS BOOLEAN; SUBTYPE st_scl2 IS BIT; SUBTYPE st_scl3 IS CHARACTER; SUBTYPE st_scl4 IS INTEGER; SUBTYPE st_scl5 IS REAL; SUBTYPE st_scl6 IS TIME; SUBTYPE st_scl7 IS RESISTANCE; SUBTYPE st_scl8 IS t_logic; -- -- character string types -- SUBTYPE st_str1 IS STRING; SUBTYPE st_str2 IS STRING (1 TO 4); -- -- Scalar types with a range constraint -- SUBTYPE cst_scl1 IS BOOLEAN RANGE TRUE TO TRUE; SUBTYPE cst_scl2 IS BIT RANGE '0' TO '0'; SUBTYPE cst_scl3 IS CHARACTER RANGE 'a' TO 'z'; SUBTYPE cst_scl4 IS INTEGER RANGE 10 DOWNTO 0; SUBTYPE cst_scl5 IS REAL RANGE 0.0 TO 10.0; SUBTYPE cst_scl6 IS TIME RANGE 0 fs TO 10 ns; SUBTYPE cst_scl7 IS RESISTANCE RANGE 0 pf TO 10000 pf; SUBTYPE cst_scl8 IS t_logic RANGE F0 TO FX; -- ----------------------------------------------------------------------------------------- -- Attribute Declarations -- ----------------------------------------------------------------------------------------- -- ATTRIBUTE atr_scl1 : st_scl1; ATTRIBUTE atr_scl2 : st_scl2; ATTRIBUTE atr_scl3 : st_scl3; ATTRIBUTE atr_scl4 : st_scl4; ATTRIBUTE atr_scl5 : st_scl5; ATTRIBUTE atr_scl6 : st_scl6; ATTRIBUTE atr_scl7 : st_scl7; ATTRIBUTE atr_scl8 : st_scl8; ATTRIBUTE atr_str1 : st_str1; ATTRIBUTE atr_str2 : st_str2; ATTRIBUTE cat_scl1 : cst_scl1; ATTRIBUTE cat_scl2 : cst_scl2; ATTRIBUTE cat_scl3 : cst_scl3; ATTRIBUTE cat_scl4 : cst_scl4; ATTRIBUTE cat_scl5 : cst_scl5; ATTRIBUTE cat_scl6 : cst_scl6; ATTRIBUTE cat_scl7 : cst_scl7; ATTRIBUTE cat_scl8 : cst_scl8; -- ========================================================================================= -- -- Apply attributes to the package -- ATTRIBUTE atr_scl1 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS TRUE; ATTRIBUTE atr_scl2 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS '0'; ATTRIBUTE atr_scl3 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 'z'; ATTRIBUTE atr_scl4 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 0; ATTRIBUTE atr_scl5 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10.0; ATTRIBUTE atr_scl6 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10 ns; ATTRIBUTE atr_scl7 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10000 pf; ATTRIBUTE atr_scl8 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS FX; ATTRIBUTE atr_str1 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS "packit"; ATTRIBUTE atr_str2 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS "pack"; ATTRIBUTE cat_scl1 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS TRUE; ATTRIBUTE cat_scl2 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS '0'; ATTRIBUTE cat_scl3 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 'z'; ATTRIBUTE cat_scl4 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 0; ATTRIBUTE cat_scl5 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10.0; ATTRIBUTE cat_scl6 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10 ns; ATTRIBUTE cat_scl7 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS 10000 pf; ATTRIBUTE cat_scl8 OF c06s03b00x00p08n01i00992pkg: PACKAGE IS FX; -- END; use work.all; use c06s03b00x00p08n01i00992pkg.all; ENTITY vests26 IS END vests26; ARCHITECTURE c06s03b00x00p08n01i00992arch OF vests26 IS BEGIN TESTING: PROCESS BEGIN ASSERT c06s03b00x00p08n01i00992pkg'atr_scl1 = TRUE REPORT "ERROR: Wrong value for 'atr_scl1" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl2 = '0' REPORT "ERROR: Wrong value for 'atr_scl2" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl3 = 'z' REPORT "ERROR: Wrong value for 'atr_scl3" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl4 = 0 REPORT "ERROR: Wrong value for 'atr_scl4" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl5 = 10.0 REPORT "ERROR: Wrong value for 'atr_scl5" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl6 = 10 ns REPORT "ERROR: Wrong value for 'atr_scl6" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl7 = 10000 pf REPORT "ERROR: Wrong value for 'atr_scl7" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_scl8 = FX REPORT "ERROR: Wrong value for 'atr_scl8" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_str1 = "packit" REPORT "ERROR: Wrong value for 'atr_str1" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'atr_str2 = "pack" REPORT "ERROR: Wrong value for 'atr_str2" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl1 = TRUE REPORT "ERROR: Wrong value for 'cat_scl1" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl2 = '0' REPORT "ERROR: Wrong value for 'cat_scl2" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl3 = 'z' REPORT "ERROR: Wrong value for 'cat_scl3" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl4 = 0 REPORT "ERROR: Wrong value for 'cat_scl4" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl5 = 10.0 REPORT "ERROR: Wrong value for 'cat_scl5" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl6 = 10 ns REPORT "ERROR: Wrong value for 'cat_scl6" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl7 = 10000 pf REPORT "ERROR: Wrong value for 'cat_scl7" SEVERITY FAILURE; ASSERT c06s03b00x00p08n01i00992pkg'cat_scl8 = FX REPORT "ERROR: Wrong value for 'cat_scl8" SEVERITY FAILURE; assert NOT( c06s03b00x00p08n01i00992pkg'atr_scl1 = TRUE and c06s03b00x00p08n01i00992pkg'atr_scl2 = '0' and c06s03b00x00p08n01i00992pkg'atr_scl3 = 'z' and c06s03b00x00p08n01i00992pkg'atr_scl4 = 0 and c06s03b00x00p08n01i00992pkg'atr_scl5 = 10.0 and c06s03b00x00p08n01i00992pkg'atr_scl6 = 10 ns and c06s03b00x00p08n01i00992pkg'atr_scl7 = 10000 pf and c06s03b00x00p08n01i00992pkg'atr_scl8 = FX and c06s03b00x00p08n01i00992pkg'atr_str1 = "packit" and c06s03b00x00p08n01i00992pkg'atr_str2 = "pack" and c06s03b00x00p08n01i00992pkg'cat_scl1 = TRUE and c06s03b00x00p08n01i00992pkg'cat_scl2 = '0' and c06s03b00x00p08n01i00992pkg'cat_scl3 = 'z' and c06s03b00x00p08n01i00992pkg'cat_scl4 = 0 and c06s03b00x00p08n01i00992pkg'cat_scl5 = 10.0 and c06s03b00x00p08n01i00992pkg'cat_scl6 = 10 ns and c06s03b00x00p08n01i00992pkg'cat_scl7 = 10000 pf and c06s03b00x00p08n01i00992pkg'cat_scl8 = FX) report "***PASSED TEST: c06s03b00x00p08n01i00992" severity NOTE; assert ( c06s03b00x00p08n01i00992pkg'atr_scl1 = TRUE and c06s03b00x00p08n01i00992pkg'atr_scl2 = '0' and c06s03b00x00p08n01i00992pkg'atr_scl3 = 'z' and c06s03b00x00p08n01i00992pkg'atr_scl4 = 0 and c06s03b00x00p08n01i00992pkg'atr_scl5 = 10.0 and c06s03b00x00p08n01i00992pkg'atr_scl6 = 10 ns and c06s03b00x00p08n01i00992pkg'atr_scl7 = 10000 pf and c06s03b00x00p08n01i00992pkg'atr_scl8 = FX and c06s03b00x00p08n01i00992pkg'atr_str1 = "packit" and c06s03b00x00p08n01i00992pkg'atr_str2 = "pack" and c06s03b00x00p08n01i00992pkg'cat_scl1 = TRUE and c06s03b00x00p08n01i00992pkg'cat_scl2 = '0' and c06s03b00x00p08n01i00992pkg'cat_scl3 = 'z' and c06s03b00x00p08n01i00992pkg'cat_scl4 = 0 and c06s03b00x00p08n01i00992pkg'cat_scl5 = 10.0 and c06s03b00x00p08n01i00992pkg'cat_scl6 = 10 ns and c06s03b00x00p08n01i00992pkg'cat_scl7 = 10000 pf and c06s03b00x00p08n01i00992pkg'cat_scl8 = FX) report "***FAILED TEST: c06s03b00x00p08n01i00992 - Expanded name denotes a primary unit contained in design library test failed." severity ERROR; wait; END PROCESS TESTING; END c06s03b00x00p08n01i00992arch; nvc-r1.17.1/test/regress/vests27.vhd000066400000000000000000000401551504111170000172150ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1945.vhd,v 1.2 2001-10-26 16:29:44 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c07s02b01x00p01n02i01945pkg is -- -- Index types for array declarations -- SUBTYPE st_ind1 IS INTEGER RANGE 1 TO 4; -- index from 1 (POSITIVE) SUBTYPE st_ind2 IS INTEGER RANGE 0 TO 3; -- index from 0 (NATURAL) SUBTYPE st_ind3 IS CHARACTER RANGE 'a' TO 'd'; -- non-INTEGER index SUBTYPE st_ind4 IS INTEGER RANGE 0 DOWNTO -3; -- descending range -- -- Logic types for subelements -- SUBTYPE st_scl1 IS BIT; SUBTYPE st_scl2 IS BOOLEAN; -- ----------------------------------------------------------------------------------------- -- Composite type declarations -- ----------------------------------------------------------------------------------------- -- -- Unconstrained arrays -- TYPE t_usa1_1 IS ARRAY (st_ind1 RANGE <>) OF BIT; TYPE t_usa1_2 IS ARRAY (st_ind2 RANGE <>) OF BOOLEAN; TYPE t_usa1_3 IS ARRAY (st_ind3 RANGE <>) OF BIT; TYPE t_usa1_4 IS ARRAY (st_ind4 RANGE <>) OF BOOLEAN; -- -- Constrained arrays of scalars (make compatable with unconstrained types -- SUBTYPE t_csa1_1 IS t_usa1_1 (st_ind1); SUBTYPE t_csa1_2 IS t_usa1_2 (st_ind2); SUBTYPE t_csa1_3 IS t_usa1_3 (st_ind3); SUBTYPE t_csa1_4 IS t_usa1_4 (st_ind4); -- ---------------------------------------------------------------------------------------------- -- -- TYPE declarations for resolution function (Constrained types only) -- TYPE t_csa1_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_1; TYPE t_csa1_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_2; TYPE t_csa1_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_3; TYPE t_csa1_4_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_4; end; use work.c07s02b01x00p01n02i01945pkg.all; ENTITY vests27 IS END vests27; ARCHITECTURE c07s02b01x00p01n02i01945arch OF vests27 IS -- -- CONSTANT Declarations -- CONSTANT ARGA_C_csa1_1 : t_csa1_1 := ( '1', '1', '0', '0' ); CONSTANT ARGA_C_usa1_1 : t_usa1_1(st_ind1) := ( '1', '1', '0', '0' ); CONSTANT ARGB_C_csa1_1 : t_csa1_1 := ( '1', '0', '1', '0' ); CONSTANT ARGB_C_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '1', '0' ); CONSTANT AND_C_csa1_1 : t_csa1_1 := ( '1', '0', '0', '0' ); CONSTANT AND_C_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '0', '0' ); CONSTANT ARGA_C_csa1_2 : t_csa1_2 := ( TRUE, TRUE, FALSE, FALSE ); CONSTANT ARGA_C_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, TRUE, FALSE, FALSE ); CONSTANT ARGB_C_csa1_2 : t_csa1_2 := ( TRUE, FALSE, TRUE, FALSE ); CONSTANT ARGB_C_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, TRUE, FALSE ); CONSTANT AND_C_csa1_2 : t_csa1_2 := ( TRUE, FALSE, FALSE, FALSE ); CONSTANT AND_C_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, FALSE, FALSE ); CONSTANT ARGA_C_csa1_3 : t_csa1_3 := ( '1', '1', '0', '0' ); CONSTANT ARGA_C_usa1_3 : t_usa1_3(st_ind3) := ( '1', '1', '0', '0' ); CONSTANT ARGB_C_csa1_3 : t_csa1_3 := ( '1', '0', '1', '0' ); CONSTANT ARGB_C_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '1', '0' ); CONSTANT AND_C_csa1_3 : t_csa1_3 := ( '1', '0', '0', '0' ); CONSTANT AND_C_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '0', '0' ); CONSTANT ARGA_C_csa1_4 : t_csa1_4 := ( TRUE, TRUE, FALSE, FALSE ); CONSTANT ARGA_C_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, TRUE, FALSE, FALSE ); CONSTANT ARGB_C_csa1_4 : t_csa1_4 := ( TRUE, FALSE, TRUE, FALSE ); CONSTANT ARGB_C_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, TRUE, FALSE ); CONSTANT AND_C_csa1_4 : t_csa1_4 := ( TRUE, FALSE, FALSE, FALSE ); CONSTANT AND_C_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, FALSE, FALSE ); -- -- SIGNAL Declarations -- SIGNAL ARGA_S_csa1_1 : t_csa1_1 := ( '1', '1', '0', '0' ); SIGNAL ARGA_S_usa1_1 : t_usa1_1(st_ind1) := ( '1', '1', '0', '0' ); SIGNAL ARGB_S_csa1_1 : t_csa1_1 := ( '1', '0', '1', '0' ); SIGNAL ARGB_S_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '1', '0' ); SIGNAL AND_S_csa1_1 : t_csa1_1 := ( '1', '0', '0', '0' ); SIGNAL AND_S_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '0', '0' ); SIGNAL ARGA_S_csa1_2 : t_csa1_2 := ( TRUE, TRUE, FALSE, FALSE ); SIGNAL ARGA_S_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, TRUE, FALSE, FALSE ); SIGNAL ARGB_S_csa1_2 : t_csa1_2 := ( TRUE, FALSE, TRUE, FALSE ); SIGNAL ARGB_S_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, TRUE, FALSE ); SIGNAL AND_S_csa1_2 : t_csa1_2 := ( TRUE, FALSE, FALSE, FALSE ); SIGNAL AND_S_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, FALSE, FALSE ); SIGNAL ARGA_S_csa1_3 : t_csa1_3 := ( '1', '1', '0', '0' ); SIGNAL ARGA_S_usa1_3 : t_usa1_3(st_ind3) := ( '1', '1', '0', '0' ); SIGNAL ARGB_S_csa1_3 : t_csa1_3 := ( '1', '0', '1', '0' ); SIGNAL ARGB_S_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '1', '0' ); SIGNAL AND_S_csa1_3 : t_csa1_3 := ( '1', '0', '0', '0' ); SIGNAL AND_S_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '0', '0' ); SIGNAL ARGA_S_csa1_4 : t_csa1_4 := ( TRUE, TRUE, FALSE, FALSE ); SIGNAL ARGA_S_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, TRUE, FALSE, FALSE ); SIGNAL ARGB_S_csa1_4 : t_csa1_4 := ( TRUE, FALSE, TRUE, FALSE ); SIGNAL ARGB_S_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, TRUE, FALSE ); SIGNAL AND_S_csa1_4 : t_csa1_4 := ( TRUE, FALSE, FALSE, FALSE ); SIGNAL AND_S_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, FALSE, FALSE ); BEGIN TESTING: PROCESS -- -- VARIABLE Declarations -- VARIABLE ARGA_V_csa1_1 : t_csa1_1 := ( '1', '1', '0', '0' ); VARIABLE ARGA_V_usa1_1 : t_usa1_1(st_ind1) := ( '1', '1', '0', '0' ); VARIABLE ARGB_V_csa1_1 : t_csa1_1 := ( '1', '0', '1', '0' ); VARIABLE ARGB_V_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '1', '0' ); VARIABLE AND_V_csa1_1 : t_csa1_1 := ( '1', '0', '0', '0' ); VARIABLE AND_V_usa1_1 : t_usa1_1(st_ind1) := ( '1', '0', '0', '0' ); VARIABLE ARGA_V_csa1_2 : t_csa1_2 := ( TRUE, TRUE, FALSE, FALSE ); VARIABLE ARGA_V_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, TRUE, FALSE, FALSE ); VARIABLE ARGB_V_csa1_2 : t_csa1_2 := ( TRUE, FALSE, TRUE, FALSE ); VARIABLE ARGB_V_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, TRUE, FALSE ); VARIABLE AND_V_csa1_2 : t_csa1_2 := ( TRUE, FALSE, FALSE, FALSE ); VARIABLE AND_V_usa1_2 : t_usa1_2(st_ind2) := ( TRUE, FALSE, FALSE, FALSE ); VARIABLE ARGA_V_csa1_3 : t_csa1_3 := ( '1', '1', '0', '0' ); VARIABLE ARGA_V_usa1_3 : t_usa1_3(st_ind3) := ( '1', '1', '0', '0' ); VARIABLE ARGB_V_csa1_3 : t_csa1_3 := ( '1', '0', '1', '0' ); VARIABLE ARGB_V_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '1', '0' ); VARIABLE AND_V_csa1_3 : t_csa1_3 := ( '1', '0', '0', '0' ); VARIABLE AND_V_usa1_3 : t_usa1_3(st_ind3) := ( '1', '0', '0', '0' ); VARIABLE ARGA_V_csa1_4 : t_csa1_4 := ( TRUE, TRUE, FALSE, FALSE ); VARIABLE ARGA_V_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, TRUE, FALSE, FALSE ); VARIABLE ARGB_V_csa1_4 : t_csa1_4 := ( TRUE, FALSE, TRUE, FALSE ); VARIABLE ARGB_V_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, TRUE, FALSE ); VARIABLE AND_V_csa1_4 : t_csa1_4 := ( TRUE, FALSE, FALSE, FALSE ); VARIABLE AND_V_usa1_4 : t_usa1_4(st_ind4) := ( TRUE, FALSE, FALSE, FALSE ); BEGIN -- -- Test AND operator on: CONSTANTs -- ASSERT ( ARGA_C_csa1_1 AND ARGB_C_csa1_1 ) = AND_C_csa1_1 REPORT "ERROR: composite AND operator failed; CONSTANT; csa1_1" SEVERITY FAILURE; ASSERT ( ARGA_C_csa1_2 AND ARGB_C_csa1_2 ) = AND_C_csa1_2 REPORT "ERROR: composite AND operator failed; CONSTANT; csa1_2" SEVERITY FAILURE; ASSERT ( ARGA_C_csa1_3 AND ARGB_C_csa1_3 ) = AND_C_csa1_3 REPORT "ERROR: composite AND operator failed; CONSTANT; csa1_3" SEVERITY FAILURE; ASSERT ( ARGA_C_csa1_4 AND ARGB_C_csa1_4 ) = AND_C_csa1_4 REPORT "ERROR: composite AND operator failed; CONSTANT; csa1_4" SEVERITY FAILURE; ASSERT ( ARGA_C_usa1_1 AND ARGB_C_usa1_1 ) = AND_C_usa1_1 REPORT "ERROR: composite AND operator failed; CONSTANT; usa1_1" SEVERITY FAILURE; ASSERT ( ARGA_C_usa1_2 AND ARGB_C_usa1_2 ) = AND_C_usa1_2 REPORT "ERROR: composite AND operator failed; CONSTANT; usa1_2" SEVERITY FAILURE; ASSERT ( ARGA_C_usa1_3 AND ARGB_C_usa1_3 ) = AND_C_usa1_3 REPORT "ERROR: composite AND operator failed; CONSTANT; usa1_3" SEVERITY FAILURE; ASSERT ( ARGA_C_usa1_4 AND ARGB_C_usa1_4 ) = AND_C_usa1_4 REPORT "ERROR: composite AND operator failed; CONSTANT; usa1_4" SEVERITY FAILURE; -- -- Test AND operator on: SIGNALs -- ASSERT ( ARGA_S_csa1_1 AND ARGB_S_csa1_1 ) = AND_S_csa1_1 REPORT "ERROR: composite AND operator failed; SIGNAL; csa1_1" SEVERITY FAILURE; ASSERT ( ARGA_S_csa1_2 AND ARGB_S_csa1_2 ) = AND_S_csa1_2 REPORT "ERROR: composite AND operator failed; SIGNAL; csa1_2" SEVERITY FAILURE; ASSERT ( ARGA_S_csa1_3 AND ARGB_S_csa1_3 ) = AND_S_csa1_3 REPORT "ERROR: composite AND operator failed; SIGNAL; csa1_3" SEVERITY FAILURE; ASSERT ( ARGA_S_csa1_4 AND ARGB_S_csa1_4 ) = AND_S_csa1_4 REPORT "ERROR: composite AND operator failed; SIGNAL; csa1_4" SEVERITY FAILURE; ASSERT ( ARGA_S_usa1_1 AND ARGB_S_usa1_1 ) = AND_S_usa1_1 REPORT "ERROR: composite AND operator failed; SIGNAL; usa1_1" SEVERITY FAILURE; ASSERT ( ARGA_S_usa1_2 AND ARGB_S_usa1_2 ) = AND_S_usa1_2 REPORT "ERROR: composite AND operator failed; SIGNAL; usa1_2" SEVERITY FAILURE; ASSERT ( ARGA_S_usa1_3 AND ARGB_S_usa1_3 ) = AND_S_usa1_3 REPORT "ERROR: composite AND operator failed; SIGNAL; usa1_3" SEVERITY FAILURE; ASSERT ( ARGA_S_usa1_4 AND ARGB_S_usa1_4 ) = AND_S_usa1_4 REPORT "ERROR: composite AND operator failed; SIGNAL; usa1_4" SEVERITY FAILURE; -- -- Test AND operator on: VARIABLEs -- ASSERT ( ARGA_V_csa1_1 AND ARGB_V_csa1_1 ) = AND_V_csa1_1 REPORT "ERROR: composite AND operator failed; VARIABLE; csa1_1" SEVERITY FAILURE; ASSERT ( ARGA_V_csa1_2 AND ARGB_V_csa1_2 ) = AND_V_csa1_2 REPORT "ERROR: composite AND operator failed; VARIABLE; csa1_2" SEVERITY FAILURE; ASSERT ( ARGA_V_csa1_3 AND ARGB_V_csa1_3 ) = AND_V_csa1_3 REPORT "ERROR: composite AND operator failed; VARIABLE; csa1_3" SEVERITY FAILURE; ASSERT ( ARGA_V_csa1_4 AND ARGB_V_csa1_4 ) = AND_V_csa1_4 REPORT "ERROR: composite AND operator failed; VARIABLE; csa1_4" SEVERITY FAILURE; ASSERT ( ARGA_V_usa1_1 AND ARGB_V_usa1_1 ) = AND_V_usa1_1 REPORT "ERROR: composite AND operator failed; VARIABLE; usa1_1" SEVERITY FAILURE; ASSERT ( ARGA_V_usa1_2 AND ARGB_V_usa1_2 ) = AND_V_usa1_2 REPORT "ERROR: composite AND operator failed; VARIABLE; usa1_2" SEVERITY FAILURE; ASSERT ( ARGA_V_usa1_3 AND ARGB_V_usa1_3 ) = AND_V_usa1_3 REPORT "ERROR: composite AND operator failed; VARIABLE; usa1_3" SEVERITY FAILURE; ASSERT ( ARGA_V_usa1_4 AND ARGB_V_usa1_4 ) = AND_V_usa1_4 REPORT "ERROR: composite AND operator failed; VARIABLE; usa1_4" SEVERITY FAILURE; wait for 5 ns; assert NOT( ( ARGA_C_csa1_1 AND ARGB_C_csa1_1 ) = AND_C_csa1_1 and ( ARGA_C_csa1_2 AND ARGB_C_csa1_2 ) = AND_C_csa1_2 and ( ARGA_C_csa1_3 AND ARGB_C_csa1_3 ) = AND_C_csa1_3 and ( ARGA_C_csa1_4 AND ARGB_C_csa1_4 ) = AND_C_csa1_4 and ( ARGA_C_usa1_1 AND ARGB_C_usa1_1 ) = AND_C_usa1_1 and ( ARGA_C_usa1_2 AND ARGB_C_usa1_2 ) = AND_C_usa1_2 and ( ARGA_C_usa1_3 AND ARGB_C_usa1_3 ) = AND_C_usa1_3 and ( ARGA_C_usa1_4 AND ARGB_C_usa1_4 ) = AND_C_usa1_4 and ( ARGA_S_csa1_1 AND ARGB_S_csa1_1 ) = AND_S_csa1_1 and ( ARGA_S_csa1_2 AND ARGB_S_csa1_2 ) = AND_S_csa1_2 and ( ARGA_S_csa1_3 AND ARGB_S_csa1_3 ) = AND_S_csa1_3 and ( ARGA_S_csa1_4 AND ARGB_S_csa1_4 ) = AND_S_csa1_4 and ( ARGA_S_usa1_1 AND ARGB_S_usa1_1 ) = AND_S_usa1_1 and ( ARGA_S_usa1_2 AND ARGB_S_usa1_2 ) = AND_S_usa1_2 and ( ARGA_S_usa1_3 AND ARGB_S_usa1_3 ) = AND_S_usa1_3 and ( ARGA_S_usa1_4 AND ARGB_S_usa1_4 ) = AND_S_usa1_4 and ( ARGA_V_csa1_1 AND ARGB_V_csa1_1 ) = AND_V_csa1_1 and ( ARGA_V_csa1_2 AND ARGB_V_csa1_2 ) = AND_V_csa1_2 and ( ARGA_V_csa1_3 AND ARGB_V_csa1_3 ) = AND_V_csa1_3 and ( ARGA_V_csa1_4 AND ARGB_V_csa1_4 ) = AND_V_csa1_4 and ( ARGA_V_usa1_1 AND ARGB_V_usa1_1 ) = AND_V_usa1_1 and ( ARGA_V_usa1_2 AND ARGB_V_usa1_2 ) = AND_V_usa1_2 and ( ARGA_V_usa1_3 AND ARGB_V_usa1_3 ) = AND_V_usa1_3 and ( ARGA_V_usa1_4 AND ARGB_V_usa1_4 ) = AND_V_usa1_4 ) report "***PASSED TEST: c07s02b01x00p01n02i01945" severity NOTE; assert ( ( ARGA_C_csa1_1 AND ARGB_C_csa1_1 ) = AND_C_csa1_1 and ( ARGA_C_csa1_2 AND ARGB_C_csa1_2 ) = AND_C_csa1_2 and ( ARGA_C_csa1_3 AND ARGB_C_csa1_3 ) = AND_C_csa1_3 and ( ARGA_C_csa1_4 AND ARGB_C_csa1_4 ) = AND_C_csa1_4 and ( ARGA_C_usa1_1 AND ARGB_C_usa1_1 ) = AND_C_usa1_1 and ( ARGA_C_usa1_2 AND ARGB_C_usa1_2 ) = AND_C_usa1_2 and ( ARGA_C_usa1_3 AND ARGB_C_usa1_3 ) = AND_C_usa1_3 and ( ARGA_C_usa1_4 AND ARGB_C_usa1_4 ) = AND_C_usa1_4 and ( ARGA_S_csa1_1 AND ARGB_S_csa1_1 ) = AND_S_csa1_1 and ( ARGA_S_csa1_2 AND ARGB_S_csa1_2 ) = AND_S_csa1_2 and ( ARGA_S_csa1_3 AND ARGB_S_csa1_3 ) = AND_S_csa1_3 and ( ARGA_S_csa1_4 AND ARGB_S_csa1_4 ) = AND_S_csa1_4 and ( ARGA_S_usa1_1 AND ARGB_S_usa1_1 ) = AND_S_usa1_1 and ( ARGA_S_usa1_2 AND ARGB_S_usa1_2 ) = AND_S_usa1_2 and ( ARGA_S_usa1_3 AND ARGB_S_usa1_3 ) = AND_S_usa1_3 and ( ARGA_S_usa1_4 AND ARGB_S_usa1_4 ) = AND_S_usa1_4 and ( ARGA_V_csa1_1 AND ARGB_V_csa1_1 ) = AND_V_csa1_1 and ( ARGA_V_csa1_2 AND ARGB_V_csa1_2 ) = AND_V_csa1_2 and ( ARGA_V_csa1_3 AND ARGB_V_csa1_3 ) = AND_V_csa1_3 and ( ARGA_V_csa1_4 AND ARGB_V_csa1_4 ) = AND_V_csa1_4 and ( ARGA_V_usa1_1 AND ARGB_V_usa1_1 ) = AND_V_usa1_1 and ( ARGA_V_usa1_2 AND ARGB_V_usa1_2 ) = AND_V_usa1_2 and ( ARGA_V_usa1_3 AND ARGB_V_usa1_3 ) = AND_V_usa1_3 and ( ARGA_V_usa1_4 AND ARGB_V_usa1_4 ) = AND_V_usa1_4 ) report "***FAILED TEST: c07s02b01x00p01n02i01945 - Logical operator AND for any user-defined one-dimensional array type test failed." severity ERROR; wait; END PROCESS TESTING; END c07s02b01x00p01n02i01945arch; nvc-r1.17.1/test/regress/vests28.vhd000066400000000000000000000054261504111170000172200ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3128.vhd,v 1.2 2001-10-26 16:29:51 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c05s02b01x02p12n01i03128ent_a IS generic ( g1 : integer := 3 ); END c05s02b01x02p12n01i03128ent_a; ARCHITECTURE c05s02b01x02p12n01i03128arch_a OF c05s02b01x02p12n01i03128ent_a IS BEGIN TESTING: PROCESS BEGIN assert g1 /= 2 severity FAILURE; assert g1 /= 3 severity FAILURE; assert g1 = 4 severity FAILURE; assert g1 /= 5 severity FAILURE; assert g1 /= 6 severity FAILURE; assert NOT( g1 /= 2 and g1 /= 3 and g1 = 4 and g1 /= 5 and g1 /= 6 ) report "***PASSED TEST: c05s02b01x02p12n01i03128" severity NOTE; assert ( g1 /= 2 and g1 /= 3 and g1 = 4 and g1 /= 5 and g1 /= 6 ) report "***FAILED TEST: c05s02b01x02p12n01i03128 - An actual associated with a formal generic in a generic map aspect be an expression test failed." severity ERROR; wait; END PROCESS TESTING; END c05s02b01x02p12n01i03128arch_a; ENTITY c05s02b01x02p12n01i03128ent IS END c05s02b01x02p12n01i03128ent; ARCHITECTURE c05s02b01x02p12n01i03128arch OF c05s02b01x02p12n01i03128ent IS BEGIN labeled : block component ic_socket generic ( g1 : integer := 2 ); end component; for instance : ic_socket use entity work.c05s02b01x02p12n01i03128ent_a (c05s02b01x02p12n01i03128arch_a) generic map ( g1 => g1 + g1 ); begin instance : ic_socket ; end block; END c05s02b01x02p12n01i03128arch; configuration vests28 of c05s02b01x02p12n01i03128ent is for c05s02b01x02p12n01i03128arch end for; end vests28; nvc-r1.17.1/test/regress/vests29.vhd000066400000000000000000000043371504111170000172210ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3040.vhd,v 1.2 2001-10-26 16:29:50 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests29 IS END vests29; ARCHITECTURE c12s02b02x00p01n02i03040arch OF vests29 IS type c_a is array(integer range <>) of integer; type c_r is record i : integer; r : real; b : bit; end record; BEGIN -- test for no associations bl1 : block generic(i:c_a(1 to 3):=(10,10,10); r:c_r:=(10,3.4,'1')); begin assert ((i(1)=10) and (i(2)=10) and (i(3)=10)) report "Default value for array generic not correct" severity failure; assert ((r.i=10) and (r.r=3.4) and (r.b='1')) report "Default value for record generic not correct" severity failure; assert NOT((i(1)=10) and (i(2)=10) and (i(3)=10) and (r.i=10) and (r.r=3.4) and (r.b='1')) report "***PASSED TEST: c12s02b02x00p01n02i03040" severity NOTE; assert ((i(1)=10) and (i(2)=10) and (i(3)=10) and (r.i=10) and (r.r=3.4) and (r.b='1')) report "***FAILED TEST: c12s02b02x00p01n02i03040 - The actual part of an implicit association element is the default expression test failed." severity ERROR; end block; END c12s02b02x00p01n02i03040arch; nvc-r1.17.1/test/regress/vests3.vhd000066400000000000000000000216521504111170000171300ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc745.vhd,v 1.2 2001-10-26 16:29:59 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s01b01x01p05n02i00745pkg is type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c: character; d: severity_level; e: integer; f: real; g: time; h: natural; i: positive; j: string(1 to 7); k: bit_vector(0 to 3); end record; type array_rec_std is array (integer range <>) of record_std_package; function F1(inp : boolean_vector) return boolean ; function F2(inp : bit_vector) return bit ; function F3(inp : string) return character ; function F4(inp : severity_level_vector) return severity_level ; function F5(inp : integer_vector) return integer ; function F6(inp : real_vector) return real ; function F7(inp : time_vector) return time ; function F8(inp : natural_vector) return natural ; function F9(inp : positive_vector) return positive ; function F10(inp : array_rec_std) return record_std_package ; end c01s01b01x01p05n02i00745pkg; package body c01s01b01x01p05n02i00745pkg is function F1(inp : boolean_vector) return boolean is begin for i in 0 to 15 loop assert(inp(i) = true) report"wrong initialization of S1" severity error; end loop; return false; end F1; function F2(inp : bit_vector) return bit is begin for i in 0 to 3 loop assert(inp(i) = '0') report"wrong initialization of S2" severity error; end loop; return '0'; end F2; function F3(inp : string) return character is begin for i in 1 to 7 loop assert(inp(i) = 's') report"wrong initialization of S3" severity error; end loop; return 'h'; end F3; function F4(inp : severity_level_vector) return severity_level is begin for i in 0 to 15 loop assert(inp(i) = note) report"wrong initialization of S4" severity error; end loop; return error; end F4; function F5(inp : integer_vector) return integer is begin for i in 0 to 15 loop assert(inp(i) = 3) report"wrong initialization of S5" severity error; end loop; return 6; end F5; function F6(inp : real_vector) return real is begin for i in 0 to 15 loop assert(inp(i) = 3.0) report"wrong initialization of S6" severity error; end loop; return 6.0; end F6; function F7(inp : time_vector) return time is begin for i in 0 to 15 loop assert(inp(i) = 3 ns) report"wrong initialization of S7" severity error; end loop; return 6 ns; end F7; function F8(inp : natural_vector) return natural is begin for i in 0 to 15 loop assert(inp(i) = 1) report"wrong initialization of S8" severity error; end loop; return 6; end F8; function F9(inp : positive_vector) return positive is begin for i in 0 to 15 loop assert(inp(i) = 1) report"wrong initialization of S9" severity error; end loop; return 6; end F9; function F10(inp : array_rec_std) return record_std_package is begin for i in 0 to 7 loop assert(inp(i) = (true,'1','s',note,3,3.0,3 ns, 1,1,"sssssss","0000")) report"wrong initialization of S10" severity error; end loop; return (false,'0','s',error,5,5.0,5 ns,5,5,"metrics","1100"); end F10; end c01s01b01x01p05n02i00745pkg; use work.c01s01b01x01p05n02i00745pkg.all; ENTITY vests3 IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15; C1 : boolean := true; C2 : bit := '1'; C3 : character := 's'; C4 : severity_level:= note; C5 : integer := 3; C6 : real := 3.0; C7 : time := 3 ns; C8 : natural := 1; C9 : positive := 1; C10 : string := "sssssss"; C11 : bit_vector := B"0000"; C48 : record_std_package := (true,'1','s',note,3,3.0,3 ns,1,1,"sssssss","0000") ); port( S1 : boolean_vector(zero to fifteen) := (others => C1); S2 : severity_level_vector(zero to fifteen) := (others => C4); S3 : integer_vector(zero to fifteen) := (others => C5); S4 : real_vector(zero to fifteen) := (others => C6); S5 : time_vector (zero to fifteen) := (others => C7); S6 : natural_vector(zero to fifteen) := (others => C8); S7 : positive_vector(zero to fifteen) := (others => C9); S8 : string(one to seven) := C10; S9 : bit_vector(zero to three) := C11; S48: array_rec_std(zero to seven) := (others => C48) ); END vests3; ARCHITECTURE c01s01b01x01p05n02i00745arch OF vests3 IS BEGIN TESTING: PROCESS variable var1 : boolean; variable var4 : severity_level; variable var5 : integer; variable var6 : real; variable var7 : time; variable var8 : natural; variable var9 : positive; variable var2 : bit; variable var3 : character; variable var48: record_std_package; BEGIN var1 := F1(S1); var2 := F2(S9); var3 := F3(S8); var4 := F4(S2); var5 := F5(S3); var6 := F6(S4); var7 := F7(S5); var8 := F8(S6); var9 := F9(S7); var48 := F10(S48); wait for 1 ns; assert(var1 = false) report "wrong assignment in the function F1" severity error; assert(var2 = '0') report "wrong assignment in the function F2" severity error; assert(var3 = 'h') report "wrong assignment in the function F3" severity error; assert(var4 = error) report "wrong assignment in the function F4" severity error; assert(var5 = 6) report "wrong assignment in the function F5" severity error; assert(var6 = 6.0) report "wrong assignment in the function F6" severity error; assert(var7 = 6 ns) report "wrong assignment in the function F7" severity error; assert(var8 = 6) report "wrong assignment in the function F8" severity error; assert(var9 = 6) report "wrong assignment in the function F9" severity error; assert(var48 = (false,'0','s',error,5,5.0,5 ns,5,5,"metrics","1100")) report "wrong assignment in the function F10" severity error; assert NOT( var1 = F1(S1) and var2 = F2(S9) and var3 = F3(S8) and var4 = F4(S2) and var5 = F5(S3) and var6 = F6(S4) and var7 = F7(S5) and var8 = F8(S6) and var9 = F9(S7) and var48 = F10(S48) ) report "***PASSED TEST: c01s01b01x01p05n02i00745" severity NOTE; assert ( var1 = F1(S1) and var2 = F2(S9) and var3 = F3(S8) and var4 = F4(S2) and var5 = F5(S3) and var6 = F6(S4) and var7 = F7(S5) and var8 = F8(S6) and var9 = F9(S7) and var48 = F10(S48) ) report "***FAILED TEST: c01s01b01x01p05n02i00745 - Generic can be used to specify the size of ports." severity ERROR; wait; END PROCESS TESTING; END c01s01b01x01p05n02i00745arch; nvc-r1.17.1/test/regress/vests30.vhd000066400000000000000000000064001504111170000172020ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3121.vhd,v 1.2 2001-10-26 16:29:51 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c05s02b01x01p05n01i03121ent_aa IS END c05s02b01x01p05n01i03121ent_aa; ARCHITECTURE c05s02b01x01p05n01i03121arch_aa OF c05s02b01x01p05n01i03121ent_aa IS BEGIN END c05s02b01x01p05n01i03121arch_aa; ARCHITECTURE c05s02b01x01p05n01i03121arch_bb OF c05s02b01x01p05n01i03121ent_aa IS BEGIN END c05s02b01x01p05n01i03121arch_bb; -- ENTITY c05s02b01x01p05n01i03121ent_a IS generic ( g1 : boolean ); port ( p1 : in Bit; p2 : out Bit ); END c05s02b01x01p05n01i03121ent_a; ARCHITECTURE c05s02b01x01p05n01i03121arch_a OF c05s02b01x01p05n01i03121ent_a IS component zippy end component; BEGIN u1 : zippy; p2 <= p1 after 10 ns; END c05s02b01x01p05n01i03121arch_a; configuration c05s02b01x01p05n01i03121cfg_a of c05s02b01x01p05n01i03121ent_a is for c05s02b01x01p05n01i03121arch_a for u1 : zippy use entity work.c05s02b01x01p05n01i03121ent_aa; end for; end for; end c05s02b01x01p05n01i03121cfg_a; -- ENTITY c05s02b01x01p05n01i03121ent IS END c05s02b01x01p05n01i03121ent; ARCHITECTURE c05s02b01x01p05n01i03121arch OF c05s02b01x01p05n01i03121ent IS component virtual generic ( g1 : boolean ); port ( p1 : in Bit; p2 : out Bit ); end component; signal s1,s2,s3,s4 : Bit; BEGIN u1 : virtual generic map ( true ) port map (s1, s2); u2 : virtual generic map ( true ) port map (s2, s3); u3 : virtual generic map ( true ) port map (s3, s4); TESTING: PROCESS BEGIN wait for 30 ns; assert NOT( s2 = s1 and s3 = s2 and s4 = s3 ) report "***PASSED TEST: c05s02b01x01p05n01i03121" severity NOTE; assert ( s2 = s1 and s3 = s2 and s4 = s3 ) report "***FAILED TEST: c05s02b01x01p05n01i03121 - Use a configuration that is not fully bound test failed." severity ERROR; wait; END PROCESS TESTING; END c05s02b01x01p05n01i03121arch; configuration vests30 of c05s02b01x01p05n01i03121ent is for c05s02b01x01p05n01i03121arch for all : virtual use configuration work.c05s02b01x01p05n01i03121cfg_a; end for; end for; end vests30; nvc-r1.17.1/test/regress/vests31.vhd000066400000000000000000000063501504111170000172070ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc480.vhd,v 1.2 2001-10-26 16:29:55 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY model IS PORT ( F1: OUT integer := 3; F2: INOUT integer := 3; F3: IN integer ); END model; architecture model of model is begin process begin wait for 1 ns; assert F3= 3 report"wrong initialization of F3 through type conversion" severity failure; assert F2 = 3 report"wrong initialization of F2 through type conversion" severity failure; wait; end process; end; ENTITY vests31 IS END vests31; ARCHITECTURE c03s02b01x01p19n01i00480arch OF vests31 IS type real_vector is array (natural range <>) of real; function resolution6(i:in real_vector) return real is variable temp : real := 3.0; begin return temp; end resolution6; subtype real_state is resolution6 real; constant C66 : real_state := 3.0; function complex_scalar(s : real_state) return integer is begin return 3; end complex_scalar; function scalar_complex(s : integer) return real_state is begin report "scalar_complex returning " & real'image(c66); return C66; end scalar_complex; component model1 PORT ( F1: OUT integer; F2: INOUT integer; F3: IN integer ); end component; for T1 : model1 use entity work.model(model); signal S1 : real_state; signal S2 : real_state; signal S3 : real_state:= C66; BEGIN T1: model1 port map ( scalar_complex(F1) => S1, scalar_complex(F2) => complex_scalar(S2), F3 => complex_scalar(S3) ); TESTING: PROCESS BEGIN wait for 1 ns; assert NOT((S1 = C66) and (S2 = C66)) report "***PASSED TEST: c03s02b01x01p19n01i00480" severity NOTE; report real'image(s1); report real'image(s2); assert ((S1 = C66) and (S2 = C66)) report "***FAILED TEST: c03s02b01x01p19n01i00480 - For an interface object of mode out, buffer, inout, or linkage, if the formal part includes a type conversion function, then the parameter subtype of that function must be a constrained array subtype." severity ERROR; wait; END PROCESS TESTING; END c03s02b01x01p19n01i00480arch; nvc-r1.17.1/test/regress/vests32.vhd000066400000000000000000000131341504111170000172060ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1785.vhd,v 1.2 2001-10-26 16:29:43 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- Package c09s06b00x00p04n07i01785pkg is type info is record field_1 : integer; field_2 : real; end record; type stuff is array (Integer range 1 to 2) of info; end c09s06b00x00p04n07i01785pkg; use work.c09s06b00x00p04n07i01785pkg.all; entity c09s06b00x00p04n07i01785ent_a is port ( port_0 : in Boolean ; port_1 : in Bit ; port_2 : in Character ; port_3 : in SEVERITY_LEVEL ; port_4 : in Integer ; port_5 : in Real ; port_6 : in TIME ; port_7 : in Natural ; port_8 : in Positive ; port_9 : in String ; port_A : in Bit_vector ; port_B : in stuff ); end c09s06b00x00p04n07i01785ent_a; use work.c09s06b00x00p04n07i01785pkg.all; architecture c09s06b00x00p04n07i01785arch_a of c09s06b00x00p04n07i01785ent_a is -- Check that the data was passed... begin TESTING: PROCESS(port_0,port_1,port_2,port_3,port_4,port_5,port_6,port_7,port_8) BEGIN assert NOT( port_0 = True and port_1 = '0' and port_2 = '@' and port_3 = NOTE and port_4 = 123456789 and port_5 = 987654321.5 and port_6 = 110 ns and port_7 = 12312 and port_8 = 3423 and port_9 = "16 characters OK" and port_A = B"01010010100101010010101001010100" and port_B = ((123, 456.7), (890, 135.7)) ) report "***PASSED TEST: c09s06b00x00p04n07i01785" severity NOTE; assert ( port_0 = True and port_1 = '0' and port_2 = '@' and port_3 = NOTE and port_4 = 123456789 and port_5 = 987654321.5 and port_6 = 110 ns and port_7 = 12312 and port_8 = 3423 and port_9 = "16 characters OK" and port_A = B"01010010100101010010101001010100" and port_B = ((123, 456.7), (890, 135.7))) report "***FAILED TEST: c09s06b00x00p04n07i01785 - Port map aspect associates a single actual with each local port in the corresponding component declaration test failed." severity ERROR; END PROCESS TESTING; end c09s06b00x00p04n07i01785arch_a; ----------------------------------------------------------------------- ENTITY vests32 IS END vests32; use work.c09s06b00x00p04n07i01785pkg.all; ARCHITECTURE c09s06b00x00p04n07i01785arch OF vests32 IS subtype reg32 is Bit_vector ( 31 downto 0 ); subtype string16 is String ( 1 to 16 ); signal sig_0 : Boolean := TRUE; signal sig_1 : Bit := '0'; signal sig_2 : Character := '@'; signal sig_3 : SEVERITY_LEVEL := NOTE; signal sig_4 : Integer := 123456789; signal sig_5 : Real := 987654321.5; signal sig_6 : TIME := 110 NS; signal sig_7 : Natural := 12312; signal sig_8 : Positive := 3423; signal sig_9 : String16 := "16 characters OK"; signal sig_A : REG32 := B"0101_0010_1001_0101_0010_1010_0101_0100"; signal sig_B : stuff := (( 123, 456.7 ), ( 890, 135.7 )); component MultiType port ( port_0 : in Boolean ; port_1 : in Bit ; port_2 : in Character ; port_3 : in SEVERITY_LEVEL ; port_4 : in Integer ; port_5 : in Real ; port_6 : in TIME ; port_7 : in Natural ; port_8 : in Positive ; port_9 : in String ; port_A : in Bit_vector ; port_B : in stuff ); end component; for u1 : MultiType use entity work.c09s06b00x00p04n07i01785ent_a (c09s06b00x00p04n07i01785arch_a); BEGIN u1 : MultiType port map ( port_0 => sig_0, port_1 => sig_1, port_2 => sig_2, port_3 => sig_3, port_4 => sig_4, port_5 => sig_5, port_6 => sig_6, port_7 => sig_7, port_8 => sig_8, port_9 => sig_9, port_A => sig_A, port_B => sig_B ); END c09s06b00x00p04n07i01785arch; nvc-r1.17.1/test/regress/vests33.vhd000066400000000000000000000036531504111170000172140ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc3083.vhd,v 1.2 2001-10-26 16:29:51 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests33 IS END vests33; ARCHITECTURE c12s06b03x00p02n01i03083arch OF vests33 IS signal S1 : BIT; signal X1 : BIT; signal S : integer := 1; BEGIN S1 <= transport '1' after 5 ns; A : block(X1 = '1') begin process(GUARD) begin if GUARD then assert false report "Failure on test. Guard value shouldn't have been changed" ; S <= 0; end if; end process; end block A; TESTING: PROCESS BEGIN wait for 10 ns; assert NOT(S = 1) report "***PASSED TEST: c12s06b03x00p02n01i03083" severity NOTE; assert (S = 1) report "***FAILED TEST: c12s06b03x00p02n01i03083 - GUARD signal is not modified in the test." severity ERROR; wait; END PROCESS TESTING; END c12s06b03x00p02n01i03083arch; nvc-r1.17.1/test/regress/vests34.vhd000066400000000000000000000145171504111170000172160ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2439.vhd,v 1.2 2001-10-26 16:29:48 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests34 IS END vests34; ARCHITECTURE c07s03b02x02p01n01i02439arch OF vests34 IS BEGIN TESTING: PROCESS subtype char128 is character range NUL to DEL; -- Range types are all predefined enumerated types. type CHAR_ARR is ARRAY( char128 ) of BIT; type BIT_ARR is ARRAY( BIT ) of BIT; type BOOL_ARR is ARRAY( BOOLEAN ) of BIT; type SEV_ARR is ARRAY( SEVERITY_LEVEL ) of BIT; -- Declare variables of these types. variable CHARV : CHAR_ARR; variable BITV : BIT_ARR; variable BOOLV : BOOL_ARR; variable SEVV : SEV_ARR; variable OKtest: integer := 0; BEGIN -- Assign each of these arrays using aggregates. -- 1. Individual aggregates. CHARV := CHAR_ARR'( 'a' => '1', 'b' => '0', NUL to '`' => '1', 'c' to DEL => '1' ); for C in char128 loop if (C = 'a') then assert( CHARV( C ) = '1' ); if NOT( CHARV( C ) = '1' ) then OKtest := 1; end if; elsif (C = 'b') then assert( CHARV( C ) = '0' ); if NOT( CHARV( C ) = '0' ) then OKtest := 1; end if; else assert( CHARV( C ) = '1' ) report "CHARV( " & character'image(c) & " ) = " & bit'image(CHARV( C )); if NOT( CHARV( C ) = '1' ) then OKtest := 1; end if; end if; end loop; BITV := BIT_ARR'( '0' => '0', '1' => '1' ); assert( BITV( '0' ) = '0' ); if NOT( BITV( '0' ) = '0' ) then OKtest := 1; end if; assert( BITV( '1' ) = '1' ); if NOT( BITV( '1' ) = '1' ) then OKtest := 1; end if; BOOLV := BOOL_ARR'( FALSE => '0', TRUE => '1' ); assert( BOOLV( FALSE ) = '0' ); if NOT( BOOLV( FALSE ) = '0' ) then OKtest := 1; end if; assert( BOOLV( TRUE ) = '1' ); if NOT( BOOLV( TRUE ) = '1' ) then OKtest := 1; end if; SEVV := SEV_ARR'( NOTE => '0', WARNING => '1', ERROR => '0', FAILURE => '1' ); assert( SEVV( NOTE ) = '0' ); assert( SEVV( WARNING ) = '1' ); assert( SEVV( ERROR ) = '0' ); assert( SEVV( FAILURE ) = '1' ); if NOT((SEVV(NOTE)='0')and(SEVV(WARNING) ='1')and(SEVV(ERROR)='0')and(SEVV(FAILURE)='1')) then OKtest := 1; end if; -- 2. Groups of aggregates. CHARV := CHAR_ARR'( 'a' | 'b' => '1', NUL to '`' => '0', 'c' to DEL => '0' ); for C in char128 loop if (C = 'a') then assert( CHARV( C ) = '1' ); if NOT( CHARV( C ) = '1' ) then OKtest := 1; end if; elsif (C = 'b') then assert( CHARV( C ) = '1' ); if NOT( CHARV( C ) = '1' ) then OKtest := 1; end if; else assert( CHARV( C ) = '0' ); if NOT( CHARV( C ) = '0' ) then OKtest := 1; end if; end if; end loop; BITV := BIT_ARR'( '0' | '1' => '0' ); assert( BITV( '0' ) = '0' ); assert( BITV( '1' ) = '0' ); if NOT((BITV('0')='0') and (BITV('1')='0')) then OKtest := 1; end if; BOOLV := BOOL_ARR'( FALSE | TRUE => '1' ); assert( BOOLV( FALSE ) = '1' ); assert( BOOLV( TRUE ) = '1' ); if NOT((BOOLV(FALSE)='1') and (BOOLV(TRUE)='1')) then OKtest := 1; end if; SEVV := SEV_ARR'( NOTE | ERROR => '0', WARNING | FAILURE => '1' ); assert( SEVV( NOTE ) = '0' ); assert( SEVV( WARNING ) = '1' ); assert( SEVV( ERROR ) = '0' ); assert( SEVV( FAILURE ) = '1' ); if NOT((SEVV(NOTE)='0')and(SEVV(WARNING) ='1')and(SEVV(ERROR)='0')and(SEVV(FAILURE)='1')) then OKtest := 1; end if; -- 3. Use of 'others' in these aggregates. CHARV := CHAR_ARR'( 'a' | 'b' => '0', others => '1' ); for C in char128 loop if (C = 'a') then assert( CHARV( C ) = '0' ); if NOT( CHARV( C ) = '0' ) then OKtest := 1; end if; elsif (C = 'b') then assert( CHARV( C ) = '0' ); if NOT( CHARV( C ) = '0' ) then OKtest := 1; end if; else assert( CHARV( C ) = '1' ); if NOT( CHARV( C ) = '1' ) then OKtest := 1; end if; end if; end loop; BITV := BIT_ARR'( others => '1' ); assert( BITV( '0' ) = '1' ); assert( BITV( '1' ) = '1' ); if NOT(( BITV( '0' ) = '1' )and( BITV( '1' ) = '1' ))then OKtest := 1; end if; BOOLV := BOOL_ARR'( FALSE => '1', others => '0' ); assert( BOOLV( FALSE ) = '1' ); assert( BOOLV( TRUE ) = '0' ); if NOT(( BOOLV( FALSE ) = '1' )and( BOOLV( TRUE ) = '0' ))then OKtest := 1; end if; SEVV := SEV_ARR'( NOTE | ERROR => '0', others => '1' ); assert( SEVV( NOTE ) = '0' ); assert( SEVV( WARNING ) = '1' ); assert( SEVV( ERROR ) = '0' ); assert( SEVV( FAILURE ) = '1' ); if NOT((SEVV(NOTE)='0')and(SEVV(WARNING) ='1')and(SEVV(ERROR)='0')and(SEVV(FAILURE)='1')) then OKtest := 1; end if; wait for 5 ns; assert NOT(OKtest = 0) report "***PASSED TEST: c07s03b02x02p01n01i02439" severity NOTE; assert (OKtest = 0) report "***FAILED TEST: c07s03b02x02p01n01i02439 - Aggregates with different range types test failed." severity ERROR; wait; END PROCESS TESTING; END c07s03b02x02p01n01i02439arch; nvc-r1.17.1/test/regress/vests35.vhd000066400000000000000000000476701504111170000172250ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc31.vhd,v 1.2 2001-10-26 16:29:51 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests35 IS END vests35; ARCHITECTURE c04s03b01x01p01n01i00031arch OF vests35 IS -- -- -- Declaration of composite types -- - array types and subtypes -- TYPE ut_chary IS ARRAY (CHARACTER RANGE <>) OF INTEGER; -- unconstrained array type TYPE ct_word IS ARRAY (0 TO 15) OF BIT; -- constrained array type SUBTYPE ust_subchary IS ut_chary; -- unconstrained array subtype SUBTYPE cst_str10 IS STRING ( 1 TO 10 ); -- constrained array subtype SUBTYPE cst_digit IS ut_chary ('0' TO '9'); -- constrained array subtype -- -- Declaration of composite types -- - records types and subtypes -- TYPE month_name IS (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec ); TYPE rt_date IS RECORD day : INTEGER RANGE 1 TO 31; month : month_name; year : INTEGER RANGE 0 TO 4000; END RECORD; -- SUBTYPE rst_date IS rt_date; BEGIN TESTING: PROCESS -- -- Constant declarations - without range constraint -- CONSTANT STRING_con_1 : STRING := "sailing"; CONSTANT STRING_con_2 : STRING := ( 's', 'a', 'i', 'l', 'i', 'n', 'g'); CONSTANT BIT_VECTOR_con_1 : BIT_VECTOR := B"10101110"; CONSTANT BIT_VECTOR_con_2 : BIT_VECTOR := ( '1', '0', '1', '0', '1', '1', '1', '0'); CONSTANT ut_chary_con : ut_chary := ( 1, 2, 3, 9, 8, 7); CONSTANT ct_word_con : ct_word := ( '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'); CONSTANT cst_str10_con_1 : cst_str10 := "abcdefghij"; CONSTANT cst_str10_con_2 : cst_str10 := ( 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'); CONSTANT cst_digit_con : cst_digit := ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); CONSTANT rt_date_con : rt_date := (1, Jan, 1989); CONSTANT rst_date_con : rst_date := (1, Apr, 2000); ---------------------------------------------------------------------------------------------------------- BEGIN ASSERT STRING_con_1(1) = 's' REPORT "STRING_con_1(1) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(2) = 'a' REPORT "STRING_con_1(2) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(3) = 'i' REPORT "STRING_con_1(3) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(4) = 'l' REPORT "STRING_con_1(4) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(5) = 'i' REPORT "STRING_con_1(5) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(6) = 'n' REPORT "STRING_con_1(6) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_1(7) = 'g' REPORT "STRING_con_1(7) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(1) = 's' REPORT "STRING_con_2(1) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(2) = 'a' REPORT "STRING_con_2(2) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(3) = 'i' REPORT "STRING_con_2(3) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(4) = 'l' REPORT "STRING_con_2(4) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(5) = 'i' REPORT "STRING_con_2(5) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(6) = 'n' REPORT "STRING_con_2(6) not properly intialized" SEVERITY FAILURE; ASSERT STRING_con_2(7) = 'g' REPORT "STRING_con_2(7) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(0) = '1' REPORT "BIT_VECTOR_con_1(1) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(1) = '0' REPORT "BIT_VECTOR_con_1(2) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(2) = '1' REPORT "BIT_VECTOR_con_1(3) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(3) = '0' REPORT "BIT_VECTOR_con_1(4) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(4) = '1' REPORT "BIT_VECTOR_con_1(5) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(5) = '1' REPORT "BIT_VECTOR_con_1(6) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(6) = '1' REPORT "BIT_VECTOR_con_1(7) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_1(7) = '0' REPORT "BIT_VECTOR_con_1(8) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(0) = '1' REPORT "BIT_VECTOR_con_2(1) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(1) = '0' REPORT "BIT_VECTOR_con_2(2) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(2) = '1' REPORT "BIT_VECTOR_con_2(3) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(3) = '0' REPORT "BIT_VECTOR_con_2(4) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(4) = '1' REPORT "BIT_VECTOR_con_2(5) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(5) = '1' REPORT "BIT_VECTOR_con_2(6) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(6) = '1' REPORT "BIT_VECTOR_con_2(7) not properly intialized" SEVERITY FAILURE; ASSERT BIT_VECTOR_con_2(7) = '0' REPORT "BIT_VECTOR_con_2(8) not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(NUL) = 1 REPORT "ut_chary_con('a') not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(SOH) = 2 REPORT "ut_chary_con('b') not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(STX) = 3 REPORT "ut_chary_con('c') not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(ETX) = 9 REPORT "ut_chary_con('d') not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(EOT) = 8 REPORT "ut_chary_con('e') not properly intialized" SEVERITY FAILURE; ASSERT ut_chary_con(ENQ) = 7 REPORT "ut_chary_con('f') not properly intialized" SEVERITY FAILURE; FOR I IN 0 TO 15 LOOP ASSERT ct_word_con(I) = '0' REPORT "ct_word_con(I) not properly intialized" SEVERITY FAILURE; END LOOP; ASSERT cst_str10_con_1(1) = 'a' REPORT "cst_str10_con_1(1) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(2) = 'b' REPORT "cst_str10_con_1(2) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(3) = 'c' REPORT "cst_str10_con_1(3) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(4) = 'd' REPORT "cst_str10_con_1(4) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(5) = 'e' REPORT "cst_str10_con_1(5) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(6) = 'f' REPORT "cst_str10_con_1(6) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(7) = 'g' REPORT "cst_str10_con_1(7) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(8) = 'h' REPORT "cst_str10_con_1(8) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(9) = 'i' REPORT "cst_str10_con_1(9) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_1(10)= 'j' REPORT "cst_str10_con_1(10)not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(1) = 'a' REPORT "cst_str10_con_2(1) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(2) = 'b' REPORT "cst_str10_con_2(2) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(3) = 'c' REPORT "cst_str10_con_2(3) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(4) = 'd' REPORT "cst_str10_con_2(4) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(5) = 'e' REPORT "cst_str10_con_2(5) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(6) = 'f' REPORT "cst_str10_con_2(6) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(7) = 'g' REPORT "cst_str10_con_2(7) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(8) = 'h' REPORT "cst_str10_con_2(8) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(9) = 'i' REPORT "cst_str10_con_2(9) not properly intialized" SEVERITY FAILURE; ASSERT cst_str10_con_2(10)= 'j' REPORT "cst_str10_con_2(10)not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('0') = 0 REPORT "cst_digit_con('0') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('1') = 1 REPORT "cst_digit_con('1') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('2') = 2 REPORT "cst_digit_con('2') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('3') = 3 REPORT "cst_digit_con('3') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('4') = 4 REPORT "cst_digit_con('4') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('5') = 5 REPORT "cst_digit_con('5') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('6') = 6 REPORT "cst_digit_con('6') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('7') = 7 REPORT "cst_digit_con('7') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('8') = 8 REPORT "cst_digit_con('8') not properly intialized" SEVERITY FAILURE; ASSERT cst_digit_con('9') = 9 REPORT "cst_digit_con('9') not properly intialized" SEVERITY FAILURE; ASSERT rt_date_con.day = 1 REPORT "rt_date_con.day not properly intialized" SEVERITY FAILURE; ASSERT rt_date_con.month = Jan REPORT "rt_date_con.month not properly intialized" SEVERITY FAILURE; ASSERT rt_date_con.year = 1989 REPORT "rt_date_con.year not properly intialized" SEVERITY FAILURE; ASSERT rst_date_con.day = 1 REPORT "rst_date_con.day not properly intialized" SEVERITY FAILURE; ASSERT rst_date_con.month = Apr REPORT "rst_date_con.month not properly intialized" SEVERITY FAILURE; ASSERT rst_date_con.year = 2000 REPORT "rst_date_con.year not properly intialized" SEVERITY FAILURE; --------------------------------------------------------------------------------------------- assert NOT( STRING_con_1(1) = 's' and STRING_con_1(2) = 'a' and STRING_con_1(3) = 'i' and STRING_con_1(4) = 'l' and STRING_con_1(5) = 'i' and STRING_con_1(6) = 'n' and STRING_con_1(7) = 'g' and STRING_con_2(1) = 's' and STRING_con_2(2) = 'a' and STRING_con_2(3) = 'i' and STRING_con_2(4) = 'l' and STRING_con_2(5) = 'i' and STRING_con_2(6) = 'n' and STRING_con_2(7) = 'g' and BIT_VECTOR_con_1(0) = '1' and BIT_VECTOR_con_1(1) = '0' and BIT_VECTOR_con_1(2) = '1' and BIT_VECTOR_con_1(3) = '0' and BIT_VECTOR_con_1(4) = '1' and BIT_VECTOR_con_1(5) = '1' and BIT_VECTOR_con_1(6) = '1' and BIT_VECTOR_con_1(7) = '0' and BIT_VECTOR_con_2(0) = '1' and BIT_VECTOR_con_2(1) = '0' and BIT_VECTOR_con_2(2) = '1' and BIT_VECTOR_con_2(3) = '0' and BIT_VECTOR_con_2(4) = '1' and BIT_VECTOR_con_2(5) = '1' and BIT_VECTOR_con_2(6) = '1' and BIT_VECTOR_con_2(7) = '0' and ut_chary_con(NUL) = 1 and ut_chary_con(SOH) = 2 and ut_chary_con(STX) = 3 and ut_chary_con(ETX) = 9 and ut_chary_con(EOT) = 8 and ut_chary_con(ENQ) = 7 and ct_word_con(0) = '0' and ct_word_con(1) = '0' and ct_word_con(2) = '0' and ct_word_con(3) = '0' and ct_word_con(4) = '0' and ct_word_con(5) = '0' and ct_word_con(6) = '0' and ct_word_con(7) = '0' and ct_word_con(8) = '0' and ct_word_con(9) = '0' and ct_word_con(10) = '0' and ct_word_con(11) = '0' and ct_word_con(12) = '0' and ct_word_con(13) = '0' and ct_word_con(14) = '0' and ct_word_con(15) = '0' and cst_str10_con_1(1) = 'a' and cst_str10_con_1(2) = 'b' and cst_str10_con_1(3) = 'c' and cst_str10_con_1(4) = 'd' and cst_str10_con_1(5) = 'e' and cst_str10_con_1(6) = 'f' and cst_str10_con_1(7) = 'g' and cst_str10_con_1(8) = 'h' and cst_str10_con_1(9) = 'i' and cst_str10_con_1(10)= 'j' and cst_str10_con_2(1) = 'a' and cst_str10_con_2(2) = 'b' and cst_str10_con_2(3) = 'c' and cst_str10_con_2(4) = 'd' and cst_str10_con_2(5) = 'e' and cst_str10_con_2(6) = 'f' and cst_str10_con_2(7) = 'g' and cst_str10_con_2(8) = 'h' and cst_str10_con_2(9) = 'i' and cst_str10_con_2(10)= 'j' and cst_digit_con('0') = 0 and cst_digit_con('1') = 1 and cst_digit_con('2') = 2 and cst_digit_con('3') = 3 and cst_digit_con('4') = 4 and cst_digit_con('5') = 5 and cst_digit_con('6') = 6 and cst_digit_con('7') = 7 and cst_digit_con('8') = 8 and cst_digit_con('9') = 9 and rt_date_con.day = 1 and rt_date_con.month = Jan and rt_date_con.year = 1989 and rst_date_con.day = 1 and rst_date_con.month = Apr and rst_date_con.year = 2000 ) report "***PASSED TEST: /src/ch04/sc03/sb01/ss01/p001/s010101.vhd" severity NOTE; assert ( STRING_con_1(1) = 's' and STRING_con_1(2) = 'a' and STRING_con_1(3) = 'i' and STRING_con_1(4) = 'l' and STRING_con_1(5) = 'i' and STRING_con_1(6) = 'n' and STRING_con_1(7) = 'g' and STRING_con_2(1) = 's' and STRING_con_2(2) = 'a' and STRING_con_2(3) = 'i' and STRING_con_2(4) = 'l' and STRING_con_2(5) = 'i' and STRING_con_2(6) = 'n' and STRING_con_2(7) = 'g' and BIT_VECTOR_con_1(0) = '1' and BIT_VECTOR_con_1(1) = '0' and BIT_VECTOR_con_1(2) = '1' and BIT_VECTOR_con_1(3) = '0' and BIT_VECTOR_con_1(4) = '1' and BIT_VECTOR_con_1(5) = '1' and BIT_VECTOR_con_1(6) = '1' and BIT_VECTOR_con_1(7) = '0' and BIT_VECTOR_con_2(0) = '1' and BIT_VECTOR_con_2(1) = '0' and BIT_VECTOR_con_2(2) = '1' and BIT_VECTOR_con_2(3) = '0' and BIT_VECTOR_con_2(4) = '1' and BIT_VECTOR_con_2(5) = '1' and BIT_VECTOR_con_2(6) = '1' and BIT_VECTOR_con_2(7) = '0' and ut_chary_con(NUL) = 1 and ut_chary_con(SOH) = 2 and ut_chary_con(STX) = 3 and ut_chary_con(ETX) = 9 and ut_chary_con(EOT) = 8 and ut_chary_con(ENQ) = 7 and ct_word_con(0) = '0' and ct_word_con(1) = '0' and ct_word_con(2) = '0' and ct_word_con(3) = '0' and ct_word_con(4) = '0' and ct_word_con(5) = '0' and ct_word_con(6) = '0' and ct_word_con(7) = '0' and ct_word_con(8) = '0' and ct_word_con(9) = '0' and ct_word_con(10) = '0' and ct_word_con(11) = '0' and ct_word_con(12) = '0' and ct_word_con(13) = '0' and ct_word_con(14) = '0' and ct_word_con(15) = '0' and cst_str10_con_1(1) = 'a' and cst_str10_con_1(2) = 'b' and cst_str10_con_1(3) = 'c' and cst_str10_con_1(4) = 'd' and cst_str10_con_1(5) = 'e' and cst_str10_con_1(6) = 'f' and cst_str10_con_1(7) = 'g' and cst_str10_con_1(8) = 'h' and cst_str10_con_1(9) = 'i' and cst_str10_con_1(10)= 'j' and cst_str10_con_2(1) = 'a' and cst_str10_con_2(2) = 'b' and cst_str10_con_2(3) = 'c' and cst_str10_con_2(4) = 'd' and cst_str10_con_2(5) = 'e' and cst_str10_con_2(6) = 'f' and cst_str10_con_2(7) = 'g' and cst_str10_con_2(8) = 'h' and cst_str10_con_2(9) = 'i' and cst_str10_con_2(10)= 'j' and cst_digit_con('0') = 0 and cst_digit_con('1') = 1 and cst_digit_con('2') = 2 and cst_digit_con('3') = 3 and cst_digit_con('4') = 4 and cst_digit_con('5') = 5 and cst_digit_con('6') = 6 and cst_digit_con('7') = 7 and cst_digit_con('8') = 8 and cst_digit_con('9') = 9 and rt_date_con.day = 1 and rt_date_con.month = Jan and rt_date_con.year = 1989 and rst_date_con.day = 1 and rst_date_con.month = Apr and rst_date_con.year = 2000 ) report "***FAILED TEST: c04s03b01x01p01n01i00031 - A constant declares a constant of the specified type." severity ERROR; wait; END PROCESS TESTING; END c04s03b01x01p01n01i00031arch; nvc-r1.17.1/test/regress/vests36.vhd000066400000000000000000000041161504111170000172120ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2460.vhd,v 1.2 2001-10-26 16:29:48 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests36 IS END vests36; ARCHITECTURE c07s03b02x02p03n02i02460arch OF vests36 IS type UNCONSTRAINED_ARRAY is array ( integer range <> ) of character; subtype CONSTRAINED_ARRAY is UNCONSTRAINED_ARRAY ( 1 to 3 ); type AGGREGATE_ARRAY is array (1 to 2) of CONSTRAINED_ARRAY; signal V,W : CONSTRAINED_ARRAY; BEGIN TESTING: PROCESS BEGIN (V,W) <= AGGREGATE_ARRAY' (('d', 'x', others => 'a'), ('d', 'x', others => 'a')); wait for 1 ns; assert NOT( V(1)='d' and V(2)='x' and V(3)='a' ) report "***PASSED TEST: c07s03b02x02p03n02i02460" severity NOTE; assert ( V(1)='d' and V(2)='x' and V(3)='a' ) report "***FAILED TEST: c07s03b02x02p03n02i02460 - An array aggregate with an others choice may appear as a value expression in an assignment statement." severity ERROR; wait; END PROCESS TESTING; END c07s03b02x02p03n02i02460arch; nvc-r1.17.1/test/regress/vests37.vhd000066400000000000000000000113611504111170000172130ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1781.vhd,v 1.2 2001-10-26 16:29:43 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- Package c09s06b00x00p04n05i01781pkg is type info is record field_1 : integer; field_2 : real; end record; type stuff is array (Integer range 1 to 2) of info; end c09s06b00x00p04n05i01781pkg; use work.c09s06b00x00p04n05i01781pkg.all; entity c09s06b00x00p04n05i01781ent_a is generic ( g0 : Boolean ; g1 : Bit ; g2 : Character ; g3 : SEVERITY_LEVEL ; g4 : Integer ; g5 : Real ; g6 : TIME ; g7 : Natural ; g8 : Positive ; g9 : String ; gA : Bit_vector ; gB : stuff ); end c09s06b00x00p04n05i01781ent_a; use work.c09s06b00x00p04n05i01781pkg.all; architecture c09s06b00x00p04n05i01781arch_a of c09s06b00x00p04n05i01781ent_a is -- Check that the data was passed... begin TESTING: PROCESS BEGIN assert NOT( g0 = True and g1 = '0' and g2 = '@' and g3 = NOTE and g4 = 123456789 and g5 = 987654321.5 and g6 = 110 ns and g7 = 12312 and g8 = 3423 and g9 = "16 characters OK" and gA = B"01010010100101010010101001010100"and gB = ((123, 456.7 ), (890, 135.7))) report "***PASSED TEST: c09s06b00x00p04n05i01781" severity NOTE; assert ( g0 = True and g1 = '0' and g2 = '@' and g3 = NOTE and g4 = 123456789 and g5 = 987654321.5 and g6 = 110 ns and g7 = 12312 and g8 = 3423 and g9 = "16 characters OK" and gA = B"01010010100101010010101001010100"and gB = ((123, 456.7 ), (890, 135.7))) report "***FAILED TEST: c09s06b00x00p04n05i01781 - The generic map aspect, if present, should associate a single actual with each local generic in the corresponding component declaration." severity ERROR; wait; END PROCESS TESTING; end c09s06b00x00p04n05i01781arch_a; ------------------------------------------------------------------------- ENTITY vests37 IS END vests37; use work.c09s06b00x00p04n05i01781pkg.all; ARCHITECTURE c09s06b00x00p04n05i01781arch OF vests37 IS subtype reg32 is Bit_vector ( 31 downto 0 ); subtype string16 is String ( 1 to 16 ); component MultiType generic ( g0 : Boolean ; g1 : Bit ; g2 : Character ; g3 : SEVERITY_LEVEL ; g4 : Integer ; g5 : Real ; g6 : TIME ; g7 : Natural ; g8 : Positive ; g9 : String ; gA : Bit_vector ; gB : stuff ); end component; for u1 : MultiType use entity work.c09s06b00x00p04n05i01781ent_a(c09s06b00x00p04n05i01781arch_a); BEGIN u1 : MultiType generic map ( True, '0', '@', NOTE, 123456789, 987654321.5, 110 ns, 12312, 3423, "16 characters OK", B"0101_0010_1001_0101_0010_1010_0101_0100", gB(2) => ( 890, 135.7 ), gB(1) => ( 123, 456.7 ) ); END c09s06b00x00p04n05i01781arch; nvc-r1.17.1/test/regress/vests38.vhd000066400000000000000000000043221504111170000172130ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA library std; use std.textio.all; ENTITY vests38 IS END vests38; ARCHITECTURE c14s03b00x00p60n01i03206arch OF vests38 IS BEGIN TESTING: PROCESS procedure write1 is file F: TEXT open write_mode is "iofile.64"; variable L: LINE; begin write(L, Integer'(12)); writeline(F, L); write(L, Integer'(34)); writeline(F, L); write(L, Integer'(56)); writeline(F, L); write(L, Integer'(78)); writeline(F, L); write(L, Integer'(90)); writeline(F, L); end write1; procedure read1 is file F: TEXT open read_mode is "iofile.64"; variable L: LINE; variable i,v_integer : Integer; begin i := 0; while not ENDFILE(F) loop readline(F, L); i := i + 1; end loop; Assert i /= 4 report "Line count to ENDFILE is incorrect" severity ERROR; assert NOT( i = 5 ) report "***PASSED TEST: c14s03b00x00p60n01i03206" severity NOTE; assert ( i = 5 ) report "***FAILED TEST: c14s03b00x00p60n01i03206 - Procedure ENDLINE test failed." & " i=" & integer'image(i) severity ERROR; end read1; BEGIN write1; wait for 10 ns; read1; wait; END PROCESS TESTING; END c14s03b00x00p60n01i03206arch; nvc-r1.17.1/test/regress/vests39.vhd000066400000000000000000000033711504111170000172170ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1679.vhd,v 1.2 2001-10-26 16:29:42 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests39 IS END vests39; ARCHITECTURE c09s01b00x00p08n01i01679arch OF vests39 IS constant size : INTEGER := 3; signal S : STRING(1 to size) := "Hi!"; BEGIN B: block generic (size : INTEGER); generic map (size => size); port (P : in STRING(1 to size)); port map (P => S); begin assert NOT(P="Hi!") report "***PASSED TEST: c09s01b00x00p08n01i01679" severity NOTE; assert (P="Hi!") report "***FAILED TEST: c09s01b00x00p08n01i01679 - Block statement test failed." severity ERROR; end block; END c09s01b00x00p08n01i01679arch; nvc-r1.17.1/test/regress/vests4.vhd000066400000000000000000000034401504111170000171240ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1488.vhd,v 1.2 2001-10-26 16:29:41 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests4 IS END vests4; ARCHITECTURE c08s08b00x00p04n03i01488arch OF vests4 IS BEGIN TESTING: PROCESS variable m : integer := 7; variable k : integer := 0; BEGIN case m is when integer'Low to -11 | 6 to 100 => k := 5; when others => NULL; end case; assert NOT( k = 5 ) report "***PASSED TEST: c08s08b00x00p04n03i01488" severity NOTE; assert ( k = 5 ) report "***FAILED TEST: c08s08b00x00p04n03i01488 - Each choice in a case statement alternative must be of the same type as the expression." severity ERROR; wait; END PROCESS TESTING; END c08s08b00x00p04n03i01488arch; nvc-r1.17.1/test/regress/vests40.vhd000066400000000000000000000042671504111170000172140ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1139.vhd,v 1.2 2001-10-26 16:29:39 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests40 IS END vests40; ARCHITECTURE c06s05b00x00p05n02i01139arch OF vests40 IS BEGIN TESTING: PROCESS type ENUM1 is (M1, M2, M3, M4, M5); type ABASE is array (ENUM1 range <>) of BOOLEAN; subtype A1 is ABASE(ENUM1 range M1 to M5); function F(i : integer) return ENUM1 is begin return M2; end F; function G(j : integer) return ENUM1 is begin return M4; end G; variable ii : integer; variable jj : integer; variable V1 : A1 ; -- := (others=>TRUE); variable V4 : A1 ; -- := (others=>TRUE); variable V2, V3: ENUM1; BEGIN V1(M1 to M3) := V1(F(ii) to G(jj)); assert NOT(V1(M1 to M3)=(false,false,false)) report "***PASSED TEST: c06s05b00x00p05n02i01139" severity NOTE; assert (V1(M1 to M3)=(false,false,false)) report "***FAILED TEST: c06s05b00x00p05n02i01139 - Dynamic expressions are permitted in lower and upper bounds in range specifications in array slices." severity ERROR; wait; END PROCESS TESTING; END c06s05b00x00p05n02i01139arch; nvc-r1.17.1/test/regress/vests41.vhd000066400000000000000000000135661504111170000172170ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc744.vhd,v 1.2 2001-10-26 16:29:59 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s01b01x01p05n02i00744pkg is type boolean_vector is array (natural range <>) of boolean; type severity_level_vector is array (natural range <>) of severity_level; type integer_vector is array (natural range <>) of integer; type real_vector is array (natural range <>) of real; type time_vector is array (natural range <>) of time; type natural_vector is array (natural range <>) of natural; type positive_vector is array (natural range <>) of positive; type record_std_package is record a: boolean; b: bit; c: character; d: severity_level; e: integer; f: real; g: time; h: natural; i: positive; j: string(1 to 7); k: bit_vector(0 to 3); end record; type array_rec_std is array (integer range <>) of record_std_package; end c01s01b01x01p05n02i00744pkg; use work.c01s01b01x01p05n02i00744pkg.all; ENTITY vests41 IS generic( zero : integer := 0; one : integer := 1; two : integer := 2; three: integer := 3; four : integer := 4; five : integer := 5; six : integer := 6; seven: integer := 7; eight: integer := 8; nine : integer := 9; fifteen:integer:= 15; C1 : boolean := true; C2 : bit := '1'; C3 : character := 's'; C4 : severity_level:= note; C5 : integer := 3; C6 : real := 3.0; C7 : time := 3 ns; C8 : natural := 1; C9 : positive := 1; C10 : string := "shishir"; C11 : bit_vector := B"0011" ); port( S1 : inout boolean_vector (zero to fifteen); S2 : inout severity_level_vector (zero to fifteen); S3 : inout integer_vector (zero to fifteen); S4 : inout real_vector (zero to fifteen); S5 : inout time_vector (zero to fifteen); S6 : inout natural_vector (zero to fifteen); S7 : inout positive_vector (zero to fifteen); S48: inout array_rec_std (zero to seven) ); END vests41; ARCHITECTURE c01s01b01x01p05n02i00744arch OF vests41 IS BEGIN TESTING: PROCESS variable k : integer := 0; BEGIN for i in S1'range loop S1(i) <= C1; end loop; for i in S2'range loop S2(i) <= C4; end loop; for i in S3'range loop S3(i) <= C5; end loop; for i in S4'range loop S4(i) <= C6; end loop; for i in S5'range loop S5(i) <= C7; end loop; for i in S6'range loop S6(i) <= C8; end loop; for i in S7'range loop S7(i) <= C9; end loop; for i in S48'range loop S48(i) <= (C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11); end loop; wait for 10 ns; for i in zero to 7 loop if (S1(i) /= true) then k := 1; end if; assert S1(i) = true report " boolean_vector(zero to fifteen) error in the left generic value" severity error; if (S2(i) /= note) then k := 1; end if; assert S2(i) = note report " severity_level_vector(zero to fifteen) error in the left generic value" severity error; if (S3(i) /= 3) then k := 1; end if; assert S3(i) = 3 report " integer_vector(zero to fifteen) error in the left generic value" severity error; if (S4(i) /= 3.0) then k := 1; end if; assert S4(i) = 3.0 report " real_vector(zero to fifteen) error in the left generic value" severity error; if (S5(i) /= 3 ns) then k := 1; end if; assert S5(i) = 3 ns report " time_vector (zero to fifteen) error in the left generic value" severity error; if (S6(i) /= 1) then k := 1; end if; assert S6(i) = 1 report " natural_vector(zero to fifteen) error in the left generic value" severity error; if (S7(i) /= 1) then k := 1; end if; assert S7(i) = 1 report " positive_vector(zero to fifteen) error in the left generic value" severity error; if (S48(i) /= (true,'1','s',note,3,3.0,3 ns,1,1,"shishir","0011")) then k := 1; end if; assert S48(i) = (true,'1','s',note,3,3.0,3 ns,1,1,"shishir","0011") report " array_rec_std(zero to seven) error in the left generic value" severity error; end loop; assert NOT( k=0 ) report "***PASSED TEST: c01s01b01x01p05n02i00744" severity NOTE; assert ( k=0 ) report "***FAILED TEST: c01s01b01x01p05n02i00744 - Generic can be used to specify the size of ports." severity ERROR; wait; END PROCESS TESTING; END c01s01b01x01p05n02i00744arch; nvc-r1.17.1/test/regress/vests42.vhd000066400000000000000000000130141504111170000172040ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc492.vhd,v 1.2 2001-10-26 16:29:55 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests42 IS END vests42; ARCHITECTURE c03s02b02x00p01n01i00492arch OF vests42 IS type etype is (one,two,three,four,five,six,seven); type TR is record i : integer; b : bit; bo : boolean; bv : bit_vector (0 to 3); r : real; t : time; e : etype; c : character; end record; type T1 is record t : time; b : bit; i : integer; bo : boolean; r : real; bv : bit_vector (0 to 3); e : etype; c : character; end record; function FUNC1(signal recd1: TR) return T1 is variable recd2:T1; begin recd2.bv := recd1.bv; recd2.b := recd1.b; recd2.bo := recd1.bo; recd2.i := recd1.i; recd2.r := recd1.r; recd2.t := recd1.t; recd2.e := recd1.e; recd2.c := recd1.c; return recd2; end FUNC1; function FUNC2(signal recd1: TR) return integer is begin return recd1.i; end; function FUNC3(signal recd1: TR) return bit is begin return recd1.b; end; function FUNC4(signal recd1: TR) return boolean is begin return recd1.bo; end; function FUNC5(signal recd1: TR) return bit_vector is begin return recd1.bv; end; function FUNC6(signal recd1: TR) return real is begin return recd1.r; end; function FUNC7(signal recd1: TR) return time is begin return recd1.t; end; function FUNC8(signal recd1: TR) return etype is begin return recd1.e; end; function FUNC9(signal recd1: TR) return character is begin return recd1.c; end; signal var1: TR; signal var2: T1; BEGIN TESTING: PROCESS variable OkayCount : integer := 0; BEGIN wait for 1 ns; var2 <= (bv=>"0000",b=>'0',bo=>false,i=>0,r=>0.0,t=>1 ms,e=>one,c=>'a'); var1 <= (bv=>"0001",b=>'1',bo=>true,i=>777,r=>333.767,t=>44 ms,e=>seven,c=>'%'); wait for 1 ns; var2 <= FUNC1(var1); wait for 1 ns; assert var2.bv = "0001" report "var2.bv /= 0001" severity note; assert var2.b = '1' report "var2.b /= 1" severity note; assert var2.bo = true report "var2.bo /= true" severity note; assert var2.i = 777 report "var2.i /= 777" severity note; assert var2.r = 333.767 report "var2.r /= 333.767" severity note; assert var2.t = 44 ms report "var2.t /= 44 ms" severity note; assert var2.e = seven report "var2.e /= seven" severity note; assert var2.c = '%' report "var2.c /= c" severity note; if var2 = (bv=>"0001",b=>'1',bo=>true,i=>777,r=>333.767,t=>44 ms,e=>seven,c=>'%') then OkayCount := OkayCount + 1; else assert false report "bad return on FUNC1" severity note; end if; var2 <= (bv=>"0000",b=>'0',bo=>false,i=>0,r=>0.0,t=>1 ms,e=>one,c=>'a'); wait for 1 ns; if var2 = (bv=>"0000",b=>'0',bo=>false,i=>0,r=>0.0,t=>1 ms,e=>one,c=>'a') then OkayCount := OkayCount + 1; end if; var2.i <= FUNC2(var1); var2.b <= FUNC3(var1); var2.bo <= FUNC4(var1); var2.bv <= FUNC5(var1); var2.r <= FUNC6(var1); var2.t <= FUNC7(var1); var2.e <= FUNC8(var1); var2.c <= FUNC9(var1); wait for 1 ns; assert var2.bv = "0001" report "var2.bv /= 0001" severity note; assert var2.b = '1' report "var2.b /= 1" severity note; assert var2.bo = true report "var2.bo /= true" severity note; assert var2.i = 777 report "var2.i /= 777" severity note; assert var2.r = 333.767 report "var2.r /= 333.767" severity note; assert var2.t = 44 ms report "var2.t /= 44 ms" severity note; assert var2.e = seven report "var2.e /= seven" severity note; assert var2.c = '%' report "var2.c /= c" severity note; if var2 = (bv=>"0001",b=>'1',bo=>true,i=>777,r=>333.767,t=>44 ms,e=>seven,c=>'%') then OkayCount := OkayCount + 1; else assert false report "bad return on FUNC2-8" severity note; end if; wait for 1 ns; assert NOT( OkayCount = 3 ) report "***PASSED TEST: c03s02b02x00p01n01i00492" severity NOTE; assert ( OkayCount = 3 ) report "***FAILED TEST: c03s02b02x00p01n01i00492 - Problem assigning record subelements in function." severity ERROR; wait; END PROCESS TESTING; END c03s02b02x00p01n01i00492arch; nvc-r1.17.1/test/regress/vests43.vhd000066400000000000000000000131051504111170000172060ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1205.vhd,v 1.2 2001-10-26 16:29:39 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c08s01b00x00p08n03i01205pkg is -- Type declarations. type SWITCH_LEVEL is ( '0', '1', 'X' ); type S_logic_vector is array(positive range <>) of SWITCH_LEVEL; -- Define the bus resolution function. function switchf( s : S_logic_vector ) return SWITCH_LEVEL; -- Further type declarations. subtype SWITCH_T is switchF SWITCH_LEVEL; type WORD is array(0 to 31) of SWITCH_T; end c08s01b00x00p08n03i01205pkg; package body c08s01b00x00p08n03i01205pkg is function switchf( s : S_logic_vector ) return SWITCH_LEVEL is begin return( S(1) ); end switchf; end c08s01b00x00p08n03i01205pkg; use work.c08s01b00x00p08n03i01205pkg.all; entity c08s01b00x00p08n03i01205ent_a is generic ( GenOne : in INTEGER ; GenTwo :INTEGER); end c08s01b00x00p08n03i01205ent_a; ------------------------------------------------------------------------- architecture c08s01b00x00p08n03i01205arch_a of c08s01b00x00p08n03i01205ent_a is -- Type definitions. type WORD2 is array( 0 to 31 ) of SWITCH_LEVEL; -- Local signals. signal A, B : WORD; signal UnResolved : WORD2; begin TEST_PROCESS: process -- Constant declarations. constant One : INTEGER := 1; constant Two : INTEGER := 2; -- Local variables. variable ShouldBeTime : TIME; variable I : INTEGER; variable k : integer := 0; begin -- Test locally static signals. A( 1 ) <= 'X' after 10 ns; A( 2 ) <= 'X' after 5 ns; ShouldBeTime := NOW + 10 ns; wait on A(1); -- Should wake up when the A(1) assignment takes place. assert (A(1) = 'X'); assert (ShouldBeTime = NOW); if (A(1) /= 'X' and ShouldBeTime /= Now) then k := 1; end if; -- Perform same test, but with a constant. A( One ) <= '1' after 10 ns; A( Two ) <= '1' after 5 ns; ShouldBeTime := NOW + 10 ns; wait on A(One); -- Should wake up when the A(1) assignment takes place. assert (A(One) = '1'); assert (ShouldBeTime = NOW); if (A(One) /= '1' and ShouldBeTime /= Now) then k := 1; end if; -- Perform same test, but with a generic. (globally static) A( GenOne ) <= 'X' after 10 ns; A( GenTwo ) <= 'X' after 5 ns; ShouldBeTime := NOW + 10 ns; wait on A(GenOne); -- Should wake up when the A(1) assignment takes place. assert (A(GenOne) = 'X'); assert (ShouldBeTime = NOW); if (A(GenOne) /= 'X' and ShouldBeTime /= Now) then k := 1; end if; -- Perform same test, but assigning to the whole thing. A <= ('1','1','1','1','1','1','1','1','1','1', '1','1','1','1','1','1','1','1','1','1', '1','1','1','1','1','1','1','1','1','1', '1','1') after 10 ns; ShouldBeTime := NOW + 10 ns; wait on A(GenOne); -- Should wake up when the all assignments take place. assert (A(GenOne) = '1'); assert (ShouldBeTime = NOW); if (A(GenOne) /= '1' and ShouldBeTime /= Now) then k := 1; end if; -- Now, perform same test but assigning to a composite -- signal which is NOT resolved at the scalar subelement -- level. UnResolved <= ('1','1','1','1','1','1','1','1','1','1', '1','1','1','1','1','1','1','1','1','1', '1','1','1','1','1','1','1','1','1','1', '1','1') after 10 ns; ShouldBeTime := NOW + 10 ns; wait on UnResolved(GenOne); -- Should wake up when the all assignments take place. assert (UnResolved(GenOne) = '1'); assert (ShouldBeTime = NOW); if (UnResolved(GenOne) /= '1' and ShouldBeTime /= Now) then k := 1; end if; assert NOT(k = 0) report "***PASSED TEST: c08s01b00x00p08n03i01205" severity NOTE; assert (k = 0) report "***FAILED TEST: c08s01b00x00p08n03i01205 - All statically indexed signal names (both locally and globally static) may be used in the sensitivity clause of a wait statement." severity ERROR; wait; end process TEST_PROCESS; end c08s01b00x00p08n03i01205arch_a; use work.c08s01b00x00p08n03i01205pkg.all; ENTITY vests43 IS END vests43; ARCHITECTURE c08s01b00x00p08n03i01205arch OF vests43 IS component c08s01b00x00p08n03i01205ent_a generic( GenOne : in INTEGER; GenTwo : INTEGER ); end component; for T1 : c08s01b00x00p08n03i01205ent_a use entity work.c08s01b00x00p08n03i01205ent_a(c08s01b00x00p08n03i01205arch_a); BEGIN T1 : c08s01b00x00p08n03i01205ent_a generic map ( 1, 2 ); END c08s01b00x00p08n03i01205arch; nvc-r1.17.1/test/regress/vests44.vhd000066400000000000000000000044121504111170000172100ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2882.vhd,v 1.2 2001-10-26 16:29:50 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests44 IS procedure proc2(constant flag:in integer; variable ret:inout integer); procedure proc3(constant flag:in integer; variable ret:inout integer); procedure proc2(constant flag:in integer; variable ret:inout integer) is begin if (flag = 0) then ret:= -1; else proc3((flag-1),ret); end if; ret:= ret + 1; end proc2; procedure proc3(constant flag:in integer; variable ret:inout integer) is begin if (flag = 0) then ret:= -1; else proc2((flag-1),ret); end if; ret:= ret + 1; end proc3; END vests44; ARCHITECTURE c02s01b00x00p07n01i02882arch OF vests44 IS BEGIN TESTING: PROCESS variable x:integer; BEGIN x:=99; assert (x=99) report "Initialization of integer variables incorrect" severity failure; proc2(3,x); assert NOT( x=3 ) report "***PASSED TEST: c02s01b00x00p07n01i02882" severity NOTE; assert ( x=3 ) report "***FAILED TEST: c02s01b00x00p07n01i02882 - Procedures resursion call test incorrect (A-B-A type)." severity ERROR; wait; END PROCESS TESTING; END c02s01b00x00p07n01i02882arch; nvc-r1.17.1/test/regress/vests45.vhd000066400000000000000000000052021504111170000172070ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1747.vhd,v 1.2 2001-10-26 16:29:43 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests45 IS function resolve_bit ( inputs : bit_vector) return bit is VARIABLE val : bit := '0'; begin if inputs'length = 0 then return val; else for i in inputs'range LOOP if inputs(i) = '1' then return '1'; end if; END LOOP; return '0'; end if; end resolve_bit; END vests45; ARCHITECTURE c09s05b00x00p12n02i01747arch OF vests45 IS signal a : resolve_bit bit BUS; signal b : resolve_bit bit BUS; signal grd : boolean; BEGIN grd <= TRUE after 10 ns, FALSE after 20 ns; block_label : BLOCK (grd) begin b <= guarded '1' after 1 ns; end block block_label; block_label_1 : BLOCK (grd) begin TESTING: PROCESS BEGIN if GUARD then a <= '1' after 1 ns; else a <= NULL; end if; wait on GUARD, a; END PROCESS TESTING; end block block_label_1; process(a,b) variable f1, f2 : integer := 0; begin if (now = 11 ns) and (a=b) then f1 := 1; end if; if (now = 20 ns) and (a=b) then f2 := 1; end if; if (now = 20 ns) then assert NOT((f1=1) and (f2=1)) report "***PASSED TEST: c09s05b00x00p12n02i01747" severity NOTE; assert ((f1=1) and (f2=1)) report "***FAILED TEST: c09s05b00x00p12n02i01747 - The concurrent guarded signal assignment statement has an equivalent process statement." severity ERROR; end if; end process; END c09s05b00x00p12n02i01747arch; nvc-r1.17.1/test/regress/vests46.vhd000066400000000000000000000045071504111170000172170ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc17.vhd,v 1.2 2001-10-26 16:29:42 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests46 IS END vests46; ARCHITECTURE c04s02b00x00p08n01i00017arch OF vests46 IS -- Forward declaration of the function. function WIRED_OR( S : BIT_VECTOR ) return BIT; -- Declare the subtype. subtype RBIT is WIRED_OR BIT; -- Declare the actual function. function WIRED_OR( S : BIT_VECTOR ) return BIT is begin assert FALSE report "***PASSED TEST: c04s02b00x00p08n01i00017" severity NOTE; if ( (S(0) = '1') OR (S(1) = '1')) then return '1'; end if; return '0'; end WIRED_OR; -- Declare a signal of that type. A resolved signal. signal S : RBIT; BEGIN -- A concurrent signal assignment. Driver # 1. S <= '1'; TESTING: PROCESS BEGIN -- Verify that resolution function getting called. S <= '1' after 10 ns; wait on S; assert NOT( S = '1' ) report "***PASSED TEST: c04s02b00x00p08n01i00017" severity NOTE; assert ( S = '1' ) report "***FAILED TEST: c04s02b00x00p08n01i00017 - If a resolution function name appears in a subtype, all signals declared to be of that subtype are resolved by that function." severity ERROR; wait; END PROCESS TESTING; END c04s02b00x00p08n01i00017arch; nvc-r1.17.1/test/regress/vests47.vhd000066400000000000000000000040661504111170000172200ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc133.vhd,v 1.2 2001-10-26 16:29:40 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests47 IS END vests47; ARCHITECTURE c04s03b02x02p08n01i00133arch OF vests47 IS type RT1 is record a : INTEGER; b : INTEGER; end record; BEGIN TESTING: PROCESS procedure Proc1(P : inout RT1; ref : in RT1; set : in RT1) is begin if (P = ref) then P := set; end if; end; variable V : RT1 := (1, 2); BEGIN V := (1, 2); Proc1(P.a => V.b, P.b => V.a, ref => (2, 1), set => (2, 3)); -- test here assert V = (3, 2) report "FAIL: P didn't get set right"; assert NOT( V = (3,2) ) report "***PASSED TEST: c04s03b02x02p08n01i00133" severity NOTE; assert ( V = (3,2) ) report "***FAILED TEST: c04s03b02x02p08n01i00133 - Association element in an association list test failed." severity ERROR; wait; END PROCESS TESTING; END c04s03b02x02p08n01i00133arch; nvc-r1.17.1/test/regress/vests48.vhd000066400000000000000000000044461504111170000172230ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc137.vhd,v 1.2 2001-10-26 16:29:40 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests48 IS END vests48; ARCHITECTURE c04s03b02x02p08n01i00137arch OF vests48 IS type AT0 is array (INTEGER range <>) of INTEGER; subtype ST0 is AT0(1 to 2); type AT1 is array (INTEGER range <>) of ST0; subtype ST1 is AT1(1 to 2); BEGIN TESTING: PROCESS procedure Proc1(P : inout ST1; ref : in ST1; set : in ST1) is begin if (P = ref) then P := set; end if; end; variable V : ST1 := ((1, 2), (3, 4)); variable V1 : ST0; variable V2 : ST0; BEGIN V1 := (1, 2); V2 := (3, 4); Proc1( P(1) => V2, P(2) => V1, ref => ((3, 4), (1, 2)), set => ((9, 8), (7, 6))); -- test here assert V1 = (7, 6) report "FAIL: actual V1 didn't get set right"; assert V2 = (9, 8) report "FAIL: actual V2 didn't get set right"; assert NOT( V1=(7,6) and V2=(9,8) ) report "***PASSED TEST: c04s03b02x02p08n01i00137" severity NOTE; assert ( V1=(7,6) and V2=(9,8) ) report "***FAILED TEST: c04s03b02x02p08n01i00137 - Association element in an association list test failed." severity ERROR; wait; END PROCESS TESTING; END c04s03b02x02p08n01i00137arch; nvc-r1.17.1/test/regress/vests49.vhd000066400000000000000000000144051504111170000172200ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1349.vhd,v 1.2 2001-10-26 16:29:40 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests49 IS END vests49; ARCHITECTURE c08s04b01x00p10n01i01349arch OF vests49 IS -- Local signals. signal S : BIT := '0'; BEGIN TESTING: PROCESS -- local variables. variable S_INITIAL : BIT; variable ShouldBeTime : TIME; variable k : integer := 0; BEGIN -- 0. Keep around the initial value of S. S_INITIAL := S; -- 1. When no preemption necessary, verify the results. INERTIAL SAME AS TRANSPORT. S <= (not S) after 10 ns, (S) after 20 ns; -- a. Wait for first transaction. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); -- b. Wait for second transaction. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = S_INITIAL); -- 2. Preempt a transaction which is to occur at the same time as second one. -- INERTIAL SAME AS TRANSPORT. S_INITIAL := S; S <= (S) after 10 ns; S <= (not S) after 10 ns; -- Should preempt first transaction. -- a. Verify that the second transaction comes as expected. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); -- b. Verify that the first transaction has been preempted. ShouldBeTime := NOW + 10 ns; wait on S for 10 ns; if (ShouldBeTime /= now ) then k := 1; end if; assert (ShouldBeTime = NOW); -- 3. Preempt a transaction which is to occur at a later time than second one. -- INERTIAL SAME AS TRANSPORT. S_INITIAL := S; S <= (S) after 15 ns; S <= (not S) after 10 ns; -- Should preempt first transaction. -- a. Verify that the second transaction comes as expected. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); -- b. Verify that the first transaction has been preempted. ShouldBeTime := NOW + 10 ns; wait on S for 10 ns; if (ShouldBeTime /= now ) then k := 1; end if; assert (ShouldBeTime = NOW); -- 4. Preempt multiple transactions. INERTIAL SAME AS TRANSPORT. S_INITIAL := S; S <= (S) after 15 ns, (not S) after 30 ns; S <= (not S) after 10 ns, (S) after 20 ns; -- a. Verify that the second transactions come as expected. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = S_INITIAL); -- b. Verify that the first transactions have been preempted. ShouldBeTime := NOW + 40 ns; wait on S for 40 ns; if (ShouldBeTime /= now ) then k := 1; end if; assert (ShouldBeTime = NOW); -- 5. Preempt transactions which occur before the second inertial assignment. S_INITIAL := S; S <= (S) after 5 ns; S <= (not S) after 10 ns, (S) after 20 ns; -- a. Verify that the second transactions come as expected. ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); ShouldBeTime := NOW + 10 ns; wait on S; if (ShouldBeTime /= now and S /= S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = S_INITIAL); -- b. Verify that the first transactions have been preempted. ShouldBeTime := NOW + 40 ns; wait on S for 40 ns; if (ShouldBeTime /= now ) then k := 1; end if; assert (ShouldBeTime = NOW); -- 6. Don't preempt transactions which occur before the second inertial assignment. S_INITIAL := S; S <= (not S) after 5 ns; S <= (not S) after 10 ns, (S) after 20 ns; -- a. Verify that the first transaction was NOT preempted. ShouldBeTime := NOW + 5 ns; wait on S; if (ShouldBeTime /= now and S /= not S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = (not S_INITIAL)); ShouldBeTime := NOW + 15 ns; wait on S; if (ShouldBeTime /= now and S /= S_INITIAL) then k := 1; end if; assert (ShouldBeTime = NOW); assert (S = S_INITIAL); -- b. Verify that there are no more transactions. ShouldBeTime := NOW + 40 ns; wait on S for 40 ns; if (ShouldBeTime /= now ) then k := 1; end if; assert (ShouldBeTime = NOW); assert NOT( k=0 ) report "***PASSED TEST: c08s04b01x00p10n01i01349" severity NOTE; assert ( k=0 ) report "***FAILED TEST: c08s04b01x00p10n01i01349 - Interial signal assignment test failed." severity ERROR; wait; END PROCESS TESTING; END c08s04b01x00p10n01i01349arch; nvc-r1.17.1/test/regress/vests5.vhd000066400000000000000000000036211504111170000171260ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1034.vhd,v 1.2 2001-10-26 16:29:38 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests5 IS END vests5; ARCHITECTURE c06s04b00x00p02n01i01034arch OF vests5 IS BEGIN TESTING: PROCESS type THREE is range 1 to 3; type A1 is array (THREE) of BOOLEAN; type A2 is array (THREE, THREE) of BOOLEAN; function F2(i : integer) return A2 is variable AR2 : A2; begin return AR2; end F2; variable A : integer; variable V: BOOLEAN; BEGIN V := F2(A)(2, 3); -- Indexed Name assert NOT(V=false) report "***PASSED TEST: c06s04b00x00p02n01i01034" severity NOTE; assert (V= false) report "***FAILED TEST: c06s04b00x00p02n01i01034 - The prefix of an indexed name can be a indexed name." severity ERROR; wait; END PROCESS TESTING; END c06s04b00x00p02n01i01034arch; nvc-r1.17.1/test/regress/vests6.vhd000066400000000000000000000044451504111170000171340ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc167.vhd,v 1.2 2001-10-26 16:29:42 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests6 IS END vests6; ARCHITECTURE c04s03b03x00p01n01i00167arch OF vests6 IS BEGIN TESTING: PROCESS constant C1 : INTEGER := 1; alias a1 : INTEGER is C1; constant C2 : STRING := "Hello"; alias a2 : STRING(4 downto 1) is C2(1 to 4); alias a3 : STRING(1 to 5) is C2; alias a4 : CHARACTER is C2(2); BEGIN assert C1 = 1; assert A1 = 1; assert C2 = "Hello"; assert A2 = "Hell"; assert A3 = "Hello"; assert A4 = 'e'; assert NOT( C1 = 1 and A1 = 1 and C2 = "Hello" and A2 = "Hell" and A3 = "Hello" and A4 = 'e' ) report "***PASSED TEST: c04s03b03x00p01n01i00167" severity NOTE; assert ( C1 = 1 and A1 = 1 and C2 = "Hello" and A2 = "Hell" and A3 = "Hello" and A4 = 'e' ) report "***FAILED TEST: c04s03b03x00p01n01i00167 - Alias for constant object test failed." severity ERROR; wait; END PROCESS TESTING; END c04s03b03x00p01n01i00167arch; nvc-r1.17.1/test/regress/vests7.vhd000066400000000000000000001422401504111170000171310ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc517.vhd,v 1.2 2001-10-26 16:29:55 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- PACKAGE c03s03b00x00p03n04i00517pkg IS -- -- Index types for array declarations -- SUBTYPE st_ind1 IS INTEGER RANGE 1 TO 8; -- index from 1 (POSITIVE) SUBTYPE st_ind2 IS INTEGER RANGE 0 TO 3; -- index from 0 (NATURAL) SUBTYPE st_ind3 IS CHARACTER RANGE 'a' TO 'd'; -- non-INTEGER index SUBTYPE st_ind4 IS INTEGER RANGE 0 DOWNTO -3; -- descending range -- -- Scalar type for subelements -- SUBTYPE st_scl1 IS CHARACTER ; SUBTYPE st_scl3 IS INTEGER RANGE 1 TO INTEGER'HIGH; SUBTYPE st_scl4 IS REAL RANGE 0.0 TO 1024.0; -- ----------------------------------------------------------------------------------------- -- Composite type declarations -- ----------------------------------------------------------------------------------------- -- -- Records of scalars -- TYPE t_scre_1 IS RECORD left : st_scl1; second : TIME; third : st_scl3; right : st_scl4; END RECORD; -- -- Unconstrained arrays of scalars -- TYPE t_usa1_1 IS ARRAY (st_ind1 RANGE <>) OF st_scl1; TYPE t_usa1_2 IS ARRAY (st_ind2 RANGE <>) OF TIME; TYPE t_usa1_3 IS ARRAY (st_ind3 RANGE <>) OF st_scl3; TYPE t_usa1_4 IS ARRAY (st_ind4 RANGE <>) OF st_scl4; TYPE t_usa2_1 IS ARRAY (st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; TYPE t_usa3_1 IS ARRAY (st_ind3 RANGE <>, st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; TYPE t_usa4_1 IS ARRAY (st_ind4 RANGE <>, st_ind3 RANGE <>, st_ind2 RANGE <>, st_ind1 RANGE <>) OF st_scl1; -- -- -- Constrained arrays of scalars (make compatable with unconstrained types -- SUBTYPE t_csa1_1 IS t_usa1_1 (st_ind1 ); SUBTYPE t_csa1_2 IS t_usa1_2 (st_ind2 ); SUBTYPE t_csa1_3 IS t_usa1_3 (st_ind3 ); SUBTYPE t_csa1_4 IS t_usa1_4 (st_ind4 ); SUBTYPE t_csa2_1 IS t_usa2_1 (st_ind2 , -- ( i2, i1 ) of CHAR st_ind1 ); SUBTYPE t_csa3_1 IS t_usa3_1 (st_ind3 , -- ( i3, i2, i1) of CHAR st_ind2 , st_ind1 ); SUBTYPE t_csa4_1 IS t_usa4_1 (st_ind4 , -- ( i4, i3, i2, i1 ) of CHAR st_ind3 , st_ind2 , st_ind1 ); -- -- -- constrained arrays of composites -- TYPE t_cca1_1 IS ARRAY (st_ind1) OF t_scre_1; -- ( i1 ) is RECORD of scalar TYPE t_cca1_2 IS ARRAY (st_ind2) OF t_csa1_1; -- ( i2 )( i1 ) is CHAR TYPE t_cca1_3 IS ARRAY (st_ind3) OF t_cca1_2; -- ( i3 )( i2 )( i1 ) is CHAR TYPE t_cca1_4 IS ARRAY (st_ind4) OF t_cca1_3; -- ( i4 )( i3 )( i2 )( i1 ) is CHAR TYPE t_cca2_1 IS ARRAY (st_ind3) OF t_csa2_1; -- ( i3 )( i2, i1 ) is CHAR TYPE t_cca2_2 IS ARRAY (st_ind4, -- ( i4, i3 )( i2, i1 ) of CHAR st_ind3) OF t_csa2_1; TYPE t_cca3_1 IS ARRAY (st_ind4, -- ( i4, i3, i2 )( i1 ) of CHAR st_ind3, st_ind2) OF t_csa1_1; TYPE t_cca3_2 IS ARRAY (st_ind4) OF t_csa3_1; -- ( i4 )( i3, i2, i1 ) is CHAR -- -- Records of composites -- TYPE t_cmre_1 IS RECORD left : t_csa1_1; -- .fN(i1) is CHAR second : t_scre_1; -- .fN.fN END RECORD; TYPE t_cmre_2 IS RECORD left , second , third , right : t_csa1_1; -- .fN(i1) is CHAR END RECORD; -- -- Mixed Records/arrays -- TYPE t_cca1_7 IS ARRAY (st_ind3) OF t_cmre_2; -- (i3).fN(i1) is CHAR TYPE t_cmre_3 IS RECORD left , second , third , right : t_cca1_7; -- .fN(i3).fN(i1) is CHAR END RECORD; -- -- TYPE declarations for resolution function (Constrained types only) -- TYPE t_scre_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_scre_1; TYPE t_csa1_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_1; TYPE t_csa1_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_2; TYPE t_csa1_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_3; TYPE t_csa1_4_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa1_4; TYPE t_csa2_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa2_1; TYPE t_csa3_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa3_1; TYPE t_csa4_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_csa4_1; TYPE t_cca1_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_1; TYPE t_cca1_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_2; TYPE t_cca1_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_3; TYPE t_cca1_4_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_4; TYPE t_cca2_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca2_1; TYPE t_cca2_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca2_2; TYPE t_cca3_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca3_1; TYPE t_cca3_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca3_2; TYPE t_cmre_1_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_1; TYPE t_cmre_2_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_2; TYPE t_cca1_7_vct IS ARRAY (POSITIVE RANGE <>) OF t_cca1_7; TYPE t_cmre_3_vct IS ARRAY (POSITIVE RANGE <>) OF t_cmre_3; -- -- Declaration of Resolution Functions -- FUNCTION rf_scre_1 ( v: t_scre_1_vct ) RETURN t_scre_1; FUNCTION rf_csa1_1 ( v: t_csa1_1_vct ) RETURN t_csa1_1; FUNCTION rf_csa1_2 ( v: t_csa1_2_vct ) RETURN t_csa1_2; FUNCTION rf_csa1_3 ( v: t_csa1_3_vct ) RETURN t_csa1_3; FUNCTION rf_csa1_4 ( v: t_csa1_4_vct ) RETURN t_csa1_4; FUNCTION rf_csa2_1 ( v: t_csa2_1_vct ) RETURN t_csa2_1; FUNCTION rf_csa3_1 ( v: t_csa3_1_vct ) RETURN t_csa3_1; FUNCTION rf_csa4_1 ( v: t_csa4_1_vct ) RETURN t_csa4_1; FUNCTION rf_cca1_1 ( v: t_cca1_1_vct ) RETURN t_cca1_1; FUNCTION rf_cca1_2 ( v: t_cca1_2_vct ) RETURN t_cca1_2; FUNCTION rf_cca1_3 ( v: t_cca1_3_vct ) RETURN t_cca1_3; FUNCTION rf_cca1_4 ( v: t_cca1_4_vct ) RETURN t_cca1_4; FUNCTION rf_cca2_1 ( v: t_cca2_1_vct ) RETURN t_cca2_1; FUNCTION rf_cca2_2 ( v: t_cca2_2_vct ) RETURN t_cca2_2; FUNCTION rf_cca3_1 ( v: t_cca3_1_vct ) RETURN t_cca3_1; FUNCTION rf_cca3_2 ( v: t_cca3_2_vct ) RETURN t_cca3_2; FUNCTION rf_cmre_1 ( v: t_cmre_1_vct ) RETURN t_cmre_1; FUNCTION rf_cmre_2 ( v: t_cmre_2_vct ) RETURN t_cmre_2; FUNCTION rf_cca1_7 ( v: t_cca1_7_vct ) RETURN t_cca1_7; FUNCTION rf_cmre_3 ( v: t_cmre_3_vct ) RETURN t_cmre_3; -- -- Resolved SUBTYPE declaration -- SUBTYPE rst_scre_1 IS rf_scre_1 t_scre_1 ; SUBTYPE rst_csa1_1 IS rf_csa1_1 t_csa1_1 ; SUBTYPE rst_csa1_2 IS rf_csa1_2 t_csa1_2 ; SUBTYPE rst_csa1_3 IS rf_csa1_3 t_csa1_3 ; SUBTYPE rst_csa1_4 IS rf_csa1_4 t_csa1_4 ; SUBTYPE rst_csa2_1 IS rf_csa2_1 t_csa2_1 ; SUBTYPE rst_csa3_1 IS rf_csa3_1 t_csa3_1 ; SUBTYPE rst_csa4_1 IS rf_csa4_1 t_csa4_1 ; SUBTYPE rst_cca1_1 IS rf_cca1_1 t_cca1_1 ; SUBTYPE rst_cca1_2 IS rf_cca1_2 t_cca1_2 ; SUBTYPE rst_cca1_3 IS rf_cca1_3 t_cca1_3 ; SUBTYPE rst_cca1_4 IS rf_cca1_4 t_cca1_4 ; SUBTYPE rst_cca2_1 IS rf_cca2_1 t_cca2_1 ; SUBTYPE rst_cca2_2 IS rf_cca2_2 t_cca2_2 ; SUBTYPE rst_cca3_1 IS rf_cca3_1 t_cca3_1 ; SUBTYPE rst_cca3_2 IS rf_cca3_2 t_cca3_2 ; SUBTYPE rst_cmre_1 IS rf_cmre_1 t_cmre_1 ; SUBTYPE rst_cmre_2 IS rf_cmre_2 t_cmre_2 ; SUBTYPE rst_cca1_7 IS rf_cca1_7 t_cca1_7 ; SUBTYPE rst_cmre_3 IS rf_cmre_3 t_cmre_3 ; -- -- Functions declarations for multi-dimensional comosite values -- FUNCTION F_csa2_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa2_1 ; FUNCTION F_csa3_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa3_1 ; FUNCTION F_csa4_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa4_1 ; FUNCTION F_cca2_2 ( v0,v2 : IN t_csa2_1 ) RETURN t_cca2_2 ; FUNCTION F_cca3_1 ( v0,v2 : IN t_csa1_1 ) RETURN t_cca3_1 ; -- ------------------------------------------------------------------------------------------- -- Data values for Composite Types -- ------------------------------------------------------------------------------------------- CONSTANT CX_scl1 : st_scl1 := 'X' ; CONSTANT C0_scl1 : st_scl1 := st_scl1'LEFT ; CONSTANT C1_scl1 : st_scl1 := 'A' ; CONSTANT C2_scl1 : st_scl1 := 'Z' ; CONSTANT CX_scl2 : TIME := 99 fs ; CONSTANT C0_scl2 : TIME := TIME'LEFT ; CONSTANT C1_scl2 : TIME := 0 fs; CONSTANT C2_scl2 : TIME := 2 ns; CONSTANT CX_scl3 : st_scl3 := 15 ; CONSTANT C0_scl3 : st_scl3 := st_scl3'LEFT ; CONSTANT C1_scl3 : st_scl3 := 6 ; CONSTANT C2_scl3 : st_scl3 := 8 ; CONSTANT CX_scl4 : st_scl4 := 99.9 ; CONSTANT C0_scl4 : st_scl4 := st_scl4'LEFT ; CONSTANT C1_scl4 : st_scl4 := 1.0 ; CONSTANT C2_scl4 : st_scl4 := 2.1 ; CONSTANT CX_scre_1 : t_scre_1 := ( CX_scl1, CX_scl2, CX_scl3, CX_scl4 ); CONSTANT C0_scre_1 : t_scre_1 := ( C0_scl1, C0_scl2, C0_scl3, C0_scl4 ); CONSTANT C1_scre_1 : t_scre_1 := ( C1_scl1, C1_scl2, C1_scl3, C1_scl4 ); CONSTANT C2_scre_1 : t_scre_1 := ( C2_scl1, C0_scl2, C0_scl3, C2_scl4 ); CONSTANT CX_csa1_1 : t_csa1_1 := ( OTHERS=>CX_scl1); CONSTANT C0_csa1_1 : t_csa1_1 := ( OTHERS=>C0_scl1); CONSTANT C1_csa1_1 : t_csa1_1 := ( OTHERS=>C1_scl1); CONSTANT C2_csa1_1 : t_csa1_1 := ( t_csa1_1'LEFT|t_csa1_1'RIGHT=>C2_scl1, OTHERS =>C0_scl1); CONSTANT CX_csa1_2 : t_csa1_2 := ( OTHERS=>CX_scl2); CONSTANT C0_csa1_2 : t_csa1_2 := ( OTHERS=>C0_scl2); CONSTANT C1_csa1_2 : t_csa1_2 := ( OTHERS=>C1_scl2); CONSTANT C2_csa1_2 : t_csa1_2 := ( t_csa1_2'LEFT|t_csa1_2'RIGHT=>C2_scl2, OTHERS =>C0_scl2); CONSTANT CX_csa1_3 : t_csa1_3 := ( OTHERS=>CX_scl3); CONSTANT C0_csa1_3 : t_csa1_3 := ( OTHERS=>C0_scl3); CONSTANT C1_csa1_3 : t_csa1_3 := ( OTHERS=>C1_scl3); CONSTANT C2_csa1_3 : t_csa1_3 := ( t_csa1_3'LEFT|t_csa1_3'RIGHT=>C2_scl3, OTHERS =>C0_scl3); CONSTANT CX_csa1_4 : t_csa1_4 := ( OTHERS=>CX_scl4); CONSTANT C0_csa1_4 : t_csa1_4 := ( OTHERS=>C0_scl4); CONSTANT C1_csa1_4 : t_csa1_4 := ( OTHERS=>C1_scl4); CONSTANT C2_csa1_4 : t_csa1_4 := ( t_csa1_4'LEFT|t_csa1_4'RIGHT=>C2_scl4, OTHERS =>C0_scl4); -- CONSTANT CX_csa2_1 : t_csa2_1 ; CONSTANT C0_csa2_1 : t_csa2_1 ; CONSTANT C1_csa2_1 : t_csa2_1 ; CONSTANT C2_csa2_1 : t_csa2_1 ; CONSTANT CX_csa3_1 : t_csa3_1 ; CONSTANT C0_csa3_1 : t_csa3_1 ; CONSTANT C1_csa3_1 : t_csa3_1 ; CONSTANT C2_csa3_1 : t_csa3_1 ; CONSTANT CX_csa4_1 : t_csa4_1 ; CONSTANT C0_csa4_1 : t_csa4_1 ; CONSTANT C1_csa4_1 : t_csa4_1 ; CONSTANT C2_csa4_1 : t_csa4_1 ; -- CONSTANT CX_cca1_1 : t_cca1_1 := ( OTHERS=>CX_scre_1 ); CONSTANT C0_cca1_1 : t_cca1_1 := ( OTHERS=>C0_scre_1 ); CONSTANT C1_cca1_1 : t_cca1_1 := ( OTHERS=>C1_scre_1 ); CONSTANT C2_cca1_1 : t_cca1_1 := ( C2_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C0_scre_1, C2_scre_1 ); CONSTANT CX_cca1_2 : t_cca1_2 := ( OTHERS=>CX_csa1_1 ); CONSTANT C0_cca1_2 : t_cca1_2 := ( OTHERS=>C0_csa1_1 ); CONSTANT C1_cca1_2 : t_cca1_2 := ( OTHERS=>C1_csa1_1 ); CONSTANT C2_cca1_2 : t_cca1_2 := ( C2_csa1_1, C0_csa1_1, C0_csa1_1, C2_csa1_1 ); CONSTANT CX_cca1_3 : t_cca1_3 := ( OTHERS=>CX_cca1_2 ); CONSTANT C0_cca1_3 : t_cca1_3 := ( OTHERS=>C0_cca1_2 ); CONSTANT C1_cca1_3 : t_cca1_3 := ( OTHERS=>C1_cca1_2 ); CONSTANT C2_cca1_3 : t_cca1_3 := ( C2_cca1_2, C0_cca1_2, C0_cca1_2, C2_cca1_2 ); CONSTANT CX_cca1_4 : t_cca1_4 := ( OTHERS=>CX_cca1_3 ); CONSTANT C0_cca1_4 : t_cca1_4 := ( OTHERS=>C0_cca1_3 ); CONSTANT C1_cca1_4 : t_cca1_4 := ( OTHERS=>C1_cca1_3 ); CONSTANT C2_cca1_4 : t_cca1_4 := ( C2_cca1_3, C0_cca1_3, C0_cca1_3, C2_cca1_3 ); CONSTANT CX_cca2_1 : t_cca2_1 ; CONSTANT C0_cca2_1 : t_cca2_1 ; CONSTANT C1_cca2_1 : t_cca2_1 ; CONSTANT C2_cca2_1 : t_cca2_1 ; -- CONSTANT CX_cca2_2 : t_cca2_2 ; CONSTANT C0_cca2_2 : t_cca2_2 ; CONSTANT C1_cca2_2 : t_cca2_2 ; CONSTANT C2_cca2_2 : t_cca2_2 ; CONSTANT CX_cca3_1 : t_cca3_1 ; CONSTANT C0_cca3_1 : t_cca3_1 ; CONSTANT C1_cca3_1 : t_cca3_1 ; CONSTANT C2_cca3_1 : t_cca3_1 ; -- CONSTANT CX_cca3_2 : t_cca3_2 ; CONSTANT C0_cca3_2 : t_cca3_2 ; CONSTANT C1_cca3_2 : t_cca3_2 ; CONSTANT C2_cca3_2 : t_cca3_2 ; CONSTANT CX_cmre_1 : t_cmre_1 := ( CX_csa1_1, CX_scre_1 ); CONSTANT C0_cmre_1 : t_cmre_1 := ( C0_csa1_1, C0_scre_1 ); CONSTANT C1_cmre_1 : t_cmre_1 := ( C1_csa1_1, C1_scre_1 ); CONSTANT C2_cmre_1 : t_cmre_1 := ( C2_csa1_1, C0_scre_1 ); CONSTANT CX_cmre_2 : t_cmre_2 := ( OTHERS=>CX_csa1_1 ); CONSTANT C0_cmre_2 : t_cmre_2 := ( OTHERS=>C0_csa1_1 ); CONSTANT C1_cmre_2 : t_cmre_2 := ( OTHERS=>C1_csa1_1 ); CONSTANT C2_cmre_2 : t_cmre_2 := ( left|right=>C2_csa1_1, OTHERS=>C0_csa1_1 ); CONSTANT CX_cca1_7 : t_cca1_7 := ( OTHERS=>CX_cmre_2 ); CONSTANT C0_cca1_7 : t_cca1_7 := ( OTHERS=>C0_cmre_2 ); CONSTANT C1_cca1_7 : t_cca1_7 := ( OTHERS=>C1_cmre_2 ); CONSTANT C2_cca1_7 : t_cca1_7 := ( C2_cmre_2, C0_cmre_2, C0_cmre_2, C2_cmre_2 ); CONSTANT CX_cmre_3 : t_cmre_3 := ( OTHERS=>CX_cca1_7 ); CONSTANT C0_cmre_3 : t_cmre_3 := ( OTHERS=>C0_cca1_7 ); CONSTANT C1_cmre_3 : t_cmre_3 := ( OTHERS=>C1_cca1_7 ); CONSTANT C2_cmre_3 : t_cmre_3 := ( left|right=>C2_cca1_7, OTHERS=>C0_cca1_7 ); -- -------------------------------------------------------------------------------------------- -- Functions for mapping from integer test values to/from values of the Test types -- -------------------------------------------------------------------------------------------- FUNCTION val_t ( i : INTEGER ) RETURN st_scl1; FUNCTION val_t ( i : INTEGER ) RETURN TIME; FUNCTION val_t ( i : INTEGER ) RETURN st_scl3; FUNCTION val_t ( i : INTEGER ) RETURN st_scl4; FUNCTION val_t ( i : INTEGER ) RETURN t_scre_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_2; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_3; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_4; FUNCTION val_t ( i : INTEGER ) RETURN t_csa2_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa3_1; FUNCTION val_t ( i : INTEGER ) RETURN t_csa4_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_3; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_4; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_1; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_2; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_7; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_3; FUNCTION val_i ( i : st_scl1 ) RETURN INTEGER; FUNCTION val_i ( i : TIME ) RETURN INTEGER; FUNCTION val_i ( i : st_scl3 ) RETURN INTEGER; FUNCTION val_i ( i : st_scl4 ) RETURN INTEGER; FUNCTION val_i ( i : t_scre_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_3 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa1_4 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa2_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa3_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_csa4_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_3 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_4 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca2_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca2_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca3_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca3_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_1 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_2 ) RETURN INTEGER; FUNCTION val_i ( i : t_cca1_7 ) RETURN INTEGER; FUNCTION val_i ( i : t_cmre_3 ) RETURN INTEGER; FUNCTION val_s ( i : st_scl1 ) RETURN STRING; FUNCTION val_s ( i : TIME ) RETURN STRING; FUNCTION val_s ( i : st_scl3 ) RETURN STRING; FUNCTION val_s ( i : st_scl4 ) RETURN STRING; FUNCTION val_s ( i : t_scre_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_2 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_3 ) RETURN STRING; FUNCTION val_s ( i : t_csa1_4 ) RETURN STRING; FUNCTION val_s ( i : t_csa2_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa3_1 ) RETURN STRING; FUNCTION val_s ( i : t_csa4_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_3 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_4 ) RETURN STRING; FUNCTION val_s ( i : t_cca2_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca2_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca3_1 ) RETURN STRING; FUNCTION val_s ( i : t_cca3_2 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_1 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_2 ) RETURN STRING; FUNCTION val_s ( i : t_cca1_7 ) RETURN STRING; FUNCTION val_s ( i : t_cmre_3 ) RETURN STRING; END; PACKAGE BODY c03s03b00x00p03n04i00517pkg IS -- -- Functions to provide values for multi-dimensional composites -- FUNCTION F_csa2_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa2_1 IS VARIABLE res : t_csa2_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP res(i,j) := v0; END LOOP; END LOOP; res(res'left (1),res'left (2)) := v2; res(res'left (1),res'right(2)) := v2; res(res'right(1),res'left (2)) := v2; res(res'right(1),res'right(2)) := v2; RETURN res; END; FUNCTION F_csa3_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa3_1 IS VARIABLE res : t_csa3_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP FOR k IN res'RANGE(3) LOOP res(i,j,k) := v0; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3)) := v2; res(res'right(1),res'left (2),res'left (3)) := v2; res(res'left (1),res'right(2),res'left (3)) := v2; res(res'right(1),res'right(2),res'left (3)) := v2; res(res'left (1),res'left (2),res'right(3)) := v2; res(res'right(1),res'left (2),res'right(3)) := v2; res(res'left (1),res'right(2),res'right(3)) := v2; res(res'right(1),res'right(2),res'right(3)) := v2; RETURN res; END; FUNCTION F_csa4_1 ( v0,v2 : IN st_scl1 ) RETURN t_csa4_1 IS VARIABLE res : t_csa4_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP FOR k IN res'RANGE(3) LOOP FOR l IN res'RANGE(4) LOOP res(i,j,k,l) := v0; END LOOP; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3),res'left (4)) := v2; res(res'right(1),res'left (2),res'left (3),res'left (4)) := v2; res(res'left (1),res'right(2),res'left (3),res'left (4)) := v2; res(res'right(1),res'right(2),res'left (3),res'left (4)) := v2; res(res'left (1),res'left (2),res'right(3),res'left (4)) := v2; res(res'right(1),res'left (2),res'right(3),res'left (4)) := v2; res(res'left (1),res'right(2),res'right(3),res'left (4)) := v2; res(res'right(1),res'right(2),res'right(3),res'left (4)) := v2; res(res'left (1),res'left (2),res'left (3),res'right(4)) := v2; res(res'right(1),res'left (2),res'left (3),res'right(4)) := v2; res(res'left (1),res'right(2),res'left (3),res'right(4)) := v2; res(res'right(1),res'right(2),res'left (3),res'right(4)) := v2; res(res'left (1),res'left (2),res'right(3),res'right(4)) := v2; res(res'right(1),res'left (2),res'right(3),res'right(4)) := v2; res(res'left (1),res'right(2),res'right(3),res'right(4)) := v2; res(res'right(1),res'right(2),res'right(3),res'right(4)) := v2; RETURN res; END; FUNCTION F_cca2_2 ( v0,v2 : IN t_csa2_1 ) RETURN t_cca2_2 IS VARIABLE res : t_cca2_2; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP res(i,j) := v0; END LOOP; END LOOP; res(res'left (1),res'left (2)) := v2; res(res'left (1),res'right(2)) := v2; res(res'right(1),res'left (2)) := v2; res(res'right(1),res'right(2)) := v2; RETURN res; END; FUNCTION F_cca3_1 ( v0,v2 : IN t_csa1_1 ) RETURN t_cca3_1 IS VARIABLE res : t_cca3_1; BEGIN FOR i IN res'RANGE(1) LOOP FOR j IN res'RANGE(2) LOOP FOR k IN res'RANGE(3) LOOP res(i,j,k) := v0; END LOOP; END LOOP; END LOOP; res(res'left (1),res'left (2),res'left (3)) := v2; res(res'right(1),res'left (2),res'left (3)) := v2; res(res'left (1),res'right(2),res'left (3)) := v2; res(res'right(1),res'right(2),res'left (3)) := v2; res(res'left (1),res'left (2),res'right(3)) := v2; res(res'right(1),res'left (2),res'right(3)) := v2; res(res'left (1),res'right(2),res'right(3)) := v2; res(res'right(1),res'right(2),res'right(3)) := v2; RETURN res; END; -- -- Resolution Functions -- FUNCTION rf_scre_1 ( v: t_scre_1_vct ) RETURN t_scre_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_scre_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_1 ( v: t_csa1_1_vct ) RETURN t_csa1_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_2 ( v: t_csa1_2_vct ) RETURN t_csa1_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_3 ( v: t_csa1_3_vct ) RETURN t_csa1_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_3; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa1_4 ( v: t_csa1_4_vct ) RETURN t_csa1_4 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa1_4; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa2_1 ( v: t_csa2_1_vct ) RETURN t_csa2_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa2_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa3_1 ( v: t_csa3_1_vct ) RETURN t_csa3_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa3_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_csa4_1 ( v: t_csa4_1_vct ) RETURN t_csa4_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_csa4_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_1 ( v: t_cca1_1_vct ) RETURN t_cca1_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_2 ( v: t_cca1_2_vct ) RETURN t_cca1_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_3 ( v: t_cca1_3_vct ) RETURN t_cca1_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_3; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_4 ( v: t_cca1_4_vct ) RETURN t_cca1_4 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_4; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca2_1 ( v: t_cca2_1_vct ) RETURN t_cca2_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca2_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca2_2 ( v: t_cca2_2_vct ) RETURN t_cca2_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca2_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca3_1 ( v: t_cca3_1_vct ) RETURN t_cca3_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca3_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca3_2 ( v: t_cca3_2_vct ) RETURN t_cca3_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca3_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_1 ( v: t_cmre_1_vct ) RETURN t_cmre_1 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_1; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_2 ( v: t_cmre_2_vct ) RETURN t_cmre_2 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_2; ELSE RETURN v(1); END IF; END; FUNCTION rf_cca1_7 ( v: t_cca1_7_vct ) RETURN t_cca1_7 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cca1_7; ELSE RETURN v(1); END IF; END; FUNCTION rf_cmre_3 ( v: t_cmre_3_vct ) RETURN t_cmre_3 IS BEGIN IF v'LENGTH=0 THEN RETURN CX_cmre_3; ELSE RETURN v(1); END IF; END; CONSTANT CX_csa2_1 : t_csa2_1 := F_csa2_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa2_1 : t_csa2_1 := F_csa2_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa2_1 : t_csa2_1 := F_csa2_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa2_1 : t_csa2_1 := F_csa2_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_csa3_1 : t_csa3_1 := F_csa3_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa3_1 : t_csa3_1 := F_csa3_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa3_1 : t_csa3_1 := F_csa3_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa3_1 : t_csa3_1 := F_csa3_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_csa4_1 : t_csa4_1 := F_csa4_1 ( CX_scl1, CX_scl1 ); CONSTANT C0_csa4_1 : t_csa4_1 := F_csa4_1 ( C0_scl1, C0_scl1 ); CONSTANT C1_csa4_1 : t_csa4_1 := F_csa4_1 ( C1_scl1, C1_scl1 ); CONSTANT C2_csa4_1 : t_csa4_1 := F_csa4_1 ( C0_scl1, C2_scl1 ); CONSTANT CX_cca2_1 : t_cca2_1 := ( OTHERS=>CX_csa2_1 ); CONSTANT C0_cca2_1 : t_cca2_1 := ( OTHERS=>C0_csa2_1 ); CONSTANT C1_cca2_1 : t_cca2_1 := ( OTHERS=>C1_csa2_1 ); CONSTANT C2_cca2_1 : t_cca2_1 := ( C2_csa2_1, C0_csa2_1, C0_csa2_1, C2_csa2_1 ); CONSTANT CX_cca2_2 : t_cca2_2 := F_cca2_2 ( CX_csa2_1, CX_csa2_1 ); CONSTANT C0_cca2_2 : t_cca2_2 := F_cca2_2 ( C0_csa2_1, C0_csa2_1 ); CONSTANT C1_cca2_2 : t_cca2_2 := F_cca2_2 ( C1_csa2_1, C1_csa2_1 ); CONSTANT C2_cca2_2 : t_cca2_2 := F_cca2_2 ( C0_csa2_1, C2_csa2_1 ); CONSTANT CX_cca3_1 : t_cca3_1 := F_cca3_1 ( CX_csa1_1, CX_csa1_1 ); CONSTANT C0_cca3_1 : t_cca3_1 := F_cca3_1 ( C0_csa1_1, C0_csa1_1 ); CONSTANT C1_cca3_1 : t_cca3_1 := F_cca3_1 ( C1_csa1_1, C1_csa1_1 ); CONSTANT C2_cca3_1 : t_cca3_1 := F_cca3_1 ( C0_csa1_1, C2_csa1_1 ); CONSTANT CX_cca3_2 : t_cca3_2 := ( OTHERS=>CX_csa3_1 ); CONSTANT C0_cca3_2 : t_cca3_2 := ( OTHERS=>C0_csa3_1 ); CONSTANT C1_cca3_2 : t_cca3_2 := ( OTHERS=>C1_csa3_1 ); CONSTANT C2_cca3_2 : t_cca3_2 := ( C2_csa3_1, C0_csa3_1, C0_csa3_1, C2_csa3_1 ); -- -- FUNCTION val_t ( i : INTEGER ) RETURN st_scl1 IS BEGIN IF i = 0 THEN RETURN C0_scl1; END IF; IF i = 1 THEN RETURN C1_scl1; END IF; IF i = 2 THEN RETURN C2_scl1; END IF; RETURN CX_scl1; END; FUNCTION val_t ( i : INTEGER ) RETURN TIME IS BEGIN IF i = 0 THEN RETURN C0_scl2; END IF; IF i = 1 THEN RETURN C1_scl2; END IF; IF i = 2 THEN RETURN C2_scl2; END IF; RETURN CX_scl2; END; FUNCTION val_t ( i : INTEGER ) RETURN st_scl3 IS BEGIN IF i = 0 THEN RETURN C0_scl3; END IF; IF i = 1 THEN RETURN C1_scl3; END IF; IF i = 2 THEN RETURN C2_scl3; END IF; RETURN CX_scl3; END; FUNCTION val_t ( i : INTEGER ) RETURN st_scl4 IS BEGIN IF i = 0 THEN RETURN C0_scl4; END IF; IF i = 1 THEN RETURN C1_scl4; END IF; IF i = 2 THEN RETURN C2_scl4; END IF; RETURN CX_scl4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_scre_1 IS BEGIN IF i = 0 THEN RETURN C0_scre_1; END IF; IF i = 1 THEN RETURN C1_scre_1; END IF; IF i = 2 THEN RETURN C2_scre_1; END IF; RETURN CX_scre_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_1 IS BEGIN IF i = 0 THEN RETURN C0_csa1_1; END IF; IF i = 1 THEN RETURN C1_csa1_1; END IF; IF i = 2 THEN RETURN C2_csa1_1; END IF; RETURN CX_csa1_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_2 IS BEGIN IF i = 0 THEN RETURN C0_csa1_2; END IF; IF i = 1 THEN RETURN C1_csa1_2; END IF; IF i = 2 THEN RETURN C2_csa1_2; END IF; RETURN CX_csa1_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_3 IS BEGIN IF i = 0 THEN RETURN C0_csa1_3; END IF; IF i = 1 THEN RETURN C1_csa1_3; END IF; IF i = 2 THEN RETURN C2_csa1_3; END IF; RETURN CX_csa1_3; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa1_4 IS BEGIN IF i = 0 THEN RETURN C0_csa1_4; END IF; IF i = 1 THEN RETURN C1_csa1_4; END IF; IF i = 2 THEN RETURN C2_csa1_4; END IF; RETURN CX_csa1_4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa2_1 IS BEGIN IF i = 0 THEN RETURN C0_csa2_1; END IF; IF i = 1 THEN RETURN C1_csa2_1; END IF; IF i = 2 THEN RETURN C2_csa2_1; END IF; RETURN CX_csa2_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa3_1 IS BEGIN IF i = 0 THEN RETURN C0_csa3_1; END IF; IF i = 1 THEN RETURN C1_csa3_1; END IF; IF i = 2 THEN RETURN C2_csa3_1; END IF; RETURN CX_csa3_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_csa4_1 IS BEGIN IF i = 0 THEN RETURN C0_csa4_1; END IF; IF i = 1 THEN RETURN C1_csa4_1; END IF; IF i = 2 THEN RETURN C2_csa4_1; END IF; RETURN CX_csa4_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_1 IS BEGIN IF i = 0 THEN RETURN C0_cca1_1; END IF; IF i = 1 THEN RETURN C1_cca1_1; END IF; IF i = 2 THEN RETURN C2_cca1_1; END IF; RETURN CX_cca1_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_2 IS BEGIN IF i = 0 THEN RETURN C0_cca1_2; END IF; IF i = 1 THEN RETURN C1_cca1_2; END IF; IF i = 2 THEN RETURN C2_cca1_2; END IF; RETURN CX_cca1_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_3 IS BEGIN IF i = 0 THEN RETURN C0_cca1_3; END IF; IF i = 1 THEN RETURN C1_cca1_3; END IF; IF i = 2 THEN RETURN C2_cca1_3; END IF; RETURN CX_cca1_3; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_4 IS BEGIN IF i = 0 THEN RETURN C0_cca1_4; END IF; IF i = 1 THEN RETURN C1_cca1_4; END IF; IF i = 2 THEN RETURN C2_cca1_4; END IF; RETURN CX_cca1_4; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_1 IS BEGIN IF i = 0 THEN RETURN C0_cca2_1; END IF; IF i = 1 THEN RETURN C1_cca2_1; END IF; IF i = 2 THEN RETURN C2_cca2_1; END IF; RETURN CX_cca2_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca2_2 IS BEGIN IF i = 0 THEN RETURN C0_cca2_2; END IF; IF i = 1 THEN RETURN C1_cca2_2; END IF; IF i = 2 THEN RETURN C2_cca2_2; END IF; RETURN CX_cca2_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_1 IS BEGIN IF i = 0 THEN RETURN C0_cca3_1; END IF; IF i = 1 THEN RETURN C1_cca3_1; END IF; IF i = 2 THEN RETURN C2_cca3_1; END IF; RETURN CX_cca3_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca3_2 IS BEGIN IF i = 0 THEN RETURN C0_cca3_2; END IF; IF i = 1 THEN RETURN C1_cca3_2; END IF; IF i = 2 THEN RETURN C2_cca3_2; END IF; RETURN CX_cca3_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_1 IS BEGIN IF i = 0 THEN RETURN C0_cmre_1; END IF; IF i = 1 THEN RETURN C1_cmre_1; END IF; IF i = 2 THEN RETURN C2_cmre_1; END IF; RETURN CX_cmre_1; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_2 IS BEGIN IF i = 0 THEN RETURN C0_cmre_2; END IF; IF i = 1 THEN RETURN C1_cmre_2; END IF; IF i = 2 THEN RETURN C2_cmre_2; END IF; RETURN CX_cmre_2; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cca1_7 IS BEGIN IF i = 0 THEN RETURN C0_cca1_7; END IF; IF i = 1 THEN RETURN C1_cca1_7; END IF; IF i = 2 THEN RETURN C2_cca1_7; END IF; RETURN CX_cca1_7; END; FUNCTION val_t ( i : INTEGER ) RETURN t_cmre_3 IS BEGIN IF i = 0 THEN RETURN C0_cmre_3; END IF; IF i = 1 THEN RETURN C1_cmre_3; END IF; IF i = 2 THEN RETURN C2_cmre_3; END IF; RETURN CX_cmre_3; END; -- -- FUNCTION val_i ( i : st_scl1 ) RETURN INTEGER IS BEGIN IF i = C0_scl1 THEN RETURN 0; END IF; IF i = C1_scl1 THEN RETURN 1; END IF; IF i = C2_scl1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : TIME ) RETURN INTEGER IS BEGIN IF i = C0_scl2 THEN RETURN 0; END IF; IF i = C1_scl2 THEN RETURN 1; END IF; IF i = C2_scl2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : st_scl3 ) RETURN INTEGER IS BEGIN IF i = C0_scl3 THEN RETURN 0; END IF; IF i = C1_scl3 THEN RETURN 1; END IF; IF i = C2_scl3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : st_scl4 ) RETURN INTEGER IS BEGIN IF i = C0_scl4 THEN RETURN 0; END IF; IF i = C1_scl4 THEN RETURN 1; END IF; IF i = C2_scl4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_scre_1 ) RETURN INTEGER IS BEGIN IF i = C0_scre_1 THEN RETURN 0; END IF; IF i = C1_scre_1 THEN RETURN 1; END IF; IF i = C2_scre_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_1 THEN RETURN 0; END IF; IF i = C1_csa1_1 THEN RETURN 1; END IF; IF i = C2_csa1_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_2 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_2 THEN RETURN 0; END IF; IF i = C1_csa1_2 THEN RETURN 1; END IF; IF i = C2_csa1_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_3 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_3 THEN RETURN 0; END IF; IF i = C1_csa1_3 THEN RETURN 1; END IF; IF i = C2_csa1_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa1_4 ) RETURN INTEGER IS BEGIN IF i = C0_csa1_4 THEN RETURN 0; END IF; IF i = C1_csa1_4 THEN RETURN 1; END IF; IF i = C2_csa1_4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa2_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa2_1 THEN RETURN 0; END IF; IF i = C1_csa2_1 THEN RETURN 1; END IF; IF i = C2_csa2_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa3_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa3_1 THEN RETURN 0; END IF; IF i = C1_csa3_1 THEN RETURN 1; END IF; IF i = C2_csa3_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_csa4_1 ) RETURN INTEGER IS BEGIN IF i = C0_csa4_1 THEN RETURN 0; END IF; IF i = C1_csa4_1 THEN RETURN 1; END IF; IF i = C2_csa4_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_1 THEN RETURN 0; END IF; IF i = C1_cca1_1 THEN RETURN 1; END IF; IF i = C2_cca1_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_2 THEN RETURN 0; END IF; IF i = C1_cca1_2 THEN RETURN 1; END IF; IF i = C2_cca1_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_3 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_3 THEN RETURN 0; END IF; IF i = C1_cca1_3 THEN RETURN 1; END IF; IF i = C2_cca1_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_4 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_4 THEN RETURN 0; END IF; IF i = C1_cca1_4 THEN RETURN 1; END IF; IF i = C2_cca1_4 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca2_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca2_1 THEN RETURN 0; END IF; IF i = C1_cca2_1 THEN RETURN 1; END IF; IF i = C2_cca2_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca2_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca2_2 THEN RETURN 0; END IF; IF i = C1_cca2_2 THEN RETURN 1; END IF; IF i = C2_cca2_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca3_1 ) RETURN INTEGER IS BEGIN IF i = C0_cca3_1 THEN RETURN 0; END IF; IF i = C1_cca3_1 THEN RETURN 1; END IF; IF i = C2_cca3_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca3_2 ) RETURN INTEGER IS BEGIN IF i = C0_cca3_2 THEN RETURN 0; END IF; IF i = C1_cca3_2 THEN RETURN 1; END IF; IF i = C2_cca3_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_1 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_1 THEN RETURN 0; END IF; IF i = C1_cmre_1 THEN RETURN 1; END IF; IF i = C2_cmre_1 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_2 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_2 THEN RETURN 0; END IF; IF i = C1_cmre_2 THEN RETURN 1; END IF; IF i = C2_cmre_2 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cca1_7 ) RETURN INTEGER IS BEGIN IF i = C0_cca1_7 THEN RETURN 0; END IF; IF i = C1_cca1_7 THEN RETURN 1; END IF; IF i = C2_cca1_7 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_i ( i : t_cmre_3 ) RETURN INTEGER IS BEGIN IF i = C0_cmre_3 THEN RETURN 0; END IF; IF i = C1_cmre_3 THEN RETURN 1; END IF; IF i = C2_cmre_3 THEN RETURN 2; END IF; RETURN -1; END; FUNCTION val_s ( i : st_scl1 ) RETURN STRING IS BEGIN IF i = C0_scl1 THEN RETURN "C0_scl1"; END IF; IF i = C1_scl1 THEN RETURN "C1_scl1"; END IF; IF i = C2_scl1 THEN RETURN "C2_scl1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : TIME ) RETURN STRING IS BEGIN IF i = C0_scl2 THEN RETURN "C0_scl2"; END IF; IF i = C1_scl2 THEN RETURN "C1_scl2"; END IF; IF i = C2_scl2 THEN RETURN "C2_scl2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : st_scl3 ) RETURN STRING IS BEGIN IF i = C0_scl3 THEN RETURN "C0_scl3"; END IF; IF i = C1_scl3 THEN RETURN "C1_scl3"; END IF; IF i = C2_scl3 THEN RETURN "C2_scl3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : st_scl4 ) RETURN STRING IS BEGIN IF i = C0_scl4 THEN RETURN "C0_scl4"; END IF; IF i = C1_scl4 THEN RETURN "C1_scl4"; END IF; IF i = C2_scl4 THEN RETURN "C2_scl4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_scre_1 ) RETURN STRING IS BEGIN IF i = C0_scre_1 THEN RETURN "C0_scre_1"; END IF; IF i = C1_scre_1 THEN RETURN "C1_scre_1"; END IF; IF i = C2_scre_1 THEN RETURN "C2_scre_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_1 ) RETURN STRING IS BEGIN IF i = C0_csa1_1 THEN RETURN "C0_csa1_1"; END IF; IF i = C1_csa1_1 THEN RETURN "C1_csa1_1"; END IF; IF i = C2_csa1_1 THEN RETURN "C2_csa1_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_2 ) RETURN STRING IS BEGIN IF i = C0_csa1_2 THEN RETURN "C0_csa1_2"; END IF; IF i = C1_csa1_2 THEN RETURN "C1_csa1_2"; END IF; IF i = C2_csa1_2 THEN RETURN "C2_csa1_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_3 ) RETURN STRING IS BEGIN IF i = C0_csa1_3 THEN RETURN "C0_csa1_3"; END IF; IF i = C1_csa1_3 THEN RETURN "C1_csa1_3"; END IF; IF i = C2_csa1_3 THEN RETURN "C2_csa1_3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa1_4 ) RETURN STRING IS BEGIN IF i = C0_csa1_4 THEN RETURN "C0_csa1_4"; END IF; IF i = C1_csa1_4 THEN RETURN "C1_csa1_4"; END IF; IF i = C2_csa1_4 THEN RETURN "C2_csa1_4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa2_1 ) RETURN STRING IS BEGIN IF i = C0_csa2_1 THEN RETURN "C0_csa2_1"; END IF; IF i = C1_csa2_1 THEN RETURN "C1_csa2_1"; END IF; IF i = C2_csa2_1 THEN RETURN "C2_csa2_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa3_1 ) RETURN STRING IS BEGIN IF i = C0_csa3_1 THEN RETURN "C0_csa3_1"; END IF; IF i = C1_csa3_1 THEN RETURN "C1_csa3_1"; END IF; IF i = C2_csa3_1 THEN RETURN "C2_csa3_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_csa4_1 ) RETURN STRING IS BEGIN IF i = C0_csa4_1 THEN RETURN "C0_csa4_1"; END IF; IF i = C1_csa4_1 THEN RETURN "C1_csa4_1"; END IF; IF i = C2_csa4_1 THEN RETURN "C2_csa4_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_1 ) RETURN STRING IS BEGIN IF i = C0_cca1_1 THEN RETURN "C0_cca1_1"; END IF; IF i = C1_cca1_1 THEN RETURN "C1_cca1_1"; END IF; IF i = C2_cca1_1 THEN RETURN "C2_cca1_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_2 ) RETURN STRING IS BEGIN IF i = C0_cca1_2 THEN RETURN "C0_cca1_2"; END IF; IF i = C1_cca1_2 THEN RETURN "C1_cca1_2"; END IF; IF i = C2_cca1_2 THEN RETURN "C2_cca1_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_3 ) RETURN STRING IS BEGIN IF i = C0_cca1_3 THEN RETURN "C0_cca1_3"; END IF; IF i = C1_cca1_3 THEN RETURN "C1_cca1_3"; END IF; IF i = C2_cca1_3 THEN RETURN "C2_cca1_3"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_4 ) RETURN STRING IS BEGIN IF i = C0_cca1_4 THEN RETURN "C0_cca1_4"; END IF; IF i = C1_cca1_4 THEN RETURN "C1_cca1_4"; END IF; IF i = C2_cca1_4 THEN RETURN "C2_cca1_4"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca2_1 ) RETURN STRING IS BEGIN IF i = C0_cca2_1 THEN RETURN "C0_cca2_1"; END IF; IF i = C1_cca2_1 THEN RETURN "C1_cca2_1"; END IF; IF i = C2_cca2_1 THEN RETURN "C2_cca2_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca2_2 ) RETURN STRING IS BEGIN IF i = C0_cca2_2 THEN RETURN "C0_cca2_2"; END IF; IF i = C1_cca2_2 THEN RETURN "C1_cca2_2"; END IF; IF i = C2_cca2_2 THEN RETURN "C2_cca2_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca3_1 ) RETURN STRING IS BEGIN IF i = C0_cca3_1 THEN RETURN "C0_cca3_1"; END IF; IF i = C1_cca3_1 THEN RETURN "C1_cca3_1"; END IF; IF i = C2_cca3_1 THEN RETURN "C2_cca3_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca3_2 ) RETURN STRING IS BEGIN IF i = C0_cca3_2 THEN RETURN "C0_cca3_2"; END IF; IF i = C1_cca3_2 THEN RETURN "C1_cca3_2"; END IF; IF i = C2_cca3_2 THEN RETURN "C2_cca3_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_1 ) RETURN STRING IS BEGIN IF i = C0_cmre_1 THEN RETURN "C0_cmre_1"; END IF; IF i = C1_cmre_1 THEN RETURN "C1_cmre_1"; END IF; IF i = C2_cmre_1 THEN RETURN "C2_cmre_1"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_2 ) RETURN STRING IS BEGIN IF i = C0_cmre_2 THEN RETURN "C0_cmre_2"; END IF; IF i = C1_cmre_2 THEN RETURN "C1_cmre_2"; END IF; IF i = C2_cmre_2 THEN RETURN "C2_cmre_2"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cca1_7 ) RETURN STRING IS BEGIN IF i = C0_cca1_7 THEN RETURN "C0_cca1_7"; END IF; IF i = C1_cca1_7 THEN RETURN "C1_cca1_7"; END IF; IF i = C2_cca1_7 THEN RETURN "C2_cca1_7"; END IF; RETURN "UNKNOWN"; END; FUNCTION val_s ( i : t_cmre_3 ) RETURN STRING IS BEGIN IF i = C0_cmre_3 THEN RETURN "C0_cmre_3"; END IF; IF i = C1_cmre_3 THEN RETURN "C1_cmre_3"; END IF; IF i = C2_cmre_3 THEN RETURN "C2_cmre_3"; END IF; RETURN "UNKNOWN"; END; END c03s03b00x00p03n04i00517pkg; USE work.c03s03b00x00p03n04i00517pkg.ALL; ENTITY vests7 IS END vests7; ARCHITECTURE c03s03b00x00p03n04i00517arch OF vests7 IS -- -- Access type declarations -- TYPE at_scre_1 IS ACCESS t_scre_1 ; TYPE at_cca1_1 IS ACCESS t_cca1_1 ; TYPE at_cca1_2 IS ACCESS t_cca1_2 ; TYPE at_cca1_3 IS ACCESS t_cca1_3 ; TYPE at_cca1_4 IS ACCESS t_cca1_4 ; TYPE at_cmre_1 IS ACCESS t_cmre_1 ; TYPE at_cmre_2 IS ACCESS t_cmre_2 ; TYPE at_cca1_7 IS ACCESS t_cca1_7 ; TYPE at_cmre_3 IS ACCESS t_cmre_3 ; -- -- BEGIN TESTING: PROCESS -- -- ACCESS VARIABLE declarations -- VARIABLE AV0_scre_1 : at_scre_1 ; VARIABLE AV2_scre_1 : at_scre_1 ; VARIABLE AV0_cca1_1 : at_cca1_1 ; VARIABLE AV2_cca1_1 : at_cca1_1 ; VARIABLE AV0_cca1_2 : at_cca1_2 ; VARIABLE AV2_cca1_2 : at_cca1_2 ; VARIABLE AV0_cca1_3 : at_cca1_3 ; VARIABLE AV2_cca1_3 : at_cca1_3 ; VARIABLE AV0_cca1_4 : at_cca1_4 ; VARIABLE AV2_cca1_4 : at_cca1_4 ; VARIABLE AV0_cmre_1 : at_cmre_1 ; VARIABLE AV2_cmre_1 : at_cmre_1 ; VARIABLE AV0_cmre_2 : at_cmre_2 ; VARIABLE AV2_cmre_2 : at_cmre_2 ; VARIABLE AV0_cca1_7 : at_cca1_7 ; VARIABLE AV2_cca1_7 : at_cca1_7 ; VARIABLE AV0_cmre_3 : at_cmre_3 ; VARIABLE AV2_cmre_3 : at_cmre_3 ; -- -- BEGIN -- -- Allocation of access values -- AV0_scre_1 := NEW t_scre_1 ; AV0_cca1_1 := NEW t_cca1_1 ; AV0_cca1_2 := NEW t_cca1_2 ; AV0_cca1_3 := NEW t_cca1_3 ; AV0_cca1_4 := NEW t_cca1_4 ; AV0_cmre_1 := NEW t_cmre_1 ; AV0_cmre_2 := NEW t_cmre_2 ; AV0_cca1_7 := NEW t_cca1_7 ; AV0_cmre_3 := NEW t_cmre_3 ; --- AV2_scre_1 := NEW t_scre_1 ' ( C2_scre_1 ) ; AV2_cca1_1 := NEW t_cca1_1 ' ( C2_cca1_1 ) ; AV2_cca1_2 := NEW t_cca1_2 ' ( C2_cca1_2 ) ; AV2_cca1_3 := NEW t_cca1_3 ' ( C2_cca1_3 ) ; AV2_cca1_4 := NEW t_cca1_4 ' ( C2_cca1_4 ) ; AV2_cmre_1 := NEW t_cmre_1 ' ( C2_cmre_1 ) ; AV2_cmre_2 := NEW t_cmre_2 ' ( C2_cmre_2 ) ; AV2_cca1_7 := NEW t_cca1_7 ' ( C2_cca1_7 ) ; AV2_cmre_3 := NEW t_cmre_3 ' ( C2_cmre_3 ) ; -- -- ASSERT AV0_scre_1.all = C0_scre_1 REPORT "Improper initialization of AV0_scre_1" SEVERITY FAILURE; ASSERT AV2_scre_1.all = C2_scre_1 REPORT "Improper initialization of AV2_scre_1" SEVERITY FAILURE; ASSERT AV0_cca1_1.all = C0_cca1_1 REPORT "Improper initialization of AV0_cca1_1" SEVERITY FAILURE; ASSERT AV2_cca1_1.all = C2_cca1_1 REPORT "Improper initialization of AV2_cca1_1" SEVERITY FAILURE; ASSERT AV0_cca1_2.all = C0_cca1_2 REPORT "Improper initialization of AV0_cca1_2" SEVERITY FAILURE; ASSERT AV2_cca1_2.all = C2_cca1_2 REPORT "Improper initialization of AV2_cca1_2" SEVERITY FAILURE; ASSERT AV0_cca1_3.all = C0_cca1_3 REPORT "Improper initialization of AV0_cca1_3" SEVERITY FAILURE; ASSERT AV2_cca1_3.all = C2_cca1_3 REPORT "Improper initialization of AV2_cca1_3" SEVERITY FAILURE; ASSERT AV0_cca1_4.all = C0_cca1_4 REPORT "Improper initialization of AV0_cca1_4" SEVERITY FAILURE; ASSERT AV2_cca1_4.all = C2_cca1_4 REPORT "Improper initialization of AV2_cca1_4" SEVERITY FAILURE; ASSERT AV0_cmre_1.all = C0_cmre_1 REPORT "Improper initialization of AV0_cmre_1" SEVERITY FAILURE; ASSERT AV2_cmre_1.all = C2_cmre_1 REPORT "Improper initialization of AV2_cmre_1" SEVERITY FAILURE; ASSERT AV0_cmre_2.all = C0_cmre_2 REPORT "Improper initialization of AV0_cmre_2" SEVERITY FAILURE; ASSERT AV2_cmre_2.all = C2_cmre_2 REPORT "Improper initialization of AV2_cmre_2" SEVERITY FAILURE; ASSERT AV0_cca1_7.all = C0_cca1_7 REPORT "Improper initialization of AV0_cca1_7" SEVERITY FAILURE; ASSERT AV2_cca1_7.all = C2_cca1_7 REPORT "Improper initialization of AV2_cca1_7" SEVERITY FAILURE; ASSERT AV0_cmre_3.all = C0_cmre_3 REPORT "Improper initialization of AV0_cmre_3" SEVERITY FAILURE; ASSERT AV2_cmre_3.all = C2_cmre_3 REPORT "Improper initialization of AV2_cmre_3" SEVERITY FAILURE; -- -- assert NOT( ( AV0_scre_1.all = C0_scre_1 ) and ( AV2_scre_1.all = C2_scre_1 ) and ( AV0_cca1_1.all = C0_cca1_1 ) and ( AV2_cca1_1.all = C2_cca1_1 ) and ( AV0_cca1_2.all = C0_cca1_2 ) and ( AV2_cca1_2.all = C2_cca1_2 ) and ( AV0_cca1_3.all = C0_cca1_3 ) and ( AV2_cca1_3.all = C2_cca1_3 ) and ( AV0_cca1_4.all = C0_cca1_4 ) and ( AV2_cca1_4.all = C2_cca1_4 ) and ( AV0_cmre_1.all = C0_cmre_1 ) and ( AV2_cmre_1.all = C2_cmre_1 ) and ( AV0_cmre_2.all = C0_cmre_2 ) and ( AV2_cmre_2.all = C2_cmre_2 ) and ( AV0_cca1_7.all = C0_cca1_7 ) and ( AV2_cca1_7.all = C2_cca1_7 ) and ( AV0_cmre_3.all = C0_cmre_3 ) and ( AV2_cmre_3.all = C2_cmre_3 )) report "***PASSED TEST: c03s03b00x00p03n04i00517" severity NOTE; assert ( ( AV0_scre_1.all = C0_scre_1 ) and ( AV2_scre_1.all = C2_scre_1 ) and ( AV0_cca1_1.all = C0_cca1_1 ) and ( AV2_cca1_1.all = C2_cca1_1 ) and ( AV0_cca1_2.all = C0_cca1_2 ) and ( AV2_cca1_2.all = C2_cca1_2 ) and ( AV0_cca1_3.all = C0_cca1_3 ) and ( AV2_cca1_3.all = C2_cca1_3 ) and ( AV0_cca1_4.all = C0_cca1_4 ) and ( AV2_cca1_4.all = C2_cca1_4 ) and ( AV0_cmre_1.all = C0_cmre_1 ) and ( AV2_cmre_1.all = C2_cmre_1 ) and ( AV0_cmre_2.all = C0_cmre_2 ) and ( AV2_cmre_2.all = C2_cmre_2 ) and ( AV0_cca1_7.all = C0_cca1_7 ) and ( AV2_cca1_7.all = C2_cca1_7 ) and ( AV0_cmre_3.all = C0_cmre_3 ) and ( AV2_cmre_3.all = C2_cmre_3 )) report "***FAILED TEST: c03s03b00x00p03n04i00517 - Each access value designates an object of the subtype defined by the subtype indication of the access type definition." severity ERROR; wait; END PROCESS TESTING; END c03s03b00x00p03n04i00517arch; nvc-r1.17.1/test/regress/vests8.vhd000066400000000000000000000037361504111170000171400ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc1310.vhd,v 1.2 2001-10-26 16:29:39 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests8 IS END vests8; ARCHITECTURE c08s04b00x00p07n02i01310arch OF vests8 IS type sigrec is record A1 : bit; A2 : integer; A3 : character; A4 : boolean; end record; signal S1 : bit; signal S2 : integer; signal S3 : character; signal S4 : boolean; BEGIN TESTING: PROCESS BEGIN (S1, S2, S3, S4) <= sigrec'('1', 1, '1', true); wait for 1 ns; assert NOT( (S1='1')and(S2=1)and(S3='1')and(S4=true) ) report "***PASSED TEST: c08s04b00x00p07n02i01310" severity NOTE; assert ( (S1='1')and(S2=1)and(S3='1')and(S4=true) ) report "***FAILED TEST: c08s04b00x00p07n02i01310 - A waveform element on the rigth-hand side must be the same as the base type of the aggregate." severity ERROR; wait; END PROCESS TESTING; END c08s04b00x00p07n02i01310arch; nvc-r1.17.1/test/regress/vests9.vhd000066400000000000000000000040111504111170000171240ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc2094.vhd,v 1.2 2001-10-26 16:29:45 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY vests9 IS END vests9; ARCHITECTURE c07s02b04x00p20n01i02094arch OF vests9 IS TYPE boolean_v is array (integer range <>) of boolean; SUBTYPE boolean_4 is boolean_v (1 to 4); SUBTYPE boolean_8 is boolean_v (1 to 8); FUNCTION return_array RETURN boolean_4 is constant l_operand : boolean_4 := (true,false,true,false); begin RETURN l_operand; end return_array; BEGIN l : block generic ( info : boolean_8 ); generic map ( return_array & return_array ); begin assert NOT(info = (true,false,true,false,true,false,true,false)) report "***PASSED TEST: c07s02b04x00p20n01i02094" severity NOTE; assert (info = (true,false,true,false,true,false,true,false)) report "***FAILED TEST: c07s02b04x00p20n01i02094 - Function array concatenation did not succeed." severity ERROR; end block; END c07s02b04x00p20n01i02094arch; nvc-r1.17.1/test/regress/vhpi1.vhd000066400000000000000000000011621504111170000167220ustar00rootroot00000000000000entity vhpi1 is port ( x : in natural; y : out natural ); end entity; architecture test of vhpi1 is subtype zero_to_one is real range 0.0 to 1.0; signal v : bit_vector(3 downto 0) := "0011"; signal b : bit; signal r : zero_to_one; signal i : integer := 42; signal A_name_with_MIXED_case : bit; begin p1: process (x) is begin report "x=" & integer'image(x); y <= x + 1 after 1 ns; end process; p2: process is begin wait for 1 ms; report "VHPI plugin did not end simulation" severity failure; end process; end architecture; nvc-r1.17.1/test/regress/vhpi10.vhd000066400000000000000000000026001504111170000170000ustar00rootroot00000000000000package counter is generic (MAX: bit_vector); subtype counter_t is bit_vector(MAX'range); end; entity sub is generic ( g0 : integer; g1 : string ); port ( p0 : bit_vector ); end entity; architecture test of sub is signal dyn : bit_vector(1 to g1'length); begin sub_b0: block is signal s : bit; begin s <= '1'; end block; ForGen1: for i in 1 to 3 generate signal s : integer; begin s <= i; end generate; end architecture; ------------------------------------------------------------------------------- entity vhpi10 is generic ( g0 : integer := 42; g1 : string := "hello" ); end entity; architecture test of vhpi10 is constant c0 : integer := 5; constant c1 : real := 1.5; component sub is generic ( g0 : integer; g1 : string ); port ( p0 : bit_vector ); end component; package pkg is new work.counter generic map (MAX => 10D"999"); signal s0: pkg.counter_t; function func return string is begin return "world"; end function; begin b0: block is signal s0 : bit; begin end block; b1: block (true) is type t_abc is (a, b, c); signal s0 : t_abc; begin end block; i0: component sub generic map ( g0 => 100, g1 => func ) port map ( p0 => "101" ); end architecture; nvc-r1.17.1/test/regress/vhpi11.vhd000066400000000000000000000011601504111170000170010ustar00rootroot00000000000000package pack is type t_rec is record x : natural; y : string; end record; type t_byte_array is array (natural range <>) of bit_vector(7 downto 0); type t_int_array is array (1 downto 0) of integer range 3 downto 0; end package; ------------------------------------------------------------------------------- use work.pack.all; entity vhpi11 is generic ( g0 : t_rec := (55, "hello") ); end entity; architecture test of vhpi11 is signal s : t_rec(y(1 to 3)); -- See issue #866 signal t : t_byte_array(1 to 3); signal u : t_int_array; begin end architecture; nvc-r1.17.1/test/regress/vhpi12.vhd000066400000000000000000000004741504111170000170110ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity vhpi12 is port ( d, clk : in std_ulogic; q : out std_ulogic ); end entity; architecture test of vhpi12 is begin process (clk) is begin if rising_edge(clk) then q <= d; end if; end process; end architecture; nvc-r1.17.1/test/regress/vhpi13.vhd000066400000000000000000000002461504111170000170070ustar00rootroot00000000000000entity vhpi13 is end entity; architecture test of vhpi13 is signal seq : natural; begin seq <= 1 after 1 ns, 2 after 2 ns, 3 after 3 ns; end architecture; nvc-r1.17.1/test/regress/vhpi14.vhd000066400000000000000000000036241504111170000170130ustar00rootroot00000000000000entity vhpi14 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of vhpi14 is function add2 (x : integer) return integer is begin end function; attribute foreign of add2 : function is "VHPI lib add2"; function popcount (x : bit_vector) return natural is begin end function; attribute foreign of popcount : function is "VHPI lib popcount"; type t_int_vec is array (natural range <>) of integer; procedure test1 (x : inout t_int_vec(1 to 4); y : in integer) is begin end procedure; attribute foreign of test1 : procedure is "VHPI lib test1"; procedure test2 (x : inout t_int_vec; y : in integer) is begin end procedure; attribute foreign of test2 : procedure is "VHPI lib test2"; function iota (n : natural) return t_int_vec is begin end function; attribute foreign of iota : function is "VHPI lib iota"; procedure no_args is -- Issue #984 begin end procedure; attribute foreign of no_args : procedure is "VHPI lib no_args"; procedure set_logic (x : out std_ulogic; dummy : in std_logic) is begin end procedure; attribute foreign of set_logic : procedure is "VHPI lib set_logic"; begin p: process is variable v1 : t_int_vec(1 to 4) := (1, 2, 3, 4); variable v2 : std_ulogic; begin assert add2(1) = 3; assert add2(-1) = 1; assert add2(-10) = -8; assert popcount("101") = 2; assert popcount("10111") = 4; test1(v1, 5); assert v1 = (6, 7, 8, 9); test2(v1, 1); assert v1 = (7, 8, 9, 10); v1 := (-4, -3, -2, -1); test2(v1, 2); assert v1 = (-2, -1, 0, 1); assert iota(2) = (0, 1); assert iota(4) = (0, 1, 2, 3); no_args; set_logic(v2, 'X'); assert v2 = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/vhpi15.vhd000066400000000000000000000005461504111170000170140ustar00rootroot00000000000000package pack1 is constant c1 : integer := 42; constant c2 : string := "hello"; end package; ------------------------------------------------------------------------------- entity vhpi15 is end entity; use work.pack1.all; architecture test of vhpi15 is signal s1 : integer := c1; signal s2 : string(1 to 5) := c2; begin end architecture; nvc-r1.17.1/test/regress/vhpi16.vhd000066400000000000000000000002421504111170000170060ustar00rootroot00000000000000entity vhpi16 is end entity; architecture test of vhpi16 is signal x : integer; begin x <= 1 after 1 ns, 2 after 2 ns, 3 after 3 ns; end architecture; nvc-r1.17.1/test/regress/vhpi2.vhd000066400000000000000000000006441504111170000167270ustar00rootroot00000000000000entity vhpi2 is port ( x : in natural; y : out natural ); end entity; architecture test of vhpi2 is begin process (x) is begin report "x=" & integer'image(x); y <= x + 1 after 1 ns; end process; process is begin wait for 1 ms; assert x = 1 report "VHPI plugin did not force X" severity failure; wait; end process; end architecture; nvc-r1.17.1/test/regress/vhpi3.vhd000066400000000000000000000003411504111170000167220ustar00rootroot00000000000000entity vhpi3 is end entity; architecture test of vhpi3 is type weight is range -100 to 4000 units g; kg = 1000 g; end units; signal x : weight := 2 g; begin end architecture; nvc-r1.17.1/test/regress/vhpi4.vhd000066400000000000000000000031271504111170000167300ustar00rootroot00000000000000entity vhpi4 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of vhpi4 is function sum (x, y : integer) return integer is begin end function; attribute foreign of sum : function is "VHPIDIRECT __vhpi_sum"; type int_vec is array (natural range <>) of integer; function sum_array (a : int_vec; len : integer) return integer is begin end function; attribute foreign of sum_array : function is "VHPIDIRECT __vhpi_sum_array"; function my_not (x : std_logic) return std_logic is begin report "do not call this" severity failure; end function; attribute foreign of my_not : function is "VHPIDIRECT __vhpi_my_not"; procedure test_proc (x : out integer; arr : out int_vec); attribute foreign of test_proc : procedure is "VHPIDIRECT __vhpi_test_proc"; procedure test_proc (x : out integer; arr : out int_vec) is begin report "do not call this" severity failure; end procedure; procedure no_args is -- Issue #984 begin end procedure; attribute foreign of no_args : procedure is "VHPIDIRECT __vhpi_no_args"; begin main: process is variable i : integer; variable v : int_vec(1 to 3); begin assert sum(2, 3) = 5; assert sum_array(int_vec'(1, 2, 3, 4, 5), 5) = 15; assert my_not('1') = '0'; assert my_not('0') = '1'; assert my_not('U') = 'U'; test_proc(i, v); assert i = 42; assert v = (integer'left, 5, integer'left); no_args; wait; end process; end architecture; nvc-r1.17.1/test/regress/vhpi5.vhd000066400000000000000000000030431504111170000167260ustar00rootroot00000000000000entity vhpi5 is end entity; architecture test of vhpi5 is -- Simple record type rec is record a, b: integer; c: integer_vector(0 to 1); end record; function init_rec(base: integer) return rec is variable m: rec; begin m.a := (base + 0) * 16; m.b := (base + 1) * 16; for i in m.c'range loop m.c(i) := (base + 2) * 16 + i; end loop; return m; end; signal m: rec := init_rec(0); -- Array of records type rec_matrix is array(0 to 6, 0 to 4) of rec; function init_rec_matrix return rec_matrix is variable n: rec_matrix; begin for i in n'range(1) loop for j in n'range(2) loop n(i, j) := init_rec(i * 256 + j * 16); end loop; end loop; return n; end; signal n: rec_matrix := init_rec_matrix; -- Record with array of records type rec_vector is array(natural range <>) of rec; type rec2 is record a, b: integer; c, d: integer_vector(0 to 4); e, f, g: rec_vector(0 to 4); end record; function init_rec2 return rec2 is variable o: rec2; begin o.a := 0 * 4096; o.b := 1 * 4096; for i in o.c'range loop o.c(i) := 2 * 4096 + i * 256; o.d(i) := 3 * 4096 + i * 256; end loop; for i in o.e'range loop o.e(i) := init_rec(4 * 256 + i * 16); o.f(i) := init_rec(5 * 256 + i * 16); o.g(i) := init_rec(6 * 256 + i * 16); end loop; return o; end; signal o: rec2 := init_rec2; begin end architecture; nvc-r1.17.1/test/regress/vhpi6.vhd000066400000000000000000000006301504111170000167260ustar00rootroot00000000000000entity vhpi6 is port ( x : in natural; y : out natural ); end entity; architecture test of vhpi6 is begin p1: process (x) is begin report "x=" & integer'image(x); y <= x + 1 after 1 ns; end process; p2: process is begin wait for 1 ms; report "VHPI plugin did not end simulation" severity failure; end process; end architecture; nvc-r1.17.1/test/regress/vhpi7.vhd000066400000000000000000000024141504111170000167310ustar00rootroot00000000000000entity vhpi7 is end entity; architecture test of vhpi7 is type s is array(0 to 1) of integer; type r is array(0 to 2) of s; function init_r return r is variable m: r; begin for i in m'range loop for j in m(i)'range loop m(i)(j) := i * 16 + j; end loop; end loop; return m; end; signal m: r := init_r; type r2 is array(0 to 2, 0 to 1) of integer; type h2 is array(0 to 6, 0 to 4) of r2; function init_h2 return h2 is variable n: h2; begin for i in n'range(1) loop for j in n'range(2) loop for k in n(i, j)'range(1) loop for l in n(i, j)'range(2) loop n(i, j)(k, l) := i * 4096 + j * 256 + k * 16 + l; end loop; end loop; end loop; end loop; return n; end; signal n: h2 := init_h2; type su is array(natural range <>) of integer; type ru is array(natural range <>) of su; function init_ru return ru is variable o: ru(0 to 2)(0 to 1); begin for i in o'range loop for j in o(i)'range loop o(i)(j) := i * 16 + j; end loop; end loop; return o; end; signal o: ru(0 to 2)(0 to 1) := init_ru; begin end architecture; nvc-r1.17.1/test/regress/vhpi8.vhd000066400000000000000000000050221504111170000167300ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; entity vhpi8 is end entity; architecture test of vhpi8 is type enum is ( e000, e001, e002, e003, e004, e005, e006, e007, e008, e009, e010, e011, e012, e013, e014, e015, e016, e017, e018, e019, e020, e021, e022, e023, e024, e025, e026, e027, e028, e029, e030, e031, e032, e033, e034, e035, e036, e037, e038, e039, e040, e041, e042, e043, e044, e045, e046, e047, e048, e049, e050, e051, e052, e053, e054, e055, e056, e057, e058, e059, e060, e061, e062, e063, e064, e065, e066, e067, e068, e069, e070, e071, e072, e073, e074, e075, e076, e077, e078, e079, e080, e081, e082, e083, e084, e085, e086, e087, e088, e089, e090, e091, e092, e093, e094, e095, e096, e097, e098, e099, e100, e101, e102, e103, e104, e105, e106, e107, e108, e109, e110, e111, e112, e113, e114, e115, e116, e117, e118, e119, e120, e121, e122, e123, e124, e125, e126, e127, e128, e129, e130, e131, e132, e133, e134, e135, e136, e137, e138, e139, e140, e141, e142, e143, e144, e145, e146, e147, e148, e149, e150, e151, e152, e153, e154, e155, e156, e157, e158, e159, e160, e161, e162, e163, e164, e165, e166, e167, e168, e169, e170, e171, e172, e173, e174, e175, e176, e177, e178, e179, e180, e181, e182, e183, e184, e185, e186, e187, e188, e189, e190, e191, e192, e193, e194, e195, e196, e197, e198, e199, e200, e201, e202, e203, e204, e205, e206, e207, e208, e209, e210, e211, e212, e213, e214, e215, e216, e217, e218, e219, e220, e221, e222, e223, e224, e225, e226, e227, e228, e229, e230, e231, e232, e233, e234, e235, e236, e237, e238, e239, e240, e241, e242, e243, e244, e245, e246, e247, e248, e249, e250, e251, e252, e253, e254, e255, e256, e257, e258, e259, e260, e261, e262, e263, e264, e265, e266, e267, e268, e269, e270, e271, e272, e273, e274, e275, e276, e277, e278, e279, e280, e281, e282, e283, e284, e285, e286, e287, e288, e289, e290, e291, e292, e293, e294, e295, e296, e297, e298, e299 ); type enum_vector is array(natural range <>) of enum; type severity_vector is array(natural range <>) of severity_level; signal lv: std_logic_vector(0 to 3) := "UX01"; signal sv: severity_vector(0 to 3) := (note, warning, error, failure); signal ev: enum_vector(0 to 3) := (e000, e001, e002, e003); signal bv: bit_vector(3 to 0); signal cv: string(1 to 4) := "NVC!"; signal rv: real_vector(0 to 3) := (0.0, 0.5, 1.0, -1.0); begin end architecture; nvc-r1.17.1/test/regress/vhpi9.vhd000066400000000000000000000013751504111170000167400ustar00rootroot00000000000000package pack1 is constant k : natural; end package; package body pack1 is constant k : natural := 4; end package body; ------------------------------------------------------------------------------- use work.pack1.all; package pack2 is type t is array (1 to k + 1) of bit_vector(k - 1 downto 0); type r is record f : bit_vector(1 to k); g : bit_vector(k downto 1); end record; end package; ------------------------------------------------------------------------------- entity vhpi9 is end entity; use work.pack1.all; use work.pack2.all; library ieee; use ieee.std_logic_1164.all; architecture test of vhpi9 is signal s : t; signal s2 : std_logic_vector(k downto 0); signal s3 : r; begin end architecture; nvc-r1.17.1/test/regress/view1.vhd000066400000000000000000000020751504111170000167320ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; end record; view in_view of rec_t is x : in; y : out; end view; view out_view of rec_t is x : out; y : in; end view; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub is begin o.x <= i.x + 1; i.y <= o.y + 5; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view1 is end entity; architecture test of view1 is signal i, o : rec_t; begin u: entity work.sub port map (i, o); check: process is begin assert i = (0, 0); assert o = (0, 0); wait for 0 ns; assert i = (0, 5); assert o = (1, 0); i.x <= 7; o.y <= 12; wait for 1 ns; assert i = (7, 17); assert o = (8, 12); wait; end process; end architecture; nvc-r1.17.1/test/regress/view2.vhd000066400000000000000000000020301504111170000167220ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; end record; view in_view of rec_t is x : in; y : out; end view; alias out_view is in_view'converse; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub is begin o.x <= i.x + 1; i.y <= o.y + 5; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view2 is end entity; architecture test of view2 is signal i, o : rec_t; begin u: entity work.sub port map (i, o); check: process is begin assert i = (0, 0); assert o = (0, 0); wait for 0 ns; assert i = (0, 5); assert o = (1, 0); i.x <= 7; o.y <= 12; wait for 1 ns; assert i = (7, 17); assert o = (8, 12); wait; end process; end architecture; nvc-r1.17.1/test/regress/view3.vhd000066400000000000000000000026641504111170000167400ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; b : bit_vector; end record; view in_view of rec_t is x : in; y : out; b : in; end view; alias out_view is in_view'converse; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub is begin o.x <= i.x + 1; i.y <= o.y + 5; o.b <= not i.b; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity sub2 is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub2 is begin u: entity work.sub port map ( i, o ); end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view3 is end entity; architecture test of view3 is signal i, o : rec_t(b(1 to 3)); begin u: entity work.sub port map (i, o); check: process is begin assert i = (0, 0, "000"); assert o = (0, 0, "000"); wait for 0 ns; assert i = (0, 5, "000"); assert o = (1, 0, "111"); i.x <= 7; o.y <= 12; i.b <= "101"; wait for 1 ns; assert i = (7, 17, "101"); assert o = (8, 12, "010"); wait; end process; end architecture; nvc-r1.17.1/test/regress/view4.vhd000066400000000000000000000035701504111170000167360ustar00rootroot00000000000000package pack is function resolved (x : bit_vector) return bit; subtype rbit_vector is (resolved) bit_vector; type vec_t is record p : bit_vector(1 to 3); q : rbit_vector(1 to 3); end record; view vec_in_view of vec_t is p : in; q : inout; end view; type rec_t is record x, y : natural; z : vec_t; end record; view in_view of rec_t is x : in; y : out; z : view vec_in_view; end view; alias out_view is in_view'converse; end package; package body pack is function resolved (x : bit_vector) return bit is variable r : bit := '0'; begin for i in x'range loop r := r or x(i); end loop; return r; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view in_view; o : view out_view ); end entity; architecture test of sub is function "not" (v : vec_t) return vec_t is begin return (not v.p, not v.q); end function; begin o.x <= i.x + 1; i.y <= o.y + 5; o.z <= not i.z; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view4 is end entity; architecture test of view4 is signal i, o : rec_t; begin u: entity work.sub port map (i, o); check: process is begin assert i = (0, 0, ("000", "000")); assert o = (0, 0, ("000", "000")); wait for 0 ns; assert i = (0, 5, ("000", "000")); assert o = (1, 0, ("111", "111")); i.x <= 7; o.y <= 12; i.z.p <= "101"; i.z.q <= "001"; wait for 1 ns; assert i = (7, 17, ("101", "001")); assert o = (8, 12, ("010", "110")); wait; end process; end architecture; nvc-r1.17.1/test/regress/view5.vhd000066400000000000000000000023031504111170000167300ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; end record; type rec_array_t is array (natural range <>) of rec_t; view in_view of rec_t is x : in; y : out; end view; alias out_view is in_view'converse; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( i : view (in_view) of rec_array_t(0 to 0); o : view (out_view) of rec_array_t(0 to 0) ); end entity; architecture test of sub is begin o(0).x <= i(0).x + 1; i(0).y <= o(0).y + 5; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity view5 is end entity; architecture test of view5 is signal i, o : rec_array_t(0 to 0); begin u: entity work.sub port map (i, o); check: process is begin assert i(0) = (0, 0); assert o(0) = (0, 0); wait for 0 ns; assert i(0) = (0, 5); assert o(0) = (1, 0); i(0).x <= 7; o(0).y <= 12; wait for 1 ns; assert i(0) = (7, 17); assert o(0) = (8, 12); wait; end process; end architecture; nvc-r1.17.1/test/regress/view6.vhd000066400000000000000000000023231504111170000167330ustar00rootroot00000000000000package pack is type rec_t is record x, y : natural; end record; view in_view of rec_t is x : in; y : out; end view; view out_view of rec_t is x : out; y : in; end view; end package; ------------------------------------------------------------------------------- use work.pack.all; entity view6 is end entity; architecture test of view6 is procedure update1 ( signal i : view in_view; signal o : view out_view ) is begin o.x <= i.x + 1; i.y <= o.y + 5; end procedure; procedure update2 ( signal i : view in_view'converse; signal o : view out_view'converse ) is begin i.x <= 7; o.y <= 12; end procedure; signal i, o : rec_t; begin u1: update1(i, o); u2: process is begin wait for 0 ns; update2(i, o); wait; end process; check: process is begin assert i = (0, 0); assert o = (0, 0); wait for 0 ns; assert i = (0, 5); assert o = (1, 0); wait for 1 ns; assert i = (7, 17); assert o = (8, 12); wait; end process; end architecture; nvc-r1.17.1/test/regress/vital1.vhd000066400000000000000000000023231504111170000170730ustar00rootroot00000000000000library ieee; use ieee.vital_timing.all; use ieee.vital_primitives.all; use ieee.std_logic_1164.all; entity vital1 is end entity; architecture test of vital1 is constant DFFTable: VitalStateTableType := -- RESET D CLK State Q (( '0', '-', '-', '-', '0'), ( '1', '1', '/', '-', '1'), ( '1', '0', '/', '-', '0'), ( '1', 'X', '/', '-', 'X'), ( '1', '-', '-', '-', 'S')); signal d, q : std_logic; signal clk : std_logic := '0'; signal reset : std_logic := '0'; signal running : boolean := true; begin p1: process (reset, d, clk) is variable prev : std_logic_vector(1 to 3); variable result : std_logic; begin vitalstatetable(result, prev, dfftable, (reset, d, clk)); q <= result; end process; clkp: clk <= not clk after 5 ns when running; p2: process is begin wait until falling_edge(clk); assert q = '0'; d <= '1'; reset <= '1'; wait until falling_edge(clk); assert q = '1'; d <= '0'; wait until falling_edge(clk); assert q = '0'; running <= false; wait; end process; end architecture; nvc-r1.17.1/test/regress/vlog1.v000066400000000000000000000001601504111170000164040ustar00rootroot00000000000000module dff (input d, clk, rstb, output reg q); always @(posedge clk) q <= d; endmodule // dff nvc-r1.17.1/test/regress/vlog1.vhd000066400000000000000000000013171504111170000167250ustar00rootroot00000000000000entity vlog1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of vlog1 is component dff is port ( d, clk, rstb : in std_logic; q : out std_logic ); end component; signal d, clk, rstb, q : std_logic; begin uut: component dff port map ( d, clk, rstb, q ); main: process is begin rstb <= '0'; clk <= '0'; d <= '0'; wait for 1 ns; rstb <= '1'; wait for 1 ns; d <= '1'; wait for 1 ns; clk <= '1'; wait for 1 ns; clk <= '0'; d <= '0'; wait for 1 ns; assert q = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/vlog10.v000066400000000000000000000012201504111170000164620ustar00rootroot00000000000000module vlog10; reg i1, i4, i5; and (o, i1, i2); or (i2, i3, i4); not (i3, i5); initial begin i5 = 1; i4 = 0; i1 = 1; #1 $display("%d", o); if (o !== 0) $display("FAILED"); i5 = 0; i4 = 1; i1 = 0; #1 $display("%d", o); if (o !== 0) $display("FAILED"); i5 = 1; i4 = 1; i1 = 1; #1 $display("%d", o); if (o !== 1) $display("FAILED"); i5 = 1; i4 = 1; i1 = 0; #1 $display("%d", o); if (o !== 0) $display("FAILED"); i5 = 0; i4 = 1; i1 = 1; #1 $display("%d", o); if (o !== 1) $display("FAILED"); $display("PASSED"); end endmodule // vlog10 nvc-r1.17.1/test/regress/vlog11.v000066400000000000000000000012471504111170000164740ustar00rootroot00000000000000module vlog11; reg i1, i2; nand (o1, i1, i2); xor (o2, i1, i2); initial begin i1 = 1; i2 = 0; #1 $display("%d %d", o1, o2); if (o1 !== 1 || o2 !== 1) $display("FAILED"); i1 = 0; i2 = 1; #1 $display("%d %d", o1, o2); if (o1 !== 1 || o2 !== 1) $display("FAILED"); i1 = 1; i2 = 1; #1 $display("%d %d", o1, o2); if (o1 !== 0 || o2 !== 0) $display("FAILED"); i1 = 0; i2 = 0; #1 $display("%d %d", o1, o2); if (o1 !== 1 || o2 !== 0) $display("FAILED"); //i1 = 1; //i2 = 1'bx; //#1 $display("%d", o1); //if (o1 !== 1'bx) $display("FAILED"); $display("PASSED"); end endmodule // vlog10 nvc-r1.17.1/test/regress/vlog12.v000066400000000000000000000012011504111170000164630ustar00rootroot00000000000000module vlog12; reg x, y, z; reg [7:0] cnt; always @(x or y or posedge z) cnt <= cnt + 1; initial begin cnt = 0; x <= 0; y <= 0; z <= 0; #1; if (cnt !== 1) begin $display("FAILED: %d !== 1", cnt); $finish; end z <= 1; #1; if (cnt !== 2) begin $display("FAILED: %d !== 2", cnt); $finish; end z <= 0; #1; if (cnt !== 2) begin $display("FAILED: %d !== 2", cnt); $finish; end y <= 1; #1; if (cnt !== 3) begin $display("FAILED: %d !== 3", cnt); $finish; end $display("PASSED"); end endmodule // vlog12 nvc-r1.17.1/test/regress/vlog13.v000066400000000000000000000004061504111170000164720ustar00rootroot00000000000000module vlog13; wire x = 1, y = 1; assign y = 0; initial begin #1; if (x !== 1) $display("FAILED -- x=%d", x); else if (y === 0 || y === 1) $display("FAILED -- y=%d", y); else $display("PASSED"); end endmodule // vlog13 nvc-r1.17.1/test/regress/vlog14.v000066400000000000000000000007571504111170000165040ustar00rootroot00000000000000module vlog14; reg [7:0] x, y, z, q; always @(*) x <= y + z; always @* q <= 1; // Should never execute initial begin y <= 5; z <= 2; #1; if (x !== 7) begin $display("FAILED: %d !== 7", x); $finish; end z <= 10; #1; if (x !== 15) begin $display("FAILED: %d !== 15", x); $finish; end #1; if (q == 1) begin $display("FAILED: %d == 1", q); $finish; end $display("PASSED"); end endmodule // vlog14 nvc-r1.17.1/test/regress/vlog15.v000066400000000000000000000005521504111170000164760ustar00rootroot00000000000000module vlog15; reg [7:0] x; reg [3:0] y; initial begin y = 4'h2; x = { 4'h1, y }; if (x !== 8'h12) begin $display("FAILED (1) -- %x !== 12", x); $finish; end x = { y, x[7:4] }; if (x !== 8'h21) begin $display("FAILED (2) -- %x !== 21", x); $finish; end $display("PASSED"); end endmodule // vlog15 nvc-r1.17.1/test/regress/vlog16.v000066400000000000000000000005441504111170000165000ustar00rootroot00000000000000module vlog16; reg [7:0] x, cnt; always @(x[4]) begin $display("x ==> %x (%d)", x, ++cnt); end initial begin cnt = 0; #1 x = 2; #1 x = 3; #1 x = 8; #1 x = 16; #1 x = 17; #1 x = 100; #1; if (cnt === 3) $display("PASSED"); else $display("FAILED -- %d != 3", cnt); end endmodule // vlog16 nvc-r1.17.1/test/regress/vlog17.v000066400000000000000000000007171504111170000165030ustar00rootroot00000000000000module sub(o); output o; parameter p = 0; generate if (p == 42) begin assign o = 1; end else begin assign o = 0; end endgenerate endmodule // sub module vlog17; wire o1, o2, o3; sub #(42) u1(o1); sub #(56) u2(o2); sub #('hx) u3(o3); initial begin #1 $display("%x %x %x", o1, o2, o3); if (o1 === 1 && o2 === 0 && o3 === 0) $display("PASSED"); else $display("FAILED"); end endmodule // vlog17 nvc-r1.17.1/test/regress/vlog18.v000066400000000000000000000004101504111170000164720ustar00rootroot00000000000000module vlog18; reg x = 1, y; reg [7:0] z = 42; initial begin // This is not a race in System Verilog if (x !== 1 || y !== 1'bx || z !== 42) $display("FAILED -- %x %x %x", x, y, z); else $display("PASSED"); end endmodule // vlog18 nvc-r1.17.1/test/regress/vlog19.v000066400000000000000000000005661504111170000165070ustar00rootroot00000000000000module vlog19; reg [7:0] x, y; wire [7:0] out; assign out = x > y ? x : y; initial begin x = 2; y = 3; #1 if (out !== 3) begin $display("FAILED (1) -- %d", out); $finish; end x[7] = 1; #1 if (out !== 130) begin $display("FAILED (1) -- %d", out); $finish; end $display("PASSED"); end endmodule // vlog19 nvc-r1.17.1/test/regress/vlog2.v000066400000000000000000000003701504111170000164100ustar00rootroot00000000000000// This file has DOS line endings module vlog2; `define MSG "hello, world!" initial begin $display(`MSG); $write("string=%s\n", "foo"); $display("%s %d %x %d", "foo", 42, 5, 0); $finish; end endmodule // vlog2 nvc-r1.17.1/test/regress/vlog20.v000066400000000000000000000006611504111170000164730ustar00rootroot00000000000000module adder(a, b, o); parameter WIDTH = 16; input [WIDTH-1:0] a, b; output [WIDTH-1:0] o; wire [WIDTH-1:0] o; assign o = a + b; always @(*) $display("%x + %x ==> %x", a, b, o); endmodule // adder module vlog20; wire [7:0] o; reg [7:0] a, b; adder #(8) u(a, b, o); integer i; initial begin for (i = 0; i < 10; i++) begin a = i; b = i * 5; #1; end end endmodule // vlog20 nvc-r1.17.1/test/regress/vlog3.v000066400000000000000000000006741504111170000164200ustar00rootroot00000000000000module vlog3; reg x; initial begin x <= 1; $display("x ==> %d", x); if (x) $display("x is true"); else $display("x is false"); #1; $display("x ==> %d", x); if (x) $display("x is true"); else $display("x is false"); #1 x <= 0; $display("x ==> %d", x); #1 x <= 4; $display("x ==> %d", x); #1; $display("x ==> %d", x); $finish; end endmodule // vlog3 nvc-r1.17.1/test/regress/vlog4.v000066400000000000000000000002721504111170000164130ustar00rootroot00000000000000module vlog4; reg [7:0] x; initial begin x <= 42; $display("x ==> %d", x); #1 $display("x ==> %d", x); x = 12; $display("x ==> %d", x); end endmodule // vlog4 nvc-r1.17.1/test/regress/vlog5.v000066400000000000000000000002511504111170000164110ustar00rootroot00000000000000module vlog5; wire x, y; assign x = 1; assign y = 0; initial begin #1; $display("%d %d %d %d", x & y, x & 1, y & 1, y & 0); end endmodule // vlog4 nvc-r1.17.1/test/regress/vlog6.v000066400000000000000000000003741504111170000164200ustar00rootroot00000000000000module vlog6; reg x; reg [7:0] y; initial begin x <= 0; y <= 0; #1; $display("%x %x %x %x", !x, ~x, !y, ~y); x <= 1; y <= 128; #1; $display("%x %x %x %x", !x, ~x, !y, ~y); $finish; end endmodule // vlog6 nvc-r1.17.1/test/regress/vlog7.v000066400000000000000000000004101504111170000164100ustar00rootroot00000000000000module vlog7; wire w1, w2, w3; pullup (w1); pullup (supply1) (w2); pulldown (w3); assign w1 = 0; assign w2 = 0; initial begin $display("%x %x %x", w1, w2, w3); #0; $display("%x %x %x", w1, w2, w3); $finish; end endmodule // vlog7 nvc-r1.17.1/test/regress/vlog8.v000066400000000000000000000012071504111170000164160ustar00rootroot00000000000000module vlog8(); reg [3:0] a, b; initial begin a = 1; b = 2; #1; a = a + b; b = a + b; if (a !== 3) begin $display("FAILED -- a: %x !== 3", a); $finish; end if (b !== 5) begin $display("FAILED -- b: %x !== 5", b); $finish; end #2; $display("PASSED"); end // initial begin initial begin #2; if (a !== 3) begin $display("FAILED -- a (signal): %x !== 3", a); $finish; end if (b !== 5) begin $display("FAILED -- b (signal): %x !== 5", b); $finish; end end endmodule // testbench nvc-r1.17.1/test/regress/vlog9.v000066400000000000000000000005021504111170000164140ustar00rootroot00000000000000module vlog9; reg clk; reg [7:0] cnt; initial begin cnt = 0; clk = 1'b0; forever #1 clk = ~clk; end always @(posedge clk) cnt = cnt + 1; initial begin #20; if (cnt === 10) $display("PASSED"); else $display("FAILED -- %d", cnt); $finish; end endmodule // vlog9 nvc-r1.17.1/test/regress/wait1.vhd000066400000000000000000000005271504111170000167240ustar00rootroot00000000000000-- A very basic sanity test of wait statements entity wait1 is end entity; architecture test of wait1 is begin process is begin assert now = 0 ns; wait_1: wait for 1 ns; assert now = 1 ns; wait for 1 fs; assert now = 1000001 fs; end_wait: wait; end process; end architecture; nvc-r1.17.1/test/regress/wait10.vhd000066400000000000000000000013061504111170000170000ustar00rootroot00000000000000entity wait10 is end entity; architecture test of wait10 is signal s : bit_vector(3 downto 0); signal n : integer := 0; begin a: process is variable cnt : integer := 0; begin wait on s(2 downto 1); cnt := cnt + 1; n <= cnt; end process; b: process is begin s <= "0000"; wait for 1 ns; s <= "1001"; wait for 1 ns; s <= "0101"; wait for 1 ns; s <= "0010"; wait for 1 ns; s(1) <= '0'; s(2) <= '1'; wait for 1 ns; s(2) <= '0'; wait for 1 ns; report integer'image(n); assert n = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait11.vhd000066400000000000000000000005621504111170000170040ustar00rootroot00000000000000entity wait11 is end entity; architecture test of wait11 is begin process is begin wait for 0.1 ns; assert now = 100 ps; wait for 0.5 ns; assert now = 600 ps; wait for 1 ns / 10.0; assert now = 700 ps; wait for 10 ps * 10.0; assert now = 800 ps; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait12.vhd000066400000000000000000000012231504111170000170000ustar00rootroot00000000000000entity wait12 is end entity; architecture test of wait12 is signal x, y : integer; begin a: process is begin wait for 1 ns; x <= 1; wait for 0 ns; x <= 2; wait for 0 ns; x <= 3; wait for 1 ns; x <= 4; wait on y; report "wake up other process"; assert y = 2; wait; end process; b: postponed process is begin wait on x; report "wake up postponed process 1"; assert x = 3; wait on x; report "wake up postponed process 2"; y <= 2 after 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait13.vhd000066400000000000000000000015061504111170000170050ustar00rootroot00000000000000entity wait13 is end entity; architecture test of wait13 is procedure wait_for ( signal s : in bit; value : in bit; timeout : in delay_length ) is begin if s /= value then my_wait: wait on s until s = value for timeout; assert s = value report "timeout waiting for " & s'path_name; end if; end procedure; signal x : bit; begin wait_for_p: process is begin wait_for(x, '1', 5 ns); wait_for(x, '0', 10 us); wait until x = '0' for 10 ns; assert now = 12 ns; wait; end process; stim_p: process is begin wait for 1 ns; x <= '1'; wait for 1 ns; x <= '0'; wait for 4 ns; x <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait14.vhd000066400000000000000000000006761504111170000170150ustar00rootroot00000000000000entity wait14 is end entity; architecture test of wait14 is signal v : bit_vector(1 to 3); signal n : integer range v'range := 3; begin stim: process is begin wait for 1 ns; v(2) <= '1'; -- Should not wake up p1 wait for 1 ns; v(3) <= '1'; n <= 1; wait; end process; p1: assert v(1) = '0' and now = 0 ns; p2: assert v(n) = '0'; end architecture; nvc-r1.17.1/test/regress/wait15.vhd000066400000000000000000000011261504111170000170050ustar00rootroot00000000000000entity wait15 is end entity; architecture test of wait15 is type wait_spec_t is record delay : delay_length; end record; type wait_array_t is array (natural range <>) of wait_spec_t; constant wait_list : wait_array_t := ( (delay => 1 ns), (delay => 2 ns), (delay => 5 us ) ); begin process is begin for w in wait_list'range loop wait for wait_list(w).delay; end loop; assert now = 5003 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait16.vhd000066400000000000000000000014061504111170000170070ustar00rootroot00000000000000entity wait16 is end entity; architecture test of wait16 is type int_vec is array (natural range <>) of integer; function get_4_ints(a, b, c, d : integer) return int_vec is begin return (a, b, c, d); end function; begin p1: process is constant x : int_vec := (1, 2, 3, 4, 5); variable y : int_vec(1 to x'length) := x; begin wait for 5 ns; assert y = (1, 2, 3, 4, 5); wait; end process; p2: process is constant x : int_vec := (6, 7, 8, 9); variable y : int_vec(1 to x'length) := x; begin wait for 5 ns; assert get_4_ints(1, 2, 3, 4) = (1, 2, 3, 4); -- Would overwrite y assert y = (6, 7, 8, 9); wait; end process; end architecture; nvc-r1.17.1/test/regress/wait17.vhd000066400000000000000000000006371504111170000170150ustar00rootroot00000000000000entity wait17 is end entity; architecture test of wait17 is function func (x : bit) return bit_vector is begin return (0 to 7 => x); end function; signal result, x : bit; begin p1: result <= func(x)(0); p2: process is begin assert result = '0'; x <= '1'; wait for 1 ns; assert result = '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait18.vhd000066400000000000000000000011041504111170000170040ustar00rootroot00000000000000entity wait18 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of wait18 is signal clk, d, q : std_logic := '0'; begin process (clk) is begin if rising_edge(clk) then q <= d; end if; end process; process is begin clk <= '1' after 10 ns; d <= '1'; wait for 11 ns; assert q = '1'; wait; end process; postponed process (clk) is begin if rising_edge(clk) then assert q = '1'; end if; end process; end architecture; nvc-r1.17.1/test/regress/wait19.vhd000066400000000000000000000004621504111170000170130ustar00rootroot00000000000000entity wait19 is end entity; architecture test of wait19 is signal x : bit; begin main: process is begin x <= not x; wait for 100 ms; -- Should terminate once time -- reaches TIME'HIGH end process; end architecture; nvc-r1.17.1/test/regress/wait2.vhd000066400000000000000000000016101504111170000167170ustar00rootroot00000000000000entity wait2 is end entity; architecture test of wait2 is begin proc1: process is begin wait for 1 ns; assert now = 1 ns report "a"; wait for 2 ns; assert now = 3 ns report "b"; wait for 0 fs; assert now = 3 ns report "h"; wait for 0 fs; assert now = 3 ns report "i"; report "done proc1"; wait; end process; proc2: process is begin wait for 1500 ps; assert now = 1500 ps report "c"; wait for 1 ns; assert now = 2500 ps report "d"; wait for 0 fs; assert now = 2500 ps report "d"; wait for 0 fs; assert now = 2500 ps report "e"; wait for 500 ps; assert now = 3 ns report "f"; wait for 0 fs; assert now = 3000 ps report "g"; report "done proc2"; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait20.vhd000066400000000000000000000007171504111170000170060ustar00rootroot00000000000000entity wait20 is end entity; architecture test of wait20 is signal x : bit_vector(1 to 3); begin main: process is begin x <= "010" after 2 ns, "101" after 4 ns, "111" after 6 ns; wait on x(2) for 10 ns; -- Splits the nexus assert now = 2 ns; assert x = "010"; wait for 3 ns; assert x = "101"; wait for 2 ns; assert x = "111"; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait21.vhd000066400000000000000000000042401504111170000170020ustar00rootroot00000000000000package pack is alias resolved_max is maximum [integer_vector return integer] ; --function resolved_max (i : integer_vector) return integer; subtype RdyType is resolved_max integer range 0 to integer'high ; subtype AckType is resolved_max integer range -1 to integer'high ; procedure request(signal rdy : inout RdyType; signal ack : in AckType); procedure wait_for(signal ack : inout AckType; signal rdy : in RdyType); type ctl_t is record rdy : RdyType; ack : AckType; end record; end package; package body pack is -- function resolved_max (i : integer_vector) return integer is -- begin -- return maximum(i); -- end function; procedure request(signal rdy : inout RdyType; signal ack : in AckType) is begin rdy <= rdy + 1; wait for 0 ns; wait until rdy = ack; end procedure; procedure wait_for(signal ack : inout AckType; signal rdy : in RdyType) is begin ack <= ack + 1; wait until ack /= rdy; end procedure; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( ctl : inout ctl_t ); end entity; architecture test of sub is begin p1: process is begin wait for 5 ns; wait_for(ctl.ack, ctl.rdy); report "processing in p2"; wait for 12 ns; end process; end architecture; ------------------------------------------------------------------------------- use work.pack.all; entity wait21 is end entity; architecture test of wait21 is signal ctl : ctl_t; signal done : boolean := false; begin uut: entity work.sub port map (ctl); p2: process is begin request(ctl.rdy, ctl.ack); assert now = 22 ns; report "acked request"; wait for 2 ns; request(ctl.rdy, ctl.ack); assert now = 41 ns; done <= true; wait; end process; p3: process is begin wait for 1 hr; assert done = true; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait22.vhd000066400000000000000000000024161504111170000170060ustar00rootroot00000000000000-- Test case from Brian Padalino -- entity wait22 is end entity ; architecture arch of wait22 is procedure generate_clock(signal ena : in boolean ; signal clock : inout bit) is begin -- Inspired by UVVM clock_generator procedure loop if not ena then if now /= 0 ps then report "Stopping clock" ; end if ; clock <= '0' ; wait until ena ; end if ; clock <= '1' ; wait for 5 ns ; clock <= '0' ; wait for 5 ns ; end loop ; end procedure ; signal clock_enable : boolean := false ; signal clock : bit := '0' ; signal reset : bit := '1' ; begin gen_clock_p: generate_clock(clock_enable, clock) ; tick_p: process(clock, reset) begin if reset = '1' then else if clock'event and clock = '1' then report "Clock tick" ; end if ; end if ; end process ; tb : process begin report "About to begin" ; wait for 10 ns ; reset <= '0' ; wait for 10 ns ; clock_enable <= true ; wait for 100 ns ; std.env.stop; end process ; end architecture ; nvc-r1.17.1/test/regress/wait23.vhd000066400000000000000000000016521504111170000170100ustar00rootroot00000000000000entity wait23 is end entity; architecture test of wait23 is type timerec is record t : time; end record; type timerec_vec is array (natural range <>) of timerec; signal s : integer := 0; begin p1: process is variable a : timerec_vec(1 to 5) := ( (t => 1 ns), (t => 2 ns), (t => 3 ns), (t => 4 ms), (t => 5 ms) ); begin for i in a'range loop s <= transport i after a(i).t; end loop; assert s = 0; wait for 1 ns; assert s = 1; wait for 1 ns; assert s = 2; wait for 1 ns; assert s = 3; wait for 4 ms; assert s = 4; wait for 1 ms; assert s = 5; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait24.vhd000066400000000000000000000010041504111170000170000ustar00rootroot00000000000000library nvc; use nvc.sim_pkg.all; entity wait24 is end entity; architecture test of wait24 is begin p1: process is begin assert now = 0 ns; assert current_delta_cycle = 0; wait for 0 ns; assert now = 0 ns; assert current_delta_cycle = 1; for i in 1 to 5 loop wait for 0 ns; end loop; assert current_delta_cycle = 6; wait for 1 ps; assert current_delta_cycle = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait25.vhd000066400000000000000000000017541504111170000170150ustar00rootroot00000000000000entity wait25 is end entity; architecture test of wait25 is signal a, b, c, d : natural; begin p1: process (a, b) is begin report "P1: a=" & integer'image(a) & " b=" & integer'image(b); end process; p2: process is begin wait on c, d for 3 ns; report "P2: c=" & integer'image(c) & " d=" & integer'image(d); assert now = 3 ns; assert c = 0; assert d = 0; wait on c, d; report "P2: c=" & integer'image(c) & " d=" & integer'image(d); assert now = 5 ns; assert c = 1; assert d = 1; wait on c, d for 1 ns; assert now = 6 ns; assert c = 2; assert d = 1; wait for 1 ns; assert now = 7 ns; wait; end process; stim: process is begin wait for 1 ns; a <= 1; b <= 1; wait for 4 ns; c <= 1; d <= 1; c <= transport 2 after 1 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait26.vhd000066400000000000000000000005341504111170000170110ustar00rootroot00000000000000entity wait26 is end entity; architecture test of wait26 is begin p1: process is variable delay : time; begin delay := 5 ns; wait for delay; assert now = 5 ns; delay := -1 hr; wait for 1 ns; wait for delay; -- Error wait; end process; end architecture; nvc-r1.17.1/test/regress/wait27.vhd000066400000000000000000000026331504111170000170140ustar00rootroot00000000000000entity wait27 is end entity; architecture test of wait27 is function rising (signal x : bit) return boolean is begin return x'event and x = '1'; end function; function falling (signal x : bit) return boolean is begin return x'event and x = '0'; end function; signal clk, rstn : bit := '0'; signal count1, count2 : natural; signal running : boolean := true; begin clkgen: clk <= not clk after 5 ns when running; p1: process (rstn, clk) is begin if rstn = '0' then count1 <= 0; elsif rising(clk) then count1 <= count1 + 1; end if; end process; p2: process (rstn, clk) is begin if rstn = '0' then count2 <= 0; elsif clk'event and clk = '0' then count2 <= count1 + 1; end if; end process; p3: process (clk) is begin if rising(clk) then assert now > 0 ns; end if; end process; check: process is begin wait until falling(clk); rstn <= '1'; wait for 50 ns; assert count1 = 5; assert count2 = 5; running <= false; wait for 20 ns; assert count1 = 6; assert count2 = 6; rstn <= '0'; wait for 0 ns; wait for 0 ns; assert count1 = 0; assert count2 = 0; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait28.vhd000066400000000000000000000010111504111170000170020ustar00rootroot00000000000000package pack is procedure do_wait; end package; package body pack is procedure do_wait is begin wait for 1 ns; end procedure; end package body; ------------------------------------------------------------------------------- entity wait28 is end entity; use work.pack.all; architecture test of wait28 is signal x : bit; begin x <= '1' after 1 ns, '0' after 2 ns; sens: process (x) is begin do_wait; -- Error end process; end architecture; nvc-r1.17.1/test/regress/wait3.vhd000066400000000000000000000006521504111170000167250ustar00rootroot00000000000000entity wait3 is end entity; architecture test of wait3 is signal x, y : bit; begin proc_a: process is begin wait for 1 ns; x <= '1'; wait for 1 ns; assert y = '1'; wait; end process; proc_b: process is begin wait on x; assert x = '1'; assert now = 1 ns; y <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait4.vhd000066400000000000000000000012111504111170000167160ustar00rootroot00000000000000entity wait4 is end entity; architecture test of wait4 is signal x, y, z : bit; begin proc_a: process is begin wait for 1 ns; y <= '1'; wait for 1 ns; z <= '1'; wait for 1 ns; assert x = '1'; wait; end process; proc_b: process is begin wait on x, y; assert y = '1'; assert now = 1 ns; assert y'event report "not y'event"; assert not x'event report "x'event"; wait on z; assert not x'event; assert z'event; assert z = '1'; x <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait5.vhd000066400000000000000000000007321504111170000167260ustar00rootroot00000000000000entity wait5 is end entity; architecture test of wait5 is signal x, y : integer := 0; begin a: process (x) is begin y <= y + 1; end process; b: process is begin wait for 1 ns; assert y = 1; x <= 1; wait for 1 ns; x <= 0; wait for 1 ns; assert y = 3; x <= 0; wait for 1 ns; assert y = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait6.vhd000066400000000000000000000007661504111170000167360ustar00rootroot00000000000000entity wait6 is end entity; architecture test of wait6 is signal x : bit_vector(3 downto 0); begin print: process (x) is begin report "x changed " & bit'image(x(3)) & " " & bit'image(x(2)) & " " & bit'image(x(1)) & " " & bit'image(x(0)); end process; stim: process is begin x <= X"1"; wait for 1 ns; x <= X"2"; wait for 1 ns; x <= X"f"; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait7.vhd000066400000000000000000000014611504111170000167300ustar00rootroot00000000000000entity wait7 is end entity; architecture test of wait7 is signal state : integer := 0; signal x : integer := 0; begin wakeup: process is begin wait until x = 1; state <= 1; wait until x = 5; state <= 2; wait until x > 10; state <= 3; wait; end process; stim: process is begin x <= -1; wait for 1 ns; assert state = 0; x <= 6; wait for 1 ns; assert state = 0; x <= 1; wait for 1 ns; assert state = 1; x <= 0; wait for 1 ns; assert state = 1; x <= 5; wait for 1 ns; assert state = 2; x <= 50; wait for 1 ns; assert state = 3; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait8.vhd000066400000000000000000000006751504111170000167370ustar00rootroot00000000000000entity wait8 is end entity; architecture test of wait8 is procedure foo(signal x : in bit_vector) is begin wait on x; end procedure; signal s : bit_vector(1 to 2) := "00"; begin a: process is begin foo(s); assert now = 10 ns; assert s = "11"; wait; end process; b: process is begin s <= "11" after 10 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/wait9.vhd000066400000000000000000000013011504111170000167230ustar00rootroot00000000000000entity wait9 is end entity; architecture test of wait9 is signal s : bit_vector(3 downto 0); signal n : integer := 0; begin a: process is variable cnt : integer := 0; begin wait on s(1), s(2); cnt := cnt + 1; n <= cnt; end process; b: process is begin s <= "0000"; wait for 1 ns; s <= "1001"; wait for 1 ns; s <= "0101"; wait for 1 ns; s <= "0010"; wait for 1 ns; s(1) <= '0'; s(2) <= '1'; wait for 1 ns; s(2) <= '0'; wait for 1 ns; report integer'image(n); assert n = 4; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave1.vhd000066400000000000000000000006051504111170000167170ustar00rootroot00000000000000entity wave1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of wave1 is signal x : std_logic; signal y : std_logic_vector(1 to 3) := "ZZZ"; begin main: process is begin x <= '1'; wait for 1 ns; y <= "101"; x <= '0'; wait for 1 ns; y <= "001"; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave10.vhd000066400000000000000000000015101504111170000167730ustar00rootroot00000000000000entity sub is generic ( g : in integer ); port ( x : in bit_vector(1 to g) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity wave10 is end entity; architecture test of wave10 is component comp is generic ( g : in integer ); port ( x : in bit_vector(1 to g) ); end component; function get_g return integer is begin return 5; end function; for u1 : comp use entity work.sub; for u2 : comp use open; signal s : bit_vector(1 to get_g); begin u1: component comp generic map (g => get_g) port map (s); u2: component comp generic map (g => get_g) port map (s); s <= "01000" after 1 ns, "11100" after 2 ns; end architecture; nvc-r1.17.1/test/regress/wave11.vhd000066400000000000000000000013211504111170000167740ustar00rootroot00000000000000entity wave11 is end entity; architecture test of wave11 is signal s : bit_vector(1 to 3); begin b: block is port ( p1 : bit_vector ); port map ( s ); type t_rec1 is record f1 : boolean; f2 : p1'subtype; end record; type t_rec1_array is array (natural range <>) of t_rec1; type t_rec2 is record f1 : integer; f2 : p1'subtype; f3 : t_rec1; f4 : t_rec1_array(0 to 2); end record; signal r : t_rec2; begin r.f2(1) <= '1' after 1 ns, '0' after 2 ns; r.f3.f2(2) <= '1' after 3 ns; r.f4(1).f1 <= true after 4 ns; end block; end architecture; nvc-r1.17.1/test/regress/wave12.vhd000066400000000000000000000021721504111170000170020ustar00rootroot00000000000000-- Run with --dump-arrays=3 entity wave12 is end entity; architecture test of wave12 is type t_mem is array (natural range <>) of bit_vector(7 downto 0); type t_rec is record x : integer; -- Should dump y : t_mem(1 to 3); -- Should dump z : t_mem(1 to 10000); -- Should not dump end record; type t_rec_array is array (natural range <>) of t_rec; signal s : t_rec_array(1 to 4); -- Should dump signal a : t_mem(1 to 2); -- Should dump signal b : t_mem(1 to 1000); -- Should not dump begin stim: process is variable mask : bit_vector(7 downto 0) := X"01"; variable num : natural; begin for i in 1 to 5 loop for j in 1 to 4 loop s(j).x <= i; s(j).y(1 + (num mod 3)) <= mask; s(j).z(1 + (num mod 10000)) <= mask; mask := mask rol 1; num := num + 1; end loop; a(1 + (num mod 2)) <= mask; wait for 1 ns; end loop; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave2.sh000066400000000000000000000003211504111170000165440ustar00rootroot00000000000000set -xe pwd which nvc which fstdump nvc -a $TESTDIR/regress/wave2.vhd -e wave2 -r -w --exclude '*foo' --include ':wave2:*' fstdump wave2.fst > wave2.dump diff -u $TESTDIR/regress/gold/wave2.dump wave2.dump nvc-r1.17.1/test/regress/wave2.vhd000066400000000000000000000005041504111170000167160ustar00rootroot00000000000000entity wave2 is end entity; architecture test of wave2 is signal foo : bit_vector(1 to 3); signal bar : bit; signal foobaz : bit; signal frobfoo : bit; begin main: process is begin bar <= '1'; wait for 1 ns; frobfoo <= '1'; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave3.vhd000066400000000000000000000040651504111170000167250ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity sub is port ( x : in std_logic_vector(7 downto 0); y : out std_logic_vector(7 downto 0) ); end entity; architecture test of sub is signal ctr : unsigned(3 to 18) := (others => '0'); signal ctr2 : unsigned(15 downto 0) := (others => '0'); begin y <= x after 5 ns; ctr <= ctr + 1 after 20 ns; ctr2 <= ctr2 + 1 after 20 ns; end architecture; ------------------------------------------------------------------------------- package p is signal s : bit; end package; ------------------------------------------------------------------------------- entity wave3 is end entity; library ieee; use ieee.std_logic_1164.all; use work.p.all; architecture test of wave3 is signal x : std_logic_vector(7 downto 0) := X"AA"; signal y : std_logic_vector(7 downto 0); signal z : std_logic := 'U'; signal o : std_logic := '0'; signal b : boolean; signal m : string(1 to 3); signal p : bit_vector(1 to 3); signal q : bit_vector(3 downto 1); signal t : delay_length; type state is (INIT, ONE, TWO); signal s : state; subtype state_sub is state range ONE to TWO; signal s2 : state_sub; begin x <= not x after 50 ns; z <= 'X' after 100 ns, -- Appears same as 'U' 'H' after 200 ns, 'Z' after 300 ns, 'L' after 400 ns, '-' after 500 ns, '1' after 600 ns; a_block: block is signal i : natural; -- No integer type in FST? signal c : character; begin i <= i + 1 after 20 ns; c <= m((i rem 3) + 1); end block; m <= "abc"; work.p.s <= '1'; b <= true; s <= ONE after 60 ns, TWO after 150 ns; sub_i: entity work.sub port map ( x, y ); gen: for i in 1 to 3 generate signal g : integer; begin end generate; p(1) <= '1'; p(2) <= '1'; p(3) <= '0'; q(1) <= '1'; q(2) <= '1'; q(3) <= '0'; t <= 20 us after 1 ps; s2 <= TWO after 4 ns; end architecture; nvc-r1.17.1/test/regress/wave4.vhd000066400000000000000000000007701504111170000167250ustar00rootroot00000000000000entity wave4 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of wave4 is type mem_t is array (natural range <>) of std_logic_vector(7 downto 0); signal mem : mem_t(0 to 9); signal dout : std_logic_vector(7 downto 0); signal addr : natural range 0 to 7; begin dout <= mem(addr); main: process is begin mem(2) <= X"01"; mem(5) <= X"55" after 1 ns; addr <= 5 after 10 ns; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave5.vhd000066400000000000000000000010631504111170000167220ustar00rootroot00000000000000entity wave5 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of wave5 is type pair is record a, b : integer; end record; type rec is record x : integer; y : std_logic_vector(1 to 3); z : pair; end record; signal r : rec; begin main: process is begin wait for 1 ns; r.y <= "101"; wait for 1 ns; r.z.b <= 5; r.z.a <= 6; wait for 1 ns; r.x <= 2; r.z.a <= 1; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave6.vhd000066400000000000000000000011511504111170000167210ustar00rootroot00000000000000entity wave6 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of wave6 is type pair is record a, b : integer; end record; type rec is record x : integer; y : std_logic_vector; z : pair; end record; subtype rec_c is rec(y(1 to 3)); signal r : rec_c; begin main: process is begin wait for 1 ns; r.y <= "101"; wait for 1 ns; r.z.b <= 5; r.z.a <= 6; wait for 1 ns; r.x <= 2; r.z.a <= 1; r.y <= "010"; wait; end process; end architecture; nvc-r1.17.1/test/regress/wave7.sh000066400000000000000000000003351504111170000165560ustar00rootroot00000000000000set -xe pwd which nvc which fstdump nvc --std=2008 -a $TESTDIR/regress/wave7.vhd -e wave7 -r -w --stats 2>err grep "Note: setup:" err fstdump wave7.fst > wave7.dump diff -u $TESTDIR/regress/gold/wave7.dump wave7.dump nvc-r1.17.1/test/regress/wave7.vhd000066400000000000000000000004021504111170000167200ustar00rootroot00000000000000use std.env.all; entity wave7 is end entity; architecture test of wave7 is signal x : integer; begin x <= 1 after 1 ns, 2 after 2 ns, 3 after 4 ns; process is begin wait for 3 ns; stop; end process; end architecture; nvc-r1.17.1/test/regress/wave8.vhd000066400000000000000000000017101504111170000167240ustar00rootroot00000000000000package pack is type rec is record x : integer; end record; impure function get_field (r : rec) return integer; end package; package body pack is impure function get_field (r : rec) return integer is begin return r.x; end function; end package body; ------------------------------------------------------------------------------- use work.pack.all; entity sub is generic ( r : rec ); port ( o : out bit_vector(1 to get_field(r)) ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity wave8 is end entity; use work.pack.all; architecture test of wave8 is function new_rec return rec is begin return (x => 4); end function; constant r : rec := new_rec; signal x : bit_vector(1 to 4); begin u: entity work.sub generic map ( r ) port map ( x ); end architecture; nvc-r1.17.1/test/regress/wave9.vhd000066400000000000000000000010651504111170000167300ustar00rootroot00000000000000entity sub is port ( ii : in bit; oo : out bit ); end entity; architecture test of sub is begin oo <= ii after 1 ps; end architecture; ------------------------------------------------------------------------------- entity wave9 is end entity; architecture test of wave9 is component sub is port ( i : in bit; o : out bit ); end component; for u : sub use entity work.sub port map ( ii => i, oo => o ); signal x, y : bit; begin u: sub port map ( x, y ); x <= '1' after 1 ns, '0' after 2 ns; end architecture; nvc-r1.17.1/test/regress/while1.vhd000066400000000000000000000006411504111170000170650ustar00rootroot00000000000000entity while1 is end entity; architecture test of while1 is begin process is variable n : integer := 5; begin while n > 0 loop report integer'image(n); n := n - 1; end loop; while n < 5 loop report integer'image(n); n := n + 1; wait for 1 ns; end loop; wait; end process; end architecture; nvc-r1.17.1/test/run_ivtest.rb000077500000000000000000000043151504111170000162530ustar00rootroot00000000000000#!/usr/bin/env ruby require 'rubygems' require 'pathname' require 'colorize' require 'timeout' require 'open3' require 'tmpdir' if ARGV.length != 1 then puts "Usage: #{__FILE__} /path/to/ivtest" exit 1 end TestDir = Pathname.new(__FILE__).realpath.dirname BuildDir = Pathname.new(ENV['BUILD_DIR'] || Dir.pwd).realpath LibPath = "#{BuildDir}/lib/std:#{BuildDir}/lib/ieee" IvtestDir = Pathname.new(ARGV[0]).realpath GitRev = IO::popen("git rev-parse --short HEAD").read.chomp Tool = ENV['NVC'] || 'nvc' ExpectFails = 1280 ENV['NVC_COLORS'] = 'always' def run_cmd(c, expfail) Open3.popen2e(c) do |i, oe, t| i.close output = nil begin Timeout::timeout(5) do output = oe.read end rescue Timeout::Error Process.kill("KILL", t.pid) output = 'Timeout!' end status = t.value if output =~ /Caught signal/ or (c =~ /-r/ and output =~ /FAILED TEST/) then puts puts c.magenta puts output return false elsif status != 0 and output =~ /PASSED TEST/ then return true # Testing assertion failure elsif status != 0 and not expfail then puts puts c.magenta puts output return false elsif status == 0 and expfail then puts puts c.magenta puts output puts "expected failure!".magenta return false end return true end end fails = 0 passes = 0 ["regress-vlg"].each do |list| File.open("#{IvtestDir}/#{list}.list").each_line do |line| cleaned = line.gsub(/#.*/, '').strip next if cleaned.empty? name, type, dir, flags = cleaned.split Dir.mktmpdir do |workdir| f = File.realpath "#{IvtestDir}/#{dir}/#{name}.v" cmd = "#{Tool} --work=work:#{workdir}/work -a --no-save #{f}" result = run_cmd cmd, (type == "CE") if result then passes += 1 print '+'.green else fails += 1 end end end end puts puts "#{passes} passes" puts "#{fails} failures" File.open("#{IvtestDir}/HISTORY", 'a') do |f| f.printf("%20s %10s %4d passes %4d failures\n", Time.new.ctime, GitRev, passes, fails) end if fails > ExpectFails then puts "Expected #{ExpectFails} failures but have #{fails}" exit 1 end nvc-r1.17.1/test/run_regr.c000066400000000000000000001131541504111170000155120ustar00rootroot00000000000000// // Copyright (C) 2016-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #ifdef __MINGW32__ #define WINVER 0x0A00 #define _WIN32_WINNT 0x0A00 #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __CYGWIN__ #include #endif #ifdef __MINGW32__ #include #include #define setenv(x, y, z) _putenv_s((x), (y)) #define realpath(N, R) _fullpath((R), (N), _MAX_PATH) #else #include #endif #include "config.h" #define WHITESPACE " \t\r\n" #define TIMEOUT 10 #define OUTFILE ".test.out" #define ANSI_RESET 0 #define ANSI_BOLD 1 #define ANSI_FG_BLACK 30 #define ANSI_FG_RED 31 #define ANSI_FG_GREEN 32 #define ANSI_FG_YELLOW 33 #define ANSI_FG_BLUE 34 #define ANSI_FG_MAGENTA 35 #define ANSI_FG_CYAN 36 #define ANSI_FG_WHITE 37 #define F_GOLD (1 << 0) #define F_FAIL (1 << 1) #define F_STOP (1 << 2) #define F_VHPI (1 << 3) #define F_2008 (1 << 4) #define F_2000 (1 << 5) #define F_NOTWIN (1 << 6) #define F_COVER (1 << 7) #define F_2019 (1 << 8) #define F_RELAX (1 << 9) #define F_RELAXED (1 << 10) #define F_WORKLIB (1 << 11) #define F_SHELL (1 << 12) #define F_2002 (1 << 13) #define F_SLOW (1 << 14) #define F_VERILOG (1 << 15) #define F_MIXED (1 << 16) #define F_WAVE (1 << 17) #define F_PSL (1 << 18) #define F_DEFINE (1 << 19) #define F_TCL (1 << 20) #define F_GTKW (1 << 21) #define F_NOCOLL (1 << 22) #define F_EXPORT (1 << 23) #define F_SHUFFLE (1 << 24) #define F_NOTBSD (1 << 25) #define F_ARRAYS (1 << 26) #define F_SEED (1 << 27) typedef struct test test_t; typedef struct param param_t; typedef struct arglist arglist_t; typedef enum { P_GENERIC, P_ENVVAR } param_kind_t; struct param { param_kind_t kind; char *name; char *value; param_t *next; }; struct test { char *name; test_t *next; int flags; char *stop; param_t *params; char *relax; char *work; unsigned olevel; char *heapsz; char *cover; char *define; char *export; char *plusarg; unsigned arrays; int seed; double duration; }; struct arglist { char *data; arglist_t *next; unsigned count; }; typedef enum { RUN_OK, RUN_FAILED, RUN_SIGNALLED, } run_status_t; static test_t *test_list = NULL; static char test_dir[PATH_MAX]; static char bin_dir[PATH_MAX]; static bool is_tty = false; static bool force_jit = false; static bool force_precompile = false; #ifdef __MINGW32__ static char *strndup(const char *s, size_t n) { size_t len = strlen(s); if (n < len) len = n; char *result = malloc(len + 1); result[len] = '\0'; return memcpy(result, s, len); } static void win32_error(const char *msg) { LPSTR mbuf = NULL; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&mbuf, 0, NULL); fprintf(stderr, "%s: %s", msg, mbuf); fflush(stderr); LocalFree(mbuf); exit(EXIT_FAILURE); } static DWORD win32_timeout_thread(LPVOID lpParam) { HANDLE hProcess = (HANDLE)lpParam; if (WaitForSingleObject(hProcess, TIMEOUT * 1000) == WAIT_TIMEOUT) { if (!TerminateProcess(hProcess, 0x500)) win32_error("TerminateProcess"); } return 0; } static run_status_t win32_run_cmd(FILE *log, arglist_t **args) { SECURITY_ATTRIBUTES saAttr; saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; HANDLE hChildStdOutRd, hChildStdOutWr; if (!CreatePipe(&hChildStdOutRd, &hChildStdOutWr, &saAttr, 0)) win32_error("StdoutRd CreatePipe"); if (!SetHandleInformation(hChildStdOutRd, HANDLE_FLAG_INHERIT, 0)) win32_error("Stdout SetHandleInformation"); char cmdline[8192], *p = cmdline; for (arglist_t *it = *args; it != NULL; it = it->next) p += snprintf(p, cmdline + sizeof(cmdline) - p, "%s%s", it != *args ? " " : "", it->data); fprintf(log, "%s\n", cmdline); fflush(log); PROCESS_INFORMATION piProcInfo; ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION)); STARTUPINFO siStartInfo; ZeroMemory(&siStartInfo, sizeof(STARTUPINFO)); siStartInfo.cb = sizeof(STARTUPINFO); siStartInfo.hStdError = hChildStdOutWr; siStartInfo.hStdOutput = hChildStdOutWr; siStartInfo.dwFlags |= STARTF_USESTDHANDLES; if (!CreateProcess(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo)) win32_error("CreateProcess"); CloseHandle(hChildStdOutWr); HANDLE hTimeoutThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)win32_timeout_thread, piProcInfo.hProcess, 0, NULL); if (hTimeoutThread == NULL) win32_error("CreateThread"); for (;;) { DWORD dwRead; CHAR chBuf[1024]; if (!ReadFile(hChildStdOutRd, chBuf, sizeof(chBuf), &dwRead, NULL)) break; else if (dwRead == 0) break; fwrite(chBuf, dwRead, 1, log); fflush(log); } if (WaitForSingleObject(piProcInfo.hProcess, 1000) != WAIT_OBJECT_0) win32_error("WaitForSingleObject"); DWORD status; if (!GetExitCodeProcess(piProcInfo.hProcess, &status)) win32_error("GetExitCodeProcess"); if (status == 0x500) fprintf(log, "Timeout!\n"); else if (status == STILL_ACTIVE) fprintf(log, "Still running!\n"); if (WaitForSingleObject(hTimeoutThread, 1000) != WAIT_OBJECT_0) win32_error("WaitForSingleObject"); CloseHandle(hTimeoutThread); CloseHandle(piProcInfo.hProcess); CloseHandle(piProcInfo.hThread); while (*args) { arglist_t *tmp = (*args)->next; free((*args)->data); free(*args); *args = tmp; } return status == 0 ? RUN_OK : RUN_FAILED; } #endif static double get_timestamp_ns(void) { #if defined __MINGW32__ static volatile uint64_t freq; if (freq == 0) { LARGE_INTEGER tmp; if (!QueryPerformanceFrequency(&tmp)) win32_error("QueryPerformanceFrequency"); freq = tmp.QuadPart; } LARGE_INTEGER ticks; if (!QueryPerformanceCounter(&ticks)) win32_error("QueryPerformanceCounter"); return (double)ticks.QuadPart * (1e9 / (double)freq); #else struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) abort(); return (double)ts.tv_nsec * 1.0e-9 + ts.tv_sec; #endif } static char *xvasprintf(const char *fmt, va_list ap) { char *strp = NULL; if (vasprintf(&strp, fmt, ap) < 0) abort(); return strp; } __attribute__((format(printf, 1, 2))) static char *xasprintf(const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *strp = xvasprintf(fmt, ap); va_end(ap); return strp; } static void set_attr(int escape) { if (is_tty) printf("\033[%dm", escape); } static bool is_comment(const char *str) { return str[0] == '#'; } static bool parse_test_list(void) { char testlist[PATH_MAX + 22]; snprintf(testlist, sizeof(testlist), "%s/regress/testlist.txt", test_dir); FILE *f = fopen(testlist, "r"); if (f == NULL) { fprintf(stderr, "%s: %s\n", testlist, strerror(errno)); return false; } bool result = false; int lineno = 0; test_t *last = NULL; while (lineno++, !feof(f)) { char line[256]; if (fgets(line, sizeof(line), f) == NULL) break; char *name = strtok(line, WHITESPACE); if (name == NULL || is_comment(name)) continue; char *options = strtok(NULL, WHITESPACE); if (options == NULL || is_comment(options)) { fprintf(stderr, "Error on testlist line %d: missing options for " "test %s\n", lineno, name); goto out_close; } char *remain = strtok(NULL, WHITESPACE); if (remain != NULL && !is_comment(remain)) { fprintf(stderr, "Error on testlist line %d: extra tokens after " "test %s options list\n", lineno, name); goto out_close; } test_t *test = calloc(sizeof(test_t), 1); test->name = strdup(name); test->olevel = 0; if (last == NULL) test_list = test; else last->next = test; char *opt = strtok(options, ","); while (opt != NULL) { if (strcmp(opt, "normal") == 0) ; else if (strcmp(opt, "gold") == 0) test->flags |= F_GOLD; else if (strcmp(opt, "fail") == 0) test->flags |= F_FAIL; else if (strncmp(opt, "stop", 4) == 0) { char *stop = strchr(opt, '='); if (stop == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "stop option in test %s\n", lineno, name); goto out_close; } test->flags |= F_STOP; test->stop = strdup(stop + 1); } else if (strcmp(opt, "2008") == 0) test->flags |= F_2008; else if (strcmp(opt, "2000") == 0) test->flags |= F_2000; else if (strcmp(opt, "2002") == 0) test->flags |= F_2002; else if (strcmp(opt, "2019") == 0) test->flags |= F_2019; else if (strcmp(opt, "vhpi") == 0) test->flags |= F_VHPI; else if (strcmp(opt, "shell") == 0) test->flags |= F_SHELL | F_NOTWIN; else if (strcmp(opt, "slow") == 0) test->flags |= F_SLOW; else if (strcmp(opt, "!windows") == 0) test->flags |= F_NOTWIN; else if (strcmp(opt, "!freebsd") == 0) test->flags |= F_NOTBSD; else if (strcmp(opt, "mixed") == 0) test->flags |= F_MIXED; else if (strcmp(opt, "verilog") == 0) test->flags |= F_VERILOG; else if (strcmp(opt, "wave") == 0) test->flags |= F_WAVE; else if (strcmp(opt, "gtkw") == 0) test->flags |= F_GTKW; else if (strcmp(opt, "psl") == 0) test->flags |= F_PSL; else if (strcmp(opt, "tcl") == 0) test->flags |= F_TCL; else if (strcmp(opt, "shuffle") == 0) test->flags |= F_SHUFFLE; else if (strcmp(opt, "no-collapse") == 0) test->flags |= F_NOCOLL; else if (strcmp(opt, "dump-arrays") == 0) test->flags |= F_ARRAYS; else if (strncmp(opt, "dump-arrays=", 12) == 0) { test->flags |= F_ARRAYS; if (sscanf(opt + 12, "%u", &(test->arrays)) != 1) { fprintf(stderr, "Error on testlist line %d: invalid " "dump-arrays argument %s\n", lineno, opt); goto out_close; } } else if (strncmp(opt, "seed=", 5) == 0) { test->flags |= F_SEED; if (sscanf(opt + 5, "%u", &(test->seed)) != 1) { fprintf(stderr, "Error on testlist line %d: invalid " "seed argument %s\n", lineno, opt); goto out_close; } } else if (strncmp(opt, "O", 1) == 0) { if (sscanf(opt + 1, "%u", &(test->olevel)) != 1) { fprintf(stderr, "Error on testlist line %d: invalid " "optimisation level %s\n", lineno, opt); goto out_close; } } else if (strncmp(opt, "H=", 2) == 0) test->heapsz = strdup(opt + 2); else if (strncmp(opt, "cover", 5) == 0) { test->flags |= F_COVER; if (opt[5] == '=') { test->cover = strdup(opt + 6); for (char *p = test->cover; *p; p++) { if (*p == '+') *p = ','; // Allow + instead of , as separator } } } else if (opt[0] == 'g' || opt[0] == '$') { char *value = strchr(opt, '='); if (value == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "parameter option in test %s\n", lineno, name); goto out_close; } param_t *p = calloc(sizeof(param_t), 1); p->name = strndup(opt + 1, value - opt - 1); p->value = strdup(value + 1); p->next = test->params; p->kind = opt[0] == 'g' ? P_GENERIC : P_ENVVAR; test->params = p; } else if (strcmp(opt, "relaxed") == 0) test->flags |= F_RELAXED; else if (strncmp(opt, "relax", 5) == 0) { char *value = strchr(opt, '='); if (value == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "relax option in test %s\n", lineno, name); goto out_close; } test->flags |= F_RELAX; test->relax = strdup(value + 1); } else if (strncmp(opt, "work", 4) == 0) { char *value = strchr(opt, '='); if (value == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "work option in test %s\n", lineno, name); goto out_close; } test->flags |= F_WORKLIB; test->work = strdup(value + 1); } else if (strncmp(opt, "define", 6) == 0) { char *value = strchr(opt, '='); if (value == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "define option in test %s\n", lineno, name); goto out_close; } test->flags |= F_DEFINE; test->define = strdup(value + 1); } else if (strncmp(opt, "export", 6) == 0) { char *value = strchr(opt, '='); if (value == NULL) { fprintf(stderr, "Error on testlist line %d: missing argument to " "export option in test %s\n", lineno, name); goto out_close; } test->flags |= F_EXPORT; test->export = strdup(value + 1); } else if (opt[0] == '+') test->plusarg = strdup(opt + 1); else { fprintf(stderr, "Error on testlist line %d: invalid option %s in " "test %s\n", lineno, opt, name); goto out_close; } opt = strtok(NULL, ","); } last = test; } result = true; out_close: fclose(f); return result; } __attribute__((format(printf, 2, 3))) static void push_arg(arglist_t **args, const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *cmd = xvasprintf(fmt, ap); va_end(ap); arglist_t *n = calloc(1, sizeof(arglist_t)); n->data = cmd; n->next = NULL; n->count = 1; arglist_t *it = *args; if (it == NULL) *args = n; else { for (; it->next != NULL; it = it->next) (it->count)++; it->next = n; (it->count)++; } } #ifndef __MINGW32__ static void signal_handler(int sig) { } #endif static run_status_t run_cmd(FILE *log, arglist_t **args) { fflush(stdout); fflush(stderr); #if defined __MINGW32__ return win32_run_cmd(log, args); #else pid_t pid = fork(); if (pid < 0) { fprintf(stderr, "Fork failed: %s", strerror(errno)); return RUN_SIGNALLED; } else if (pid == 0) { dup2(fileno(log), STDOUT_FILENO); dup2(fileno(log), STDERR_FILENO); int nullfd = open("/dev/null", O_WRONLY); if (nullfd != -1) dup2(nullfd, STDIN_FILENO); char **argv = calloc((*args)->count + 1, sizeof(char *)); arglist_t *it = *args; for (int i = 0; i < (*args)->count; i++, it = it->next) { printf("%s%s", i > 0 ? " " : "", it->data); argv[i] = it->data; } printf("\n"); execv((*args)->data, argv); fprintf(stderr, "Exec failed: %s\n", strerror(errno)); _exit(EXIT_FAILURE); } else { while (*args) { arglist_t *tmp = (*args)->next; free((*args)->data); free(*args); *args = tmp; } signal(SIGALRM, signal_handler); signal(SIGCHLD, signal_handler); alarm(TIMEOUT); pause(); signal(SIGALRM, SIG_DFL); signal(SIGCHLD, SIG_DFL); int status = 0, nready = waitpid(pid, &status, WNOHANG); if (nready < 0) { fprintf(stderr, "Waiting for child failed: %s\n", strerror(errno)); return RUN_SIGNALLED; } else if (nready != 0 && WIFSIGNALED(status)) { fprintf(log, "Caught signal %d\n", WTERMSIG(status)); return RUN_SIGNALLED; } else if (nready == 0 || !WIFEXITED(status)) { fprintf(log, "Timeout!\n"); if (kill(pid, SIGTERM) != 0) fprintf(stderr, "Sending SIGTERM to child failed: %s\n", strerror(errno)); else wait(&status); return RUN_SIGNALLED; } else return WEXITSTATUS(status) == 0 ? RUN_OK : RUN_FAILED; } #endif // __CYGWIN__ || __MINGW32__ } static void push_std(test_t *test, arglist_t **args) { if (test->flags & F_2000) push_arg(args, "--std=2000"); else if (test->flags & F_2002) push_arg(args, "--std=2002"); else if (test->flags & F_2008) push_arg(args, "--std=2008"); else if (test->flags & F_2019) push_arg(args, "--std=2019"); else push_arg(args, "--std=1993"); } static void chomp(char *str) { const size_t len = strlen(str); if (len > 0 && str[len - 1] == '\n') str[len - 1] = '\0'; } #ifndef __MINGW32__ static bool remove_dir(const char *path) { DIR *d = opendir(path); if (d == NULL) return false; bool result = false; char buf[PATH_MAX]; struct dirent *e; while ((e = readdir(d))) { if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue; snprintf(buf, sizeof(buf), "%s" DIR_SEP "%s", path, e->d_name); if (e->d_type == DT_DIR && !remove_dir(buf)) goto out_close; else if (e->d_type == DT_REG && unlink(buf) < 0) goto out_close; } if (rmdir(path) < 0) goto out_close; result = true; out_close: closedir(d); return result; } #endif __attribute__((unused)) static bool make_dir(const char *name) { #ifdef __MINGW32__ return mkdir(name) == 0; #else return mkdir(name, 0777) == 0; #endif } __attribute__((unused)) static bool dir_exists(const char *path) { struct stat st; return stat(path, &st) == 0 && S_ISDIR(st.st_mode); } __attribute__((format(printf, 1, 2))) static bool file_exists(const char *fmt, ...) { va_list ap; va_start(ap, fmt); char *path = xvasprintf(fmt, ap); va_end(ap); bool exists = false; struct stat st; if (stat(path, &st) == 0 && S_ISREG(st.st_mode)) exists = true; free(path); return exists; } static bool enter_test_directory(test_t *test, char *dir) { #ifdef __MINGW32__ if (!dir_exists("logs") && !make_dir("logs")) { printf("make_dir %s failed\n", "logs"); return false; } snprintf(dir, PATH_MAX, "logs/%s", test->name); if (!dir_exists(dir) && !make_dir(dir)) { printf("make_dir %s failed\n", dir); return false; } #else snprintf(dir, PATH_MAX, "%s/nvcXXXXXX", getenv("TEMP") ?: "/tmp"); if (mkdtemp(dir) == NULL) return false; #endif if (chdir(dir) != 0) return false; return true; } static void explain(int attr, const char *prefix, const char *fmt, va_list ap) { char *reason = NULL; if (fmt != NULL) reason = xvasprintf(fmt, ap); set_attr(attr); if (reason != NULL) printf("%s (%s)", prefix, reason); else printf("%s", prefix); set_attr(ANSI_RESET); printf("\n"); fflush(stdout); free(reason); } __attribute__((format(printf, 1, 2))) static void failed(const char *fmt, ...) { va_list ap; va_start(ap, fmt); explain(ANSI_FG_RED, "failed", fmt, ap); va_end(ap); } __attribute__((format(printf, 1, 2))) static void skipped(const char *fmt, ...) { va_list ap; va_start(ap, fmt); explain(ANSI_FG_CYAN, "skipped", fmt, ap); va_end(ap); } static bool run_test(test_t *test) { printf("%15s : ", test->name); int skip = 0; #if defined __MINGW32__ || defined __CYGWIN__ skip |= (test->flags & F_NOTWIN); #endif #ifdef __FreeBSD__ skip |= (test->flags & F_NOTBSD); #endif #ifndef HAVE_LLVM skip |= (test->flags & F_SLOW); #else const char *threshold = getenv("NVC_JIT_THRESHOLD"); if (threshold != NULL && atoi(threshold) == 0) skip |= (test->flags & F_SLOW); #endif #ifndef ENABLE_TCL skip |= (test->flags & F_TCL); #endif if (skip) { if (skip & F_SLOW) skipped("slow with interpreter"); else if (skip & F_TCL) skipped("tcl not enabled"); else if (skip & (F_NOTWIN | F_WAVE)) skipped("disabled on windows"); else if (skip & F_NOTBSD) skipped("disabled on freebsd"); else skipped(NULL); return true; } bool result = false; char dir[PATH_MAX], cwd[PATH_MAX]; if (getcwd(cwd, PATH_MAX) == NULL) { failed("error getting working directory: %s", strerror(errno)); return false; } if (!enter_test_directory(test, dir)) { failed("error creating test directory: %s", strerror(errno)); return false; } FILE *outf = fopen(OUTFILE, "w"); if (outf == NULL) { failed("error creating %s/out log file: %s", dir, strerror(errno)); result = false; goto out_chdir; } setenv("TEST_NAME", test->name, 1); arglist_t *args = NULL; const double start_ns = get_timestamp_ns(); if (test->flags & F_SHELL) { push_arg(&args, SH_PATH); push_arg(&args, "%s" DIR_SEP "regress" DIR_SEP "%s.sh", test_dir, test->name); } else if (test->flags & F_TCL) { push_arg(&args, "%s" DIR_SEP "nvc%s", bin_dir, EXEEXT); push_std(test, &args); if (test->flags & F_WORKLIB) push_arg(&args, "--work=%s", test->work); if (test->heapsz != NULL) push_arg(&args, "-H%s", test->heapsz); if (file_exists("%s/regress/%s.vhd", test_dir, test->name)) { push_arg(&args, "-a"); push_arg(&args, "%s/regress/%s.vhd", test_dir, test->name); push_arg(&args, "-e"); push_arg(&args, "%s", test->name); } push_arg(&args, "--do"); push_arg(&args, "%s" DIR_SEP "regress" DIR_SEP "%s.tcl", test_dir, test->name); } else { push_arg(&args, "%s" DIR_SEP "nvc%s", bin_dir, EXEEXT); push_std(test, &args); if (test->flags & F_WORKLIB) push_arg(&args, "--work=%s", test->work); if (test->heapsz != NULL) push_arg(&args, "-H%s", test->heapsz); if (test->flags & F_VHPI) push_arg(&args, "--load=%s/../lib/vhpi_test.so%s", bin_dir, EXEEXT); if (test->flags & F_SEED) push_arg(&args, "--seed=%u", test->seed); push_arg(&args, "-a"); if (!(test->flags & F_VERILOG)) push_arg(&args, "%s" DIR_SEP "regress" DIR_SEP "%s.vhd", test_dir, test->name); if (test->flags & (F_MIXED | F_VERILOG)) push_arg(&args, "%s" DIR_SEP "regress" DIR_SEP "%s.v", test_dir, test->name); if (test->flags & F_RELAX) push_arg(&args, "--relax=%s", test->relax); if (test->flags & F_RELAXED) push_arg(&args, "--relaxed"); if (test->flags & F_PSL) push_arg(&args, "--psl"); if (test->flags & F_DEFINE) push_arg(&args, "--define=%s", test->define); if (test->flags & F_VHPI) push_arg(&args, "--preserve-case"); push_arg(&args, "-e"); push_arg(&args, "%s", test->name); push_arg(&args, "-O%u", test->olevel); if (test->flags & F_NOCOLL) push_arg(&args, "--no-collapse"); if (test->flags & F_COVER) { if (test->cover) push_arg(&args, "--cover=%s", test->cover); else push_arg(&args, "--cover"); } for (param_t *p = test->params; p != NULL; p = p->next) { switch (p->kind) { case P_GENERIC: push_arg(&args, "-g%s=%s", p->name, p->value); break; case P_ENVVAR: setenv(p->name, p->value, 1); break; } } if (force_jit) push_arg(&args, "--jit"); else if (force_precompile) push_arg(&args, "--precompile"); if (test->flags & F_FAIL) { if (run_cmd(outf, &args) != RUN_OK) { failed(NULL); result = false; goto out_print; } push_arg(&args, "%s/nvc%s", bin_dir, EXEEXT); push_std(test, &args); if (test->heapsz != NULL) push_arg(&args, "-H%s", test->heapsz); if (test->flags & F_VHPI) push_arg(&args, "--load=%s/../lib/vhpi_test.so%s", bin_dir, EXEEXT); } else push_arg(&args, "--no-save"); push_arg(&args, "-r"); if (test->flags & F_STOP) push_arg(&args, "--stop-time=%s", test->stop); if (test->flags & F_WAVE) push_arg(&args, "-w"); if (test->arrays > 0) push_arg(&args, "--dump-arrays=%u", test->arrays); else if (test->flags & F_ARRAYS) push_arg(&args, "--dump-arrays"); if (test->flags & F_GTKW) push_arg(&args, "-g"); if (test->flags & F_SHUFFLE) push_arg(&args, "--shuffle"); if (test->plusarg != NULL) push_arg(&args, "+%s", test->plusarg); push_arg(&args, "%s", test->name); } run_status_t status = run_cmd(outf, &args); if (test->flags & F_FAIL) { if (!(result = (status == RUN_FAILED))) { failed("expected error"); goto out_print; } } else if (!(result = (status == RUN_OK))) { failed(NULL); goto out_print; } if ((test->flags & F_COVER) && (test->flags & F_EXPORT)) { // Generate and check XML report push_arg(&args, "%s/nvc%s", bin_dir, EXEEXT); push_arg(&args, "--cover-export"); push_arg(&args, "--relative=%s" DIR_SEP "regress", test_dir); push_arg(&args, "--out=export.xml"); push_arg(&args, "--format=%s", test->export); char *unit = strdup(test->name); for (char *p = unit; *p; p++) *p = toupper((int)*p); push_arg(&args, "%s.ncdb", test->name); if (run_cmd(outf, &args) != RUN_OK) { failed("coverage report"); result = false; goto out_print; } else if (!file_exists("export.xml")) { failed("missing exported coverage report"); result = false; goto out_print; } #ifdef XMLLINT_PATH push_arg(&args, "%s", XMLLINT_PATH); push_arg(&args, "--noout"); push_arg(&args, "--nonet"); push_arg(&args, "--dtdvalid"); push_arg(&args, "%s/%s.dtd", test_dir, test->export); push_arg(&args, "export.xml"); if (run_cmd(outf, &args) != RUN_OK) { failed("XML lint failed"); result = false; goto out_print; } #else skipped("missing xmllint"); goto out_close; #endif push_arg(&args, "%s", DIFF_PATH); #if defined __MINGW32__ || defined __CYGWIN__ push_arg(&args, "--strip-trailing-cr"); #endif push_arg(&args, "-u"); push_arg(&args, "%s/regress/gold/%s.xml", test_dir, test->name); push_arg(&args, "export.xml"); if (run_cmd(outf, &args) != RUN_OK) { failed("XML mismatch"); result = false; goto out_print; } } else if ((test->flags & F_COVER) && !(test->flags & F_SHELL)) { // Generate coverage report char *unit = strdup(test->name); for (char *p = unit; *p; p++) *p = toupper((int)*p); push_arg(&args, "%s/nvc%s", bin_dir, EXEEXT); push_arg(&args, "--cover-report"); push_arg(&args, "--output=./html"); push_arg(&args, "%s.ncdb", test->name); push_arg(&args, "--cover-export"); push_arg(&args, "--relative=%s" DIR_SEP "regress", test_dir); push_arg(&args, "--output=export.xml"); //push_arg(&args, "--out=%s/regress/gold/%s.xml", test_dir, test->name); push_arg(&args, "--format=xml"); push_arg(&args, "%s.ncdb", test->name); free(unit); if (run_cmd(outf, &args) != RUN_OK) { failed("coverage report"); result = false; goto out_print; } else if (!file_exists("html/index.html")) { failed("missing coverage report index.html"); result = false; goto out_print; } push_arg(&args, "%s", DIFF_PATH); #if defined __MINGW32__ || defined __CYGWIN__ push_arg(&args, "--strip-trailing-cr"); #endif push_arg(&args, "-u"); push_arg(&args, "%s/regress/gold/%s.xml", test_dir, test->name); push_arg(&args, "export.xml"); if (run_cmd(outf, &args) != RUN_OK) { failed("XML mismatch"); result = false; goto out_print; } } if (test->flags & F_WAVE) { push_arg(&args, "%s/fstdump%s", bin_dir, EXEEXT); push_arg(&args, "-o"); push_arg(&args, "%s.dump", test->name); push_arg(&args, "%s.fst", test->name); if (run_cmd(outf, &args) != RUN_OK) { failed("fstdump"); result = false; goto out_print; } push_arg(&args, "%s", DIFF_PATH); #if defined __MINGW32__ || defined __CYGWIN__ push_arg(&args, "--strip-trailing-cr"); #endif push_arg(&args, "-u"); push_arg(&args, "%s/regress/gold/%s.dump", test_dir, test->name); push_arg(&args, "%s.dump", test->name); if (run_cmd(outf, &args) != RUN_OK) { failed("waveform mismatch"); result = false; goto out_print; } } if (test->flags & F_GTKW) { push_arg(&args, "%s", DIFF_PATH); #if defined __MINGW32__ || defined __CYGWIN__ push_arg(&args, "--strip-trailing-cr"); #endif push_arg(&args, "-u"); push_arg(&args, "%s/regress/gold/%s.gtkw", test_dir, test->name); push_arg(&args, "%s.gtkw", test->name); if (run_cmd(outf, &args) != RUN_OK) { failed("gtkw file mismatch"); result = false; goto out_print; } } if (test->flags & F_GOLD) { char goldname[PATH_MAX + 19]; snprintf(goldname, sizeof(goldname), "%s/regress/gold/%s.txt", test_dir, test->name); FILE *goldf = fopen(goldname, "r"); if (goldf == NULL) { failed("missing gold file"); result = false; goto out_close; } outf = freopen(OUTFILE, "r", outf); assert(outf != NULL); int lineno = 0; char gold_line[256]; char out_line[256]; while (fgets(gold_line, sizeof(gold_line), goldf)) { chomp(gold_line); lineno++; bool match = false; while (!match && fgets(out_line, sizeof(out_line), outf)) { chomp(out_line); match = strstr(out_line, gold_line) != NULL; } if (!match) { failed("no match line %d", lineno); set_attr(ANSI_FG_CYAN); printf("%s\n", gold_line); set_attr(ANSI_RESET); result = false; break; } } fclose(goldf); while (fgets(out_line, sizeof(out_line), outf)) { if (strstr(out_line, "*** Caught signal") != NULL || strstr(out_line, "fatal_trace") != NULL) { failed("crashed!"); result = false; break; } } } else if (test->flags & F_VERILOG) { outf = freopen(OUTFILE, "r", outf); assert(outf != NULL); bool found_passed = false, found_failed = false; char line[256]; while (fgets(line, sizeof(line), outf)) { found_passed |= (strstr(line, "PASSED") != NULL); found_failed |= (strstr(line, "FAILED") != NULL); } if (found_failed) { failed(NULL); result = false; } else if (found_failed && found_passed) { failed("printed both PASSED and FAILED"); result = false; } else if (!found_failed && !found_passed) { failed("did not print PASSED or FAILED"); result = false; } } out_print: if (result) { set_attr(ANSI_FG_GREEN); printf("ok\n"); set_attr(ANSI_RESET); } else { char line[256]; outf = freopen(OUTFILE, "r", outf); assert(outf != NULL); while (fgets(line, sizeof(line), outf)) fputs(line, stdout); } const double end_ns = get_timestamp_ns(); test->duration = end_ns - start_ns; out_close: fclose(outf); out_chdir: if (chdir(cwd) != 0) { set_attr(ANSI_FG_RED); printf("Failed to switch to %s: %s\n", cwd, strerror(errno)); set_attr(ANSI_RESET); return false; } #ifndef __MINGW32__ if (!remove_dir(dir)) { set_attr(ANSI_FG_RED); printf("Failed to remove directory %s: %s\n", dir, strerror(errno)); set_attr(ANSI_RESET); return false; } #endif return result; } static void checked_realpath(const char *path, char *output) { if (realpath(path, output) == NULL) { fprintf(stderr, "Error: failed to get real path for %s: %s\n", path, strerror(errno)); exit(EXIT_FAILURE); } } int main(int argc, char **argv) { checked_realpath(TESTDIR, test_dir); char argv0_path[PATH_MAX]; checked_realpath(argv[0], argv0_path); strncpy(bin_dir, dirname(argv0_path), sizeof(bin_dir) - 1); is_tty = isatty(STDOUT_FILENO); #ifdef __MINGW32__ if (!is_tty) { // Handle running under MinTty HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); const size_t size = sizeof(FILE_NAME_INFO) + sizeof(WCHAR) * MAX_PATH; FILE_NAME_INFO *nameinfo = malloc(size); if (!GetFileInformationByHandleEx(hStdOut, FileNameInfo, nameinfo, size)) win32_error("GetFileInformationByHandle"); if ((wcsncmp(nameinfo->FileName, L"\\msys-", 6) == 0 || wcsncmp(nameinfo->FileName, L"\\cygwin-", 8) == 0) && wcsstr(nameinfo->FileName, L"pty") != NULL) is_tty = true; free(nameinfo); } #endif setenv("NVC_LIBPATH", "", 1); char lib_dir[PATH_MAX + 7]; snprintf(lib_dir, sizeof(lib_dir), "%s/../lib", bin_dir); setenv("NVC_IMP_LIB", lib_dir, 1); setenv("NVC_LIBPATH", lib_dir, 1); #ifdef __MINGW32__ SetConsoleOutputCP(65001); #else setenv("LANG", "en_US.UTF-8", 1); #endif setenv("NVC_COVER_TIMESTAMP", "0", 1); setenv("NVC_COVER_VERSION", "TEST", 1); if (getenv("QUICK")) return 0; bool print_stats= false; int c; while ((c = getopt(argc, argv, "sjp")) != -1) { switch (c) { case 's': print_stats = true; break; case 'j': force_jit = true; break; case 'p': force_precompile = true; break; case '?': return EXIT_FAILURE; default: abort(); } } if (!parse_test_list()) return EXIT_FAILURE; char *newpath = xasprintf("%s:%s", bin_dir, getenv("PATH")); #ifndef __MINGW32__ setenv("PATH", newpath, 1); setenv("TESTDIR", test_dir, 1); #endif free(newpath); unsigned mask = 0; for (int i = optind; i < argc; i++) { if (strcmp(argv[i], "wave") == 0) mask |= F_WAVE; else if (strcmp(argv[i], "vhpi") == 0) mask |= F_VHPI; else if (strcmp(argv[i], "psl") == 0) mask |= F_PSL; else if (strcmp(argv[i], "cover") == 0) mask |= F_COVER; else if (strcmp(argv[i], "vlog") == 0) mask |= F_VERILOG | F_MIXED; } int fails = 0; for (test_t *it = test_list; it != NULL; it = it->next) { bool found; if (argc > optind) { found = !!(it->flags & mask); for (int i = optind; i < argc && !found; i++) { if (isdigit((int)argv[i][strlen(argv[i]) - 1])) found = strcmp(it->name, argv[i]) == 0; else found = strstr(it->name, argv[i]) != NULL; } } else found = true; if (found && !run_test(it)) fails++; } if (print_stats) { test_t *slowest = test_list; double sum = 0.0; int count = 0; for (test_t *it = test_list; it != NULL; it = it->next) { if (it->duration == 0.0) continue; else if (it->duration > slowest->duration) slowest = it; count++; sum += it->duration; } printf("%d tests in %.2f seconds; ", count, sum); if (slowest->duration > 2 * (sum / count)) printf("slowest test was %s (%.1f ms); ", slowest->name, slowest->duration * 1000.0); printf("average %.1f ms\n", (sum / count) * 1000.0); set_attr(ANSI_RESET); } if (fails > 0) { set_attr(ANSI_FG_RED); set_attr(ANSI_BOLD); printf("%d failures!\n", fails); set_attr(ANSI_RESET); return EXIT_FAILURE; } return 0; } nvc-r1.17.1/test/run_vests.rb000077500000000000000000000103441504111170000161000ustar00rootroot00000000000000#!/usr/bin/env ruby require 'rubygems' require 'pathname' require 'colorize' require 'timeout' require 'open3' require 'tmpdir' TestDir = Pathname.new(__FILE__).realpath.dirname BuildDir = Pathname.new(ENV['BUILD_DIR'] || Dir.pwd).realpath LibPath = "#{BuildDir}/lib/std:#{BuildDir}/lib/ieee" VestsDir = Pathname.new(ARGV[0] || "#{TestDir}/vests").realpath Prefix = "#{VestsDir}/vhdl-93" GitRev = IO::popen("git rev-parse --short HEAD").read.chomp Tool = ENV['NVC'] || 'nvc' Billowitch = "#{Prefix}/billowitch" ExpectFails = 32 ENV['NVC_COLORS'] = 'always' def run_cmd(c, expfail) Open3.popen2e(c) do |i, oe, t| i.close output = nil begin Timeout::timeout(5) do output = oe.read end rescue Timeout::Error Process.kill("KILL", t.pid) output = 'Timeout!' end status = t.value if output =~ /Caught signal/ or (c =~ /-r/ and output =~ /FAILED TEST/) then puts puts c.magenta puts output return false elsif status != 0 and output =~ /PASSED TEST/ then return true # Testing assertion failure elsif status != 0 and not expfail then puts puts c.magenta puts output return false elsif status == 0 and expfail then puts puts c.magenta puts output puts "expected failure!".magenta return false end return true end end def guess_top(src) best = nil File.open(src).each_line do |l| if m = l.match(/^(?:entity|configuration) *(\w+)/i) then best = m.captures[0] end end return best end unless Dir.exist? VestsDir puts "VESTs source missing from #{VestsDir}" puts puts "You can download this using" puts " git clone https://github.com/nickg/vests.git" exit 1 end fails = 0 passes = 0 # # Billowitch, compliant # Dir.mktmpdir do |tmpdir| Dir.chdir tmpdir puts puts "Billowitch, compliant".blue.bold puts File.open("#{Billowitch}/compliant/compliant.exp").each_line do |line| next unless m = line.match(/^run_compliant_test +(\w+.vhdl?)(.*)(?:#.*)?$/) tc = m.captures[0] io = m.captures[1] Dir.mktmpdir do |workdir| f = File.realpath "#{Billowitch}/compliant/#{tc}" top = guess_top f cmd = "#{Tool} --std=1993 --work=work:#{workdir}/work -a #{f} -e --jit --no-save #{top} -r" result = run_cmd cmd, false if result then passes += 1 print '+'.green else fails += 1 end end end end # # Billowitch, non-compliant, analyser failure # Dir.mktmpdir do |tmpdir| Dir.chdir tmpdir puts puts "Billowitch, non-compliant, analyzer failure".blue.bold puts File.open("#{Billowitch}/non_compliant/analyzer_failure/non_compliant.exp").each_line do |line| next unless m = line.match(/^run_non_compliant_test +(\w+.vhdl?)(.*)(?:#.*)?$/) tc = m.captures[0] io = m.captures[1] Dir.mktmpdir do |workdir| f = File.realpath "#{Billowitch}/non_compliant/analyzer_failure/#{tc}" cmd = "#{Tool} --std=1993 --work=work:#{workdir}/work -a #{f}" result = run_cmd cmd, true if result then passes += 1 print '+'.green else fails += 1 end end end end # # Billowitch, non-compliant, simulator failure # Dir.mktmpdir do |tmpdir| Dir.chdir tmpdir puts puts "Billowitch, compliant, simulator failure".blue.bold puts File.open("#{Billowitch}/non_compliant/simulator_failure/non_compliant.exp").each_line do |line| next unless m = line.match(/^run_non_compliant_test +(\w+.vhdl?)(.*)(?:#.*)?$/) tc = m.captures[0] io = m.captures[1] Dir.mktmpdir do |workdir| f = File.realpath "#{Billowitch}/non_compliant/simulator_failure/#{tc}" top = guess_top f cmd = "#{Tool} --std=1993 --work=work:#{workdir}/work -a #{f} -e --jit --no-save #{top} -r" result = run_cmd cmd, true if result then passes += 1 print '+'.green else fails += 1 end end end end puts puts "#{passes} passes" puts "#{fails} failures" File.open("#{VestsDir}/HISTORY", 'a') do |f| f.printf("%20s %10s %4d passes %4d failures\n", Time.new.ctime, GitRev, passes, fails) end if fails > ExpectFails then puts "Expected #{ExpectFails} failures but have #{fails}" exit 1 end nvc-r1.17.1/test/sdf/000077500000000000000000000000001504111170000142725ustar00rootroot00000000000000nvc-r1.17.1/test/sdf/parse1.sdf000066400000000000000000000001431504111170000161610ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE I1) ) )nvc-r1.17.1/test/sdf/parse10.sdf000066400000000000000000000005541504111170000162470ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE B2.C2) (DELAY (ABSOLUTE (IOPATH (posedge clk_a) x_q (0)) (IOPATH (negedge clk_b[17]) y_q (0)) (IOPATH (negedge clk_c[2:3]) z_q[1:2] (0)) ) ) ) )nvc-r1.17.1/test/sdf/parse11.sdf000066400000000000000000000004401504111170000162420ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE B2.C2) (DELAY (ABSOLUTE (IOPATH a b (17) ) (IOPATH c d ((2.3) (1.2)) ) (IOPATH e f ((0) (1) (2.5)) ) ) ) ) )nvc-r1.17.1/test/sdf/parse12.sdf000066400000000000000000000005321504111170000162450ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE B2.C2) (DELAY (ABSOLUTE (IOPATH g h (1:2.4:3) ((:4.7:5) (6.1::7) (8.9:9:)) ((10.00007::) (:11.500:) (::12.99)) ) (IOPATH i j () () () () () () () () () () () () ()) ) ) ) )nvc-r1.17.1/test/sdf/parse13.sdf000066400000000000000000000005321504111170000162460ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "Fancy SDF super version 1.0 followed by 2.1 that shall be ignored") (DATE "Dec 17, 1991 14:49:48") (DESIGN "testchip") (VENDOR "Big Chips Inc.") (PROGRAM "New VHDL Compiler") (PROGRAM "Duplicit program entry") (VERSION "1.10.2") (CELL (CELLTYPE "AND2") (INSTANCE I1) ) )nvc-r1.17.1/test/sdf/parse14.sdf000066400000000000000000000006471504111170000162560ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "DFF") (INSTANCE cache.mem3.bndrx.I103) (LABEL (ABSOLUTE (TCLK_Q (7.54:12.14:19.78) (6.97:13.66:18.47)) (TSETUP_D_CLK (3:4:5.6)) ) (INCREMENT (TCLK_QB (8.16:13.74:20.25) (7.63:14.83:21.42)) (THOLD_D_CLK (4:5.6:7)) ) ) ) )nvc-r1.17.1/test/sdf/parse15.sdf000066400000000000000000000005221504111170000162470ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "DFF") (INSTANCE hierarchy_example) (DELAY (PATHPULSE (0.4)) (PATHPULSE (0.1) (0.5)) (PATHPULSE my_inst.my_sub_inst.a my_inst_my_sub_inst.b (5.4)) (PATHPULSEPERCENT top.in top.out (10.2) (11.9)) ) ) )nvc-r1.17.1/test/sdf/parse16.sdf000066400000000000000000000005011504111170000162450ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE i_and) (DELAY (ABSOLUTE (COND i_and.b==1'b0 (IOPATH i_and.a i_and.y (0.5) )) (COND "My condition name" i_and.b=='b1 (IOPATH i_and.a i_and.y (0.4) )) ) ) ) )nvc-r1.17.1/test/sdf/parse17.sdf000066400000000000000000000015311504111170000162520ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (DIVIDER / ) (CELL (CELLTYPE "AND2") (INSTANCE i_and) (DELAY (ABSOLUTE (COND a (IOPATH x y ())) (COND a/b/c/d (IOPATH x y ())) (COND (((((e/f/g/h))))) (IOPATH x y ())) (COND +(x/y/z) (IOPATH x y ())) (COND -(x/y/z) (IOPATH x y ())) (COND !(x/y/z) (IOPATH x y ())) (COND ~(x/y/z) (IOPATH x y ())) (COND &(x/y/z) (IOPATH x y ())) (COND ~&(x/y/z) (IOPATH x y ())) (COND |(x/y/z) (IOPATH x y ())) (COND ~|(x/y/z) (IOPATH x y ())) (COND ^(x/y/z) (IOPATH x y ())) (COND ^~(x/y/z) (IOPATH x y ())) (COND ~^(x/y/z) (IOPATH x y ())) ) ) ) )nvc-r1.17.1/test/sdf/parse18.sdf000066400000000000000000000030711504111170000162540ustar00rootroot00000000000000(DELAYFILE (SDFVERSION "4.0") (CELL (CELLTYPE "AND2") (INSTANCE i_and) (DELAY (ABSOLUTE (COND a.b.c[5]+x.y.z[1] (IOPATH x y ())) (COND (a.b.c[5])-x.y.z[2] (IOPATH x y ())) (COND a.b.c[5]*(x.y.z[2]) (IOPATH x y ())) (COND (a.b.c[5])/(x.y.z[2]) (IOPATH x y ())) (COND (a.b.c%x.y.z) (IOPATH x y ())) (COND (a.b.c==(x.y.z)) (IOPATH x y ())) (COND ((a.b.c)!=x.y.z) (IOPATH x y ())) (COND ((a.b.c)===(x.y.z)) (IOPATH x y ())) (COND (((a.b.c))!==x.y.z) (IOPATH x y ())) (COND a.b.c&&x.y.z (IOPATH x y ())) (COND a.b.c||x.y.z (IOPATH x y ())) (COND a.b.cx.y.z (IOPATH x y ())) (COND a.b.c>=x.y.z (IOPATH x y ())) (COND a.b.c&x.y.z (IOPATH x y ())) (COND a.b.c|x.y.z (IOPATH x y ())) (COND a.b.c^x.y.z (IOPATH x y ())) (COND a.b.c^~x.y.z (IOPATH x y ())) (COND a.b.c~^x.y.z (IOPATH x y ())) (COND a.b.c>>x.y.z (IOPATH x y ())) (COND a.b.c<) of integer; type int_vec_ptr is access int_vec; type string_ptr is access string; end package; package body p is procedure test is variable v : int_ptr; variable i : integer; variable r : rec_ptr; variable a : int_vec_ptr; variable s : string_ptr; begin v := null; -- OK i := null; -- Error deallocate(v); -- OK v := new integer; -- OK v := new integer'(5); -- OK v := new 5; -- Error v := new i; -- Error v.all := 5; -- OK v := 5; -- Error i := v.all + 5; -- OK r := new rec; -- OK r.all.value := 1; -- OK r.value := 1; -- OK r.link := r; -- OK r.link := r.all; -- Error i := r.value; -- OK r := r.all.link; -- OK a := new int_vec(1 to 3); -- OK a.all(5) := 2; -- OK a(5) := 2; -- OK a(1 to 2) := (1, 2); -- OK s := new string'(""); -- OK s := new integer'(1); -- Error s := new s(1 to 3); -- Error end procedure; procedure test2(x : inout rec_ptr) is begin x.value := x.value + 1; end procedure; procedure test3 is type a; type a is access integer; -- OK variable v : a; -- OK begin end procedure; type int_ptr_array is array (integer range <>) of int_ptr; type int_ptr_array_ptr is access int_ptr_array; procedure alloc_ptr_array(x : inout int_ptr_array_ptr) is begin x := new int_ptr_array; -- Error x := new int_ptr_array(1 to 3); -- OK x.all := (null, null, null); -- OK end procedure; procedure tets4 is type bvp is access bit_vector; variable x : bvp(1 to 4) := new bit_vector'("1010"); -- OK variable y : int_ptr(1 to 3) := int_ptr'(null); -- Error begin end procedure; procedure test5 is type foo; variable f : foo; -- Error begin end procedure; procedure test6 is variable v : int_vec(1 to 3); begin v(1) := new integer'(5); -- Error end procedure; procedure test7 is type a; type a_ptr is access a; variable p : a_ptr; begin p := new a; -- Error end procedure; procedure test8 is variable p : int_vec(1 to 3); begin for i in p.all'range loop -- Error end loop; end procedure; procedure test9 is type pt is protected procedure dummy; end protected; type pt is protected body procedure dummy is begin end procedure; end protected body; type ptp is access pt; -- Error type ft is file of natural; -- OK type ftp is access ft; -- Error begin end procedure; procedure test10 (p : out rec_ptr) is begin p.value := 1; -- Error end procedure; end package body; nvc-r1.17.1/test/sem/afunc.vhd000066400000000000000000000046411504111170000161060ustar00rootroot00000000000000entity afunc is end entity; architecture test of afunc is function get return bit_vector is begin return X"10"; end function; function get2(x : integer := 0) return bit_vector is begin return "01"; end function; function get3(x, y : integer := 0) return bit_vector is begin return "01"; end function; begin process is begin assert get(0) = '0'; -- OK assert '0' = get(0); -- OK assert get2(0) = "01"; -- OK assert "01" = get2(0); -- OK assert get2(0) = '0'; -- OK assert '0' = get2(0); -- OK assert get3(1, 2) & '1' = "01"; -- OK wait; end process; -- Reduced from VESTS case tc1072.vhd b1: block is TYPE A IS ARRAY (NATURAL RANGE <>) OF INTEGER; SUBTYPE A6 IS A (1 TO 6); SUBTYPE A8 IS A (1 TO 8); FUNCTION func1 (a,b : INTEGER := 3) RETURN A6 IS BEGIN IF (a=3) AND (b=3) THEN RETURN (1,2,3,4,5,6); ELSE IF (a=3) THEN RETURN (11,22,33,44,55,66); ELSE RETURN (111,222,333,444,555,666); END IF; END IF; END; begin TESTING: PROCESS VARIABLE q : A8; BEGIN q(1) := func1(3)(1); -- OK end process; end block; -- Seen in OSVVM process is function get (prefix : string := ""; n : integer := 0) return string is begin return prefix; end function; constant s1 : string := "foo" & get("hello") & '1'; -- OK -- constant s2 : string := "foo" & get(1) & '1'; -- OK constant s3 : string := get(n => 5) & "1"; -- OK type pt is protected function get1 (prefix : string := "") return string; procedure test; end protected; type pt is protected body function get1 (prefix : string := "") return string is begin return prefix; end function; procedure test is constant c1 : string := "foo" & get1("hello") & '1'; -- OK constant c2 : string := "foo" & get1(1) & '1'; -- OK begin end procedure; end protected body; begin end process; end architecture; nvc-r1.17.1/test/sem/agg2008.vhd000066400000000000000000000050331504111170000160560ustar00rootroot00000000000000entity agg2008 is end entity; architecture test of agg2008 is begin p1: process is variable x : integer_vector(1 to 4); variable y, z : integer_vector(1 to 2); begin x := ( integer_vector'(1, 2), integer_vector'(3, 4) ); -- OK y := ( 5, 6 ); -- OK z := ( 7, 8 ); -- OK x := ( y, z ); -- OK x := ( 1, 2, y, 3 ); -- OK z := ( 1, 2, 1.2 ); -- Error z := ( 1 => true, 2 => 5 ); -- Error x := ( (1, 2), z ); -- OK x := ( 1 => y, 2 => z ); -- Error x := ( 1 to 4 => x ); -- OK x := ( 1 to 2 => y, 3 to 4 => z ); -- OK wait; end process; p2: process is type int2d is array (natural range <>, natural range <>) of integer; variable x : int2d(1 to 2, 1 to 2); begin x := ( (1, 2), (3, 4) ); -- OK x := ( x, x ); -- Error end process; b2: block is signal vec : bit_vector(7 downto 0); begin vec <= (3 downto 0 => "111", others => '0'); -- OK (at parse time) end block; p3: process is type int_ptr is access integer; type int_ptr_array is array (integer range <>) of int_ptr; type int_ptr_array_ptr is access int_ptr_array; variable x : int_ptr_array_ptr; begin x.all := (null, null, null); -- OK end process; p4: process is type int_vec2 is array (natural range <>) of integer_vector; -- OK constant a : int_vec2(1 to 2)(1 to 2) := ( -- OK ((1, 2), (3, 4)), ((5, 6), (7, 8)) ); begin end process; p5: process is type unit_spec_t is record name : string(1 to 3); length : positive; unit : time; end record; type unit_map_t is array (natural range <>) of unit_spec_t; constant unit_map : unit_map_t := ( ( "fs ", 2, fs ), ( "ps ", 2, ps ) ); -- OK begin end process; p6: process is type t_bv_array is array (natural range <>) of bit_vector; subtype t_byte_array is t_bv_array(open)(7 downto 0); -- OK variable v1 : t_byte_array; -- Error variable v2 : t_byte_array(1 to 3); -- OK variable b3 : integer(open); -- Error variable v3 : t_byte_array(1 to 3)(4 to 5); -- Error subtype t_error1 is t_byte_array(1 to 3)(4 to 5); -- Error begin end process; end architecture; nvc-r1.17.1/test/sem/alias.vhd000066400000000000000000000073351504111170000161060ustar00rootroot00000000000000entity e is end entity; architecture test of e is alias my_int is integer; -- OK signal x : my_int; -- OK subtype s is my_int range 1 to 5; -- OK alias my_bad : integer is integer; -- Error alias ax is x; -- OK signal y : ax; -- Error alias as is s; -- OK signal z : as; -- OK function foo (x : bit) return integer; function foo (x : character) return integer; alias foo_bit is foo [bit return integer]; -- OK alias foo_char is foo [character return integer]; -- OK alias foo_int is foo [integer return integer]; -- Error alias foo_p is foo [bit]; -- Error alias foo_a is foo(1) [bit return integer]; -- Error alias foo_b is foo [blah return integer]; -- Error procedure bar (x : bit); procedure bar (x : character); alias bar_bit is bar [bit]; -- OK alias bar_char is bar [character]; -- OK alias bar_int is bar [integer]; -- Error procedure test is begin assert foo_bit('1') = 1; -- OK assert foo_char('1') = 1; -- OK bar_bit('1'); -- OK bar_char('1'); -- OK assert foo('1') = 1; -- Error assert foo_int(1) = 1; -- Error bar_bit(character'( '1' )); -- Error bar_bit(character'(1)); -- Error end procedure; type bv_ptr is access bit_vector; procedure test2(variable x : bv_ptr) is variable v : bit_vector(1 to 10); alias va is v(x'left); -- Error begin end procedure; procedure maybe_use_last_value(signal x : my_int); procedure proc is begin maybe_use_last_value(ax); end procedure; type int_array is array (integer range <>) of integer; alias int_vector is int_array; type int_array_2 is array (integer range <>) of integer; constant c1 : int_array_2(1 to 3) := (1, 2, 3); constant c2 : int_vector(1 to 3) := int_vector(c1); -- OK subtype bad is blah blah blah; -- Error function foo_bad (x : bit) return bad; -- OK function foo_bad (x : bit) return bad; -- Error (suppressed) alias foo_o is foo_bad [bit return bad]; -- OK alias foo_o is foo_bad [character return bad]; -- Error (suppressed) alias my_now is std.standard.now [return delay_length]; -- OK alias my_eq is std.standard."=" [bit, bit return boolean]; -- OK type int_mat2d is array (integer range <>, integer range <>) of integer; constant c3 : int_mat2d(1 to 2, 1 to 2) := ((1, 2), (3, 4)); alias c2_alias is c3; -- Error (in '93) constant c4 : integer := int_vector; -- Error type line is access string; procedure access_alias ( variable p : inout line ) is variable l : line; alias a : string(1 to 3) is l.all; -- Error alias b : string(1 to p'length) is p.all; -- Error begin end procedure; constant LEN : natural := 20 ; function doit return bit_vector is alias length : natural is LEN ; -- Following is OK, from UVVM constant rv : bit_vector(length-1 downto 0) := (length-1 => '1', others =>'0') ; begin return rv ; end function ; procedure double_alias is type r is record x, y : integer; end record; alias a1 is r; alias a2 is a1; -- OK variable v : a2; -- OK begin end procedure; function less (x, y : int_vector) return boolean; alias "<=" is less[int_vector, int_vector return boolean]; -- OK constant c5 : boolean := int_vector'(1, 2) <= (1, 3); -- OK begin end architecture; nvc-r1.17.1/test/sem/alias2.vhd000066400000000000000000000030471504111170000161640ustar00rootroot00000000000000entity alias2 is end entity; architecture test of alias2 is type t_test is protected procedure increment; impure function get return natural; impure function get_bits return rv of bit_vector; end protected; type t_test is protected body variable count : natural; procedure increment is begin count := count + 1; end procedure; impure function get return natural is begin return count; end function; impure function get_bits return rv of bit_vector is begin return (rv'range => '1'); end function; end protected body; procedure foobar is begin end procedure; shared variable pt : t_test; alias inc is pt.increment []; -- OK alias get is pt.get [return natural]; -- OK alias bad1 is pt.foobar []; -- Error alias bad2 is xx.increment []; -- Error alias bits is pt.get_bits [return bit_vector]; -- OK alias bad3 is pt.increment; -- Error alias fb1 is foobar []; -- OK alias fb2 is fb1 []; -- OK alias inc2 is inc []; -- OK begin tb: process is begin inc; -- OK assert get = 1; -- OK assert bits = "101"; -- Error assert pt.get_bits = "111"; -- Error fb2; -- OK inc2; -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/altera1.vhd000066400000000000000000000003151504111170000163350ustar00rootroot00000000000000entity altera1 is generic (g : integer); type t is array (1 to 2**g) of bit; end entity; architecture a of altera1 is constant c : t := (others => '0'); -- Crash here begin end architecture; nvc-r1.17.1/test/sem/ambiguous.vhd000066400000000000000000000124431504111170000170040ustar00rootroot00000000000000entity e is end entity; architecture a of e is type foo is (a, b, c); type bar is (a, b, c); signal x : foo := a; signal y : bar := b; begin process is begin x <= c; y <= a; end process; process is begin x <= foo'(a); y <= bar'(a); end process; p3: process is type baz is (a, b, c, d); variable z : baz := b; begin z := d; -- OK z := a; -- OK x <= a; -- OK end process; process is begin x <= bar'(c); -- Error! end process; process is type small is range 10 downto -5; variable z : small := -5; variable a : boolean; begin a := z = -5; -- OK a := -5 = z; -- OK end process; process is variable a : bit_vector(3 downto 0); variable x : character; variable b : boolean; begin b := x = '1'; -- OK b := '1' = x; -- OK b := a = ('0', '1', '0', '1'); -- OK b := ('0', '1', '0', '1') = a; -- OK b := ('0', '1') = ('0', '1'); -- Error end process; process is subtype some_foo is foo range a to b; -- OK subtype less_foo is some_foo range a to a; subtype all_foo is foo; variable f : some_foo; variable g : all_foo; variable h : less_foo; begin f := a; -- OK f := c; -- OK at semantic check g := f; -- OK g := h; -- OK end process; process is type weird is ( '¢', '¦' ); variable x : weird; variable y : character; begin x := '¢'; -- OK y := '¢'; -- OK report "foo¥bar"; -- OK end process; process is type t is (false, true); begin for i in false to false loop -- Error end loop; end process; process is function now return integer; begin for i in now to now loop -- Error end loop; end process; process is function false return integer is begin return 1; end function; begin for i in false to false loop -- Error end loop; end process; process is function "="(a, b : foo) return boolean is begin return false; end function; variable x, y : foo; begin assert x = y; -- OK end process; end architecture; package pack is type my_int is range 1 to 10; end package; use work.pack.all; package pack2 is function "<"(a, b: my_int) return boolean; end package; use work.pack2.all; use work.pack.all; architecture a2 of e is function ">"(a, b: my_int) return boolean; begin process is variable x, y : my_int; begin assert x > y; -- OK assert x < y; -- Error end process; process is function uniform (a, b : real) return real; type disttype is (none, uniform, other); variable v : disttype; variable r : real; begin case v is when none | uniform => r := uniform(1.0, 2.0); -- OK when others => r := 0.0; end case; end process; end architecture; architecture a3 of e is type unsigned is array (natural range <>) of bit; function "*"(a, b : unsigned) return bit_vector; function "*"(a, b : bit_vector) return bit_vector; function "*"(a, b : unsigned) return unsigned; function "+"(a, b : unsigned) return bit_vector; function "+"(a, b : bit_vector) return bit_vector; function "+"(a, b : unsigned) return unsigned; signal x, y, z : bit_vector(7 downto 0); begin x <= unsigned(y) * unsigned(z) + unsigned(z); end architecture; -- Test case reduced from Altera model architecture a4 of e is function resolved (x : bit_vector) return bit; subtype rbit is resolved bit; type rbit_vector is array (natural range <>) of rbit; function "and" (x, y : rbit_vector) return rbit_vector; signal mdio_wr : rbit; signal reg_addr : rbit_vector(15 downto 0); begin process is begin assert ((X"0000" & mdio_wr) and reg_addr) /= X"0000"; end process; end architecture; architecture issue61 of e is type ubit_vector is array (natural range <>) of bit; begin process is variable x: bit_vector(4 downto 0); variable y: ubit_vector(6 downto 0); begin y := ubit_vector(x & ('0' & '1')); y := ubit_vector((x & '0') & '1'); y := ubit_vector(x & '0' & '1'); wait; end process; end architecture; architecture cassign of e is function "="(x, y : bit) return bit; signal x, y, z : bit; begin x <= '1' when y = z else '0'; -- OK end architecture; architecture expect_fail of e is type t is (C, B, A); type t_vec is array (1 to 2) of t; -- Type of aggregate must be determinable from the context constant x : boolean := (A, A) < (C, C); -- Error begin end architecture; -- -*- coding: latin-1; -*- nvc-r1.17.1/test/sem/array.vhd000066400000000000000000000336101504111170000161260ustar00rootroot00000000000000package p is type int_array is array (integer range <>) of integer; type ten_ints is array (1 to 10) of integer; end package; entity ent is end entity; use work.p.all; architecture arch of ent is -- All these declarations are OK signal x : int_array(1 to 5); signal y : ten_ints; signal z : int_array(1 to 3) := ( 0, 1, 2 ); signal m : int_array(1 to 3) := ( 1 to 3 => 0 ); alias a : int_array(2 to 3) is x(2 to 3); begin process is -- Positional elements cannot follow named variable e : int_array(1 to 2) := ( 0 => 1, 2 ); begin end process; process is -- Others element must be last variable e : ten_ints := ( others => 5, 1 => 2 ); begin end process; process is -- Only one others element variable e : ten_ints := ( others => 5, others => 2 ); begin end process; process is -- Single element aggregates must be named variable a : int_array(0 to 0) := ( 0 => 1 ); variable b : int_array(0 to 0) := ( 1 ); -- Error begin end process; process is variable a : integer; begin x(0) <= 1; -- OK x <= ( others => 2 ); -- OK x <= 1; -- RHS not array a := x(0); -- OK a := x; -- LHS not array end process; process is variable b : boolean; begin b := z = m; -- OK b := z /= m; -- OK b := z = y; -- Different types end process; process is begin x(1 to 3) <= z; x(1 to 2) <= z(1 to 2); x(x'range) <= (others => 0); end process; process is begin a(2) <= 4; -- OK y(2) <= 1; -- OK end process; process is type int2d is array (1 to 10, 1 to 4) of integer; variable w : int2d := ( 1 => ( 1, 2, 3, 4 ), 2 => ( others => 5 ), others => ( others => 0 ) ); begin w(2, 4) := 6; w(6) := 6; -- Too few indices w(6, 7, 2) := 2; -- Too many indices end process; process is type letter is (A, B, C); type larray is array (letter) of integer; variable w : larray; begin w(A) := 2; -- OK w(5) := 66; -- Wrong index type end process; process is variable n : int_array(1 to 3) := ( 0, 1 => 1, others => 2 ); -- Error begin end process; process is variable x : integer; constant c : integer := 3; variable y : int_array(1 to 3); begin y := ( 1 => 2, 2 => 3, x => 5 ); -- Error y := ( 1 => 2, 2 => 3, c => 5 ); -- OK end process; process is variable x : integer; variable y : int_array(3 downto 0); begin x(1 to 3) := (others => 4); -- Error y(1 to 3) := (others => 4); -- Error assert y = (others => 4); -- Error end process; process is subtype four_ints is int_array(1 to 4); variable x : four_ints; begin x(1 to 3) := (1, 2, 3); -- OK x(2) := 1; -- OK x(3 downto 1) := (others => '0'); -- Error assert x(2) = 5; -- OK end process; process is function foo(size: integer) return int_array is subtype rtype is int_array(size-1 downto 0); variable result: rtype; begin assert result(0) = 1; return result; end; begin end process; process is function plus(A, B: int_array) return int_array is variable BV, sum: int_array(A'left downto 0); begin return sum; end; begin end process; process is subtype int4_t is int_array(1 to 4); type foo_t is array (integer'left to 10) of integer; variable v : int_array(foo_t'range); variable u : foo_t; begin assert int4_t'length = 4; assert foo_t'length = 50; end process; process is subtype a_to_c is character range 'a' to 'c'; type abc_ints is array (a_to_c) of integer; variable v : abc_ints; begin assert abc_ints'length = 3; v('b') := 2; end process; process is type bit_map is array (bit) of integer; variable b : bit_map := ( '0' => 5, '1' => 6 ); type bit_map2 is array (bit, 0 to 1) of integer; variable c : bit_map2 := ( '0' => (0 => 0, 1 => 1), '1' => (0 => 2, 1 => 3) ); begin b('0') := 6; c('1', 1) := 5; end process; process is constant c : ten_ints := (ten_ints'range => 5); variable v : ten_ints; begin v := (v'range => 6); -- OK end process; process is type mybit is ('0', '1'); type bit_map is array (bit range '0' to '1') of integer; variable v : bit_map; variable b : bit; begin v(b) := 1; -- OK end process; process is begin assert x'length(1) = 5; -- OK end process; process is type bad is array (integer range <>) of int_array; -- Error begin end process; process is type int2d is array (natural range <>, natural range <>) of integer; constant c : int2d := ( (0, 1, 2), (0, 1, 2) ); -- OK constant d : int2d := ( (0, 1), (5, 6, 7) ); -- OK (at sem) constant e : int2d := ( (0, 1), (others => 2) ); -- Error begin end process; process is variable b1 : bit_vector(7 downto 0); begin b1 := b1 sll 1; b1 := b1 srl 2; b1 := b1 sla 0; b1 := b1 sra 1; b1 := b1 rol 6; b1 := b1 ror 1; end process; process is variable i : integer; alias xi is x(1 to i); -- Error alias zi : integer is z(i); -- Error alias xx : integer is x(1 to 2); -- Error begin end process; process is variable i : integer; begin i(6) := 2; -- Error end process; process is constant c : integer := -1; type bad_range is array (-1 to -5) of integer; -- OK type ok_range is array(c to -5) of integer; -- OK begin end process; process is subtype bad_sub1 is int_array(1 to 3, 2 to 5); -- Error begin end process; process is type element is array (integer range 0 to 1) of bit_vector( 0 to 1); begin end process; process is type ten_ten_ints is array (1 to 10) of ten_ints; type int2d is array (natural range <>, natural range <>) of integer; variable t1, t2 : ten_ten_ints; variable m1, m2 : int2d(1 to 3, 1 to 3); begin assert t1 = t2; -- OK assert t1 /= t2; -- OK assert t1 < t2; -- Error assert t1 > t2; -- Error assert m1 = m2; -- OK assert m1 < m2; -- Error end process; process is subtype num_array is int_array; -- OK subtype bad_array is not_here; -- Error variable a1 : num_array(1 to 3); -- OK variable a2 : num_array; -- Error begin end process; process is constant k : integer := 5; type a is array (k) of integer; -- Error variable v : a; -- Error begin end process; process is type ibv is array (boolean range <>) of integer; variable a : ibv(false to true); begin a(false) := 1; -- OK a(4) := 2; -- Error a(false to false) := (others => 1); -- OK end process; process is subtype r is integer range 1 to 3; begin x(r'range) <= (others => 1); x(r) <= (others => 1); end process; process is subtype str is string; constant x : str := "hello"; -- OK begin end process; process is type barry2d is array (boolean range <>, boolean range <>) of integer; variable b : barry2d(false to true, false to true); type ibarray2d is array (integer range <>, boolean range <>) of integer; variable ib : ibarray2d(1 to 5, false to true); begin b(barry2d'left(1), barry2d'left(2)) := 5; -- OK ib(integer'(5), boolean'(true)) := 1; -- OK ib(ibarray2d'left(1), ibarray2d'left(2)) := 5; -- OK end process; process is type enum1 is (m1, m2, m3, m4, m5); type abase is array (enum1 range <>) of boolean; subtype a1 is abase(enum1 range m1 to m5); variable V1 : A1; begin assert v1 = (false, false, false); -- OK end process; process is variable x : int_array(1 to 3); begin x := (1 | 2 to 3 => 5); -- OK end process; process is variable b : bit_vector(1 to 3); -- OK begin b := "1fe"; -- Error end process; issue86: block is type integer_vector is array (natural range <>) of integer; subtype ElementType is integer ; subtype ArrayofElementType is integer_vector; function inside0 (constant E : ElementType; constant A : in ArrayofElementType) return boolean is begin for i in A'range loop -- OK (issue #86) if E = A(i) then return TRUE; end if ; end loop ; return FALSE ; end function inside0; begin end block; process is subtype bad is ten_ints (1 to 4); -- Error constant c : ten_ints(2 to 4) := (others => 0); -- Error begin end process; process is type e is (one, two, three); type arr is array (e range <>) of integer; constant c : arr := (1, 2, 3, 4); begin end process; no_file_types: block is type t_int_file is file of integer; type t_file_array is array (0 to 1) of t_int_file; -- Error begin end block; billowitch_tc586: block is type real_cons_vector is array (15 downto 0) of real; type real_cons_vector_file is file of real_cons_vector; constant C19 : real_cons_vector := (others => 3.0); -- OK begin end block; process is type bad1 is array (real range <>) of real; -- Error type bad2 is array (natural range <>, bit_vector range <>) of bit; -- Error begin end process; process is variable n : positive; begin x <= (true => 1, others => 0); -- Error x <= (1 to true => 0); -- Error x <= (false to true => 0, 1 => 1); -- Error x <= (n to n + 4 => n); -- OK x <= (n => 3, others => 0); -- Error x <= (1 => 0, 2 to n => 1); -- Error x <= (1 to n => 1); -- OK end process; process is procedure p(l : natural) is variable v : int_array(1 to l); begin v := (1 => 0, others => 1); -- Error end procedure; begin end process; process is function f(b:integer:=0) return string is begin return "abc"; end function; function f return string is begin return "def"; end function; alias f0 is f [integer return string]; -- OK subtype r is integer range 1 to 2; begin report "x: " & f0(r) severity note; -- OK report "x: " & f(r) severity note; -- Error end process; process is type bit_map is array (bit) of integer; function f return bit_map is begin return (0, 1); end function; begin assert f(bit) = (0, 1); -- OK assert f(std.standard.bit) = (0, 1); -- OK end process; process is type a1 is array (0.0 to 7) of real; -- Error begin end process; process is begin assert m'range(5)'left = 2; -- Error end process; process is variable v : foo; -- Error begin v(0) := 1; -- Error v(1 to 3) := 0; -- Error end process; process is type t_alert_level is (NO_ALERT, NOTE, TB_NOTE, WARNING); type t_alert_counters is array (NOTE to t_alert_level'right) of natural; begin end process; process is -- Reduced from UVVM case type rec is record x : string(1 to 3); end record; procedure proc (variable r : out rec) is alias a : string(r.x'range) is r.x; begin a(1 to 3) := "abc"; -- OK end procedure; begin end process; issue685: process is subtype byte is bit_vector(7 downto 0); type byte_vector is array (natural range <>) of byte; type my_record is record a : byte_vector(0 to 4); end record my_record; constant MY_CONST : my_record := (a => (others => x"00")); function to_hstring(x : bit_vector) return string; begin report to_hstring(MY_CONST(0)); -- Error end process; issue835: process is type t_my_bv is array (natural range <>) of bit; variable x : bit_vector(1 to 7); variable y : t_my_bv(1 to 4); begin y(1) := t_my_bv(x)(1); -- Error y := t_my_bv(x)(1 to 4); -- Error end process; process is type t_int2d is array (natural range <>, natural range <>) of integer; type t_int2d_ptr is access t_int2d; variable p : t_int2d_ptr; begin p.all(1) := 2; -- Error end process; end architecture; nvc-r1.17.1/test/sem/assert.vhd000066400000000000000000000011501504111170000163030ustar00rootroot00000000000000entity e is end entity; architecture a of e is begin process is begin assert false; -- OK assert 1 > 2 report "false"; -- OK assert 4 < 7 report "true" severity failure; -- OK report "boo" severity note; end process; process is begin assert 1; -- Not BOOLEAN end process; process is begin report 53; -- Not STRING end process; process is begin report "boo" severity 1; -- Not SEVERITY_LEVEL end process; end architecture; nvc-r1.17.1/test/sem/attr.vhd000066400000000000000000000220561504111170000157640ustar00rootroot00000000000000entity e is end entity; architecture a1 of e is attribute foo : integer; attribute bar : string; signal x, y, z : integer; attribute foo of x : signal is 6; -- OK attribute bar of y : signal is "hello"; -- OK type int_vec is array (integer range <>) of integer; type int_vec_ptr is access int_vec; signal i : int_vec(1 to 3); attribute foo of i : signal is 6; -- OK begin process is variable v : integer; begin v := x'foo; -- OK report y'bar; -- OK end process; process is begin report z'foo; -- Error end process; process is variable v : int_vec_ptr; begin assert v'length = 5; -- OK assert v.all'length = 62; -- OK end process; process is begin report e'path_name; -- OK report e'instance_name; -- OK report a1'path_name; -- OK report a1'instance_name; -- OK end process; process is begin assert i'event; -- OK assert i(1)'event; -- OK assert i(x)'event; -- OK assert i'foo = 1; -- OK assert i(1)'foo = 2; -- Error end process; end architecture; architecture a2 of e is attribute foo : integer; attribute bar : string; signal x, y, z : integer; attribute foo of z : signal is string'("boo"); -- Error attribute bar of x : signal is 73; -- Error attribute foo of q : signal is 71; -- Error attribute foo of yah : label is 12; -- Ignored begin end architecture; architecture a3 of e is type int10_vec is array (integer range 1 to 10) of integer; begin process is variable x : integer; begin assert int10_vec'low = 1; -- OK assert int10_vec'high = 10; -- OK assert int10_vec'left = 1; -- OK assert int10_vec'right = 10; -- OK assert int10_vec'low(1) = 1; -- OK assert int10_vec'left(x) = 2; -- Error end process; end architecture; package pack is function func(x : in integer) return integer; attribute p : POSITIVE; attribute p of pack : package is 10; -- OK end package; package body pack is function func(x : in integer) return integer is begin report func'instance_name; -- OK report x'simple_name; -- OK report true'simple_name; -- Error report pack'path_name; -- OK report integer'path_name; -- OK (issue #1064) return x + 1; end function; end package body; entity issue39 is generic ( g : bit := '0' ); begin assert (g = '0' or g = '1') report issue39'instance_name & "oops!" severity failure; end entity issue39; architecture a4 of e is begin process is begin assert integer'image(0)(0) = '0'; -- OK end process; process is variable i : integer; attribute a : bit_vector; attribute a of i : variable is "101"; attribute b : integer; attribute b of i : variable is 4; begin assert i'a(1) = '0'; -- OK assert i'b(1) = 1; -- Error end process; process is variable i : integer; attribute a : boolean; attribute a of i : signal is true; -- Error begin end process; process is variable x : integer; begin assert x'last_event = 0 ns; -- Error end process; process is type bv_ptr is access bit_vector; variable a : bv_ptr; type r is record x : integer; end record; variable b : r; begin a(a'range) := "110101"; -- OK a(bit_vector'range) := "110101"; -- Error a(b'range) := "101010"; -- Error a(e'range) := "110101"; -- Error end process; process is function func(x : integer) return bit_vector; variable a : bit_vector(1 to 10); begin a(func(4)'range) := (others => '1'); -- OK end process; process is type bvptr is access bit_vector; variable b : bvptr; begin for i in b.all'range loop -- OK end loop; for i in b'range loop -- OK end loop; end process; b1: block is function fie return string is begin return "11010011"; end function; function fie2(x : integer := 4) return string is begin -- report fie2'instance_name; ??? return "101"; end function; begin process begin assert fie'RIGHT = 1; -- OK assert fie2'RIGHT = 1; -- OK end process; end block; process type int2_vec is array (66 to 67) of integer; variable b : boolean; variable x : int2_vec; begin b := a4'length = 5; -- Error b := x'length = 5; -- OK b := x'low(1) = 1; -- OK b := x'high(1) = 5; -- OK b := x'left = 1; -- OK b := x'right = 5; -- OK b := int2_vec'length = 2; -- OK b := int2_vec'low = 66; -- OK report int2_vec'image(x); -- Error end process; process is subtype my_int is integer range 1 to 20; subtype my_bool is boolean range true to true; variable x : integer; alias my_int_base is my_int'base; -- OK begin assert my_int'base'left = 1; -- OK assert x'base'left = 2; -- Error assert my_int'base = 5; -- Error assert my_bool'base'pos(true) = 1; -- OK report my_bool'base'image(true); -- OK end process; process is variable x : not_here; -- Errror begin assert x'length = 0; -- Error (suppressed) end process; process is -- Test for VHDL-2019 attributes used in -93 attribute index : integer; attribute designated_type : integer; attribute converse : integer; variable a : integer; attribute index of a : variable is 4; -- OK attribute designated_type of a : variable is 4; -- OK attribute converse of a : variable is 4; -- OK begin assert a'index = 4; -- OK assert a'designated_type = 4; -- OK assert a'converse = 4; -- OK end process; process is begin assert integer'val(1) = 1; -- OK assert integer'val(1.2) = 1; -- Error assert integer'val; -- Error assert integer'pred(15) = 14; -- OK assert integer'succ(15) = 16; -- OK end process; process is type bit2d is array (1 to 2, 1 to 2) of bit; begin assert bit2d'value("1010") = (('1','0'),('1','0')); -- Error end process; end architecture; use work.pack.all; entity tc3109 is attribute p of tc3109 : entity is 20; -- OK end tc3109; architecture tc3109arch of tc3109 is attribute p of tc3109arch : architecture is 30; -- OK begin testing: process begin assert not( tc3109'p = 20 and -- OK tc3109arch'p = 30 ); -- OK assert ( tc3109'p = 20 and -- OK tc3109arch'p = 30 ); -- OK wait; end process testing; end; ARCHITECTURE c07s04b01x00p08n01i02565arch OF e IS SUBTYPE s10 IS STRING (1 TO 4); ATTRIBUTE attr1 : INTEGER; ATTRIBUTE attr1 OF s10 : SUBTYPE IS 4; -- OK begin TESTING: PROCESS VARIABLE v : s10; BEGIN v := (1 | s10'attr1 => 'a', OTHERS => 'b' ); -- OK wait for 5 ns; wait; END PROCESS TESTING; END c07s04b01x00p08n01i02565arch; architecture builtins of e is procedure p; procedure p2; procedure p3; attribute never_waits : boolean; attribute never_waits of p : procedure is true; -- OK attribute never_waits of p2 : procedure is false; -- OK attribute never_waits of p3 : procedure is 1 = 1; -- Error function f return integer; function f2 return integer; attribute never_waits of f : function is true; -- Error procedure q (x : integer); procedure q (x : boolean); attribute never_waits of q [integer] : procedure is true; -- OK attribute foreign of f [return integer] : function is "bad string"; -- OK attribute foreign of f2 [return integer] : function is e'path_name; -- OK begin b: block is port ( x : out bit ); begin process is begin assert x'event; -- Error assert x'active; -- Error assert x'transaction = '1'; -- Error assert x'delayed(1 ns) = '1'; -- Error assert x'stable; -- Error assert x'last_event = 0 ns; -- Error assert x'last_active = 0 ns; -- Error assert x'driving; -- OK assert x'driving_value = '1'; -- OK end process; end block; end architecture; nvc-r1.17.1/test/sem/block.vhd000066400000000000000000000010531504111170000160760ustar00rootroot00000000000000entity blk is end entity; architecture test of blk is signal y : integer; begin b1: block is generic ( g1 : integer; g2 : bit := '1' ); -- OK generic map ( g1 => 5 ); -- OK port ( p1 : in integer ); -- OK port map ( p1 => y ); -- OK signal internal : integer; begin internal <= p1 + g1; -- OK end block; b2: block is -- Error (missing g1 in map) generic ( g1 : integer ); begin end block; end architecture; nvc-r1.17.1/test/sem/conc.vhd000066400000000000000000000014161504111170000157310ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x, y : integer; begin x <= 4; -- OK y <= x + 2; -- OK x <= '4'; -- Wrong type x <= 6 when y > 2 else 7; -- OK x <= 7 when 7 else 3; -- Condition not boolean x <= reject 5 inertial 7; -- Reject not time with y select x <= -- OK 1 when 3, 2 when 8, 3 when others; with y select x <= 1 when y; -- Not locally static with y select x <= true when 5; -- Wrong type with y select x <= 6, 7 after 1 ns when false; -- Wrong type end architecture; nvc-r1.17.1/test/sem/concat.vhd000066400000000000000000000024211504111170000162530ustar00rootroot00000000000000entity concat is end entity; architecture arch of concat is type int_array is array (integer range <>) of integer; begin process variable w : int_array(1 to 4); variable x, y : int_array(1 to 3); variable z : int_array(1 to 6); variable s : string(1 to 5); variable t : int_array(1 to 2); variable b : bit_vector(1 to 3); variable c : bit_vector(1 to 4); begin x := ( 1, 2, 3 ); y := ( 4, 5, 6 ); z := x & y; -- OK w := 1 & x; -- OK w := y & 5; -- OK s := 'h' & string'("ello"); -- OK s := 1 & string'("ello"); -- Error t := 6 & 7; -- OK t := 7 & character'( 'x' ); -- Error c := bit_vector(b & '1'); -- OK assert "10" = ("1" & b(1)); -- OK assert ("1" & b(1)) = "10"; -- OK assert "10" = (b(1) & "0"); -- OK wait; end process; process type mem_type is array (1 to 128) of bit_vector(7 downto 0); variable mem : mem_type; variable byte : bit_vector(7 downto 0); begin mem := mem(1 to 127) & byte; -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/condexpr.vhd000066400000000000000000000021011504111170000166210ustar00rootroot00000000000000entity condexpr is end entity; architecture test of condexpr is constant c0 : integer := 5; constant c1 : integer := 1 when c0 > 2 else 2; -- OK constant c2 : integer := 1 when 1 else 1; -- Error constant c3 : integer := 1 when true else 1.0; -- Error signal s1 : bit := '1' when c2 > 4 else '0'; -- OK begin process is variable v1 : real := 1.0 when c0 = 2 else 5.15; -- OK begin v1 := 1.0 when c2 > 2 else unaffected when c2 < 10 else unaffected; -- OK wait; end process; process is function foo (x : in integer) return integer is begin return 5 when x > 2 else 3; -- OK return 5.0 when x > 2 else 3.4; -- Error return when x < 2; -- Error end function; procedure bar (x : out integer) is begin return when c0 > 2; -- OK return when c0; -- Error end procedure; begin return when s1 = '1'; -- Error end process; end architecture; nvc-r1.17.1/test/sem/config.vhd000066400000000000000000000020321504111170000162470ustar00rootroot00000000000000entity sub1 is end entity; architecture a of sub1 is begin end architecture; ------------------------------------------------------------------------------- entity sub2 is end entity; architecture a of sub2 is begin end architecture; ------------------------------------------------------------------------------- entity top is attribute x : integer; end entity; architecture a of top is component comp is end component; component not_used is end component; for others : not_used use entity work.sub2(a); -- Crash from Billowitch tc3114 begin c1: component comp; end architecture; ------------------------------------------------------------------------------- configuration conf of top is attribute o of 'A' : literal is 5; -- Error attribute x of top : entity is 5; -- OK for a for c1 : comp use entity work.sub2(a); end for; for bad : comp -- Error use entity work.sub2(a); end for; end for; end configuration; nvc-r1.17.1/test/sem/config2.vhd000066400000000000000000000026241504111170000163400ustar00rootroot00000000000000entity sub is generic ( g : integer; g2 : bit ); port ( i : in bit_vector; o : out bit_vector ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity other is generic ( gg : integer; g2 : real ); port ( ii : in bit_vector; oo : out bit_vector; zz : out integer ); end entity; architecture test of other is begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component comp is generic ( g : integer; g2 : bit ); port ( i : in bit_vector; o : out bit_vector; k : out bit; zz : out real ); end component; signal x, y : bit_vector(3 downto 0); begin u1: component comp -- Error generic map (5, '1') port map (x, y); u2: component comp -- OK generic map (5, '1') port map (y, x); end architecture; ------------------------------------------------------------------------------- configuration conf of top is for test for u1 : comp use entity work.other(test); -- Error end for; for u2 : comp use entity work.sub(test); end for; end for; end configuration; nvc-r1.17.1/test/sem/const.vhd000066400000000000000000000023641504111170000161400ustar00rootroot00000000000000entity e is end entity; architecture a of e is constant x : integer := 5; function f_pure(n : in integer) return integer is begin return n + 1; end function; impure function f_impure return integer is begin return x; end function; signal s : integer; begin process is variable v : integer; begin v := x; -- OK x := v; -- Error end process; process is constant c : integer; -- Error begin end process; process is constant c : integer := f_pure(5); -- OK begin end process; process is constant c : integer := f_impure; -- OK (LRM 93 7.4.2 note 2) begin end process; end architecture; ------------------------------------------------------------------------------- package p is constant c : integer; -- OK constant d : integer; constant f : integer; end package; package body p is constant c : integer := 6; -- OK constant e : integer := c + 1; -- OK constant c : integer := 6; -- Error constant f : bit := '1'; -- Error -- Missing definition for d end package body; nvc-r1.17.1/test/sem/const2.vhd000066400000000000000000000003451504111170000162170ustar00rootroot00000000000000package deferred is type t_int_array is array (natural range <>) of integer; constant def_arr : t_int_array; end package; package body deferred is constant def_arr : t_int_array := (0 to 2 => 10); end package body; nvc-r1.17.1/test/sem/context.vhd000066400000000000000000000023431504111170000164730ustar00rootroot00000000000000-- Library foo package pack is type my_int is range 1 to 10; end package; ------------------------------------------------------------------------------- -- Library bar context test_context is library foo; use foo.pack.all; end context; ------------------------------------------------------------------------------- -- Library bar library foo; context foo.test_context; entity foo is port ( x : in my_int ); end entity; ------------------------------------------------------------------------------- context foo.pack; -- Error entity e2 is end entity; ------------------------------------------------------------------------------- package pack2 is end package; ------------------------------------------------------------------------------- context work_context is library work; -- Error use work.pack2; -- Error context work.blah; -- Error end context; ------------------------------------------------------------------------------- context nested is library foo; context foo.test_context; end nested; context work.nested; entity foo2 is port ( x : in my_int ); -- OK end entity; nvc-r1.17.1/test/sem/conv.vhd000066400000000000000000000026501504111170000157550ustar00rootroot00000000000000entity conv is end entity; architecture test of conv is type e is (F, G, H); type a is array (integer range <>) of integer; type b is array (integer range <>) of integer; type c is array (integer range <>) of e; subtype d is a(1 to 3); type k is array (e range <>) of integer; type a2 is array (integer range <>, integer range <>) of integer; function eq(x : a; y : b) return boolean is begin return x = a(y); end function; begin process is variable x : integer; variable y : a(1 to 3); variable z : b(1 to 3); variable w : c(1 to 3); variable u : d; variable t : time; variable r : real; variable s : k(f to h); variable y2 : a2(1 to 3, 1 to 3); begin x := integer(2); -- OK x := integer(y); -- Error y := z; -- Error y := a(z); -- OK w := c(y); -- Error assert eq(y, z); -- OK assert eq(y, b(y)); -- OK assert eq(u, z); -- OK assert eq(a(u), z); -- OK r := real(sec / t); -- OK x := integer(y(1)); -- OK y := a(s); -- Error y2 := a2(y); -- Error wait; end process; end architecture; nvc-r1.17.1/test/sem/driving.vhd000066400000000000000000000007221504111170000164500ustar00rootroot00000000000000entity driving is port ( i : in integer; o : out integer ); end entity; architecture test of driving is signal x : integer; begin p1: process is variable v : integer; begin x <= 1; assert x'driving; -- OK assert v'driving; -- Error assert o'driving; -- OK assert i'driving; -- Error wait; end process; end architecture; nvc-r1.17.1/test/sem/duplicate.vhd000066400000000000000000000013041504111170000167550ustar00rootroot00000000000000package pack is function func(x : integer) return integer; procedure proc(x : integer); end package; ------------------------------------------------------------------------------- entity duplicate is end entity; use work.pack.all; architecture test of duplicate is function func(x : integer) return integer is begin return x + 1; end function; procedure proc(x : integer) is begin end procedure; begin process is begin assert func(2) = 3; -- OK assert work.pack.func(2) = 3; -- OK proc(2); -- OK work.pack.proc(2); -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/dwlau.vhd000066400000000000000000000007001504111170000161160ustar00rootroot00000000000000entity dwl_lu is port ( fs: in bit_vector (2 downto 1); a, b: in bit_vector (3 downto 0); lu_out: out bit_vector (3 downto 0); carryout: out bit); end dwl_lu; architecture behavioral of dwl_lu is begin process (a, b) begin lu_out <= (not a); carryout <= '0'; end process; process is begin wait for 5 fs; end process; end behavioral; nvc-r1.17.1/test/sem/ename.vhd000066400000000000000000000033531504111170000160760ustar00rootroot00000000000000package ename_pack is constant c1 : integer := << constant .top.foo : integer >>; -- OK constant c2 : integer := << constant foo.bar : integer >>; -- Error end package; ------------------------------------------------------------------------------- entity ename is end entity; architecture test of ename is alias e1 is <>; -- OK constant k1 : integer := <>; -- OK signal s1 : bit_vector(1 to k1); -- OK signal s2 : bit_vector(1 to <>); -- OK (since 1.16) constant k2 : integer := <>; -- Error begin p1: process is begin e1 <= '1'; -- OK e1 := '1'; -- Error <> := 5; -- OK <> <= force '1'; -- OK <> <= release; -- Error assert <>).bar : integer>> = 1; -- Error wait; end process; p2: process is procedure test1 (signal x : integer) is begin end procedure; procedure test2 (variable x : integer) is begin end procedure; begin test1(<< signal ^.s : integer >>); -- OK test2(<< variable ^.s : integer >>); -- OK test2(<< constant ^.s : integer >>); -- Error end process; p3: process is alias a1 : bit is <>; -- Error begin end process; << signal ^.foo : bit >> <= '1'; -- OK (issue #1156) b1: block is port ( p : inout integer ); port map ( << signal .foo.s : integer >> ); -- OK (issue #1220) begin end block; end architecture; nvc-r1.17.1/test/sem/entity.vhd000066400000000000000000000025551504111170000163300ustar00rootroot00000000000000entity e is attribute foo : integer; attribute foo of e : entity is 55; constant c : integer := 1; begin pass : assert (e'foo = 55 and c = 1) -- OK report "unexpected" severity failure; end entity; package pack is end package; architecture test of e is constant d : integer := c + 1; -- OK begin process is begin report integer'image(e'foo); -- OK end process; recur: entity work.e(invalid) -- OK (until elaboration) ; bad: entity work.pack; -- Error end architecture; architecture a of pack is -- Error begin end architecture; ------------------------------------------------------------------------------- entity edecls is generic ( N : positive ); subtype my_int is integer range 1 to N + 1; -- OK, globally static end entity; architecture test of edecls is signal x : my_int; -- OK begin end architecture; ------------------------------------------------------------------------------- entity statement_part is port ( x : in integer; y : out integer ); begin assert x < 4; -- OK process (x) is begin assert x < 10; -- OK end process; process (x) is begin y <= x + 1; -- Error end process; end entity; nvc-r1.17.1/test/sem/error1.vhd000066400000000000000000000011271504111170000162200ustar00rootroot00000000000000entity sub is port ( x, y : in bit_vector(3 downto 0); z : out bit_vector(7 downto 0) ); end entity; architecture test of sub is begin z <= x & y; end architecture; ------------------------------------------------------------------------------- entity elab11 is end entity; architecture test of elab11 is signal a, b : bit_vector(7 downto 0); begin sub_i: entity work.sub port map ( x(0) => '0'; -- Error x(3 downto 1) => a(7 downto 5), y => a(5 downto 2), z => b ); end architecture; nvc-r1.17.1/test/sem/error2.vhd000066400000000000000000000003231504111170000162160ustar00rootroot00000000000000package error2 is subtype char128 is character range (NUL to DEL); -- Error -- Crash here constant k : string := IfElse(false, "Status: " & IfElse(true, "PASSED", "FAILED") & LF, ""); end package; nvc-r1.17.1/test/sem/error3.vhd000066400000000000000000000016701504111170000162250ustar00rootroot00000000000000entity error3 is end entity; architecture test of error3 is -- Examples from LRM 93 section 7.2.5 type R1 is 0 to 7; -- Error type R2 is 7 downto 0; -- Error type T1 is array (R1 range <>) of Bit; type T2 is array (R2 range <>) of Bit; subtype S1 is T1(R1); subtype S2 is T2(R2); constant K1: S1 := (others => '0'); constant K2: T1 := K1(1 to 3) & K1(3 to 4); -- K2'Left = 0 and K2'Right = 4 constant K3: T1 := K1(5 to 7) & K1(1 to 2); -- K3'Left = 0 and K3'Right = 4 constant K4: T1 := K1(2 to 1) & K1(1 to 2); -- K4'Left = 0 and K4'Right = 1 constant K5: S2 := (others => '0'); constant K6: T2 := K5(3 downto 1) & K5(4 downto 3); -- K6'Left = 7 and K6'Right = 3 constant K7: T2 := K5(7 downto 5) & K5(2 downto 1); -- K7'Left = 7 and K7'Right = 3 constant K8: T2 := K5(1 downto 2) & K5(2 downto 1); -- K8'Left = 7 and K8'Right = 6 begin end architecture; nvc-r1.17.1/test/sem/file.vhd000066400000000000000000000047671504111170000157420ustar00rootroot00000000000000package p is type ft is file of natural; -- OK type int_ptr is access integer; type bad1 is file of int_ptr; -- Error type bad2 is file of ft; -- Error file f1 : ft is "foo.txt" ; -- OK file f2 : integer is "bar.txt"; -- Error file f3 : ft open READ_MODE is "x.txt"; -- OK file f4 : ft open 5 is "y.txt"; -- Error file f5 : ft; -- OK file f6 : ft is 6; -- Error type arr_1d is array (natural range <>) of integer; type arr_2d is array (natural range <>, natural range <>) of integer; subtype subarr_1d is arr_1d (1 to 2); subtype subarr_2d is arr_2d (1 to 2, 3 to 4); type ft2 is file of arr_1d; -- OK type bad4 is file of arr_2d; -- Error type ft3 is file of subarr_1d; -- OK type bad5 is file of subarr_2d; -- Error type t_ptr_arr is array (natural range <>) of int_ptr; subtype sub_ptr_arr is t_ptr_arr (1 to 2); type t_rec is record a : integer; b : int_ptr; end record; type t_rec2 is record a : integer; b : sub_ptr_arr; c : real; end record; type bad6 is file of t_ptr_arr; -- Error type bad7 is file of sub_ptr_arr; -- Error type bad8 is file of t_rec; -- Error type bad9 is file of t_rec2; -- Error type t_ok_rec is record a : integer; b : time; c : arr_1d(1 to 1); d : arr_2d(10 to 20, 1 to 3); end record; type ft4 is file of t_ok_rec; -- OK function get_ft4 return ft4; -- Error signal s : ft(1 downto 0); -- Error end package; package body p is procedure test is variable status : file_open_status; variable n : natural; begin file_open(f5, "foo.txt", WRITE_MODE); -- OK file_open(f5, "bar.txt"); -- OK file_open(status, f5, "x.txt"); -- OK file_close(f1); -- OK write(f1, 5); -- OK read(f1, n); -- OK read(f1, status); -- Error assert endfile(f1); -- OK end procedure; procedure test2 is begin assert f1 = f1; -- Error assert f5 /= f1; -- Error end procedure; end package body; nvc-r1.17.1/test/sem/file_and_access.vhd000066400000000000000000000024371504111170000200750ustar00rootroot00000000000000package p is type t_int_file is file of integer; type t_int_access is access integer; type t_access_array is array (0 to 1) of t_int_access; type t_access_record is record a : integer; b : t_int_access; end record; constant c1 : t_int_access; -- Error constant c2 : t_access_array; -- Error constant c3 : t_access_record; -- Error constant c4 : t_int_file; -- Error signal s1 : t_int_access; -- Error signal s2 : t_access_array; -- Error signal s3 : t_access_record; -- Error signal s4 : t_int_file; -- Error attribute a1 : t_int_access; -- Error attribute a2 : t_access_array; -- Error attribute a3 : t_access_record; -- Error attribute a4 : t_int_file; -- Error component bad_gen is generic ( g1 : t_int_access; -- Error g2 : t_access_array; -- Error g3 : t_access_record; -- Error g4 : t_int_file -- Error ); end component; component bad_ports is port ( p1 : t_int_access; -- Error p2 : t_access_array; -- Error p3 : t_access_record; -- Error p4 : t_int_file -- Error ); end component; end package p; nvc-r1.17.1/test/sem/force.vhd000066400000000000000000000021361504111170000161050ustar00rootroot00000000000000entity force1 is end entity; architecture test of force1 is signal s : integer; signal b : bit; begin p1: process is variable v : integer; begin s <= force out 1; -- OK v <= force out 1; -- Error s <= force out 1.2; -- Error (s, s) <= force integer_vector'(1, 2); -- Error s <= force 1; -- OK (default to in) wait; end process; b1: block is generic (g : bit); generic map ('1'); port (i : in bit); port map (b); begin p2: process is begin i <= force in '0'; -- OK i <= force out '1'; -- Error g <= force in '0'; -- Error i <= force in true; -- Error end process; end block; p2: process is variable v : integer; begin s <= release; -- OK v <= release out; -- Error (s, s) <= release; -- Error wait; end process; end architecture; nvc-r1.17.1/test/sem/foreign1.vhd000066400000000000000000000004371504111170000165230ustar00rootroot00000000000000package p is procedure fproc; attribute foreign of fproc : procedure is "_foo"; procedure proc; end package; package body p is procedure proc is begin -- This procedure should be tagged as never waiting fproc; end procedure; end package body; nvc-r1.17.1/test/sem/func.vhd000066400000000000000000000211411504111170000157370ustar00rootroot00000000000000package func is function sum(x, y, z : in integer) return integer; function invalid(x : out integer) return integer; -- Error type uenum is (A, B, C); type uenum_vector is array (integer range <>) of uenum; function resolved(v : uenum_vector) return uenum; subtype enum is resolved uenum; subtype enum_ab is resolved uenum range A to B; function resolved2(v : uenum) return uenum; subtype enum_bad1 is resolved2 uenum; -- Error function resolved3(v : uenum; x : integer) return uenum; subtype enum_bad2 is resolved3 uenum; -- Error subtype enum_bad3 is uenum uenum; -- Error function default1(x : in uenum := 6) return uenum; -- Error function foo return integer is -- Error begin return 4; end function; end package; package body bad is -- Error end package body; package body func is function sum(x, y, z : in integer) return integer is begin return x + y; -- OK end function; function test1(x : integer) return integer is begin return A; -- Wrong return type end function; function test2(x : out integer) return integer is -- Invalid mode begin return 0; end function; function test3(x : integer) return integer is begin null; -- Missing return statement end function; function foo(x, y, z : in integer) return integer; function foo(x, y, z : in integer) return integer; -- Duplicate function test4(x : uenum_vector) return uenum is begin return x(x'low); end function; function test5(x, y : uenum) return uenum is type uenum2d is array (uenum, uenum) of uenum; constant table : uenum2d := ( ( A, A, A ), ( A, B, C ), ( A, C, B ) ); begin return table(x, y); end function; function test6(x : uenum_vector) return uenum_vector is variable tmp : uenum_vector(1 to x'length); begin for i in tmp'range loop tmp(i) := A; end loop; return tmp; end function; function test7(x : uenum_vector) return uenum_vector is subtype rtype is uenum_vector(x'length downto 0); variable r : rtype; begin return r; end function; function test8(x : uenum) return uenum_vector is begin return test7((1 to 3 => x)); end function; function default2(y : in integer := 6) return integer is begin return y * 2; end function; function test9 return integer is begin return default2; end function; function test10(k : in integer) return integer is variable v : integer; variable u : uenum; begin v := sum(x => 4, 1, 2); -- Error v := sum(1, x => 4, x => 4); -- Error v := sum(1, y => k, z => 4); -- OK u := resolved3(A, x => 4); -- OK u := resolved3(x => 3, v => B); -- OK return v; end function; function test11(constant c : in bit) return bit; -- OK function test12(variable v : in bit) return bit; -- Error type ft is file of bit; function test13(file f : ft) return bit; -- OK function test14(signal s : bit) return bit; -- OK procedure modify(variable b : inout bit) is begin b := '1'; end procedure; function test15(file f : ft) return bit is variable b : bit; begin read(f, b); -- OK return b; end function; function test16(x : in bit) return bit is begin modify(x); -- Error return x; end function; impure function test17(x : in bit) return bit is begin if now = 10 ns then return '1'; else return '0'; end if; end function; function test18(x : in bit) return bit is begin return not test17(x); -- Error, test18 not impure end function; type int_ptr is access integer; function test19(x : in int_ptr) return integer; -- Error function recur(x : in integer) return integer is begin if x = 0 then return 1; else return x * recur(x - 1); end if; end function; function test20(x : integer := 5; y : real) return integer is variable k : integer; begin k := test20(6.5); -- Error k := test20(5); -- Error k := test20(y => 7); -- Error return k; end function; function test21a(x : string) return integer; function test21a(x : bit_vector) return integer; function test21 return integer is begin return test21a(';' & LF); -- OK end function; function test22a(x : integer) return integer is begin return x + 1; end function; function test22a(x : integer) return real is begin return real(x) + 1.0; end function; function test22 return integer is begin assert test22a(1) = 2; -- OK assert test22a(1) = 2.0; -- OK return 1; end function; impure function test23 return integer is variable x : integer; impure function sub(y : in integer) return integer is begin return x + y; end function; begin x := 5; return sub(2); end function; function test24f(x : integer; r : real := 1.0) return integer; function test24f(y : integer; b : boolean := true) return integer; function test24 return integer is begin return test24f(x => 1) + test24f(y => 2); end function; end package body; package func2 is procedure test25(constant x : integer); end package; package body func2 is procedure test25(variable x : integer) is -- Error begin end procedure; function test26(signal x : integer) return integer; function test26(x : integer) return integer is -- Error begin return 1; end function; end package body; package func3 is end package; package body func3 is -- default class should be treated identically to constant class -- (ie, this should not produce an error) function issue182(bitv : bit_vector) return integer is function nested_fun return integer is begin return bitv'length; -- OK end function; begin return nested_fun; end function; function issue123(signal x : integer) return integer is function nested return integer is begin return x + 1; -- Error end function; begin return nested; end function; function constpure(x : integer) return integer is function nested return integer is begin return x + 1; -- OK end function; begin return nested; end function; procedure notdef(x : integer) is begin fnork(x + 1); -- Error end procedure; procedure not_a_procedure is begin constpure(1); -- Error assert notdef(2) = 1; -- Error end procedure; constant bad_c : bad_type := foo; -- Error function bad_param ( constant x : bad_type := bad_c ) return bad_type; -- Error function func1 (x : integer) return integer; function func1 (x : integer := 2) return integer is -- Error begin return 1; end function; function func2 (x : integer := 1) return integer; function func2 (x : integer := 2) return integer is -- Error begin return 1; end function; function func3 (x : bit := '1') return integer; function func3 (x : bit := '0') return integer is -- Error begin return 1; end function; function func4 (x : integer) return integer; impure function func4 (x : integer) return integer is -- Error begin return 1; end function; impure function func5 (x : integer) return integer; function func5 (x : integer) return integer is -- Error begin return 1; end function; impure function func6 (variable x : integer) return integer; -- Error impure function func7 (x : inout integer) return integer; -- Error function func8 return integer is begin return; -- Error end function; function "and" (x : integer) return integer; -- Error function "not" (x, y : integer) return integer; -- Error function "+" (x : integer) return bit; -- OK function "/" (a, b, c : integer) return integer; -- Error end package body; nvc-r1.17.1/test/sem/generate.vhd000066400000000000000000000021221504111170000165740ustar00rootroot00000000000000entity g is end entity; architecture test of g is constant c : integer := 5; signal x : integer; signal b : bit_vector(1 to 5); begin g1: if true generate -- OK begin x <= 5; end generate; g2: if x generate -- Error begin end generate; g3: if false generate -- OK signal y : integer; begin y <= x; end generate; g4: if false generate y <= 5; -- Error end generate; g5: for i in 1 to 5 generate -- OK b(i) <= '1'; end generate; g6: for x in b'range generate -- OK constant k : bit := '1'; begin b(x) <= k; end generate; g7: for x in b'range generate alias a is b(x); -- OK begin a <= '1'; end generate; g8: if x > 4 generate -- Error end generate; g9: for i in 1 to x generate -- Error end generate; g10: for i in integer (-4) to integer (-1) generate -- OK end generate; end architecture; nvc-r1.17.1/test/sem/generics.vhd000066400000000000000000000067001504111170000166070ustar00rootroot00000000000000entity bot is generic ( N : integer ); port ( o : out integer ); end entity; architecture a of bot is begin process is begin o <= N; wait; end process; end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is signal x : integer; begin bot0: entity work.bot -- OK generic map ( N => 5 ) port map ( o => x ); bot1: entity work.bot -- OK generic map ( 5 ) port map ( o => x ); bot3: entity work.bot port map ( o => x ); -- Missing N bot4: entity work.bot generic map ( 1, 2 ) -- Too many generics port map ( o => x ); end architecture; ------------------------------------------------------------------------------- entity bad is generic ( X : integer; Y : integer := X + 1 ); -- X not visible port ( p : in integer := X ); end entity; ------------------------------------------------------------------------------- entity class is generic ( constant X : integer; -- OK signal Y : integer ); -- Error end entity; ------------------------------------------------------------------------------- package p is component c is generic ( X : integer ); -- OK port ( p : in integer range 1 to X; -- OK q : in integer range 1 to Y ); -- Error end component; end package; ------------------------------------------------------------------------------- entity static is generic ( X : integer ); end entity; architecture a of static is constant k : integer := X + 1; signal s : bit_vector(1 to 3); signal s2 : integer; alias sx : bit is s(X); alias sx1 : bit is s(X + 1); alias sx2 : bit_vector is s(k to 3); function f(x : bit_vector) return integer; component c is generic ( x : bit_vector(2 downto 0) ); end component; component d is generic ( t : time ); end component; begin i1: entity work.bot generic map ( N => f("100") ) port map ( o => open ); i2: component c generic map ( x => "00" & '1' ); -- OK i3: component c generic map ( x => "00" & sx ); -- OK (since 1.16) i4: component d generic map ( t => 100 ns ); -- OK i5: component c generic map ( 6 => 1 ); -- Error i6: component c generic map ( "not"(x) => "101" ); -- Error i7: component c generic map ( i6 ); -- Error i8: component c generic map ( a ); -- Error i9: component c generic map ( std.standard ); -- Error i10: component c generic map ( x(s2 downto 0) => "00" ); -- Error b1: block is generic ( constant b : inout boolean ); -- Error generic map ( true ); begin end block; b2: block is generic ( g : integer ); generic map ( open ); -- Error begin end block; b3: block is generic ( g : bit_vector(1 to 2) := "00" ); generic map ( g(1) => open, g(2) => '1' ); -- Error begin end block; b4: block is generic ( g : bit_vector(1 to 2) := "00" ); generic map ( g(1) => '1', g(2) => open ); -- Error begin end block; end architecture; nvc-r1.17.1/test/sem/generics2008.vhd000066400000000000000000000003541504111170000171200ustar00rootroot00000000000000entity e1 is generic ( a : integer; b : integer := a; -- OK c : integer := d; -- Error d : integer; e, f : integer := e -- Error ); end entity; nvc-r1.17.1/test/sem/genpack.vhd000066400000000000000000000070401504111170000164160ustar00rootroot00000000000000package myfixed is generic ( whole : natural; frac : natural ); -- OK constant width : natural := whole + frac; -- OK type fixed_t is array (1 to width) of bit; -- OK function "+"(x, y : fixed_t) return fixed_t; -- OK end package; package body myfixed is function "+"(x, y : fixed_t) return fixed_t is variable result : fixed_t; begin for i in 1 to width loop result(i) := x(i) or y(i); end loop; return result; end function; end package body; ------------------------------------------------------------------------------- package my_consts is constant x : integer := 5; constant y : integer := 6; end package; ------------------------------------------------------------------------------- use work.my_consts.all; package myfixed_4_8 is new work.myfixed generic map ( x, y ); -- OK ------------------------------------------------------------------------------- entity ent is end entity; architecture test of ent is package myfixed_2_4 is new work.myfixed generic map (2, 4); -- OK package bad1 is new work.ent generic map (2, 4); -- Error package bad2 is new std.standard generic map (2, 4); -- Error package bad3 is new work.not_here generic map (2, 4); -- Error package bad4 is new work.myfixed generic map (2); -- Error constant c : natural := myfixed_2_4.width; -- OK constant d : myfixed_2_4.fixed_t := (others => '0'); -- OK begin end architecture; ------------------------------------------------------------------------------- package myfloat is generic ( package fixed_pkg is new work.myfixed generic map (<>) ); -- OK use fixed_pkg.width; -- OK end package; package body myfloat is use fixed_pkg.all; -- OK constant k : natural := whole; -- OK function add(a, b : fixed_t) return fixed_t is begin return a + b; -- OK end function; end package body; ------------------------------------------------------------------------------- package bad is generic ( package bad_std is new std.standard generic map (<>) ); -- Error end package; ------------------------------------------------------------------------------- package my_poly1 is new work.myfloat generic map ( fixed_pkg => not_here); -- Error ------------------------------------------------------------------------------- architecture test2 of ent is package p1 is new work.myfloat generic map ( fixed_pkg => work.myfixed_4_8 ); -- OK package p2 is new work.myfloat generic map ( fixed_pkg => p1 ); -- Error package p3 is new work.myfloat generic map ( fixed_pkg => std.standard ); -- Error package p4 is new work.bad generic map ( bad_std => work.myfixed_4_8 ); -- Error (suppressed) package p5 is new work.myfloat; -- Error begin end architecture; ------------------------------------------------------------------------------- package ptr_pkg is generic ( type t ); type ptr is access t; end package; ------------------------------------------------------------------------------- package int_ptr_pkg is new work.ptr_pkg generic map ( t => integer ); ------------------------------------------------------------------------------- use work.int_ptr_pkg; architecture test3 of ent is procedure p is variable v : int_ptr_pkg.ptr; begin v := new integer; -- OK int_ptr_pkg.deallocate(v); -- OK end procedure; begin end architecture; nvc-r1.17.1/test/sem/genpack2.vhd000066400000000000000000000055111504111170000165010ustar00rootroot00000000000000package fixed_generic_pkg is generic (g : integer); type UNRESOLVED_ufixed is array (INTEGER range <>) of bit; subtype ufixed is UNRESOLVED_ufixed; function to_ufixed ( arg : NATURAL) return UNRESOLVED_ufixed; end package; package body fixed_generic_pkg is function to_ufixed ( arg : NATURAL) return UNRESOLVED_ufixed is begin return (1 to 1 => '0'); end function; end package body; ------------------------------------------------------------------------------- package fixed_pkg is new work.fixed_generic_pkg generic map (4); ------------------------------------------------------------------------------- package float_generic_pkg is generic ( package fixed_pkg is new work.fixed_generic_pkg generic map (<>) ); use fixed_pkg.all; type UNRESOLVED_float is array (INTEGER range <>) of bit; subtype float is UNRESOLVED_float; subtype UNRESOLVED_float32 is UNRESOLVED_float (8 downto -23); alias U_float32 is UNRESOLVED_float32; subtype float32 is float (8 downto -23); function to_ufixed ( arg : UNRESOLVED_float) return UNRESOLVED_ufixed; end package; package body float_generic_pkg is function to_ufixed ( arg : UNRESOLVED_float) return UNRESOLVED_ufixed is begin return (1 to 1 => '0'); end function; end package body; ------------------------------------------------------------------------------- package float_pkg is new work.float_generic_pkg generic map (work.fixed_pkg); ------------------------------------------------------------------------------- entity genpack13 is end entity; use work.fixed_pkg.all; use work.float_pkg.all; architecture test of genpack13 is begin main: process is subtype ufixed7 is ufixed (3 downto -3); -- 7 bit variable checknum : float32; variable check7uf1, check7uf : ufixed7; begin check7uf1 := to_ufixed (checknum); wait; end process; end architecture; ------------------------------------------------------------------------------- package data_type_pkg is generic ( type t_generic; c_default : t_generic ); constant c_val : t_generic := c_default; end package; ------------------------------------------------------------------------------- package data_type_pkg_bv is package inst is new work.data_type_pkg generic map ( t_generic => bit_vector(1 to 8), c_default => X"00" ); -- OK use inst.all; end package; ------------------------------------------------------------------------------- use work.data_type_pkg_bv.all; package data_type_test is constant test : bit_vector(1 to 8) := inst.c_val; -- OK use work.data_type_pkg_bv.inst.all; -- OK end package; nvc-r1.17.1/test/sem/genpack3.vhd000066400000000000000000000015641504111170000165060ustar00rootroot00000000000000package pack1 is generic (x : integer := 5; y : integer := 2); end package; ------------------------------------------------------------------------------- package pack2 is generic (x : integer; y : integer := 2); end package; ------------------------------------------------------------------------------- package pack3 is component comp1 is generic ( package p is new work.pack1 generic map (x => 2) ); -- OK end component; component comp2 is generic ( package p is new work.pack1 generic map (z => 2) ); -- Error end component; component comp3 is generic ( package p is new work.pack1 generic map (default) ); -- OK end component; component comp4 is generic ( package p is new work.pack2 generic map (default) ); -- Error end component; end package; nvc-r1.17.1/test/sem/genpack4.vhd000066400000000000000000000010341504111170000164770ustar00rootroot00000000000000package pack1 is type t_foo is (a, b, c); alias a_foo is t_foo; -- This causes a crash function "=" (l, r : t_foo) return boolean; end package; ------------------------------------------------------------------------------- package pack2 is generic ( type t ); end package; ------------------------------------------------------------------------------- use work.pack1.all; package pack3 is type t_type is (one, two, three); package pack2_inst is new work.pack2 generic map ( t_type ); -- OK end package; nvc-r1.17.1/test/sem/genpack5.vhd000066400000000000000000000040751504111170000165100ustar00rootroot00000000000000package adder is generic (type t; function "+" (a, b : t) return t is <>); function add (x, y : t) return t; end package; package body adder is function add (x, y : t) return t is begin return x + y; end function; end package body; ------------------------------------------------------------------------------- package adder2 is generic (type t; function "+" (a, b : t) return t is <>); end package; ------------------------------------------------------------------------------- entity sub is generic ( package p is new work.adder generic map (<>) ); port ( x, y : in p.t; z : out p.t ); end entity; architecture test of sub is begin z <= p.add(x, y); end architecture; ------------------------------------------------------------------------------- entity sub2 is generic ( package p is new work.adder2 generic map (<>) ); port ( x, y : in p.t; z : out p.t ); end entity; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component sub is generic ( package p is new work.adder generic map (<>) ); port ( x : in p.t; z : out p.t ); end component; signal xr, zr : real; signal xi, zi : integer; package real_adder is new work.adder generic map ( real ); package int_adder is new work.adder generic map ( integer ); begin u1: sub generic map ( real_adder ) port map ( xr, zr ); -- OK u2: sub generic map ( real_adder ) port map ( xi, open ); -- Error u3: sub generic map ( real_adder ) port map ( xr, zr ); -- OK end architecture; ------------------------------------------------------------------------------- configuration genpack17 of top is for test for u1 : sub use entity work.sub port map ( y => x ); end for; for u3 : sub use entity work.sub2 port map ( y => x ); -- Error end for; end for; end configuration; nvc-r1.17.1/test/sem/gensub.vhd000066400000000000000000000054011504111170000162700ustar00rootroot00000000000000entity gensub is end entity; architecture test of gensub is begin b1: block is function adder generic (n : integer) (x : integer) return integer is begin return x + n; -- OK end function; function add1 is new adder generic map (1); -- OK constant c1 : integer := add1(2); -- OK begin end block; b2: block is function not_generic return integer; -- OK function error1 is new not_generic generic map (1); -- Error function no_body generic (n : integer) return integer; function error2 is new no_body generic map (1); -- Error begin end block; b3: block is function adder generic (type t; function "+"(l, r : t) return t is <>; n : t) (x : t) return t is -- OK begin return x + n; end function; function add1_int is new adder generic map (t => integer, n => 1); function add1_real is new adder generic map (t => real, n => 1.0); constant c1 : integer := add1_int(integer'(1)); -- OK constant c2 : real := add1_real(real'(1.0)); -- OK function add_error1 is new adder generic map (t => string, n => 1); -- Error constant c3 : integer := adder(4); -- Error procedure do_stuff generic (x : integer) is begin end procedure; begin do_stuff; -- Error end block; b4: block is function outer generic (type t) (x : t) return t is function inner generic (type q; y : q) return q is begin return y + t; -- Error end function; function inner_inst is new inner generic map (q => t, y => x); -- OK (???) begin return inner_inst; end function; begin end block; b5: block is function test1 generic (x : integer) return integer; function test1 generic (x : real) return integer is -- Error begin return 1; end function; function test2 generic (x : integer) return integer; function test2 generic (x, y : real) return integer is -- Error begin return 1; end function; begin end block; b6: block is function test1 generic (type t) (x : t) return integer is begin return 1; end function; function test1 generic (type t) (x : t) return real is begin return 1.0; end function; function test_error is new test1 generic map (t => boolean); -- Error function test_error2 is new test444 generic map (t => boolean); -- Error begin end block; end architecture; nvc-r1.17.1/test/sem/gensub2.vhd000066400000000000000000000025661504111170000163630ustar00rootroot00000000000000package generic_ff_pack is procedure FF generic ( type T) parameter ( signal q : out T; constant d : in T; constant INIT_VAL : in T; constant rst : in bit; signal clk : in bit; constant en : in bit := '1'); end package generic_ff_pack; package body generic_ff_pack is procedure FF generic ( type T) parameter ( signal q : out T; constant d : in T; constant INIT_VAL : in T; constant rst : in bit; signal clk : in bit; constant en : in bit := '1') is begin if (clk'event and clk = '1') then if (rst /= '0') then q <= INIT_VAL; elsif (en = '1') then q <= d; end if; end if; end procedure FF; end package body; use work.generic_ff_pack.all; entity generic_ff_tb is port ( clkIn : in bit; rstIn : in bit; enIn : in bit; valIn : in bit_vector(7 downto 0); valOut : out bit_vector(7 downto 0)); end entity generic_ff_tb; architecture behav of generic_ff_tb is procedure ff_byte is new FF generic map (T => bit_vector(7 downto 0)); constant INIT_VAL : bit_vector(7 downto 0) := (others=>'0'); begin ff_byte(valOut, valIn, INIT_VAL, rstIn, clkIn, enIn); end architecture behav; nvc-r1.17.1/test/sem/gentype.vhd000066400000000000000000000051441504111170000164640ustar00rootroot00000000000000entity sub is generic ( type t; -- OK INIT : t ); -- OK end entity; architecture test of sub is constant myconst : t := INIT; -- OK signal mysig : t; -- OK subtype mysub is t range 1 to 2; -- Error begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is component comp1 is generic ( type t; -- OK INIT : t ); -- OK end component; component comp2 is end component; component comp3 is generic ( type t; -- OK function func1 (x : t) return t; -- OK procedure proc1 (x : t) is <> ); -- OK end component; component comp4 is generic ( type t; -- OK function func1 (x : integer) return string is to_string; -- OK procedure proc1 (x : t) is <> ); -- OK end component; for u3: comp2 use entity work.sub generic map ( t => real, init => 5.1 ); -- OK procedure proc1 ( a : integer ); procedure proc1 ( b : real ); function my_func (a : integer) return integer; function my_func (a : real) return real; function some_other_func (a, b : integer) return integer; type incomplete; begin u1: entity work.sub generic map ( t => integer, init => 5 ); -- OK u2: component comp1 generic map ( t => integer, init => 5 ); -- OK u3: component comp2; -- OK u4: entity work.sub generic map ( t => integer, init => 1.2 ); -- Error u5: entity work.sub generic map ( real, "=", "/=", 5.2 ); -- Not sure: GHDL gives an error u6: entity work.sub generic map ( t => 5, init => 2 ); -- Error u7: component comp3 generic map ( t => integer, func1 => my_func, proc1 => proc1 ); -- OK u8: component comp3 generic map ( t => integer, func1 => my_func ); -- OK u9: component comp3 generic map ( func1 => my_func ); -- Error u10: component comp3 generic map ( t => bit, func1 => my_func ); -- Error u11: component comp3 generic map ( t => real, func1 => my_func ); -- OK u12: component comp1 generic map ( t => my_func, init => 5 ); -- Error u13: component comp1 generic map ( t => u12, init => 5 ); -- Error u14: component comp1 generic map ( t => incomplete, init => 1 ); -- Error end architecture; nvc-r1.17.1/test/sem/implicit.vhd000066400000000000000000000011571504111170000166230ustar00rootroot00000000000000entity implicit is end entity; architecture test of implicit is signal x : integer; begin process is begin assert x'delayed = 4; -- OK assert x'delayed(1 ns) = 5; -- OK assert x'delayed(5) = 1; -- Error assert x'stable; -- OK assert x'stable(1 ns); -- OK assert x'delayed'stable(2 ns); -- OK assert x'transaction = '1'; -- OK assert x'quiet; -- OK assert x'quiet(5 ns); -- OK assert x'stable(x * ns); -- Error end process; end architecture; nvc-r1.17.1/test/sem/incomplete.vhd000066400000000000000000000024541504111170000171510ustar00rootroot00000000000000entity incomplete is end entity; architecture test of incomplete is type t1; function func1 return t1; -- Error type t2; type t3 is access t2; -- OK type t2 is protected function func2 return integer; end protected; type t2 is protected body function func2 return integer is begin return 42; end function; end protected body; shared variable v1 : t2; -- OK constant c1 : integer := v1.func2; -- OK procedure proc1 (variable x : inout t3) is begin assert x.func2 = 42; -- OK end procedure; type t4 is access t1(1 to 2); -- Error type t5 is array (natural range <>) of t1; -- Error type t6 is record f : t1; -- Error end record; constant c2 : integer := t1'length; -- Error constant c3 : integer := t1'left; -- Error function func3 (x : t1) return integer; -- Error type t7 is access t1; procedure proc2 (variable x : inout t7) is begin x.all(1 to 3) := x.all(3 to 5); -- Error end procedure; begin b: block is generic ( g : t1 := 1 ); -- Error port ( p : t1 := 2 ); -- Error begin end block; end architecture; nvc-r1.17.1/test/sem/integer.vhd000066400000000000000000000034041504111170000164430ustar00rootroot00000000000000entity b is end entity; architecture a of b is type my_int1 is range 0 to 10; type my_int2 is range -20 to 30; signal x : my_int1 := 2; begin process is variable z : my_int1; begin z := x; end process; process is variable y : my_int2; begin -- Should generate error as my_int1 and my_int2 incompatible y := x; end process; process is subtype my_int2_sub is my_int2 range 0 to 10; variable yy : my_int2_sub; begin yy := 6; -- OK -- Should fail even though the range is the same yy := x; end process; process is -- Base type is undefined subtype bad is nothing range 1 to 2; begin end process; process is subtype my_int2_same is my_int2; subtype another_one is my_int2_same range 0 to 10; variable yyy : another_one; variable foo : my_int2 range 0 to 10; begin yyy := foo; -- OK yyy := foo * 2; -- OK yyy := 5 * (2 + 4) / 2; -- OK yyy := (yyy + 5) * x + 2; -- Cannot convert my_int1 to my_int2 end process; process is variable b : my_int2 := my_int2'left; -- OK begin b := my_int2'low; -- OK b := my_int2'high; -- OK b := my_int2'right; -- OK b := my_int2'cake; -- Error end process; process is type bad is range 1 to 2.0; -- Error type x is array (boolean) of boolean; type bad2 is range x'range; -- Error begin end process; process is type bad3 is range 1 to x; -- Error begin end process; end architecture; nvc-r1.17.1/test/sem/interfaces.vhd000066400000000000000000000023651504111170000171360ustar00rootroot00000000000000package interfaces is type text is file of string; component comp1 is port ( signal p1 : integer; -- OK p2 : integer -- OK ); end component; component comp2 is port (variable p : integer); -- Error end component; component comp3 is port (constant p : integer); -- Error end component; component comp4 is port (file p : text); -- Error end component; component comp5 is generic (constant p1 : integer; -- OK p2 : integer);-- OK end component; component comp6 is generic (signal p : integer); -- Error end component; component comp7 is generic (variable p : integer); -- Error end component; component comp8 is generic (file p : text); -- Error end component; procedure proc1(c : buffer integer); -- Error procedure proc2(c : linkage integer); -- Error procedure proc3(constant c : inout integer); -- Error procedure proc3a(constant c : out integer); -- Error procedure proc4(file c : integer); -- Error procedure proc5(constant c : text); -- Error end package interfaces; nvc-r1.17.1/test/sem/issue1010.vhd000066400000000000000000000003531504111170000164400ustar00rootroot00000000000000package pack is function get_abs_ext return integer; end package; package body pack is function get_abs_ext return integer is begin return <>; -- Error end; end package body; nvc-r1.17.1/test/sem/issue102.vhd000066400000000000000000000005101504111170000163540ustar00rootroot00000000000000package COMPONENTS is component DUMMY_MODULE port (I : in bit; O : out bit); end component; end package; use WORK.COMPONENTS.DUMMY_MODULE; entity DUMMY_TOP is port (I : in bit; O : out bit); end entity; architecture RTL of DUMMY_TOP is begin U: DUMMY_MODULE port map(I=>I, O=>O); end architecture; nvc-r1.17.1/test/sem/issue1020.vhd000066400000000000000000000006331504111170000164420ustar00rootroot00000000000000entity foo is end entity; architecture arch of foo is type unsigned is array (natural range <>) of bit; begin process is procedure xyzzy( v : inout unsigned ) is begin end procedure; variable x : bit_vector( 7 downto 0 ); begin -- trying to do an inout conversion triggers the bug: xyzzy( bit_vector( v ) => unsigned( x ) ); -- Error wait; end process; end architecture; nvc-r1.17.1/test/sem/issue1024.vhd000066400000000000000000000012601504111170000164430ustar00rootroot00000000000000entity delayline is generic ( delay : positive ); port ( i : in bit_vector; o : out bit_vector ); end entity; architecture rtl of delayline is type delay_t is array (natural range <>) of bit_vector; signal d : delay_t(delay - 1 downto 0)(i'range); -- This statement causes the problem begin (o, d) <= d & i; -- OK issue1028: block is type bitvv is array(natural range <>) of bit_vector; signal foo: bitvv(2 downto 0)(0 downto 0); begin foo <= bitvv'( -- OK 2 downto 1 => foo(1 downto 0), 0 => foo(2) ); end block; end architecture rtl; nvc-r1.17.1/test/sem/issue1025.vhd000066400000000000000000000017521504111170000164520ustar00rootroot00000000000000package mwe_pkg is procedure drive_sig_default (signal s : out bit); end package; package body mwe_pkg is procedure drive_sig_default (signal s : out bit) is begin s <= '1'; end procedure; end package body; -------------------------------------------------------------------------------- use work.mwe_pkg.all; entity mwe_generic is generic ( procedure drive_sig (signal s : out bit) is drive_sig_default ); end entity; architecture bhv of mwe_generic is signal a : bit; begin -- Case 1 does not work -- drive_sig(a); -- Case 2 works process is begin drive_sig(a); wait; end process; end architecture; -------------------------------------------------------------------------------- entity mwe is end entity; architecture bhv of mwe is procedure p (signal s : out bit) is begin s <= '1'; end procedure; begin inst : entity work.mwe_generic generic map (open) ; end architecture; nvc-r1.17.1/test/sem/issue1038.vhd000066400000000000000000000003351504111170000164520ustar00rootroot00000000000000package timing_pkg is type type1 is range real'high; -- error type type2 is range real'base'low; -- error type type3 is range real'base'range; -- ok type type4 is range natural'range; -- ok end package; nvc-r1.17.1/test/sem/issue105.vhd000066400000000000000000000013101504111170000163560ustar00rootroot00000000000000entity sub is generic ( GEN : in bit_vector(1 to 3) ); port ( x : in bit_vector(1 to 3) ); end entity; architecture test of sub is begin process (x) is begin case x is when GEN => -- Error (used to be allowed) report "x = GEN"; when others => report "x /= GEN"; end case; end process; end architecture; ------------------------------------------------------------------------------- entity issue105 is end entity; architecture test of issue105 is signal s : bit_vector(1 to 3) := "101"; begin sub_i: entity work.sub generic map ( "101" ) port map ( s ); end architecture; nvc-r1.17.1/test/sem/issue1057.vhd000066400000000000000000000004051504111170000164510ustar00rootroot00000000000000entity tb_simple is end tb_simple; architecture tb of tb_simple is type my_rec is array (7 downto 0) of bit_vector; signal sigA : my_rec(open)(0 downto 0); -- OK signal sigB : my_rec(7 downto 0)(0 downto 0); -- Error begin sigA(0)(0) <= '0'; end tb; nvc-r1.17.1/test/sem/issue1067.vhd000066400000000000000000000004051504111170000164520ustar00rootroot00000000000000entity issue1067 is end entity; architecture test of issue1067 is impure function data_length(x : integer) return natural is begin return 42; end function; signal s : bit_vector(data_length(1)'range); -- Error begin end architecture; nvc-r1.17.1/test/sem/issue1173.vhd000066400000000000000000000007561504111170000164610ustar00rootroot00000000000000package test_pkg is type t_test is record sig : bit; sig_vector : bit_vector(15 downto 0); end record; constant C_WIDTH : integer := t_test.sig_vector'length; -- OK (relaxed) constant C_CONSTANT : bit_vector(t_test.sig_vector'range) := (others => '1'); type t_test_2 is record sig : bit; sig_vector : bit_vector(t_test.sig_vector'range); end record; constant c_error : bit := t_test_2.sig; -- Error end package; nvc-r1.17.1/test/sem/issue1212.vhd000066400000000000000000000007071504111170000164470ustar00rootroot00000000000000package tb_utils is end package tb_utils; package body tb_utils is procedure f_gen_clk(signal clk : out bit; variable clk2 : out bit; constant freq : in natural) is begin loop wait for (0.5 / real(freq)) * 1 sec; clk <= not clk; -- Error (even in 2008) clk2 := not clk2; -- OK (in 2008) end loop; end procedure f_gen_clk; end package body; nvc-r1.17.1/test/sem/issue128.vhd000066400000000000000000000006201504111170000163660ustar00rootroot00000000000000package A_NG is procedure PROC(SEL: in integer); end package; package body A_NG is procedure PROC(SEL: in integer) is begin case SEL is when 0 | 1 => -- Used to crash in sem_hoist_for_loop_var for i in 0 to 3 loop end loop; when others => null; end case; end procedure; end package body; nvc-r1.17.1/test/sem/issue130.vhd000066400000000000000000000003371504111170000163640ustar00rootroot00000000000000package A_NG is end package; package body A_NG is procedure PROC(S: in integer; Q: out integer) is begin -- Spurious error without forward declaration PROC(S,Q); end procedure; end package body; nvc-r1.17.1/test/sem/issue131.vhd000066400000000000000000000005401504111170000163610ustar00rootroot00000000000000package A_NG is type STATE_TYPE is (STATE_IDLE, STATE_0, STATE_1); end package; package body A_NG is procedure PROC is type STATE_TYPE is (STATE_IDLE, STATE_A, STATE_B); variable state : STATE_TYPE; begin state := STATE_A; -- Referenced wrong STATE_TYPE end procedure; end package body; nvc-r1.17.1/test/sem/issue132.vhd000066400000000000000000000006671504111170000163740ustar00rootroot00000000000000-- a_pkg.vhd package A_PKG is type POS_TYPE is record X : integer; Y : integer; end record; end package; -- a_ng.vhd use WORK.A_PKG.all; entity A_NG is generic (POS: POS_TYPE := (X => 0, Y => 0)); end entity; architecture MODEL of A_NG is procedure GET_X(X:out integer) is begin X := POS.X; -- "no visible declaration for POS.X" end procedure; begin end architecture; nvc-r1.17.1/test/sem/issue133.vhd000066400000000000000000000006101504111170000163610ustar00rootroot00000000000000package A_PKG is type POS_TYPE is record X : integer; Y : integer; end record; constant POS_ZERO : POS_TYPE := (X => 0, Y=> 0); end package; use WORK.A_PKG.all; entity A_NG is end entity; architecture MODEL of A_NG is procedure GET_ZERO_X(X:out integer) is begin X := POS_ZERO.X; -- OK end procedure; begin end architecture; nvc-r1.17.1/test/sem/issue140.vhd000066400000000000000000000017371504111170000163720ustar00rootroot00000000000000package protected_type_pkg is type protected_t is protected procedure proc; end protected; end package; package body protected_type_pkg is type protected_t is protected body procedure proc is begin end; end protected body; end package body; ------------------------------------------------------------------------------- use work.protected_type_pkg.protected_t; entity e is end entity; architecture a of e is procedure proc(variable prot : inout protected_t) is begin prot.proc; -- Was undefined end; begin end architecture; ------------------------------------------------------------------------------- use work.protected_type_pkg.protected_t; package protected_user_pkg is procedure proc(variable prot : inout protected_t); end package; package body protected_user_pkg is procedure proc(variable prot : inout protected_t) is begin prot.proc; -- Was undefined end; end package body; nvc-r1.17.1/test/sem/issue144.vhd000066400000000000000000000006711504111170000163720ustar00rootroot00000000000000package multiple_function_bodies_pkg is function fun return integer; end package; package body multiple_function_bodies_pkg is function fun return integer is begin return 0; end function; function fun return integer is -- Error begin return 1; end function; procedure proc(x : integer) is begin end procedure; procedure proc(x : integer) is -- Error begin end procedure; end package body; nvc-r1.17.1/test/sem/issue151.vhd000066400000000000000000000007731504111170000163730ustar00rootroot00000000000000package type_pkg is type rec_t is record field : integer; end record; end package; use work.type_pkg.all; package pkg1 is function fun(rec : rec_t) return integer; impure function ifun(rec : rec_t) return integer; procedure proc(variable rec : inout rec_t); end package; use work.type_pkg.all; use work.pkg1.all; package pkg2 is function fun(rec : rec_t) return integer; -- OK impure function ifun(rec : rec_t) return integer; procedure proc(variable rec : inout rec_t); end package; nvc-r1.17.1/test/sem/issue162.vhd000066400000000000000000000021671504111170000163740ustar00rootroot00000000000000package ambiguous is end package; package body ambiguous is procedure proc(arg1 : integer; arg2 : boolean := false) is begin end procedure; procedure proc(arg2 : boolean := false) is begin end procedure; procedure calling_proc is begin proc; -- Works proc(false); -- Works proc(1, false); -- Works proc(arg1 => 1, arg2 => true); -- Works proc(arg2 => true); -- Adding the named argument cause error on ambiguous call end procedure; function fun(arg1 : integer; arg2 : boolean := false) return integer is begin return 1; end function; function fun(arg2 : boolean := false) return integer is begin return 0; end function; function calling_fun_works(arg2 : boolean := false) return integer is begin -- Works assert fun(true) = 0; assert fun(1, true) = 0; assert fun(arg1 => 1, arg2 => true) = 0; return 0; end function; function calling_fun(arg2 : boolean := false) return integer is begin return fun(arg2 => true); -- Adding named argument cause error on ambiguous call end function; end package body; nvc-r1.17.1/test/sem/issue165.vhd000066400000000000000000000003731504111170000163740ustar00rootroot00000000000000package assert_after_missing_type is end package; package body assert_after_missing_type is procedure proc(var : type_t) is begin end; procedure calling_proc is begin proc(1); -- Error (used to cause SIGABRT) end; end package body; nvc-r1.17.1/test/sem/issue173.vhd000066400000000000000000000011221504111170000163640ustar00rootroot00000000000000package other_pkg is type type_t is (value1, value2); function fun return integer; procedure proc; end package; package body other_pkg is function fun return integer is begin return 0; end function; procedure proc is begin end procedure; end package body; use work.other_pkg.all; package pkg is end package; package body pkg is -- Error here when work library not called "work" alias pkg_t is work.other_pkg.type_t; procedure proc is variable var : integer; begin work.other_pkg.proc; var := work.other_pkg.fun; end procedure; end package body; nvc-r1.17.1/test/sem/issue174.vhd000066400000000000000000000005421504111170000163720ustar00rootroot00000000000000package other_pkg is procedure other_proc; end package; package body other_pkg is procedure other_proc is begin end procedure; end package body; use work.other_pkg.other_proc; -- use work.other_pkg.all works though package pkg is end package; package body pkg is procedure proc is begin other_proc; end procedure; end package body; nvc-r1.17.1/test/sem/issue176.vhd000066400000000000000000000020561504111170000163760ustar00rootroot00000000000000package pack is procedure proc; end package; package body pack is procedure proc is begin wait for 1 ns; end procedure; end package body; ------------------------------------------------------------------------------- entity ent is end entity; use work.pack.all; architecture a of ent is begin main : process procedure proc_wait is begin wait for 1 ns; end procedure; procedure proc_wait_indirect is begin proc_wait; end procedure; impure function fun return integer is begin proc_wait_indirect; -- Error proc_wait; -- Error return 42; end function; variable var : integer; begin var := fun; assert var = 42; report integer'image(var); wait until false; end process; process is function fun2 return boolean is begin proc; -- Error (not at sem) return true; end function; begin assert fun2; wait; end process; end architecture; nvc-r1.17.1/test/sem/issue177.vhd000066400000000000000000000003311504111170000163710ustar00rootroot00000000000000entity ent is end entity; architecture a of ent is begin main : process function fun return integer is begin wait for 1 ns; return 42; end function; begin end process; end architecture; nvc-r1.17.1/test/sem/issue178.vhd000066400000000000000000000006421504111170000163770ustar00rootroot00000000000000entity ent is end entity; architecture a of ent is type protected_t is protected procedure proc; end protected; type protected_t is protected body procedure proc is begin report "tick"; wait for 1 ns; report "tock"; end procedure; end protected body; begin main : process variable prot : protected_t; begin prot.proc; wait; end process; end architecture; nvc-r1.17.1/test/sem/issue188.vhd000066400000000000000000000030651504111170000164020ustar00rootroot00000000000000entity issue188 is end entity; architecture test of issue188 is type ft is file of boolean; function file_func return boolean is file f : ft; -- Error variable b : boolean; begin read(f, b); return b; end function; impure function file_func_impure return boolean is file f : ft; -- OK variable b : boolean; begin read(f, b); return b; end function; file f : ft; function file_func2 return boolean is variable b : boolean; begin read(f, b); -- Error return b; end function; procedure read_b(b : out boolean) is begin read(f, b); end procedure; procedure call_read_b(b : out boolean) is begin read_b(b); end procedure; function call_call_read_b return boolean is variable b : boolean; begin call_read_b(b); -- Error return b; end function; impure function impure_call_call_read_b return boolean is variable b : boolean; begin call_read_b(b); -- Error return b; end function; shared variable x : integer; procedure update_x is begin x := 2; end procedure; function call_update_x return boolean is begin update_x; return true; end function; impure function impure_call_update_x return boolean is begin update_x; return true; end function; begin end architecture; nvc-r1.17.1/test/sem/issue197.vhd000066400000000000000000000010671504111170000164020ustar00rootroot00000000000000entity entity_attr is constant MIN_DELAY : NATURAL := 42; attribute DELAY : NATURAL; attribute DELAY of entity_attr : entity is MIN_DELAY; end entity; architecture foo of entity_attr is begin end architecture; entity issue197 is end entity; architecture foe of issue197 is constant fumble: natural := work.entity_attr'DELAY; begin alu_div_0: entity work.entity_attr ; MONITOR: process begin assert fumble = 42; assert work.entity_attr'DELAY = 42; report '.' & 'A'; wait; end process; end architecture; nvc-r1.17.1/test/sem/issue201.vhd000066400000000000000000000007541504111170000163660ustar00rootroot00000000000000package pkg is type prot_t is protected procedure proc; end protected; end package; package body pkg is type prot_t is protected body procedure proc is procedure nested_proc is begin end procedure; function nested_fun return integer is begin return 0; end function; function nested_ifun return integer is begin return 0; end function; begin end procedure; end protected body; end package body; nvc-r1.17.1/test/sem/issue219.vhd000066400000000000000000000006251504111170000163740ustar00rootroot00000000000000package fred2 is function hi_there return string; end package fred2; package body fred2 is type line is access string; function hi_there return string is variable ln : line; begin if null = ln then -- Was error return "Proper initial value for access type."; else return "Compiler error."; end if; end function hi_there; end package body fred2; nvc-r1.17.1/test/sem/issue220.vhd000066400000000000000000000007761504111170000163730ustar00rootroot00000000000000package fred3 is function my_favorite_letter return character; end package fred3; package body fred3 is type other is ('X', 'Y', 'Z'); function my_favorite_letter return character is begin for ch in 'A' to 'Z' loop -- Was error if ch = 'R' then return ch; end if; end loop; for ch in 'Z' downto 'A' loop -- Was error if ch = 'R' then return ch; end if; end loop; end function my_favorite_letter; end package body fred3; nvc-r1.17.1/test/sem/issue221.vhd000066400000000000000000000013231504111170000163610ustar00rootroot00000000000000package fred4 is type fred4_t is protected impure function is_empty return boolean; impure function hi_there return string; end protected fred4_t; end package fred4; package body fred4 is type fred4_t is protected body ---------------------------------------- impure function is_empty return boolean is begin return TRUE; end function is_empty; ---------------------------------------- impure function hi_there return string is begin if is_empty then return "perfect"; else return "we have a problem"; end if; end function hi_there; ---------------------------------------- end protected body fred4_t; end package body fred4; nvc-r1.17.1/test/sem/issue224.vhd000066400000000000000000000020651504111170000163700ustar00rootroot00000000000000entity test is end entity test; architecture test of test is -- next line should fail to compile because it's not legal to assign a default value to a signal parameter procedure proc(signal a : integer := 1) is begin end procedure proc; begin end architecture test; architecture test2 of test is procedure proc(signal a : integer) is begin end procedure proc; begin -- next line should also fail to compile because it's not legal to have no actual or an OPEN actual proc(a => open); end architecture test2; architecture test3 of test is procedure proc( variable a : in integer := 1; variable b : out integer := 1 -- Error ) is begin end procedure proc; begin end architecture test3; architecture test4 of test is procedure proc( variable a : in integer := 1; variable b : inout integer := 1 -- Error ) is begin end procedure proc; begin end architecture test4; entity test2 is port ( a : linkage boolean := false -- error ); end entity test2; nvc-r1.17.1/test/sem/issue225.vhd000066400000000000000000000022471504111170000163730ustar00rootroot00000000000000package p1 is constant c1 : integer := 1; end package; package p2 is constant c2 : integer := 2; end package; package p3 is constant c3 : integer := 3; end package; package p4 is constant c4 : integer := 4; end package; package p5 is constant c5 : integer := 5; end package; package p6 is constant c6 : integer := 6; end package; entity issue225 is use work.p1.all; end entity issue225; architecture test of issue225 is use work.p2.all; -- doesn't work begin g1: if true generate use work.p3.all; -- doesn't work begin b1: block use work.p4.all; -- doesn't work begin pp1: process use work.p5.all; -- doesn't work procedure doit is use work.p6.all; -- doesn't work variable x : integer; begin x := c1 + c2 + c3 + c4 + c5 + c6; wait; end procedure doit; begin doit; end process pp1; end block b1; end generate g1; end architecture test; nvc-r1.17.1/test/sem/issue226.vhd000066400000000000000000000007201504111170000163660ustar00rootroot00000000000000package in_foo is type thing is (x, y); end package; ------------------------------------------------------------------------------- entity issue226 is end entity; architecture test of issue226 is begin process is variable l : std.textio.line; -- OK begin std.textio.write(l, string'("hello")); -- OK end process; process is variable x : foo.in_foo.thing; -- Error begin end process; end architecture; nvc-r1.17.1/test/sem/issue232.vhd000066400000000000000000000010051504111170000163600ustar00rootroot00000000000000entity subent is port ( a : in string(1 to 2) := "AB"; b : out string(1 to 2)); end entity subent; architecture test of subent is begin b(1) <= a(1); b(2) <= a(2); end architecture test; entity test is end entity test; architecture test of test is signal b : string(1 to 2); begin e1: entity work.subent port map ( a => open, b(1) => b(1), b(2) => open -- it's not legal to have a mix of OPEN and non-open ); end architecture test; nvc-r1.17.1/test/sem/issue236.vhd000066400000000000000000000016401504111170000163710ustar00rootroot00000000000000entity subent is port ( a : in boolean := false; b : in boolean; c : inout string; -- unconstrained d : out string(1 to 4) ); end entity; entity test is end entity; architecture a1 of test is signal x : string(1 to 3); begin e1: entity work.subent -- ok port map ( -- a is an unassociated port of mode IN but has a default value b => true, c => x -- d is unassociated port of mode OUT but is constrained ); e2: entity work.subent -- error port map ( a => true, -- b is not allowed to be unassociated c => x ); end architecture; architecture a2 of test is begin e2: entity work.subent -- error port map ( a => true, b => true -- c is not allowed to be unassociated ); end architecture; nvc-r1.17.1/test/sem/issue239.vhd000066400000000000000000000015311504111170000163730ustar00rootroot00000000000000entity issue239 is end entity; architecture test of issue239 is shared variable sv : boolean := false; constant cb : boolean := sv; signal sb : boolean := sv; -- ok begin process variable var : boolean := false; variable var2 : boolean := var; -- ok procedure proc( constant b : in boolean := var -- error ) is begin report boolean'image(b) severity note; end procedure; procedure proc2 ( variable b : in boolean := var -- error ) is begin report boolean'image(b) severity note; end procedure; begin proc; var := true; proc; wait; end process; end architecture; package package_issue239 is constant deferred : integer; procedure proc(a : integer := deferred); -- OK end package; nvc-r1.17.1/test/sem/issue246.vhd000066400000000000000000000002061504111170000163670ustar00rootroot00000000000000package pkg is subtype s is integer (0 to 10); -- error subtype ss is string range 2 to 5; -- error end package pkg; nvc-r1.17.1/test/sem/issue264.vhd000066400000000000000000000020251504111170000163700ustar00rootroot00000000000000entity mux4to1 is port ( A,B : in bit; Y1 : out bit ); end entity mux4to1; architecture behv of mux4to1 is --signal test : bit_vector(1 downto 0); begin y1proc : process(A, B) type foo is (F1, F2); type foo_vec1 is array (integer range <>) of foo; type foo_vec2 is array (integer range <>) of foo; variable x : integer; variable f : foo; begin --test <= A & B; case (A&B) is -- Error --case test is when others => Y1 <= '0'; end case; case (x & x) is -- Error when others => null; end case; case (f & f) is -- Error when others => null; end case; end process; process is type int_vec is array (integer range <>) of integer; variable x : integer; begin case (x & x) is -- Error when others => null; end case; end process; end architecture; nvc-r1.17.1/test/sem/issue276.vhd000066400000000000000000000007661504111170000164050ustar00rootroot00000000000000package other_pkg is type rec_t is record field : integer; end record; end package; package body other_pkg is end package body; package pkg is type prot_t is protected end protected; end package; -- Uncomment to make it work. -- library library_name; use work.other_pkg.all; package body pkg is type prot_t is protected body variable rec : rec_t; procedure method is begin report integer'image(rec.field); end procedure; end protected body; end package body; nvc-r1.17.1/test/sem/issue293.vhd000066400000000000000000000003671504111170000164010ustar00rootroot00000000000000entity test is end test; architecture behv of test is -- Crash "** Fatal: tree kind T_TYPE_CONV does not have item I_ATTRS" constant AWIDTH : integer := integer(4); -- or natural signal a : bit_vector (AWIDTH downto 0); begin end behv; nvc-r1.17.1/test/sem/issue311.vhd000066400000000000000000000013451504111170000163650ustar00rootroot00000000000000package TEST is type EVENT_TYPE is (EVENT_1, EVENT_2); end TEST; use WORK.TEST; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is constant init_event : TEST.EVENT_TYPE := TEST.EVENT_1; -- OK begin end MODEL; ------------------------------------------------------------------------------- package p1 is type EVENT_TYPE is (EVENT_1, EVENT_2); end package; package p2 is type EVENT_TYPE is (EVENT_1, EVENT_2); end package; use work.p1; use work.p2; entity e is end entity; architecture a of e is constant event1 : P1.EVENT_TYPE := P1.EVENT_1; -- OK constant event2 : P2.EVENT_TYPE := P2.EVENT_1; -- OK constant event4 : P1.EVENT_TYPE := P2.EVENT_1; -- Error begin end architecture; nvc-r1.17.1/test/sem/issue316.vhd000066400000000000000000000014011504111170000163630ustar00rootroot00000000000000package my_logic is type std_logic is ('0', '1'); type std_logic_vector is array (natural range <>) of std_logic; type unsigned is array (natural range <>) of std_logic; type signed is array (natural range <>) of std_logic; function to_integer(x : unsigned) return integer; end package; use work.my_logic.all; entity test is port ( clk_in : in std_logic; reset_in : in std_logic ); end entity; architecture default1 of test is type rec_t is record field : std_logic; end record; procedure a_procedure ( signal reg_in : in rec_t ) is begin null; end procedure; begin comb_proc : process begin a_procedure( reg_in => ( field => '0' )); end process; end architecture; nvc-r1.17.1/test/sem/issue326.vhd000066400000000000000000000007121504111170000163700ustar00rootroot00000000000000package test is function x(i : integer) return integer; end package; package body test is function x(i : integer) return integer is variable x : integer; begin x := i + 5; -- Spurious error here return x; end function; procedure y is variable y : integer; -- Spurious error here begin end procedure; end package body; nvc-r1.17.1/test/sem/issue340.vhd000066400000000000000000000021171504111170000163650ustar00rootroot00000000000000entity submodule is port ( sig : in bit); end entity; architecture a of submodule is begin main : process begin wait for 1 ns; assert sig = '1'; report "Success"; wait; end process; end; entity bug is end entity; architecture a of bug is signal sig_vector : bit_vector(0 to 1) := "00"; alias sig_bit_alias : bit is sig_vector(0); signal sig : bit := '0'; alias sig_alias : bit is sig; procedure drive(signal value : out bit) is begin value <= '1'; end; begin main : process begin drive(sig_alias); drive(sig_bit_alias); wait for 1 ns; assert sig_vector(0) = '1'; assert sig = '1'; assert sig_alias = '1'; assert sig_bit_alias = '1'; report "Success"; wait; end process; submodule0_inst : entity work.submodule port map ( sig => sig_alias); submodule1_inst : entity work.submodule port map ( sig => sig_bit_alias); submodule2_inst : entity work.submodule port map ( sig => sig); submodule3_inst : entity work.submodule port map ( sig => sig_vector(0)); end; nvc-r1.17.1/test/sem/issue341.vhd000066400000000000000000000027251504111170000163730ustar00rootroot00000000000000entity issue341 is end entity; architecture test of issue341 is begin process is function func(b : bit) return boolean is begin return b = '1'; end function; function func(b : character) return boolean is begin return b = '1'; end function; alias func_bit is func [bit return boolean]; alias func_char is func [character return boolean]; begin assert func_bit('1'); -- OK assert func_char('1'); -- OK assert func_bit('y'); -- Error wait; end process; no_parameter : process function func return boolean is begin return false; end; alias func_alias is func[return boolean]; variable value : boolean := func_alias; begin if func_alias then assert false; end if; while func_alias loop assert false; end loop; wait; end process; with_parameter : process function func(value : boolean) return boolean is begin return value; end; alias func_alias is func[boolean return boolean]; variable value : boolean := func_alias(false); begin if func_alias(false) then assert false; end if; while func_alias(false) loop assert false; end loop; wait; end process; end architecture; nvc-r1.17.1/test/sem/issue350.vhd000066400000000000000000000004631504111170000163700ustar00rootroot00000000000000entity issue350 is end entity; architecture test of issue350 is constant STAY_AT_LIMIT_STRING : string := "STAY_AT_LIMIT"; constant COUNTER_WRAPAROUND_MAX : integer := STAY_AT_LIMIT_STRING'length; signal COUNTER_WRAPAROUND_PAD : string(1 to COUNTER_WRAPAROUND_MAX); begin end architecture; nvc-r1.17.1/test/sem/issue356.vhd000066400000000000000000000011671504111170000164000ustar00rootroot00000000000000entity nvc_bug is end nvc_bug; architecture behav of nvc_bug is type std_logic_vector is array (integer range <>) of integer; function to_bitvector(x : std_logic_vector) return bit_vector; signal mode : std_logic_vector(1 downto 0); begin process begin --nvc doesn't like the to_bitvector() below, fails in analysis. case to_bitvector(mode) is when "00" => when "01" => when "10" => when "11" => when others => end case; assert false report "end of test" severity note; wait; end process; end behav; nvc-r1.17.1/test/sem/issue359.vhd000066400000000000000000000004301504111170000163730ustar00rootroot00000000000000entity issue359 is end entity; architecture test of issue359 is signal foo : integer; procedure foo (signal foo : in integer) is -- Error begin end procedure; begin process is begin foo(foo); wait; end process; end architecture; nvc-r1.17.1/test/sem/issue359a.vhd000066400000000000000000000004021504111170000165330ustar00rootroot00000000000000-- this test program aborts during analysis entity nvc_bug is end nvc_bug; architecture behav of nvc_bug is signal host_write : bit; begin process procedure host_write is begin end host_write; begin host_write <= '1'; end process; end behav; nvc-r1.17.1/test/sem/issue363.vhd000066400000000000000000000006131504111170000163710ustar00rootroot00000000000000package pkg is type enum_t is (enum0, enum1); end package; entity bug is end entity; use work.pkg.enum1; use work.pkg; use work.pkg.all; architecture a of bug is constant enum2 : work.pkg.enum_t := work.pkg.enum0; constant enum3 : pkg.enum_t := pkg.enum1; begin main : process is begin assert enum2 = work.pkg.enum0; assert enum3 = pkg.enum1; wait; end process; end; nvc-r1.17.1/test/sem/issue368.vhd000066400000000000000000000020341504111170000163750ustar00rootroot00000000000000-- this package has mis-labeled "in" and "out" parameters in the procedure declaration -- but no errors or warnings are generated. package nvc_package_bug is procedure in_through_the_out_door ( signal sig_in: out bit; --note this is labeled an "out" parameter but is really "in" signal sig_out: in bit --note this is labeled an "in" parameter but is really "out" ); procedure foo (x : in integer); procedure bar (signal x : in integer); function baz(x : integer) return integer; end nvc_package_bug; package body nvc_package_bug is procedure in_through_the_out_door ( signal sig_in: in bit; signal sig_out: out bit) is begin sig_out <= sig_in; end procedure in_through_the_out_door; procedure foo (y : in integer) is -- Error begin end procedure; procedure bar (x : in integer) is -- Error begin end procedure; function baz(y : integer) return integer is -- Error begin return 0; end function; end package body nvc_package_bug; nvc-r1.17.1/test/sem/issue369.vhd000066400000000000000000000007661504111170000164100ustar00rootroot00000000000000entity ir1045 is end entity; architecture foo of ir1045 is begin THIS_PROCESS: process type twovalue is ('0', '1'); subtype string4 is string(1 to 4); attribute a: string4; attribute a of '1' : literal is "TRUE"; begin assert THIS_PROCESS.'1''a /= "TRUE" report "'1''a /= ""TRUE"" is FALSE"; report "THIS_PROCESS.'1''a'RIGHT = " & integer'image(THIS_PROCESS.'1''a'RIGHT); wait; end process; end architecture; nvc-r1.17.1/test/sem/issue377.vhd000066400000000000000000000011131504111170000163720ustar00rootroot00000000000000package p1 is type int_vector is array (integer range <>) of integer; end package; use work.p1.all; package p2 is function "="(x, y : int_vector) return boolean; end package; entity issue377 is end entity; use work.p1.all; use work.p2.all; architecture test1 of issue377 is signal x, y : int_vector(3 downto 0); begin assert x = y; -- Error end architecture; use work.p2.all; use work.p1.all; architecture test2 of issue377 is signal x, y : int_vector(3 downto 0); begin assert x = y; -- Error end architecture; nvc-r1.17.1/test/sem/issue386.vhd000066400000000000000000000012041504111170000163730ustar00rootroot00000000000000package interface_function_common is function is_unrecognized_primary_command (byte : bit_vector) return boolean; end interface_function_common; package body interface_function_common is -- Error: does not match specification function is_unrecognized_primary_command (byte : bit_vector(7 downto 0)) return boolean is variable unsigned_stripped_byte : bit_vector(7 downto 0); begin unsigned_stripped_byte(6 downto 0) := byte(6 downto 0); unsigned_stripped_byte(7) := '0'; return unsigned_stripped_byte = X"00"; end is_unrecognized_primary_command; end package body interface_function_common; nvc-r1.17.1/test/sem/issue407.vhd000066400000000000000000000017341504111170000163750ustar00rootroot00000000000000entity bug is end entity; architecture test of bug is constant engnum : integer:=8; subtype engrange is integer range 0 to engnum-1; type bit_array is array(engrange) of bit; type byte_array is array(engrange) of bit_vector(7 downto 0); type mode_t is (RDBMG, C2ENC, C2DEC, C1DEC, WRBMG); type mode_arr_t is array (natural range <>) of mode_t; constant ECC_RD_DATA_VAL : bit := '1'; signal buf_ce : bit_vector(engrange); signal bufmode : mode_arr_t(0 to 0); signal index : natural := 0; signal c2enc_ce, c2dec_ce, c1dec_ce : bit_vector(engrange); signal task4_ce : bit := '1'; begin ce: with bufmode(index) select buf_ce <= (engrange => ECC_RD_DATA_VAL) WHEN RDBMG, -- OK c2enc_ce when C2ENC, c2dec_ce WHEN C2DEC, c1dec_ce WHEN C1DEC, (engrange => task4_ce) WHEN WRBMG, -- OK (engrange => '0') WHEN others; -- OK buf_ce <= (bit => '0'); -- Error end architecture; nvc-r1.17.1/test/sem/issue465.vhd000066400000000000000000000005631504111170000164000ustar00rootroot00000000000000use work.testtest_pkg.all; -- Missing package test2_pkg is type t_test is protected procedure test_proc; end protected; end package; package body test2_pkg is type t_test is protected body procedure test_proc is alias a_test_val is test_val.rec_val; begin a_test_val := 1; end procedure; end protected body; end package body; nvc-r1.17.1/test/sem/issue482.vhd000066400000000000000000000002201504111170000163650ustar00rootroot00000000000000package test_pkg is type t_type is (ONE, TWO); alias t_type2 is t_type; constant C_CONST : string := t_type2'image(ONE); end package; nvc-r1.17.1/test/sem/issue509.vhd000066400000000000000000000006051504111170000163740ustar00rootroot00000000000000entity test is end entity test; architecture beh of test is type t_vvc_config is record clock_name : string(1 to 30); end record; signal vvc_config : t_vvc_config; alias clock_name : string is vvc_config.clock_name; begin process begin vvc_config.clock_name <= (others => NUL); clock_name <= (others => NUL); wait; end process; end architecture beh; nvc-r1.17.1/test/sem/issue52.vhd000066400000000000000000000003411504111170000163020ustar00rootroot00000000000000entity issueD is begin end entity issueD; architecture a of issueD is component c is generic (g : bit_vector); end component c; begin u : c generic map (g => (1 downto 0 => '1')); end architecture a; nvc-r1.17.1/test/sem/issue53.vhd000066400000000000000000000002571504111170000163110ustar00rootroot00000000000000entity c is port (i : in bit); begin assert (i = '0') report "not '0'" severity note; -- OK assert (i = '1') report "not '1'" severity note; -- OK end entity c; nvc-r1.17.1/test/sem/issue58.vhd000066400000000000000000000005341504111170000163140ustar00rootroot00000000000000entity issue58 is begin end entity issue58; architecture a of issue58 is type t is record g : bit; end record t; constant c : t := ( g => '0' ); component comp is generic (g : bit_vector := "0"); end component comp; begin u : comp generic map (g => (1 downto 0 => c.g)); end architecture a; nvc-r1.17.1/test/sem/issue655.vhd000066400000000000000000000006631504111170000164020ustar00rootroot00000000000000entity issue655 is end entity ; architecture casearch of issue655 is subtype too_high is integer range 500 to integer'high ; subtype too_low is integer range integer'low to -500; begin process is variable x : integer; begin case x is when too_high => null ; when too_low => null ; when others => null ; end case ; end process ; end architecture ; nvc-r1.17.1/test/sem/issue659.vhd000066400000000000000000000002761504111170000164060ustar00rootroot00000000000000entity test is end entity ; architecture arch of test is procedure write_to_in(variable y : in integer) is begin y := y + 1 ; end procedure ; begin end architecture ; nvc-r1.17.1/test/sem/issue660.vhd000066400000000000000000000005431504111170000163730ustar00rootroot00000000000000package pack is function blah(constant x : in integer) return integer ; procedure dosomething(constant x : integer) ; end package ; package body pack is function blah(x : in integer) return integer is begin return x + 1; end function ; procedure dosomething(constant x : in integer) is begin end procedure ; end package body ;nvc-r1.17.1/test/sem/issue713.vhd000066400000000000000000000007561504111170000164000ustar00rootroot00000000000000package testpkg is generic ( type A ; type B ; function to_string(x : A) return string is <> ; function to_string(x : B) return string is <> ) ; function doit(l : A ; r : B) return string ; end package ; package body testpkg is function doit(l : A ; r : B) return string is begin return to_string(A) & to_string(B) ; -- Error end function ; end package body ; package test_int_int is new work.testpkg generic map(A => integer, B => integer) ; nvc-r1.17.1/test/sem/issue770.vhd000066400000000000000000000005661504111170000164020ustar00rootroot00000000000000package pkg is function identity_a (a : bit) return bit; function identity_b (b : bit) return bit; end package pkg; package body pkg is function identity_a (constant a : bit) return bit is begin return a; end function; function identity_b (constant b : bit) return bit is begin return b; end function; end package body pkg; nvc-r1.17.1/test/sem/issue88.vhd000066400000000000000000000013311504111170000163130ustar00rootroot00000000000000entity issue88 is end entity; architecture test of issue88 is type str_ptr is access string; type rec is record p : str_ptr; end record; procedure get_length(variable r : rec; l : out integer) is begin l := r.p'length; -- OK end; procedure get_length2(variable r : rec; l : out integer) is begin l := r.p.all'length; -- OK end; type str_ptr_ptr is access str_ptr; type rec2 is record pp : str_ptr_ptr; end record; procedure get_length3(variable r : rec2; l : out integer) is begin l := r.pp.all'length; -- OK l := r.p.all.all'length; -- Error end; begin end architecture; nvc-r1.17.1/test/sem/issue884.vhd000066400000000000000000000003141504111170000163770ustar00rootroot00000000000000entity issue884 is end entity; architecture test of issue884 is procedure proc is begin << signal .issue884.uut.x : integer >> <= 42; -- Error end procedure; begin end architecture; nvc-r1.17.1/test/sem/issue89.vhd000066400000000000000000000007671504111170000163300ustar00rootroot00000000000000-- -*- vhdl-basic-offset: 2 -*- entity double_alias is end entity; architecture a of double_alias is procedure proc(arg : integer) is begin end procedure; procedure proc(arg : string) is begin end procedure; alias my_proc is proc[integer]; alias my_proc is proc[string]; begin process is variable i : integer; variable s : string(1 to 3); begin my_proc(i); -- OK my_proc(s); -- OK end process; end architecture; nvc-r1.17.1/test/sem/issue945.vhd000066400000000000000000000020301504111170000163720ustar00rootroot00000000000000entity test1 is port ( clk_i : bit; data_i : bit_vector(1 downto 0); stb_i : bit ); end test1; architecture arch of test1 is begin end arch; entity test0 is end test0; architecture arch of test0 is type test_record is record x : bit; y : bit; end record; type larger_record is record tr : test_record; end record; function RecordToVec(r : test_record) return bit_vector is begin return r.y & r.x; end function; signal clk : bit := '0'; signal stb : bit := '0'; signal r : larger_record; begin inst0 : entity work.test1 port map ( clk_i => clk, stb_i => stb, data_i => RecordToVec(r.tr) -- OK ); inst1 : entity work.test1 port map ( clk_i => clk, stb_i => stb, data_i => RecordToVec(r) -- Error ); inst2 : entity work.test1 port map ( clk_i => clk, stb_i => stb, data_i => RecordToVec(r.tr.x) -- Error ); clk <= not clk after 5 ns; end arch; nvc-r1.17.1/test/sem/issue958.vhd000066400000000000000000000007311504111170000164040ustar00rootroot00000000000000package foo is subtype bar is bit_vector; function "-"(arg: in bar) return bar; function "+"(lhs, rhs: in bar) return bar; function "*"(lhs, rhs: in bar) return bar; end foo; package body foo is function "-"(arg: bar) return bar is -- Error begin end function "-"; function "+"(lhs, rhs: bar) return bar is -- Error (once) begin end function "+"; function "*"(lhs : in bar; rhs : in bar) return bar is -- Error begin end function; end foo; nvc-r1.17.1/test/sem/issue965.vhd000066400000000000000000000010571504111170000164040ustar00rootroot00000000000000package pack is procedure do_something; signal s : bit; end package; package body pack is procedure drive_signal_out (signal p : out bit) is begin p <= '1'; end procedure; procedure drive_signal_inout (signal p : inout bit) is begin p <= '1'; end procedure; procedure do_something is begin s <= '0'; -- This errors... drive_signal_out(s); -- ... but not this drive_signal_inout(s); -- ... or this end procedure; end package body; nvc-r1.17.1/test/sem/issue980.vhd000066400000000000000000000005601504111170000163770ustar00rootroot00000000000000package issue980 is type t_enum is (a, b, c); subtype t_sub is t_enum range a to b; function foo return t_sub; procedure bar (x : t_sub); end package; package body issue980 is function foo return t_enum is -- Error begin end function; procedure bar (x : t_enum) is -- Error begin end procedure; end package body; nvc-r1.17.1/test/sem/jcore1.vhd000066400000000000000000000040401504111170000161660ustar00rootroot00000000000000entity jcore1 is end entity; architecture test of jcore1 is type macin1_sel_t is (SEL_XBUS, SEL_ZBUS, SEL_WBUS); type macin2_sel_t is (SEL_YBUS, SEL_ZBUS, SEL_WBUS); type mult_state_t is (NOP, DMULSL, DMULSL1, DMULSL2, DMULUL, DMULUL1, DMULUL2, MACL, MACL1, MACL2, MACW, MACW1, MACWS, MACWS1, MULL, MULL1, MULL2, MULSW, MULSW1, MULUW, MULUW1); type zbus_sel_t is (SEL_ARITH, SEL_LOGIC, SEL_SHIFT, SEL_MANIP, SEL_YBUS, SEL_WBUS); type sr_sel_t is (SEL_PREV, SEL_WBUS, SEL_ZBUS, SEL_DIV0U, SEL_ARITH, SEL_LOGIC, SEL_INT_MASK, SEL_SET_T); type t_sel_t is (SEL_CLEAR, SEL_SET, SEL_SHIFT, SEL_CARRY); type mem_addr_sel_t is (SEL_XBUS, SEL_YBUS, SEL_ZBUS); type pipeline_wb_stall_t is record mulcom1 : std_logic; wrmach, wrmacl : std_logic; wrreg_w, wrsr_w : std_logic; macsel1 : macin1_sel_t; macsel2 : macin2_sel_t; mulcom2 : mult_state_t; end record; type pipeline_ex_stall_t is record wrpc_z : std_logic; wrsr_z : std_logic; ma_issue : std_logic; wrpr_pc : std_logic; zbus_sel : zbus_sel_t; sr_sel : sr_sel_t; t_sel : t_sel_t; mem_addr_sel : mem_addr_sel_t; mem_wdata_sel : mem_wdata_sel_t; wrreg_z : std_logic; wrmach, wrmacl : std_logic; shiftfunc : shiftfunc_t; mulcom1 : std_logic; mulcom2 : mult_state_t; macsel1 : macin1_sel_t; macsel2 : macin2_sel_t; end record; type pipeline_t is record ex1 : pipeline_ex_t; ex1_stall : pipeline_ex_stall_t; wb1 : pipeline_wb_t; wb2 : pipeline_wb_t; wb3 : pipeline_wb_t; wb1_stall : pipeline_wb_stall_t; wb2_stall : pipeline_wb_stall_t; wb3_stall : pipeline_wb_stall_t; end record; signal p : pipeline_t; -- Used to assert in make_default_value begin end architecture; nvc-r1.17.1/test/sem/lcs2016_02.vhd000066400000000000000000000005541504111170000164040ustar00rootroot00000000000000package pack is type int_ptr is access integer; impure function func1 (variable x : inout int_ptr) return integer; -- OK pure function func2 (x : inout int_ptr) return integer; -- Error impure function func3 (variable x : in integer) return integer; -- OK pure function func4 (variable x : in integer) return integer; -- Error end package; nvc-r1.17.1/test/sem/lcs2016_04.vhd000066400000000000000000000006431504111170000164050ustar00rootroot00000000000000package pack is type int_ptr is access integer; type rec is record x : int_ptr; end record; type ft is file of character; type pt is protected procedure proc1 (x : inout int_ptr); -- OK procedure proc2 (variable x : in rec); -- OK function func1 (file x : ft) return character; -- OK function func2 return int_ptr; -- OK end protected; end package; nvc-r1.17.1/test/sem/lcs2016_07.vhd000066400000000000000000000010111504111170000163760ustar00rootroot00000000000000entity lcs2016_07 is end entity; architecture test of lcs2016_07 is begin p1: process is variable v : bit := '1'; begin b1: block is -- OK variable v : integer := 1; constant c : boolean := true; begin v := 6; end block b1; assert c; -- Error block is shared variable v : integer; -- Error begin end block; wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_14a.vhd000066400000000000000000000021731504111170000165470ustar00rootroot00000000000000entity lcs2016_014a is end entity; architecture test of lcs2016_014a is type pt is protected procedure proc; function func (x : integer := 2) return integer; end protected; type pt is protected body procedure proc is begin end procedure; function func (x : integer := 2) return integer is begin return x; end function; end protected body; type ptp is access pt; -- OK type ft is file of natural; -- OK type ftp is access ft; -- OK -- TODO: additions re. generic protected types begin p1: process is variable sv : ptp; -- OK variable v : pt; begin assert sv = null; -- OK sv := new pt; -- OK sv.all.proc; -- OK sv.proc; -- OK sv.all.all.proc; -- Error assert sv.all.func = 2; -- OK assert sv.func(5) = 2; -- OK sv := new pt'(sv.all); -- Error (?) wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_16.vhd000066400000000000000000000001671504111170000164110ustar00rootroot00000000000000entity ent1 is generic ( g1 : type is private ); -- OK port ( p1 : type is private ); -- OK end entity; nvc-r1.17.1/test/sem/lcs2016_18.vhd000066400000000000000000000030701504111170000164070ustar00rootroot00000000000000entity lcs2016_18 is end entity; architecture test of lcs2016_18 is type int_ptr is access integer; constant c1 : int_ptr'designated_subtype := 2; -- OK constant c2 : test'designated_subtype := 1; -- Error constant c3 : integer'designated_subtype := 2; -- Error type file_of_int is file of integer; constant c4 : file_of_int'designated_subtype := 2; -- OK begin p1: process is variable v1 : int_ptr; constant c5 : v1'designated_subtype := 5; -- OK constant c6 : v1'designated_subtype := true; -- Error begin end process; p2: process is type int_map is array (integer range <>, boolean range <>) of integer; constant c7 : int_map'index := 23; -- OK constant c8 : int_map'index(2) := true; -- OK constant c9 : int_map'index(2) := 12; -- Error constant c10 : int_map'index(0) := 55; -- Error constant c11 : int_map'index(3) := false; -- Error constant c12 : integer'index := 1; -- Error variable v2 : int_map(1 to 3, true to false); constant c13 : v2'index(1) := 5; -- OK constant c14 : int_map'index(1 + 0) := 3; -- OK (but not supported) begin end process; p3: process is constant x : integer := 2; variable y : real; begin report x'image; -- OK report p3'image; -- Error assert x'left = integer'left; -- OK report y'length; -- Error report file_of_int'image(3); -- Error end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_19.vhd000066400000000000000000000005531504111170000164130ustar00rootroot00000000000000entity lcs2016_19 is end entity; architecture test of lcs2016_19 is signal s1 : integer_vector := (1, 2, 3); -- OK signal s2 : integer_vector; -- Error begin p1: process is variable v1 : integer_vector := (1, 2, 3); -- OK variable v2 : integer_vector; -- Error begin wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_23.vhd000066400000000000000000000004451504111170000164060ustar00rootroot00000000000000-- library foo entity foo_e is end entity; architecture test of foo_e is begin end architecture; ------------------------------------------------------------------------------- -- library bar library foo; configuration foo_cfg of foo.foo_e is for test end for; end configuration; nvc-r1.17.1/test/sem/lcs2016_33.vhd000066400000000000000000000013271504111170000164070ustar00rootroot00000000000000entity lcs2016_33 is end entity; architecture test of lcs2016_33 is type t_test1 is protected private variable x : integer; -- OK procedure proc; end protected; constant c : integer := 1; type t_test2 is protected private variable p1 : t_test1; -- OK private variable p2 : t_test1; -- OK alias a is p1.proc []; -- OK alias b is p2.proc []; -- OK alias cc is c; -- Error end protected; type t_test2 is protected body end protected body; shared variable sv : t_test2; begin process is begin sv.a; -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_41.vhd000066400000000000000000000017461504111170000164130ustar00rootroot00000000000000entity lcs2016_41 is end entity; use std.reflection.all; architecture test of lcs2016_41 is begin p1: process is variable stm : subtype_mirror; variable astm : array_subtype_mirror; variable vm : value_mirror; variable i : integer; variable v : bit_vector(1 to 3); type int_ptr_t is access integer; variable p : int_ptr_t; begin stm := integer'reflect; -- OK vm := i'reflect; -- OK i := integer'reflect; -- Error i := i'reflect; -- Error stm := v'subtype'reflect; -- OK assert stm.get_type_class = CLASS_ARRAY; -- OK astm := stm.to_array; -- OK vm := p1'reflect; -- Error assert v'subtype'reflect.get_type_class = CLASS_ARRAY; -- OK stm := bit_vector'reflect; -- Error stm := int_ptr_t'reflect; -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_45a.vhd000066400000000000000000000112011504111170000165430ustar00rootroot00000000000000package lcs2016_45a is type rec_t is record a : integer ; b : string ; c : bit_vector(7 downto 0) ; d : bit_vector(0 to -1) ; end record ; view master1 of rec_t is a : in ; b : out ; c : out ; d : inout ; end view ; alias slave is master1'converse ; -- OK view master2 of rec_t is a, x : in; -- Error end view; view master3 of rec_t is a, d : in; -- Error end view; view bad1 of integer is -- Error a, d : in; -- Error end view; type rec_vec_t is array (natural range <>) of rec_t; function resolved (r : rec_vec_t) return rec_t; subtype rrec_t is resolved rec_t; view master4 of rrec_t is -- Error a, b, c, d : in; end view; view bad2 of rec_t is integer : in; -- Error a, b, c, d : in; end view; view master5 of rec_t is a, b, c, d : in; b : out; -- Error end view; constant k : master1; -- Error alias a1 is integer'converse; -- Error alias a2 is master1; -- OK alias a3 is a2'converse; -- OK component comp1 is port ( x : view master1 ); -- OK end component; component comp2 is port ( x : view rec_t; -- Error y : view master1 of integer; -- Error z : view master1 of rec_t; -- Ok ); end component; view master6 of rec_t is a : in ; b : out ; c : inout ; d : linkage ; -- Error end view ; type outer_rec_t is record r : rec_t; s : rec_vec_t; end record ; view outer_master1 of outer_rec_t is r : view master1; -- OK s : in; end view; view outer_master2 of outer_rec_t is r : view integer; -- Error s : in; end view; component comp3 is port ( x : view (master1) of rec_vec_t; -- OK y : view (master1) of rec_t; -- Error z : view (master1) of bit_vector); -- Error end component; view outer_master4 of outer_rec_t is r : in; s : view (master1); -- OK end view; view outer_master5 of outer_rec_t is s : in; r : view (master1); -- Error end view; view outer_master6 of outer_rec_t is s : view master1; -- Error r : in; end view; end package ; ------------------------------------------------------------------------------- package pack is type rec_t is record a, b : bit; end record; type rec_array_t is array (natural range <>) of rec_t; view master_rec_t of rec_t is -- OK a : in; b : out; end view; alias slave_rec_t is master_rec_t'converse; -- OK end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( r : view slave_rec_t of rec_t; -- OK a : view (slave_rec_t) of rec_array_t(1 to 3) ); -- OK end entity; architecture test of sub is component comp1 is port ( p : view slave_rec_t of rec_t ); end component; component comp2 is port ( p : view slave_rec_t'converse of rec_t ); end component; begin p1: process is begin assert r.a = '1'; -- OK assert r = ('1', '0'); -- OK r.a <= '1'; -- OK r.b <= '0'; -- Error r <= ('1', '1'); -- Error a(0).a <= '1'; -- OK a(0).b <= '0'; -- Error end process; u1: component comp1 port map ( r ); -- OK u2: component comp2 port map ( r ); -- Error u3: component comp1 port map ( ( '1', '0' ) ); -- Error p2: process is procedure proc1 ( signal x : view slave_rec_t of rec_t ); -- OK procedure proc2 ( signal x : view slave_rec_t'converse of rec_t ); -- OK procedure proc3 ( signal x : view integer of rec_t ); -- Error procedure proc4 ( signal x : view (slave_rec_t) of rec_t ); -- Error procedure proc4 ( signal x : view slave_rec_t of integer ); -- Error begin proc1(r); -- OK proc2(r); -- Error proc2; -- Error end process; u4: component comp1; -- Error end architecture; nvc-r1.17.1/test/sem/lcs2016_47.vhd000066400000000000000000000016421504111170000164140ustar00rootroot00000000000000package pack is type pt is protected procedure do_something; end protected; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( variable sv : inout pt ); -- OK end entity; architecture test of sub is begin p1: process is begin sv.do_something; -- OK wait; end process; end architecture; ------------------------------------------------------------------------------- entity lcs2016_47 is end entity; use work.pack.all; architecture test of lcs2016_47 is shared variable sv : pt; component c1 is port ( variable x : out pt; -- Error variable y : inout integer ); -- Error end component; signal i : integer; begin u1: entity work.sub port map ( sv ); -- OK u2: component c1 port map ( sv, i ); --Error end architecture; nvc-r1.17.1/test/sem/lcs2016_49.vhd000066400000000000000000000012151504111170000164120ustar00rootroot00000000000000entity e is end entity; architecture a of e is function func1 generic (type t) (x, y : t) return t is begin return x; end function; procedure proc1 generic (type t) (x : t) is begin end procedure; begin process is begin assert func1 generic map (integer) parameter map (1, 2) = 1; -- OK proc1 generic map (bit) ('1'); -- OK proc1 generic map (integer) parameter map (2); -- OK assert proc1 generic map (integer) (1); -- Error proc1 generic map (bit) (1); -- Error proc1 generic map (func1) (1); -- Error wait; end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_59.vhd000066400000000000000000000166551504111170000164310ustar00rootroot00000000000000entity lcs2016_59 is generic ( type t1 is <>; type t2 is (<>); type t3 is range <>; type t4 is units <>; type t5 is range <> . <>; type t6 is array (natural range <>) of type is private; type t7 is access type is private; type t8 is file of type is private ); end entity; architecture test of lcs2016_59 is component c1 is generic ( type t is <> ); end component; component c2 is generic ( type t is (<>) ); end component; component c3 is generic ( type t is range <> ); end component; component c4 is generic ( type t is units <> ); end component; component c5 is generic ( type t is range <> . <> ); end component; component c6 is generic ( type t is array (natural range <>) of type is (<>) ); end component; component c7 is generic ( type t is access type is <> ); end component; component c8 is generic ( type t is file of type is private ); end component; signal s1 : t1; signal s2 : t2; signal s3 : t3; signal s4 : t4; signal s5 : t5; signal s6 : t6(1 to 3); -- OK signal s7 : t7; -- Error signal s8 : t8; -- Error begin u1: component c1 generic map ( t => integer ); -- OK u2: component c1 generic map ( t => real ); -- OK u3: component c1 generic map ( t => bit_vector ); -- Error u4: component c1 generic map ( t => t1 ); -- OK u5: component c1 generic map ( t => t3 ); -- OK assert s1 = s1; -- OK assert s1 /= s1; -- OK assert s1 < s1; -- OK assert s1 <= s1; -- OK assert s1 > s1; -- OK assert s1 >= s1; -- OK assert minimum(s1, s1) = s1; -- OK assert maximum(s1, s1) = s1; -- OK assert to_string(s1) = "111"; -- OK u6: component c2 generic map ( t => integer ); -- OK u7: component c2 generic map ( t => real ); -- Error u7a: component c2 generic map ( t => t2 ); -- OK assert s2 < s2; -- OK u8: component c3 generic map ( t => integer ); -- OK u9: component c3 generic map ( t => bit ); -- Error u9a: component c3 generic map ( t => t3 ); -- OK assert s3 + s3 = 0; -- OK assert s3 - s3 = 0; -- OK assert s3 / 1 = s3; -- OK assert -1 * s3 = -s3; -- OK assert +s3 = s3; -- OK assert abs(s3) = 5; -- OK u10: component c5 generic map ( t => real ); -- OK u11: component c5 generic map ( t => integer ); -- Error u11a: component c5 generic map ( t => t5 ); -- OK assert s5 + 1.0 = 0.0; -- OK assert s5 * s5 = s5; -- OK u12: component c4 generic map ( t => time ); -- OK u13: component c4 generic map ( t => integer ); -- Error u13a: component c4 generic map ( t => t4 ); -- OK assert s4 < s4; -- OK assert to_string(s4) = "1 ns"; -- OK b1: block is type t_int_ptr is access integer; type t_bit_ptr is access bit; component c7a is generic ( type t is access bit ); end component; begin u14: component c7 generic map ( t => t_int_ptr ); -- OK u15: component c7 generic map ( t => real ); -- Error u16: component c7 generic map ( t => t7 ); -- Error u17: component c7a generic map ( t => t_bit_ptr ); -- OK u18: component c7a generic map ( t => t_int_ptr ); -- Error p1: process is variable ptr : t7; begin deallocate(ptr); -- OK ptr := new t7'designated_subtype; -- OK wait; end process; end block; b2: block is type t_int_file is file of integer; type t_bit_file is file of bit; component c8a is generic ( type t is file of bit ); end component; impure function "=" (file x, y : t_bit_file) return boolean is begin return false; end function; impure function "=" (file x, y : t_int_file) return boolean is begin return false; end function; impure function "/=" (file x, y : t_bit_file) return boolean is begin return false; end function; impure function "/=" (file x, y : t_int_file) return boolean is begin return false; end function; begin u19: component c8 generic map ( t => t_int_file ); -- OK u20: component c8 generic map ( t => real ); -- Error u21: component c8 generic map ( t => t8 ); -- Error u22: component c8a generic map ( t => t_bit_file ); -- OK u23: component c8a generic map ( t => t_int_file ); -- Error end block; b3: block is type t_bool_map is array (boolean) of boolean; type t_time_map is array (integer range <>) of time; type t_matrix is array (natural range <>, natural range <>) of real; component c6a is generic ( type t is array (type is range <>) of boolean ); end component; begin u24: component c6 generic map ( t => bit_vector ); -- OK u25: component c6 generic map ( t => integer ); -- Error u26: component c6 generic map ( t => t_bool_map ); -- Error u27: component c6 generic map ( t => t6 ); -- Error u28: component c6a generic map ( t => t_bool_map ); -- Error u29: component c6a generic map ( t => t_time_map ); -- Error u30: component c6 generic map ( t => t_matrix ); -- Error p1: process is variable v1 : t6(1 to 3); -- OK variable v2 : t6; -- Error begin v1(2) := v1(1); -- OK assert v1'length = 3; -- OK wait; end process; end block; b4: block is generic ( type array_type is array(type is (<>)) of type is private ); generic map ( array_type => integer_vector ); alias index_type is array_type'INDEX; -- OK alias element_type is array_type'ELEMENT; -- OK begin end block; b5: block is generic ( type ft is file of type is private ); generic map ( ft => t8 ); file f : ft; -- OK begin end block; b7: block is package gp is generic ( type array_type is array (type is (<>)) of type is private ); alias index_type is array_type'INDEX; alias element_type is array_type'ELEMENT; end package; package p is new gp generic map ( array_type => bit_vector ); signal x : p.array_type(1 to 3); -- OK signal y : p.index_type := 5; -- OK signal z : p.element_type := '1'; -- OK begin end block; end architecture; nvc-r1.17.1/test/sem/lcs2016_72b.vhd000066400000000000000000000033521504111170000165540ustar00rootroot00000000000000entity lcs2016_72b is end entity; architecture test of lcs2016_72b is function iota return result_t of integer_vector is -- OK variable result : result_t; variable counter : natural; begin for i in result'range loop result(i) := counter; counter := counter + 1; end loop; return result; end function; function resize(x : integer_vector) return rv_t of integer_vector is alias xa : integer_vector(x'length - 1 downto 0) is x ; variable rv : rv_t := (others => 0); alias ra : integer_vector(rv'length - 1 downto 0) is rv ; constant bound : integer := minimum(x'length, rv'length) - 2 ; begin if bound >= 0 then rv(bound downto 0) := xa(bound downto 0); end if; return rv ; end function ; signal s1 : integer_vector(1 to 2) := iota; -- OK begin process is variable v1 : integer_vector(1 to 3); variable v2 : integer; constant c1 : integer_vector(1 to 2) := iota; -- OK constant c2 : integer_vector := iota; -- Error begin v1 := iota; -- OK v2 := iota; -- Error assert iota = (1, 2, 3); -- Error (v1, v2) := iota; -- Error wait; end process; process is function return_int return rv_t of integer is -- Error variable r : rv_t; begin return r; end function; subtype bv3_t is bit_vector(1 to 3); function return_carray return rv_t of bv3_t is -- Error variable r : rv_t; begin return r; end function; begin end process; end architecture; nvc-r1.17.1/test/sem/lcs2016_75.vhd000066400000000000000000000015571504111170000164220ustar00rootroot00000000000000entity lcs2016_75 is end entity; architecture test of lcs2016_75 is type t_rec1 is record x, y : integer; end record; type t_rec2 is record y, x : integer; end record; type t_rec3 is record x, z : integer; y : real; end record; type t_rec4 is record x : t_rec1; y : t_rec2; end record; type t_rec5 is record x : t_rec2; y : t_rec1; end record; begin p1: process is variable r1 : t_rec1; variable r2 : t_rec2; variable r3 : t_rec3; variable r4 : t_rec4; variable r5 : t_rec5; begin r1 := t_rec1(r2); -- OK r1 := t_rec1(r3); -- OK r3 := t_rec3(r1); -- Error r4 := t_rec4(r5); -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/linkage.vhd000066400000000000000000000003761504111170000164250ustar00rootroot00000000000000entity e is port ( x : linkage integer ); end entity; architecture a of e is begin x <= 1; -- Error assert x = 1; -- Error sub: entity work.e port map ( x ); -- OK end architecture; nvc-r1.17.1/test/sem/mcase.vhd000066400000000000000000000021411504111170000160730ustar00rootroot00000000000000entity mcase is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of mcase is begin p1: process is variable x : std_logic; variable y : std_logic_vector(1 to 3); variable z : integer; begin case? x is -- OK when '1' => null; when '-' => null; end case?; case? z is when 1 => null; -- Error end case?; case? y is -- OK when "---" => null; end case?; wait; end process; p2 : process is type my_vec is array (natural range <>) of std_logic; type my_vec2 is array (natural range <>, natural range <>) of std_logic; variable x : my_vec(1 to 1); variable y : my_vec2(1 to 1, 1 to 1); begin case? x is -- OK when "1" => null; when "-" => null; end case?; case? y is -- Error when others => null; end case?; wait; end process; end architecture; nvc-r1.17.1/test/sem/missingwait.vhd000066400000000000000000000034121504111170000173430ustar00rootroot00000000000000entity foo is end entity; architecture arch of foo is signal a : bit; procedure does_wait is begin wait for 10 ns; end procedure; procedure does_not_wait is begin report "not waiting"; end procedure; procedure does_indirectly_wait is begin does_wait; end procedure; begin -- Warning, contains no wait. process is begin report "no wait"; end process; -- Ok, contains wait. process is begin wait for 10 ns; end process; -- Ok, has sensitivity. process (a) is begin report "a changed"; end process; -- Ok, has sensitivity. process (ALL) is begin report "something changed"; end process; -- Ok, calls procedure with wait. process is begin does_wait; end process; -- Warning, calls procedure without wait. process is begin does_not_wait; end process; -- Ok, calls procedure with indirect wait. process is begin does_indirectly_wait; end process; -- Ok, wait in if block. process is begin if now < 100 ns then wait for 1 ns; else wait; end if; end process; -- Ok, pcall with wait in if block. process is begin if now < 100 ns then does_wait; end if; end process; -- Ok, wait in case block. process is begin case a is when '0' => wait for 1 ns; when '1' => wait for 10 ns; when others => wait on a; end case; end process; -- Ok, pcall with wait in case block. process is begin case a is when '0' => does_wait; when '1' => does_not_wait; when others => null; end case; end process; -- Ok, calls procedure with indirect wait. process is begin does_indirectly_wait; end process; end architecture; nvc-r1.17.1/test/sem/murax.vhd000066400000000000000000000251731504111170000161510ustar00rootroot00000000000000-- Generator : SpinalHDL v1.6.0 git head : 73c8d8e2b86b45646e9d0b2e729291f2b65e6be3 -- Component : Murax -- Git hash : 68e704f3092be640aa92c876cf78702a83167f94 package pkg_enum is type BranchCtrlEnum is (INC,B,JAL,JALR); type ShiftCtrlEnum is (DISABLE_1,SLL_1,SRL_1,SRA_1); type AluBitwiseCtrlEnum is (XOR_1,OR_1,AND_1); type AluCtrlEnum is (ADD_SUB,SLT_SLTU,BITWISE); type EnvCtrlEnum is (NONE,XRET); type Src2CtrlEnum is (RS,IMI,IMS,PC); type Src1CtrlEnum is (RS,IMU,PC_INCREMENT,URS1); type JtagState is (RESET,IDLE,IR_SELECT,IR_CAPTURE,IR_SHIFT,IR_EXIT1,IR_PAUSE,IR_EXIT2,IR_UPDATE,DR_SELECT,DR_CAPTURE,DR_SHIFT,DR_EXIT1,DR_PAUSE,DR_EXIT2,DR_UPDATE); type UartStopType is (ONE,TWO); type UartParityType is (NONE,EVEN,ODD); type UartCtrlTxState is (IDLE,START,DATA,PARITY,STOP); type UartCtrlRxState is (IDLE,START,DATA,PARITY,STOP); function pkg_mux (sel : bit; one : BranchCtrlEnum; zero : BranchCtrlEnum) return BranchCtrlEnum; subtype BranchCtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant BranchCtrlEnum_binary_sequential_INC : BranchCtrlEnum_binary_sequential_type := "00"; constant BranchCtrlEnum_binary_sequential_B : BranchCtrlEnum_binary_sequential_type := "01"; constant BranchCtrlEnum_binary_sequential_JAL : BranchCtrlEnum_binary_sequential_type := "10"; constant BranchCtrlEnum_binary_sequential_JALR : BranchCtrlEnum_binary_sequential_type := "11"; function pkg_mux (sel : bit; one : ShiftCtrlEnum; zero : ShiftCtrlEnum) return ShiftCtrlEnum; subtype ShiftCtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant ShiftCtrlEnum_binary_sequential_DISABLE_1 : ShiftCtrlEnum_binary_sequential_type := "00"; constant ShiftCtrlEnum_binary_sequential_SLL_1 : ShiftCtrlEnum_binary_sequential_type := "01"; constant ShiftCtrlEnum_binary_sequential_SRL_1 : ShiftCtrlEnum_binary_sequential_type := "10"; constant ShiftCtrlEnum_binary_sequential_SRA_1 : ShiftCtrlEnum_binary_sequential_type := "11"; function pkg_mux (sel : bit; one : AluBitwiseCtrlEnum; zero : AluBitwiseCtrlEnum) return AluBitwiseCtrlEnum; subtype AluBitwiseCtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant AluBitwiseCtrlEnum_binary_sequential_XOR_1 : AluBitwiseCtrlEnum_binary_sequential_type := "00"; constant AluBitwiseCtrlEnum_binary_sequential_OR_1 : AluBitwiseCtrlEnum_binary_sequential_type := "01"; constant AluBitwiseCtrlEnum_binary_sequential_AND_1 : AluBitwiseCtrlEnum_binary_sequential_type := "10"; function pkg_mux (sel : bit; one : AluCtrlEnum; zero : AluCtrlEnum) return AluCtrlEnum; subtype AluCtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant AluCtrlEnum_binary_sequential_ADD_SUB : AluCtrlEnum_binary_sequential_type := "00"; constant AluCtrlEnum_binary_sequential_SLT_SLTU : AluCtrlEnum_binary_sequential_type := "01"; constant AluCtrlEnum_binary_sequential_BITWISE : AluCtrlEnum_binary_sequential_type := "10"; function pkg_mux (sel : bit; one : EnvCtrlEnum; zero : EnvCtrlEnum) return EnvCtrlEnum; subtype EnvCtrlEnum_binary_sequential_type is bit_vector(0 downto 0); constant EnvCtrlEnum_binary_sequential_NONE : EnvCtrlEnum_binary_sequential_type := "0"; constant EnvCtrlEnum_binary_sequential_XRET : EnvCtrlEnum_binary_sequential_type := "1"; function pkg_mux (sel : bit; one : Src2CtrlEnum; zero : Src2CtrlEnum) return Src2CtrlEnum; subtype Src2CtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant Src2CtrlEnum_binary_sequential_RS : Src2CtrlEnum_binary_sequential_type := "00"; constant Src2CtrlEnum_binary_sequential_IMI : Src2CtrlEnum_binary_sequential_type := "01"; constant Src2CtrlEnum_binary_sequential_IMS : Src2CtrlEnum_binary_sequential_type := "10"; constant Src2CtrlEnum_binary_sequential_PC : Src2CtrlEnum_binary_sequential_type := "11"; function pkg_mux (sel : bit; one : Src1CtrlEnum; zero : Src1CtrlEnum) return Src1CtrlEnum; subtype Src1CtrlEnum_binary_sequential_type is bit_vector(1 downto 0); constant Src1CtrlEnum_binary_sequential_RS : Src1CtrlEnum_binary_sequential_type := "00"; constant Src1CtrlEnum_binary_sequential_IMU : Src1CtrlEnum_binary_sequential_type := "01"; constant Src1CtrlEnum_binary_sequential_PC_INCREMENT : Src1CtrlEnum_binary_sequential_type := "10"; constant Src1CtrlEnum_binary_sequential_URS1 : Src1CtrlEnum_binary_sequential_type := "11"; function pkg_mux (sel : bit; one : JtagState; zero : JtagState) return JtagState; function pkg_toStdLogicVector_native (value : JtagState) return bit_vector; function pkg_toJtagState_native (value : bit_vector(3 downto 0)) return JtagState; function pkg_mux (sel : bit; one : UartStopType; zero : UartStopType) return UartStopType; subtype UartStopType_binary_sequential_type is bit_vector(0 downto 0); constant UartStopType_binary_sequential_ONE : UartStopType_binary_sequential_type := "0"; constant UartStopType_binary_sequential_TWO : UartStopType_binary_sequential_type := "1"; function pkg_mux (sel : bit; one : UartParityType; zero : UartParityType) return UartParityType; subtype UartParityType_binary_sequential_type is bit_vector(1 downto 0); constant UartParityType_binary_sequential_NONE : UartParityType_binary_sequential_type := "00"; constant UartParityType_binary_sequential_EVEN : UartParityType_binary_sequential_type := "01"; constant UartParityType_binary_sequential_ODD : UartParityType_binary_sequential_type := "10"; function pkg_mux (sel : bit; one : UartCtrlTxState; zero : UartCtrlTxState) return UartCtrlTxState; function pkg_toStdLogicVector_native (value : UartCtrlTxState) return bit_vector; function pkg_toUartCtrlTxState_native (value : bit_vector(2 downto 0)) return UartCtrlTxState; function pkg_mux (sel : bit; one : UartCtrlRxState; zero : UartCtrlRxState) return UartCtrlRxState; function pkg_toStdLogicVector_native (value : UartCtrlRxState) return bit_vector; function pkg_toUartCtrlRxState_native (value : bit_vector(2 downto 0)) return UartCtrlRxState; end pkg_enum; package pkg_scala2hdl is function pkg_extract (that : bit_vector; bitId : integer) return bit; type unsigned is array (natural range <>) of bit; type signed is array (natural range <>) of bit; function pkg_cat (a : signed; b : signed) return signed; function pkg_not (value : signed) return signed; function pkg_mux (sel : bit; one : bit; zero : bit) return bit; function pkg_mux (sel : bit; one : bit_vector; zero : bit_vector) return bit_vector; function pkg_mux (sel : bit; one : unsigned; zero : unsigned) return unsigned; function pkg_mux (sel : bit; one : signed; zero : signed) return signed; function pkg_toStdLogic (value : boolean) return bit; function pkg_toStdLogicVector (value : bit) return bit_vector; end pkg_scala2hdl; library work; use work.pkg_scala2hdl.all; use work.all; use work.pkg_enum.all; entity UartCtrlTx is port( io_configFrame_dataLength : in unsigned(2 downto 0); io_configFrame_stop : in UartStopType_binary_sequential_type; io_configFrame_parity : in UartParityType_binary_sequential_type; io_samplingTick : in bit; io_write_valid : in bit; io_write_ready : out bit; io_write_payload : in bit_vector(7 downto 0); io_cts : in bit; io_txd : out bit; io_break : in bit; io_mainClk : in bit; resetCtrl_systemReset : in bit ); end UartCtrlTx; architecture arch of UartCtrlTx is signal clockDivider_counter_willIncrement : bit; signal clockDivider_counter_willClear : bit; signal clockDivider_counter_valueNext : unsigned(2 downto 0); signal clockDivider_counter_value : unsigned(2 downto 0); signal clockDivider_counter_willOverflowIfInc : bit; signal clockDivider_counter_willOverflow : bit; signal tickCounter_value : unsigned(2 downto 0); signal stateMachine_state : UartCtrlTxState; signal stateMachine_parity : bit; signal stateMachine_txd : bit; signal when_UartCtrlTx_l58 : bit; signal when_UartCtrlTx_l73 : bit; signal when_UartCtrlTx_l76 : bit; signal when_UartCtrlTx_l93 : bit; signal zz_io_txd : bit; begin process(io_samplingTick) begin clockDivider_counter_willIncrement <= pkg_toStdLogic(false); if io_samplingTick = '1' then clockDivider_counter_willIncrement <= pkg_toStdLogic(true); end if; end process; clockDivider_counter_willClear <= pkg_toStdLogic(false); process(stateMachine_state,io_write_payload,tickCounter_value,stateMachine_parity) begin stateMachine_txd <= pkg_toStdLogic(true); case stateMachine_state is when pkg_enum.IDLE => when pkg_enum.START => stateMachine_txd <= pkg_toStdLogic(false); when pkg_enum.DATA => when pkg_enum.PARITY => stateMachine_txd <= stateMachine_parity; when others => end case; end process; process(io_break,stateMachine_state,clockDivider_counter_willOverflow,when_UartCtrlTx_l73) begin io_write_ready <= io_break; case stateMachine_state is when pkg_enum.IDLE => when pkg_enum.START => when pkg_enum.DATA => if clockDivider_counter_willOverflow = '1' then if when_UartCtrlTx_l73 = '1' then io_write_ready <= pkg_toStdLogic(true); end if; end if; when pkg_enum.PARITY => when others => end case; end process; io_txd <= zz_io_txd; process(io_mainClk, resetCtrl_systemReset) begin if resetCtrl_systemReset = '1' then stateMachine_state <= pkg_enum.IDLE; zz_io_txd <= pkg_toStdLogic(true); elsif io_mainClk'active and io_mainClk = '1' then clockDivider_counter_value <= clockDivider_counter_valueNext; case stateMachine_state is when pkg_enum.IDLE => if when_UartCtrlTx_l58 = '1' then stateMachine_state <= pkg_enum.START; end if; when pkg_enum.START => if clockDivider_counter_willOverflow = '1' then stateMachine_state <= pkg_enum.DATA; end if; when pkg_enum.DATA => if clockDivider_counter_willOverflow = '1' then if when_UartCtrlTx_l73 = '1' then if when_UartCtrlTx_l76 = '1' then stateMachine_state <= pkg_enum.STOP; else stateMachine_state <= pkg_enum.PARITY; end if; end if; end if; when pkg_enum.PARITY => if clockDivider_counter_willOverflow = '1' then stateMachine_state <= pkg_enum.STOP; end if; when others => if clockDivider_counter_willOverflow = '1' then if when_UartCtrlTx_l93 = '1' then stateMachine_state <= pkg_mux(io_write_valid,pkg_enum.START,pkg_enum.IDLE); end if; end if; end case; zz_io_txd <= (stateMachine_txd and (not io_break)); end if; end process; end arch; nvc-r1.17.1/test/sem/osvvm1.vhd000066400000000000000000000024131504111170000162400ustar00rootroot00000000000000package AlertLogPkg is subtype AlertLogIDType is integer ; type AlertLogIDVectorType is array (integer range <>) of AlertLogIDType ; type AlertType is (FAILURE, ERROR, WARNING) ; -- NEVER subtype AlertIndexType is AlertType range FAILURE to WARNING ; type AlertCountType is array (AlertIndexType) of integer ; end AlertLogPkg ; package body AlertLogPkg is type AlertLogStructPType is protected impure function GetDisabledAlertCount return AlertCountType ; impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return AlertCountType ; end protected AlertLogStructPType ; type AlertLogStructPType is protected body impure function GetDisabledAlertCount return AlertCountType is variable Count : AlertCountType := (others => 0) ; begin return Count ; end function GetDisabledAlertCount ; end protected body AlertLogStructPType ; shared variable AlertLogStruct : AlertLogStructPType ; impure function GetDisabledAlertCount return AlertCountType is variable result : AlertCountType ; begin result := AlertLogStruct.GetDisabledAlertCount ; -- OK return result ; end function GetDisabledAlertCount ; end package body AlertLogPkg ; nvc-r1.17.1/test/sem/osvvm2.vhd000066400000000000000000000030571504111170000162460ustar00rootroot00000000000000package OsvvmGlobalPkg is type OsvvmOptionsType is (OPT_INIT_PARM_DETECT, OPT_USE_DEFAULT, DISABLED, FALSE, ENABLED, TRUE) ; -- Defaults for String values constant OSVVM_DEFAULT_ALERT_PREFIX : string := "%% Alert" ; constant OSVVM_DEFAULT_LOG_PREFIX : string := "%% Log " ; constant OSVVM_DEFAULT_WRITE_PREFIX : string := "%% " ; constant OSVVM_DEFAULT_DONE_NAME : string := "DONE" ; constant OSVVM_DEFAULT_PASS_NAME : string := "PASSED" ; constant OSVVM_DEFAULT_FAIL_NAME : string := "FAILED" ; constant OSVVM_STRING_INIT_PARM_DETECT : string := NUL & NUL & NUL ; constant OSVVM_STRING_USE_DEFAULT : string := NUL & "" ; -- Coverage Settings constant OSVVM_DEFAULT_WRITE_PASS_FAIL : OsvvmOptionsType := FALSE ; constant OSVVM_DEFAULT_WRITE_BIN_INFO : OsvvmOptionsType := TRUE ; constant OSVVM_DEFAULT_WRITE_COUNT : OsvvmOptionsType := TRUE ; constant OSVVM_DEFAULT_WRITE_ANY_ILLEGAL : OsvvmOptionsType := FALSE ; end OsvvmGlobalPkg ; use work.OsvvmGlobalPkg.all ; package CoveragePkg is -- type OsvvmOptionsType is (OPT_DEFAULT, FALSE, TRUE) ; alias CovOptionsType is work.OsvvmGlobalPkg.OsvvmOptionsType ; constant COV_OPT_INIT_PARM_DETECT : CovOptionsType := work.OsvvmGlobalPkg.OPT_INIT_PARM_DETECT ; -- For backward compatibility. Don't add to other packages. alias DISABLED is work.OsvvmGlobalPkg.DISABLED [return work.OsvvmGlobalPkg.OsvvmOptionsType ]; alias ENABLED is work.OsvvmGlobalPkg.ENABLED [return work.OsvvmGlobalPkg.OsvvmOptionsType ]; end package CoveragePkg ; nvc-r1.17.1/test/sem/osvvm3.vhd000066400000000000000000000032241504111170000162430ustar00rootroot00000000000000package my_logic is type unsigned is array (natural range <>) of bit; type signed is array (natural range <>) of bit; function to_integer(x : unsigned) return integer; function to_integer(x : signed) return integer; end package; use work.my_logic.all; package codec_builder_pkg is function from_byte_array ( constant byte_array : string) return bit_vector; constant integer_code_length : positive := 4; procedure decode ( constant code : string; variable index : inout positive; variable result : out work.my_logic.unsigned); procedure decode ( constant code : string; variable index : inout positive; variable result : out work.my_logic.signed); end package codec_builder_pkg; package body codec_builder_pkg is procedure decode ( constant code : string; variable index : inout positive; variable result : out integer) is begin result := to_integer(work.my_logic.signed(from_byte_array(code(index to index + integer_code_length - 1)))); index := index + integer_code_length; end procedure decode; procedure decode ( constant code : string; variable index : inout positive; variable result : out work.my_logic.unsigned) is variable result_bv : bit_vector(result'range); begin result := work.my_logic.unsigned(result_bv); end; procedure decode ( constant code : string; variable index : inout positive; variable result : out work.my_logic.signed) is variable result_bv : bit_vector(result'range); begin result := work.my_logic.signed(result_bv); end; end package body codec_builder_pkg; nvc-r1.17.1/test/sem/osvvm4.vhd000066400000000000000000000006451504111170000162500ustar00rootroot00000000000000entity osvvm4 is end entity; architecture test of osvvm4 is procedure push (x : bit_vector) is begin end procedure; procedure push (y : string; x : bit_vector) is begin end procedure; begin p1: process is begin push("101"); -- OK push(x => "101"); -- OK push(('1', '0')); -- OK end process; end architecture; nvc-r1.17.1/test/sem/osvvm5.vhd000066400000000000000000000017601504111170000162500ustar00rootroot00000000000000package typepack is type foo is (A, B, C); function "=" (l, r : foo) return boolean; end package; package body typepack is function "=" (l, r : foo) return boolean is begin return false; end function; end package body; package genpack is generic ( type t; def : integer ); end package; package genpack_bitvec is new work.genpack generic map (t => bit_vector, def => 2); use work.typepack.all; package genpack_foo is new work.genpack generic map (t => foo, def => 2); use work.genpack_foo.all; use work.typepack.all; entity e is end entity; architecture test of e is begin p1: process is variable x, y : foo; begin assert x = y; -- OK wait; end process; p2: process is variable x : t; -- OK variable y : integer := def; begin end process; p3: process is use work.genpack.all; -- Error use work.genpack; -- OK begin end process; end architecture; nvc-r1.17.1/test/sem/physical.vhd000066400000000000000000000014661504111170000166300ustar00rootroot00000000000000package physical is type mytime is range 1 to 30 units fs; ps = 1000 fs; ns = 1000.0 ps; -- Error foo = fs; -- OK end units; type myothertime is range 1 to 100 units fs; -- OK? GHDL reports error bar = 100 foo; -- Error end units; type t_freq is range 1 to 1000000 units hz; khz = 1000 hz; mhz = 1000 khz; end units; constant c1 : integer := mhz / hz; -- OK (special implicit conversion rule) function foo (x, y : integer) return integer; function foo (x : integer; y : string) return integer; constant c2 : integer := foo(mhz / hz, hz / hz); -- OK end package; nvc-r1.17.1/test/sem/ports.vhd000066400000000000000000000255101504111170000161570ustar00rootroot00000000000000package foo_pkg is type my_int is range 0 to 100; subtype my_int_sub is my_int range 10 to 20; end package; ------------------------------------------------------------------------------- use work.foo_pkg.all; entity foo is port ( o : out my_int; i : in my_int ); end entity; ------------------------------------------------------------------------------- architecture bar of foo is begin process is variable x : my_int; begin x := i; -- OK end process; process is variable x : my_int; begin -- Cannot read output x := o; end process; process is begin o <= 24; -- OK end process; process is begin -- Cannot assign input i <= 23; end process; end architecture; ------------------------------------------------------------------------------- entity top is generic (str : string := "boo"); end entity; use work.foo_pkg.all; architecture test of top is component foo is port ( o : out my_int; i : in my_int ); end component; type int_vec is array (integer range <>) of integer; component bar is port ( i : in int_vec(1 to 10); o : out int_vec(1 to 2) ); end component; signal x, y : my_int; begin foo1: entity work.foo -- OK port map ( o => x, i => y ); foo2: entity work.foo -- OK port map ( x, y ); foo3: entity work.foo ; -- Missing i association foo4: entity work.foo -- Two associations for i port map ( i => x, i => y, o => x ); foo5: entity work.foo -- Too many ports port map ( x, y, x, y ); foo6: entity work.foo -- No port cake port map ( cake => 4 ); bad1: entity work.bad; -- No such entity open1: entity work.foo -- OK port map ( i => x, o => open ); open2: entity work.foo -- Cannot use OPEN with input port map ( i => open, o => open ); foo7: foo -- OK port map ( o => x, i => y ); foo8: component foo -- OK port map ( o => x, i => y ); bad2: component x -- Not component port map ( a => 1, b => 2 ); b1: block is signal x : int_vec(1 to 10); signal y : int_vec(1 to 2); signal k : integer; begin bar1: bar -- OK port map ( o(1 to 10) => x(1 to 10), i(1 to 2) => y(1 to 2) ); bar2: bar -- OK port map ( o(1 to 4) => x(1 to 4), o(5 to 10) => x(5 to 10), i(1 to 2) => y(1 to 2) ); bar3: bar port map ( o(1) => x(1), o(2) => x(2), o(3 to 10) => x(3 to 10), i => y ); bar4: bar port map ( o(1) => x(1), o(2) => x(k), -- Error o(3 to 10) => x(3 to 10), i => y ); bar5: bar port map ( o(1) => x(1), o(q) => x(2), -- Error o(3 to 10) => x(3 to 10), i => y ); bar6: bar port map ( o(1) => x(1), o(2) => x(2), o(3 to u) => x(3 to 10), -- Error i => y ); bar7: bar port map ( o(k) => x(1), -- Error o(2) => x(2), o(3 to 10) => x(3 to 10), i => y ); bar8: bar port map ( o(1) => x(1), o(2) => x(2), o(3 to k) => x(3 to 10), -- Error i => y ); end block; foo9: foo -- Error port map ( o => x, i => hello(5) ); foo10: foo port map ( i => y ); -- OK end architecture; ------------------------------------------------------------------------------- architecture other of top is type int_vec is array (integer range <>) of integer; component comp1 is port ( a : in integer := 5; o : out int_vec ); end component; signal s : int_vec(1 to 3); begin c1: component comp1 -- OK port map ( a => open, o => s ); c2: component comp1 port map ( a => 5, o => open ); -- Error c3: component comp1 port map ( a => 1.0, -- Error o => s ); end architecture; ------------------------------------------------------------------------------- architecture conv of top is type int_vec1 is array (integer range <>) of integer; type int_vec2 is array (integer range <>) of integer; type my_int1 is range 0 to 1; component comp1 is port ( i : in int_vec1(1 to 3); n : in my_int1 := 5; o : out int_vec2(1 to 3) ); end component; component comp2 is port ( i : in int_vec1 ); end component; component comp3 is port ( b : out bit ); end component; component comp4 is port ( b : inout bit ); end component; function func1(x : in bit) return my_int1; function func2(x : in bit; y : in integer := 5) return my_int1; function func3(x : in bit) return integer; function func4(x : in integer) return bit; signal x : int_vec1(1 to 3); signal y : int_vec2(1 to 3); signal z : bit; signal i : integer; shared variable b : bit; begin c1: component comp1 port map ( i => int_vec1(y) ); -- OK c2: component comp2 port map ( i => int_vec1(y) ); -- Error c3: component comp1 port map ( i => x, n => func1(z) ); -- OK c4: component comp1 port map ( i => x, n => func2(z) ); -- Error c6: component comp1 port map ( i => int_vec1(y), o => int_vec2(x) ); -- Error c7: component comp3 port map ( func3(b) => i ); -- OK c8: component comp1 port map ( i => (1, 1, 1), int_vec1(o) => x ); -- OK c9: component comp1 port map ( int_vec2(i) => y, -- Error int_vec1(o) => x ); c10: component comp3 port map ( func3(b) => open ); -- Error c11: component comp4 port map ( func3(b) => func4(i) ); -- OK c12: component comp4 port map ( '0' ); -- Error c13: component comp4 port map ( b ); -- Error end architecture; entity ent_with_vec is port ( x : in bit_vector(3 downto 0); y : out bit_vector(3 downto 0) ); end entity; architecture test of ent_with_vec is begin x(1) <= '0'; -- Error y(1) <= y(0); -- Error end architecture; ------------------------------------------------------------------------------- architecture other2 of top is procedure assign(x : out integer) is begin x := 5; end procedure; procedure assign_and_check(x : inout integer) is begin assign(x); -- OK assert x = 5; end procedure; procedure bad(variable x : in integer) is begin assign(x); end procedure; begin end architecture; ------------------------------------------------------------------------------- architecture actual_func of top is component comp is port ( i : in integer ); end component; signal s : integer; function "not"(x : integer) return integer; function foo(x : integer; y : integer := 2) return integer; begin c1: component comp port map ( i => "not"(s) ); -- OK c2: component comp port map ( i => not s ); -- Error, not treated as conversion func c3: component comp port map ( i => foo(s) ); -- Error, not treated as conversion func c4: component comp port map ( i => "not"(1) ); -- OK (not a conversion function) c5: component comp port map ( "not"(5) => s ); -- Error end architecture; ------------------------------------------------------------------------------- architecture modes of top is signal x, y : bit; begin b1: block is port ( ub : buffer bit; uio : inout bit; ui : in bit; uo : out bit; ul : linkage bit ); port map ( x, y, '1', open ); begin sub1: block is port ( lb : buffer bit; lio : inout bit; li : in bit; lo : out bit ); port map ( lb => uio, -- Error lio => ub, -- Error li => uo, -- Error lo => ui -- Error ); begin end block; sub2: block is port ( lio : inout bit; ll : linkage bit; li : in bit ); port map ( lio => uo, -- Error ll => ul, -- OK li => ul -- Error ); begin end block; sub3: block is port ( lb : buffer bit; lo : out bit; li : in bit; ll : linkage bit ); port map ( lb => ui, -- Error lo => ub, -- Error li => ub, -- OK ll => ub -- OK ); begin end block; end block; end architecture; ------------------------------------------------------------------------------- architecture conv2 of top is signal s : real; begin b1: block is port ( io1, io2 : inout integer ); port map ( io1 => integer(s), -- Error integer(io2) => s ); -- Error begin end block; end architecture; ------------------------------------------------------------------------------- architecture open_actual of top is begin process is procedure test (constant c: natural) is begin end procedure; begin test(open); wait; end process; end architecture; nvc-r1.17.1/test/sem/procedure.vhd000066400000000000000000000124761504111170000170070ustar00rootroot00000000000000package p is procedure foo(x : in integer; y : out integer); procedure yah is -- Error begin null; end procedure; end package; package body p is procedure foo(x : in integer; y : out integer) is variable i : integer; begin y := x + 1; end procedure; procedure bar(x : in integer; signal y : out integer) is begin y <= x + 1; end procedure; procedure yam is begin return; -- OK return 5; -- Error end procedure; procedure foo_wrap(y : out integer) is begin foo(5, y); end procedure; procedure has_def(x : in integer; y : in integer := 7) is begin end procedure; procedure calls_has_def is begin has_def(5); end procedure; procedure bad_def(x : in bit := 6) is begin end procedure; procedure bad_def2(x : in bit := '1'; y : in integer) is begin end procedure; procedure diff_types(x : in integer; y : in string) is begin end procedure; procedure test_named is begin diff_types(1, "foo"); -- OK diff_types(1, y => "bar"); -- OK diff_types(x => 1, y => "foo"); -- OK diff_types(y => "la", x => 6); -- OK diff_types(y => "foo"); -- Error diff_types(y => "f", 6); -- Error end procedure; procedure overload(x : in bit) is begin end procedure; procedure overload(x : in integer) is begin end procedure; procedure test_overload is begin overload('1'); overload(1); end procedure; procedure test1(x : in integer; y : out integer) is begin y := y + 1; -- Error x := 6; end procedure; procedure test2(signal x : in bit) is begin -- These are errors according to LRM 93 section 2.1.1.2 assert x'stable; assert x'quiet; assert x'transaction = '1'; assert x'delayed(1 ns) = '1'; end procedure; type int_ptr is access integer; procedure test3(constant x : inout int_ptr); -- Error procedure test4(x : in int_ptr); -- Error procedure test4a(x : int_ptr); -- Error procedure test4b(x : out int_ptr); -- OK procedure test5_a(variable x : integer) is begin end procedure; procedure test5_b(variable x : integer) is alias a : integer is x; begin test5_a(a); end procedure; type int2d is array (natural range <>, natural range <>) of integer; procedure test6 ( variable a : inout bit_vector; constant b : in int2d; constant c : in natural ) is begin end procedure; procedure test6 ( variable a : inout bit_vector; constant b : in int2d ) is begin test6 ( b => b, c => 1, a => a ); end procedure; procedure test7a(x : in bit_vector(1 to 2)) is begin end procedure; procedure test7b is begin test7a(x(1) => '0', x(2) => '1'); -- OK end procedure; procedure test8(x : out int_ptr) is begin if x /= null then -- Error end if; end procedure; procedure test9(x : out integer) is begin x <= 5; -- Error end procedure; type t_access_array is array (0 to 1) of int_ptr; type t_access_record is record a : integer; b : int_ptr; end record; procedure test10(constant arg : t_access_array) is -- Error begin null; end procedure; procedure test11(constant arg : t_access_record) is -- Error begin null; end procedure; procedure test12(signal arg : t_access_array) is -- Error begin null; end procedure; procedure test13(signal arg : t_access_record) is -- Error begin null; end procedure; procedure test14 is variable x : bit_vector(1 to 3); begin x(1); -- Error end procedure; procedure test15 (signal x : out bit bus) is -- Error begin end procedure; procedure test16 (signal x : in bit_vector(1 to 3)) is procedure test16_a (signal y : bit) is begin end procedure; variable i : integer; begin test16_a(x(i)); -- Error, not static name end procedure; procedure test17 is procedure test17_a (x, y : integer) is begin end procedure; begin test17_a(x => 1, x => 2); -- Error test17_a(z => 1, x => 2); -- Error end procedure; procedure test18 (signal x : in bit) is begin x <= '1'; -- Error end procedure; procedure tc145 is -- Vests non-compliant tc145.vhd procedure P1 (a : in integer; b: out integer) is begin end procedure; function F1 (I1, I2 : in integer) return real is begin return 1.0; end function; variable x1 : real := 1.0; variable x2 : real := 1.0; variable y : real ; begin P1 (10, F1(b, x1) => x2 ); -- Failure_here end procedure; procedure "and" is -- Error begin end procedure; end package body; nvc-r1.17.1/test/sem/protected.vhd000066400000000000000000000075241504111170000170060ustar00rootroot00000000000000entity e is end entity; architecture a of e is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; end protected SharedCounter; type bad1 is protected procedure foo (x : not_here); -- Error end protected; type bad1 is protected body -- OK end protected body; type bad2 is protected body -- Error end protected body; type boolean is protected body -- Error end protected body; type now is protected body -- Error end protected body; type SharedCounter is protected body variable counter: Integer := 0; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; end protected body; type SharedCounter is protected body -- Error end protected body; subtype s is SharedCounter; -- Error shared variable x : integer; -- Error shared variable y : SharedCounter; -- OK shared variable z : SharedCounter := 1; -- Error function make return SharedCounter is -- Error variable result : SharedCounter; begin return result; end function; procedure proc(variable sh : in SharedCounter := make) is -- error begin end procedure; begin end architecture; architecture a2 of e is type SharedCounter is protected procedure increment (N: Integer := 1); procedure decrement (N: Integer := 1); impure function value return Integer; procedure foo (x : in integer); end protected SharedCounter; type SharedCounter is protected body variable counter: Integer := 0; procedure increment (N: Integer := 1) is begin counter := counter + N; end procedure increment; procedure decrement (N: Integer := 1) is begin counter := counter - N; end procedure decrement; impure function value return Integer is begin return counter; end function value; procedure bar (x : in integer ) is begin null; end procedure; procedure foo (x : in integer ) is begin bar(x + 1); end procedure; end protected body; shared variable x : SharedCounter; -- OK begin process is begin x.increment(2); -- OK x.increment; -- OK x.counter := 5; -- Error x.decrement(1, 2); -- Error assert x.value = 5; -- OK end process; process is function get_value (x : in sharedcounter ) return integer is -- Error begin return x.value; -- Error end function; begin end process; bad_assignment: process variable y : SharedCounter; variable z : SharedCounter; begin y := z; -- Error wait; end process; end architecture; package issue85 is type protected_t is protected procedure add(argument : inout protected_t); -- OK end protected protected_t; end package; package pkg is type protected_t is protected end protected protected_t; type missing_method is protected procedure doit; end protected; end package; package body pkg is type missing_method is protected body -- Missing body for doit end protected body; -- Missing body for protected_t end package body; nvc-r1.17.1/test/sem/protected2.vhd000066400000000000000000000016431504111170000170640ustar00rootroot00000000000000package p is type t_protected is protected end protected; constant c : t_protected; -- Error end package; package body p is type t_protected is protected body end protected body; end package body; use work.p.all; entity e1 is end entity; architecture a1 of e1 is type bad_file_type is file of t_protected; -- Error type t_protected_array is array (0 to 1) of t_protected; -- Error type t_protected_record is record a : integer; b : t_protected; -- Error c : real; end record; signal s : t_protected; -- Error attribute t : t_protected; -- Error component bad_gen is generic ( g1 : t_protected -- Error ); end component; component bad_port is port ( p1 : t_protected -- Error ); end component; begin end architecture; nvc-r1.17.1/test/sem/real.vhd000066400000000000000000000023461504111170000157350ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x : real := 1.234; -- OK type my_real is range 0.0 to 1.0; -- OK begin process is variable v : my_real; begin x <= x + 6.1215; -- OK x <= v; -- Error end process; process is variable i : integer; begin i := integer(x); -- OK x <= real(i); -- OK x <= real(5); -- OK x <= real(bit'('1')); -- Error end process; process is variable x : real; begin x := real'left; -- OK x := real'right; -- OK end process; process is constant i : integer := 5; constant r : real := 252.4; type t is range r to i; -- Error type t2 is range i to r; -- Error type t3 is range integer'range; -- Error begin end process; process is variable t : time; variable r : real; begin r := real(t / 1 ps) * 1.0; -- OK end process; process is type bad is range 1.0 to x; -- Error begin end process; end architecture; nvc-r1.17.1/test/sem/record.vhd000066400000000000000000000113561504111170000162710ustar00rootroot00000000000000package p is type r1 is record -- OK x : integer; y : integer; end record; type r2 is record -- Error x, x : integer; end record; type r3 is record -- Error x : r3; end record; type r4 is record x, y, z : integer; end record; type r5 is record x : r1; y : integer; end record; type r1_vec is array (integer range <>) of r1; type r6 is record x : r1_vec; -- Error end record; end package; package body p is procedure p1 is variable v1 : r1 := (1, 2); -- OK variable v2 : r4 := (1, 2); -- Error variable v3 : r1 := (1, v1); -- Error variable v4 : r1 := (x => 1, y => 2); -- OK variable v5 : r1 := (x => 1); -- Error variable v6 : r1 := (x => 1, y => 2, q => 1); -- Error variable v7 : r1 := (x => 1, y => v1); -- Error variable v8 : r1 := (others => 9); -- OK variable v9 : r1 := (x => 1, others => 2); variable v10 : r1 := (x => 1, x => 2, y => 3); -- Error variable v11 : r1 := (1, x => 4, y => 2); -- Error variable v12 : r1 := (1, y => 4); -- OK variable v13 : r1; begin end procedure; procedure p2 is variable v1 : r1; variable v2 : r5; begin v1.x := 2; v1.y := v1.x + 5; v2.x.x := 3; end procedure; procedure p3 is variable a1 : r1_vec; -- Error begin end procedure; procedure p4 is variable a2 : r1_vec(0 to 3); -- OK begin a2(2).x := 5; -- OK a2(1).f := 2; -- Error a2(0).x := a2(1).y; -- OK end procedure; procedure p5 is subtype r1_sub is r1; -- OK variable a : r1_sub; -- OK begin a.x := 5; -- OK a.y := a.x + 2; -- OK a.z := 2; -- Error end procedure; procedure p6 is subtype r1_bad is r1(1 to 3); -- Error begin end procedure; procedure p7 is type rec is record vec : bit_vector(1 to 3); end record; variable a : rec; begin assert a.vec'length = 3; -- OK end procedure; procedure p8 is function make_r1 return r1 is begin return (x => 1, y => 2); -- OK end function; begin assert make_r1.x = 1; -- OK assert make_r1.z = 2; -- Error end procedure; type int_file is file of integer; type r7 is record a : int_file; end record; type r8 is record a : integer range 1 to 10; end record; procedure p9 is variable x : r8; -- OK begin end procedure; procedure p10 is variable x : r8 := (ack => '1'); -- Error begin end procedure; type line is access string; -- Copied from incorrect code in std.textio procedure read (l : inout line; value : out time; good : out boolean ) is type unit_spec_t is record name : string(1 to 3); length : positive; unit : time; end record; type unit_map_t is array (natural range <>) of unit_spec_t; constant unit_map : unit_spec_t := ( ( "fs ", 2, fs ) ); variable scale, len : integer; variable scale_good : boolean; begin good := false; if not scale_good then return; end if; for i in 0 to 0 loop len := unit_map(i).length; -- Error if l'length > len and l.all(1 to len) = unit_map(i).name(1 to len) then value := scale * unit_map(i).unit; good := true; end if; end loop; end procedure; procedure aggregates is variable r : r1; begin r := (1 => 1); -- Error r := (1, 2, 3); -- Error r := (1, 2, others => 3); -- Error r := (x to y => 4); -- Error r := (x to z => 2); -- Error end procedure; procedure test1 is variable r : foo; -- Error begin r.baz := 1; -- Error end procedure; procedure test2 is procedure sub (x : integer) is begin end procedure; begin sub(x.z => 2); -- Error end procedure; procedure test3 is variable r : r1 := r1'left; -- Error begin end procedure; end package body; nvc-r1.17.1/test/sem/record2008.vhd000066400000000000000000000074231504111170000166030ustar00rootroot00000000000000entity record2008 is end entity; architecture test of record2008 is type rec1 is record x : bit_vector; -- OK end record; constant c1 : rec1 := ( x => "101" ); -- OK signal s1 : rec1; -- Error signal r1 : rec1(x(1 to 3)); -- OK signal r2 : rec1(y(1 to 3)); -- Error signal r3 : rec1(r2(1 to 2)); -- Error type rec2 is record x, y : bit_vector; -- OK a : bit_vector(1 to 3); b : integer; end record; signal r4 : rec2(x(1 to 3), y(1 to 4)); -- OK signal r5 : rec2(x(1 to 3), x(1 to 4)); -- Error signal r6 : rec2(x(1 to 3), p(1 to 4)); -- Error signal r7 : rec2(b(1 to 3)); -- Error signal r8 : rec2(x(1 to 3)); -- Error subtype t1 is rec1(x(1 to 3)); -- OK signal r9 : t1; -- OK subtype t2 is rec1; -- OK signal r10 : t2; -- Error subtype t3 is rec2(x(1 to 5)); -- OK signal r11 : t3(y(1 to 2)); -- OK subtype t4 is t3(y(1 to 1)); -- OK subtype t5 is t4(x(1 to 2)); -- Error type rec3 is record r : rec1; -- OK s : bit_vector; -- OK end record; signal r12 : rec3; -- Error signal r13 : rec3(r(x(1 to 3)), s(1 to 2)); -- OK signal r14 : rec3(s(1 to 2)); -- Error begin p1: process is begin r4.x <= (others => '0'); -- OK end process; -- From UVVM p2: process is type unsigned is array(natural range <>) of bit ; type some_config is record a : unsigned ; b : integer ; end record ; constant FINAL_CONFIG : some_config(a(0 downto 0)) := ( a => (others =>'0'), -- OK b => 20 ) ; constant c2 : some_config(a(0 downto 0)) := ( (others =>'0'), 20 ) ; -- OK begin end process; p3: process is type rec1_vec is array (natural range <>) of rec1; constant c1 : rec1_vec(0 to 0)(x(1 to 3)) := ( -- OK 0 => (x => "111") ); begin end process; -- From "abc" test case provided by Brian Padalino p4: process is type Parameters_t is record BW : natural; PAIRS : natural; end record; type Indices_t is array (natural range <>) of bit_vector; type Bus_t is record Indices : Indices_t; end record; function Test( abc_bus : Bus_t; indices : Indices_t ) return Bus_t is variable result : Bus_t( Indices(abc_bus.Indices'range)(abc_bus.Indices'element'range) ); -- OK begin return result; end function; begin end process; p5: process is procedure test (r : rec1) is variable y : r'subtype; -- OK alias yx : y.x'subtype is y.x; -- OK begin end procedure; begin end process; p6: process is type rec1_array is array (natural range <>) of rec1; variable a1 : rec1_array(1 to 3); -- Error begin end process; p7: process is -- See issue #1155 type ArrayOfSigned is array (natural range <>) of bit_vector; type InterlacedSignal is record Data : ArrayOfSigned; Valid : bit; end record; subtype Interlaced16bSignal is InterlacedSignal(Data(open)(15 downto 0)); variable r : Interlaced16bSignal; -- Error begin end process; p8: process is variable x : not_an_array(1 to 2)(not_a_record(data(open))); -- Error begin end process; end architecture; nvc-r1.17.1/test/sem/resolution.vhd000066400000000000000000000024371504111170000172160ustar00rootroot00000000000000package resolution is type my_utype is (a, b, c); type my_utype_vector is array (natural range <>) of my_utype; subtype my_type_error is bit_vector my_utype; -- Error constant vec : bit_vector(1 to 3) := "101"; subtype my_type_error_2 is vec(1) my_utype; -- Error function resolved (s : my_utype_vector) return my_utype; subtype my_type is resolved my_utype; -- OK subtype my_type_vector is (resolved) my_utype_vector; -- OK subtype my_type_vector_2 is (resolved, resolved) my_utype_vector; -- Error type urec is record x, y : integer; end record; type urec_vector is array (natural range <>) of urec; function resolved (s : urec_vector) return urec; subtype rec is resolved urec; -- OK subtype my_type2 is (resolved) my_utype; -- Error procedure proc (s : my_utype_vector); subtype my_type3 is proc my_utype; -- Error function func1 (s : urec_vector) return my_utype; subtype my_type4 is func1 my_utype; -- Error function func2 (s : my_utype_vector) return urec; subtype my_type5 is func2 my_utype; -- Error type my_utype_vector_vector is array (natural range <>) of my_utype_vector(1 to 3); subtype my_type_vector_vector is ((resolved)) my_utype_vector_vector; end package; nvc-r1.17.1/test/sem/scope.vhd000066400000000000000000000171501504111170000161220ustar00rootroot00000000000000package pack1 is type my_int1 is range 0 to 10; end package; ------------------------------------------------------------------------------- package pack2 is type my_int1 is range 0 to 10; end package; ------------------------------------------------------------------------------- use work.pack1; use work.pack2; entity no_use_clause is port ( a : in pack1.my_int1; -- OK b : out pack2.my_int1 ); -- OK end entity; ------------------------------------------------------------------------------- architecture a of no_use_clause is type my_int1 is range 10 to 50; begin process is begin -- Should fail as types have same name but from different packages b <= a; end process; process is variable v : pack2.my_int1; begin b <= v; -- OK end process; process is variable v : my_int1; begin -- Should fail as local my_int1 distinct from pack1.my_int1 v := a; end process; end architecture; ------------------------------------------------------------------------------- use work.pack1.all; entity foo is generic ( g : my_int1 ); port ( p : in my_int1 ); end entity; ------------------------------------------------------------------------------- architecture a of foo is -- Architecture decls exist in same scope as entity so this should -- generate an error signal g : my_int1; begin end architecture; ------------------------------------------------------------------------------- architecture b of foo is -- Should also generate an error signal p : my_int1; begin end architecture; ------------------------------------------------------------------------------- architecture c of foo is begin -- This is OK as processes define a new scope process is variable p : my_int1; variable g : my_int1; begin g := 6; p := 2; wait for 1 ns; end process; end architecture; ------------------------------------------------------------------------------- entity overload is port ( SI: in bit; SO: out bit ); end ; architecture behave of overload is begin foo_inst: SO <= SI; end behave; ------------------------------------------------------------------------------- use work.all; -- OK entity no_use_clause2 is port ( a : in pack1.my_int1; -- OK b : out my_int1 ); -- Error end entity; ------------------------------------------------------------------------------- package pack3 is type my_enum is (E1, E2, E3); end package; ------------------------------------------------------------------------------- use work.pack3.all; package pack4 is type my_enum_array is array (integer range <>) of my_enum; end package; ------------------------------------------------------------------------------- use work.pack4.all; architecture d of foo is signal x : my_enum_array(1 to 3); -- OK signal y : my_enum_array(1 to 3) := (others => E1); -- Error: E1 not visible begin end architecture; ------------------------------------------------------------------------------- package pack5 is function func1(x : integer) return boolean; function func2(x : integer) return boolean; function "and"(x, y : integer) return boolean; end package; ------------------------------------------------------------------------------- use work.pack5.func1; architecture a2 of foo is begin process is begin assert func1(4); -- OK assert func2(5); -- Error end process; end architecture; ------------------------------------------------------------------------------- use work.pack5.not_here; -- Error architecture a3 of foo is begin end architecture; ------------------------------------------------------------------------------- entity bar is end entity; architecture a4 of bar is begin process is use work.pack1.all; variable x : my_int1; -- OK begin x := 5; end process; process is variable x : my_int1; -- Error begin end process; b: block is use work.pack1; signal x : pack1.my_int1; -- OK begin end block; end architecture; ------------------------------------------------------------------------------- use work.pack5."and"; architecture a5 of bar is begin process is begin assert 1 and 2; -- OK assert work.pack5."and"(1, 2); -- OK assert pack5."and"(1, 2); -- Error end process; end architecture; ------------------------------------------------------------------------------- package pack6 is component bar is end component; end package; ------------------------------------------------------------------------------- use work.pack6.all; architecture a6 of bar is begin process is begin report bar'path_name; -- OK (references entity) end process; end architecture; ------------------------------------------------------------------------------- use foo.bar.all; -- Error architecture a7 of bar is begin end architecture; ------------------------------------------------------------------------------- package pack7 is function foo(x : in integer) return boolean; function foo(y : in real) return boolean; end package; ------------------------------------------------------------------------------- use work.pack7.foo; architecture issue62 of bar is begin process is begin assert foo(integer'(1)); -- OK assert foo(real'(1.6)); -- OK end process; end architecture; ------------------------------------------------------------------------------- use work.all; use work.pack1.all; architecture issue63 of bar is signal x : my_int1; -- OK begin end architecture; ------------------------------------------------------------------------------- package pack8 is function min(x, y : in integer) return integer; end package; ------------------------------------------------------------------------------- use work.pack8.all; -- OK architecture unit_decl_crash of bar is begin process is variable x : integer := min(1, 2); -- OK begin end process; end architecture; ------------------------------------------------------------------------------- architecture labels of bar is signal mySignalVector: bit_vector (7 downto 0); signal myOtherSignal: bit := '1'; begin process begin L1: for i in 0 to 9 loop for i in 0 to 7 loop mySignalVector(i) <= myOtherSignal; report "outer loop i = " & integer'image(L1.i); report "inner loop i = " & integer'image(i); report integer'image(L1.x); -- Error end loop; end loop; wait; end process; end architecture; ------------------------------------------------------------------------------- architecture more_labels of bar is begin p1: process is variable x : boolean; begin p1.x := true; -- OK for x in 1 to 10 loop p1.x := false; -- OK end loop; end process; b1: block is constant x : integer := 2; begin process is variable x : boolean; begin x := true; -- OK assert b1.x = 2; -- OK end process; end block; end architecture; nvc-r1.17.1/test/sem/seq.vhd000066400000000000000000000156261504111170000156070ustar00rootroot00000000000000entity seq is end entity; architecture test of seq is begin -- If statements process is variable v : integer; begin if true then -- OK report "hello"; end if; if 1 then -- Not boolean end if; if false then x := 5; -- Error in statement end if; if true or false then null; else v := true; -- Error in else part end if; if false then null; elsif true then null; elsif x > 2 then g := v; -- Error else v := 1; end if; end process; -- Null statements process is begin null; end process; -- Return statements process is begin return 1; -- Error end process; -- While statements process is variable n : integer := 5; begin while n > 0 loop -- OK n := n - 1; end loop; loop -- OK null; end loop; loop return 5; -- Error end loop; while 5 loop -- Error null; end loop; end process; -- For process is variable v : integer; begin for i in 0 to 10 loop -- OK v := i + 1; end loop; for i in bit'range loop -- OK null; end loop; for i in x'range loop -- Error null; end loop; end process; -- Case process is type letter is (A, B, C); variable l : letter; variable v : bit_vector(0 to 3); constant k : bit := '1'; variable n : bit; variable i : integer; begin l := A; case l is -- OK when a => null; when b | c => null; end case; case l is -- OK when a => null; when others => null; end case; case l is -- Others not last when others => null; when a => null; end case; case l is when l => -- Not locally static null; when others => end case; case v is when "0101" => -- OK null; when "1101" => -- OK null; end case; case v is when (0 to 3 => k) => -- OK null; when (0 to 3 => n) => -- Not locally static null; end case; case i is when 1 => -- OK null; when integer'(5) => -- OK null; when (1 + 5) * 7 => -- OK null; when i + 2 => -- Not locally static null; end case; case bit is -- Error when '1' => null; when '0' => null; end case; case i is when 1 to 6 => -- OK null; when 7 to 6.1612 => -- Error null; end case; case i is when n to k => -- Error null; end case; case i is when 1 to i => -- Error null; end case; end process; -- Exit process is begin loop exit when false; -- OK exit when 1; -- Not boolean end loop; end process; -- Procedure call process is procedure add1(x : in integer; y : out integer) is begin y := x + 1; end procedure; variable a, b : integer; begin add1(a, b); -- OK add1(1, b); -- OK add1(3, 6); -- Error end process; -- Next process is begin loop next when false; -- OK next when 1; -- Not boolean next; -- OK end loop; next; -- Not in loop l1: loop next foo; -- Not a label end loop; l2: loop l3: loop l4: loop next l2; -- OK end loop; end loop; end loop; end process; -- Statement labels dup: process is begin end process; dup: process is begin end process; -- Loop over enumeration process is begin for c in character loop -- OK end loop; for c in integer loop -- OK end loop; for c in real loop -- Error end loop; end process; -- Signal assignment to variable process is variable i : integer; begin i <= 1; -- Error end process; -- Corner cases in discrete range drange: process is begin for i in 1 range 1 to 2 loop -- Error end loop; for i in integer range 1.0 to 2.0 loop -- Error end loop; for i in real range real'(1.0) to real'(2.0) loop -- Error end loop; end process; -- Variable assignment to aggregate process is type int_vec is array (natural range <>) of integer; variable v : int_vec(1 to 2); variable a, b : integer; begin (a, b) := v; -- OK (a, 1) := v; -- Error (v(a), b) := v; -- Error (others => a) := v; -- Error (1 to 2 => a) := v; -- Error (a, a) := v; -- Error end process; -- Wrong class for procedure arguments process is procedure p1(signal x : bit); variable v : bit; begin p1(v); -- Error p1('1'); -- Error end process; -- Invalid use of loop parameter process is procedure p1 (x : out integer); begin for i in 1 to 10 loop i := 5; -- Error p1(i); -- Error end loop; end process; -- Case statement with error in type process is variable x : bad_type; -- Error begin case x is -- Error (suppressed) when others => null; end case; end process; end architecture; nvc-r1.17.1/test/sem/signal.vhd000066400000000000000000000060661504111170000162720ustar00rootroot00000000000000entity e is port ( p : in bit ); end entity; architecture a of e is signal v : bit_vector(1 to 3); signal x, y, z : bit; begin process is begin (x, y, z) <= v; -- OK (x, y, z) <= x; -- Error (x, y, z) <= "101"; -- Error (bit'('1'), y, z) <= v; -- Error (others => x) <= v; -- Error (p, y, z) <= v; -- Error end process; (x, y, z) <= v; -- OK (x, y, z) <= x; -- Error (bit'('1'), y, z) <= v; -- Error (others => x) <= v; -- Error (p, y, z) <= v; -- Error process is variable i : integer; begin (v(i), v(1), v(2)) <= v; -- Error end process; b1: block is procedure proc1 (signal s : out bit) is procedure nested is begin s <= '0'; -- OK end procedure; begin x <= '1'; -- Error s <= '1'; -- OK end procedure; begin end block; b2: block (true) is begin guard <= false; -- Error end block; b3: block is signal guard : integer; begin x <= guarded not x; -- Error end block; b4: block (v) is -- Error begin end block; b5: block is constant guard : boolean := false; begin x <= guarded not x; -- Error x <= null; -- Error end block; b6: block is signal q : integer bus; -- Error begin end block; b7: block is function resolved (x : bit_vector) return bit; subtype rbit is resolved bit; signal s : rbit bus; -- OK disconnect s : rbit after 1 ns; -- OK disconnect 'x' : character after 1 ns; -- Error disconnect v : bit_vector after 1 ns; -- Error disconnect s : bit_vector after 2 ns; -- Error disconnect s : rbit after s; -- Error signal i : integer; disconnect s : rbit after i * ns; -- Error begin end block; b8: block is signal bad : bit := e; -- Error begin end block; b9: block is signal i : integer; begin real(i) <= 5.0; -- Error end block; process is begin (x, x, x) <= v; -- Error end process; b10: block (true) is function resolved (x : bit_vector) return bit; subtype rbit is resolved bit; signal s : rbit bus; -- OK signal t : bit; begin (s, t) <= bit_vector'("10"); -- Error (s, t) <= guarded bit_vector'("10"); -- Error with t select s <= guarded '1' when '0', -- OK '0' when others; with t select s <= '1' when '0', -- Error (missed) '0' when others; end block; end architecture; nvc-r1.17.1/test/sem/spec1.vhd000066400000000000000000000031521504111170000160210ustar00rootroot00000000000000entity c1_ent1 is end entity; ------------------------------------------------------------------------------- package p is end package; ------------------------------------------------------------------------------- entity e is end entity; architecture a of e is -- Errors detected in decls component c1 is end component; component c2 is end component; for i1: c2 use entity work.c1_ent1; -- Error for i1: e use entity work.c1_ent1; -- Error for i8: c1 use entity work.c1_ent1; -- OK for bad: c1 use entity work.c1_ent1; -- Error for i2: c1 use entity work.c1_ent1; -- Error for i1: c1 use entity work.c1_ent1; -- Error for i3: c1 use entity work.not_here; -- Error for i3: c1 use entity work.p; -- Error for all: c2 use entity work.c1_ent1; -- OK for i5: c1 use entity work.c1_ent1; -- Error for all: c2 use entity work.c1_ent1; -- Error for others: c1 use entity work.c1_ent1; -- OK for i7: c1 use open; -- OK begin i1: component c1; i2: entity work.e; i3: component c1; i4: component c2; b1: block is begin i5: component c1; end block; i6: component c1; i7: component c1; i8: component c1; end architecture; architecture a2 of e is -- Errors detected in stmts component c1 is end component; component c2 is end component; for i1: c2 use entity work.c1_ent1; -- Error for i2: c1 use entity work.c1_ent1; -- Error begin i1: component c1; i2: entity work.e; end architecture; nvc-r1.17.1/test/sem/spec2.vhd000066400000000000000000000040651504111170000160260ustar00rootroot00000000000000entity ent1 is generic ( g1 : integer; g2 : boolean := true ); port ( p1 : in bit; p2 : out bit; p3 : in integer := 0 ); end entity; architecture dummy of ent1 is begin end architecture; configuration ent1cfg of ent1 is for dummy end for; end configuration; ------------------------------------------------------------------------------- entity test is end entity; architecture test of test is component comp1 is port ( p1 : in bit; p2 : out bit; p3 : in integer := 0 ); end component; for u1 : comp1 use entity work.ent1 -- OK generic map ( g1 => 5 ); for u2 : comp1 use entity work.ent1; -- Error component comp2 is generic ( g3 : integer ); port ( p4 : out bit ); end component; for u3 : comp2 use entity work.ent1 -- OK generic map ( g1 => g3 ) port map ( p1 => '0', p2 => p4 ); for u4 : comp2 use entity work.ent1 -- Error port map ( p1 => '0', p2 => p4 ); component comp3 is generic ( g2 : boolean := true; g1 : integer ); port ( p2 : out bit; p1 : in bit; p3 : in integer := 0 ); end component; for u5 : comp3 use entity work.ent1; -- OK for u6 : comp3 use configuration work.ent1cfg; -- OK for u7 : comp3 use configuration work.ent1cfg generic map ( g1 => 5 ); -- OK (?) begin u1: component comp1 port map ( '1', open ); u2: component comp1 port map ( '1', open ); u3: component comp2 generic map ( g3 => 5 ) port map ( open ); u4: component comp2 generic map ( g3 => 5 ) port map ( open ); u5: component comp3 generic map ( g1 => 2 ) port map ( open, '1' ); u6: component comp3 generic map ( g1 => 2 ) port map ( open, '1' ); u7: component comp3 generic map ( g1 => 2 ) port map ( open, '1' ); u8: component comp3 generic map ( g1 => 2 ) port map ( open, '1' ); end architecture; nvc-r1.17.1/test/sem/static.vhd000066400000000000000000000056631504111170000163060ustar00rootroot00000000000000entity static is generic ( G : integer := 1 ); end entity; architecture test of static is begin process is subtype byte is bit_vector(7 downto 0); variable bv : byte; variable i : integer; attribute hello : integer; attribute hello of bv : variable is 6; begin case i is when bv'length => -- OK null; when bv'left => -- OK null; when byte'right => -- OK null; when bv'hello => -- OK null; when others => null; end case; end process; process is variable v : bit_vector(3 downto 0); constant c : bit_vector := "1010"; constant d : bit_vector(G downto 0) := (others => '0'); begin case v is when c => -- OK null; when others => null; end case; case v is when d => -- Error null; when others => null; end case; end process; end architecture; ------------------------------------------------------------------------------- entity sub is generic ( N : integer ); port ( x : bit_vector ); end entity; architecture test of sub is signal y : bit_vector(N - 1 downto 0) := (others => '0') ; begin sub_i: entity work.sub generic map ( N => N ) port map ( x => x(x'left downto x'right) ); -- Error gen1: for i in y'range generate -- OK end generate; b1: block is type r is record x, y : integer; end record; signal x : r := (1, 2); begin gen2: if (N, 2) = r'(1, 2) generate -- OK end generate; end block; sub2_i: entity work.sub generic map ( N => N ) port map ( x(N downto 0) => x ); -- Error process is type rec is record f1, f2 : integer; end record; subtype rs is rec; -- OK constant rc : rs := (0, 0); -- OK constant i : integer := rc.f1; -- OK begin end process; p1: process is constant t : time := -5 ns; -- OK, globally static begin end process; p2: process is constant n : integer := bad_func(2); -- Error subtype t is integer range 0 to n - 1; -- Crash in sem_locally_static begin end process; p3: process is constant STR : string := "abc"; variable v : string(1 to 3); begin case v is when STR => null; -- OK end case; end process; p4: process is constant N1 : integer := N + 1; variable v : bit_vector(7 downto 0); alias a is v(N1 downto 0); -- OK begin end process; end architecture; nvc-r1.17.1/test/sem/std.vhd000066400000000000000000000010721504111170000155770ustar00rootroot00000000000000entity a is end entity; architecture b of a is signal i : integer := 5; signal t : time := 5 fs; signal c : character := 'x'; subtype my_time is time; constant x : my_time := my_time'left + 5 ns; begin process is begin wait for 4 ns; t <= now; end process; process is -- Default values variable a : time; variable b : my_time; begin end process; process is variable t : time := -1 ns; variable u : time := 1.2 ns; begin end process; end architecture; nvc-r1.17.1/test/sem/subtype.vhd000066400000000000000000000012271504111170000165020ustar00rootroot00000000000000package p is -- Reduced failure case from VESTs type ibi is array (integer range <>, boolean range <>) of integer ; subtype irange is integer range 1 to 5 ; subtype brange is boolean range false to true ; subtype ibi_s is ibi (irange, brange); -- OK subtype ibi_x is ibi (brange, irange); -- Error type int_vec is array (integer range <>) of integer; function resolved(x : int_vec) return integer; signal rint1 : resolved integer; -- OK signal rint2 : not_here integer; -- Error constant k : integer := 5; type bit_vector_array is array (natural range <>) of bit_vector(k downto 0); end package; nvc-r1.17.1/test/sem/supersede.vhd000066400000000000000000000005541504111170000170100ustar00rootroot00000000000000entity portlisttest is port ( signal a: in bit; signal b: out bit ); end entity; entity portlisttest is end entity; architecture foo of portlisttest is signal a: bit; signal b: bit; begin DUT: entity work.portlisttest --(fum) port map ( a => a, b => b ); end architecture; nvc-r1.17.1/test/sem/tc251.vhd000066400000000000000000000035221504111170000156450ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc251.vhd,v 1.2 2001-10-26 16:29:48 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- ENTITY c03s01b02x00p04n01i00251ent IS END c03s01b02x00p04n01i00251ent; ARCHITECTURE c03s01b02x00p04n01i00251arch OF c03s01b02x00p04n01i00251ent IS type I1 is range 1 to 10; type I2 is range 11 to 20; constant V1: I1 := 1; constant V2: I2 := 20; type I5 is range V1 to V2; BEGIN TESTING: PROCESS variable k : integer := 6; BEGIN k := 5; assert NOT(k=5) report "***PASSED TEST: c03s01b02x00p04n01i00251" severity NOTE; assert (k=5) report "***FAILED TEST: c03s01b02x00p04n01i00251 - Range constraints in integer type definition need not be of the same integer type." severity ERROR; wait; END PROCESS TESTING; END c03s01b02x00p04n01i00251arch; nvc-r1.17.1/test/sem/tc792.vhd000066400000000000000000000046271504111170000156660ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc792.vhd,v 1.2 2001-10-26 16:30:00 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c01s01b02x00p03n01i00792pkg is constant k : integer := 5; function wired_and (sig : bit_vector) return bit; end c01s01b02x00p03n01i00792pkg; package body c01s01b02x00p03n01i00792pkg is function wired_and (sig : bit_vector) return bit is begin return '0'; end wired_and; end c01s01b02x00p03n01i00792pkg; ENTITY c01s01b02x00p03n01i00792ent_1 IS GENERIC (CONSTANT a : bit); ALIAS alias_identifier : bit IS a ; END c01s01b02x00p03n01i00792ent_1 ; ENTITY c01s01b02x00p03n01i00792ent_2 IS GENERIC (CONSTANT a : bit); ATTRIBUTE my_name : integer; END c01s01b02x00p03n01i00792ent_2 ; ENTITY c01s01b02x00p03n01i00792ent_4 IS GENERIC (CONSTANT a : bit); USE work.c01s01b02x00p03n01i00792pkg.ALL; END c01s01b02x00p03n01i00792ent_4 ; use work.c01s01b02x00p03n01i00792pkg.all; ENTITY c01s01b02x00p03n01i00792ent_5 IS port (signal a : in wired_and bit bus); DISCONNECT a:bit AFTER 100 ns; END c01s01b02x00p03n01i00792ent_5 ; -------------------------------- ENTITY vests37 IS END vests37; ARCHITECTURE c01s01b02x00p03n01i00792arch OF vests37 IS BEGIN TESTING: PROCESS BEGIN assert FALSE report "***PASSED TEST: c01s01b02x00p03n01i00792" severity NOTE; wait; END PROCESS TESTING; END c01s01b02x00p03n01i00792arch; nvc-r1.17.1/test/sem/textio.vhd000066400000000000000000000032001504111170000163140ustar00rootroot00000000000000package textio is type line is access string; type text is file of string; type side is (RIGHT, LEFT); subtype width is natural; file input : text open READ_MODE is "STD_INPUT"; file output : text open WRITE_MODE is "STD_OUTPUT"; end package; package body textio is procedure grow (l : inout line; extra : in natural; old_size : out natural ) is variable tmp : line; begin if l = null then l := new string(1 to extra); old_size := 0; elsif extra > 0 then old_size := l'length; tmp := new string(1 to l'length + extra); -- OK tmp(1 to l'length) := l.all; deallocate(l); l := tmp; end if; end procedure; procedure shrink (l : inout line; size : in natural) is variable tmp : line; begin assert l /= null; if size < l'length then tmp := new string(1 to size); tmp.all := l.all(1 to size); deallocate(l); l := tmp; end if; end procedure; procedure consume (l : inout line; nchars : in natural) is variable tmp : line; begin if nchars = 0 then return; end if; assert l /= null; if nchars = l'length then tmp := new string'(""); else assert nchars <= l'length; tmp := new string(1 to l'length - nchars); -- OK tmp.all := l.all(1 + nchars to l'length); end if; deallocate(l); l := tmp; end procedure; end package body; nvc-r1.17.1/test/sem/universal.vhd000066400000000000000000000011531504111170000170150ustar00rootroot00000000000000entity e is end entity; architecture a of e is begin process is variable r : real; variable i : integer; begin r := 1.5 * 2; -- Error r := r * 2; -- Error r := 6 * 5.15; -- Error r := i * 1.51; -- Error r := 62.3 / 6; -- Error r := 1.51 / i; -- Error r := real(1.5 * 2); -- OK r := real(6 * 5.15); -- OK r := real(62.3 / 6); -- OK wait; end process; end architecture; nvc-r1.17.1/test/sem/use.vhd000066400000000000000000000017361504111170000156100ustar00rootroot00000000000000package pkg1 is type my_int1 is range 1 to 10; type my_int2 is range 1 to 10; type my_int3 is range 1 to 10; end package; ------------------------------------------------------------------------------- package pkg2 is use work.pkg1.my_int2; -- OK function func return my_int2; end package; package body pkg2 is use work.pkg1.my_int1; -- OK constant x : my_int1 := 2; -- OK function func return my_int2 is -- OK use work.pkg1.my_int3; -- OK variable y : my_int3; -- OK begin return 0; end function; constant y : my_int3; -- Error end package body; ------------------------------------------------------------------------------- entity ent is use work.pkg1.my_int1; -- OK constant c : my_int1 := 2; -- OK use work.spam; -- Error use work.1; -- Error end entity; nvc-r1.17.1/test/sem/varinit.vhd000066400000000000000000000033471504111170000164700ustar00rootroot00000000000000entity computation is end entity; package my_logic is type std_logic is ('0', '1'); type std_logic_vector is array (natural range <>) of std_logic; type unsigned is array (natural range <>) of std_logic; type signed is array (natural range <>) of std_logic; function to_integer(x : unsigned) return integer; end package; use work.my_logic.all; architecture foo of computation is signal size :std_logic_vector (7 downto 0) := "00001001"; -- architecture declarative part begin UNLABELLED: process variable N: integer := to_integer(unsigned'("00000111")) ; ---WORKING type memory is array (N downto 0 ) of std_logic_vector (31 downto 0 ); variable ram: memory; begin report "UNLABELLED memory left bound = " &integer'image(N); wait; end process; OTHER: process variable N: integer:= to_integer (unsigned(size)) ; -- Not working type memory is array (N downto 0 ) of std_logic_vector (31 downto 0 ); variable ram: memory; begin report "OTHER memory left bound = " &integer'image(N); wait; end process; size <= "01000010" after 1 ns; block1: block is constant N: integer:= to_integer (unsigned(size)) ; -- OK (since 1.16) constant M: integer := size'length; -- OK constant P: boolean := size'event; -- OK (since 1.16) begin end block; end architecture; architecture bar of computation is signal N : integer := 5; signal bad : bit_vector(1 to N); -- OK (since 1.16) signal x : integer range 1 to N; -- OK (since 1.16) signal y : bit_vector(1 to bad'length); -- OK subtype my_int is integer range 1 to N; -- OK (since 1.16) begin end architecture; nvc-r1.17.1/test/sem/vests1.vhd000066400000000000000000000036661504111170000162450ustar00rootroot00000000000000 -- Copyright (C) 2001 Bill Billowitch. -- Some of the work to develop this test suite was done with Air Force -- support. The Air Force and Bill Billowitch assume no -- responsibilities for this software. -- This file is part of VESTs (Vhdl tESTs). -- VESTs is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the -- Free Software Foundation; either version 2 of the License, or (at -- your option) any later version. -- VESTs is distributed in the hope that it will be useful, but WITHOUT -- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. -- You should have received a copy of the GNU General Public License -- along with VESTs; if not, write to the Free Software Foundation, -- Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- --------------------------------------------------------------------- -- -- $Id: tc914.vhd,v 1.2 2001-10-26 16:30:02 paw Exp $ -- $Revision: 1.2 $ -- -- --------------------------------------------------------------------- package c10s03b00x00p07n01i00914pkg is type c10s03b00x00p07n01i00914pkg is (a,b); end c10s03b00x00p07n01i00914pkg; use work.all; ENTITY c10s03b00x00p07n01i00914ent IS END c10s03b00x00p07n01i00914ent; ARCHITECTURE c10s03b00x00p07n01i00914arch OF c10s03b00x00p07n01i00914ent IS signal S : c10s03b00x00p07n01i00914pkg.c10s03b00x00p07n01i00914pkg; BEGIN TESTING: PROCESS use work.c10s03b00x00p07n01i00914pkg.all; BEGIN S <= a after 5 ns; wait for 10 ns; assert NOT( S = a ) report "***PASSED TEST: c10s03b00x00p07n01i00914" severity NOTE; assert ( S = a ) report "***FAILED TEST: c10s03b00x00p07n01i00914 - A primary unit of a library can be made visible by selection." severity ERROR; wait; END PROCESS TESTING; END c10s03b00x00p07n01i00914arch; nvc-r1.17.1/test/sem/vhdl2008.vhd000066400000000000000000000060311504111170000162540ustar00rootroot00000000000000entity vhdl2008 is generic ( g : integer ); end entity; architecture test of vhdl2008 is signal s : integer; begin process is variable x, y : integer; begin x := 1 when y > 2 else 5; -- OK x := 5 when x; -- Error x := 1 when x < 1 else false; -- Error end process; -- Changes to locally static rules process is type r is record k : bit; end record; constant c : bit_vector(1 to 3) := "101"; constant d : r := ( k => '1' ); variable x : bit; variable y : r; variable i : integer; begin case x is when c(1) => null; -- OK when d.k => null; -- OK when c(i) => null; -- Error when others => null; end case; end process; -- 'SUBTYPE attribute process is variable x : integer; begin x := baz'subtype(4); -- Error report to_string(x'subtype); -- Error end process; g1: case g generate -- OK when 5 => s <= 2; when g => -- OK s <= 3; when s => -- Error s <= 5; end generate; -- Range in aggregate target process is variable v : integer_vector(1 to 2); variable a, b : integer; begin (1 to 2 => v) := v; -- OK (1 to 2 => a) := v; -- Error end process; -- Changes to closely related types process is variable i : integer_vector(1 to 3); variable r : real_vector(1 to 3); variable b : boolean_vector(1 to 3); begin i := integer_vector(i); -- OK r := real_vector(i); -- OK b := boolean_vector(i); -- Error end process; -- Changes to globally static attribute rules b1: block is type t_rec is record x : bit_vector; end record; signal s : t_rec(x(1 to 5)); begin b2: block is port ( p : t_rec ); port map ( s ); begin g1: for i in p.x'range generate -- OK end generate; g2: for i in q.x'range generate -- Error end generate; end block; end block; -- Port maps with non-globally-static expressions b2: block is type t_array is array (natural range <>) of integer; signal s : integer; function get_array (signal s : integer; constant x : integer) return t_array is begin return (1 to 3 => s + x); end function; begin sub1: block is port ( p1 : t_array ); port map ( p1 => get_array(s, 5) ); -- Error begin end block; end block; -- Type interface declaration in parameter list b3: block is function test2 ( type t ) return bit is -- Error begin end function; begin end block; end architecture; nvc-r1.17.1/test/sem/vital1.vhd000066400000000000000000000005231504111170000162050ustar00rootroot00000000000000package vital1 is TYPE VitalTransitionType IS ( tr01, tr10, tr0z, trz1, tr1z, trz0, tr0X, trx1, tr1x, trx0, trxz, trzx); SUBTYPE VitalDelayType IS TIME; TYPE VitalDelayType01 IS ARRAY (VitalTransitionType RANGE tr01 to tr10) OF TIME; -- OK end package; nvc-r1.17.1/test/sem/wait.vhd000066400000000000000000000027271504111170000157610ustar00rootroot00000000000000entity a is end entity; architecture b of a is signal x, y : bit; signal z : bit_vector(3 downto 0); alias xa is x; alias za : bit is z(2); begin -- wait for process is begin wait for ps; wait for 5 ns; wait for 2 * 4 hr; wait for 523; -- Not TIME type end process; -- wait on process is variable v : bit; begin wait on x; wait on x, y; wait on v; -- Not signal end process; -- process sensitivity process (x, y) is begin x <= y; end process; process (x, a) is -- Bad name a begin x <= '1'; end process; process (x) is begin x <= y; wait for 1 ns; -- Not allowed wait end process; -- wait until process is begin wait until true; wait until x = '1'; wait until x; -- Not boolean wait until y = x for 1 ns; wait until y = x for x; -- Not time end process; -- Alias in sensitivity list process (xa, za) is begin end process; -- Wait on scalar sub-elements and slices process is variable i : integer; begin wait on z(1), za, z(2 downto 1); wait on z(i); -- Not static end process; process (now) is -- Error begin end process; end architecture; nvc-r1.17.1/test/shell/000077500000000000000000000000001504111170000146255ustar00rootroot00000000000000nvc-r1.17.1/test/shell/describe1.vhd000066400000000000000000000002741504111170000171740ustar00rootroot00000000000000entity describe1 is end entity; architecture test of describe1 is signal x : integer := 5; begin b1: block is signal y : bit; begin end block; end architecture; nvc-r1.17.1/test/shell/examine1.vhd000066400000000000000000000010341504111170000170350ustar00rootroot00000000000000entity examine1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of examine1 is signal x : integer := 5; signal y : integer; signal a : std_logic := '1'; signal b : std_logic_vector(3 downto 0) := "01XU"; signal s : string(1 to 5) := "hello"; signal ss : string(1 to 2) := (1 => 'a', others => nul); type t is (foo, bar, baz); type t_vec is array (natural range <>) of t; signal v : t_vec(1 to 3) := (foo, bar, baz); signal p : time := 42 ns; begin end architecture; nvc-r1.17.1/test/shell/force1.vhd000066400000000000000000000011341504111170000165060ustar00rootroot00000000000000entity force1 is end entity; architecture test of force1 is signal x : bit; signal y : integer; signal z : bit_vector(1 to 3); begin x <= '0'; y <= 55; z <= "001"; tb: process is begin wait for 1 ns; assert x = '0'; assert y = 55; assert z = "001"; wait for 1 ns; assert x = '1'; assert y = 42; assert z = "110"; wait for 1 ns; assert x = '0'; assert y = 42; wait for 1 ns; assert y = 55; assert z = "001"; wait; end process; end architecture; nvc-r1.17.1/test/shell/wave1.vhd000066400000000000000000000006471504111170000163620ustar00rootroot00000000000000entity sub is port ( y : in bit ); end entity; architecture test of sub is begin end architecture; ------------------------------------------------------------------------------- entity wave1 is end entity; architecture test of wave1 is signal x : bit; signal b : boolean; begin x <= '1' after 1 ns, '0' after 2 ns; b <= true after 1 ns; u: entity work.sub port map ( x ); end architecture; nvc-r1.17.1/test/simp/000077500000000000000000000000001504111170000144665ustar00rootroot00000000000000nvc-r1.17.1/test/simp/allsens.vhd000066400000000000000000000037271504111170000166430ustar00rootroot00000000000000entity allsens is end entity; architecture test of allsens is type bv_array is array (natural range <>) of bit_vector(1 to 3); signal x, y : bit; signal v : bit_vector(1 to 3); signal z : bv_array(1 to 3); signal n : integer range v'range := 3; constant c : bit_vector(1 to 3) := "101"; begin p0: process (all) is -- (y) begin x <= y; end process; p1: assert v(1) = '0'; -- v(1) p2: assert v(n) = '0'; -- v, n p3: assert z(1)(2) = '0'; -- z(1)(2) p4: assert z(n)(2) = '0'; -- z, n p5: assert z(2)(n) = '0'; -- z(2), n p6: assert v(1 to 2) = "00"; -- v(1 to 2) p7: assert v(1 to n) = "00"; -- v, n p8: assert z(n)(1 to 2) = "00"; -- z, n p9: assert z(1 to 2)(n) = "000"; -- z(1 to 2), n p10: process (all) is -- n, y begin v(n) <= y; end process; p11: process (all) is -- n, y, v(1), z(1) variable b : bit_vector(0 to 1); begin if n > 5 then x <= y; else b(bit'pos(v(1))) := z(1)(n); end if; end process; p12: process (all) is -- x, v(1), v(2) procedure proc (signal s : out bit) is begin s <= v(2); end procedure; begin case x is when '0' => v(2) <= v(1); when '1' => proc(y); end case; end process; p13: process (all) is -- n, v begin for i in 1 to n loop assert v(i) = '1'; end loop; while n < 5 loop n <= n + 1; end loop; end process; p14: v <= x & y & v(2); -- x, y, v(2) p15: x <= c(n); -- n p16: process (all) is -- v(1) begin v(2) <= v(1); v(3) <= v(1); end process; end architecture; nvc-r1.17.1/test/simp/args.vhd000066400000000000000000000007741504111170000161350ustar00rootroot00000000000000entity args is end entity; architecture a of args is function func(x, y : in integer) return integer is begin return x + y; end function; procedure proc(x, y : in integer := 55) is begin end procedure; begin process is variable a, b, c : integer; begin c := func(x => a, y => b); c := func(a, y => b); c := func(y => b, x => a); proc(y => b, x => a); proc(y => a); wait; end process; end architecture; nvc-r1.17.1/test/simp/casearray1.vhd000066400000000000000000000011451504111170000172250ustar00rootroot00000000000000entity casearray1 is end entity; library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; architecture test of casearray1 is signal x : std_logic_vector(7 downto 0); signal y : integer; begin p1: process is constant b : boolean_vector := not (true, false); begin case x is when X"1" & X"2" => y <= 1; when X"1" & not X"2" => y <= 2; when X"12" or X"52" => y <= 3; when std_logic_vector(to_unsigned(42, 8)) => y <= 4; when others => null; end case; wait; end process; end architecture; nvc-r1.17.1/test/simp/casefold1.vhd000066400000000000000000000033101504111170000170270ustar00rootroot00000000000000-- Test case from Adam Barnes -- package mycomp_pkg is type int_array is array(natural range <>) of integer; component mycomp is generic ( mygen : int_array(1 to 6) ); port ( i : in bit; o : out bit ); end component mycomp; end package mycomp_pkg; -------------------------------------------------------------------------------- library work; use work.mycomp_pkg.all; entity mycomp is generic ( mygen : int_array(1 to 6) ); port ( i : in bit; o : out bit ); end entity mycomp; architecture sim of mycomp is begin o <= not i; casep: process begin --case mygen(1) is case 1 is when 0 to 128 => report "value of mygen(1) is in range 0..128; value is " & integer'image(mygen(1)); when others => report "value of mygen(1) is NOT in range 0..128; value is " & integer'image(mygen(1)) severity failure; end case; wait; end process; end architecture; entity top is end entity top; library work; use work.mycomp_pkg.all; architecture sim of top is signal test : bit; constant mygen : int_array := (0,1,2,3,4,5); begin process begin case mygen(1) is when 0 to 128 => report "value of mygen(1) is in range 0..128; value is " & integer'image(mygen(1)); when others => report "value of mygen(1) is NOT in range 0..128; value is " & integer'image(mygen(1)); end case; wait; end process; UUT: component mycomp generic map ( mygen => mygen ) port map ( i => test, o => open ); end architecture sim; nvc-r1.17.1/test/simp/casegen.vhd000066400000000000000000000004561504111170000166030ustar00rootroot00000000000000entity casegen is end entity; architecture test of casegen is constant k : integer := 5; signal s : integer; begin g1: case k generate when 1 => s <= 2; when 2 => s <= 3; when five: 5 => s <= 7; when others => s <= 99; end generate; end architecture; nvc-r1.17.1/test/simp/cfold.vhd000066400000000000000000000073451504111170000162710ustar00rootroot00000000000000entity e is end entity; architecture a of e is signal x : integer := -3 * 4 + 2; type t is range -5 to 11 - 3; constant c : integer := +4 + 1; signal y : t; type int_array is array (integer range <>) of integer; constant a1 : int_array(1 to 5) := (1, 2, 3, 4, 5); constant a2 : int_array(1 to 7) := (2 to 3 => 6, others => 5); constant a3 : int_array(1 to 9) := (8 => 24, others => 0); constant a4 : int_array(5 downto 1) := (1, 2, 3, 4, 5); constant a5 : int_array(5 downto 1) := (5 downto 3 => -1, others => 1); begin process is variable b : boolean; variable d : time; begin x <= c / 2; y <= t'high; y <= t'left; b := t'right = 8; b := (t'right - t'left) = 2; b := t'high /= 2; b := true and true; b := true and false; b := true or false; b := true xor true; b := not true; b := not false; b := true xnor false; b := false nand false; b := false nor true; b := 7 > 5 and 6 < 2; x <= a1(2); x <= a2(1); x <= a2(3); x <= a3(8); x <= a1'length; x <= a4(2); x <= a5(4); x <= 2 ** 4; d := -5 ns; end process; process is begin if true then x <= 1; end if; if false then x <= 5; end if; if false then null; else x <= 5; end if; while false loop null; end loop; if true then x <= 1; x <= 5; null; end if; end process; process is variable r : real; variable b : boolean; begin r := 1.0 + 0.0; r := 1.5 * 4.0; r := 2.0 / 2.0; b := 4.6 > 1.2; end process; process variable k : time; begin end process; process type int2_vec is array (66 to 67) of integer; variable b : boolean; begin b := a1'length = 5; b := a1'low(1) = 1; b := a1'high(1) = 5; b := a1'left = 1; b := a1'right = 5; b := int2_vec'length = 2; b := int2_vec'low = 66; end process; process is begin case 1 is when 1 => null; when 2 => x <= 1; when others => report "bang"; end case; end process; process is variable r : real; begin r := real(1.5 * 2); r := real(3 * 0.2); r := real(5.0 / 2); r := 2.0 ** 4; end process; process is constant one : bit := '1'; variable b : boolean; begin b := one = '1'; b := '0' /= one; end process; -- Billowitch tc3170 tc3170: process is constant L : REAL := -10.0; constant R : REAL := 10.0; type RT1 is range L to R; begin assert ( RT1'right = RT1(R) ); -- Should be removed end process; bitvec: process is variable b : boolean; begin b := ("101" and "110") = "100"; b := ("110" and "011") = "010"; b := ("101" or "110") = "111"; b := not "101" = "010"; b := ("001" or "010") = "011"; b := ("101" nor "110") = "000"; b := ("101" nand "110") = "011"; b := ("101" nor "110") = "000"; end process; -- Billowitch tc2256 tc2256: process variable i : integer; begin i := 1 mod 0; -- should yield divide-by-zero error end process; -- Billowitch tc2705 tc2705: process is constant i : real := 0.12; constant m : real := 1.2e-1; begin assert abs(i-m) < 0.00000000001; -- True end process; end architecture; nvc-r1.17.1/test/simp/concat.vhd000066400000000000000000000012731504111170000164430ustar00rootroot00000000000000package concat is constant c1 : bit_vector := "1" & "00"; constant c2 : string := "xy" & "z"; constant c3 : bit_vector := '1' & '0'; constant c4 : string := "fo" & 'o'; constant c5 : integer_vector := 0 & 1; -- (A_POS, A_POS) constant c6 : integer_vector := (0 & 1) & 2; -- (A_POS, A_POS, A_POS) constant c7 : integer_vector := c5 & 2; -- (A_CONCAT, A_POS) constant c8 : integer_vector := 0 & (1 & 2); -- (A_POS, A_POS, A_POS) constant c9 : integer_vector := 1 & c8; -- (A_POS, A_CONCAT) constant c10 : integer_vector := c5 & c6; -- (A_CONCAT, A_CONCAT) constant c11 : integer_vector := 1 & 2 & 3 & 4; -- (A_POS, A_POS, A_POS, A_POS) end package; nvc-r1.17.1/test/simp/condexpr.vhd000066400000000000000000000007311504111170000170140ustar00rootroot00000000000000entity condexpr is end entity; architecture test of condexpr is constant c1 : integer := 1 when 1 > 2 else 5; function foo (x : integer) return integer is begin return 2 when x > 1 else unaffected; return 5 when x < 5 else 7; return 7 when x = 2; end function; procedure bar (x : integer) is begin return when x = 2; return when 2 = 3; return when 1 = 1; end procedure; begin end architecture; nvc-r1.17.1/test/simp/condvar.vhd000066400000000000000000000004041504111170000166230ustar00rootroot00000000000000entity condvar is end entity; architecture test of condvar is begin process is variable x, y : integer; begin x := 1 when y > 2 else 5; -- OK x := 1 when y > 2 else unaffected; -- OK end process; end architecture; nvc-r1.17.1/test/simp/constarr.vhd000066400000000000000000000011261504111170000170240ustar00rootroot00000000000000package pack is function bit_to_char (b : bit) return character; end package; package body pack is function bit_to_char (b : bit) return character is type table_t is array (bit) of character; constant table : table_t := ( '0' => '0', '1' => '1' ); -- OK begin return table(b); end function; end package body; entity constarr is end entity; use work.pack.all; architecture a of constarr is constant c1 : character := bit_to_char('1'); constant c2 : character := bit_to_char('0'); begin end architecture; nvc-r1.17.1/test/simp/context.vhd000066400000000000000000000005741504111170000166630ustar00rootroot00000000000000-- Library foo package pack is end package; ------------------------------------------------------------------------------- -- Library bar context test_context is library foo; use foo.pack.all; end context; ------------------------------------------------------------------------------- -- Library bar library foo; context foo.test_context; entity foo is end entity; nvc-r1.17.1/test/simp/conv1.vhd000066400000000000000000000021041504111170000162140ustar00rootroot00000000000000entity conv1 is end entity; architecture test of conv1 is type natural_vector is array (natural range <>) of natural; type nat3_vector is array (1 to 3) of natural; type int2d is array (natural range <>, natural range <>) of integer; type nat2d is array (natural range <>, natural range <>) of natural; type byte_array1 is array (natural range <>) of bit_vector(1 to 8); type byte_array2 is array (natural range <>) of bit_vector(7 downto 0); function func1 (x : in natural_vector) return natural_vector is constant padding : integer_vector(1 to (4-(x'length mod 4))) := (others => 0); begin return natural_vector(padding); -- Should not fold end function; begin p1: process is constant c1 : natural_vector(1 to 3) := natural_vector(integer_vector'(1, 2, 3)); constant c2 : nat3_vector := nat3_vector(integer_vector'(1, 2, 3)); constant c3 : nat2d := nat2d(int2d'((1, 2), (3, 4))); constant c4 : byte_array1 := byte_array1(byte_array2'(X"01", X"02")); begin end process; end architecture; nvc-r1.17.1/test/simp/copysub.vhd000066400000000000000000000007451504111170000166630ustar00rootroot00000000000000entity sub is generic ( n : natural ); end entity; architecture test of sub is function get_n return integer is begin return n; end function; constant x : natural := get_n; begin end architecture; ------------------------------------------------------------------------------- entity top is end entity; architecture test of top is begin sub_1: entity work.sub generic map ( 5 ); sub_2: entity work.sub generic map ( 10 ); end architecture; nvc-r1.17.1/test/simp/cpcall.vhd000066400000000000000000000006071504111170000164320ustar00rootroot00000000000000entity cpcall is end entity; architecture test of cpcall is procedure test1 (signal a, b : in bit) is begin assert a = b; end procedure; procedure test2 (signal a, b : in bit) is begin if a = b then wait for 1 ns; end if; end procedure; signal x, y : bit; begin p0: test1(x, y); p1: test2(x, y); end architecture; nvc-r1.17.1/test/simp/ffold.vhd000066400000000000000000000202171504111170000162650ustar00rootroot00000000000000package pack is function add4(x : in integer) return integer; function add1(x : in integer) return integer; function log2(x : in integer) return integer; function case1(x : in integer) return integer; function adddef(x, y : in integer := 5) return integer; function chain1(x : string) return boolean; function chain2(x, y : string) return boolean; function flip(x : bit_vector(3 downto 0)) return bit_vector; type real_vector is array (natural range <>) of real; function lookup(index : integer) return real; function get_bitvec(x, y : integer) return bit_vector; function approx(x, y : real; t : real := 0.001) return boolean; function get_string(x : integer) return string; function get_string(x : real) return string; function get_string(x : character) return string; function get_string(x : time) return string; function needs_heap(x : integer) return integer; function sum_left_right(x : bit_vector) return integer; procedure p5(x : in integer; y : out integer); function call_proc(x : in integer) return integer; type rec is record x : bit_vector(1 to 3); y : integer; end record; function make_rec(x : bit_vector(1 to 3); y : integer) return rec; function min(x, y : integer) return integer; function get_left(x : bit_vector) return bit; function test_alloc_proc(a, b, c : string) return boolean; function test_logic(x, y : bit) return bit; function test_div(x, y : integer) return integer; end package; package body pack is function add4(x : in integer) return integer is begin return x + 4; end function; function add1(x : in integer) return integer is begin return x + 1; end function; function log2(x : in integer) return integer is variable r : integer := 0; variable c : integer := 1; begin --while true loop --end loop; if x <= 1 then r := 1; else while c < x loop r := r + 1; c := c * 2; end loop; end if; return r; end function; function case1(x : in integer) return integer is begin case x is when 1 => return 2; when 2 => return 3; when others => return 5; end case; end function; function adddef(x, y : in integer := 5) return integer is begin return x + y; end function; function chain1(x : string) return boolean is variable r : boolean := false; begin if x = "hello" then r := true; end if; return r; end function; function chain2(x, y : string) return boolean is variable r : boolean := false; begin if chain1(x) or chain1(y) then r := true; end if; return r; end function; function flip(x : bit_vector(3 downto 0)) return bit_vector is variable r : bit_vector(3 downto 0); begin r(0) := x(3); r(1) := x(2); r(2) := x(1); r(3) := x(0); return r; end function; function lookup(index : integer) return real is constant table : real_vector := ( 0.62, 61.62, 71.7, 17.25, 26.15, 651.6, 0.45, 5.761 ); begin return table(index); end function; function get_bitvec(x, y : integer) return bit_vector is variable r : bit_vector(x to y) := "00"; begin return r; end function; function approx(x, y : real; t : real := 0.001) return boolean is begin return abs(x - y) < t; end function; function get_string(x : integer) return string is begin return integer'image(x); end function; function get_string(x : real) return string is begin return real'image(x); end function; function get_string(x : character) return string is begin return character'image(x); end function; function get_string(x : time) return string is begin return time'image(x); end function; function needs_heap(x : integer) return integer is begin if integer'image(x)'length = 2 then return x * 2; else return x / 2; end if; end function; function sum_left_right(x : bit_vector) return integer is begin return x'left + x'right; end function; procedure p5(x : in integer; y : out integer) is variable k : integer := x + 1; begin y := k; end procedure; function call_proc(x : in integer) return integer is variable y : integer; begin p5(x, y); return y; end function; function make_rec(x : bit_vector(1 to 3); y : integer) return rec is variable r : rec; begin r.x := x; r.y := y; return r; end function; function min(x, y : integer) return integer is begin if x > y then return y; else return x; end if; end function; function get_left(x : bit_vector) return bit is constant l : integer := x'left; variable v : bit_vector(1 to x'right); constant m : integer := min(x'length, v'length) + 1; begin return x(l); end function; type line is access string; procedure cat_str(x : inout line; s : in string) is variable tmp : line := x; variable len : integer := 0; begin if x /= null then len := x.all'length; end if; x := new string(1 to s'length + len); if tmp /= null then x.all(1 to len) := tmp.all; end if; x.all(1 + len to s'length + len) := s; if tmp /= null then deallocate(tmp); end if; end procedure; function test_alloc_proc(a, b, c : string) return boolean is variable l : line; variable r : boolean; begin cat_str(l, a); cat_str(l, b); r := l.all = c; deallocate(l); return r; end function; function test_logic(x, y : bit) return bit is begin return (x and y) xor (x or y) xor (x nand y) xor (x nor y) xor (x xnor y); end function; function test_div(x, y : integer) return integer is begin return x / y; -- Need to evaluate zero check end function; end package body; ------------------------------------------------------------------------------- entity ffold is end entity; use work.pack.all; architecture a of ffold is begin b1: block is signal s0 : integer := add1(5); signal s1 : integer := add4(1); signal s2 : integer := log2(11); signal s3 : integer := log2(integer(real'(5.5))); signal s4 : integer := case1(1); signal s5 : integer := case1(7); signal s6 : integer := adddef; signal s7 : boolean := chain2("foo", "hello"); signal s8 : boolean := flip("1010") = "0101"; signal s9 : boolean := flip("1010") = "0111"; signal s10 : real := lookup(0); -- 0.62; signal s11 : real := lookup(2); -- 71.7; signal s12 : boolean := get_bitvec(1, 2) = "00"; signal s13 : boolean := approx(1.0000, 1.0001); signal s14 : boolean := approx(1.0000, 1.01); signal s15 : boolean := get_string(5) = "5"; signal s16 : boolean := get_string(2.5) = "2.5"; signal s17 : boolean := get_string('F') = "'F'"; signal s18 : boolean := get_string(1 fs) = "1 fs"; signal s19 : integer := needs_heap(40); signal s20 : integer := sum_left_right("101010"); signal s21 : integer := call_proc(1); signal s22 : boolean := make_rec("010", 20).y = 20; signal s23 : boolean := get_left("1010") = '1'; signal s24 : boolean := make_rec("010", 4).x = "010"; signal s25 : boolean := test_alloc_proc("hello", "world", "helloworld"); signal s26 : boolean := test_alloc_proc("hello", "moo", "hellomoowee"); signal s27 : bit := test_logic('1', '0'); signal s28 : integer := test_div(5, 2); begin end block; end architecture; nvc-r1.17.1/test/simp/ffold2.vhd000066400000000000000000000011351504111170000163450ustar00rootroot00000000000000package pack is function nested(x : integer) return integer; end package; package body pack is function nested(x : integer) return integer is variable result : integer; procedure add1 is begin result := result + 1; end procedure; begin result := x; add1; add1; return result; end function; end package body; entity ffold2 is end entity; use work.pack.all; architecture test of ffold2 is begin b1: block is constant c1 : integer := nested(1); -- 3 begin end block; end architecture; nvc-r1.17.1/test/simp/foreign1.vhd000066400000000000000000000007641504111170000167120ustar00rootroot00000000000000entity foreign1 is end entity; architecture test of foreign1 is function f (x : integer) return integer; attribute foreign of f : function is "VHPIDIRECT symbol"; function f (x : integer) return integer is begin return 99; -- Should not call this end function; function g (x : integer) return integer is begin return f(x) + 1; end function; constant c1 : integer := g(1); -- Should not fold begin end architecture; nvc-r1.17.1/test/simp/func9.vhd000066400000000000000000000010311504111170000162100ustar00rootroot00000000000000entity func9 is end entity; architecture test of func9 is constant msg0 : string := "zero"; constant msg1 : string := "one"; function get_message(x : in bit) return string is begin case x is when '0' => return msg0; when '1' => return msg1; end case; end function; begin g1: if get_message('1') /= "one" generate a1: assert false; end generate; g2: if get_message('0') /= "zero" generate a1: assert false; end generate; end architecture; nvc-r1.17.1/test/simp/genmap.vhd000066400000000000000000000012621504111170000164410ustar00rootroot00000000000000entity sub1 is generic ( x : integer := 5; y : bit_vector(1 to 3) ); end entity; package pack is type rec is record x, y : integer; end record; end package; use work.pack.all; entity sub2 is generic ( r : rec ); end entity; entity genmap is end entity; use work.pack.all; architecture test of genmap is begin u1: entity work.sub1 generic map ( y => ('1', '1', '0'), x => 2 ); u2: entity work.sub1 generic map ( y => "101" ); u3: entity work.sub1 generic map ( 0, y(1) => '1', y(2) => '0', y(3) => '1' ); u4: entity work.sub2 generic map ( r.y => 3, r.x => 2 ); end architecture; nvc-r1.17.1/test/simp/genpack1.vhd000066400000000000000000000014511504111170000166630ustar00rootroot00000000000000package pack is generic ( x : string := "foo" ) ; constant s : string := x ; constant t : string := "hello" ; constant k : integer; end package ; package body pack is constant k : integer := 42; end package body; ------------------------------------------------------------------------------- package pack2 is new work.pack generic map (x => "bar") ; ------------------------------------------------------------------------------- entity genpack1 is end entity; use work.pack2.all; architecture test of genpack1 is function get_length (s : string) return integer is begin return s'length; end function; begin p1: process is begin assert k = 42; assert s = "bar"; assert t = "hello"; wait; end process; end architecture; nvc-r1.17.1/test/simp/genpack2.vhd000066400000000000000000000010261504111170000166620ustar00rootroot00000000000000package pack1 is generic (x, y : integer); constant c : integer := x + y; end package; ------------------------------------------------------------------------------- package pack2 is generic (package p is new work.pack1 generic map (<>)); end package; ------------------------------------------------------------------------------- package pack3 is generic (package p is new work.pack2 generic map (<>)); -- Should not simplify package pi is new work.pack1 generic map (1, 2); -- Should fold C end package; nvc-r1.17.1/test/simp/gentype.vhd000066400000000000000000000013231504111170000166430ustar00rootroot00000000000000package cmp_pkg is generic ( type t; function cmp_fn (x, y : t) return boolean ); function equal (a, b : t) return boolean; end package; package body cmp_pkg is function equal (a, b : t) return boolean is begin return cmp_fn(a, b); end function; end package body; ------------------------------------------------------------------------------- entity gentype2 is end entity; architecture test of gentype2 is package cmp_int is new work.cmp_pkg generic map ( t => integer, cmp_fn => "=" ); use cmp_int.all; begin main: process is begin assert equal(4, 4); assert not equal(5, 6); wait; end process; end architecture; nvc-r1.17.1/test/simp/grlib1.vhd000066400000000000000000000012121504111170000163450ustar00rootroot00000000000000package config_types is constant cfg_width : integer := 1; type config_vec_t is array (0 to 16) of integer; end package; ------------------------------------------------------------------------------- use work.config_types.all; package config is constant cfg_vec : config_vec_t := ( cfg_width => 2, others => 0); end package; ------------------------------------------------------------------------------- use work.config.all; use work.config_types.all; package types is constant width : integer := 2 * cfg_vec(cfg_width); type rec is record x : bit_vector(1 to width); end record; end package; nvc-r1.17.1/test/simp/guard.vhd000066400000000000000000000004741504111170000163000ustar00rootroot00000000000000entity guard is end entity; architecture test of guard is signal value : natural := 0; signal output : natural; begin b1: block (value < 10) is begin p1: output <= guarded value * 2; p2: with output select value <= guarded output + 1 when others; end block; end architecture; nvc-r1.17.1/test/simp/ieee1.vhd000066400000000000000000000003431504111170000161610ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; package ieee1 is constant b1 : std_logic := '1' ?= '1'; -- '1' constant b2 : std_logic := '1' ?= '0'; -- '0' constant b3 : std_logic := 'H' ?= '1'; -- '1' end package; nvc-r1.17.1/test/simp/issue1182.vhd000066400000000000000000000014741504111170000166430ustar00rootroot00000000000000package str is signal s : integer; end package str; ------------------------------------------------------------------------------- use work.str.all; package const is type unsigned is array (natural range <>) of bit; constant C_ADDRESS : unsigned(4 downto 0) := "00001"; end package const; ------------------------------------------------------------------------------- use work.const.all; entity test is end entity; architecture beh of test is signal address : bit_vector(4 downto 0); begin p_proc : process begin assert C_ADDRESS = "00001" report "Address 1 wrong " & to_string(C_ADDRESS) severity failure; address <= bit_vector(C_ADDRESS); assert C_ADDRESS = "00001" report "Address 2 wrong " & to_string(C_ADDRESS) severity failure; wait; end process; end architecture; nvc-r1.17.1/test/simp/issue1239.vhd000066400000000000000000000003431504111170000166400ustar00rootroot00000000000000entity bug is end entity bug; architecture tb of bug is type arr_t is array(0 to 1) of bit_vector(1 downto 0); begin process is begin report to_string(arr_t'element'length); wait; end process; end architecture; nvc-r1.17.1/test/simp/issue155.vhd000066400000000000000000000006431504111170000165570ustar00rootroot00000000000000package issue155 is type W_TYPE is record A : integer; B : integer; C : integer; end record; constant W : W_TYPE := (A => 8, B => 4, C => 2); signal A : bit_vector(W.A-1 downto 0); signal B : bit_vector(W.B-1 downto 0); signal C : bit_vector(W.C-1 downto 0); constant V : W_TYPE := (1, 2, 3); signal D : bit_vector(V.C-1 downto V.A); end package; nvc-r1.17.1/test/simp/issue194.vhd000066400000000000000000000010431504111170000165550ustar00rootroot00000000000000package pkg is function other_fun return integer; function fun return integer; end package; package body pkg is function other_fun return integer is begin return 0; end function; function fun return integer is function nested return integer is begin return other_fun; end; begin return nested; end function; end package body; use work.pkg.all; entity issue194 is end entity; architecture a of issue194 is begin main : process begin assert fun = 0; wait; end process; end architecture; nvc-r1.17.1/test/simp/issue212.vhd000066400000000000000000000014421504111170000165470ustar00rootroot00000000000000package pack is function func(x : string) return boolean; end package; package body pack is function func2(x : string) return boolean; function func(x : string) return boolean is begin return func2(x); end function; function func2(x : string) return boolean is variable r : boolean; begin if x = "StratixHC" then r := true; end if; return r; end function; end package body; ------------------------------------------------------------------------------- entity issue212 is generic ( device : string := "StratixHC" ); end entity; use work.pack.all; architecture test of issue212 is signal s : bit; begin gen: if func(device) generate s <= '1'; end generate; end architecture; nvc-r1.17.1/test/simp/issue309.vhd000066400000000000000000000023121504111170000165530ustar00rootroot00000000000000-- test_ng.vhd entity issue309 is end issue309; architecture MODEL of issue309 is function check return boolean is constant org_data : bit_vector(31 downto 0) := "01110110010101000011001000010000"; variable val_data : bit_vector(31 downto 0); begin val_data := (others => '0'); for i in 7 downto 0 loop val_data(31 downto 4) := val_data(27 downto 0); val_data( 3 downto 0) := org_data(i*4+3 downto i*4); end loop; return (val_data = org_data); end function; function check2 return boolean is constant org_data : bit_vector(0 to 31) := "01110110010101000011001000010000"; variable val_data : bit_vector(0 to 31); begin val_data := (others => '0'); for i in 7 downto 0 loop val_data(4 to 31) := val_data(0 to 27); val_data(0 to 3) := org_data(i*4 to i*4+3); end loop; return (val_data = org_data); end function; constant c : boolean := check; constant d : boolean := check2; begin g1: if c generate assert true report "c"; end generate; g2: if d generate assert true report "d"; end generate; end MODEL; nvc-r1.17.1/test/simp/issue320.vhd000066400000000000000000000014001504111170000165410ustar00rootroot00000000000000package TEST_PACKAGE is type CHANNEL_TYPE is ( CHANNEL_0, CHANNEL_1, CHANNEL_2 ); end TEST_PACKAGE; use WORK.TEST_PACKAGE.all; entity ISSUE320 is end ISSUE320; architecture MODEL of ISSUE320 is function GEN_INIT_VALUE(CHANNEL: CHANNEL_TYPE) return integer is variable value : integer; begin case CHANNEL is when CHANNEL_1 => value := 1; when CHANNEL_2 => value := 2; when others => value := 0; end case; return value; end function; -- Strange error about not being able to find a libary as '.' in -- mangled function name wrongly interpreted constant INIT_VALUE : integer := GEN_INIT_VALUE(CHANNEL_0); begin end MODEL; nvc-r1.17.1/test/simp/issue321.vhd000066400000000000000000000017441504111170000165550ustar00rootroot00000000000000package pack is function MAX(A,B:integer) return integer; function CALC_DATA_SIZE(WIDTH:integer) return integer; end package; package body pack is function MAX(A,B:integer) return integer is begin if (A > B) then return A; else return B; end if; end function; function CALC_DATA_SIZE(WIDTH:integer) return integer is variable value : integer; begin value := 0; -- Crashed here as result of ** was real while (2**(value) < WIDTH) loop value := value + 1; end loop; return value; end function; end package body; use work.pack.all; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is constant T_DATA_WIDTH : integer := 12; constant M_DATA_WIDTH : integer := 23; constant BUF_DATA_BITS : integer := MAX(T_DATA_WIDTH, M_DATA_WIDTH); constant BUF_DATA_BIT_SIZE : integer := CALC_DATA_SIZE(BUF_DATA_BITS); begin end; nvc-r1.17.1/test/simp/issue322.vhd000066400000000000000000000010751504111170000165530ustar00rootroot00000000000000use std.textio.all; entity TEST_NG is end TEST_NG; architecture MODEL of TEST_NG is type TEST_TYPE is record name : LINE; end record; function NEW_TEST(NAME: STRING) return TEST_TYPE is variable self : TEST_TYPE; begin WRITE(self.name, NAME); return self; end function; begin process -- Crashed here as cannot evaluate vcode null -- ... but also an access type cannot be constant folded variable t : TEST_TYPE := NEW_TEST(string'("test")); begin end process; end MODEL; nvc-r1.17.1/test/simp/issue331.vhd000066400000000000000000000041441504111170000165530ustar00rootroot00000000000000-- issue331.vhd entity ISSUE331 is generic ( INFO_BITS : integer := 1; INFO_1_VAL : integer := 0 ); port ( I_INFO_0 : in bit_vector(INFO_BITS-1 downto 0); I_INFO_1 : in bit_vector(INFO_BITS-1 downto 0); O_INFO_0 : out bit_vector(INFO_BITS-1 downto 0); O_INFO_1 : out bit_vector(INFO_BITS-1 downto 0) ); end ISSUE331; architecture MODEL of ISSUE331 is type INFO_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; end record; type VEC_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; INFO_0 : INFO_RANGE_TYPE; INFO_1 : INFO_RANGE_TYPE; end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable d_pos : integer; variable v : VEC_RANGE_TYPE; procedure SET_INFO_RANGE(INFO_RANGE: inout INFO_RANGE_TYPE; BITS: in integer) is begin INFO_RANGE.DATA_LO := d_pos; INFO_RANGE.DATA_HI := d_pos + BITS-1; d_pos := d_pos + BITS; end procedure; begin d_pos := 0; v.DATA_LO := d_pos; SET_INFO_RANGE(v.INFO_0, INFO_BITS); if (INFO_1_VAL /= 0) then SET_INFO_RANGE(v.INFO_1, INFO_BITS); end if; v.DATA_HI := d_pos - 1; if (INFO_1_VAL = 0) then SET_INFO_RANGE(v.INFO_1, INFO_BITS); end if; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal i_data : bit_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); begin i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO) <= I_INFO_0; O_INFO_0 <= i_data(VEC_RANGE.INFO_0.DATA_HI downto VEC_RANGE.INFO_0.DATA_LO); INFO_1: if (INFO_1_VAL /= 0) generate i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO) <= I_INFO_1; O_INFO_1 <= i_data(VEC_RANGE.INFO_1.DATA_HI downto VEC_RANGE.INFO_1.DATA_LO); end generate; end MODEL; nvc-r1.17.1/test/simp/issue332.vhd000066400000000000000000000014721504111170000165550ustar00rootroot00000000000000-- test_ng.vhd entity TEST_REGS is generic ( REGS_BITS : integer := 32 ); port ( CLK : in bit; RST : in bit; REGS_WEN : in bit_vector(REGS_BITS-1 downto 0); REGS_WDATA : in bit_vector(REGS_BITS-1 downto 0); REGS_RDATA : out bit_vector(REGS_BITS-1 downto 0) ); end TEST_REGS; architecture RTL of TEST_REGS is type UNSIGNED is array (NATURAL range <> ) of BIT; constant NAU: UNSIGNED(0 downto 1) := (others => '0'); function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED is begin return ARG; end RESIZE; signal curr_value : unsigned(REGS_BITS-1 downto 0); signal x : boolean; begin REGS_RDATA <= bit_vector(RESIZE(curr_value, REGS_RDATA'length)); x <= regs_rdata'event; end RTL; nvc-r1.17.1/test/simp/issue344.vhd000066400000000000000000000010241504111170000165510ustar00rootroot00000000000000package pkg is type type_t is (a,b,c,d); function type_t_image(data : type_t) return string; end package; package body pkg is function type_t_image(data : type_t) return string is begin return type_t'image(data); end; end; use work.pkg.all; entity bug is end entity; architecture arch of bug is begin main : process begin assert type_t_image(a) = "a"; assert type_t_image(b) = "b"; assert type_t_image(c) = "c"; assert type_t_image(d) = "d"; report "Success"; wait; end process; end; nvc-r1.17.1/test/simp/issue345.vhd000066400000000000000000000017261504111170000165630ustar00rootroot00000000000000package pkg is function func (s : string) return natural; function func2 (s : natural) return natural; function func3(x : integer) return integer; end package; package body pkg is function func(s : string) return natural is function inner_func return natural is begin return s'length; end; begin return inner_func; end; function func2(s : natural) return natural is function inner_func return natural is begin return s; end; begin return inner_func; end; function func3(x : integer) return integer is function inner(n : integer) return integer is begin return x + n; end function; begin return inner(2); end function; end; use work.pkg.all; entity bug is end entity; architecture a of bug is begin main : process begin s1: assert func("") = 0; s2: assert func("abc") = 3; s3: assert func2(10) = 10; s4: assert func3(5) = 7; wait; end process; end; nvc-r1.17.1/test/simp/issue362.vhd000066400000000000000000000013441504111170000165560ustar00rootroot00000000000000entity bug is end entity; architecture a of bug is type enum_t is (enum0, enum1); subtype enum_subtype_t is enum_t; type enum_vec_t is array (natural range <>) of enum_t; function resolve_enum(values : enum_vec_t) return enum_t; subtype resolved_enum_t is resolve_enum enum_t; function resolve_enum(values : enum_vec_t) return enum_t is begin return values(0); end; function func return enum_t is begin return enum_subtype_t'low; end; function func2 return enum_t is begin return resolved_enum_t'high; end; begin main : process is begin -- Should both be optimised out during constant folding assert func = enum_t'low; assert func2 = enum_t'high; wait; end process; end; nvc-r1.17.1/test/simp/issue425.vhd000066400000000000000000000142461504111170000165630ustar00rootroot00000000000000----------------------------------------------------------------------------------- -- Used to crash randomly during constant folding ----------------------------------------------------------------------------------- package SMPL_TYPES is constant SMPL_ADDR_MAX_WIDTH : integer := 64; constant SMPL_DATA_MAX_WIDTH : integer := 1024; constant SMPL_STRB_MAX_WIDTH : integer := SMPL_DATA_MAX_WIDTH/8; constant SMPL_SIZE_MAX_WIDTH : integer := 8; constant SMPL_INFO_WIDTH : integer := 4; subtype SMPL_INFO_TYPE is bit_vector(SMPL_INFO_WIDTH-1 downto 0); constant SMPL_RESP_WIDTH : integer := 2; subtype SMPL_RESP_TYPE is bit_vector(SMPL_RESP_WIDTH-1 downto 0); type SMPL_A_SIGNALS_TYPE is record ADDR : bit_vector(SMPL_ADDR_MAX_WIDTH-1 downto 0); WRITE : bit; SIZE : bit_vector(SMPL_SIZE_MAX_WIDTH-1 downto 0); INFO : SMPL_INFO_TYPE; VALID : bit; READY : bit; end record; constant SMPL_A_SIGNALS_DONTCARE : SMPL_A_SIGNALS_TYPE := ( ADDR => (others => '1'), WRITE => '1', SIZE => (others => '1'), INFO => (others => '1'), VALID => '1', READY => '1' ); constant SMPL_A_SIGNALS_NULL : SMPL_A_SIGNALS_TYPE := ( ADDR => (others => '0'), WRITE => '0', SIZE => (others => '0'), INFO => (others => '0'), VALID => '0', READY => '0' ); type SMPL_W_SIGNALS_TYPE is record DATA : bit_vector(SMPL_DATA_MAX_WIDTH-1 downto 0); STRB : bit_vector(SMPL_STRB_MAX_WIDTH-1 downto 0); VALID : bit; READY : bit; end record; constant SMPL_W_SIGNALS_DONTCARE : SMPL_W_SIGNALS_TYPE := ( DATA => (others => '1'), STRB => (others => '1'), VALID => '1', READY => '1' ); constant SMPL_W_SIGNALS_NULL : SMPL_W_SIGNALS_TYPE := ( DATA => (others => '0'), STRB => (others => '0'), VALID => '0', READY => '0' ); type SMPL_R_SIGNALS_TYPE is record DATA : bit_vector(SMPL_DATA_MAX_WIDTH-1 downto 0); RESP : SMPL_RESP_TYPE; VALID : bit; READY : bit; end record; constant SMPL_R_SIGNALS_DONTCARE : SMPL_R_SIGNALS_TYPE := ( DATA => (others => '1'), RESP => (others => '1'), VALID => '1', READY => '1' ); constant SMPL_R_SIGNALS_NULL : SMPL_R_SIGNALS_TYPE := ( DATA => (others => '0'), RESP => (others => '0'), VALID => '0', READY => '0' ); type SMPL_B_SIGNALS_TYPE is record RESP : SMPL_RESP_TYPE; VALID : bit; READY : bit; end record; constant SMPL_B_SIGNALS_DONTCARE : SMPL_B_SIGNALS_TYPE := ( RESP => (others => '1'), VALID => '1', READY => '1' ); constant SMPL_B_SIGNALS_NULL : SMPL_B_SIGNALS_TYPE := ( RESP => (others => '0'), VALID => '0', READY => '0' ); type SMPL_SIGNALS_TYPE is record AR : SMPL_A_SIGNALS_TYPE; AW : SMPL_A_SIGNALS_TYPE; R : SMPL_R_SIGNALS_TYPE; W : SMPL_W_SIGNALS_TYPE; B : SMPL_B_SIGNALS_TYPE; end record; constant SMPL_SIGNALS_DONTCARE : SMPL_SIGNALS_TYPE := ( AR => SMPL_A_SIGNALS_DONTCARE, AW => SMPL_A_SIGNALS_DONTCARE, R => SMPL_R_SIGNALS_DONTCARE, W => SMPL_W_SIGNALS_DONTCARE, B => SMPL_B_SIGNALS_DONTCARE ); end SMPL_TYPES; ----------------------------------------------------------------------------------- -- ----------------------------------------------------------------------------------- use WORK.SMPL_TYPES.all; entity CHANNEL_PLAYER is generic ( CHANNEL : integer; MASTER : boolean := FALSE ); end CHANNEL_PLAYER; architecture MODEL of CHANNEL_PLAYER is function GEN_INIT_signals return SMPL_SIGNALS_TYPE is variable value : SMPL_SIGNALS_TYPE; begin value := SMPL_SIGNALS_DONTCARE; if (MASTER) then case CHANNEL is when 1 => value.AR := SMPL_A_SIGNALS_NULL; value.AR.READY := '1'; when 2 => value.AW := SMPL_A_SIGNALS_NULL; value.AW.READY := '1'; when 3 => value.W := SMPL_W_SIGNALS_NULL; value.W.READY := '1'; when 4 => value.R := SMPL_R_SIGNALS_DONTCARE; value.R.READY := '0'; when 5 => value.B := SMPL_B_SIGNALS_DONTCARE; value.B.READY := '0'; when others => null; end case; end if; return value; end function; constant INIT_SIGNALS : SMPL_SIGNALS_TYPE := GEN_INIT_SIGNALS; begin process variable out_signals : SMPL_SIGNALS_TYPE; begin out_signals := INIT_SIGNALS; wait; end process; end MODEL; ----------------------------------------------------------------------------------- -- ----------------------------------------------------------------------------------- entity MASTER_PLAYER is end MASTER_PLAYER; architecture MODEL of MASTER_PLAYER is begin C0: entity WORK.CHANNEL_PLAYER generic map (0, FALSE); C1: entity WORK.CHANNEL_PLAYER generic map (1, TRUE ); C2: entity WORK.CHANNEL_PLAYER generic map (2, TRUE ); C3: entity WORK.CHANNEL_PLAYER generic map (3, TRUE ); C4: entity WORK.CHANNEL_PLAYER generic map (4, TRUE ); C5: entity WORK.CHANNEL_PLAYER generic map (5, TRUE ); end MODEL; ----------------------------------------------------------------------------------- -- ----------------------------------------------------------------------------------- entity issue425 is end issue425; architecture MODEL of issue425 is begin M: entity WORK.MASTER_PLAYER; S: entity WORK.MASTER_PLAYER; end MODEL; nvc-r1.17.1/test/simp/issue436.vhd000066400000000000000000000015571504111170000165660ustar00rootroot00000000000000entity issue436 is end entity; architecture MODEL of issue436 is type VEC_RANGE_TYPE is record DATA_LO : integer; DATA_HI : integer; end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable v : VEC_RANGE_TYPE; begin v.DATA_HI := 31; v.DATA_LO := 0; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal data : bit_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); type int_vector is array (natural range <>) of integer; function get_array return int_vector is variable v : int_vector(1 to 3); begin v := (1, 2, 3); return v; end function; constant c2 : int_vector := get_array; signal data2 : bit_vector(c2(2) downto 0); begin end MODEL; nvc-r1.17.1/test/simp/issue437.vhd000066400000000000000000000026331504111170000165630ustar00rootroot00000000000000entity SAMPLE is generic ( DATA_BITS : integer := 0 ); port ( DATA : bit_vector(DATA_BITS-1 downto 0) ); end entity; architecture RTL of SAMPLE is begin end RTL; entity issue437 is generic( DATA_BITS : integer := 8 ); end entity; architecture MODEL of issue437 is type VEC_RANGE_TYPE is record VAL_LO : integer; VAL_HI : integer; DATA_LO : integer; DATA_HI : integer; end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable v_pos : integer; variable d_pos : integer; variable v : VEC_RANGE_TYPE; procedure SET_DATA_RANGE(DATA_RANGE: inout VEC_RANGE_TYPE; BITS: in integer) is begin v_pos := v_pos + 1; d_pos := d_pos + BITS + 1; end procedure; begin v_pos := 0; d_pos := 0; v.VAL_LO := v_pos; v.DATA_LO := d_pos; SET_DATA_RANGE(v, DATA_BITS); v.VAL_HI := v_pos - 1; v.DATA_HI := d_pos - 1; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal data : bit_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); begin U: entity WORK.SAMPLE generic map(DATA_BITS => data'length) port map(DATA => data); end MODEL; nvc-r1.17.1/test/simp/issue438.vhd000066400000000000000000000034071504111170000165640ustar00rootroot00000000000000-- test_ng.vhd library ieee; use ieee.std_logic_1164.all; entity ISSUE438 is generic( INFO_SIZE : integer := 1; INFO_BITS : integer := 8 ); end entity; architecture MODEL of ISSUE438 is type INFO_RANGE_TYPE is record VAL_POS : integer; DATA_LO : integer; DATA_HI : integer; end record; type INFO_RANGE_VECTOR is array (integer range <>) of INFO_RANGE_TYPE; type VEC_RANGE_TYPE is record VAL_LO : integer; VAL_HI : integer; DATA_LO : integer; DATA_HI : integer; INFO_LIST : INFO_RANGE_VECTOR(INFO_SIZE-1 downto 0); end record; function SET_VEC_RANGE return VEC_RANGE_TYPE is variable v_pos : integer; variable d_pos : integer; variable v : VEC_RANGE_TYPE; procedure SET_INFO_RANGE(INFO_RANGE: inout INFO_RANGE_TYPE; BITS: in integer) is begin INFO_RANGE.VAL_POS := v_pos; INFO_RANGE.DATA_LO := d_pos; INFO_RANGE.DATA_HI := d_pos + BITS-1; v_pos := v_pos + 1; d_pos := d_pos + BITS; end procedure; begin v_pos := 0; d_pos := 0; v.VAL_LO := v_pos; v.DATA_LO := d_pos; for i in 0 to INFO_SIZE-1 loop SET_INFO_RANGE(v.INFO_LIST(i), INFO_BITS); end loop; v.VAL_HI := v_pos - 1; v.DATA_HI := d_pos - 1; return v; end function; constant VEC_RANGE : VEC_RANGE_TYPE := SET_VEC_RANGE; signal data : std_logic_vector(VEC_RANGE.DATA_HI downto VEC_RANGE.DATA_LO); begin end MODEL; nvc-r1.17.1/test/simp/issue49.vhd000066400000000000000000000006511504111170000165000ustar00rootroot00000000000000entity issueA is generic ( L : integer range 0 to integer'high ); begin end entity issueA; architecture a of issueA is pure function fL ( iDUMMY : boolean ) return integer is begin if (L < 1) then return 1; else return L; end if; end function fL; constant cL : integer range 1 to integer'high := fL(true); begin end architecture a; nvc-r1.17.1/test/simp/issue496.vhd000066400000000000000000000007411504111170000165660ustar00rootroot00000000000000package test_pkg is type rec is record f : integer; end record; signal s : rec; function get_length( constant msg_id : in natural) return natural; end package; package body test_pkg is function get_length( constant msg_id : in natural) return natural is begin return 1; end function; end package body; entity test is end entity; use work.test_pkg.all; architecture rtl of test is constant one : integer := get_length(1); begin end architecture; nvc-r1.17.1/test/simp/issue574.vhd000066400000000000000000000006231504111170000165620ustar00rootroot00000000000000library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package test is type t_memory_map_array is array (natural range 0 to 10) of natural; constant C_VER : unsigned(4 downto 0) := "00001"; constant C_MEMORY_MAP_ITEM_DEFAULT : natural := 0; constant C_MEMORY_MAP_DEFAULT : t_memory_map_array := ( to_integer(C_VER) => 1, others => C_MEMORY_MAP_ITEM_DEFAULT); end package; nvc-r1.17.1/test/simp/issue742.vhd000066400000000000000000000005241504111170000165570ustar00rootroot00000000000000PACKAGE tb_test_package IS CONSTANT C_VEC : bit_vector(2 DOWNTO 0) := "111"; PROCEDURE test ( o: OUT bit ); END PACKAGE tb_test_package; PACKAGE BODY tb_test_package IS PROCEDURE test ( o: OUT bit ) IS BEGIN IF C_VEC /= "000" THEN o := '1'; ELSE o := '0'; END IF; END test; END PACKAGE BODY tb_test_package; nvc-r1.17.1/test/simp/issue782.vhd000066400000000000000000000025521504111170000165660ustar00rootroot00000000000000library ieee; use ieee.math_real.all; package top_pkg is function log2_ceil ( val: natural) return natural; end package top_pkg; package body top_pkg is function log2_ceil ( val: natural) return natural is begin return integer(ceil(log2(real(val) + 1.0))); end function log2_ceil; end package body top_pkg; use work.top_pkg.log2_ceil; package test_pkg is type t_segment_type is ( VERSION_NUMBER ); constant C_MAX_WORD_LENGTH : natural := 3; constant C_MAX_ADDR_WIDTH : natural := log2_ceil(4095); type t_data_segment is record word_idx : bit_vector(C_MAX_ADDR_WIDTH - 1 downto 0); word_length : natural range 0 to C_MAX_WORD_LENGTH; end record t_data_segment; type t_data_segment_template is array(t_segment_type) of t_data_segment; constant C_SEGMENT_RECORDS : t_data_segment_template := ( VERSION_NUMBER => t_data_segment'( word_idx => (others => '0'), word_length => 1) ); end package; use work.test_pkg.all; entity test is end entity test; architecture beh of test is signal segment_word : t_data_segment; begin b_block : block is signal calib_version_tmp : bit_vector(C_SEGMENT_RECORDS(VERSION_NUMBER).word_length * 8 - 1 downto 0); begin process begin report "OK 2"; wait; end process; end block; end architecture beh; nvc-r1.17.1/test/simp/issue812.vhd000066400000000000000000000010721504111170000165540ustar00rootroot00000000000000entity sub is generic ( G : integer ); end entity; architecture test of sub is signal x : integer; begin p: process is begin if x = 1 then report "one"; elsif g = 2 then report "two"; else report "other"; end if; wait; end process; end architecture; ------------------------------------------------------------------------------- entity issue812 is end entity; architecture test of issue812 is begin u: entity work.sub generic map ( 5 ); end architecture; nvc-r1.17.1/test/simp/issue821.vhd000066400000000000000000000005671504111170000165640ustar00rootroot00000000000000entity issue821 is end entity; architecture test of issue821 is signal x : integer; begin g: for i in 1 to 2 generate begin p: process is begin if i > 1 then x <= 1; elsif x < 100 then x <= 2; end if; wait; end process; end generate; end architecture; nvc-r1.17.1/test/simp/issue867.vhd000066400000000000000000000010771504111170000165730ustar00rootroot00000000000000package pkg is function dummy_function return natural; end package pkg; package body pkg is function dummy_function return natural is begin return 4; end function; end package body pkg; library work; use work.pkg.all; entity ent is -- Should get rewritten before signals below constant CONST : natural := dummy_function; end entity ent; architecture arch of ent is signal s0 : bit; signal s1 : bit_vector(CONST downto 0); signal s2 : bit_vector(CONST downto 0); begin s2 <= s1 and (s1'range => s0); end architecture arch; nvc-r1.17.1/test/simp/issue882.vhd000066400000000000000000000005401504111170000165620ustar00rootroot00000000000000entity test is end entity; architecture arch of test is signal my_a : integer := 0; signal my_b : integer := 1; begin process (all) is procedure do_thing (signal a : in integer; signal b : out integer) is begin b <= a; end procedure; begin my_b <= my_a; end process; end architecture; nvc-r1.17.1/test/simp/length.vhd000066400000000000000000000001731504111170000164530ustar00rootroot00000000000000package length is -- Seems to be a bug in VHDL-2019 standard constant c1 : integer := integer'length; end package; nvc-r1.17.1/test/simp/order1.vhd000066400000000000000000000004551504111170000163710ustar00rootroot00000000000000package order1 is type t is (A, B, C); type t_vec is array (natural range <>) of t; end package; package order1 is type t is (C, B, A); -- Redefine t type t_vec is array (1 to 2) of t; constant x : boolean := t_vec'(A, A) < t_vec'(C, C); -- False end package; nvc-r1.17.1/test/simp/order2.vhd000066400000000000000000000005671504111170000163760ustar00rootroot00000000000000package order2 is constant c_one : bit_vector(3 downto 0) := x"5"; constant c_two : bit_vector(3 downto 0) := not c_one; -- Locally static procedure needs_a_body; end package; package body order2 is constant c_three : bit_vector(3 downto 0) := not c_one; -- Locally static procedure needs_a_body is begin end procedure; end package body; nvc-r1.17.1/test/simp/osvvm4.vhd000066400000000000000000000022451504111170000164320ustar00rootroot00000000000000package ScoreboardGenericPkg is generic ( type ExpectedType ; type ActualType ; function Match(Actual : ActualType ; -- defaults Expected : ExpectedType) return boolean ; -- is "=" ; function expected_to_string(A : ExpectedType) return string ; -- is to_string ; function actual_to_string (A : ActualType) return string -- is to_string ; ) ; end package; ------------------------------------------------------------------------------- package AlertLogPkg is function MetaMatch (l, r : bit_vector) return boolean ; function MetaMatch (l, r : integer) return boolean ; end package; ------------------------------------------------------------------------------- package ScoreBoardPkg_slv is new work.ScoreboardGenericPkg generic map ( ExpectedType => bit_vector, ActualType => bit_vector, Match => work.AlertLogPkg.MetaMatch, -- "=", [std_logic_vector, std_logic_vector return boolean] expected_to_string => to_hstring, -- [std_logic_vector return string] actual_to_string => to_hstring -- [std_logic_vector return string] ) ; nvc-r1.17.1/test/simp/packinst1.vhd000066400000000000000000000002461504111170000170700ustar00rootroot00000000000000package genpack is generic ( constant a, b : real ); constant k : real := a / b; end package; package inst is new work.genpack generic map ( 4.0, 2.0 ); nvc-r1.17.1/test/simp/physical.vhd000066400000000000000000000002551504111170000170070ustar00rootroot00000000000000package pack is constant c1 : time := 1000 hr; -- Error constant c2 : time := 42141.4 hr; -- Error constant c3 : time := 8.2 ms; -- OK end package; nvc-r1.17.1/test/simp/ports2008.vhd000066400000000000000000000006621504111170000166560ustar00rootroot00000000000000entity sub is port ( x : in integer; y : in integer_vector(1 to 3) ); end entity; entity top is end entity; architecture test of top is signal a : integer; begin b: block is signal b : integer; -- Insert new signal here begin u: entity work.sub port map ( x => a + b, y => a & b & (0 => 4) ); -- Insert new process here end block; end architecture; nvc-r1.17.1/test/simp/predef.vhd000066400000000000000000000007051504111170000164400ustar00rootroot00000000000000package predef is function add1(x : integer) return integer; end package; package body predef is function add1(x : integer) return integer is begin return x + 1; end function; -- Calls to predefined functions should always be folded constant c1 : integer := 1 + 2; constant c2 : boolean := true xor false; -- This should not be folded in analysis phase constant c3 : integer := add1(2); end package body; nvc-r1.17.1/test/simp/proc.vhd000066400000000000000000000007471504111170000161440ustar00rootroot00000000000000entity proc is end entity; architecture test of proc is signal x, y : integer; procedure proc(n : integer) is begin end procedure; begin -- Test rewrite of process sensitivity list process (x, y) is begin report "awake"; end process; -- Test rewrite of concurrent assignments x <= y + 4; postponed x <= y + 4 when y < 2 else x + 1 when x < 2 else 0; -- Concurrent procedure call to process proc(n => 4); end architecture; nvc-r1.17.1/test/simp/protfold1.vhd000066400000000000000000000014431504111170000171050ustar00rootroot00000000000000package pack is type pt is protected procedure not_called; end protected; function add2(x : integer) return integer; end package; package body pack is type pt is protected body procedure not_called is begin end procedure; end protected body; shared variable p : pt; function add2(x : integer) return integer is begin return x + 2; end function; end package body; ------------------------------------------------------------------------------- entity protfold1 is end entity; use work.pack.all; architecture test of protfold1 is begin g0: if add2(4) = 6 generate begin p1: process is begin report "ok"; wait; end process; end generate; end architecture; nvc-r1.17.1/test/simp/protfold2.vhd000066400000000000000000000033771504111170000171160ustar00rootroot00000000000000package protfold2_pack is type id_alloc_t is protected impure function next_id return integer; end protected; type rec_t is record id : integer; end record; impure function get_next_rec return rec_t; end package; package body protfold2_pack is type int_ptr_t is access integer; type ptr_array_t is array (natural range <>) of int_ptr_t; type id_alloc_t is protected body variable counter : integer := 0; variable ptrs : ptr_array_t(1 to 5); impure function next_id return integer is begin counter := counter + 1; return counter; end function; end protected body; shared variable id_alloc : id_alloc_t; impure function get_next_rec return rec_t is begin return (id => id_alloc.next_id); end function; end package body; ------------------------------------------------------------------------------- use work.protfold2_pack.all; entity protfold2_sub is generic ( r1, r2 : rec_t ); end entity; architecture test of protfold2_sub is begin g1: if r1.id = 1 generate begin p1: process is begin assert r1.id = 1; wait; end process; end generate; g2: if r2.id = 2 generate begin p1: process is begin assert r2.id = 2; wait; end process; end generate; end architecture; ------------------------------------------------------------------------------- use work.protfold2_pack.all; entity protfold2 is end entity; architecture test of protfold2 is constant cr1 : rec_t := get_next_rec; constant cr2 : rec_t := get_next_rec; begin u: entity work.protfold2_sub generic map ( cr1, cr2 ); end architecture; nvc-r1.17.1/test/simp/recrange.vhd000066400000000000000000000006311504111170000167570ustar00rootroot00000000000000package pack is type rec is record x : bit_vector(1 to 8); end record; end package; ------------------------------------------------------------------------------- use work.pack.all; entity sub is port ( r : in rec ); end entity; architecture test of sub is begin p1: process (r) begin assert r.x(r.x'range) = (r.x'range => '0'); end process; end architecture; nvc-r1.17.1/test/simp/shift2.vhd000066400000000000000000000100661504111170000163730ustar00rootroot00000000000000entity shift2 is end entity; architecture test of shift2 is begin assert bit_vector'("11100") ror -8 = "00111" report "ror -8 is broken" severity error; assert bit_vector'("11100") ror -7 = "10011" report "ror -7 is broken" severity error; assert bit_vector'("11100") ror -6 = "11001" report "ror -6 is broken" severity error; assert bit_vector'("11100") ror -5 = "11100" report "ror -5 is broken" severity error; assert bit_vector'("11100") ror -4 = "01110" report "ror -4 is broken" severity error; assert bit_vector'("11100") ror -3 = "00111" report "ror -3 is broken" severity error; assert bit_vector'("11100") ror -2 = "10011" report "ror -2 is broken" severity error; assert bit_vector'("11100") ror -1 = "11001" report "ror -1 is broken" severity error; assert bit_vector'("11100") ror 0 = "11100" report "ror 0 is broken" severity error; assert bit_vector'("11100") ror 1 = "01110" report "ror 1 is broken" severity error; assert bit_vector'("11100") ror 2 = "00111" report "ror 2 is broken" severity error; assert bit_vector'("11100") ror 3 = "10011" report "ror 3 is broken" severity error; assert bit_vector'("11100") ror 4 = "11001" report "ror 4 is broken" severity error; assert bit_vector'("11100" ror 5) = "11100" report "ror 5 is broken" severity error; assert bit_vector'("11100") ror 6 = "01110" report "ror 6 is broken" severity error; assert bit_vector'("11100") ror 7 = "00111" report "ror 7 is broken" severity error; assert bit_vector'("11100") ror 8 = "10011" report "ror 8 is broken" severity error; -- ROL assert bit_vector'("11100") rol -8 = "10011" report "rol -8 is broken" severity error; assert bit_vector'("11100") rol -7 = "00111" report "rol -7 is broken" severity error; assert bit_vector'("11100") rol -6 = "01110" report "rol -6 is broken" severity error; assert bit_vector'("11100" rol -5) = "11100" report "rol -5 is broken" severity error; assert bit_vector'("11100") rol -4 = "11001" report "rol -4 is broken" severity error; assert bit_vector'("11100") rol -3 = "10011" report "rol -3 is broken" severity error; assert bit_vector'("11100") rol -2 = "00111" report "rol -2 is broken" severity error; assert bit_vector'("11100") rol -1 = "01110" report "rol -1 is broken" severity error; assert bit_vector'("11100") rol 0 = "11100" report "rol 0 is broken" severity error; assert bit_vector'("11100") rol 1 = "11001" report "rol 1 is broken" severity error; assert bit_vector'("11100") rol 2 = "10011" report "rol 2 is broken" severity error; assert bit_vector'("11100") rol 3 = "00111" report "rol 3 is broken" severity error; assert bit_vector'("11100") rol 4 = "01110" report "rol 4 is broken" severity error; assert bit_vector'("11100") rol 5 = "11100" report "rol 5 is broken" severity error; assert bit_vector'("11100") rol 6 = "11001" report "rol 6 is broken" severity error; assert bit_vector'("11100") rol 7 = "10011" report "rol 7 is broken" severity error; assert bit_vector'("11100") rol 8 = "00111" report "rol 8 is broken" severity error; -- Misc assert ("1011" sll 1) = "0110"; assert ("1011" srl 1) = "0101"; assert ("1011" sla 1) = "0111"; assert ("1011" sra 1) = "1101"; assert ("1011" srl -1) = "0110"; assert ("1011" sll -1) = "0101"; assert ("1011" sra -1) = "0111"; assert ("1011" sla -1) = "1101"; end architecture; nvc-r1.17.1/test/simp/simpif1.vhd000066400000000000000000000016631504111170000165470ustar00rootroot00000000000000entity simpif1 is end entity; architecture test of simpif1 is signal s : integer; constant c : integer := 5; begin p1: process is variable v : integer := 0; begin if c > 2 then if c < 10 then v := 2; wait for 1 ns; end if; wait for 1 ns; end if; wait; end process; p2: process is variable v : integer := 0; begin if c > v then v := 2; elsif c = 5 then v := 7; else s <= 1; end if; end process; p3: process is variable v : integer := 0; begin if c = 2 then v := 2; elsif c = v then s <= 1; else v := 7; end if; end process; p4: process is begin if false then s <= 5; end if; end process; end architecture; nvc-r1.17.1/test/simp/static1.vhd000066400000000000000000000037321504111170000165460ustar00rootroot00000000000000package util is function log2(x : in integer) return integer; end package; package body util is function log2(x : in integer) return integer is variable r : integer := 0; variable c : integer := 1; begin if x <= 1 then r := 1; else while c < x loop r := r + 1; c := c * 2; end loop; end if; return r; end function; end package body; ------------------------------------------------------------------------------- use work.util.all; entity memory is generic ( WIDTH : integer; DEPTH : integer ); port ( clk : in bit; addr : in bit_vector(log2(DEPTH) - 1 downto 0); din : in bit_vector(WIDTH - 1 downto 0); dout : out bit_vector(WIDTH - 1 downto 0); we : in bit ); end entity; architecture rtl of memory is type ram_t is array (0 to DEPTH - 1) of bit_vector(WIDTH - 1 downto 0); signal addr_r : bit_vector(log2(DEPTH) - 1 downto 0); -- Should be folded signal ram : ram_t; begin end architecture; ------------------------------------------------------------------------------- use work.util.all; entity bigram is end entity; architecture test of bigram is constant ITERS : integer := 100; constant WIDTH : integer := 1024; constant DEPTH : integer := 1024; signal clk : bit := '0'; signal addr : bit_vector(log2(DEPTH) - 1 downto 0); -- Should be folded signal din : bit_vector(WIDTH - 1 downto 0); signal dout : bit_vector(WIDTH - 1 downto 0); signal we : bit := '1'; signal running : boolean := true; begin clk <= not clk after 5 ns when running else '0'; uut: entity work.memory generic map ( WIDTH => WIDTH, DEPTH => DEPTH ) port map ( clk => clk, addr => addr, din => din, dout => dout, we => we ); end architecture; nvc-r1.17.1/test/simp/synth1.vhd000066400000000000000000000033161504111170000164220ustar00rootroot00000000000000entity synth1 is end entity; library ieee; use ieee.std_logic_1164.all; architecture test of synth1 is signal clk : std_logic; signal reset, x, y : bit; signal z : bit_vector(1 to 3); type t_rec is record x : bit; y : bit_vector(1 to 3); end record; signal r : t_rec; begin p1: process (x) is -- Warning begin y <= x and z(1) and y; end process; p2: process (x, z) is -- No warning begin y <= x and z(1); end process; p3: process (clk) is -- No warning begin if clk'event and clk = '1' then y <= x; end if; end process; p4: process (x) is -- Warning begin if clk'event and clk = '1' then y <= x; end if; end process; p5: process (clk, reset) is -- No warning begin if reset = '1' then y <= '0'; elsif clk'event and clk = '1' then y <= x; end if; end process; p6: process (clk) is -- Warning begin if reset = '1' then y <= '0'; elsif clk'event and clk = '1' then y <= x; else y <= '1'; end if; end process; p7: process (clk, reset) is -- No warning begin if reset = '1' then y <= '0'; elsif rising_edge(clk) then y <= x; end if; end process; p8: process (r.x, r.y) is -- No warning begin y <= r.x or r.y(1); end process; process (r.x) is -- Warning begin y <= r.x or r.y(1); end process; end architecture; nvc-r1.17.1/test/simp/table.vhd000066400000000000000000000015041504111170000162600ustar00rootroot00000000000000package table is type STD_ULOGIC is ( 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' ); type STD_ULOGIC_VECTOR is array (NATURAL range <>) of STD_ULOGIC; end package; package body table is type stdlogic_table is array(STD_ULOGIC, STD_ULOGIC) of STD_ULOGIC; constant resolution_table : stdlogic_table := ( ('U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U'), ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'), ('U', 'X', '0', 'X', '0', '0', '0', '0', 'X'), ('U', 'X', 'X', '1', '1', '1', '1', '1', 'X'), ('U', 'X', '0', '1', 'Z', 'W', 'L', 'H', 'X'), ('U', 'X', '0', '1', 'W', 'W', 'W', 'W', 'X'), ('U', 'X', '0', '1', 'L', 'W', 'L', 'W', 'X'), ('U', 'X', '0', '1', 'H', 'W', 'W', 'H', 'X'), ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X') ); end package body; nvc-r1.17.1/test/strhash.c000066400000000000000000000051231504111170000153370ustar00rootroot00000000000000#include "../src/util.h" #include #include #include #include #include #define WORDS 100000 static uint32_t djb2_mix(const char *key) { uint32_t hash = 5381; int c; while ((c = *key++)) hash = ((hash << 5) + hash) + c; return mix_bits_32(hash); } static uint32_t djb2_orig(const char *key) { uint32_t hash = 5381; int c; while ((c = *key++)) hash = ((hash << 5) + hash) + c; return hash; } __attribute__((target("sse4.1"))) static uint32_t simd_mix_32(const char *key) { __m128i zero = _mm_setzero_si128(); __m128i prime1 = _mm_set1_epi32(0xcc9e2d51); __m128i prime2 = _mm_set1_epi32(0x1b873593); __m128i shift1 = _mm_set1_epi64x(15); __m128i shift2 = _mm_set1_epi64x(17); uint32_t hash = 0; for (int pos = 0;; pos += 16) { __m128i n = _mm_loadu_si128((const __m128i *)(key + pos)); __m128i cmp = _mm_cmpeq_epi8(n, zero); n = _mm_mullo_epi32(n, prime1); n = _mm_or_si128(_mm_sll_epi32(n, shift1), _mm_srl_epi32(n, shift2)); n = _mm_mullo_epi32(n, prime2); __m128i mix1 = _mm_xor_si128(n, _mm_srli_si128(n, 8)); __m128i mix2 = _mm_xor_si128(mix1, _mm_srli_si128(mix1, 4)); hash ^= _mm_cvtsi128_si32(mix2); if (_mm_movemask_epi8(cmp)) break; } return hash; } uint64_t get_timestamp_ns(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_nsec + (ts.tv_sec * UINT64_C(1000000000)); } static void run_test(const char *name, uint32_t (*fn)(const char *), char *mem) { int tab[1024] = {}; uint64_t start = get_timestamp_ns(); for (int n = 0; n < 100; n++) { for (int i = 0; i < WORDS; i++) tab[(*fn)(mem + i*32) & (ARRAY_LEN(tab) - 1)]++; } uint64_t end = get_timestamp_ns(); int sum = 0; for (int i = 0; i < ARRAY_LEN(tab); i++) sum += tab[i]; double avg = (double)sum / ARRAY_LEN(tab), sumsq = 0.0; for (int i = 0; i < ARRAY_LEN(tab); i++) sumsq += pow(tab[i] - avg, 2); double std = sqrt(sumsq / ARRAY_LEN(tab)); printf("%-10s : %.1f ± %.2f%% (%.3f ms)\n", name, avg, 100.0 * (std / avg), (double)(end - start) / 1.0e6); } int main(int argc, char **argv) { FILE *f = fopen("/usr/share/dict/words", "r"); assert(f); char *mem = calloc(32, WORDS); char buf[256]; for (int i = 0; i < WORDS && fgets(buf, sizeof(buf), f); i++) strncpy(mem + i*32, buf, 31); fclose(f); run_test("djb2_mix", djb2_mix, mem); run_test("djb2_orig", djb2_orig, mem); run_test("simd_mix_32", simd_mix_32, mem); return 0; } nvc-r1.17.1/test/test-osvvm.tcl000066400000000000000000000016271504111170000163570ustar00rootroot00000000000000# Clones OsvvmLibraries, runs all tests. Used by the test-osvvm.yml workflow. # To run manually: # tclsh test-osvvm.tcl # Note: tcllib is required for OSVVM if {[info exists env(OSVVM_DIR)]} { set OsvvmDir $env(OSVVM_DIR) } else { set scriptdir [ file dirname [ file normalize [ info script ] ] ] set fid [open "$scriptdir/../contrib/install-osvvm.sh" r] while {[gets $fid line] != -1} { if {[regexp -all -- {git_wrapper \S+ (\S+)} $line -> tag]} { break } }; close $fid; set OsvvmDir [file join $::env(HOME) .cache nvc "OsvvmLibraries-$tag"] } source $OsvvmDir/Scripts/StartNVC.tcl #SetVHDLVersion 2019 SetExtendedElaborateOptions {--jit} set ::osvvm::AnalyzeErrorStopCount 1 set ::osvvm::SimulateErrorStopCount 1 if {[info exists env(OSVVM_MUST_BUILD)]} { build $OsvvmDir/OsvvmLibraries } build $OsvvmDir/RunAllTests build $OsvvmDir/RunAllTestsVti nvc-r1.17.1/test/test_bounds.c000066400000000000000000000711221504111170000162160ustar00rootroot00000000000000// // Copyright (C) 2013-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "diag.h" #include "jit/jit.h" #include "option.h" #include "phase.h" #include "scan.h" #include "type.h" #include #include #include START_TEST(test_bounds) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/bounds/bounds.vhd"); const error_t expect[] = { { 26, "left index 0 violates constraint POSITIVE" }, { 27, "right index 60 violates constraint FOO" }, { 31, "array S index -52 outside of POSITIVE range 1 to 10" }, { 32, "array S slice right index 11 outside of POSITIVE range 1 to 10" }, { 33, "array S slice left index 0 outside of POSITIVE range 1 to 10" }, { 37, "aggregate choice index 0 outside of POSITIVE range " "1 to 2147483647" }, { 46, "actual length 4 does not match formal length 8 for parameter X" }, { 47, "actual length 4 does not match formal length 8 for parameter X" }, { 50, "actual length 4 for dimension 2 does not" }, { 53, "value 9 does not match length of target 10 for signal S" }, { 54, "value 2 does not match length of target 0 for signal N" }, { 55, "expected at most 0 positional associations in MY_VEC1 " }, { 60, "length of value 10 does not match length of target 3" }, { 66, "array S index 11 outside of POSITIVE range 1 to 10" }, { 67, "array S index -1 outside of POSITIVE range 1 to 10" }, { 74, "aggregate choice index 0 outside of POSITIVE range 1 to " "2147483647" }, { 83, "value '1' outside of ALPHA range 'a' to 'z' for variable A" }, { 84, "0 outside of POSITIVE range 1 to 2147483647 for variable P" }, { 89, "invalid dimension 5 for type MY_VEC1" }, { 94, "value -1 outside of NATURAL range 0 to 2147483647 for " "parameter X" }, { 107, "aggregate choice index 5 outside of POSITIVE range 1 to 3" }, { 116, "length of sub-aggregate 2 does not match expected length 4" }, { 137, "array index 14 outside of NATURAL range 0 to 2" }, { 155, "value 2 outside of REAL range 0 to 1 for parameter X"}, { 164, "missing choice for element FOUR of T_ARR with index type SE"}, { 165, "expected at most 3 positional associations in T_ARR aggregate " "with index type SE range TWO to FOUR"}, { 175, "ONE outside of E range THREE downto TWO for parameter ARG2" }, { 176, "FOUR outside of E range THREE downto TWO for parameter ARG2"}, { 177, "ONE outside of E range TWO to FOUR for parameter ARG1"}, { 178, "FIVE outside of E range TWO to FOUR for parameter ARG1"}, { 188, "aggregate choice index ONE outside of E range TWO to FOUR"}, { 190, "aggregate choice index ONE outside of E range TWO to FOUR"}, { 190, "aggregate choice index FIVE outside of E range TWO to FOUR"}, { 198, "length of sub-aggregate 3 does not match expected length 4" }, { 206, "left index ONE violates constraint SE" }, { 206, "right index FOUR violates constraint SE" }, { 219, "-5 NS outside of TIME range 0 HR to 10 NS for parameter A"}, { 221, "5 NS outside of TIME range 10 SEC downto 20 US for parameter A"}, { 227, "200 NS outside of TIME range -10 NS to 10 NS"}, { 228, "-200 NS outside of TIME range -10 NS to 10 NS"}, { 236, "array M index 'A' outside of CHARACTER range 'a' to 'z'" }, { 237, "array M slice left index '1' outside of CHARACTER range " "'a' to 'z'" }, { 242, "value 3 does not match length of target 4 for alias A" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); unit_registry_t *ur = get_registry(); mir_context_t *mc = get_mir(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); bounds_check(a); check_expected_errors(); } END_TEST START_TEST(test_bounds2) { const error_t expect[] = { { 13, "assignment delay may not be negative"}, { 20, "assignment delay may not be negative"}, { 24, "assignment delay may not be negative"}, { 25, "assignment delay may not be negative"}, { 33, "rejection limit may not be negative"}, { 34, "rejection limit may not be greater than first assignment delay"}, { 39, "wait timeout may not be negative"}, { 52, "value 20 outside of INTEGER range 0 to 9 for signal S"}, { 53, "'Z' outside of CHARACTER range 'a' to 'z' for constant C1"}, { 54, "value 10 outside of REAL range 0 to 5"}, { 55, "value 0 HR outside of TIME range 10 NS to 10 US for constant T"}, { 56, "value 10 outside of R range 0 to 1 for constant C2"}, { 59, "value 30 outside of SUBINT range 1 to 10 for parameter A"}, { 63, "'c' outside of CHARACTER range 'a' to 'b' for parameter A" }, { 70, "value 20 outside of INTEGER range 10 downto 0 for generic G2"}, { 73, "value 2 outside of INTEGER range 0 to 1 for port P2"}, { 79, "value 5.0999999999999996 outside of REAL range 0 to 5"}, { 95, "assignment delays must be in ascending time order"}, { 96, "assignment delays must be in ascending time order"}, { 97, "assignment delays must be in ascending time order"}, { 98, "assignment delays must be in ascending time order"}, { 99, "assignment delays must be in ascending time order"}, { 127, "length of type conversion argument 9 does not match expected " "length 10 for constrained array subtype BV10" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/bounds2.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); bounds_check(a); check_expected_errors(); } END_TEST START_TEST(test_case) { const error_t expect[] = { { 13, "missing choice for element C of type LETTER" }, { 19, "missing choice for element B of type AB" }, { 30, "10 to 19" }, { 36, "4 to 2147483647" }, { 44, "2147483647" }, { 51, "value 50 is already covered" }, { 53, "range 60 to 64 is already covered" }, { 59, "case choice index -1 outside of NATURAL range 0 to 2147483647" }, { 79, "choices cover only 2 of 8 possible values" }, { 84, "missing choice for element 3 of BIT_VECTOR with index type " "NATURAL range 1 to 3" }, { 86, "expected at most 3 positional associations in BIT_VECTOR " "aggregate with index type NATURAL range 1 to 3" }, { 88, "expected 3 elements in string literal but have 2" }, { 90, "expected 3 elements in string literal but have 4" }, { 95, "choices cover only 2 of 65536 possible values" }, { 101, "choices cover only 2 of 121 possible values" }, { 113, "missing choices for elements 3 downto 1 of type MY_INT" }, { 117, "case choice index 11 outside of MY_INT range 10 downto 1" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/case.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue36) { input_from_file(TESTDIR "/bounds/issue36.vhd"); tree_t e = parse_and_check(T_ENTITY); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(e, jit, ur, mc); bounds_check(e); jit_free(jit); fail_if_errors(); } END_TEST START_TEST(test_issue54) { const error_t expect[] = { { 12, "index 3 outside of NATURAL range 7 downto 4" }, { 12, "index 0 outside of NATURAL range 7 downto 4" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue54.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue99) { const error_t expect[] = { { 7, "type conversion argument -1.5 out of bounds 0 to 2147483647" }, { 8, "type conversion argument -1 out of bounds 1 to 5" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue99.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); check_expected_errors(); } END_TEST START_TEST(test_issue150) { const error_t expect[] = { { 7, "missing choices for elements 6 to 7 of T_LUT8X8 with index " "type INTEGER range 0 to 7" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue150.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue200) { input_from_file(TESTDIR "/bounds/issue200.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); fail_if_errors(); } END_TEST START_TEST(test_issue208) { const error_t expect[] = { { 20, "missing choice for element 1 of type INTEGER range 1 downto 0" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue208.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue247) { const error_t expect[] = { { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue247.vhd"); tree_t a = parse_and_check(T_PACKAGE); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue251) { input_from_file(TESTDIR "/bounds/issue251.vhd"); const error_t expect[] = { { 24, "array X index -1 outside of NATURAL range 3 downto 0" }, { 30, "array A index -1 outside of NATURAL range 3 downto 0" }, { 31, "length of value 4 does not match length of target 3" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue269) { const error_t expect[] = { { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/bounds/issue269.vhd"); tree_t a = parse_and_check(T_PACKAGE); fail_unless(error_count() == 0); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); bounds_check(a); jit_free(jit); check_expected_errors(); } END_TEST START_TEST(test_issue307b) { input_from_file(TESTDIR "/bounds/issue307b.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); bounds_check(a); fail_if_errors(); } END_TEST START_TEST(test_issue356) { input_from_file(TESTDIR "/bounds/issue356.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); bounds_check(a); fail_if_errors(); } END_TEST START_TEST(test_issue98) { input_from_file(TESTDIR "/bounds/issue98.vhd"); const error_t expect[] = { { 5, "value 9223372036854775807 outside of INTEGER range -2147483648 " "to 2147483647 for signal I" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_tc1147) { input_from_file(TESTDIR "/bounds/tc1147.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(error_count() == 0); bounds_check(a); fail_if_errors(); } END_TEST START_TEST(test_aggregate) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/aggregate.vhd"); const error_t expect[] = { { 8, "duplicate choice for A" }, { 8, "for element B of MY_ENUM_MAP with index type MY_ENUM" }, { 9, "for element C of MY_ENUM_MAP with index type MY_ENUM" }, { 10, "duplicate choice for B" }, { 16, "for element 1 of MY_BIT_VEC with index type NATURAL " "range 3 downto 1" }, { 17, "missing choices for elements 6 downto 5, 10 downto 8 of " "MY_INT_MAP with index type MY_INT" }, { 21, "expected at most 3 positional associations in INTEGER_VECTOR " "aggregate with index type NATURAL range 1 to 3" }, { 22, "missing choice for element 5 of INTEGER_VECTOR with index " "type NATURAL range 1 to 5" }, { 24, "length of value 2 does not match length of target 3" }, { 25, "discrete range has 4 elements but length of expression is 3" }, { 29, "discrete range has 4 elements but length of expression is 3" }, { 32, "value -1 outside of POSITIVE range 1 to 2147483647" }, { 35, "length of value 3 does not match length of target 4" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_osvvm1) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/osvvm1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_range1) { input_from_file(TESTDIR "/bounds/range1.vhd"); const error_t expect[] = { { 10, "invalid dimension 2 for type BIT_VECTOR" }, { 11, "invalid dimension -1 for type BIT_VECTOR" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_case2) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/case2.vhd"); const error_t expect[] = { { 29, "expected case choice to have length 5 but is 3" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue477a) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/issue477a.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); tree_t d = get_decl(p, "C_DATA_VERSION"); fail_unless(tree_kind(d) == T_CONST_DECL); type_t type = tree_type(d); fail_unless(type_kind(type) == T_SUBTYPE); int64_t left; fail_unless(folded_int(tree_left(range_of(type, 0)), &left)); ck_assert_int_eq(left, 7); fail_if_errors(); } END_TEST START_TEST(test_issue477b) { input_from_file(TESTDIR "/bounds/issue477b.vhd"); const error_t expect[] = { { 23, "missing choice for element TYPE_5 of T_DATA_SEGMENT_TEMPLATE " }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_case3) { input_from_file(TESTDIR "/bounds/case3.vhd"); const error_t expect[] = { { 16, "duplicate choice in case statement" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_driver1) { input_from_file(TESTDIR "/bounds/driver1.vhd"); const error_t expect[] = { { 13, "array S index 7 outside of NATURAL range 1 to 3" }, { 11, "array S index 5 outside of NATURAL range 1 to 3" }, { 16, "array S index -1 outside of NATURAL range 1 to 3" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_nullrange) { input_from_file(TESTDIR "/bounds/nullrange.vhd"); const error_t expect[] = { { 14, "type T_NULL_INT has null range" }, { 15, "value 0 outside of T_NULL_INT range 0 to -1 for variable X" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue617) { input_from_file(TESTDIR "/bounds/issue617.vhd"); const error_t expect[] = { { 17, "array EXAMPLE right bound -32 violates BIT_VECTOR index " "constraint 0 to 2147483647" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue734) { input_from_file(TESTDIR "/bounds/issue734.vhd"); const error_t expect[] = { { 10, "array VAL index 0 outside of NATURAL range 0 downto 1" }, { 11, "VAL slice left index 1 outside of NATURAL range 0 downto 1" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_case4) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/case4.vhd"); const error_t expect[] = { { 9, "choices cover only 1 of 256 ** 5 possible values" }, { 0, "expression has 5 elements of type CHARACTER, each of which " "has 256 possible values" }, { 0, "the --relaxed option downgrades this to a warning" }, { 0, "the case expression subtype is not locally static" }, { 18, "missing choices for elements 2 to 2147483647 of type NATURAL" }, { 29, "choices cover only 1 of 256 ** 12 possible values" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_initial) { set_standard(STD_19); input_from_file(TESTDIR "/bounds/initial.vhd"); const error_t expect[] = { { 8, "expected at most 5 positional associations in REAL_VECTOR " "aggregate with index type NATURAL range 1 to 5" }, { 11, "expected at most 5 positional associations in REAL_VECTOR " "aggregate with index type NATURAL range 1 to 5" }, { 17, "expected at most 5 positional associations in REAL_VECTOR " "aggregate with index type NATURAL range 1 to 5" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_case5) { input_from_file(TESTDIR "/bounds/case5.vhd"); const error_t expect[] = { { 22, "missing choice for element BAZ of type T_TYPE" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue800) { input_from_file(TESTDIR "/bounds/issue800.vhd"); const error_t expect[] = { { 10, "call to predefined operator \"=\" always returns FALSE" }, { 0, "left length is 3 but right length is 2" }, { 11, "call to predefined operator \"/=\" always returns FALSE" }, { 0, "left length is 3 but right length is 9" }, { 14, "call to predefined operator \"=\" always returns FALSE" }, { 0, "left length is 3 but right length is 1" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue806) { input_from_file(TESTDIR "/bounds/issue806.vhd"); parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue819) { input_from_file(TESTDIR "/bounds/issue819.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_cons1) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/cons1.vhd"); const error_t expect[] = { { 4, "left index -1 violates constraint POSITIVE" }, { 7, "left index 0 violates constraint POSITIVE" }, { 9, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, // TODO: these should be suppressed { 12, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, { 12, "left index 0 violates constraint POSITIVE" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue863) { input_from_file(TESTDIR "/bounds/issue863.vhd"); const error_t expect[] = { { 17, "invalid dimension 0 for type REAL_MATRIX" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_subtype) { input_from_file(TESTDIR "/bounds/subtype.vhd"); const error_t expect[] = { { 3, "left index -1 violates constraint INT8" }, { 4, "right index 300 violates constraint INT8" }, { 8, "right index C violates constraint AB" }, { 11, "left index -1 violates constraint REAL10" }, { 13, "left index -1 violates constraint POSITIVE" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue951) { input_from_file(TESTDIR "/bounds/issue951.vhd"); parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue966) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/issue966.vhd"); const error_t expect[] = { { 27, "duplicate choice in case statement" }, { 0, "repeated here" }, { 0, "previous choice for this value" }, { 32, "choices cover only 13122 of 9 ** 10 possible values" }, { 0, "expression has 10 elements of type STD_ULOGIC, each of " "which has 9 possible values" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue975) { input_from_file(TESTDIR "/bounds/issue975.vhd"); const error_t expect[] = { { 8, "left index 0 violates constraint POSITIVE" }, { 9, "right index 0 violates constraint POSITIVE" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1040) { input_from_file(TESTDIR "/bounds/issue1040.vhd"); const error_t expect[] = { { 7, "length of value 32 does not match length of target 12" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1021) { input_from_file(TESTDIR "/bounds/issue1021.vhd"); const error_t expect[] = { { 6, "length of value 0 does not match length of target 2 for " "constant SMAP" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1091) { input_from_file(TESTDIR "/bounds/issue1091.vhd"); const error_t expect[] = { { 9, "missing choices for elements 2 to 3 of VEC" }, { 9, "missing choices for elements 0 to 2 of VEC" }, { 10, "value 1 is already covered" }, { 10, "missing choice for element 3 of VEC" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_map1) { input_from_file(TESTDIR "/bounds/map1.vhd"); const error_t expect[] = { { 19, "length of value 3 does not match length of target 2" }, { 28, "length of value 4 does not match length of target 3 for " "generic G1" }, { 29, "value 7 outside of INTEGER range 0 to 3 for generic G2" }, { 33, "length of value 2 does not match length of target 3 for " "signal P1" }, { 44, "length of value 2 does not match length of target 3 for " "signal P1" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue817) { set_standard(STD_08); input_from_file(TESTDIR "/bounds/issue817.vhd"); const error_t expect[] = { { 37, "length of value 7 does not match length of target 8" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_map2) { input_from_file(TESTDIR "/bounds/map2.vhd"); const error_t expect[] = { { 19, "length of value 8 does not match length of target 7 for " "generic INFO" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST Suite *get_bounds_tests(void) { Suite *s = suite_create("bounds"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_bounds); tcase_add_test(tc_core, test_bounds2); tcase_add_test(tc_core, test_case); tcase_add_test(tc_core, test_issue36); tcase_add_test(tc_core, test_issue54); tcase_add_test(tc_core, test_issue99); tcase_add_test(tc_core, test_issue150); tcase_add_test(tc_core, test_issue200); tcase_add_test(tc_core, test_issue208); tcase_add_test(tc_core, test_issue247); tcase_add_test(tc_core, test_issue251); tcase_add_test(tc_core, test_issue269); tcase_add_test(tc_core, test_issue307b); tcase_add_test(tc_core, test_issue356); tcase_add_test(tc_core, test_issue98); tcase_add_test(tc_core, test_tc1147); tcase_add_test(tc_core, test_aggregate); tcase_add_test(tc_core, test_osvvm1); tcase_add_test(tc_core, test_range1); tcase_add_test(tc_core, test_case2); tcase_add_test(tc_core, test_issue477a); tcase_add_test(tc_core, test_issue477b); tcase_add_test(tc_core, test_case3); tcase_add_test(tc_core, test_driver1); tcase_add_test(tc_core, test_nullrange); tcase_add_test(tc_core, test_issue617); tcase_add_test(tc_core, test_issue734); tcase_add_test(tc_core, test_case4); tcase_add_test(tc_core, test_initial); tcase_add_test(tc_core, test_case5); tcase_add_test(tc_core, test_issue800); tcase_add_test(tc_core, test_issue806); tcase_add_test(tc_core, test_issue819); tcase_add_test(tc_core, test_cons1); tcase_add_test(tc_core, test_issue863); tcase_add_test(tc_core, test_subtype); tcase_add_test(tc_core, test_issue951); tcase_add_test(tc_core, test_issue966); tcase_add_test(tc_core, test_issue975); tcase_add_test(tc_core, test_issue1040); tcase_add_test(tc_core, test_issue1021); tcase_add_test(tc_core, test_issue1091); tcase_add_test(tc_core, test_map1); tcase_add_test(tc_core, test_issue817); tcase_add_test(tc_core, test_map2); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_charset.c000066400000000000000000000071421504111170000163560ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "ident.h" #include "lib.h" #include "phase.h" #include "scan.h" #include "tree.h" START_TEST(test_iso88591) { input_from_file(TESTDIR "/charset/iso8859-1.vhd"); const error_t expect[] = { { 11, "unexpected error while parsing constant declaration" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); lib_put(lib_work(), e); ck_assert_int_eq(ident_len(tree_ident(e)), 10); fail_unless(tree_ident(e) == ident_new("WORK.\xda\xdb\xdc\xdd\xde")); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_ident(a) == ident_new("WORK.\xda\xdb\xdc\xdd\xde-" "\xdb\xdc\xdd\xde\xff\xdb\xdc" "\xdd\xde\xff")); fail_unless(tree_decls(a) == 4); tree_t d1 = tree_decl(a, 1); fail_unless(tree_kind(d1) == T_CONST_DECL); fail_unless(tree_ident(d1) == ident_new("\xdf\xc0\xc1\xc2\xc3\xc4\xc5\xc6" "\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce" "\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6" "\xd8\xd9\xda\xdb\xdc\xdd\xde\xff")); tree_t d2 = tree_decl(a, 2); fail_unless(tree_kind(d2) == T_CONST_DECL); fail_unless(tree_ident(d2) == ident_new("\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7" "\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8" "\xd9\xda\xdb\xdc\xdd\xde")); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_utf8) { input_from_file(TESTDIR "/charset/utf8.vhd"); const error_t expect[] = { { 3, "possible multi-byte UTF-8 character found in input" }, { 3, "unexpected error while parsing constant declaration" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_strings) { set_standard(_i); input_from_file(TESTDIR "/charset/strings.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); tree_t s0 = tree_value(tree_decl(p, 0)); fail_unless(tree_kind(s0) == T_STRING); ck_assert_int_eq(tree_chars(s0), 8); tree_t s0c0 = tree_char(s0, 0); fail_unless(tree_ident(s0c0) == ident_new("'\xe5'")); fail_unless(tree_pos(tree_ref(s0c0)) == 0xe5); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST Suite *get_charset_tests(void) { Suite *s = suite_create("charset"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_iso88591); tcase_add_test(tc, test_utf8); tcase_add_loop_test(tc, test_strings, STD_93, STD_19 + 1); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_debug.c000066400000000000000000000043411504111170000160110ustar00rootroot00000000000000// // Copyright (C) 2021 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "debug.h" #include "test_util.h" #if defined __clang__ #pragma clang optimize off #elif defined __GNUC__ #pragma GCC optimize ("O0") #endif static int call_line = 0; DLLEXPORT __attribute__((noinline)) void global_func(void) { int capture_line = __LINE__; debug_info_t *di = debug_capture(); (void)capture_line; const int nframes = debug_count_frames(di); fail_unless(nframes >= 3); const debug_frame_t *f0 = debug_get_frame(di, 0); fail_unless(f0->kind == FRAME_PROG); fail_if(f0->symbol == NULL); ck_assert_str_eq(f0->symbol, "global_func"); fail_if(f0->module == NULL); fail_unless(strstr(f0->module, "unit_test")); fail_unless(f0->lineno == capture_line || f0->lineno == 0); fail_unless(f0->pc >= (uintptr_t)global_func); fail_unless(f0->pc < (uintptr_t)global_func + 0x1000); const debug_frame_t *f1 = debug_get_frame(di, 1); fail_unless(f1->kind == FRAME_PROG); fail_unless(strstr(f1->module, "unit_test")); fail_unless(f1->lineno == call_line || f0->lineno == 0); debug_free(di); } __attribute__((noinline)) static void static_func(void) { call_line = __LINE__; global_func(); } START_TEST(test_capture) { static_func(); } END_TEST START_TEST(test_symbol_name) { ck_assert_str_eq(debug_symbol_name(global_func), "global_func"); } END_TEST Suite *get_debug_tests(void) { Suite *s = suite_create("debug"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_capture); tcase_add_test(tc_core, test_symbol_name); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_driver.c000066400000000000000000000175131504111170000162230ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "ident.h" #include "driver.h" #include "phase.h" #include "scan.h" START_TEST(test_sanity1) { input_from_file(TESTDIR "/driver/sanity1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *ds = find_drivers(a); tree_t x = get_decl(a, "X"); tree_t y = get_decl(a, "Y"); tree_t z = get_decl(a, "Z"); tree_t r = get_decl(a, "R"); tree_t p0 = tree_stmt(a, 0); tree_t p1 = tree_stmt(a, 1); tree_t u2 = tree_stmt(a, 2); driver_info_t *p0di = get_drivers(ds, p0); ck_assert_ptr_nonnull(p0); ck_assert_ptr_null(p0di->chain_decl); ck_assert_ptr_null(p0di->chain_proc); ck_assert_ptr_eq(p0di->where, p0); ck_assert(tree_kind(p0di->prefix) == T_REF); ck_assert_ptr_eq(tree_ref(p0di->prefix), x); ck_assert_ptr_eq(p0di->decl, x); ck_assert(!p0di->tentative); driver_info_t *p1di0 = get_drivers(ds, p1); ck_assert_ptr_nonnull(p1); ck_assert_ptr_nonnull(p1di0->chain_decl); ck_assert_ptr_nonnull(p1di0->chain_proc); ck_assert_ptr_eq(p1di0->where, p1); ck_assert(tree_kind(p1di0->prefix) == T_ARRAY_REF); ck_assert_ptr_eq(p1di0->decl, z); driver_info_t *p1di1 = p1di0->chain_proc; ck_assert_ptr_null(p1di1->chain_decl); ck_assert_ptr_nonnull(p1di1->chain_proc); ck_assert_ptr_eq(p1di1->where, p1); ck_assert(tree_kind(p1di1->prefix) == T_REF); ck_assert_ptr_eq(p1di1->decl, y); driver_info_t *p1di2 = p1di1->chain_proc; ck_assert_ptr_nonnull(p1di2->chain_decl); ck_assert_ptr_null(p1di2->chain_proc); ck_assert_ptr_eq(p1di2->where, p1); ck_assert(tree_kind(p1di2->prefix) == T_RECORD_REF); ck_assert_ptr_eq(p1di2->decl, r); driver_info_t *u2di0 = get_drivers(ds, u2); ck_assert_ptr_nonnull(u2); ck_assert_ptr_nonnull(u2di0->chain_decl); ck_assert_ptr_null(u2di0->chain_proc); ck_assert_ptr_eq(u2di0->where, u2); ck_assert(tree_kind(u2di0->prefix) == T_ARRAY_REF); ck_assert_ptr_eq(u2di0->decl, z); tree_t b4p0 = tree_stmt(tree_stmt(a, 4), 0); driver_info_t *b4p0di = get_drivers(ds, b4p0); ck_assert_ptr_nonnull(b4p0di); ck_assert_ptr_null(b4p0di->chain_proc); tree_t g5p0 = tree_stmt(tree_cond(tree_stmt(a, 5), 0), 0); driver_info_t *g5p0di = get_drivers(ds, g5p0); ck_assert_ptr_nonnull(g5p0di); ck_assert_ptr_nonnull(g5p0di->chain_proc); ck_assert(g5p0di->tentative); ck_assert(has_unique_driver(ds, x)); ck_assert(!has_unique_driver(ds, z)); free_drivers(ds); fail_if_errors(); } END_TEST START_TEST(test_sanity2) { input_from_file(TESTDIR "/driver/sanity2.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *di = find_drivers(a); tree_t x = get_decl(a, "X"); tree_t y = get_decl(a, "Y"); tree_t p = tree_port(tree_primary(a), 0); tree_t p0 = tree_stmt(a, 0); tree_t p1 = tree_stmt(a, 1); tree_t p2 = tree_stmt(a, 2); tree_t p3 = tree_stmt(a, 3); driver_info_t *p0di = get_drivers(di, p0); ck_assert_ptr_nonnull(p0); ck_assert_ptr_null(p0di->chain_decl); ck_assert_ptr_null(p0di->chain_proc); ck_assert_ptr_eq(p0di->where, p0); ck_assert(tree_kind(p0di->prefix) == T_ARRAY_SLICE); ck_assert_ptr_eq(p0di->decl, x); ck_assert(!p0di->tentative); driver_info_t *p1di = get_drivers(di, p1); ck_assert_ptr_nonnull(p1); ck_assert_ptr_null(p1di->chain_decl); ck_assert_ptr_null(p1di->chain_proc); ck_assert_ptr_eq(p1di->where, p1); ck_assert(tree_kind(p1di->prefix) == T_REF); ck_assert_ptr_eq(p1di->decl, y); ck_assert(!p1di->tentative); driver_info_t *p2di = get_drivers(di, p2); ck_assert_ptr_nonnull(p2di); ck_assert_ptr_nonnull(p2di->chain_decl); ck_assert_ptr_null(p2di->chain_proc); ck_assert_ptr_eq(p2di->where, p2); ck_assert(tree_kind(p2di->prefix) == T_ARRAY_REF); ck_assert_ptr_eq(p2di->decl, p); ck_assert(!p2di->tentative); driver_info_t *p3di = get_drivers(di, p3); ck_assert_ptr_nonnull(p3di); ck_assert_ptr_null(p3di->chain_decl); ck_assert_ptr_null(p3di->chain_proc); ck_assert_ptr_eq(p2di->chain_decl, p3di); ck_assert_ptr_eq(p3di->where, p3); ck_assert(tree_kind(p3di->prefix) == T_ARRAY_SLICE); ck_assert_ptr_eq(p3di->decl, p); ck_assert(!p3di->tentative); free_drivers(di); fail_if_errors(); } END_TEST START_TEST(test_unique1) { input_from_file(TESTDIR "/driver/unique1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *ds = find_drivers(a); tree_t s1 = get_decl(a, "S1"); ck_assert(has_unique_driver(ds, s1)); tree_t s2 = get_decl(a, "S2"); ck_assert(!has_unique_driver(ds, s2)); tree_t s3 = get_decl(a, "S3"); ck_assert(has_unique_driver(ds, s3)); tree_t s4 = get_decl(a, "S4"); ck_assert(has_unique_driver(ds, s4)); tree_t s5 = get_decl(a, "S5"); ck_assert(!has_unique_driver(ds, s5)); free_drivers(ds); fail_if_errors(); } END_TEST START_TEST(test_unique2) { input_from_file(TESTDIR "/driver/unique2.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *ds = find_drivers(a); tree_t s1 = get_decl(a, "S1"); ck_assert(!has_unique_driver(ds, s1)); free_drivers(ds); fail_if_errors(); } END_TEST START_TEST(test_unique3) { set_standard(STD_19); input_from_file(TESTDIR "/driver/unique3.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *ds = find_drivers(a); tree_t s1 = get_decl(a, "S1"); ck_assert(!has_unique_driver(ds, s1)); tree_t s2 = get_decl(a, "S2"); ck_assert(!has_unique_driver(ds, s2)); free_drivers(ds); fail_if_errors(); } END_TEST START_TEST(test_issue930) { input_from_file(TESTDIR "/driver/issue930.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); driver_set_t *di = find_drivers(a); tree_t signals[] = { get_decl(a, "NAME"), get_decl(a, "S1"), get_decl(a, "S2"), get_decl(a, "S3"), get_decl(a, "S4") }; tree_t p0 = tree_stmt(a, 0); driver_info_t *p0di = get_drivers(di, p0); for (int i = 0; i < ARRAY_LEN(signals); i++, p0di = p0di->chain_proc) { ck_assert_ptr_nonnull(p0di); ck_assert_ptr_null(p0di->chain_decl); ck_assert_ptr_eq(p0di->where, p0); ck_assert(tree_kind(p0di->prefix) == T_REF); ck_assert_ptr_eq(p0di->decl, signals[i]); ck_assert(!p0di->tentative); } ck_assert_ptr_null(p0di); free_drivers(di); fail_if_errors(); } END_TEST START_TEST(test_issue953) { input_from_file(TESTDIR "/driver/issue953.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t b = tree_stmt(a, 0); fail_unless(tree_kind(b) == T_BLOCK); driver_set_t *ds = find_drivers(b); tree_t p = tree_port(b, 0); ck_assert(!has_unique_driver(ds, p)); free_drivers(ds); fail_if_errors(); } END_TEST Suite *get_driver_tests(void) { Suite *s = suite_create("driver"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_sanity1); tcase_add_test(tc, test_sanity2); tcase_add_test(tc, test_unique1); tcase_add_test(tc, test_unique2); tcase_add_test(tc, test_unique3); tcase_add_test(tc, test_issue930); tcase_add_test(tc, test_issue953); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_dump.c000066400000000000000000000556171504111170000157040ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "lib.h" #include "ident.h" #include "option.h" #include "phase.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include "scan.h" #include "tree.h" #include "vlog/vlog-node.h" #include "vlog/vlog-phase.h" #include static void diff_dump(const char *have, const char *expect) { if (strcmp(have, expect) == 0) return; for (;;) { const char *nl1 = strchrnul(have, '\n'); const char *nl2 = strchrnul(expect, '\n'); const int len1 = nl1 - have; const int len2 = nl2 - expect; if (len1 != len2 || strncmp(have, expect, len1) != 0) { color_printf("$red$- %.*s$$\n", len2, expect); color_printf("$green$+ %.*s$$\n", len1, have); ck_abort_msg("found difference in dump"); } else if (*nl1 == '\0' || *nl2 == '\0') break; have = nl1 + 1; expect = nl2 + 1; } ck_assert_str_eq(have, expect); } START_TEST(test_vhdl1) { input_from_file(TESTDIR "/dump/vhdl1.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(tree_primary(a)); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "entity WORK.VHDL1 is\n" " port (\n" " signal X : in BIT;\n" " signal Y : out INTEGER );\n" "end entity;\n" "\n"); tb_rewind(tb); dump(a); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "architecture WORK.VHDL1-TEST of VHDL1 is\n" " signal Z : BIT;\n" "begin\n" " Z <= X after 1 NS;\n" "end architecture;\n" "\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vhdl2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/dump/vhdl2.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); const char *decl_cases[][2] = { { "S1", "signal S1 : BIT_VECTOR(1 to 6) := (1 => '1', others => '0');\n" }, { "T1", "type T1 is array (NATURAL range <>) of BIT;\n" }, { "T2", "subtype T2 is T1(1 to 99);\n" }, { "F1", "function F1 (\n" " constant X : in INTEGER;\n" " constant Y : in INTEGER ) return BIT;\n" " -- WORK.VHDL2-TEST.F1(II)J\n" }, { "PROC1", "procedure PROC1 is -- Never waits\n" " -- WORK.VHDL2-TEST.PROC1\n" " variable V1 : INTEGER := 5;\n" "begin\n" " V1 := \"+\"(V1, 1);\n" "end procedure;\n" }, { "C1", "component C1 is\n" " generic (\n" " constant G1 : in INTEGER := 2;\n" " type T is private;\n" " -- predefined function \"=\" : in \"=\" [T, T return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T, T return BOOLEAN] := <>;\n" " );\n" " port (\n" " signal X : out BIT;\n" " signal Y : out BIT );\n" "end component;\n" }, { "T3", "type T3 is record\n" " X : INTEGER;\n" " Y : INTEGER;\n" "end record;\n" }, { "FACT", "function FACT ( constant N : in NATURAL ) return NATURAL is\n" " -- WORK.VHDL2-TEST.FACT(N)N\n" "begin\n" " if \">\"(N, 1) then\n" " return \"*\"(N, FACT(\"-\"(N, 1)));\n" " else\n" " return 1;\n" " end if;\n" "end function;\n" }, }; for (int i = 0; i < ARRAY_LEN(decl_cases); i++) { dump(get_decl(a, decl_cases[i][0])); diff_dump(tb_get(tb), decl_cases[i][1]); tb_rewind(tb); } const char *stmt_cases[][2] = { { "B1", "B1: block is\n" " port ( signal P : in INTEGER );\n" " port map (P => inertial 1);\n" "begin\n" "end block;\n" }, { "U1", "U1: component C1\n" " generic map (T => INTEGER, \"=\", \"/=\")\n" " port map (open, Y => S1(0));\n" }, { "P1", "P1: process (S1) is\n" "begin\n" " S1 <= reject 1 NS inertial \"101010\" after 1 NS, (others => '1') after 2 NS;\n" " report \"hello\";\n" "end process;\n" }, { "G1", "G1: for I in INTEGER(5) downto INTEGER(2) generate\n" " /* loop variable */ I : INTEGER range INTEGER(5) downto INTEGER(2);\n" " attribute A : INTEGER;\n" " signal R : REAL := 1.234500;\n" " attribute A of R : signal is 5;\n" "begin\n" " assert \">\"(R, 0.000000);\n" "end generate;\n" }, }; const int nstmts = tree_stmts(a); for (int i = 0; i < ARRAY_LEN(stmt_cases); i++) { tree_t s = NULL; for (int j = 0; j < nstmts; j++) { tree_t sj = tree_stmt(a, j); if (icmp(tree_ident(sj), stmt_cases[i][0])) { s = sj; break; } } ck_assert_msg(s != NULL, "cannot find statemnt %s", stmt_cases[i][0]); dump(s); diff_dump(tb_get(tb), stmt_cases[i][1]); tb_rewind(tb); } fail_if_errors(); } END_TEST START_TEST(test_vhdl3) { set_standard(STD_08); input_from_file(TESTDIR "/dump/vhdl3.vhd"); tree_t b = parse_and_check(T_PACKAGE, T_PACK_BODY, -1); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(tree_primary(b)); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "package WORK.VHDL3 is\n" " generic ( constant G : in INTEGER );\n" " constant C1 : BIT_VECTOR(1 to G);\n" "end package;\n" "\n"); tb_rewind(tb); dump(b); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "package body WORK.VHDL3-body is\n" " constant C1 : BIT_VECTOR(1 to G) := (others => '1');\n" " constant C2 : INTEGER := << constant .UUT.X : INTEGER >>;\n" "end package body;\n" "\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vhdl4) { set_standard(STD_19); input_from_file(TESTDIR "/dump/vhdl4.vhd"); tree_t e = parse_and_check(T_ENTITY); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(e); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "entity WORK.E is\n" " generic (\n" " type T1 is private;\n" " -- predefined function \"=\" : in \"=\" [T1, T1 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T1, T1 return BOOLEAN] := <>;\n" " type T2 is <>;\n" " -- predefined function \"<\" : in \"<\" [T2, T2 return BOOLEAN] := <>;\n" " -- predefined function \">\" : in \">\" [T2, T2 return BOOLEAN] := <>;\n" " -- predefined function \"<=\" : in \"<=\" [T2, T2 return BOOLEAN] := <>;\n" " -- predefined function \">=\" : in \">=\" [T2, T2 return BOOLEAN] := <>;\n" " -- predefined function MINIMUM : in MINIMUM [T2, T2 return T2] := <>;\n" " -- predefined function MAXIMUM : in MAXIMUM [T2, T2 return T2] := <>;\n" " -- predefined function TO_STRING : in TO_STRING [T2 return STRING] := <>;\n" " -- predefined function \"=\" : in \"=\" [T2, T2 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T2, T2 return BOOLEAN] := <>;\n" " type T3 is (<>);\n" " -- predefined function \"<\" : in \"<\" [T3, T3 return BOOLEAN] := <>;\n" " -- predefined function \">\" : in \">\" [T3, T3 return BOOLEAN] := <>;\n" " -- predefined function \"<=\" : in \"<=\" [T3, T3 return BOOLEAN] := <>;\n" " -- predefined function \">=\" : in \">=\" [T3, T3 return BOOLEAN] := <>;\n" " -- predefined function MINIMUM : in MINIMUM [T3, T3 return T3] := <>;\n" " -- predefined function MAXIMUM : in MAXIMUM [T3, T3 return T3] := <>;\n" " -- predefined function TO_STRING : in TO_STRING [T3 return STRING] := <>;\n" " -- predefined function \"=\" : in \"=\" [T3, T3 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T3, T3 return BOOLEAN] := <>;\n" " type T4 is range <>;\n" " -- predefined function \"**\" : in \"**\" [T4, T4 return T4] := <>;\n" " -- predefined function \"mod\" : in \"mod\" [T4, T4 return T4] := <>;\n" " -- predefined function \"rem\" : in \"rem\" [T4, T4 return T4] := <>;\n" " -- predefined function \"+\" : in \"+\" [T4, T4 return T4] := <>;\n" " -- predefined function \"-\" : in \"-\" [T4, T4 return T4] := <>;\n" " -- predefined function \"+\" : in \"+\" [T4 return T4] := <>;\n" " -- predefined function \"-\" : in \"-\" [T4 return T4] := <>;\n" " -- predefined function \"*\" : in \"*\" [T4, T4 return T4] := <>;\n" " -- predefined function \"/\" : in \"/\" [T4, T4 return T4] := <>;\n" " -- predefined function \"abs\" : in \"abs\" [T4 return T4] := <>;\n" " -- predefined function \"<\" : in \"<\" [T4, T4 return BOOLEAN] := <>;\n" " -- predefined function \">\" : in \">\" [T4, T4 return BOOLEAN] := <>;\n" " -- predefined function \"<=\" : in \"<=\" [T4, T4 return BOOLEAN] := <>;\n" " -- predefined function \">=\" : in \">=\" [T4, T4 return BOOLEAN] := <>;\n" " -- predefined function MINIMUM : in MINIMUM [T4, T4 return T4] := <>;\n" " -- predefined function MAXIMUM : in MAXIMUM [T4, T4 return T4] := <>;\n" " -- predefined function TO_STRING : in TO_STRING [T4 return STRING] := <>;\n" " -- predefined function \"=\" : in \"=\" [T4, T4 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T4, T4 return BOOLEAN] := <>;\n" " type T5 is units <>;\n" " -- predefined function \"mod\" : in \"mod\" [T5, T5 return T5] := <>;\n" " -- predefined function \"rem\" : in \"rem\" [T5, T5 return T5] := <>;\n" " -- predefined function \"+\" : in \"+\" [T5, T5 return T5] := <>;\n" " -- predefined function \"-\" : in \"-\" [T5, T5 return T5] := <>;\n" " -- predefined function \"+\" : in \"+\" [T5 return T5] := <>;\n" " -- predefined function \"-\" : in \"-\" [T5 return T5] := <>;\n" " -- predefined function \"abs\" : in \"abs\" [T5 return T5] := <>;\n" " -- predefined function \"<\" : in \"<\" [T5, T5 return BOOLEAN] := <>;\n" " -- predefined function \">\" : in \">\" [T5, T5 return BOOLEAN] := <>;\n" " -- predefined function \"<=\" : in \"<=\" [T5, T5 return BOOLEAN] := <>;\n" " -- predefined function \">=\" : in \">=\" [T5, T5 return BOOLEAN] := <>;\n" " -- predefined function MINIMUM : in MINIMUM [T5, T5 return T5] := <>;\n" " -- predefined function MAXIMUM : in MAXIMUM [T5, T5 return T5] := <>;\n" " -- predefined function TO_STRING : in TO_STRING [T5 return STRING] := <>;\n" " -- predefined function \"=\" : in \"=\" [T5, T5 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T5, T5 return BOOLEAN] := <>;\n" " type T6 is range <> . <>;\n" " -- predefined function \"+\" : in \"+\" [T6, T6 return T6] := <>;\n" " -- predefined function \"-\" : in \"-\" [T6, T6 return T6] := <>;\n" " -- predefined function \"+\" : in \"+\" [T6 return T6] := <>;\n" " -- predefined function \"-\" : in \"-\" [T6 return T6] := <>;\n" " -- predefined function \"*\" : in \"*\" [T6, T6 return T6] := <>;\n" " -- predefined function \"/\" : in \"/\" [T6, T6 return T6] := <>;\n" " -- predefined function \"abs\" : in \"abs\" [T6 return T6] := <>;\n" " -- predefined function \"<\" : in \"<\" [T6, T6 return BOOLEAN] := <>;\n" " -- predefined function \">\" : in \">\" [T6, T6 return BOOLEAN] := <>;\n" " -- predefined function \"<=\" : in \"<=\" [T6, T6 return BOOLEAN] := <>;\n" " -- predefined function \">=\" : in \">=\" [T6, T6 return BOOLEAN] := <>;\n" " -- predefined function MINIMUM : in MINIMUM [T6, T6 return T6] := <>;\n" " -- predefined function MAXIMUM : in MAXIMUM [T6, T6 return T6] := <>;\n" " -- predefined function TO_STRING : in TO_STRING [T6 return STRING] := <>;\n" " -- predefined function \"=\" : in \"=\" [T6, T6 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T6, T6 return BOOLEAN] := <>;\n" " type T7 is array (T3 range <>) of T1;\n" " -- predefined function \"=\" : in \"=\" [T7, T7 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T7, T7 return BOOLEAN] := <>;\n" " type T8 is access ..;\n" " -- predefined function \"=\" : in \"=\" [T8, T8 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T8, T8 return BOOLEAN] := <>;\n" " -- predefined procedure DEALLOCATE : in DEALLOCATE [T8] := <>;\n" " type T9 is file of ..;\n" " -- predefined function \"=\" : in \"=\" [T9, T9 return BOOLEAN] := <>;\n" " -- predefined function \"/=\" : in \"/=\" [T9, T9 return BOOLEAN] := <>;\n" " );\n" "end entity;\n" "\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vhdl5) { set_standard(STD_19); input_from_file(TESTDIR "/dump/vhdl5.vhd"); tree_t b = parse_and_check(T_PACKAGE, T_PACK_BODY); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(b); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "package body WORK.VHDL5-body is\n" " type PT is protected\n" " function SOMETHING return INTEGER;\n" " -- WORK.VHDL5.PT.SOMETHING()I\n" " end protected;\n" "\n" " type PT is protected body\n" " variable V : INTEGER := 55;\n" "\n" " function SOMETHING return INTEGER is\n" " -- WORK.VHDL5.PT.SOMETHING()I\n" " begin\n" " return V;\n" " end function;\n" " end protected body;\n" "\n" " variable SV : PT;\n" "\n" " procedure GET_IT ( variable X : out INTEGER ) is -- Never waits\n" " -- WORK.VHDL5.GET_IT(I)\n" " begin\n" " X := SV.SOMETHING;\n" " end procedure;\n" "\n" " procedure ATTRS is -- Never waits\n" " -- WORK.VHDL5.ATTRS\n" " attribute FOO : STRING;\n" " attribute FOO of ATTRS : procedure is \"123\";\n" " attribute FOO of all : literal is \"abcd\";\n" " attribute FOO of others : procedure is \"xxx\";\n" " begin\n" " end procedure;\n" "end package body;\n" "\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_psl1) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/dump/psl1.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); psl_dump(tree_psl(tree_decl(a, 4))); diff_dump(tb_get(tb), "default clock is \"and\"(CLK'EVENT, \"=\"(CLK, '1'))"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 0))); diff_dump(tb_get(tb), "assert never B/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 1))); diff_dump(tb_get(tb), "assert always A -> (next_a [3 to 5] B)" "/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 2))); diff_dump(tb_get(tb), "assert {A;\"and\"(B, C)}" "/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 3))); diff_dump(tb_get(tb), "assert A -> (next [2] (B until! C))" "/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 4))); diff_dump(tb_get(tb), "cover {TRUE[*];A[*4]}/*@(default clock)*/ report \"msg\""); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 5))); diff_dump(tb_get(tb), "assert always ((A until_ B) async_abort C)" "/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 6))); diff_dump(tb_get(tb), "assert (A before! B)/*@(default clock)*/"); tb_rewind(tb); psl_dump(tree_psl(tree_stmt(a, 7))); diff_dump(tb_get(tb), "assert A [[signal X : BIT;\n" "X <= reject 0 ps inertial '1';\n" "]]/*@(default clock)*/"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vlog1) { input_from_file(TESTDIR "/dump/vlog1.v"); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); vlog_dump(m1, 0); diff_dump(tb_get(tb), "module dff (d, clk, rstb, q);\n" " input d;\n" " input clk;\n" " input rstb;\n" " output q;\n" " logic q;\n" " always @(posedge clk) q <= d;\n" "endmodule // dff\n\n"); tb_rewind(tb); vlog_node_t m2 = vlog_parse(); fail_if(m2 == NULL); vlog_dump(m2, 0); diff_dump(tb_get(tb), "module mod2;\n" " wire logic [7:0] bus;\n" " wire logic w;\n" " logic r;\n" " integer i;\n" " parameter logic [7:0] p1 = 5;\n" " localparam bit p2 = 0;\n" " logic [7:0] array1 [127:0];\n" " initial begin\n" " $display(\"hello\", $time);\n" " if (bus) r <= 1 | r;\n" " $finish;\n" " r = 1;\n" " #1 r <= 0;\n" " r = ~w;\n" " r = #1 5;\n" " r <= #5 1;\n" " do w = r && w; while (r);\n" " while (1);\n" " repeat (5) r = r + 1;\n" " for (i = 0; i < 10; i++) r = !r;\n" " forever i = ++i;\n" " end\n" " assign bus = 3;\n" " pullup (supply0,supply1) g1 (w);\n" " mod #(42) u1 (w), u2 (bus[1]);\n" " assign bus[2] = 4'd1;\n" " initial casex (w)\n" " 1'b0, 1'b1: r = p1[3:0];\n" " default: r = 0;\n" " endcase\n" "endmodule // mod2\n\n"); tb_rewind(tb); vlog_node_t m3 = vlog_parse(); fail_if(m3 == NULL); vlog_dump(m3, 0); diff_dump(tb_get(tb), "primitive multiplexer (mux, control, dataA, dataB);\n" " output mux;\n" " input control;\n" " input dataA;\n" " input dataB;\n" " table\n" " 01?:1;\n" " 00?:0;\n" " 1?1:1;\n" " 1?0:0;\n" " endtable\n" "endprimitive // multiplexer\n\n"); tb_rewind(tb); vlog_node_t m4 = vlog_parse(); fail_if(m4 == NULL); vlog_dump(m4, 0); diff_dump(tb_get(tb), "module mod3;\n" " wire logic x;\n" " wire logic y;\n" " wire logic z;\n" " real v1 = 1.5;\n" " integer v2 = x ? 1 : 2;\n" " wire logic zz;\n" " initial begin\n" " if (x || (y === z)) ;\n" " if ((x & y) | (y & (z === (x + z)))) ;\n" " if ((x == y) || (y == z)) ;\n" " if ((x & y) == z) ;\n" " end\n" " assign z = {x, y};\n" " assign zz = {5{z}};\n" "endmodule // mod3\n\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vhdl6) { set_standard(STD_08); input_from_file(TESTDIR "/dump/vhdl6.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH, -1); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); dump(a); diff_dump(tb_get(tb), "use STD.STANDARD.all;\n" "\n" "architecture WORK.VHDL6-TEST of VHDL6 is\n" " signal X : INTEGER;\n" " default clock is TRUE;\n" "begin\n" " assert \"=\"(<< constant ^.FOO : INTEGER >>, 2);\n" " assert \"=\"(X, 1) -> (\"=\"(X, 2))/*@(default clock)*/;\n" "end architecture;\n\n"); tb_rewind(tb); fail_if_errors(); } END_TEST START_TEST(test_vhdl7) { set_standard(STD_19); input_from_file(TESTDIR "/dump/vhdl7.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); LOCAL_TEXT_BUF tb = tb_new(); capture_syntax(tb); tree_t source = get_decl(a, "SOURCE"); dump(source); diff_dump(tb_get(tb), "view SOURCE of T_REC is\n" " X : IN;\n" " Y : OUT;\n" "end view;\n"); tb_rewind(tb); tree_t b = tree_stmt(a, 0); dump(b); diff_dump(tb_get(tb), "B: block is\n" " port (\n" " signal P1 : view SOURCE;\n" " signal P2 : view SOURCE'CONVERSE );\n" " port map (X, Y);\n" "begin\n" "end block;\n"); tb_rewind(tb); fail_if_errors(); } END_TEST Suite *get_dump_tests(void) { Suite *s = suite_create("dump"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_vhdl1); tcase_add_test(tc_core, test_vhdl2); tcase_add_test(tc_core, test_vhdl3); tcase_add_test(tc_core, test_vhdl4); tcase_add_test(tc_core, test_vhdl5); tcase_add_test(tc_core, test_psl1); tcase_add_test(tc_core, test_vlog1); tcase_add_test(tc_core, test_vhdl6); tcase_add_test(tc_core, test_vhdl7); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_elab.c000066400000000000000000001375031504111170000156350ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "cov/cov-api.h" #include "diag.h" #include "jit/jit.h" #include "lib.h" #include "option.h" #include "phase.h" #include "rt/model.h" #include "scan.h" #include "type.h" #include #include #include START_TEST(test_elab1) { input_from_file(TESTDIR "/elab/elab1.vhd"); (void)run_elab(); fail_if_errors(); } END_TEST START_TEST(test_elab2) { input_from_file(TESTDIR "/elab/elab2.vhd"); (void)run_elab(); fail_if_errors(); } END_TEST START_TEST(test_elab3) { input_from_file(TESTDIR "/elab/elab3.vhd"); (void)run_elab(); fail_if_errors(); } END_TEST START_TEST(test_open) { tree_t top; input_from_file(TESTDIR "/elab/open.vhd"); top = run_elab(); fail_if(top == NULL); // We used to delete all statements here but the behaviour // has changed fail_unless(tree_stmts(top) == 1); fail_if_errors(); } END_TEST START_TEST(test_genagg) { input_from_file(TESTDIR "/elab/genagg.vhd"); (void)run_elab(); fail_if_errors(); } END_TEST START_TEST(test_comp) { input_from_file(TESTDIR "/elab/comp.vhd"); const error_t expect[] = { { 77, "port X in entity WORK.E2 without a default value has no " "corresponding port in component E2" }, { 83, "port X in component E3 has type BIT which is incompatible " "with type INTEGER in entity WORK.E3" }, { -1, NULL } }; expect_errors(expect); (void)run_elab(); check_expected_errors(); } END_TEST START_TEST(test_issue17) { input_from_file(TESTDIR "/elab/issue17.vhd"); (void)run_elab(); fail_if_errors(); } END_TEST START_TEST(test_issue19) { input_from_file(TESTDIR "/elab/issue19.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_unless(tree_stmts(e) == 1); fail_if_errors(); } END_TEST START_TEST(test_bounds10) { input_from_file(TESTDIR "/elab/bounds10.vhd"); const error_t expect[] = { { 10, "length of value 1 does not match length of target 101" }, { -1, NULL } }; expect_errors(expect); (void)run_elab(); } END_TEST START_TEST(test_copy1) { input_from_file(TESTDIR "/elab/copy1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t copy1 = tree_stmt(e, 0); tree_t sub1_i = tree_stmt(copy1, 0); tree_t sub2_i = tree_stmt(copy1, 1); tree_t func1 = get_decl(sub1_i, "DOUBLE"); tree_t func2 = get_decl(sub2_i, "DOUBLE"); fail_if(func1 == func2); // Should copy functions tree_t var1 = get_decl(sub1_i, "GLOBAL"); tree_t var2 = get_decl(sub2_i, "GLOBAL"); fail_unless(var1 == var2); // Should not copy variables fail_if_errors(); } END_TEST START_TEST(test_record) { input_from_file(TESTDIR "/elab/record.vhd"); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_ifgen) { input_from_file(TESTDIR "/elab/ifgen.vhd"); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_open2) { input_from_file(TESTDIR "/elab/open2.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue93) { input_from_file(TESTDIR "/elab/issue93.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t top = run_elab(); fail_if(top == NULL); fail_unless(tree_stmts(tree_stmt(top, 0)) == 4); fail_if_errors(); } END_TEST START_TEST(test_const1) { input_from_file(TESTDIR "/elab/const1.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t top = run_elab(); fail_if(top == NULL); tree_t pwm_1 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(pwm_1) == T_BLOCK); tree_t ctr_r = tree_decl(pwm_1, tree_decls(pwm_1) - 1); fail_unless(tree_kind(ctr_r) == T_SIGNAL_DECL); fail_unless(tree_ident(ctr_r) == ident_new("CTR_R")); int64_t len; fail_unless(folded_length(range_of(tree_type(ctr_r), 0), &len)); fail_unless(len == 15); fail_if_errors(); } END_TEST START_TEST(test_libbind) { input_from_file(TESTDIR "/elab/libbind.vhd"); lib_t work = lib_work(); lib_t other = lib_tmp("other"); lib_set_work(other); parse_check_and_simplify(T_ENTITY, T_ARCH, -1); fail_if_errors(); lib_set_work(work); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue153) { input_from_file(TESTDIR "/elab/issue153.vhd"); // This used to produce an error at elaboration time fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue157) { input_from_file(TESTDIR "/elab/issue157.vhd"); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue159) { input_from_file(TESTDIR "/elab/issue159.vhd"); lib_t work = lib_work(); lib_t other = lib_tmp("dummy"); lib_set_work(other); parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH, -1); fail_if_errors(); lib_set_work(work); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue175) { input_from_file(TESTDIR "/elab/issue175.vhd"); lib_t lib2 = lib_tmp("lib2"); lib_set_work(lib2); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY, -1); fail_if_errors(); lib_t lib = lib_tmp("lib"); lib_set_work(lib); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue184) { input_from_file(TESTDIR "/elab/issue184.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t gen_cfg2 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(gen_cfg2) == T_BLOCK); fail_unless(tree_stmts(gen_cfg2) == 1); fail_unless(icmp(tree_ident(tree_stmt(gen_cfg2, 0)), "GOOD")); fail_if_errors(); } END_TEST START_TEST(test_libbind2) { input_from_file(TESTDIR "/elab/libbind2.vhd"); lib_t work = lib_work(); lib_t other = lib_tmp("other"); lib_set_work(other); parse_check_and_simplify(T_ENTITY, T_ARCH, -1); fail_if_errors(); lib_set_work(work); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_toplevel2) { input_from_file(TESTDIR "/elab/toplevel2.vhd"); const error_t expect[] = { { LINE_INVALID, "generic value for UNUSED not used" }, { -1, NULL } }; expect_errors(expect); elab_set_generic("I", "4"); elab_set_generic("S", "hello"); elab_set_generic("B", "'1'"); elab_set_generic("V", "101"); elab_set_generic("UNUSED", "6678"); tree_t top = run_elab(); fail_if(top == NULL); fail_unless(tree_stmts(tree_stmt(top, 0)) == 3); check_expected_errors(); } END_TEST START_TEST(test_libbind3) { input_from_file(TESTDIR "/elab/libbind3.vhd"); lib_set_work(lib_tmp("foo")); parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, -1); fail_if_errors(); lib_set_work(lib_tmp("bar")); fail_if(run_elab() == NULL); fail_if_errors(); } END_TEST START_TEST(test_jcore1) { input_from_file(TESTDIR "/elab/jcore1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t sub_i = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(sub_i) == T_BLOCK); fail_unless(tree_params(sub_i) == 2); tree_t p0 = tree_param(sub_i, 0); fail_unless(tree_subkind(p0) == P_POS); fail_unless(tree_kind(tree_value(p0)) == T_RECORD_REF); fail_if_errors(); } END_TEST START_TEST(test_eval1) { input_from_file(TESTDIR "/elab/eval1.vhd"); const error_t expect[] = { { 12, "index -1 outside of INTEGER range 7 downto 0" }, { 16, "generate expression is not static" }, { -1, NULL } }; expect_errors(expect); fail_unless(run_elab() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue305) { input_from_file(TESTDIR "/elab/issue305.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t s = tree_decl(tree_stmt(top, 0), 2); fail_unless(tree_kind(s) == T_SIGNAL_DECL); fail_unless(icmp(tree_ident(s), "DATA_I")); int64_t len; fail_unless(folded_length(range_of(tree_type(s), 0), &len)); ck_assert_int_eq(len, 8); fail_if_errors(); } END_TEST START_TEST(test_gbounds) { input_from_file(TESTDIR "/elab/gbounds.vhd"); tree_t top = run_elab(); fail_if(top == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue307) { input_from_file(TESTDIR "/elab/issue307.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t proc = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(proc) == T_PROCESS); tree_t s0 = tree_stmt(proc, 0); fail_unless(tree_kind(s0) == T_PCALL); fail_if_errors(); } END_TEST START_TEST(test_issue315) { input_from_file(TESTDIR "/elab/issue315.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t d2 = get_decl(tree_stmt(top, 0), "INFO"); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(tree_value(d2)) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_issue325) { input_from_file(TESTDIR "/elab/issue325.vhd"); lib_set_work(lib_tmp("foo")); tree_t top = run_elab(); fail_if(top == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue328) { input_from_file(TESTDIR "/elab/issue328.vhd"); lib_set_work(lib_tmp("foo")); tree_t top = run_elab(); fail_if(top == NULL); tree_t b0 = tree_stmt(top, 0); tree_t vec_range = get_decl(b0, "VEC_RANGE"); fail_unless(tree_kind(vec_range) == T_CONST_DECL); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(tree_value(vec_range)) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_issue330) { input_from_file(TESTDIR "/elab/issue330.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t b0 = tree_stmt(top, 0); tree_t vec_range = get_decl(b0, "VEC_RANGE"); fail_unless(tree_kind(vec_range) == T_CONST_DECL); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(tree_value(vec_range)) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_issue336) { input_from_file(TESTDIR "/elab/issue336.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_unless(tree_stmts(tree_stmt(e, 0)) == 3); fail_if_errors(); } END_TEST START_TEST(test_openinout) { input_from_file(TESTDIR "/elab/openinout.vhd"); tree_t e = run_elab(); tree_t b_top = tree_stmt(e, 0); tree_t b_uut = tree_stmt(b_top, 0); fail_unless(tree_ident(b_uut) == ident_new("UUT")); fail_unless(tree_params(b_uut) == 4); tree_t b_uut_m0 = tree_param(b_uut, 0); fail_unless(tree_subkind(b_uut_m0) == P_POS); fail_unless(tree_kind(tree_value(b_uut_m0)) == T_OPEN); tree_t p0 = tree_stmt(b_uut, 0); tree_t p0s0 = tree_stmt(p0, 0); fail_unless(tree_kind(p0s0) == T_SIGNAL_ASSIGN); tree_t p0s0w0 = tree_value(tree_waveform(p0s0, 0)); fail_unless(tree_kind(p0s0w0) == T_FCALL); tree_t p1 = tree_stmt(b_uut, 1); tree_t p1s0 = tree_stmt(p1, 0); fail_unless(tree_kind(p1s0) == T_SIGNAL_ASSIGN); tree_t p1s0w0 = tree_value(tree_waveform(p1s0, 0)); fail_unless(tree_kind(p1s0w0) == T_FCALL); tree_t b_uut2 = tree_stmt(b_top, 1); fail_unless(tree_ident(b_uut2) == ident_new("UUT2")); fail_unless(tree_params(b_uut2) == 2); tree_t b_sub = tree_stmt(b_uut2, 0); fail_unless(tree_ident(b_sub) == ident_new("SUB_I")); fail_unless(tree_params(b_sub) == 4); tree_t p2 = tree_stmt(b_sub, 0); tree_t p2s0 = tree_stmt(p2, 0); fail_unless(tree_kind(p2s0) == T_SIGNAL_ASSIGN); tree_t p2s0w0 = tree_value(tree_waveform(p2s0, 0)); fail_unless(tree_kind(p2s0w0) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_opencase) { input_from_file(TESTDIR "/elab/opencase.vhd"); tree_t e = run_elab(); tree_t uut = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_params(uut) == 2); fail_unless(tree_stmts(uut) == 1); tree_t py = tree_param(uut, 1); fail_unless(tree_subkind(py) == P_POS); fail_unless(tree_pos(py) == 1); fail_unless(tree_kind(tree_value(py)) == T_OPEN); fail_if_errors(); } END_TEST START_TEST(test_issue232) { input_from_file(TESTDIR "/elab/issue232.vhd"); tree_t e = run_elab(); tree_t e1 = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(e1) == T_BLOCK); tree_t p0 = tree_stmt(e1, 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t s0 = tree_stmt(p0, 0); fail_unless(tree_kind(s0) == T_SIGNAL_ASSIGN); fail_unless(tree_params(e1) == 2); fail_unless(tree_kind(tree_value(tree_param(e1, 0))) == T_OPEN); tree_t v = tree_value(tree_port(e1, 0)); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 2); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'A'")); fail_unless(tree_ident(tree_char(v, 1)) == ident_new("'B'")); fail_if_errors(); } END_TEST START_TEST(test_issue373) { input_from_file(TESTDIR "/elab/issue373.vhd"); tree_t e = run_elab(); tree_t unit = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(unit) == T_BLOCK); fail_unless(tree_ident(unit) == ident_new("UNIT")); fail_unless(tree_stmts(unit) == 1); tree_t sub = tree_stmt(unit, 0); fail_unless(tree_kind(sub) == T_BLOCK); fail_unless(tree_ident(sub) == ident_new("SUB")); fail_unless(tree_stmts(sub) == 1); tree_t p0 = tree_stmt(sub, 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t s0 = tree_stmt(p0, 0); fail_unless(tree_kind(s0) == T_REPORT); tree_t m = tree_message(s0); fail_unless(tree_kind(m) == T_REF); // This used to get folded by the old evaluator fail_if_errors(); } END_TEST START_TEST(test_issue374) { input_from_file(TESTDIR "/elab/issue374.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue404) { input_from_file(TESTDIR "/elab/issue404.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t p0 = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t s0 = tree_stmt(p0, 0); fail_unless(tree_kind(s0) == T_SIGNAL_ASSIGN); tree_t v0 = tree_value(tree_waveform(s0, 0)); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(v0) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_block1) { input_from_file(TESTDIR "/elab/block1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(b) == T_BLOCK); fail_unless(tree_params(b) == 2); fail_unless(tree_genmaps(b) == 1); fail_if_errors(); } END_TEST START_TEST(test_open3) { input_from_file(TESTDIR "/elab/open3.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(b) == T_BLOCK); fail_unless(tree_params(b) == 3); fail_unless(tree_subkind(tree_param(b, 0)) == P_NAMED); fail_unless(tree_subkind(tree_param(b, 1)) == P_NAMED); fail_unless(tree_subkind(tree_param(b, 2)) == P_NAMED); fail_if_errors(); } END_TEST START_TEST(test_comp2) { input_from_file(TESTDIR "/elab/comp2.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t top = tree_stmt(e, 0); fail_unless(tree_kind(top) == T_BLOCK); fail_unless(tree_stmts(top) == 2); tree_t sub1_i = tree_stmt(top, 0); fail_unless(tree_kind(sub1_i) == T_BLOCK); fail_unless(tree_ident(sub1_i) == ident_new("SUB1_I")); fail_unless(tree_generics(sub1_i) == 0); fail_unless(tree_genmaps(sub1_i) == 0); tree_t sub1 = tree_stmt(sub1_i, 0); fail_unless(tree_kind(sub1) == T_BLOCK); fail_unless(tree_ident(sub1) == ident_new("SUB1")); fail_unless(tree_generics(sub1) == 1); fail_unless(tree_genmaps(sub1) == 1); tree_t sub1_x = tree_value(tree_genmap(sub1, 0)); fail_unless(tree_kind(sub1_x) == T_LITERAL); fail_unless(tree_ival(sub1_x) == 4); tree_t sub1_y = tree_value(tree_decl(sub1, 1)); fail_unless(tree_kind(sub1_y) == T_LITERAL); fail_unless(tree_ival(sub1_y) == 4); tree_t sub2_i = tree_stmt(top, 1); fail_unless(tree_kind(sub2_i) == T_BLOCK); fail_unless(tree_ident(sub2_i) == ident_new("SUB2_I")); fail_unless(tree_generics(sub2_i) == 2); fail_unless(tree_genmaps(sub2_i) == 2); tree_t sub2 = tree_stmt(sub2_i, 0); fail_unless(tree_kind(sub2) == T_BLOCK); fail_unless(tree_ident(sub2) == ident_new("SUB2")); fail_unless(tree_generics(sub2) == 2); fail_unless(tree_genmaps(sub2) == 2); tree_t sub2_x = tree_value(tree_genmap(sub2, 0)); fail_unless(tree_kind(sub2_x) == T_LITERAL); fail_unless(tree_ival(sub2_x) == 7); tree_t sub2_y = tree_value(tree_genmap(sub2, 1)); fail_unless(tree_kind(sub2_y) == T_REF); fail_unless(tree_ident(sub2_y) == ident_new("FALSE")); fail_if_errors(); } END_TEST START_TEST(test_comp3) { input_from_file(TESTDIR "/elab/comp3.vhd"); const error_t expect[] = { { 36, "generic X in entity WORK.SUB1 without a default value has no " "corresponding generic in component SUB1" }, { 0, "declaration of generic X in entity" }, { 38, "generic X in component SUB2 has type BOOLEAN which is " "incompatible with type INTEGER in entity WORK.SUB2" }, { 0, "declaration of generic X in component" }, { 0, "declaration of generic X in entity" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_tc3138) { input_from_file(TESTDIR "/elab/tc3138.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("C05S02B02X00P02N01I03138ENT")); fail_unless(tree_stmts(b0) == 2); fail_unless(tree_kind(tree_stmt(b0, 0)) == T_BLOCK); fail_unless(tree_kind(tree_stmt(b0, 1)) == T_PROCESS); fail_if_errors(); } END_TEST START_TEST(test_tc2881) { input_from_file(TESTDIR "/elab/tc2881.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("C02S01B00X00P07N01I02881ENT")); fail_unless(tree_stmts(b0) == 1); tree_t p0 = tree_stmt(b0, 0); fail_unless(tree_kind(p0) == T_PROCESS); // The assignment "x:= func2(3)" is globally static where func2 is // declared in the entity is globaally static and should really be // folded but isn't currently fail_if_errors(); } END_TEST START_TEST(test_tc846) { input_from_file(TESTDIR "/elab/tc846.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("C01S03B01X00P08N01I00846ENT")); fail_unless(tree_stmts(b0) == 2); tree_t a1 = tree_stmt(b0, 0); fail_unless(tree_ident(a1) == ident_new("A1")); fail_unless(tree_stmts(a1) == 1); tree_t fa = tree_stmt(a1, 0); fail_unless(tree_ident(fa) == ident_new("FULL_ADDER")); fail_unless(tree_stmts(fa) == 1); tree_t c1 = tree_stmt(fa, 0); fail_unless(tree_ident(c1) == ident_new("C1")); fail_unless(tree_stmts(c1) == 1); tree_t and2g = tree_stmt(c1, 0); fail_unless(tree_ident(and2g) == ident_new("AND2G")); fail_unless(tree_stmts(and2g) == 0); fail_unless(tree_decls(and2g) == 2); fail_unless(tree_ident(tree_decl(and2g, 1)) == ident_new("X")); fail_if_errors(); } END_TEST START_TEST(test_issue435) { input_from_file(TESTDIR "/elab/issue435.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("ISSUE435")); fail_unless(tree_stmts(b0) == 1); tree_t q = tree_stmt(b0, 0); fail_unless(tree_ident(q) == ident_new("Q")); fail_unless(tree_stmts(q) == 1); tree_t ifgen = tree_stmt(q, 0); fail_unless(tree_ident(ifgen) == ident_new("QUEUE_SIZE_VALID")); fail_unless(tree_stmts(ifgen) == 0); fail_if_errors(); } END_TEST START_TEST(test_issue442) { input_from_file(TESTDIR "/elab/issue442.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("ISSUE442")); fail_unless(tree_stmts(b0) == 1); tree_t dut = tree_stmt(b0, 0); fail_unless(tree_ident(dut) == ident_new("DUT")); fail_unless(tree_kind(dut) == T_BLOCK); fail_unless(tree_stmts(dut) == 1); fail_unless(tree_genmaps(dut) == 2); tree_t sample = tree_stmt(dut, 0); fail_unless(tree_ident(sample) == ident_new("SAMPLE")); fail_unless(tree_kind(sample) == T_BLOCK); fail_unless(tree_genmaps(sample) == 2); tree_t m1 = tree_value(tree_genmap(sample, 1)); fail_unless(tree_kind(m1) == T_LITERAL); fail_unless(tree_ival(m1) == 4); fail_if_errors(); } END_TEST START_TEST(test_issue448) { input_from_file(TESTDIR "/elab/issue448.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("ISSUE448")); fail_unless(tree_stmts(b0) == 1); tree_t tb = tree_stmt(b0, 0); fail_unless(tree_ident(tb) == ident_new("TB")); fail_unless(tree_kind(tb) == T_BLOCK); fail_unless(tree_stmts(tb) == 1); fail_unless(tree_genmaps(tb) == 5); tree_t inner = tree_stmt(tb, 0); fail_unless(tree_ident(inner) == ident_new("IMAGE_STREAM_BUFFER_TEST_BENCH")); fail_unless(tree_kind(inner) == T_BLOCK); fail_unless(tree_genmaps(inner) == 6); tree_t m1 = tree_value(tree_genmap(inner, 2)); fail_unless(tree_kind(m1) == T_LITERAL); fail_unless(tree_ival(m1) == 8192); fail_if_errors(); } END_TEST START_TEST(test_fold1) { input_from_file(TESTDIR "/elab/fold1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("FOLD1")); fail_unless(tree_stmts(b0) == 1); tree_t u = tree_stmt(b0, 0); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_kind(u) == T_BLOCK); // This used to get folded by the old evaluator fail_unless(tree_stmts(u) == 1); fail_unless(tree_genmaps(u) == 1); fail_unless(tree_decls(u) == 2); tree_t k = tree_decl(u, 1); fail_unless(tree_ident(k) == ident_new("K")); fail_unless(tree_kind(tree_value(k)) == T_REF); // This used to get folded by the old evaluator fail_if_errors(); } END_TEST START_TEST(test_fold2) { input_from_file(TESTDIR "/elab/fold2.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("FOLD2")); fail_unless(tree_stmts(b0) == 1); tree_t u = tree_stmt(b0, 0); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_kind(u) == T_BLOCK); // This used to get folded by the old evaluator fail_unless(tree_stmts(u) == 1); fail_unless(tree_genmaps(u) == 1); fail_unless(tree_decls(u) == 2); tree_t k = tree_decl(u, 1); fail_unless(tree_ident(k) == ident_new("K")); fail_unless(tree_kind(tree_value(k)) == T_REF); // This used to get folded by the old evaluator fail_if_errors(); } END_TEST START_TEST(test_toplevel3) { set_standard(STD_08); input_from_file(TESTDIR "/elab/toplevel3.vhd"); const error_t expect[] = { { 15, "top-level port R2 cannot have unconstrained type REC" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_ename1) { set_standard(STD_08); input_from_file(TESTDIR "/elab/ename1.vhd"); const error_t expect[] = { { 23, "external name X not found" }, { 0, "name UUT not found inside ENAME1" }, { 0, "an object cannot be referenced by an external name until " "it has been elaborated" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue459) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue459.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("ISSUE459")); fail_unless(tree_stmts(b0) == 1); tree_t u = tree_stmt(b0, 0); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_kind(u) == T_BLOCK); fail_unless(tree_stmts(u) == 2); fail_if_errors(); } END_TEST START_TEST(test_link1) { input_from_file(TESTDIR "/elab/link1.vhd"); const error_t expect[] = { { 2, "division by zero" }, { 7, "failed to initialise package WORK.PACK" }, // TODO: this fatal error should be removed after lazy linking is added { 24, "failed to link package WORK.PACK" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_generate1) { set_standard(STD_08); input_from_file(TESTDIR "/elab/generate1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("GENERATE1")); fail_unless(tree_stmts(b0) == 3); tree_t g1 = tree_stmt(b0, 0); fail_unless(tree_ident(g1) == ident_new("G(1)")); fail_unless(tree_kind(g1) == T_BLOCK); fail_unless(tree_stmts(g1) == 1); fail_if_errors(); } END_TEST START_TEST(test_neorv1) { input_from_file(TESTDIR "/elab/neorv1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("NEORV1")); fail_unless(tree_stmts(b0) == 2); tree_t g0 = tree_stmt(b0, 0); fail_unless(tree_ident(g0) == ident_new("G(0)")); fail_unless(tree_kind(g0) == T_BLOCK); fail_unless(tree_stmts(g0) == 1); tree_t u = tree_stmt(g0, 0); fail_unless(tree_kind(u) == T_BLOCK); tree_t p0 = tree_port(u, 0); tree_t m0 = tree_param(u, 0); fail_unless(tree_subkind(m0) == P_NAMED); tree_t n = tree_name(m0); fail_unless(tree_kind(n) == T_ARRAY_REF); fail_unless(tree_ref(tree_value(n)) == p0); fail_if_errors(); } END_TEST START_TEST(test_toplevel4) { elab_set_generic("CONFIG", "hello"); elab_set_generic("R", "2.5"); elab_set_generic("T", "5000 us"); input_from_file(TESTDIR "/elab/toplevel4.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("TOPLEVEL4")); fail_unless(tree_stmts(b0) == 1); // String assert does not fold tree_t m0 = tree_value(tree_genmap(b0, 0)); fail_unless(tree_kind(m0) == T_STRING); fail_unless(type_kind(tree_type(m0)) == T_SUBTYPE); fail_if_errors(); } END_TEST START_TEST(test_comp4) { set_standard(STD_08); input_from_file(TESTDIR "/elab/comp4.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("COMP4")); fail_unless(tree_stmts(b0) == 1); tree_t u = tree_stmt(b0, 0); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_stmts(u) == 1); fail_if_errors(); } END_TEST START_TEST(test_issue514) { input_from_file(TESTDIR "/elab/issue514.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t b0 = tree_stmt(e, 0); fail_unless(tree_ident(b0) == ident_new("ISSUE514")); fail_unless(tree_stmts(b0) == 1); tree_t u = tree_stmt(b0, 0); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_stmts(u) == 3); fail_if_errors(); } END_TEST START_TEST(test_issue518) { input_from_file(TESTDIR "/elab/issue518.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_config1) { input_from_file(TESTDIR "/elab/config1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t top = tree_stmt(e, 0); fail_unless(tree_stmts(top) == 2); tree_t u1 = tree_stmt(top, 0); fail_unless(tree_ports(u1) == 0); fail_unless(tree_params(u1) == 0); tree_t u2 = tree_stmt(top, 1); fail_unless(tree_ports(u2) == 1); fail_unless(tree_params(u2) == 1); fail_if_errors(); } END_TEST START_TEST(test_ename2) { set_standard(STD_08); input_from_file(TESTDIR "/elab/ename2.vhd"); const error_t expect[] = { { 22, "external name K not found" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_assert7) { input_from_file(TESTDIR "/elab/assert7.vhd"); const error_t expect[] = { { 8, "Assertion violation." }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue539) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue539.vhd"); const error_t expect[] = { { 23, "value length 2 does not match signal S length 1" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_bounds14) { input_from_file(TESTDIR "/elab/bounds14.vhd"); const error_t expect[] = { { 11, "value length 12 does not match signal X length 8" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue228) { elab_set_generic("G", "10"); input_from_file(TESTDIR "/elab/issue228.vhd"); const error_t expect[] = { { 2, "value 10 outside of INTEGER range 0 to 3 for generic G" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_generic1) { input_from_file(TESTDIR "/elab/generic1.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t u = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_stmts(u) == 2); tree_t p1s0 = tree_stmt(tree_stmt(u, 0), 0); fail_unless(tree_kind(p1s0) == T_SIGNAL_ASSIGN); tree_t one = tree_value(tree_waveform(p1s0, 0)); fail_unless(tree_kind(one) == T_LITERAL); fail_unless(tree_ival(one) == 1); tree_t p2s0 = tree_stmt(tree_stmt(u, 1), 0); fail_unless(tree_kind(p2s0) == T_ASSERT); tree_t m = tree_message(p2s0); fail_unless(tree_kind(m) == T_REF); fail_unless(tree_ident(m) == ident_new("M")); fail_unless(tree_kind(tree_ref(m)) == T_GENERIC_DECL); tree_t sev = tree_severity(p2s0); fail_unless(tree_kind(sev) == T_REF); fail_unless(tree_ident(sev) == ident_new("ERROR")); fail_unless(tree_kind(tree_ref(sev)) == T_ENUM_LIT); fail_if_errors(); } END_TEST START_TEST(test_generic2) { input_from_file(TESTDIR "/elab/generic2.vhd"); tree_t e = run_elab(); fail_if(e == NULL); tree_t u = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_stmts(u) == 2); tree_t p1s0 = tree_stmt(tree_stmt(u, 0), 0); fail_unless(tree_kind(p1s0) == T_SIGNAL_ASSIGN); tree_t two = tree_value(tree_waveform(p1s0, 0)); fail_unless(tree_kind(two) == T_LITERAL); fail_unless(tree_ival(two) == 2); tree_t p2s0 = tree_stmt(tree_stmt(u, 1), 0); fail_unless(tree_kind(p2s0) == T_ASSERT); tree_t value = tree_value(p2s0); fail_unless(tree_kind(value) == T_REF); fail_unless(tree_ident(value) == ident_new("FALSE")); fail_unless(tree_kind(tree_ref(value)) == T_ENUM_LIT); fail_if_errors(); } END_TEST START_TEST(test_issue669) { input_from_file(TESTDIR "/elab/issue669.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_if(e == NULL); tree_t f = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(f) == T_BLOCK); fail_unless(tree_ident(f) == ident_new("F")); tree_t p = tree_stmt(f, 0); fail_unless(tree_kind(p) == T_PROCESS); tree_t w = tree_stmt(p, 1); fail_unless(tree_kind(w) == T_WAIT); ck_assert_int_eq(tree_ival(tree_delay(w)), INT64_C(-1000000000000)); fail_if_errors(); } END_TEST START_TEST(test_mixed1) { analyse_file(TESTDIR "/elab/mixed1.v", NULL, NULL, NULL); input_from_file(TESTDIR "/elab/mixed1.vhd"); const error_t expect[] = { { 23, "missing matching VHDL port declaration for Verilog port 'two' " "in component MOD1" }, { 37, "port FOUR not found in Verilog module mod1" }, { 48, "cannot connect VHDL signal with type BIT to Verilog output " "port 'three'" }, { 56, "missing matching VHDL generic declaration for Verilog parameter " "'g1' in component MOD1" }, { 67, "generic G1 should have type INTEGER to match corresponding " "Verilog parameter" }, { 79, "generic G2 not found in Verilog module mod1" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_genpack1) { set_standard(STD_08); input_from_file(TESTDIR "/elab/genpack1.vhd"); const error_t expect[] = { { 8, "Assertion violation." }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_genpack2) { set_standard(STD_08); input_from_file(TESTDIR "/elab/genpack2.vhd"); const error_t expect[] = { { 14, "Assertion violation." }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_genpack3) { set_standard(STD_08); input_from_file(TESTDIR "/elab/genpack3.vhd"); const error_t expect[] = { { 8, "Assertion violation." }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_genpack4) { set_standard(STD_08); input_from_file(TESTDIR "/elab/genpack4.vhd"); const error_t expect[] = { { 19, "Assertion violation." }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_view1) { set_standard(STD_19); input_from_file(TESTDIR "/elab/view1.vhd"); const error_t expect[] = { { 21, "value length 3 does not match view IN_VIEW length 2" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue707) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue707.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_bounds40) { set_standard(STD_08); input_from_file(TESTDIR "/elab/bounds40.vhd"); const error_t expect[] = { { 32, "actual length 3 does not match formal length 8" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_bounds41) { set_standard(STD_08); input_from_file(TESTDIR "/elab/bounds41.vhd"); const error_t expect[] = { { 38, "actual length 1 does not match formal length 2" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_body1) { input_from_file(TESTDIR "/elab/body1.vhd"); const error_t expect[] = { { 1, "missing body for package WORK.PACK" }, { -1, NULL } }; expect_errors(expect); (void)run_elab(); } END_TEST START_TEST(test_issue759) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue759.vhd"); tree_t a = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); cover_data_t *cover = cover_data_init(COVER_MASK_ALL, 0, 0); rt_model_t *m = model_new(jit, cover); tree_t e = elab(tree_to_object(a), jit, ur, mc, cover, NULL, m); fail_if(e == NULL); model_free(m); jit_free(jit); fail_if_errors(); } END_TEST START_TEST(test_block2) { set_standard(_i); input_from_file(TESTDIR "/elab/block2.vhd"); run_elab(); fail_if_errors(); } END_TEST START_TEST(test_bounds42) { input_from_file(TESTDIR "/elab/bounds42.vhd"); const error_t expect[] = { { 27, "actual length 5 does not match formal length 2" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_gentype1) { set_standard(STD_08); input_from_file(TESTDIR "/elab/gentype1.vhd"); const error_t expect[] = { { 6, "declaration of signal S cannot have unconstrained " "type BIT_VECTOR" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_bounds7) { set_standard(STD_08); input_from_file(TESTDIR "/elab/bounds7.vhd"); const error_t expect[] = { { 23, "actual length 3 does not match formal length 8" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_bounds11) { input_from_file(TESTDIR "/elab/bounds11.vhd"); const error_t expect[] = { { 35, "actual length 3 does not match formal length 5" }, { 0, "while elaborating instance U" }, { 0, "generic G => OPEN" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_jcore2) { input_from_file(TESTDIR "/elab/jcore2.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_vlog1) { const error_t expect[] = { { 11, "name of Verilog module sub1 in library unit WORK.SUB1 does " "not match name SUB1 in module instance u2" }, { 12, "expected 2 port connections for module sub1 but found 1" }, { 13, "module bad not found in library WORK" }, { 14, "missing value for parameter p" }, { 15, "module sub1 has 1 parameter but 2 values given" }, { -1, NULL } }; expect_errors(expect); analyse_file(TESTDIR "/elab/vlog1.v", NULL, NULL, NULL); object_t *obj = lib_get_generic(lib_work(), ident_new("WORK.VLOG1"), NULL); ck_assert_ptr_nonnull(obj); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); rt_model_t *m = model_new(j, NULL); tree_t top = elab(obj, j, ur, mc, NULL, NULL, m); fail_unless(top == NULL); model_free(m); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_ename3) { set_standard(STD_08); input_from_file(TESTDIR "/elab/ename3.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue855) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue855.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue864) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue864.vhd"); const error_t expect[] = { { 15, "Could not open: ./nonexistent.txt" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue860) { set_standard(STD_08); input_from_file(TESTDIR "/elab/issue860.vhd"); const error_t expect[] = { { 34, "external name CLK not found" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_genpack5) { set_standard(STD_08); input_from_file(TESTDIR "/elab/genpack5.vhd"); const error_t expect[] = { { 71, "port Y in entity WORK.SUB without a default value has no " "corresponding port in component SUB" }, { 72, "generic P in component SUB2 has class package which is " "incompatible with class constant in entity WORK.SUB2" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_null1) { input_from_file(TESTDIR "/elab/null1.vhd"); const error_t expect[] = { { 7, "value 0 outside of T_NULL_INT range 0 to -1 for signal X" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_generic3) { set_standard(STD_08); input_from_file(TESTDIR "/elab/generic3.vhd"); const error_t expect[] = { { 10, "value length 5 does not match signal X length 2" }, { 0, "while elaborating instance U" }, { 0, "generic I => 42" }, { 0, "generic S => \"hello\"" }, { 0, "generic T => 5000000 FS" }, { 0, "generic B => ('0', '1', '0')" }, { 0, "generic TY => INTEGER" }, { 0, "generic \"=\" => \"=\" [INTEGER, INTEGER return BOOLEAN]" }, { 0, "generic \"/=\" => \"/=\" [INTEGER, INTEGER return BOOLEAN]" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_toplevel5) { set_standard(STD_08); input_from_file(TESTDIR "/elab/toplevel5.vhd"); const error_t expect[] = { { 2, "generic G of top-level entity must have default value" }, { 3, "only constant top-level generics are supported" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue969) { input_from_file(TESTDIR "/elab/issue969.vhd"); const error_t expect[] = { { 7, "maximum instantiation depth of 127 reached" }, { 0, "this is likely caused by unbounded recursion" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1012) { input_from_file(TESTDIR "/elab/issue1012.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); cover_data_t *cover = cover_data_init(COVER_MASK_TOGGLE, 0, 0); rt_model_t *m = model_new(jit, NULL); tree_t e = elab(tree_to_object(a), jit, ur, mc, cover, NULL, m); fail_if(e == NULL); model_free(m); jit_free(jit); fail_if_errors(); } END_TEST START_TEST(test_issue1017) { set_standard(STD_19); input_from_file(TESTDIR "/elab/issue1017.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_signal34) { set_standard(STD_08); input_from_file(TESTDIR "/elab/signal34.vhd"); const error_t expect[] = { { 16, "signal MEM has 34359738368 sub-elements which is greater than " "the maximum supported 2147483647" }, { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1195) { opt_set_int(OPT_PRESERVE_CASE, 1); input_from_file(TESTDIR "/elab/issue1195.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1201) { set_standard(STD_19); input_from_file(TESTDIR "/elab/issue1201.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1204) { set_standard(STD_19); input_from_file(TESTDIR "/elab/issue1204.vhd"); tree_t e = run_elab(); fail_if(e == NULL); fail_if_errors(); } END_TEST Suite *get_elab_tests(void) { Suite *s = suite_create("elab"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_elab1); tcase_add_test(tc, test_elab2); tcase_add_test(tc, test_elab3); tcase_add_test(tc, test_open); tcase_add_test(tc, test_genagg); tcase_add_test(tc, test_comp); tcase_add_test(tc, test_issue17); tcase_add_test(tc, test_issue19); tcase_add_test(tc, test_bounds10); tcase_add_test(tc, test_copy1); tcase_add_test(tc, test_record); tcase_add_test(tc, test_ifgen); tcase_add_test(tc, test_open2); tcase_add_test(tc, test_issue93); tcase_add_test(tc, test_const1); tcase_add_test(tc, test_libbind); tcase_add_test(tc, test_issue153); tcase_add_test(tc, test_issue157); tcase_add_test(tc, test_issue159); tcase_add_test(tc, test_issue175); tcase_add_test(tc, test_issue184); tcase_add_test(tc, test_libbind2); tcase_add_test(tc, test_toplevel2); tcase_add_test(tc, test_libbind3); tcase_add_test(tc, test_jcore1); tcase_add_test(tc, test_eval1); tcase_add_test(tc, test_issue305); tcase_add_test(tc, test_gbounds); tcase_add_test(tc, test_issue307); tcase_add_test(tc, test_issue315); tcase_add_test(tc, test_issue325); tcase_add_test(tc, test_issue328); tcase_add_test(tc, test_issue330); tcase_add_test(tc, test_issue336); tcase_add_test(tc, test_openinout); tcase_add_test(tc, test_opencase); tcase_add_test(tc, test_issue232); tcase_add_test(tc, test_issue373); tcase_add_test(tc, test_issue374); tcase_add_test(tc, test_issue404); tcase_add_test(tc, test_block1); tcase_add_test(tc, test_open3); tcase_add_test(tc, test_comp2); tcase_add_test(tc, test_comp3); tcase_add_test(tc, test_tc3138); tcase_add_test(tc, test_tc2881); tcase_add_test(tc, test_tc846); tcase_add_test(tc, test_issue435); tcase_add_test(tc, test_issue442); tcase_add_test(tc, test_issue448); tcase_add_test(tc, test_fold1); tcase_add_test(tc, test_fold2); tcase_add_test(tc, test_toplevel3); tcase_add_test(tc, test_ename1); tcase_add_test(tc, test_issue459); tcase_add_exit_test(tc, test_link1, 1); tcase_add_test(tc, test_generate1); tcase_add_test(tc, test_neorv1); tcase_add_test(tc, test_toplevel4); tcase_add_test(tc, test_comp4); tcase_add_test(tc, test_issue514); tcase_add_test(tc, test_issue518); tcase_add_test(tc, test_config1); tcase_add_test(tc, test_ename2); tcase_add_test(tc, test_assert7); tcase_add_test(tc, test_issue539); tcase_add_test(tc, test_bounds14); tcase_add_test(tc, test_issue228); tcase_add_test(tc, test_generic1); tcase_add_test(tc, test_generic2); tcase_add_test(tc, test_issue669); tcase_add_test(tc, test_mixed1); tcase_add_test(tc, test_genpack1); tcase_add_test(tc, test_genpack2); tcase_add_test(tc, test_genpack3); tcase_add_test(tc, test_genpack4); tcase_add_test(tc, test_view1); tcase_add_test(tc, test_issue707); tcase_add_test(tc, test_bounds40); tcase_add_test(tc, test_bounds41); tcase_add_exit_test(tc, test_body1, 1); tcase_add_test(tc, test_issue759); tcase_add_test(tc, test_bounds42); tcase_add_loop_test(tc, test_block2, STD_02, STD_19 + 1); tcase_add_test(tc, test_gentype1); tcase_add_test(tc, test_bounds7); tcase_add_test(tc, test_bounds11); tcase_add_test(tc, test_jcore2); tcase_add_test(tc, test_vlog1); tcase_add_test(tc, test_ename3); tcase_add_test(tc, test_issue855); tcase_add_test(tc, test_issue864); tcase_add_test(tc, test_issue860); tcase_add_test(tc, test_genpack5); tcase_add_test(tc, test_null1); tcase_add_test(tc, test_generic3); tcase_add_test(tc, test_toplevel5); tcase_add_test(tc, test_issue969); tcase_add_test(tc, test_issue1012); tcase_add_test(tc, test_issue1017); tcase_add_test(tc, test_signal34); tcase_add_test(tc, test_issue1195); tcase_add_test(tc, test_issue1201); tcase_add_test(tc, test_issue1204); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_ident.c000066400000000000000000000306151504111170000160310ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "lib.h" #include #include #include #include #include START_TEST(test_ident_new) { ident_t i1 = ident_new("foo"); fail_if(i1 == NULL); } END_TEST START_TEST(test_equality) { ident_t i1, i2, i3, i4; i1 = ident_new("foo"); i2 = ident_new("foo"); i3 = ident_new("foobar"); i4 = ident_new("poo"); fail_unless(i1 == i2); fail_if(i2 == i3); fail_if(i1 == i4); fail_if(i3 == i4); } END_TEST START_TEST(test_istr) { ident_t i1, i2; i1 = ident_new("frob"); fail_unless(strcasecmp(istr(i1), "frob") == 0); i2 = ident_new("FrOB"); fail_unless(strcasecmp(istr(i2), "FrOB") == 0); i1 = ident_new("pingu"); fail_unless(strcasecmp(istr(i1), "PINGU") == 0); } END_TEST START_TEST(test_rand) { for (int i = 0; i < 10000; i++) { char buf[16]; size_t len = (rand() % (sizeof(buf) - 3)) + 2; for (size_t j = 0; j < len; j++) buf[j] = '0' + (rand() % 80); buf[len - 1] = '\0'; ident_t i1 = ident_new(buf); fail_if(i1 == NULL); fail_unless(strcmp(istr(i1), buf) == 0); } } END_TEST START_TEST(test_read_write) { ident_t i1, i2, i3; i1 = ident_new("goobar"); i2 = ident_new("foo"); i3 = ident_new("foo"); fbuf_t *f = fbuf_open("test.ident", FBUF_OUT, FBUF_CS_NONE); fail_if(f == NULL); ident_wr_ctx_t wctx = ident_write_begin(f); ident_write(i1, wctx); ident_write(i2, wctx); ident_write(i3, wctx); ident_write_end(wctx); fbuf_close(f, NULL); f = fbuf_open("test.ident", FBUF_IN, FBUF_CS_NONE); fail_if(f == NULL); ident_rd_ctx_t rctx = ident_read_begin(f); ident_t j1, j2, j3; j1 = ident_read(rctx); j2 = ident_read(rctx); j3 = ident_read(rctx); ident_read_end(rctx); fail_unless(i1 == j1); fail_unless(i2 == j2); fail_unless(i3 == j3); fail_unless(j2 == j3); fbuf_close(f, NULL); remove("test.ident"); } END_TEST START_TEST(test_prefix) { ident_t a, b, c, d, e, f; a = ident_new("foo"); b = ident_new("bar"); c = ident_prefix(a, b, '.'); fail_unless(c == ident_new("foo.bar")); fail_if(c == a); fail_if(c == b); d = ident_prefix(ident_prefix(c, c, '.'), ident_new("carrot"), '/'); fail_unless(d == ident_new("foo.bar.foo.bar/carrot")); fail_if(d == c); e = ident_prefix(NULL, a, '?'); fail_unless(e == a); f = ident_prefix(a, b, '\0'); fail_unless(f == ident_new("foobar")); } END_TEST START_TEST(test_char) { ident_t i; i = ident_new("foobar"); fail_unless(ident_char(i, 0) == 'f'); fail_unless(ident_char(i, 5) == 'r'); fail_unless(ident_char(i, 3) == 'b'); } END_TEST START_TEST(test_until) { ident_t i, tmp; i = ident_new("aye.bee.c"); tmp = ident_until(i, '.'); fail_unless(tmp == ident_new("aye")); fail_unless(tmp == ident_until(i, '.')); i = ident_new("nodot"); fail_unless(ident_until(i, '.') == i); } END_TEST START_TEST(test_runtil) { ident_t i; i = ident_new("aye.bee.c"); fail_unless(ident_runtil(i, '.') == ident_new("aye.bee")); i = ident_new("nodot"); fail_unless(ident_runtil(i, '.') == i); } END_TEST START_TEST(test_rfrom) { ident_t i; i = ident_new("foo.bar.yah"); fail_unless(ident_rfrom(i, '.') == ident_new("yah")); } END_TEST START_TEST(test_from) { ident_t i; i = ident_new("foo.bar.yah"); fail_unless(ident_from(i, '.') == ident_new("bar.yah")); } END_TEST START_TEST(test_icmp) { ident_t i, j; i = ident_new("foobar"); j = ident_new("cake"); fail_unless(icmp(i, "foobar")); fail_unless(icmp(j, "cake")); fail_if(icmp(i, "cake")); fail_if(icmp(i, "fooba")); fail_if(icmp(j, "cakesniffer")); fail_unless(icmp(NULL, NULL)); fail_if(icmp(NULL, "one")); fail_if(icmp(i, NULL)); } END_TEST; START_TEST(test_glob) { ident_t i; i = ident_new("foobar"); fail_unless(ident_glob(i, "foobar", -1)); fail_unless(ident_glob(i, "foobar", 6)); fail_if(ident_glob(i, "foobaz", -1)); fail_if(ident_glob(i, "goobar", -1)); fail_unless(ident_glob(i, "*", -1)); fail_unless(ident_glob(i, "f*", -1)); fail_unless(ident_glob(i, "f*r", -1)); fail_unless(ident_glob(i, "f*b*r", -1)); fail_if(ident_glob(i, "f*c*r", -1)); fail_unless(ident_glob(i, "**bar", -1)); i = ident_new("foo:bar:a"); fail_unless(ident_glob(i, "*:a", -1)); fail_unless(ident_glob(i, "foo:*", -1)); } END_TEST; START_TEST(test_len) { fail_unless(ident_len(ident_new("a")) == 1); fail_unless(ident_len(ident_new("abc")) == 3); } END_TEST START_TEST(test_downcase) { fail_unless(ident_downcase(ident_new("ABC")) == ident_new("abc")); fail_unless(ident_downcase(ident_new("123xY")) == ident_new("123xy")); const char longtext1[] = "XXXXXXXXXXXXXsdfsdfdXXXXXXXXXXXASAAFASFAAFAFAF" "AFAFAFAFAadfsdfsdfdAAAAAAAAAA"; const char longtext2[] = "xxxxxxxxxxxxxsdfsdfdxxxxxxxxxxxasaafasfaafafaf" "afafafafaadfsdfsdfdaaaaaaaaaa"; fail_unless(ident_downcase(ident_new(longtext1)) == ident_new(longtext2)); } END_TEST START_TEST(test_compare) { ck_assert_int_eq(ident_compare(ident_new("a"), ident_new("a")), 0); ck_assert_int_eq(ident_compare(ident_new("aaa"), ident_new("aaa")), 0); ck_assert_int_lt(ident_compare(ident_new("a"), ident_new("b")), 0); ck_assert_int_lt(ident_compare(ident_new("aaa"), ident_new("aab")), 0); ck_assert_int_gt(ident_compare(ident_new("aab"), ident_new("aaa")), 0); ck_assert_int_lt(ident_compare(ident_new("aa"), ident_new("aaa")), 0); ck_assert_int_gt(ident_compare(ident_new("aaa"), ident_new("aa")), 0); ck_assert_int_gt(ident_compare(ident_new("bab"), ident_new("aba")), 0); ck_assert_int_lt(ident_compare(ident_new("abcd"), ident_new("alemnic")), 0); } END_TEST START_TEST(test_walk_selected) { ident_t it = ident_new("foo.bar.baz"); fail_unless(ident_walk_selected(&it) == ident_new("foo")); fail_unless(it == ident_new("bar.baz")); fail_unless(ident_walk_selected(&it) == ident_new("bar")); fail_unless(it == ident_new("baz")); fail_unless(ident_walk_selected(&it) == ident_new("baz")); fail_unless(it == NULL); it = ident_new("foo"); fail_unless(ident_walk_selected(&it) == ident_new("foo")); fail_unless(it == NULL); it = ident_new("foo.'.'.bar"); fail_unless(ident_walk_selected(&it) == ident_new("foo")); fail_unless(it == ident_new("'.'.bar")); fail_unless(ident_walk_selected(&it) == ident_new("'.'")); fail_unless(it == ident_new("bar")); it = ident_new("\\foo.'.'.bar\\"); fail_unless(ident_walk_selected(&it) == ident_new("\\foo.'.'.bar\\")); fail_unless(it == NULL); } END_TEST START_TEST(test_starts_with) { fail_unless(ident_starts_with(ident_new("ABCdef"), ident_new("ABC"))); fail_if(ident_starts_with(ident_new("abcdef"), ident_new("ABC"))); fail_unless(ident_starts_with(ident_new("foo(x).bar"), ident_new("foo(x)"))); fail_if(ident_starts_with(ident_new("foo(x).bar"), NULL)); } END_TEST START_TEST(test_distance) { const char *words[17] = { "previous", "clam", "loud", "sore", "striped", "healthy", "automatic", "spy", "surround", "trade", "flowers" "nifty", "chickens", "beef", "nutty", "kindly", "kitten", "sitting", }; ident_t ids[17]; for (int i = 0; i < 17; i++) ids[i] = ident_new(words[i]); const int expect[17][17] = { { 0, 8, 6, 7, 7, 7, 9, 8, 7, 7, 10, 7, 7, 8, 8, 8, 7, }, { 8, 0, 4, 4, 7, 6, 8, 4, 8, 4, 11, 7, 4, 5, 6, 6, 7, }, { 6, 4, 0, 3, 6, 6, 8, 4, 5, 4, 10, 8, 4, 5, 5, 6, 7, }, { 7, 4, 3, 0, 4, 7, 8, 3, 6, 4, 10, 7, 4, 5, 6, 5, 6, }, { 7, 7, 6, 4, 0, 7, 8, 5, 5, 4, 10, 7, 6, 7, 7, 6, 5, }, { 7, 6, 6, 7, 7, 0, 8, 6, 8, 6, 10, 7, 6, 5, 6, 6, 7, }, { 9, 8, 8, 8, 8, 8, 0, 9, 8, 7, 11, 9, 9, 6, 9, 7, 7, }, { 8, 4, 4, 3, 5, 6, 9, 0, 7, 5, 10, 8, 4, 4, 5, 6, 6, }, { 7, 8, 5, 6, 5, 8, 8, 7, 0, 7, 11, 7, 8, 7, 8, 7, 6, }, { 7, 4, 4, 4, 4, 6, 7, 5, 7, 0, 11, 7, 5, 5, 5, 5, 6, }, { 10, 11, 10, 10, 10, 10, 11, 10, 11, 11, 0, 11, 10, 9, 10, 10, 11, }, { 7, 7, 8, 7, 7, 7, 9, 8, 7, 7, 11, 0, 7, 8, 7, 5, 6, }, { 7, 4, 4, 4, 6, 6, 9, 4, 8, 5, 10, 7, 0, 5, 6, 5, 7, }, { 8, 5, 5, 5, 7, 5, 6, 4, 7, 5, 9, 8, 5, 0, 5, 4, 5, }, { 8, 6, 5, 6, 7, 6, 9, 5, 8, 5, 10, 7, 6, 5, 0, 4, 6, }, { 8, 6, 6, 5, 6, 6, 7, 6, 7, 5, 10, 5, 5, 4, 4, 0, 3, }, { 7, 7, 7, 6, 5, 7, 7, 6, 6, 6, 11, 6, 7, 5, 6, 3, 0, }, }; for (int i = 0; i < 17; i++) { for (int j = 0; j < 17; j++) { const int d = ident_distance(ids[i], ids[j]); ck_assert_int_eq(d, expect[i][j]); } } } END_TEST START_TEST(test_uniq) { ident_t i1 = ident_new("prefix"); ident_t i2 = ident_uniq("prefix"); fail_if(i1 == i2); fail_unless(i2 == ident_new("prefix1")); fail_unless(icmp(ident_uniq("prefix"), "prefix2")); } END_TEST START_TEST(test_pos) { ident_t i1 = ident_new("hello"); ck_assert_int_eq(ident_pos(i1, 'h'), 0); ck_assert_int_eq(ident_pos(i1, 'l'), 2); ck_assert_int_eq(ident_pos(i1, 'o'), 4); ck_assert_int_eq(ident_pos(i1, 'x'), -1); } END_TEST START_TEST(test_sprintf) { ident_t i1 = ident_sprintf("hello %d world", 42); ck_assert_ptr_eq(i1, ident_new("hello 42 world")); char buf[256]; // Test overflow code path for (int i = 0; i < sizeof(buf) - 2; i++) buf[i] = 'a' + i % 26; buf[sizeof(buf) - 1] = '\0'; ident_t i2 = ident_sprintf("%s", buf); ck_assert_ptr_eq(i2, ident_new(buf)); } END_TEST START_TEST(test_new_n) { ident_t i1 = ident_new_n("hello world", 5); ck_assert_ptr_eq(i1, ident_new("hello")); } END_TEST START_TEST(test_casecmp) { static const struct { const char *a, *b; bool result; } cases[] = { { "abcd", "abcd", true }, { "abcd", "abc", false }, { "abcd", "aBCd", true }, { "123456789123456789abcD", "123456789123456789abcd", true }, { "123456789123456789abcD", "123456789123456789abcdx", false }, { "123456789123456789abcD", "123456789123456789abbd", false }, }; for (int i = 0; i < ARRAY_LEN(cases); i++) { ident_t a = ident_new(cases[i].a); ident_t b = ident_new(cases[i].b); const bool cmp = ident_casecmp(a, b); ck_assert_msg(cmp == cases[i].result, "%s %c= %s failed", cases[i].a, cases[i].result ? '=' : '!', cases[i].b); ck_assert((ident_casehash(a) == ident_casehash(b)) == cases[i].result); } } END_TEST Suite *get_ident_tests(void) { Suite *s = suite_create("ident"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_ident_new); tcase_add_test(tc_core, test_equality); tcase_add_test(tc_core, test_istr); tcase_add_test(tc_core, test_rand); tcase_add_test(tc_core, test_read_write); tcase_add_test(tc_core, test_prefix); tcase_add_test(tc_core, test_char); tcase_add_test(tc_core, test_until); tcase_add_test(tc_core, test_runtil); tcase_add_test(tc_core, test_icmp); tcase_add_test(tc_core, test_glob); tcase_add_test(tc_core, test_rfrom); tcase_add_test(tc_core, test_from); tcase_add_test(tc_core, test_len); tcase_add_test(tc_core, test_downcase); tcase_add_test(tc_core, test_compare); tcase_add_test(tc_core, test_walk_selected); tcase_add_test(tc_core, test_starts_with); tcase_add_test(tc_core, test_distance); tcase_add_test(tc_core, test_uniq); tcase_add_test(tc_core, test_pos); tcase_add_test(tc_core, test_sprintf); tcase_add_test(tc_core, test_new_n); tcase_add_test(tc_core, test_casecmp); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_jit.c000066400000000000000000002004031504111170000155060ustar00rootroot00000000000000// // Copyright (C) 2021-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "diag.h" #include "ident.h" #include "jit/jit-ffi.h" #include "jit/jit-layout.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "mask.h" #include "object.h" #include "option.h" #include "phase.h" #include "scan.h" #include "type.h" #include #include #include #define REG(r) ((jit_value_t){ .kind = JIT_VALUE_REG, .reg = (r) }) #define CONST(i) ((jit_value_t){ .kind = JIT_VALUE_INT64, .int64 = (i) }) #define LABEL(l) ((jit_value_t){ .kind = JIT_VALUE_LABEL, .label = (l) }) #define ADDR(r, d) \ ((jit_value_t){ .kind = JIT_ADDR_REG, .reg = (r), .disp = (d) }) static jit_handle_t compile_for_test(jit_t *j, const char *name) { return jit_lazy_compile(j, ident_new(name)); } static inline int64_t extend_value(jit_value_t value) { switch (value.kind) { case JIT_VALUE_LABEL: return value.label; case JIT_VALUE_HANDLE: return value.handle; case JIT_VALUE_REG: return value.reg; case JIT_ADDR_REG: return (int64_t)value.reg << 32 | value.disp; default: return value.int64; } } static void check_nullary(jit_func_t *f, int nth, jit_op_t expect) { jit_ir_t *ir = &(f->irbuf[nth]); if (ir->op == expect) return; jit_dump_with_mark(f, nth); if (ir->op != expect) ck_abort_msg("expected op %s but have %s", jit_op_name(expect), jit_op_name(ir->op)); } static void check_unary(jit_func_t *f, int nth, jit_op_t expect, jit_value_t arg1) { jit_ir_t *ir = &(f->irbuf[nth]); if (ir->op == expect && ir->arg1.kind == arg1.kind && extend_value(ir->arg1) == extend_value(arg1)) return; jit_dump_with_mark(f, nth); if (ir->op != expect) ck_abort_msg("expected op %s but have %s", jit_op_name(expect), jit_op_name(ir->op)); else if (ir->arg1.kind != arg1.kind) ck_abort_msg("expected arg1 kind %d but have %d", arg1.kind, ir->arg1.kind); else ck_abort_msg("expected arg1 value %"PRIi64" but have %"PRIi64, extend_value(arg1), extend_value(ir->arg1)); } static void check_binary(jit_func_t *f, int nth, jit_op_t expect, jit_value_t arg1, jit_value_t arg2) { jit_ir_t *ir = &(f->irbuf[nth]); if (ir->op == expect && ir->arg1.kind == arg1.kind && extend_value(ir->arg1) == extend_value(arg1) && ir->arg2.kind == arg2.kind && extend_value(ir->arg2) == extend_value(arg2)) return; jit_dump_with_mark(f, nth); if (ir->op != expect) ck_abort_msg("expected op %s but have %s", jit_op_name(expect), jit_op_name(ir->op)); else if (ir->arg1.kind != arg1.kind) ck_abort_msg("expected arg1 kind %d but have %d", arg1.kind, ir->arg1.kind); else if (ir->arg1.int64 != arg1.int64) ck_abort_msg("expected arg1 value %"PRIi64" but have %"PRIi64, extend_value(arg1), extend_value(ir->arg1)); else if (ir->arg2.kind != arg2.kind) ck_abort_msg("expected arg2 kind %d but have %d", arg2.kind, ir->arg2.kind); else ck_abort_msg("expected arg2 value %"PRIi64" but have %"PRIi64, extend_value(arg2), extend_value(ir->arg2)); } START_TEST(test_add1) { input_from_file(TESTDIR "/jit/add1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t fn1 = compile_for_test(j, "WORK.PACK.ADD1(I)I"); ck_assert_int_eq(jit_call(j, fn1, NULL, 5).integer, 6); ck_assert_int_eq(jit_call(j, fn1, NULL, INT32_C(-5)).integer, -4); jit_handle_t fn2 = compile_for_test(j, "WORK.PACK.ADD1(R)R"); ck_assert_double_eq_tol(jit_call(j, fn2, NULL, 5.0).real, 6.0, 0.001); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_fact) { input_from_file(TESTDIR "/jit/fact.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t fn1 = compile_for_test(j, "WORK.PACK.FACT(I)I"); ck_assert_int_eq(jit_call(j, fn1, NULL, 5).integer, 120); ck_assert_int_eq(jit_call(j, fn1, NULL, 8).integer, 40320); jit_handle_t fn2 = compile_for_test(j, "WORK.PACK.FACT_RECUR(I)I"); ck_assert_int_eq(jit_call(j, fn2, NULL, 5).integer, 120); ck_assert_int_eq(jit_call(j, fn2, NULL, 8).integer, 40320); jit_free(j); } END_TEST START_TEST(test_sum) { input_from_file(TESTDIR "/jit/sum.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); int32_t data[] = { 1, 2, 3, 4, 5 }; jit_handle_t fn1 = compile_for_test(j, "WORK.SUMPKG.GET_LEFT(22WORK.SUMPKG.INT_VECTOR)I"); ck_assert_int_eq(jit_call(j, fn1, NULL, data, 1, 5).integer, 1); ck_assert_int_eq(jit_call(j, fn1, NULL, data, -5, 4).integer, -5); jit_handle_t fn2 = compile_for_test(j, "WORK.SUMPKG.GET_RIGHT(22WORK.SUMPKG.INT_VECTOR)I"); ck_assert_int_eq(jit_call(j, fn2, NULL, data, 1, 5).integer, 5); ck_assert_int_eq(jit_call(j, fn2, NULL, data, -5, 0).integer, -6); ck_assert_int_eq(jit_call(j, fn2, NULL, data, -5, 2).integer, -4); jit_handle_t fn3 = compile_for_test(j, "WORK.SUMPKG.GET_LENGTH(22WORK.SUMPKG.INT_VECTOR)I"); ck_assert_int_eq(jit_call(j, fn3, NULL, data, 1, 5).integer, 5); ck_assert_int_eq(jit_call(j, fn3, NULL, data, -5, 0).integer, 0); ck_assert_int_eq(jit_call(j, fn3, NULL, data, -5, 2).integer, 2); ck_assert_int_eq(jit_call(j, fn3, NULL, data, -5, -2).integer, 1); jit_handle_t fn4 = compile_for_test(j, "WORK.SUMPKG.SUM(22WORK.SUMPKG.INT_VECTOR)I"); ck_assert_int_eq(jit_call(j, fn4, NULL, data, 1, 5).integer, 15); ck_assert_int_eq(jit_call(j, fn4, NULL, data, 5, -6).integer, 15); ck_assert_int_eq(jit_call(j, fn4, NULL, data, 1, 2).integer, 3); ck_assert_int_eq(jit_call(j, fn4, NULL, data, 100, 2).integer, 3); ck_assert_int_eq(jit_call(j, fn4, NULL, data, -10, 2).integer, 3); ck_assert_int_eq(jit_call(j, fn4, NULL, data, 1, 0).integer, 0); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_context1) { input_from_file(TESTDIR "/jit/context1.vhd"); const error_t expect[] = { { 16, "index 55 outside of NATURAL range 1 to 5" }, { 16, "index -1 outside of NATURAL range 1 to 5" }, { 22, "index -1 outside of NATURAL range 1 to 5" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t handle = jit_lazy_compile(j, ident_new("WORK.PACK")); void *ctx = jit_link(j, handle); fail_if(ctx == NULL); int32_t *c1 = jit_get_frame_var(j, handle, ident_new("C1")); ck_assert_int_eq(*c1, 42); jit_handle_t fn1 = compile_for_test(j, "WORK.PACK.GET_ELT(N)I"); ck_assert_int_eq(jit_call(j, fn1, ctx, 1).integer, 10); ck_assert_int_eq(jit_call(j, fn1, ctx, 2).integer, 20); jit_scalar_t result; fail_if(jit_try_call(j, fn1, &result, NULL, 55)); fail_if(jit_try_call(j, fn1, &result, NULL, -1)); jit_handle_t fn2 = compile_for_test(j, "WORK.PACK.NESTED_GET_ELT(N)I"); ck_assert_int_eq(jit_call(j, fn2, ctx, 1).integer, 10); ck_assert_int_eq(jit_call(j, fn2, ctx, 5).integer, 50); fail_if(jit_try_call(j, fn2, &result, NULL, -1)); int x; jit_handle_t fn3 = compile_for_test(j, "WORK.PACK.READ_ELT(NI)"); fail_unless(jit_try_call(j, fn3, &result, NULL, ctx, 1, &x)); ck_assert_int_eq(x, 10); fail_unless(jit_try_call(j, fn3, &result, NULL, ctx, 5, &x)); ck_assert_int_eq(x, 50); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_record1) { input_from_file(TESTDIR "/jit/record1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t pack1_handle = jit_lazy_compile(j, ident_new("WORK.PACK1")); jit_handle_t pack2_handle = jit_lazy_compile(j, ident_new("WORK.PACK2")); eval_frame_t *pack1 = jit_link(j, pack1_handle); fail_if(pack1 == NULL); eval_frame_t *pack2 = jit_link(j, pack2_handle); fail_if(pack2 == NULL); jit_handle_t fn = compile_for_test(j, "WORK.PACK2.SUM_FIELDS()I"); ck_assert_int_eq(jit_call(j, fn, pack2).integer, 6); jit_free(j); } END_TEST START_TEST(test_record2) { input_from_file(TESTDIR "/jit/record2.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t pack3_handle = jit_lazy_compile(j, ident_new("WORK.PACK3")); jit_handle_t pack4_handle = jit_lazy_compile(j, ident_new("WORK.PACK4")); eval_frame_t *pack3 = jit_link(j, pack3_handle); fail_if(pack3 == NULL); eval_frame_t *pack4 = jit_link(j, pack4_handle); fail_if(pack4 == NULL); jit_handle_t fn = compile_for_test(j, "WORK.PACK4.SUM_FIELDS()I"); ck_assert_int_eq(jit_call(j, fn, pack4).integer, 21); jit_free(j); } END_TEST START_TEST(test_record3) { input_from_file(TESTDIR "/jit/record3.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t pack5_handle = jit_lazy_compile(j, ident_new("WORK.PACK5")); jit_handle_t pack6_handle = jit_lazy_compile(j, ident_new("WORK.PACK6")); eval_frame_t *pack5 = jit_link(j, pack5_handle); fail_if(pack5 == NULL); eval_frame_t *pack6 = jit_link(j, pack6_handle); fail_if(pack6 == NULL); jit_handle_t fn = compile_for_test(j, "WORK.PACK6.SUM_FIELDS()I"); ck_assert_int_eq(jit_call(j, fn, pack6).integer, 55); jit_free(j); } END_TEST DLLEXPORT void _nvc_ieee_warnings(jit_scalar_t *args) { args[0].integer = IEEE_WARNINGS_ON; } START_TEST(test_ieee_warnings) { input_from_file(TESTDIR "/jit/ieeewarn.vhd"); // This should not fold the call to IEEE_WARNINGS tree_t top = run_elab(); tree_t b = tree_stmt(top, 0); fail_unless(tree_decls(b) == 2); tree_t d1 = tree_decl(b, 1); fail_unless(tree_kind(d1) == T_CONST_DECL); fail_unless(tree_ident(d1) == ident_new("E")); fail_unless(tree_kind(tree_value(d1)) == T_REF); jit_t *j = get_jit(); jit_handle_t handle = jit_compile(j, ident_new("WORK.IEEEWARN")); void *pkg = jit_link(j, handle); fail_if(pkg == NULL); uint8_t *p = jit_get_frame_var(j, handle, ident_new("ENABLED")); ck_assert_int_eq(*p, 1); } END_TEST START_TEST(test_overflow) { input_from_file(TESTDIR "/jit/overflow.vhd"); const error_t expect[] = { { 18, "result of 2147483647 + 1 cannot be represented as INTEGER" }, { 18, "result of 2147483647 + 2147483647 cannot be represented as " }, { 23, "result of -2147483648 - 53 cannot be represented as INTEGER" }, { 28, "result of -1942444142 * 128910 cannot be represented as INTEGER" }, { 33, "result of 5 ** 60 cannot be represented as INTEGER" }, { 38, "result of 255 + 128 cannot be represented as UINT8" }, { 43, "result of 2 - 3 cannot be represented as UINT8" }, { 48, "result of 255 * 2 cannot be represented as UINT8" }, { 53, "result of 15 ** 26 cannot be represented as UINT8" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t add = compile_for_test(j, "WORK.OVERFLOW.ADD(II)I"); jit_handle_t sub = compile_for_test(j, "WORK.OVERFLOW.SUB(II)I"); jit_handle_t mul = compile_for_test(j, "WORK.OVERFLOW.MUL(II)I"); jit_handle_t exp = compile_for_test(j, "WORK.OVERFLOW.EXP(II)I"); jit_scalar_t result; fail_if(jit_try_call(j, add, &result, NULL, INT32_MAX, 1)); fail_if(jit_try_call(j, add, &result, NULL, INT32_MAX, INT32_MAX)); fail_if(jit_try_call(j, sub, &result, NULL, INT32_MIN, 53)); fail_if(jit_try_call(j, mul, &result, NULL, 2352523154, 128910)); fail_if(jit_try_call(j, exp, &result, NULL, 5, 60)); #define UINT8 "19WORK.OVERFLOW.UINT8" jit_handle_t addu = compile_for_test(j, "WORK.OVERFLOW.ADD(" UINT8 UINT8 ")" UINT8); jit_handle_t subu = compile_for_test(j, "WORK.OVERFLOW.SUB(" UINT8 UINT8 ")" UINT8); jit_handle_t mulu = compile_for_test(j, "WORK.OVERFLOW.MUL(" UINT8 UINT8 ")" UINT8); jit_handle_t expu = compile_for_test(j, "WORK.OVERFLOW.EXP(" UINT8 "I)" UINT8); #undef UINT8 ck_assert_int_eq(jit_call(j, addu, NULL, 5, 6).integer, 11); ck_assert_int_eq(jit_call(j, addu, NULL, 127, 1).integer, 128); fail_if(jit_try_call(j, addu, &result, NULL, 255, 128)); ck_assert_int_eq(jit_call(j, subu, NULL, 255, 4).integer, 251); ck_assert_int_eq(jit_call(j, subu, NULL, 1, 1).integer, 0); fail_if(jit_try_call(j, subu, &result, NULL, 2, 3)); ck_assert_int_eq(jit_call(j, mulu, NULL, 127, 2).integer, 254); fail_if(jit_try_call(j, mulu, &result, NULL, 255, 2)); ck_assert_int_eq(jit_call(j, expu, NULL, 3, 3).integer, 27); fail_if(jit_try_call(j, expu, &result, NULL, 15, 26)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_record4) { input_from_file(TESTDIR "/jit/record4.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t func1 = compile_for_test(j, "WORK.PACK5.FUNC1(I)I"); jit_handle_t func2 = compile_for_test(j, "WORK.PACK5.FUNC2(I)I"); jit_handle_t func3 = compile_for_test(j, "WORK.PACK5.FUNC3(I)I"); jit_handle_t func4 = compile_for_test(j, "WORK.PACK5.FUNC4(I)I"); ck_assert_int_eq(jit_call(j, func1, NULL, 5).integer, 40); ck_assert_int_eq(jit_call(j, func1, NULL, 2).integer, 7); ck_assert_int_eq(jit_call(j, func1, NULL, 0).integer, 0); ck_assert_int_eq(jit_call(j, func2, NULL, 5).integer, 40); ck_assert_int_eq(jit_call(j, func2, NULL, 2).integer, 7); ck_assert_int_eq(jit_call(j, func2, NULL, 0).integer, 0); ck_assert_int_eq(jit_call(j, func3, NULL, 2).integer, 6); ck_assert_int_eq(jit_call(j, func4, NULL, 3).integer, 27); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_access1) { input_from_file(TESTDIR "/jit/access1.vhd"); const error_t expect[] = { { 16, "null access dereference" }, { 44, "out of memory attempting to allocate 1032 byte " }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); int32_t *p LOCAL = xmalloc_array(2, sizeof(int32_t)); p[0] = 42; p[1] = 0xdeadbeef; jit_handle_t deref = compile_for_test(j, "WORK.ACCESS1.DEREF(20WORK.ACCESS1.INT_PTRI)"); jit_call(j, deref, NULL, NULL, p, p + 1); ck_assert_int_eq(p[1], 42); jit_scalar_t result; fail_if(jit_try_call(j, deref, &result, NULL, NULL, NULL, p + 1)); ck_assert_int_eq(p[1], 42); jit_handle_t test1 = compile_for_test(j, "WORK.ACCESS1.TEST1(20WORK.ACCESS1.INT_PTR)"); jit_call(j, test1, NULL, NULL, p); ck_assert_int_eq(p[1], 0); jit_handle_t oom = compile_for_test(j, "WORK.ACCESS1.OOM"); fail_if(jit_try_call(j, oom, &result, NULL, NULL)); jit_handle_t gc_a_lot = compile_for_test(j, "WORK.ACCESS1.GC_A_LOT"); fail_unless(jit_try_call(j, gc_a_lot, &result, NULL, NULL)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_array1) { input_from_file(TESTDIR "/jit/array1.vhd"); const error_t expect[] = { { 14, "value length 2 does not match variable A length 3" }, { 40, "" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); int32_t a0[3] = {}; int32_t a1[3] = { 1, 2, 3 }; jit_handle_t assign = compile_for_test(j, "WORK.ARRAY1.ASSIGN(14WORK.ARRAY1.IV14WORK.ARRAY1.IV)"); jit_call(j, assign, NULL, NULL, a0, 1, 3, a1, 1, 3); ck_assert_mem_eq(a0, a1, sizeof(a0)); a1[0] = 44; jit_call(j, assign, NULL, NULL, a0, 1, 3, a1, -4, 3); ck_assert_mem_eq(a0, a1, sizeof(a0)); a1[0] = 99; jit_scalar_t result; fail_if(jit_try_call(j, assign, &result, NULL, NULL, a0, 1, 3, a1, 1, 2)); ck_assert_mem_ne(a0, a1, sizeof(a0)); jit_handle_t get_ints = compile_for_test(j, "WORK.ARRAY1.GET_INTS(II)14WORK.ARRAY1.IV"); fail_unless(jit_try_call(j, get_ints, &result, NULL, 5, -1)); ck_assert_ptr_nonnull(result.pointer); int32_t *vals = result.pointer; ck_assert_ptr_nonnull(vals); ck_assert_int_eq(vals[0], -1); ck_assert_int_eq(vals[1], 0); ck_assert_int_eq(vals[2], 1); ck_assert_int_eq(vals[3], 2); ck_assert_int_eq(vals[4], 3); jit_handle_t issue94 = compile_for_test(j, "WORK.ARRAY1.ISSUE94(II)Q"); fail_unless(jit_try_call(j, issue94, &result, NULL, 4, 4)); ck_assert_ptr_nonnull(result.pointer); unsigned char *bits = result.pointer; ck_assert_ptr_nonnull(bits); ck_assert_int_eq(bits[0], 1); ck_assert_int_eq(bits[1], 1); ck_assert_int_eq(bits[2], 1); ck_assert_int_eq(bits[3], 1); jit_handle_t test2 = compile_for_test(j, "WORK.ARRAY1.TEST2(S)"); fail_unless(jit_try_call(j, test2, &result, NULL, NULL, NULL, 1, 0)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_relop1) { input_from_file(TESTDIR "/jit/relop1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); #define UINT8 "17WORK.RELOP1.UINT8" jit_handle_t cmpless = compile_for_test(j, "WORK.RELOP1.CMPLESS(" UINT8 UINT8 ")B"); #undef UINT8 ck_assert_int_eq(jit_call(j, cmpless, NULL, 5, 6).integer, 1); ck_assert_int_eq(jit_call(j, cmpless, NULL, 127, 128).integer, 1); ck_assert_int_eq(jit_call(j, cmpless, NULL, 200, 255).integer, 1); jit_handle_t fcmpless = compile_for_test(j, "WORK.RELOP1.CMPLESS(RR)B"); ck_assert_int_eq(jit_call(j, fcmpless, NULL, 5.0, 6.0).integer, 1); ck_assert_int_eq(jit_call(j, fcmpless, NULL, -5.0, -6.0).integer, 0); ck_assert_int_eq(jit_call(j, fcmpless, NULL, 0.001, 0.2).integer, 1); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_proc1) { input_from_file(TESTDIR "/jit/proc1.vhd"); const error_t expect[] = { { 48, "cannot wait inside function call" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t add2 = compile_for_test(j, "WORK.PROC1_PACK2.ADD2(I)I"); ck_assert_int_eq(jit_call(j, add2, NULL, 5).integer, 7); jit_scalar_t result; fail_if(jit_try_call(j, add2, &result, NULL, 10)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_unreachable) { input_from_file(TESTDIR "/jit/unreachable.vhd"); const error_t expect[] = { { 6, "function FUNC did not return a value" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t func = compile_for_test(j, "WORK.UNREACHABLE.FUNC(I)I"); ck_assert_int_eq(jit_call(j, func, NULL, 5).integer, 10); jit_scalar_t result; fail_if(jit_try_call(j, func, &result, NULL, -1)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_arith1) { input_from_file(TESTDIR "/jit/arith1.vhd"); const error_t expect[] = { { 25, "division by zero" }, { 35, "value inf outside of REAL range" }, { 45, "negative exponent -1 only allowed for floating-point types" }, { 50, "result of -(-2147483648) cannot be represented as INTEGER" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_scalar_t result; jit_handle_t divii = compile_for_test(j, "WORK.ARITH1.DIV(II)I"); ck_assert_int_eq(jit_call(j, divii, NULL, 4, 2).integer, 2); ck_assert_int_eq(jit_call(j, divii, NULL, 5, 2).integer, 2); ck_assert_int_eq(jit_call(j, divii, NULL, -5, -2).integer, 2); ck_assert_int_eq(jit_call(j, divii, NULL, -5, -1).integer, 5); fail_if(jit_try_call(j, divii, &result, NULL, 1, 0)); jit_handle_t divrr = compile_for_test(j, "WORK.ARITH1.DIV(RR)R"); ck_assert_double_eq(jit_call(j, divrr, NULL, 4.0, 2.0).real, 2.0); ck_assert_double_eq(jit_call(j, divrr, NULL, 4.0, 0.5).real, 8.0); jit_handle_t divir = compile_for_test(j, "WORK.ARITH1.DIV(IR)R"); ck_assert_double_eq(jit_call(j, divir, NULL, 4, 2.0).real, 2.0); fail_if(jit_try_call(j, divir, &result, NULL, 4, 0.0)); jit_handle_t expr = compile_for_test(j, "WORK.ARITH1.EXP(RI)R"); ck_assert_double_eq(jit_call(j, expr, NULL, 2.0, 4).real, 16.0); ck_assert_double_eq(jit_call(j, expr, NULL, 2.0, -1).real, 0.5); jit_handle_t expi = compile_for_test(j, "WORK.ARITH1.EXP(II)I"); ck_assert_int_eq(jit_call(j, expi, NULL, 2, 4).integer, 16); fail_if(jit_try_call(j, expi, &result, NULL, 2, -1)); jit_handle_t negi = compile_for_test(j, "WORK.ARITH1.NEG(I)I"); ck_assert_int_eq(jit_call(j, negi, NULL, 2).integer, -2); ck_assert_int_eq(jit_call(j, negi, NULL, -124).integer, 124); fail_if(jit_try_call(j, negi, &result, NULL, INT32_MIN)); jit_handle_t negr = compile_for_test(j, "WORK.ARITH1.NEG(R)R"); ck_assert_double_eq(jit_call(j, negr, NULL, 2.0).real, -2.0); ck_assert_double_eq(jit_call(j, negr, NULL, -256.0).real, 256.0); jit_handle_t castri = compile_for_test(j, "WORK.ARITH1.CAST(R)I"); ck_assert_int_eq(jit_call(j, castri, NULL, 2.0).integer, 2); ck_assert_int_eq(jit_call(j, castri, NULL, 1.5).integer, 2); ck_assert_int_eq(jit_call(j, castri, NULL, 1.4999).integer, 1); ck_assert_int_eq(jit_call(j, castri, NULL, -1.4999).integer, -1); jit_handle_t absi = compile_for_test(j, "WORK.ARITH1.ABZ(I)I"); ck_assert_int_eq(jit_call(j, absi, NULL, 2).integer, 2); ck_assert_int_eq(jit_call(j, absi, NULL, 0).integer, 0); ck_assert_int_eq(jit_call(j, absi, NULL, -5).integer, 5); // Bug! needs a trap abs //ck_assert_int_eq(jit_call(j, absi, NULL, "i", INT32_MIN).integer, INT32_MAX); jit_handle_t absr = compile_for_test(j, "WORK.ARITH1.ABZ(R)R"); ck_assert_double_eq(jit_call(j, absr, NULL, 2.0).real, 2.0); ck_assert_double_eq(jit_call(j, absr, NULL, -0.0).real, 0.0); ck_assert_double_eq(jit_call(j, absr, NULL, -4.0).real, 4.0); jit_handle_t modi = compile_for_test(j, "WORK.ARITH1.MODD(II)I"); ck_assert_int_eq(jit_call(j, modi, NULL, 4, 2).integer, 0); ck_assert_int_eq(jit_call(j, modi, NULL, 5, 3).integer, 2); ck_assert_int_eq(jit_call(j, modi, NULL, -5, 3).integer, 1); ck_assert_int_eq(jit_call(j, modi, NULL, -512, -8).integer, 0); ck_assert_int_eq(jit_call(j, modi, NULL, -510, -8).integer, -6); jit_handle_t remi = compile_for_test(j, "WORK.ARITH1.REMM(II)I"); ck_assert_int_eq(jit_call(j, remi, NULL, 4, 2).integer, 0); ck_assert_int_eq(jit_call(j, remi, NULL, 5, 3).integer, 2); ck_assert_int_eq(jit_call(j, remi, NULL, -5, 3).integer, -2); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_assert1) { input_from_file(TESTDIR "/jit/assert1.vhd"); const error_t expect[] = { { 10, "hello world" }, { 15, "-10 negative" }, { 16, "too big" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_scalar_t result; jit_handle_t fn1 = compile_for_test(j, "WORK.ASSERT1.DO_REPORT"); fail_unless(jit_try_call(j, fn1, &result, NULL, NULL)); jit_handle_t fn2 = compile_for_test(j, "WORK.ASSERT1.DO_ASSERT(I)"); fail_unless(jit_try_call(j, fn2, &result, NULL, NULL, 10)); fail_unless(jit_try_call(j, fn2, &result, NULL, NULL, -10)); fail_if(jit_try_call(j, fn2, &result, NULL, NULL, 555)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_case1) { input_from_file(TESTDIR "/jit/case1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t test1 = compile_for_test(j, "WORK.CASE1.TEST1(12WORK.CASE1.T)I"); ck_assert_int_eq(jit_call(j, test1, NULL, 0).integer, 10); ck_assert_int_eq(jit_call(j, test1, NULL, 1).integer, 20); ck_assert_int_eq(jit_call(j, test1, NULL, 2).integer, 30); const uint8_t one[] = { 0, 0, 0, 1 }; const uint8_t eff[] = { 1, 1, 1, 1 }; const uint8_t ten[] = { 1, 0, 1, 0 }; jit_handle_t test2 = compile_for_test(j, "WORK.CASE1.TEST2(Q)I"); ck_assert_int_eq(jit_call(j, test2, NULL, one).integer, 1); ck_assert_int_eq(jit_call(j, test2, NULL, eff).integer, 15); ck_assert_int_eq(jit_call(j, test2, NULL, ten).integer, 10); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_real1) { input_from_file(TESTDIR "/jit/real1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t approx = compile_for_test(j, "WORK.REAL1.APPROX(RRR)B"); ck_assert_int_eq(jit_call(j, approx, NULL, 1.0, 1.0001, 0.001).integer, 1); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_prot1) { set_standard(STD_02); input_from_file(TESTDIR "/jit/prot1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t handle = compile_for_test(j, "WORK.PROT1"); void *pkg = jit_link(j, handle); fail_if(pkg == NULL); jit_handle_t fn = compile_for_test(j, "WORK.PROT1.FETCH_AND_ADD(I)I"); ck_assert_int_eq(jit_call(j, fn, pkg, 0).integer, 0); ck_assert_int_eq(jit_call(j, fn, pkg, 1).integer, 1); ck_assert_int_eq(jit_call(j, fn, pkg, 1).integer, 2); ck_assert_int_eq(jit_call(j, fn, pkg, 6).integer, 8); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_layout) { jit_t *j = jit_new(NULL, NULL); const jit_layout_t *l = NULL; l = layout_of(std_type(NULL, STD_INTEGER)); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 4); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 4); l = signal_layout_of(std_type(NULL, STD_INTEGER)); ck_assert_int_eq(l->nparts, 2); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, sizeof(void *)); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); ck_assert_int_eq(l->parts[1].offset, 8); ck_assert_int_eq(l->parts[1].size, 8); ck_assert_int_eq(l->parts[1].repeat, 1); ck_assert_int_eq(l->parts[1].align, 8); l = layout_of(std_type(NULL, STD_REAL)); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 8); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); l = layout_of(std_type(NULL, STD_TIME)); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 8); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); l = layout_of(std_type(NULL, STD_BOOLEAN)); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 1); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 1); l = layout_of(std_type(NULL, STD_STRING)); ck_assert_int_eq(l->nparts, 2); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, sizeof(void *)); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); ck_assert_int_eq(l->parts[1].offset, sizeof(void *)); ck_assert_int_eq(l->parts[1].size, sizeof(int64_t)); ck_assert_int_eq(l->parts[1].repeat, 2); l = signal_layout_of(std_type(NULL, STD_STRING)); ck_assert_int_eq(l->nparts, 3); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, sizeof(void *)); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); ck_assert_int_eq(l->parts[1].offset, 8); ck_assert_int_eq(l->parts[1].size, 8); ck_assert_int_eq(l->parts[1].repeat, 1); ck_assert_int_eq(l->parts[1].align, 8); ck_assert_int_eq(l->parts[2].offset, 16); ck_assert_int_eq(l->parts[2].size, sizeof(int64_t)); ck_assert_int_eq(l->parts[2].repeat, 2); input_from_file(TESTDIR "/jit/layout.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); freeze_global_arena(); fail_unless(parse() == NULL); type_t r1 = tree_type(get_decl(p, "R1")); l = layout_of(r1); ck_assert_int_eq(l->nparts, 3); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 4); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[1].offset, 4); ck_assert_int_eq(l->parts[1].size, 1); ck_assert_int_eq(l->parts[1].repeat, 1); ck_assert_int_eq(l->parts[2].offset, 8); ck_assert_int_eq(l->parts[2].size, 8); ck_assert_int_eq(l->parts[2].repeat, 1); type_t r2 = tree_type(get_decl(p, "R2")); l = layout_of(r2); ck_assert_int_eq(l->nparts, 2); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 16); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[0].align, 8); ck_assert_int_eq(l->parts[1].offset, 16); ck_assert_int_eq(l->parts[1].size, 4); ck_assert_int_eq(l->parts[1].repeat, 1); type_t a = tree_type(get_decl(p, "A")); l = layout_of(a); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 1); ck_assert_int_eq(l->parts[0].repeat, 5); ck_assert_int_eq(l->parts[0].align, 1); type_t bv = tree_type(get_decl(p, "T_BYTE_VECTOR")); l = layout_of(bv); ck_assert_int_eq(l->nparts, 2); ck_assert_int_eq(l->size, sizeof(void *) + 2*sizeof(int64_t)); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, sizeof(void *)); ck_assert_int_eq(l->parts[0].align, sizeof(void *)); ck_assert_int_eq(l->parts[1].offset, sizeof(void *)); ck_assert_int_eq(l->parts[1].size, sizeof(int64_t)); ck_assert_int_eq(l->parts[1].repeat, 2); type_t c1 = tree_type(get_decl(p, "C1")); l = layout_of(c1); ck_assert_int_eq(l->nparts, 1); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 1); ck_assert_int_eq(l->parts[0].align, 1); ck_assert_int_eq(l->parts[0].repeat, 3 * 8); type_t t_array = tree_type(get_decl(p, "T_ARRAY")); l = signal_layout_of(t_array); ck_assert_int_eq(l->nparts, 2); ck_assert_int_eq(l->parts[0].offset, 0); ck_assert_int_eq(l->parts[0].size, 8); ck_assert_int_eq(l->parts[0].align, sizeof(void *)); ck_assert_int_eq(l->parts[0].repeat, 1); ck_assert_int_eq(l->parts[1].offset, 8); ck_assert_int_eq(l->parts[1].size, 8); ck_assert_int_eq(l->parts[1].align, 8); ck_assert_int_eq(l->parts[1].repeat, 2); l = signal_layout_of(r1); ck_assert_int_eq(l->nparts, 3); for (int i = 0; i < 3; i++) { ck_assert_int_eq(l->parts[i].offset, 16 * i); ck_assert_int_eq(l->parts[i].size, 16); ck_assert_int_eq(l->parts[i].align, sizeof(void *)); ck_assert_int_eq(l->parts[i].repeat, 1); } jit_free(j); } END_TEST START_TEST(test_range1) { input_from_file(TESTDIR "/jit/range1.vhd"); const error_t expect[] = { { 13, "0 outside of POSITIVE range 1 to 2147483647 for variable P" }, { 13, "value -5 outside of POSITIVE range 1 to 2147483647 for" }, { 20, "value 0 outside of PREAL range 1 to 1.7976931348623157e+308 " "for variable P" }, { 20, "value -5 outside of PREAL range" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_scalar_t result; jit_handle_t fn1 = compile_for_test(j, "WORK.RANGE1.AS_POSITIVE(I)P"); ck_assert_int_eq(jit_call(j, fn1, NULL, 1).integer, 1); ck_assert_int_eq(jit_call(j, fn1, NULL, 2).integer, 2); fail_if(jit_try_call(j, fn1, &result, NULL, 0)); fail_if(jit_try_call(j, fn1, &result, NULL, -5)); jit_handle_t fn2 = compile_for_test(j, "WORK.RANGE1.AS_POSITIVE(R)17WORK.RANGE1.PREAL"); ck_assert_double_eq(jit_call(j, fn2, NULL, 1.0).real, 1.0); ck_assert_double_eq(jit_call(j, fn2, NULL, 1.001).real, 1.001); fail_if(jit_try_call(j, fn2, &result, NULL, 0.0)); fail_if(jit_try_call(j, fn2, &result, NULL, -5.0)); jit_free(j); check_expected_errors(); } END_TEST static void trace1_diag_fn(diag_t *d, void *context) { ck_assert_str_eq(diag_get_text(d), "division by zero"); ck_assert_int_eq(diag_traces(d), 3); ck_assert_str_eq(diag_get_trace(d, 0), "Procedure TEST3 []"); ck_assert_str_eq(diag_get_trace(d, 1), "Procedure TEST2 []"); ck_assert_str_eq(diag_get_trace(d, 2), "Procedure TEST1 []"); } START_TEST(test_trace1) { input_from_file(TESTDIR "/jit/trace1.vhd"); diag_set_consumer(trace1_diag_fn, NULL); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_scalar_t result; jit_handle_t test1 = compile_for_test(j, "WORK.TRACE1.TEST1"); fail_if(jit_try_call(j, test1, &result, NULL, "")); jit_free(j); fail_unless(error_count() == 1); } END_TEST START_TEST(test_issue496) { set_standard(STD_08); input_from_file(TESTDIR "/jit/issue496.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACKAGE); jit_t *j = jit_new(get_registry(), get_mir()); jit_handle_t handle = compile_for_test(j, "WORK.ISSUE496"); void *pkg = jit_link(j, handle); fail_if(pkg == NULL); char *c = jit_get_frame_var(j, handle, ident_new("C")); ck_assert_mem_eq(c, "one", 3); jit_free(j); fail_if_errors(); } END_TEST START_TEST(test_value1) { input_from_file(TESTDIR "/jit/value1.vhd"); const error_t expect[] = { { 257, "found invalid characters \"x\" after value \"42x\"" }, { 405, "found invalid characters \".4\" after value \"4..4\"" }, { 80, "\" FOO\" is not a valid unit name" }, { 23, "\"FOO\" is not a valid enumeration value" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); jit_scalar_t result; jit_handle_t fn1 = compile_for_test(j, "WORK.VALUE1.STR_TO_INT(S)I"); ck_assert_int_eq(jit_call(j, fn1, NULL, "123", 1, 3).integer, 123); ck_assert_int_eq(jit_call(j, fn1, NULL, "-5", 1, 2).integer, -5); ck_assert_int_eq(jit_call(j, fn1, NULL, " 42 ", 1, 4).integer, 42); fail_if(jit_try_call(j, fn1, &result, NULL, "42x", 1, 3)); jit_handle_t fn2 = compile_for_test(j, "WORK.VALUE1.STR_TO_REAL(S)R"); ck_assert_double_eq(jit_call(j, fn2, NULL, "123", 1, 3).real, 123.0); ck_assert_double_eq(jit_call(j, fn2, NULL, "-4.5", 1, 4).real, -4.5); fail_if(jit_try_call(j, fn2, &result, NULL, "4..4", 1, 4)); jit_handle_t fn3 = compile_for_test(j, "WORK.VALUE1.STR_TO_TIME(S)T"); ck_assert_int_eq(jit_call(j, fn3, NULL, "123 FS", 1, 6).integer, 123); ck_assert_int_eq(jit_call(j, fn3, NULL, " 52 PS ", 1, 8).integer, 52000); fail_if(jit_try_call(j, fn3, &result, NULL, "4 FOO", 1, 5)); jit_handle_t fn4 = compile_for_test(j, "WORK.VALUE1.STR_TO_BOOL(S)B"); ck_assert_int_eq(jit_call(j, fn4, NULL, "true", 1, 4).integer, 1); ck_assert_int_eq(jit_call(j, fn4, NULL, " FALSE ", 1, 7).integer, 0); fail_if(jit_try_call(j, fn4, &result, NULL, "FOO", 1, 3)); jit_free(j); check_expected_errors(); } END_TEST START_TEST(test_assemble1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = "RECV R0, #0 \n" "MOV R1, #2 \n" "ADD R1, R0, R1 \n" "SEND #0, R1 \n" "RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); tlab_t tlab = jit_null_tlab(j); jit_scalar_t result, p0 = { .integer = 5 }; fail_unless(jit_fastcall(j, h1, &result, p0, p0, &tlab)); ck_assert_int_eq(result.integer, 7); jit_free(j); } END_TEST START_TEST(test_assemble2) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" "L1: CMP.EQ R0, #0 \n" " JUMP.T L2 \n" " SUB R0, R0, #1 \n" " JUMP L1 \n" "L2: SEND #0, R0 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); tlab_t tlab = jit_null_tlab(j); jit_scalar_t result, p0 = { .integer = 5 }; fail_unless(jit_fastcall(j, h1, &result, p0, p0, &tlab)); ck_assert_int_eq(result.integer, 0); jit_free(j); } END_TEST START_TEST(test_cfg1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" " MOV R1, #1 \n" "L1: CMP.EQ R0, #0 \n" " JUMP.T L2 \n" " MUL R1, R1, R0 \n" " SUB R0, R0, #1 \n" " JUMP L1 \n" "L2: SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); tlab_t tlab = jit_null_tlab(j); jit_scalar_t result, p0 = { .integer = 5 }; fail_unless(jit_fastcall(j, h1, &result, p0, p0, &tlab)); ck_assert_int_eq(result.integer, 120); jit_func_t *f = jit_get_func(j, h1); jit_cfg_t *cfg = jit_get_cfg(f); ck_assert_int_eq(cfg->nblocks, 4); ck_assert_int_eq(cfg->blocks[0].returns, 0); ck_assert_int_eq(cfg->blocks[0].aborts, 0); ck_assert_int_eq(cfg->blocks[0].in.count, 0); ck_assert_int_eq(cfg->blocks[0].out.count, 1); ck_assert_int_eq(jit_get_edge(&cfg->blocks[0].out, 0), 1); ck_assert_int_eq(cfg->blocks[0].livein.size, 3); ck_assert_int_eq(cfg->blocks[0].livein.bits, 0); ck_assert_int_eq(cfg->blocks[0].liveout.size, 3); ck_assert_int_eq(cfg->blocks[0].liveout.bits, 0x3); ck_assert_int_eq(cfg->blocks[0].varkill.size, 3); ck_assert_int_eq(cfg->blocks[0].varkill.bits, 0x3); ck_assert_int_eq(cfg->blocks[1].in.count, 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].in, 0), 0); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].in, 1), 2); ck_assert_int_eq(cfg->blocks[1].out.count, 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].out, 0), 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].out, 1), 3); ck_assert_int_eq(cfg->blocks[1].livein.bits, 0x3); ck_assert_int_eq(cfg->blocks[1].liveout.bits, 0x3); ck_assert_int_eq(cfg->blocks[1].varkill.bits, 0b100); ck_assert_int_eq(cfg->blocks[2].in.count, 1); ck_assert_int_eq(jit_get_edge(&cfg->blocks[2].in, 0), 1); ck_assert_int_eq(cfg->blocks[2].out.count, 1); ck_assert_int_eq(jit_get_edge(&cfg->blocks[2].out, 0), 1); ck_assert_int_eq(cfg->blocks[2].livein.bits, 0x3); ck_assert_int_eq(cfg->blocks[2].liveout.bits, 0x3); ck_assert_int_eq(cfg->blocks[2].varkill.bits, 0x3); ck_assert_int_eq(cfg->blocks[3].returns, 1); ck_assert_int_eq(cfg->blocks[3].in.count, 1); ck_assert_int_eq(jit_get_edge(&cfg->blocks[3].in, 0), 1); ck_assert_int_eq(cfg->blocks[3].out.count, 0); ck_assert_int_eq(cfg->blocks[3].livein.bits, 0x2); ck_assert_int_eq(cfg->blocks[3].liveout.bits, 0); ck_assert_int_eq(cfg->blocks[3].varkill.bits, 0); jit_free(j); } END_TEST START_TEST(test_lvn1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MUL R0, #2, #3 \n" " MUL.8 R0, #100, #5 \n" " ADD R0, #5, #-7 \n" " SUB R0, #12, #30 \n" " ADD R1, R2, R3 \n" " ADD R4, R2, R3 \n" " MUL R1, R2, #3 \n" " MUL R4, #3, R2 \n" " MOV R1, #666 \n" " MUL R5, #3, R2 \n" " MUL R1, #1, R2 \n" " MUL R1, #0, R2 \n" " ADD R1, R1, #0 \n" " SUB R1, R1, #0 \n" " SUB R2, #0, R2 \n" " SUB.O R2, #0, R2 \n" " $EXP R3, #3, #4 \n" " $EXP R3, #2, R2 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[0].op, J_MOV); ck_assert_int_eq(f->irbuf[0].arg1.int64, 6); ck_assert_int_eq(f->irbuf[1].op, J_MUL); ck_assert_int_eq(f->irbuf[1].size, JIT_SZ_8); ck_assert_int_eq(f->irbuf[2].op, J_MOV); ck_assert_int_eq(f->irbuf[2].arg1.int64, -2); ck_assert_int_eq(f->irbuf[3].op, J_MOV); ck_assert_int_eq(f->irbuf[3].arg1.int64, -18); ck_assert_int_eq(f->irbuf[5].op, J_MOV); ck_assert_int_eq(f->irbuf[5].arg1.reg, f->irbuf[4].result); check_unary(f, 7, J_MOV, REG(f->irbuf[6].result)); check_binary(f, 9, J_MUL, REG(2), CONST(3)); ck_assert_int_eq(f->irbuf[10].op, J_MOV); ck_assert_int_eq(f->irbuf[10].arg1.reg, 2); ck_assert_int_eq(f->irbuf[11].op, J_MOV); ck_assert_int_eq(f->irbuf[11].arg1.int64, 0); ck_assert_int_eq(f->irbuf[12].op, J_NOP); ck_assert_int_eq(f->irbuf[13].op, J_NOP); ck_assert_int_eq(f->irbuf[14].op, J_NEG); ck_assert_int_eq(f->irbuf[14].arg1.kind, JIT_VALUE_REG); ck_assert_int_eq(f->irbuf[14].arg1.reg, 2); ck_assert_int_eq(f->irbuf[15].op, J_SUB); ck_assert_int_eq(f->irbuf[16].op, J_MOV); ck_assert_int_eq(f->irbuf[16].arg1.int64, 81); ck_assert_int_eq(f->irbuf[17].op, J_SHL); ck_assert_int_eq(f->irbuf[17].arg1.int64, 1); jit_free(j); } END_TEST START_TEST(test_lvn2) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R0, #2 \n" " ADD R1, R0, #1 \n" "L1: ADD R1, R0, #1 \n" " ADD R0, R0, #1 \n" " JUMP L1 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[2].op, J_ADD); ck_assert_int_eq(f->irbuf[2].arg1.reg, 0); ck_assert_int_eq(f->irbuf[2].arg2.int64, 1); ck_assert_int_eq(f->irbuf[3].op, J_MOV); ck_assert_int_eq(f->irbuf[3].arg1.reg, 1); jit_free(j); } END_TEST START_TEST(test_lvn3) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R0, #2 \n" " $COPY R0, [R1], [R2] \n" " MOV R0, #2 \n" " $COPY R0, [R3], [R4] \n" " SUB R46, #1, R41 \n" " ADD R58, R41, #1 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[2].op, J_MOV); ck_assert_int_eq(f->irbuf[2].arg1.kind, JIT_VALUE_INT64); ck_assert_int_eq(f->irbuf[2].arg1.int64, 2); ck_assert_int_eq(f->irbuf[5].op, J_ADD); ck_assert_int_eq(f->irbuf[5].arg2.kind, JIT_VALUE_INT64); ck_assert_int_eq(f->irbuf[5].arg2.int64, 1); jit_free(j); } END_TEST START_TEST(test_issue575) { input_from_file(TESTDIR "/jit/issue575.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); struct { int32_t x; uint8_t y[3]; } rec = { 42, { 0, 0, 0 } }; jit_handle_t fn = compile_for_test(j, "WORK.ISSUE575.TEST(17WORK.ISSUE575.RECJ)"); jit_call(j, fn, NULL, NULL, &rec, 1); ck_assert_int_eq(rec.x, 42); for (int i = 0; i < 3; i++) ck_assert_int_eq(rec.y[i], 1); jit_free(j); } END_TEST START_TEST(test_cfg2) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" " $CASE R0, #1, L1 \n" " $CASE R0, #2, L2 \n" " $CASE R0, #3, L3 \n" " JUMP L4 \n" "L1: RET \n" "L2: RET \n" "L3: RET \n" "L4: RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); tlab_t tlab = jit_null_tlab(j); jit_scalar_t result, p0 = { .integer = 5 }; fail_unless(jit_fastcall(j, h1, &result, p0, p0, &tlab)); ck_assert_int_eq(result.integer, 5); jit_func_t *f1 = jit_get_func(j, h1); jit_cfg_t *cfg1 = jit_get_cfg(f1); ck_assert_int_eq(cfg1->nblocks, 6); ck_assert_int_eq(cfg1->blocks[1].first, 4); const char *text2 = " RECV R0, #0 \n" " $CASE R0, #2, L1 \n" " $CASE R0, #3, L2 \n" " SEND #0, #55 \n" " RET \n" "L1: RET \n" "L2: RET \n"; jit_handle_t h2 = jit_assemble(j, ident_new("myfunc2"), text2); fail_unless(jit_fastcall(j, h2, &result, p0, p0, &tlab)); ck_assert_int_eq(result.integer, 55); jit_func_t *f2 = jit_get_func(j, h2); jit_cfg_t *cfg2 = jit_get_cfg(f2); ck_assert_int_eq(cfg2->nblocks, 4); ck_assert_int_eq(cfg2->blocks[1].first, 3); jit_free(j); } END_TEST START_TEST(test_lvn4) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R0, #5 \n" " ADD R1, R0, #2 \n" " CMP.EQ #1, #1 \n" " CSEL R2, #5, #6 \n" " CSET R3 \n" " DIV R5, R4, #2 \n" " DIV R6, #7, #5 \n" " DIV R7, #4, #0 \n" " DIV R8, R7, #1 \n" " MUL R9, R7, #16 \n" " MUL R10, R7, #16 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); check_unary(f, 1, J_MOV, CONST(7)); check_unary(f, 3, J_MOV, CONST(5)); check_unary(f, 4, J_MOV, CONST(1)); check_binary(f, 5, J_DIV, REG(4), CONST(2)); check_unary(f, 6, J_MOV, CONST(1)); check_binary(f, 7, J_DIV, CONST(4), CONST(0)); check_unary(f, 8, J_MOV, REG(7)); check_binary(f, 9, J_SHL, REG(7), CONST(4)); check_unary(f, 10, J_MOV, REG(9)); jit_free(j); } END_TEST START_TEST(test_lvn5) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " JUMP L1 \n" "L1: NOP \n" " JUMP L2 \n" " MOV R0, R2 \n" "L2: JUMP L3 \n" " NOP \n" "L3: NOP \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f1 = jit_get_func(j, h1); jit_do_lvn(f1); ck_assert_int_eq(f1->irbuf[0].op, J_NOP); check_unary(f1, 2, J_JUMP, LABEL(6)); const char *text2 = " CMP.EQ #1, #1 \n" " JUMP.T L1 \n" " NOP \n" "L1: NOP \n" " CMP.EQ #1, #0 \n" " JUMP.T L1 \n" " RET \n"; jit_handle_t h2 = jit_assemble(j, ident_new("myfunc2"), text2); jit_func_t *f2 = jit_get_func(j, h2); jit_do_lvn(f2); check_unary(f2, 1, J_JUMP, LABEL(3)); ck_assert_int_eq(f2->irbuf[1].cc, JIT_CC_NONE); ck_assert_int_eq(f2->irbuf[5].op, J_NOP); jit_free(j); } END_TEST START_TEST(test_lvn6) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R29, R28 \n" " MOV R32, #1 \n" " MOV R33, #-1 \n" " CMP.EQ #1, #1 \n" " MOV R34, R33 \n" " ADD R35, R34, #1 \n" " CLAMP R36, R35 \n" " NEG R37, #1 \n" " XOR R38, R37, R36 \n" " ASR R39, R38, #63 \n" " XOR R40, R39, R38 \n" " XOR R50, #0, R49 \n" " XOR R52, R51, #0 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); check_unary(f, 4, J_MOV, CONST(-1)); check_unary(f, 5, J_MOV, CONST(0));; check_unary(f, 6, J_MOV, CONST(0)); check_unary(f, 7, J_MOV, CONST(-1)); check_unary(f, 8, J_MOV, CONST(-1)); check_unary(f, 9, J_MOV, CONST(-1)); check_unary(f, 10, J_MOV, CONST(0)); ck_assert_int_eq(f->irbuf[11].op, J_MOV); ck_assert_int_eq(f->irbuf[12].op, J_MOV); jit_free(j); } END_TEST START_TEST(test_cprop1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, #0 \n" " MOV R2, R1 \n" " MOV R3, R2 \n" " ADD R4, R3, R1 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_cprop(f); check_unary(f, 0, J_MOV, CONST(0)); check_unary(f, 1, J_MOV, CONST(0)); check_unary(f, 2, J_MOV, CONST(0)); check_binary(f, 3, J_ADD, CONST(0), CONST(0)); jit_free(j); } END_TEST START_TEST(test_dce1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, #0 \n" " MOV R3, R2 \n" " ADD R6, R4, R2 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_dce(f); ck_assert_int_eq(f->irbuf[0].op, J_NOP); ck_assert_int_eq(f->irbuf[1].op, J_NOP); ck_assert_int_eq(f->irbuf[2].op, J_NOP); jit_free(j); } END_TEST START_TEST(test_nops1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " ADD R1, R1, #2 \n" " NOP \n" " NOP \n" " ADD R2, R1, R1 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f1 = jit_get_func(j, h1); jit_delete_nops(f1); ck_assert_int_eq(f1->nirs, 2); check_binary(f1, 0, J_ADD, REG(1), CONST(2)); check_binary(f1, 1, J_ADD, REG(1), REG(1)); const char *text2 = " NOP \n" " ADD R1, R1, #2 \n" " NOP \n" "L1: NOP \n" " JUMP L1 \n"; jit_handle_t h2 = jit_assemble(j, ident_new("myfunc2"), text2); jit_func_t *f2 = jit_get_func(j, h2); jit_delete_nops(f2); ck_assert_int_eq(f2->nirs, 2); check_binary(f2, 0, J_ADD, REG(1), CONST(2)); check_unary(f2, 1, J_JUMP, LABEL(1)); ck_assert_int_eq(f2->irbuf[1].target, 1); jit_free(j); } END_TEST START_TEST(test_issue608) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " JUMP L1 \n" "L1: MOV R2, #5 \n" " $COPY R2, [R1], [R0] \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_cfg_t *cfg = jit_get_cfg(f); ck_assert_int_eq(cfg->nblocks, 2); ck_assert_int_eq(cfg->blocks[0].liveout.bits, 0x3); ck_assert_int_eq(cfg->blocks[1].livein.bits, 0x3); jit_free(j); } END_TEST START_TEST(test_lvn7) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, #8 \n" " $MOVE R1, [R2], [CP+0] \n" " MOV R3, #0 \n" " $COPY R3, [R1], [R2] \n" " $MOVE R7, [R2], [CP+6] \n" " \n" "00 01 02 03 04 05 06 07 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[1].op, J_STORE); ck_assert_int_eq(f->irbuf[1].arg1.int64, UINT64_C(0x706050403020100)); ck_assert_int_eq(f->irbuf[3].op, J_NOP); ck_assert_int_eq(f->irbuf[4].op, MACRO_COPY); jit_free(j); } END_TEST START_TEST(test_lvn8) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, #8 \n" " $BZERO R1, [R2] \n" " MOV R3, #0 \n" " $BZERO R3, [R4] \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[1].op, J_STORE); ck_assert_int_eq(f->irbuf[1].arg1.int64, 0); ck_assert_int_eq(f->irbuf[3].op, J_NOP); jit_free(j); } END_TEST START_TEST(test_lvn9) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, #32 \n" " $MEMSET.16 R1, [R2], #0xffff \n" " $MEMSET.32 R1, [R2], #0xabababab \n" " $MEMSET.64 R1, [R2], #0x0101010101010101 \n" " $MEMSET.32 R3, [R4], #0 \n" " MOV R3, #0 \n" " $MEMSET.8 R3, [R2], #0xf0 \n" " MOV R4, #4 \n" " $MEMSET.8 R4, [R0+20], #1 \n" " $MEMSET.16 R4, [R0+20], #0x2233 \n" " MOV R4, #8 \n" " $MEMSET.16 R4, [R0+20], #0x2233 \n" " $MEMSET.32 R4, [R0+20], #0x11223344 \n" " $MEMSET.64 R4, [R0+20], #0xbeef \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[1].size, JIT_SZ_8); ck_assert_int_eq(f->irbuf[1].arg2.int64, 0xff); ck_assert_int_eq(f->irbuf[2].size, JIT_SZ_8); ck_assert_int_eq(f->irbuf[2].arg2.int64, 0xab); ck_assert_int_eq(f->irbuf[3].size, JIT_SZ_8); ck_assert_int_eq(f->irbuf[3].arg2.int64, 1); ck_assert_int_eq(f->irbuf[4].op, MACRO_BZERO); ck_assert_int_eq(f->irbuf[4].size, JIT_SZ_UNSPEC); ck_assert_int_eq(f->irbuf[4].arg2.kind, JIT_VALUE_INVALID); ck_assert_int_eq(f->irbuf[6].op, J_NOP); ck_assert_int_eq(f->irbuf[8].op, J_STORE); ck_assert_int_eq(f->irbuf[8].size, JIT_SZ_32); ck_assert_int_eq(f->irbuf[8].arg1.int64, 0x1010101); ck_assert_int_eq(f->irbuf[9].op, J_STORE); ck_assert_int_eq(f->irbuf[9].size, JIT_SZ_32); ck_assert_int_eq(f->irbuf[9].arg1.int64, 0x22332233); ck_assert_int_eq(f->irbuf[11].op, J_STORE); ck_assert_int_eq(f->irbuf[11].size, JIT_SZ_64); ck_assert_int_eq(f->irbuf[11].arg1.int64, 0x2233223322332233); ck_assert_int_eq(f->irbuf[12].op, J_STORE); ck_assert_int_eq(f->irbuf[12].size, JIT_SZ_64); ck_assert_int_eq(f->irbuf[12].arg1.int64, 0x1122334411223344); ck_assert_int_eq(f->irbuf[13].op, J_STORE); ck_assert_int_eq(f->irbuf[13].size, JIT_SZ_64); ck_assert_int_eq(f->irbuf[13].arg1.int64, 0xbeef); jit_free(j); } END_TEST START_TEST(test_cfg3) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" " MOV R1, #1 \n" " CMP.EQ R0, #1 \n" " JUMP L1 \n" "L1: JUMP.T L2 \n" "L2: CMP.EQ R0, #0 \n" " JUMP.T L1 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc"), text1); jit_func_t *f = jit_get_func(j, h1); jit_cfg_t *cfg = jit_get_cfg(f); ck_assert_int_eq(cfg->nblocks, 4); ck_assert_int_eq(cfg->blocks[0].returns, 0); ck_assert_int_eq(cfg->blocks[0].aborts, 0); ck_assert_int_eq(cfg->blocks[0].in.count, 0); ck_assert_int_eq(cfg->blocks[0].out.count, 1); ck_assert_int_eq(jit_get_edge(&cfg->blocks[0].out, 0), 1); ck_assert_int_eq(cfg->blocks[0].livein.size, 3); ck_assert_int_eq(cfg->blocks[0].livein.bits, 0); ck_assert_int_eq(cfg->blocks[0].liveout.size, 3); ck_assert_int_eq(cfg->blocks[0].liveout.bits, 0b101); ck_assert_int_eq(cfg->blocks[0].varkill.size, 3); ck_assert_int_eq(cfg->blocks[0].varkill.bits, 0b111); ck_assert_int_eq(cfg->blocks[1].in.count, 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].in, 0), 0); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].in, 1), 2); ck_assert_int_eq(cfg->blocks[1].out.count, 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].out, 0), 2); ck_assert_int_eq(jit_get_edge(&cfg->blocks[1].out, 1), 2); ck_assert_int_eq(cfg->blocks[1].livein.bits, 0b101); ck_assert_int_eq(cfg->blocks[1].liveout.bits, 0b1); ck_assert_int_eq(cfg->blocks[1].varkill.bits, 0); jit_free(j); } END_TEST START_TEST(test_dce2) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " CMP.EQ R0, #1 \n" " CMP.LT #0, #1 \n" " JUMP.T L1 \n" "L1: NOP \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_dce(f); ck_assert_int_eq(f->irbuf[0].op, J_NOP); ck_assert_int_eq(f->irbuf[1].op, J_CMP); jit_free(j); } END_TEST START_TEST(test_code1) { const error_t expect[] = { { LINE_INVALID, "JIT code buffer for test too small" }, { -1, NULL }, }; expect_errors(expect); code_cache_t *code = code_cache_new(); code_blob_t *blob = code_blob_new(code, ident_new("test"), 100); ck_assert_ptr_nonnull(blob); void *mem LOCAL = xcalloc(1024 * 1024); code_blob_emit(blob, mem, 128); fail_if(blob->overflow); code_blob_emit(blob, mem, 1024 * 1024); fail_unless(blob->overflow); jit_entry_fn_t entry = NULL; code_blob_finalise(blob, &entry); ck_assert_ptr_null(entry); for (int i = 0; i < 50; i++) { const size_t size = rand() % (1024 * 1024); blob = code_blob_new(code, ident_new("loop"), size); ck_assert_ptr_nonnull(blob); code_blob_emit(blob, mem, size); fail_if(blob->overflow); code_blob_finalise(blob, &entry); } code_cache_free(code); check_expected_errors(); } END_TEST START_TEST(test_lvn10) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " SEND #0, R0 \n" " SEND #1, R1 \n" " SEND #2, R2 \n" " $EXIT #1 \n" " RECV R3, #0 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); ck_assert_int_eq(f->irbuf[3].op, J_NOP); ck_assert_int_eq(f->irbuf[4].op, J_NOP); ck_assert_int_eq(f->irbuf[5].op, J_NOP); ck_assert_int_eq(f->irbuf[8].op, J_NOP); jit_free(j); } END_TEST START_TEST(test_cprop2) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, R0 \n" " MOV R2, R1 \n" " ADD R0, R0, #1 \n" " ADD R1, R1, #1 \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f1 = jit_get_func(j, h1); jit_do_cprop(f1); check_unary(f1, 0, J_MOV, REG(0)); check_unary(f1, 1, J_MOV, REG(0)); check_binary(f1, 2, J_ADD, REG(0), CONST(1)); check_binary(f1, 3, J_ADD, REG(1), CONST(1)); jit_free(j); } END_TEST START_TEST(test_mem2reg1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " $SALLOC R0, #0, #4 \n" " $SALLOC R1, #8, #7 \n" " $SALLOC R2, #16, #8 \n" " LOAD.32 R3, [R0] \n" " LOAD.32 R4, [R2] \n" " STORE.32 #5, [R0] \n" ; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_mem2reg(f); check_nullary(f, 0, J_NOP); check_binary(f, 1, MACRO_SALLOC, CONST(0), CONST(7)); check_binary(f, 2, MACRO_SALLOC, CONST(8), CONST(8)); check_unary(f, 3, J_MOV, REG(0)); check_unary(f, 4, J_LOAD, ADDR(2, 0)); check_unary(f, 5, J_MOV, CONST(5)); ck_assert_int_eq(f->framesz, 16); jit_free(j); } END_TEST START_TEST(test_lscan1) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " MOV R1, R0 \n" " ADD R0, R0, #1 \n" " ADD R1, R1, #1 \n" " MUL R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); phys_slot_t *slots LOCAL = xmalloc_array(f->nregs, sizeof(phys_slot_t)); const int spills = jit_do_lscan(f, slots, ~UINT64_C(0x3)); ck_assert_int_eq(spills, 1); ck_assert_int_eq(slots[0], 0); ck_assert_int_eq(slots[1], 1); ck_assert_int_eq(slots[2], STACK_BASE); check_unary(f, 0, J_MOV, REG(0)); check_binary(f, 1, J_ADD, REG(0), CONST(1)); check_binary(f, 2, J_ADD, REG(1), CONST(1)); jit_free(j); } END_TEST START_TEST(test_trim1) { set_standard(STD_08); input_from_file(TESTDIR "/jit/trim1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); jit_t *j = jit_new(get_registry(), get_mir()); static const struct { const char *fn; int32_t delta; } cases[] = { { "FUNC1()Q", +8 }, { "FUNC2()J", 0 }, { "FUNC3(I)C", 0 }, { "FUNC4()Q", +16 }, // Context pointer plus array { "PROC1", 0 }, { "FUNC5(I)I", 0 }, { "FUNC6()J", 0 }, { "FUNC7(I)I", 0 }, }; jit_handle_t pack = jit_compile(j, ident_new("WORK.TRIM1")); void *context = jit_link(j, pack); ck_assert_ptr_nonnull(context); mspace_t *m = jit_get_mspace(j); tlab_t *tlab = tlab_acquire(m); for (int i = 0; i < ARRAY_LEN(cases); i++) { ident_t fn = ident_sprintf("WORK.TRIM1.%s", cases[i].fn); jit_handle_t handle = jit_compile(j, fn); jit_scalar_t arg0 = { .pointer = context }; jit_scalar_t arg1 = { .integer = 42 }; jit_scalar_t result; const uint32_t entry = ((rand() % (tlab->limit / 2)) + 7) & ~7; tlab->alloc = entry; jit_fastcall(j, handle, &result, arg0, arg1, tlab); ck_assert_msg(tlab->alloc == entry + cases[i].delta, "%s: expected alloc delta %+d but have %+d", cases[i].fn, cases[i].delta, tlab->alloc - entry); } tlab_release(tlab); jit_free(j); } END_TEST START_TEST(test_lvn11) { jit_t *j = jit_new(NULL, NULL); const char *text1 = " SHL R0, #0, #1 \n" " OR R1, #1, R0 \n" " OR R2, R1, #0 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = jit_assemble(j, ident_new("myfunc1"), text1); jit_func_t *f = jit_get_func(j, h1); jit_do_lvn(f); check_unary(f, 0, J_MOV, CONST(0)); check_unary(f, 1, J_MOV, CONST(1)); check_unary(f, 2, J_MOV, CONST(1)); jit_free(j); } END_TEST Suite *get_jit_tests(void) { Suite *s = suite_create("jit"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_add1); tcase_add_test(tc, test_fact); tcase_add_test(tc, test_sum); tcase_add_test(tc, test_context1); tcase_add_test(tc, test_record1); tcase_add_test(tc, test_record2); tcase_add_test(tc, test_record3); tcase_add_test(tc, test_ieee_warnings); tcase_add_test(tc, test_overflow); tcase_add_test(tc, test_record4); tcase_add_test(tc, test_access1); tcase_add_test(tc, test_array1); tcase_add_test(tc, test_relop1); tcase_add_test(tc, test_proc1); tcase_add_test(tc, test_unreachable); tcase_add_test(tc, test_arith1); tcase_add_test(tc, test_assert1); tcase_add_test(tc, test_case1); tcase_add_test(tc, test_real1); tcase_add_test(tc, test_prot1); tcase_add_test(tc, test_layout); tcase_add_test(tc, test_range1); tcase_add_test(tc, test_trace1); tcase_add_test(tc, test_issue496); tcase_add_test(tc, test_value1); tcase_add_test(tc, test_assemble1); tcase_add_test(tc, test_assemble2); tcase_add_test(tc, test_cfg1); tcase_add_test(tc, test_lvn1); tcase_add_test(tc, test_lvn2); tcase_add_test(tc, test_lvn3); tcase_add_test(tc, test_issue575); tcase_add_test(tc, test_cfg2); tcase_add_test(tc, test_lvn4); tcase_add_test(tc, test_lvn5); tcase_add_test(tc, test_lvn6); tcase_add_test(tc, test_cprop1); tcase_add_test(tc, test_dce1); tcase_add_test(tc, test_nops1); tcase_add_test(tc, test_issue608); tcase_add_test(tc, test_lvn7); tcase_add_test(tc, test_lvn8); tcase_add_test(tc, test_lvn9); tcase_add_test(tc, test_cfg3); tcase_add_test(tc, test_dce2); tcase_add_test(tc, test_code1); tcase_add_test(tc, test_lvn10); tcase_add_test(tc, test_cprop2); tcase_add_test(tc, test_mem2reg1); tcase_add_test(tc, test_lscan1); tcase_add_test(tc, test_trim1); tcase_add_test(tc, test_lvn11); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_lib.c000066400000000000000000000215451504111170000154760ustar00rootroot00000000000000// // Copyright (C) 2011-2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "lib.h" #include "object.h" #include "tree.h" #include "type.h" #include "util.h" #include static lib_t work; static const char *tmp; static void setup(void) { tmp = getenv("ORIGINAL_TEMP"); if (tmp == NULL) { tmp = getenv("TEMP"); if (tmp == NULL) tmp = "/tmp"; } char *spec LOCAL = xasprintf("test_lib:%s" DIR_SEP "test_lib", tmp); work = lib_new(spec); fail_if(work == NULL); } static void teardown(void) { if (work) { lib_destroy(work); lib_free(work); work = NULL; } } static type_t my_int_type(void) { static type_t type = NULL; if (type == NULL) { tree_t min = tree_new(T_LITERAL); tree_set_subkind(min, L_INT); tree_set_ival(min, INT64_MIN); tree_t max = tree_new(T_LITERAL); tree_set_subkind(max, L_INT); tree_set_ival(max, INT64_MAX); type = type_new(T_INTEGER); type_set_ident(type, ident_new("my_int_type")); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_TO); tree_set_left(r, min); tree_set_right(r, max); tree_set_type(r, type); type_add_dim(type, r); tree_set_type(min, type); tree_set_type(max, type); } return type; } static tree_t str_to_agg(const char *p, const char *end) { tree_t t = tree_new(T_AGGREGATE); unsigned len = 0; while (*p != '\0' && p != end) { const char ch[] = { '\'', *p++, '\'', '\0' }; tree_t ref = tree_new(T_REF); tree_set_ident(ref, ident_new(ch)); tree_t a = tree_new(T_ASSOC); tree_set_subkind(a, A_POS); tree_set_value(a, ref); tree_add_assoc(t, a); ++len; } tree_t left = tree_new(T_LITERAL); tree_set_subkind(left, L_INT); tree_set_ival(left, 0); tree_t right = tree_new(T_LITERAL); tree_set_subkind(right, L_INT); tree_set_ival(right, len - 1); type_t type = type_new(T_ARRAY); type_set_ident(type, ident_new("string")); type_set_elem(type, my_int_type()); type_add_index(type, my_int_type()); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_DOWNTO); tree_set_left(r, left); tree_set_right(r, right); tree_t cons = tree_new(T_CONSTRAINT); tree_set_subkind(cons, C_INDEX); tree_add_range(cons, r); type_t sub = type_new(T_SUBTYPE); type_set_base(sub, type); type_set_constraint(sub, cons); tree_set_type(t, sub); return t; } START_TEST(test_lib_new) { fail_if(work == NULL); } END_TEST START_TEST(test_lib_fopen) { FILE *f = lib_fopen(work, "_test", "w"); fprintf(f, "hello world"); fclose(f); lib_free(work); lib_add_search_path(tmp); work = lib_find(ident_new("test_lib")); fail_if(work == NULL); f = lib_fopen(work, "_test", "r"); fail_if(f == NULL); char buf[12]; fail_if(fgets(buf, sizeof(buf), f) == NULL); fail_unless(strcmp(buf, "hello world") == 0); fclose(f); } END_TEST START_TEST(test_lib_save) { { make_new_arena(); tree_t ent = tree_new(T_ENTITY); tree_set_ident(ent, ident_new("TEST_LIB.name")); type_t e = type_new(T_ENUM); type_set_ident(e, ident_new("myenum")); tree_t a = tree_new(T_ENUM_LIT); tree_set_ident(a, ident_new("a")); tree_set_type(a, e); tree_set_pos(a, 55); type_enum_add_literal(e, a); tree_t b = tree_new(T_ENUM_LIT); tree_set_ident(b, ident_new("b")); tree_set_type(b, e); type_enum_add_literal(e, b); tree_t p1 = tree_new(T_PORT_DECL); tree_set_ident(p1, ident_new("foo")); tree_set_subkind(p1, PORT_OUT); tree_set_type(p1, my_int_type()); tree_add_port(ent, p1); tree_t p2 = tree_new(T_PORT_DECL); tree_set_ident(p2, ident_new("bar")); tree_set_subkind(p2, PORT_IN); tree_set_type(p2, e); tree_add_port(ent, p2); lib_put(work, ent); make_new_arena(); tree_t ar = tree_new(T_ARCH); tree_set_ident(ar, ident_new("TEST_LIB.arch")); tree_set_ident2(ar, ident_new("foo")); tree_t pr = tree_new(T_PROCESS); tree_set_ident(pr, ident_new("proc")); tree_add_stmt(ar, pr); tree_t v1 = tree_new(T_VAR_DECL); tree_set_ident(v1, ident_new("v1")); tree_set_type(v1, e); tree_t r = tree_new(T_REF); tree_set_ident(r, ident_new("v1")); tree_set_ref(r, v1); tree_t s = tree_new(T_VAR_ASSIGN); tree_set_ident(s, ident_new("var_assign")); tree_set_target(s, r); tree_set_value(s, r); tree_add_stmt(pr, s); tree_t c = tree_new(T_LITERAL); tree_set_subkind(c, L_INT); tree_set_ival(c, 53); tree_t s2 = tree_new(T_VAR_ASSIGN); tree_set_ident(s2, ident_new("var_assign")); tree_set_target(s2, r); tree_set_value(s2, c); tree_add_stmt(pr, s2); tree_t s3 = tree_new(T_VAR_ASSIGN); tree_set_ident(s3, ident_new("var_assign")); tree_set_target(s3, r); tree_set_value(s3, str_to_agg("foobar", NULL)); tree_add_stmt(pr, s3); tree_t s4 = tree_new(T_ASSERT); tree_set_ident(s4, ident_new("assert")); tree_set_value(s4, c); tree_set_severity(s4, c); tree_set_message(s4, str_to_agg("message", NULL)); tree_add_stmt(pr, s4); lib_put(work, ar); } lib_save(work); lib_free(work); lib_add_search_path(tmp); work = lib_find(ident_new("test_lib")); fail_if(work == NULL); { tree_t ent = lib_get(work, ident_new("TEST_LIB.name")); fail_if(ent == NULL); fail_unless(tree_kind(ent) == T_ENTITY); fail_unless(tree_ident(ent) == ident_new("TEST_LIB.name")); fail_unless(tree_ports(ent) == 2); tree_t p1 = tree_port(ent, 0); fail_unless(tree_kind(p1) == T_PORT_DECL); fail_unless(tree_subkind(p1) == PORT_OUT); fail_unless(type_kind(tree_type(p1)) == T_INTEGER); tree_t p2 = tree_port(ent, 1); fail_unless(tree_kind(p2) == T_PORT_DECL); fail_unless(tree_subkind(p2) == PORT_IN); type_t e = tree_type(p2); fail_unless(type_kind(e) == T_ENUM); fail_unless(type_enum_literals(e) == 2); tree_t a = type_enum_literal(e, 0); fail_unless(tree_kind(a) == T_ENUM_LIT); fail_unless(tree_ident(a) == ident_new("a")); fail_unless(tree_type(a) == e); fail_unless(tree_pos(a) == 55); tree_t b = type_enum_literal(e, 1); fail_unless(tree_kind(b) == T_ENUM_LIT); fail_unless(tree_ident(b) == ident_new("b")); fail_unless(tree_type(b) == e); tree_t ar = lib_get(work, ident_new("TEST_LIB.arch")); fail_if(ar == NULL); fail_unless(tree_ident(ar) == ident_new("TEST_LIB.arch")); fail_unless(tree_ident2(ar) == ident_new("foo")); tree_t pr = tree_stmt(ar, 0); fail_unless(tree_kind(pr) == T_PROCESS); fail_unless(tree_ident(pr) == ident_new("proc")); tree_t s = tree_stmt(pr, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); tree_t r = tree_target(s); fail_unless(tree_kind(r) == T_REF); fail_unless(tree_value(s) == r); tree_t s2 = tree_stmt(pr, 1); fail_unless(tree_kind(s2) == T_VAR_ASSIGN); fail_unless(tree_target(s2) == r); tree_t s3 = tree_stmt(pr, 2); fail_unless(tree_kind(s3) == T_VAR_ASSIGN); fail_unless(tree_target(s3) == r); fail_unless(tree_kind(tree_value(s3)) == T_AGGREGATE); tree_t s4 = tree_stmt(pr, 3); fail_unless(tree_kind(s4) == T_ASSERT); fail_unless(tree_ident(s4) == ident_new("assert")); tree_t c = tree_value(s2); fail_unless(tree_kind(c) == T_LITERAL); fail_unless(tree_subkind(c) == L_INT); fail_unless(tree_ival(c) == 53); // Type declaration and reference written to different units // so two copies of the type declaration will be read back // hence can't check for pointer equality here fail_unless(type_eq(tree_type(tree_ref(r)), e)); } } END_TEST Suite *get_lib_tests(void) { Suite *s = suite_create("lib"); TCase *tc_core = nvc_unit_test(); tcase_add_checked_fixture(tc_core, setup, teardown); tcase_add_test(tc_core, test_lib_new); tcase_add_test(tc_core, test_lib_fopen); tcase_add_test(tc_core, test_lib_save); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_lower.c000066400000000000000000005300541504111170000160600ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "cov/cov-api.h" #include "diag.h" #include "jit/jit.h" #include "lower.h" #include "option.h" #include "phase.h" #include "rt/model.h" #include "scan.h" #include "vcode.h" #include typedef struct { vcode_op_t op; const char *func; const char *name; int64_t value; double real; vcode_cmp_t cmp; vcode_block_t target; vcode_block_t target_else; uint32_t tag; int length; uint8_t dim; uint8_t hops; uint8_t field; uint8_t subkind; } check_bb_t; #define CAT(x, y) x##y #define CHECK_BB(n) check_bb(n, CAT(bb, n), ARRAY_LEN(CAT(bb, n))) #define EXPECT_BB(n) const check_bb_t CAT(bb, n)[] static bool fuzzy_cmp(ident_t id, const char *str) { if (*str == '*') return strstr(istr(id), str + 1) != NULL; else return ident_new(str) == id; } static void check_bb(int bb, const check_bb_t *expect, int len) { fail_unless(bb < vcode_count_blocks()); vcode_select_block(bb); const int nops = vcode_count_ops(); int eptr = 0, actual = nops; for (int i = 0; i < nops && eptr < len; i++) { const vcode_op_t vop = vcode_get_op(i); if (vop == VCODE_OP_COMMENT) { actual--; continue; } const check_bb_t *e = &(expect[eptr++]); if (vop != e->op) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to be %s but was %s", i, bb, vcode_op_string(e->op), vcode_op_string(vop)); } switch (e->op) { case VCODE_OP_PCALL: if (e->target != vcode_get_target(i, 0)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have resume target %d but " "has %d", i, bb, e->target, vcode_get_target(i, 0)); } // Fall-through case VCODE_OP_FCALL: case VCODE_OP_CLOSURE: case VCODE_OP_FUNCTION_TRIGGER: if (!fuzzy_cmp(vcode_get_func(i), e->func)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to call %s but calls %s", i, bb, e->func, istr(vcode_get_func(i))); } break; case VCODE_OP_CONST: if (e->value != vcode_get_value(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have constant %"PRIi64 " but has %"PRIi64, i, bb, e->value, vcode_get_value(i)); } break; case VCODE_OP_CONST_REP: if (e->value != vcode_get_value(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have repeat count %"PRIi64 " but has %"PRIi64, i, bb, e->value, vcode_get_value(i)); } break; case VCODE_OP_CONST_REAL: if (e->real != vcode_get_real(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have constant %lf but has %lf", i, bb, e->real, vcode_get_real(i)); } break; case VCODE_OP_CMP: if (e->cmp != vcode_get_cmp(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have comparison %"PRIi64 " but has %d", i, bb, e->value, vcode_get_cmp(i)); } break; case VCODE_OP_ASSERT: case VCODE_OP_REPORT: case VCODE_OP_RETURN: case VCODE_OP_UNWRAP: case VCODE_OP_LENGTH_CHECK: case VCODE_OP_EXPONENT_CHECK: case VCODE_OP_NULL: case VCODE_OP_RANGE_NULL: case VCODE_OP_RANGE_LENGTH: case VCODE_OP_NULL_CHECK: case VCODE_OP_FILE_WRITE: break; case VCODE_OP_UARRAY_LEFT: case VCODE_OP_UARRAY_RIGHT: case VCODE_OP_UARRAY_DIR: case VCODE_OP_UARRAY_LEN: if (e->dim != vcode_get_dim(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have dimension %d but has %d", i, bb, e->dim, vcode_get_dim(i)); } break; case VCODE_OP_WAIT: if (e->target != vcode_get_target(i, 0)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have wait target %d but has %d", i, bb, e->target, vcode_get_target(i, 0)); } break; case VCODE_OP_COND: if (e->target_else != vcode_get_target(i, 1)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have else target %d but has %d", i, bb, e->target_else, vcode_get_target(i, 1)); } // Fall-through case VCODE_OP_JUMP: if (e->target != vcode_get_target(i, 0)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have jump target %d but has %d", i, bb, e->target, vcode_get_target(i, 0)); } break; case VCODE_OP_STORE: case VCODE_OP_LOAD: case VCODE_OP_INDEX: { ident_t name = vcode_var_name(vcode_get_address(i)); if (!fuzzy_cmp(name, e->name)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have address name %s but " "has %s", i, bb, e->name, istr(name)); } } break; case VCODE_OP_LINK_VAR: case VCODE_OP_LINK_PACKAGE: { ident_t name = vcode_get_ident(i); if (name != ident_new(e->name)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have name %s but has %s", i, bb, e->name, istr(name)); } } break; case VCODE_OP_ADD: case VCODE_OP_SUB: case VCODE_OP_MUL: case VCODE_OP_DIV: case VCODE_OP_EXP: case VCODE_OP_MOD: case VCODE_OP_REM: case VCODE_OP_NEG: case VCODE_OP_ABS: case VCODE_OP_CAST: case VCODE_OP_OR: case VCODE_OP_NOR: case VCODE_OP_AND: case VCODE_OP_NOT: case VCODE_OP_LOAD_INDIRECT: case VCODE_OP_STORE_INDIRECT: case VCODE_OP_ARRAY_REF: case VCODE_OP_ADDRESS_OF: case VCODE_OP_SCHED_WAVEFORM: case VCODE_OP_SELECT: case VCODE_OP_EVENT: case VCODE_OP_ACTIVE: case VCODE_OP_CONST_RECORD: case VCODE_OP_COPY: case VCODE_OP_MEMSET: case VCODE_OP_WRAP: case VCODE_OP_NEW: case VCODE_OP_ALL: case VCODE_OP_DEALLOCATE: case VCODE_OP_CASE: case VCODE_OP_INIT_SIGNAL: case VCODE_OP_MAP_SIGNAL: case VCODE_OP_DRIVE_SIGNAL: case VCODE_OP_TRANSFER_SIGNAL: case VCODE_OP_MAP_CONST: case VCODE_OP_RESOLVED: case VCODE_OP_RESOLUTION_WRAPPER: case VCODE_OP_RESOLVE_SIGNAL: case VCODE_OP_ALIAS_SIGNAL: case VCODE_OP_TRAP_ADD: case VCODE_OP_TRAP_SUB: case VCODE_OP_TRAP_MUL: case VCODE_OP_TRAP_NEG: case VCODE_OP_TRAP_EXP: case VCODE_OP_PACKAGE_SCOPE: case VCODE_OP_ARRAY_SCOPE: case VCODE_OP_POP_SCOPE: case VCODE_OP_ADD_TRIGGER: case VCODE_OP_OR_TRIGGER: case VCODE_OP_CMP_TRIGGER: case VCODE_OP_BIND_EXTERNAL: break; case VCODE_OP_CONST_ARRAY: if (vcode_count_args(i) != e->length) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have %d array elements but " "has %d", i, bb, e->length, vcode_count_args(i)); } break; case VCODE_OP_VAR_UPREF: { vcode_state_t state; vcode_state_save(&state); vcode_var_t address = vcode_get_address(i); int hops = vcode_get_hops(i); for (vcode_unit_t vu = vcode_active_unit(); hops > 0; hops--) vcode_select_unit((vu = vcode_unit_context(vu))); ident_t actual = vcode_var_name(address); vcode_state_restore(&state); if (!icmp(actual, e->name)) { vcode_dump_with_mark(i, NULL, NULL); fail("expect op %d in block %d to have address %s" " but has %s", i, bb, e->name, istr(actual)); } } // Fall-through case VCODE_OP_CONTEXT_UPREF: if (vcode_get_hops(i) != e->hops) { vcode_dump_with_mark(i, NULL, NULL); fail("expect op %d in block %d to have hop count %d" " but has %d", i, bb, e->hops, vcode_get_hops(i)); } break; case VCODE_OP_RECORD_REF: if (vcode_get_field(i) != e->field) { vcode_dump_with_mark(i, NULL, NULL); fail("expect op %d in block %d to have field %d" " but has %d", i, bb, e->field, vcode_get_field(i)); } break; case VCODE_OP_ALLOC: case VCODE_OP_SCHED_EVENT: case VCODE_OP_CLEAR_EVENT: case VCODE_OP_FILE_OPEN: case VCODE_OP_INDEX_CHECK: case VCODE_OP_RANGE_CHECK: case VCODE_OP_DEBUG_LOCUS: break; case VCODE_OP_RESUME: if ((e->func != NULL) && !icmp(vcode_get_func(i), e->func)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to call %s but calls %s", i, bb, e->func, istr(vcode_get_func(i))); } break; case VCODE_OP_COVER_BRANCH: case VCODE_OP_COVER_TOGGLE: case VCODE_OP_COVER_STMT: case VCODE_OP_COVER_EXPR: if (e->tag != vcode_get_tag(i)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to have cover tag %d but has %d", i, bb, e->tag, vcode_get_tag(i)); } break; case VCODE_OP_PACKAGE_INIT: case VCODE_OP_PROTECTED_INIT: if (!fuzzy_cmp(vcode_get_func(i), e->name)) { vcode_dump_with_mark(i, NULL, NULL); fail("expected op %d in block %d to initialise package %s " "instead of %s", i, bb, e->name, istr(vcode_get_func(i))); } break; default: fail("cannot check op %s", vcode_op_string(e->op)); } } if (actual != eptr) { vcode_dump_with_mark(len + nops - actual, NULL, NULL); fail("expected %d ops in block %d but have %d", len, bb, actual); } } static vcode_unit_t find_unit_for(tree_t decl) { fail_unless(is_subprogram(decl)); unit_registry_t *ur = get_registry(); vcode_unit_t vu = unit_registry_get(ur, tree_ident2(decl)); if (vu == NULL) fail("missing vcode unit for %s", istr(tree_ident2(decl))); return vu; } static vcode_unit_t find_unit(const char *name) { unit_registry_t *ur = get_registry(); vcode_unit_t vu = unit_registry_get(ur, ident_new(name)); if (vu == NULL) fail("missing vcode unit for %s", name); return vu; } START_TEST(test_wait1) { input_from_file(TESTDIR "/lower/wait1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.WAIT1.P1"); vcode_select_unit(v0); const check_bb_t bb0[] = { { VCODE_OP_RETURN } }; CHECK_BB(0); const check_bb_t bb1[] = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_FCALL, .func = "*STD.STANDARD.NOW()" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); const check_bb_t bb2[] = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_FCALL, .func = "*STD.STANDARD.NOW()" }, { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WAIT, .target = 3 } }; CHECK_BB(2); const check_bb_t bb3[] = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_FCALL, .func = "*STD.STANDARD.NOW()" }, { VCODE_OP_CONST, .value = 1000001 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 4 } }; CHECK_BB(3); const check_bb_t bb4[] = { { VCODE_OP_JUMP, .target = 1 } }; CHECK_BB(4); fail_if_errors(); } END_TEST START_TEST(test_assign1) { input_from_file(TESTDIR "/lower/assign1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ASSIGN1.P1"); vcode_select_unit(v0); fail_unless(vcode_count_vars() == 2); const check_bb_t bb0[] = { { VCODE_OP_CONST, .value = 64 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONST, .value = -4 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN } }; CHECK_BB(0); const check_bb_t bb1[] = { { VCODE_OP_CONST, .value = 4000000 }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); const check_bb_t bb2[] = { { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 64 }, { VCODE_OP_CMP }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_CONST, .value = -4 }, { VCODE_OP_CMP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_MUL }, { VCODE_OP_CONST, .value = -8 }, { VCODE_OP_CMP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_WAIT, .target = 3 } }; CHECK_BB(2); const check_bb_t bb3[] = { { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_CONST, .value = 12 }, { VCODE_OP_CMP }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 4 } }; CHECK_BB(3); const check_bb_t bb4[] = { { VCODE_OP_JUMP, .target = 1 } }; CHECK_BB(4); fail_if_errors(); } END_TEST START_TEST(test_assign2) { input_from_file(TESTDIR "/lower/assign2.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ASSIGN2.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 8 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_INDEX, .name = "Y" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_MEMSET }, { VCODE_OP_RETURN } }; CHECK_BB(0); fail_unless(vcode_get_op(4) == VCODE_OP_CONST_ARRAY); for (int i = 0; i < 8; i++) fail_unless(vcode_get_arg(4, i) == vcode_get_result((i == 6) ? 2 : 3)); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CMP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_INDEX, .name = "Y" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_signal1) { input_from_file(TESTDIR "/lower/signal1.vhd"); run_elab(); vcode_unit_t vc = find_unit("WORK.SIGNAL1"); vcode_select_unit(vc); { EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } fail_unless(vcode_count_vars() == 1); fail_unless(icmp(vcode_var_name(0), "X")); vcode_unit_t v0 = find_unit("WORK.SIGNAL1.P1"); vcode_select_unit(v0); { EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } fail_if_errors(); } END_TEST START_TEST(test_cond1) { input_from_file(TESTDIR "/lower/cond1.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); vcode_unit_t v0 = find_unit("WORK.COND1.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = -2147483648 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 2, .target_else = 3 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_JUMP, .target = 3 } }; CHECK_BB(2); EXPECT_BB(3) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 4, .target_else = 5 } }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_JUMP, .target = 6 } }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_JUMP, .target = 6 } }; CHECK_BB(5); EXPECT_BB(6) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 100 }, { VCODE_OP_CONST, .value = 111 }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_REPORT }, { VCODE_OP_WAIT, .target = 7 } }; CHECK_BB(6); } END_TEST START_TEST(test_arith1) { input_from_file(TESTDIR "/lower/arith1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ARITH1.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = -2147483648 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONST, .value = 12 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_CONST, .value = 15 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_SUB }, { VCODE_OP_CONST, .value = -9 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_MUL }, { VCODE_OP_CONST, .value = 36 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 12 }, { VCODE_OP_DIV }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_NEQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_LT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_LEQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GEQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_NEG }, { VCODE_OP_CONST, .value = -3 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_EXPONENT_CHECK }, { VCODE_OP_TRAP_EXP }, { VCODE_OP_CONST, .value = 531441 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = -34 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_ABS }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_MOD }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_REM }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = -5 }, { VCODE_OP_REM }, { VCODE_OP_CONST, .value = -2 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_MOD }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 3 } }; CHECK_BB(2); fail_if_errors(); } END_TEST START_TEST(test_pack1) { input_from_file(TESTDIR "/lower/pack1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t v0 = find_unit("WORK.PACK1.ADD1(I)I"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_RETURN } }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_func1) { input_from_file(TESTDIR "/lower/func1.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); vcode_unit_t v0 = find_unit("WORK.FUNC1.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "WORK.FUNC1.ADD1(I)I" }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_issue94) { input_from_file(TESTDIR "/lower/issue94.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); } END_TEST START_TEST(test_arrayop1) { input_from_file(TESTDIR "/lower/arrayop1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ARRAYOP1.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "STD.STANDARD.\"<\"(QQ)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_array1) { input_from_file(TESTDIR "/lower/array1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ARRAY1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "WORK.ARRAY1.FUNC()Q" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 2 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "STD.STANDARD.\"=\"(QQ)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_nest1) { input_from_file(TESTDIR "/lower/nest1.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); tree_t p = tree_stmt(tree_stmt(e, 0), 0); fail_unless(tree_kind(p) == T_PROCESS); { vcode_unit_t v0 = find_unit("WORK.NEST1.LINE_7"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_FCALL, .func = "WORK.NEST1.LINE_7.ADD_TO_X(I)I" }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } tree_t f1 = tree_decl(p, 2); fail_unless(tree_kind(f1) == T_FUNC_BODY); { vcode_unit_t v0 = find_unit_for(f1); vcode_select_unit(v0); fail_unless(icmp(vcode_unit_name(v0), "WORK.NEST1.LINE_7.ADD_TO_X(I)I")); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.NEST1.LINE_7.ADD_TO_X(I)I.DO_IT()I" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } tree_t f2 = tree_decl(f1, 0); fail_unless(tree_kind(f2) == T_FUNC_BODY); { vcode_unit_t v0 = find_unit_for(f2); vcode_select_unit(v0); fail_unless(icmp(vcode_unit_name(v0), "WORK.NEST1.LINE_7.ADD_TO_X(I)I.DO_IT()I")); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 2, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "Y" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_RETURN } }; CHECK_BB(0); } } END_TEST START_TEST(test_signal2) { input_from_file(TESTDIR "/lower/signal2.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.SIGNAL2.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_EVENT }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_ACTIVE }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_attr1) { input_from_file(TESTDIR "/lower/attr1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ATTR1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ADD }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST, .value = INT32_MAX }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_SUB }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = -1 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_LOAD, .name = "Z" }, { VCODE_OP_ADD }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_ADD }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ADD }, { VCODE_OP_CONST, .value = 10 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = -1 }, { VCODE_OP_ADD }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_assign3) { input_from_file(TESTDIR "/lower/assign3.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ASSIGN3.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_INDEX, .name = "Y" }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_COPY }, { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "STD.STANDARD.\"/=\"(QQ)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_record1) { input_from_file(TESTDIR "/lower/record1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.RECORD1.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_INDEX, .name = "A" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_INDEX, .name = "B" }, { VCODE_OP_COPY }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "A" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_INDEX, .name = "B" }, { VCODE_OP_COPY }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "*WORK.RECORD1-TEST.\"=\"(" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_signal4) { input_from_file(TESTDIR "/lower/signal4.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); vcode_unit_t v0 = find_unit("WORK.SIGNAL4.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_RESOLVED }, { VCODE_OP_COPY }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_staticwait) { input_from_file(TESTDIR "/lower/staticwait.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); vcode_unit_t v0 = find_unit("WORK.STATICWAIT.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_RETURN } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_proc1) { input_from_file(TESTDIR "/lower/proc1.vhd"); tree_t e = run_elab(); { vcode_unit_t v0 = find_unit("WORK.PROC1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_LOAD, .name = "A" }, { VCODE_OP_INDEX, .name = "B" }, { VCODE_OP_FCALL, .func = "WORK.PROC1.ADD1(II)" }, { VCODE_OP_LOAD, .name = "B" }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_FCALL, .func = "WORK.PROC1.ADD1(II)" }, { VCODE_OP_LOAD, .name = "B" }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } fail_if_errors(); } END_TEST START_TEST(test_while1) { input_from_file(TESTDIR "/lower/while1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.WHILE1.P1"); vcode_select_unit(v0); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "N" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_COND, .target = 3, .target_else = 4 } }; CHECK_BB(2); EXPECT_BB(3) = { { VCODE_OP_LOAD, .name = "N" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_SUB }, { VCODE_OP_STORE, .name = "N" }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(3); fail_if_errors(); } END_TEST START_TEST(test_loop1) { input_from_file(TESTDIR "/lower/loop1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.LOOP1.P1"); vcode_select_unit(v0); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "A" }, { VCODE_OP_CONST, .value = 10 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 5, .target_else = 4 } }; CHECK_BB(2); EXPECT_BB(6) = { { VCODE_OP_LOAD, .name = "A" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_STORE, .name = "A" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_MOD }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 9, .target_else = 8 } }; CHECK_BB(6); fail_if_errors(); } END_TEST START_TEST(test_proc3) { input_from_file(TESTDIR "/lower/proc3.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONST, .value = 10000000 }, { VCODE_OP_WAIT, .target = 1 } }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONST, .value = 5000000 }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } { vcode_unit_t v0 = find_unit("WORK.PROC3.P2"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_INDEX, .name = "X" }, { VCODE_OP_PCALL, .func = "WORK.PROC3.P1(I)", .target = 2 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_RESUME, .func = "WORK.PROC3.P1(I)" }, { VCODE_OP_WAIT, .target = 3 } }; CHECK_BB(2); } } END_TEST START_TEST(test_loop2) { input_from_file(TESTDIR "/lower/loop2.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 1000 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GEQ }, { VCODE_OP_COND, .target = 3, .target_else = 4 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_RETURN }, }; CHECK_BB(2); } END_TEST START_TEST(test_slice1) { input_from_file(TESTDIR "/lower/slice1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.SLICE1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST_ARRAY, .length = 4 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_COPY }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_CONST_ARRAY, .length = 2 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_COPY }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_WRAP }, { VCODE_OP_CONST_ARRAY, .length = 2 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = -2147483648 }, { VCODE_OP_CONST, .value = -2147483647 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func="*WORK.SLICE1-TEST.\"=\"" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_funcif) { input_from_file(TESTDIR "/lower/funcif.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); fail_unless(vcode_count_blocks() == 3); } END_TEST START_TEST(test_memset) { input_from_file(TESTDIR "/lower/memset.vhd"); tree_t e = run_elab(); tree_t b0 = tree_stmt(e, 0); { tree_t f = get_decl(b0, "FOO"); fail_if(f == NULL); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_MEMSET }, { VCODE_OP_RETURN } }; CHECK_BB(0); } { tree_t f = get_decl(b0, "BAR"); fail_if(f == NULL); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_CONST, .value = 2880154539 }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST, .value = INT32_MAX }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_MEMSET }, { VCODE_OP_RETURN } }; CHECK_BB(0); } fail_if_errors(); } END_TEST START_TEST(test_func5) { input_from_file(TESTDIR "/lower/func5.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_RETURN } }; CHECK_BB(0); } { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 2)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_EVENT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } { vcode_unit_t v0 = find_unit("WORK.FUNC5.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_FCALL, .func = "WORK.FUNC5.ADD_ONE_S(sI)I" }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_FCALL, .func = "WORK.FUNC5.EVENT(sI)B" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } } END_TEST START_TEST(test_bounds1) { input_from_file(TESTDIR "/lower/bounds1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.BOUNDS1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_LOAD, .name = "K" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 9 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ADD }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_record6) { input_from_file(TESTDIR "/lower/record6.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); tree_t f = get_decl(tree_stmt(e, 0), "MAKE_REC"); fail_if(f == NULL); fail_unless(tree_kind(f) == T_FUNC_BODY); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); fail_unless(vcode_var_flags(0) & VAR_HEAP); EXPECT_BB(0) = { { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_REP, .value = 3 }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_COPY }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_proc7) { input_from_file(TESTDIR "/lower/proc7.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC, .subkind = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); // This block is pointless as both index checks get optimised out EXPECT_BB(1) = { { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_WAIT, .target = 3 }, }; CHECK_BB(2); } END_TEST START_TEST(test_issue116) { input_from_file(TESTDIR "/lower/issue116.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); run_elab(); vcode_unit_t v0 = find_unit("WORK.ISSUE116.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "INTSTAT", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_mulphys) { input_from_file(TESTDIR "/lower/mulphys.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1000000 }, { VCODE_OP_CAST }, { VCODE_OP_MUL }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_cover) { input_from_file(TESTDIR "/lower/cover.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); unit_registry_t *ur = get_registry(); mir_context_t *mc = get_mir(); jit_t *jit = jit_new(ur, mc); cover_data_t *data = cover_data_init(COVER_MASK_STMT | COVER_MASK_EXPRESSION | COVER_MASK_BRANCH, 0, 0); rt_model_t *m = model_new(jit, data); elab(tree_to_object(a), jit, ur, mc, data, NULL, m); vcode_unit_t v0 = find_unit("WORK.COVER_ENT.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_COVER_STMT, .tag = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_COVER_STMT, .tag = 1 }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_NOT }, { VCODE_OP_COND, .target = 3, .target_else = 2 } }; CHECK_BB(1); EXPECT_BB(3) = { { VCODE_OP_COVER_EXPR, .tag = 2 }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_VAR_UPREF, .name = "S", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 10 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_NOT }, { VCODE_OP_COND, .target = 7, .target_else = 6 } }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_COVER_EXPR, .tag = 3 }, { VCODE_OP_JUMP, .target = 4 } }; CHECK_BB(5); EXPECT_BB(6) = { { VCODE_OP_COND, .target = 9, .target_else = 8 } }; CHECK_BB(6); EXPECT_BB(7) = { { VCODE_OP_COVER_EXPR, .tag = 4 }, { VCODE_OP_JUMP, .target = 6 } }; CHECK_BB(7); EXPECT_BB(8) = { { VCODE_OP_OR }, { VCODE_OP_NOT }, { VCODE_OP_NOT }, { VCODE_OP_AND }, { VCODE_OP_COND, .target = 11, .target_else = 10 } }; CHECK_BB(8); EXPECT_BB(9) = { { VCODE_OP_COVER_EXPR, .tag = 5 }, { VCODE_OP_JUMP, .target = 8 } }; CHECK_BB(9); EXPECT_BB(10) = { { VCODE_OP_AND }, { VCODE_OP_COND, .target = 13, .target_else = 12 } }; CHECK_BB(10); EXPECT_BB(11) = { { VCODE_OP_COVER_EXPR, .tag = 6 }, { VCODE_OP_JUMP, .target = 10 } }; CHECK_BB(11); EXPECT_BB(12) = { { VCODE_OP_AND }, { VCODE_OP_COND, .target = 15, .target_else = 14 } }; CHECK_BB(12); EXPECT_BB(13) = { { VCODE_OP_COVER_EXPR, .tag = 7 }, { VCODE_OP_JUMP, .target = 12 } }; CHECK_BB(13); EXPECT_BB(14) = { { VCODE_OP_COND, .target = 16, .target_else = 17 } }; CHECK_BB(14); EXPECT_BB(15) = { { VCODE_OP_COVER_EXPR, .tag = 8 }, { VCODE_OP_JUMP, .target = 14 } }; CHECK_BB(15); EXPECT_BB(16) = { { VCODE_OP_COVER_BRANCH, .tag = 9 }, { VCODE_OP_COVER_STMT, .tag = 11 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_JUMP, .target = 18} }; CHECK_BB(16); EXPECT_BB(18) = { { VCODE_OP_VAR_UPREF, .name = "S", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_COVER_STMT, .tag = 12 }, { VCODE_OP_WAIT, .target = 19 } }; CHECK_BB(18); model_free(m); jit_free(jit); fail_if_errors(); } END_TEST START_TEST(test_issue122) { input_from_file(TESTDIR "/lower/issue122.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.ISSUE122.FUNC(I)I.NESTED()I" }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue124) { input_from_file(TESTDIR "/lower/issue124.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK" }, { VCODE_OP_FCALL, .func = "WORK.PACK.TO_INTEGER(18WORK.PACK.UNSIGNED)I" }, { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_FCALL, .func = "STD.STANDARD.INTEGER$image" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue135) { input_from_file(TESTDIR "/lower/issue135.vhd"); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_FCALL, .func = "STD.STANDARD.INTEGER$image" }, { VCODE_OP_FCALL, .func = "STD.STANDARD.TIME$image" }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ADD }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ADD }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ADD }, { VCODE_OP_ADD }, { VCODE_OP_SUB }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ADD }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CAST }, { VCODE_OP_ADD }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue134) { input_from_file(TESTDIR "/lower/issue134.vhd"); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST_ARRAY, .length = 0 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue136) { set_standard(STD_00); input_from_file(TESTDIR "/lower/issue136.vhd"); tree_t e = run_elab(); tree_t b0 = tree_stmt(e, 0); tree_t body = get_nth_decl(b0, "RECORD_RETURNER_T", 1); fail_unless(tree_kind(body) == T_PROT_BODY); (void)find_unit("WORK.CANNOT_RETURN_SAFETY_CHECK_PKG.RECORD_RETURNER_T"); vcode_unit_t v0 = find_unit_for(tree_decl(body, 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "REC", .hops = 1 }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue125) { input_from_file(TESTDIR "/lower/issue125.vhd"); run_elab(); } END_TEST START_TEST(test_access_bug) { input_from_file(TESTDIR "/lower/access_bug.vhd"); run_elab(); } END_TEST START_TEST(test_issue149) { input_from_file(TESTDIR "/lower/issue149.vhd"); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SUB }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = -1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_STORE, .name = "I" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue158) { input_from_file(TESTDIR "/lower/issue158.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.CANNOT_RETURN_SAFETY_CHECK_PKG.FUN()S"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_NULL }, { VCODE_OP_STORE, .name = "VALUE" }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_INDEX, .name = "VALUE" }, { VCODE_OP_FCALL, .func = "WORK.CANNOT_RETURN_SAFETY_CHECK_PKG.PROC(" "46WORK.CANNOT_RETURN_SAFETY_CHECK_PKG.STRING_PTR)" }, { VCODE_OP_LOAD, .name = "VALUE" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_NULL_CHECK }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue167) { set_standard(STD_00); input_from_file(TESTDIR "/lower/issue167.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.E"); vcode_select_unit(v0); fail_unless(vtype_kind(2) == VCODE_TYPE_CONTEXT); fail_unless(vtype_kind(3) == VCODE_TYPE_CONTEXT); ident_t p1_name = vtype_name(2); fail_unless(icmp(p1_name, "WORK.PKG.P1")); // This used to get mangled with @
ident_t p2_name = vtype_name(3); fail_unless(icmp(p2_name, "WORK.E-A.P2")); } END_TEST START_TEST(test_issue164) { input_from_file(TESTDIR "/lower/issue164.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t v0 = find_unit_for(tree_decl(p, 0)); fail_unless(icmp(vcode_unit_name(v0), "WORK.ISSUE164.SAME_NAME(I)")); vcode_unit_t v1 = find_unit_for(tree_decl(p, 1)); fail_unless(icmp(vcode_unit_name(v1), "WORK.ISSUE164.SAME_NAME()I")); } END_TEST START_TEST(test_sigvar) { input_from_file(TESTDIR "/lower/sigvar.vhd"); tree_t e = run_elab(); { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); // Pointless block: index checks were elimintated EXPECT_BB(1) = { { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_UNWRAP }, { VCODE_OP_RESOLVED }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_RETURN } }; CHECK_BB(2); } { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 2)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_UNWRAP }, { VCODE_OP_RESOLVED }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_UNWRAP }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_RETURN } }; CHECK_BB(0); } } END_TEST START_TEST(test_issue181) { input_from_file(TESTDIR "/lower/issue181.vhd"); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); fail_unless(vcode_count_vars() == 2); EXPECT_BB(0) = { { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue203) { input_from_file(TESTDIR "/lower/issue203.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ISSUE203.MAIN.PROC"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.TEXTIO" }, { VCODE_OP_LINK_VAR, .name = "OUTPUT" }, { VCODE_OP_CONST, .value = 104 }, { VCODE_OP_CONST, .value = 101 }, { VCODE_OP_CONST, .value = 108 }, { VCODE_OP_CONST, .value = 111 }, { VCODE_OP_CONST_ARRAY, .length = 5 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 10 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_ALLOC }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_COPY }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_FILE_WRITE }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue215) { input_from_file(TESTDIR "/lower/issue215.vhd"); run_elab(); } END_TEST START_TEST(test_choice1) { input_from_file(TESTDIR "/lower/choice1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); unit_registry_t *ur = get_registry(); mir_context_t *mc = get_mir(); jit_t *jit = jit_new(ur, mc); cover_data_t *data = cover_data_init(COVER_MASK_BRANCH, 0, 0); rt_model_t *m = model_new(jit, NULL); elab(tree_to_object(a), jit, ur, mc, data, NULL, m); vcode_unit_t v0 = find_unit("WORK.CHOICE1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = -2147483648 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GEQ }, { VCODE_OP_CMP, .cmp = VCODE_CMP_LEQ }, { VCODE_OP_AND }, { VCODE_OP_COND, .target = 4, .target_else = 3 }, }; CHECK_BB(1); EXPECT_BB(3) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CASE }, }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_COVER_BRANCH, .tag = 0 }, { VCODE_OP_CONST, .value = -1 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(5); EXPECT_BB(6) = { { VCODE_OP_COVER_BRANCH, .tag = 1 }, { VCODE_OP_JUMP, .target = 5 } }; CHECK_BB(6); EXPECT_BB(7) = { { VCODE_OP_COVER_BRANCH, .tag = 2 }, { VCODE_OP_JUMP, .target = 5 } }; CHECK_BB(7); EXPECT_BB(8) = { { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(8); EXPECT_BB(9) = { { VCODE_OP_COVER_BRANCH, .tag = 3 }, { VCODE_OP_JUMP, .target = 8 } }; CHECK_BB(9); EXPECT_BB(12) = { { VCODE_OP_COVER_BRANCH, .tag = 6 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(12); model_free(m); jit_free(jit); } END_TEST START_TEST(test_tag) { input_from_file(TESTDIR "/lower/tag.vhd"); run_elab(); { vcode_unit_t v0 = find_unit("WORK.TAG"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.P" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t v1 = find_unit("WORK.P"); vcode_select_unit(v1); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_PACKAGE_SCOPE }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "S" }, { VCODE_OP_POP_SCOPE }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_iffold) { input_from_file(TESTDIR "/lower/iffold.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.IFFOLD.SUB_I.P1"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .name = "Y", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_JUMP, .target = 1 } }; CHECK_BB(1); } END_TEST START_TEST(test_real1) { input_from_file(TESTDIR "/lower/real1.vhd"); tree_t e = run_elab(); { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_NEG }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } { vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 2)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "Z" }, { VCODE_OP_CAST }, { VCODE_OP_CONST_REAL, .real = 0.5 }, { VCODE_OP_MUL }, { VCODE_OP_RETURN } }; CHECK_BB(0); } } END_TEST START_TEST(test_assert1) { input_from_file(TESTDIR "/lower/assert1.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ASSERT1.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_STORE, .name = "B" }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_thunk) { input_from_file(TESTDIR "/lower/thunk.vhd"); tree_t arch = parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH); unit_registry_t *ur = get_registry(); { vcode_unit_t t0 = lower_global_thunk(ur, tree_value(tree_decl(arch, 0))); fail_if(t0 == NULL); vcode_select_unit(t0); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.PACK" }, { VCODE_OP_LINK_VAR, .name = "C" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_NOT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); vcode_unit_unref(t0); } } END_TEST START_TEST(test_issue303) { input_from_file(TESTDIR "/lower/issue303.vhd"); run_elab(); } END_TEST START_TEST(test_dealloc) { input_from_file(TESTDIR "/lower/dealloc.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t v1 = find_unit_for(tree_decl(p, 1)); vcode_select_unit(v1); EXPECT_BB(0) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "WORK.PACK.ANOTHER_PROC(13WORK.PACK.PTR)" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue324) { input_from_file(TESTDIR "/lower/issue324.vhd"); run_elab(); } END_TEST START_TEST(test_issue333) { input_from_file(TESTDIR "/lower/issue333.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ISSUE333.MAIN"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 49 }, { VCODE_OP_CONST_ARRAY, .length = 1 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_COPY }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "L" }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_INDEX, .name = "L" }, { VCODE_OP_FCALL, .func = "*WORK.ISSUE333.PROC(" }, { VCODE_OP_CONST, .value = 50 }, { VCODE_OP_CONST_ARRAY, .length = 2 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_COPY }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "L" }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_issue338) { input_from_file(TESTDIR "/lower/issue338.vhd"); tree_t e = run_elab(); e = tree_stmt(e, 0); // Function f1 { vcode_unit_t vu = find_unit_for(tree_decl(e, 1)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_COND, .target = 1, .target_else = 2 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "WORK.P" }, { VCODE_OP_FCALL, .func = "WORK.P.F(B)B" }, { VCODE_OP_AND }, { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "*shortcircuit" }, { VCODE_OP_RETURN }, }; CHECK_BB(2); } // Function f2 { vcode_unit_t vu = find_unit_for(tree_decl(e, 2)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_AND }, { VCODE_OP_RETURN } }; CHECK_BB(0); } // Function f3 { vcode_unit_t vu = find_unit_for(tree_decl(e, 3)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_OR }, { VCODE_OP_AND }, { VCODE_OP_RETURN } }; CHECK_BB(0); } // Function f4 { vcode_unit_t vu = find_unit_for(tree_decl(e, 4)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } // Function f5 { vcode_unit_t vu = find_unit_for(tree_decl(e, 5)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.P" }, { VCODE_OP_FCALL, .func = "WORK.P.F(B)B" }, { VCODE_OP_NOT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } // Function f6 { vcode_unit_t vu = find_unit_for(tree_decl(e, 6)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "WORK.P" }, { VCODE_OP_FCALL, .func = "WORK.P.F(B)B" }, { VCODE_OP_OR }, { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "*shortcircuit" }, { VCODE_OP_RETURN }, }; CHECK_BB(2); } // Function f7 { vcode_unit_t vu = find_unit_for(tree_decl(e, 7)); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_NOT }, { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "WORK.P" }, { VCODE_OP_FCALL, .func = "WORK.P.F(B)B" }, { VCODE_OP_NOR }, { VCODE_OP_STORE, .name = "*shortcircuit" }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "*shortcircuit" }, { VCODE_OP_RETURN }, }; CHECK_BB(2); } } END_TEST START_TEST(test_issue338b) { input_from_file(TESTDIR "/lower/issue338b.vhd"); tree_t e = run_elab(); vcode_unit_t v0 = find_unit_for(tree_decl(tree_stmt(e, 0), 1)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_CONST_ARRAY, .length = 0 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "STD.STANDARD.\"=\"(SS)B$predef" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue347) { input_from_file(TESTDIR "/lower/issue347.vhd"); run_elab(); } END_TEST START_TEST(test_hintbug) { input_from_file(TESTDIR "/lower/hintbug.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.HINTBUG.P1"); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_FCALL, .func = "WORK.HINTBUG.FUNC(J)Q" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ALLOC }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL , .func = "STD.STANDARD.\"=\"(QQ)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 } }; CHECK_BB(1); } END_TEST START_TEST(test_issue351) { input_from_file(TESTDIR "/lower/issue351.vhd"); run_elab(); vcode_unit_t v0 = find_unit("WORK.ISSUE351.P1"); vcode_select_unit(v0); EXPECT_BB(4) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_LOAD, .name = "I.LOOP1" }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INDEX, .name = "CURR_QUEUE" }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "*WORK.ISSUE351.DUMP_WORDS" }, { VCODE_OP_LOAD, .name = "*right" }, { VCODE_OP_LOAD, .name = "*step" }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "I.LOOP1" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 3, .target_else = 4 }, }; CHECK_BB(4); } END_TEST START_TEST(test_tounsigned) { input_from_file(TESTDIR "/lower/tounsigned.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t v0 = find_unit_for(tree_decl(p, 0)); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SUB }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "RESULT" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = INT32_MAX }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_JUMP, .target = 2 } }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_STORE, .name = "I_VAL" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SUB }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_COND, .target = 4, .target_else = 3 }, }; CHECK_BB(2); EXPECT_BB(3) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_STORE, .name = "I.MAINLOOP" }, { VCODE_OP_JUMP, .target = 5 } }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_LOAD, .name = "RESULT" }, { VCODE_OP_RETURN } }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_LOAD, .name = "I.MAINLOOP" }, { VCODE_OP_LOAD, .name = "I_VAL" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_REM }, // Optimised from mod { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 6, .target_else = 7 } }; CHECK_BB(5); EXPECT_BB(6) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_LOAD, .name = "RESULT" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_JUMP, .target = 8 }, }; CHECK_BB(6); EXPECT_BB(7) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_LOAD, .name = "RESULT" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_JUMP, .target = 8 } }; CHECK_BB(7); EXPECT_BB(8) = { { VCODE_OP_LOAD, .name = "I_VAL" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DIV }, { VCODE_OP_STORE, .name = "I_VAL" }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "I.MAINLOOP" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 4, .target_else = 5 } }; CHECK_BB(8); } END_TEST START_TEST(test_issue357) { input_from_file(TESTDIR "/lower/issue357.vhd"); run_elab(); } END_TEST START_TEST(test_signal11) { input_from_file(TESTDIR "/lower/signal11.vhd"); run_elab(); vcode_unit_t vpack = find_unit("WORK.PACK"); fail_if(vpack == NULL); vcode_select_unit(vpack); fail_unless(vcode_count_vars() == 1); fail_unless(vcode_var_name(0) == ident_new("X")); } END_TEST START_TEST(test_access1) { input_from_file(TESTDIR "/lower/access1.vhd"); tree_t e = run_elab(); tree_t d = get_decl(tree_stmt(e, 0), "LIST_ADD"); vcode_unit_t v0 = find_unit_for(d); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_NULL }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_CAST }, { VCODE_OP_STORE, .name = "N" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_NULL_CHECK }, // Redundant, optimisation prevented by cast { VCODE_OP_CAST }, { VCODE_OP_ALL }, // Redundant, optimisation prevented by cast { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_sum) { input_from_file(TESTDIR "/lower/sum.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "SUM"); fail_unless(tree_kind(f) == T_FUNC_BODY); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "RESULT" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 2, .target_else = 1 } }; CHECK_BB(0); EXPECT_BB(3) = { { VCODE_OP_LOAD, .name = "I.SUMLOOP" }, { VCODE_OP_LOAD, .name = "RESULT" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_STORE, .name = "RESULT" }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "I.SUMLOOP" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 2, .target_else = 3 } }; CHECK_BB(3); } END_TEST START_TEST(test_extern1) { input_from_file(TESTDIR "/lower/extern1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = tree_decl(p, 0); fail_unless(tree_kind(f) == T_FUNC_BODY); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "MATH_CZERO" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_synopsys1) { input_from_file(TESTDIR "/lower/synopsys1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "WRITE"); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "S" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = INT32_MAX }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "M" }, { VCODE_OP_UNWRAP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 4, .target_else = 3 } }; CHECK_BB(2); } END_TEST START_TEST(test_access2) { input_from_file(TESTDIR "/lower/access2.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "GET_FRESH"); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_vital1) { input_from_file(TESTDIR "/lower/vital1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "VITALSETUPHOLDCHECK"); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = -1 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SELECT }, { VCODE_OP_STORE, .name = "*right" }, { VCODE_OP_STORE, .name = "*step" }, { VCODE_OP_STORE, .name = "I.L1" }, { VCODE_OP_JUMP, .target = 3 } }; CHECK_BB(1); EXPECT_BB(4) = { { VCODE_OP_RESUME, .func = "WORK.VITAL_TIMING.PROC(22WORK.VITAL_TIMING.LINEI)" }, { VCODE_OP_LOAD, .name = "*right" }, { VCODE_OP_LOAD, .name = "*step" }, { VCODE_OP_LOAD, .name = "I.L1" }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "I.L1" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 2, .target_else = 3 } }; CHECK_BB(4); } END_TEST START_TEST(test_case1) { input_from_file(TESTDIR "/lower/case1.vhd"); tree_t e = run_elab(); tree_t s = tree_stmt(tree_stmt(tree_stmt(e, 0), 0), 0); fail_unless(tree_kind(s) == T_CASE); vcode_unit_t v0 = find_unit("WORK.CASE7.TESTP"); vcode_select_unit(v0); fail_unless(vcode_count_vars() == 2); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "*enc" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "*i" }, { VCODE_OP_JUMP, .target = 3 }, }; CHECK_BB(1); EXPECT_BB(4) = { { VCODE_OP_LOAD, .name = "*enc" }, { VCODE_OP_CONST, .value = 0x10 }, { VCODE_OP_CONST, .value = 0x18 }, { VCODE_OP_CONST, .value = 0x22 }, { VCODE_OP_CONST, .value = 0x13 }, { VCODE_OP_CASE }, }; CHECK_BB(4); } END_TEST START_TEST(test_incomplete) { input_from_file(TESTDIR "/lower/incomplete.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); vcode_unit_t v0 = find_unit("WORK.P"); vcode_select_unit(v0); fail_unless(vcode_count_vars() == 2); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_STORE, .name = "C" }, { VCODE_OP_STORE, .name = "CP" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue389) { input_from_file(TESTDIR "/lower/issue389.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); bounds_check(p); fail_if(error_count() > 0); vcode_unit_t v0 = find_unit("WORK.COMMON"); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_INDEX, .name = "EXAMPLE_INIT" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 64 }, { VCODE_OP_CONST_ARRAY, .length = 32 }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_const1) { input_from_file(TESTDIR "/lower/const1.vhd"); tree_t b = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(b); fail_if(error_count() > 0); { vcode_unit_t v1 = find_unit("WORK.ISSUEH"); vcode_select_unit(v1); fail_unless(vcode_count_vars() == 1); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "C" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_const2) { input_from_file(TESTDIR "/lower/const2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.CONST2"); vcode_select_unit(vu); fail_unless(vcode_count_vars() == 1); vcode_type_t v0_type = vcode_var_type(0); fail_unless(vtype_kind(v0_type) == VCODE_TYPE_UARRAY); fail_unless(vtype_kind(vtype_elem(v0_type)) == VCODE_TYPE_SIGNAL); fail_unless(vcode_var_flags(0) & VAR_SIGNAL); } END_TEST START_TEST(test_vital2) { input_from_file(TESTDIR "/lower/vital2.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "VITALSETUPHOLDCHECK"); vcode_unit_t v0 = find_unit(istr(tree_ident2(f))); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_RECORD_REF, .field = 8 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_NULL_CHECK }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, // TODO: redundant { VCODE_OP_INDEX_CHECK }, // TODO: redundant { VCODE_OP_STORE, .name = "*i" }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 4, .target_else = 3 }, }; CHECK_BB(1); } END_TEST START_TEST(test_conv1) { input_from_file(TESTDIR "/lower/conv1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "GET"); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_NEG }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CAST }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_resfn1) { input_from_file(TESTDIR "/lower/resfn1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.RESFN1"); vcode_select_unit(vu); // Should only be one call to resolution wrapper EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_CLOSURE, .func = "WORK.RESFN1.RBIT$resolution" }, { VCODE_OP_RESOLUTION_WRAPPER }, { VCODE_OP_STORE, .name = "WORK.RESFN1.RBIT$resolution" }, { VCODE_OP_INDEX, .name = "WORK.RESFN1.RBIT$resolution" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_RESOLVE_SIGNAL }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_RESOLVE_SIGNAL }, { VCODE_OP_STORE, .name = "Y" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_issue426) { input_from_file(TESTDIR "/lower/issue426.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.TEST_1_1.U.TEST_1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "WORK.CORE" }, { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_INDEX, .name = "EXP_STATUS" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "EXP_STATUS" }, { VCODE_OP_COPY }, { VCODE_OP_RETURN } }; CHECK_BB(0); } END_TEST START_TEST(test_instance1) { input_from_file(TESTDIR "/lower/instance1.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.INSTANCE1.SUB_I"); vcode_select_unit(vu); fail_unless(vcode_unit_kind(vu) == VCODE_UNIT_INSTANCE); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_STORE, .name = "WIDTH" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 5 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_MAP_CONST }, { VCODE_OP_RETURN } }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.INSTANCE1.SUB_I.SUB"); vcode_select_unit(vu); fail_unless(vcode_unit_kind(vu) == VCODE_UNIT_INSTANCE); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_STORE, .name = "WIDTH" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_UNWRAP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_RETURN } }; CHECK_BB(0); } } END_TEST START_TEST(test_sig2var) { input_from_file(TESTDIR "/lower/sig2var.vhd"); run_elab(); { vcode_unit_t vfoo = find_unit("WORK.SIG2VAR.FOO(sQ)Q"); vcode_select_unit(vfoo); fail_unless(vcode_count_vars() == 1); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_UNWRAP }, { VCODE_OP_RESOLVED }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CAST }, { VCODE_OP_CAST }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); } { vcode_unit_t vbar = find_unit("WORK.SIG2VAR.BAR(sJ)J"); vcode_select_unit(vbar); fail_unless(vcode_count_vars() == 1); EXPECT_BB(0) = { { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_STORE, .name = "V" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_protupref) { set_standard(STD_08); input_from_file(TESTDIR "/lower/protupref.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); (void)find_unit("WORK.ALERTLOGPKG.ALERTLOGSTRUCTPTYPE"); vcode_unit_t vu = find_unit( "WORK.ALERTLOGPKG.ALERTLOGSTRUCTPTYPE.ALERT(" "31WORK.ALERTLOGPKG.ALERTLOGIDTYPES26WORK.ALERTLOGPKG.ALERTTYPE)"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_VAR_UPREF, .name = "ALERT_NAME", .hops = 2 }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_MUL }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_REPORT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_closefile) { input_from_file(TESTDIR "/lower/closefile.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.FILEPACK.TEST"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_NULL }, { VCODE_OP_STORE, .name = "F" }, { VCODE_OP_CONST, .value = 'f' }, { VCODE_OP_CONST_ARRAY, .length = 1 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_INDEX, .name = "F" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_FILE_OPEN }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.FILEPACK.TEST.FILE_CLOSE(" "23WORK.FILEPACK.TEST.TEXT)$predef" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_record2) { input_from_file(TESTDIR "/lower/record2.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.RECORD2.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.RECORD2.P2"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.RECORD2.P3"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } } END_TEST START_TEST(test_array2) { set_standard(STD_08); input_from_file(TESTDIR "/lower/array2.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.ARRAY2.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P2"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P3"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P4"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "*i" }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "*i" }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "*i" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD, .name = "Y" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 3, .target_else = 2 }, }; CHECK_BB(2); EXPECT_BB(3) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ARRAY_REF, .value = 0 }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_ARRAY_REF, .value = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 4 }, }; CHECK_BB(3); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P5"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P6"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "S", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INDEX, .name = "*tmp" }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P7"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P8"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_LOAD, .name = "X" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.ARRAY2.P9"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.ARRAY2.P9.F()24WORK.ARRAY2-TEST.INT_VEC" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ADD }, { VCODE_OP_SUB }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CAST }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_COPY }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_JUMP, .target = 1 }, }; CHECK_BB(1); } } END_TEST START_TEST(test_concat) { input_from_file(TESTDIR "/lower/concat.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.CONCAT.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_COPY }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.CONCAT.P2"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "S", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST, .value = 6 }, { VCODE_OP_CONST_ARRAY, .length = 3 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } } END_TEST START_TEST(test_nullarray) { input_from_file(TESTDIR "/lower/nullarray.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.NULLARRAY"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.NULLARRAY.GET_BITS()Q" }, { VCODE_OP_UNWRAP }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ALLOC }, { VCODE_OP_COPY }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "A" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_osvvm2) { input_from_file(TESTDIR "/lower/osvvm2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.OSVVM2.TEST(N)"); vcode_select_unit(vu); EXPECT_BB(2) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_COPY }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "FIELDNAME" }, { VCODE_OP_RETURN }, }; CHECK_BB(2); } END_TEST START_TEST(test_issue444) { input_from_file(TESTDIR "/lower/issue444.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu1 = find_unit("WORK.ISSUE444.PROC(I)"); vcode_select_unit(vu1); ck_assert_int_eq(vcode_count_vars(), 2); fail_unless(vcode_var_flags(1) & VAR_TEMP); vcode_unit_t vu2 = find_unit("WORK.ISSUE444.PROC(I).T$value"); vcode_select_unit(vu2); ck_assert_int_eq(vcode_count_vars(), 1); fail_unless(vcode_var_flags(0) & VAR_TEMP); fail_if_errors(); } END_TEST START_TEST(test_vunit1) { set_standard(STD_02); input_from_file(TESTDIR "/lower/vunit1.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); (void)find_unit("WORK.STRING_PTR_PKG.PROT_STORAGE_T"); vcode_unit_t vu = find_unit("WORK.STRING_PTR_PKG.PROT_STORAGE_T.SET(NPC)"); vcode_select_unit(vu); EXPECT_BB(3) = { { VCODE_OP_VAR_UPREF, .name = "ST", .hops = 1 }, { VCODE_OP_RECORD_REF, .field = 5 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_NULL_CHECK }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_INDEX, .name = "S" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_NULL_CHECK }, { VCODE_OP_ALL }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SUB }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_JUMP, .target = 1 }, }; CHECK_BB(3); fail_if_errors(); } END_TEST START_TEST(test_vunit2) { input_from_file(TESTDIR "/lower/vunit2.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit( "WORK.VUNIT2.GET_ONE(N)19WORK.VUNIT2.INT_PTR"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "A" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_vunit3) { input_from_file(TESTDIR "/lower/vunit3.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.VUNIT3.ALLOC_REG()19WORK.VUNIT3.REC_PTR"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_CAST }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_vunit4) { input_from_file(TESTDIR "/lower/vunit4.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.VUNIT4.GET_REC(N)15WORK.VUNIT4.REC"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_INDEX, .name = "record" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_directmap) { input_from_file(TESTDIR "/lower/directmap.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.DIRECTMAP.UUT"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "Y" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_STORE, .name = "I" }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = INT32_MIN }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "O" }, { VCODE_OP_MAP_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_directmap2) { input_from_file(TESTDIR "/lower/directmap2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.DIRECTMAP2.UUT"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "WORK.DIRECTMAP2_PACK" }, { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "P" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "Q" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "I" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 2 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_recsignal1) { input_from_file(TESTDIR "/lower/recsignal1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.RECSIGNAL1.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "P" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "Q" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_vunit5) { set_standard(STD_08); input_from_file(TESTDIR "/lower/vunit5.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.VUNIT5.PROC(Q)"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SUB }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_UNWRAP }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_issue462) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue462.vhd"); run_elab(); vcode_unit_t vu = find_unit( "WORK.ISSUE462.GET(24WORK.ISSUE462-TEST.MEM_TNN)J"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_MUL }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_CAST }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_directmap3) { input_from_file(TESTDIR "/lower/directmap3.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.DIRECTMAP3.U"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_STORE, .name = "W" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "O1" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "O2" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "P" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "O" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_MAP_SIGNAL }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_MAP_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_issue476) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue476.vhd"); parse_check_and_simplify(T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_issue478) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue478.vhd"); parse_check_and_simplify(T_PACKAGE); vcode_unit_t vu = find_unit("WORK.TEST_PKG"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_genpack1) { set_standard(STD_08); input_from_file(TESTDIR "/lower/genpack1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.GENPACK1.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.P5" }, { VCODE_OP_FCALL, .func = "WORK.P5.T$image" }, { VCODE_OP_CONST, .value = 97 }, { VCODE_OP_CONST_ARRAY, .length = 1 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "STD.STANDARD.\"=\"(SS)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_predef1) { input_from_file(TESTDIR "/lower/predef1.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.PREDEF1.F(III)I"); vcode_select_unit(vu); // The type declaration creates nested subprograms EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "A_WIDTH" }, { VCODE_OP_STORE, .name = "B_WIDTH" }, { VCODE_OP_STORE, .name = "DEPTH" }, { VCODE_OP_NULL }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_SUB }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_SUB }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "WORK.PREDEF1-TEST.F(III)I.A" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.PREDEF1.U2.B1.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_NULL }, { VCODE_OP_INDEX, .name = "V" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_FCALL, .func = "WORK.SUB-TEST.B1.\"=\"(" "22WORK.SUB-TEST.B1.T_REC22WORK.SUB-TEST.B1.T_REC)B$predef" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2}, }; CHECK_BB(1); } fail_if_errors(); } END_TEST START_TEST(test_signal5) { input_from_file(TESTDIR "/lower/signal5.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.SIGNAL5.P1"); vcode_select_unit(vu); // The type declaration creates nested subprograms EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "S", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_bigarray) { input_from_file(TESTDIR "/lower/bigarray.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.BIGARRAY.GET_ARRAY()21WORK.BIGARRAY.INT_VEC"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1048576 }, { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 1048576 }, { VCODE_OP_WRAP }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue582) { input_from_file(TESTDIR "/lower/issue582.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); mir_context_t *mc = get_mir(); unit_registry_t *ur = unit_registry_new(mc); jit_t *jit = jit_new(ur, mc); cover_data_t *data = cover_data_init(COVER_MASK_ALL, 0, 0); rt_model_t *m = model_new(jit, NULL); elab(tree_to_object(a), jit, ur, mc, data, NULL, m); model_free(m); jit_free(jit); unit_registry_free(ur); fail_if_errors(); } END_TEST START_TEST(test_issue591) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue591.vhd"); run_elab(); fail_if_errors(); } END_TEST START_TEST(test_case2) { input_from_file(TESTDIR "/lower/case2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.CASE2.U.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "O", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 99 }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); fail_if_errors(); } END_TEST START_TEST(test_issue613) { input_from_file(TESTDIR "/lower/issue613.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE613.U"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK" }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_FCALL, .func = "WORK.PACK.GET_BITS(N)Q" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_UARRAY_LEN, .dim = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "Q" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_MAP_CONST }, { VCODE_OP_UNWRAP }, { VCODE_OP_MAP_CONST }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_wait2) { input_from_file(TESTDIR "/lower/wait2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.WAIT2.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "R" }, { VCODE_OP_RECORD_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "R" }, { VCODE_OP_RECORD_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CLEAR_EVENT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_EVENT }, { VCODE_OP_AND }, { VCODE_OP_COND, .target = 3, .target_else = 4 }, }; CHECK_BB(2); } END_TEST START_TEST(test_link1) { input_from_file(TESTDIR "/lower/link1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.LINK1.U.SUB"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.PACK" }, { VCODE_OP_LINK_VAR, .name = "K" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_STORE, .name = "C" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_driver1) { input_from_file(TESTDIR "/lower/driver1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.DRIVER1.U.P1"); vcode_select_unit(vu); EXPECT_BB(3) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_VAR_UPREF, .name = "R", .hops = 1 }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(3); } END_TEST START_TEST(test_attr2) { set_standard(STD_08); input_from_file(TESTDIR "/lower/attr2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ATTR2"); vcode_select_unit(vu); EXPECT_BB(3) = { { VCODE_OP_POP_SCOPE }, { VCODE_OP_LOAD, .name = "R" }, { VCODE_OP_LOAD, .name = "K" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_RECORD_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_CAST }, { VCODE_OP_STORE, .name = "L" }, { VCODE_OP_RETURN }, }; CHECK_BB(3); } END_TEST START_TEST(test_copy1) { input_from_file(TESTDIR "/lower/copy1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); bounds_check(p); fail_if(error_count() > 0); tree_t f = get_decl(p, "TEST_COPY"); vcode_unit_t v0 = find_unit_for(f); vcode_select_unit(v0); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 4096 }, { VCODE_OP_INDEX, .name = "SRC" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_INDEX, .name = "DEST" }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 100 }, { VCODE_OP_JUMP, .target = 1 }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue662) { input_from_file(TESTDIR "/lower/issue662.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.SUB.CMP"); vcode_select_unit(vu); vcode_type_t vt = vtype_find_named_record(ident_new("WORK.TEST_PKG.T1$")); fail_if(vt == VCODE_INVALID_TYPE); fail_if_errors(); } END_TEST START_TEST(test_event1) { set_standard(STD_08); input_from_file(TESTDIR "/lower/event1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.EVENT1.DO_WAIT(s20WORK.EVENT1-TEST.REC)"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "S" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_WAIT, .target = 1 }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue725) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue725.vhd"); parse_check_and_simplify(T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_cond2) { set_standard(STD_19); input_from_file(TESTDIR "/lower/cond2.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); vcode_unit_t vu = find_unit("WORK.COND2.DUMMY_LOOP(Q)"); vcode_select_unit(vu); EXPECT_BB(3) = { { VCODE_OP_LOAD, .name = "I._L0" }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 4, .target_else = 5 }, }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_RETURN }, }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_RETURN }, }; CHECK_BB(5); fail_if_errors(); } END_TEST START_TEST(test_protpcall) { set_standard(STD_02); input_from_file(TESTDIR "/lower/protpcall.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.PROTECTED11.PT.PROC"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "COUNT", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_FCALL, .func = "WORK.PROTECTED11.PT.PROC(I)" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.PROTECTED11.PT.PROC(I)"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "COUNT", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_TRAP_ADD }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONTEXT_UPREF, .hops = 2 }, { VCODE_OP_FCALL, .func = "WORK.PROTECTED11.DO_SOMETHING" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } fail_if_errors(); } END_TEST START_TEST(test_assert2) { input_from_file(TESTDIR "/lower/assert2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ASSERT2.TEST(IS)"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP, .cmp = VCODE_CMP_GT }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue756) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue756.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE756.TB"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "WORK.ISSUE756.GET_SIZE()I" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_MUL }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_STORE, .name = "PTR" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_const3) { input_from_file(TESTDIR "/lower/const3.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.CONST3.P1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "*GET_REALS" }, { VCODE_OP_UNWRAP }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ALLOC }, { VCODE_OP_COPY }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "C1" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_CONST_REAL, .real = 0.0 }, { VCODE_OP_CONST_REAL, .real = 1.0 }, { VCODE_OP_CONST_ARRAY, .length = 5 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "C2" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_transfer1) { input_from_file(TESTDIR "/lower/transfer1.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.TRANSFER1.P1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "A" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "B" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_TRANSFER_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.TRANSFER1.P2"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "D" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "E" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_TRANSFER_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.TRANSFER1.P3"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "E" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "F" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.TRANSFER1.P4"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "D" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "E" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 5000000 }, { VCODE_OP_CONST, .value = 2000000 }, { VCODE_OP_TRANSFER_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_subtype1) { input_from_file(TESTDIR "/lower/subtype1.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.SUBTYPE1.GET_BV(N)Q"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_STORE, .name = "R" }, { VCODE_OP_NULL }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "WORK.SUBTYPE1-TEST.GET_BV(N)Q.T_RESULT" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "WORK.SUBTYPE1.GET_BV(N)Q.HELPER()Q" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.SUBTYPE1.GET_BV(N)Q.HELPER()Q"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "WORK.SUBTYPE1-TEST.GET_BV(N)Q.T_RESULT" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ALLOC }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_MEMSET }, { VCODE_OP_CAST }, { VCODE_OP_CAST }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_COND, .target = 2, .target_else = 1 }, }; CHECK_BB(0); } } END_TEST START_TEST(test_alias1) { input_from_file(TESTDIR "/lower/alias1.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ALIAS1.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK" }, { VCODE_OP_LINK_VAR, .name = "A" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 2 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ASSERT }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_issue768) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue768.vhd"); parse_check_and_simplify(T_PACKAGE); unit_registry_t *ur = get_registry(); vcode_unit_t vu = unit_registry_get(ur, ident_new("WORK.ISSUE768")); fail_if(vu == NULL); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "C_HDLC_CODEC" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST_ARRAY, .length = 8 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_WRAP }, { VCODE_OP_CONST_ARRAY, .length = 8 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_WRAP }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_proc4) { input_from_file(TESTDIR "/lower/proc4.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.PROC4.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK" }, { VCODE_OP_FCALL, .func = "WORK.PACK.DOES_NOT_WAIT" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_issue791) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue791.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE791.READ_MEM"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1048576 }, { VCODE_OP_INDEX, .name = "V_MEMORY" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 64 }, { VCODE_OP_INDEX, .name = "V_MEMORY2" }, { VCODE_OP_CONST_ARRAY, .length = 64 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_osvvm3) { input_from_file(TESTDIR "/lower/osvvm3.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.OSVVM3.B1.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_FCALL, .func = "*PROC" }, { VCODE_OP_VAR_UPREF, .name = "T", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_FCALL, .func = "*PROC" }, { VCODE_OP_WAIT, .target = 4 }, }; CHECK_BB(1); } END_TEST START_TEST(test_bounds2) { input_from_file(TESTDIR "/lower/bounds2.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.BOUNDS2.P"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "VID_DATA_IN", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 24 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST_ARRAY, .length = 12 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 12 }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_subtype2) { input_from_file(TESTDIR "/lower/subtype2.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.PACK2"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.PACK1" }, { VCODE_OP_NULL }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_FCALL, .func = "WORK.PACK1.EXPENSIVE(I)I" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "WORK.PACK2.T_SUB1" }, { VCODE_OP_INDEX, .name = "WORK.PACK2.T_REC" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_MEMSET }, { VCODE_OP_FCALL, .func = "WORK.PACK1.EXPENSIVE(I)I" }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_FCALL, .func = "WORK.PACK1.EXPENSIVE(I)I" }, { VCODE_OP_NULL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "WORK.PACK2.T_INTEGER" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.SUBTYPE2.B1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 5 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK2" }, { VCODE_OP_LINK_VAR, .name = "WORK.PACK2.T_SUB1" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_MAP_CONST }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.SUBTYPE2.P1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK2" }, { VCODE_OP_LINK_VAR, .name = "WORK.PACK2.T_SUB1" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_UARRAY_LEN}, { VCODE_OP_MUL }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "A" }, { VCODE_OP_MEMSET }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.SUBTYPE2.P2"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_LINK_PACKAGE, .name = "WORK.PACK2" }, { VCODE_OP_LINK_VAR, .name = "WORK.PACK2.T_INTEGER" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_STORE, .name = "X" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_directmap5) { input_from_file(TESTDIR "/lower/directmap5.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.DIRECTMAP5.B"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FCALL, .func = "WORK.DIRECTMAP5.GET_VALUE()N" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "T" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue837) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue837.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE837.B"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.PACK" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "STR" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_FCALL, .func = "WORK.PACK.EXPENSIVE(S)I" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_CONST, .value = 12 }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "S" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_directmap6) { input_from_file(TESTDIR "/lower/directmap6.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.DIRECTMAP6.U"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "Y" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_STORE, .name = "I" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "O" }, { VCODE_OP_MAP_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.DIRECTMAP6.U.SUB"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "I" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "O" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_ALIAS_SIGNAL }, { VCODE_OP_STORE, .name = "II" }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "OO" }, { VCODE_OP_MAP_SIGNAL }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_issue844) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue844.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE844.U"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_STORE, .name = "G1" }, { VCODE_OP_STORE, .name = "G2" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 4 }, // TODO: just pass a scalar init value { VCODE_OP_ALLOC }, { VCODE_OP_MEMSET }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_WRAP }, { VCODE_OP_STORE, .name = "P" }, { VCODE_OP_MAP_CONST }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_trigger1) { input_from_file(TESTDIR "/lower/trigger1.vhd"); run_elab(); { vcode_unit_t vu = find_unit("WORK.TRIGGER1.P1"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .name = "CLK", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FUNCTION_TRIGGER, .func = "WORK.TRIGGER1.RISING(sJ)B" }, { VCODE_OP_ADD_TRIGGER }, { VCODE_OP_RETURN }, }; CHECK_BB(0); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_NOT }, { VCODE_OP_SCHED_WAVEFORM }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } { vcode_unit_t vu = find_unit("WORK.TRIGGER1.P2"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "X", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .name = "CLK", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.TRIGGER1.P3"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "Y", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .name = "RSTN", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_VAR_UPREF, .name = "CLK", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CMP_TRIGGER }, { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_FUNCTION_TRIGGER, .func = "WORK.TRIGGER1.RISING(sJ)B" }, { VCODE_OP_OR_TRIGGER }, { VCODE_OP_ADD_TRIGGER }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } { vcode_unit_t vu = find_unit("WORK.TRIGGER1.P4"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_VAR_UPREF, .name = "Z", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DRIVE_SIGNAL }, { VCODE_OP_VAR_UPREF, .name = "CLK", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_SCHED_EVENT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CMP_TRIGGER }, { VCODE_OP_ADD_TRIGGER }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } } END_TEST START_TEST(test_issue859) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue859.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE859.I_MODEL"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "WORK.MODEL_PKG" }, { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "AXILITE_IF_2" }, { VCODE_OP_RECORD_REF, .field = 3 }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 4 }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_INDEX, .name = "RD_PORT_IN" }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 2 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue934) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue934.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE934.CHECK"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST_ARRAY, .length = 16 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 7 }, { VCODE_OP_WRAP }, { VCODE_OP_FCALL, .func = "*PROC" }, { VCODE_OP_WAIT, .target = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_issue972) { input_from_file(TESTDIR "/lower/issue972.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE972.B"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_INDEX, .name = "R" }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_CONST_RECORD }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_COPY }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_RECORD_REF, .field = 0 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_RANGE_CHECK }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_INIT_SIGNAL }, { VCODE_OP_STORE, .name = "S" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue1029) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1029.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE1029.CALL"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONTEXT_UPREF, .hops = 1 }, { VCODE_OP_INDEX, .name = "S.ename" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_NULL }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 4, .target_else = 5 }, }; CHECK_BB(1); EXPECT_BB(4) = { { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_BIND_EXTERNAL }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_JUMP, .target = 5 }, }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_PCALL, .func = "WORK.ISSUE1029.P(sJ)", .target = 6 }, }; CHECK_BB(5); } END_TEST START_TEST(test_issue1080) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1080.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE1080.U.P"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_VAR_UPREF, .hops = 1, .name = "S1" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_CAST }, { VCODE_OP_SUB }, { VCODE_OP_SUB }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_SELECT }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_LEN, .dim = 1 }, { VCODE_OP_MUL }, { VCODE_OP_UNWRAP }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_UARRAY_LEFT, .dim = 1 }, { VCODE_OP_UARRAY_RIGHT, .dim = 1 }, { VCODE_OP_UARRAY_DIR, .dim = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_VAR_UPREF, .hops = 2, .name = "S2" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_WRAP }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "O" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UARRAY_LEFT, .dim = 0 }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_RIGHT, .dim = 0 }, { VCODE_OP_CAST }, { VCODE_OP_UARRAY_DIR, .dim = 0 }, { VCODE_OP_RANGE_NULL }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_COND, .target = 3, .target_else = 2 }, }; CHECK_BB(1); } END_TEST START_TEST(test_genpack2) { set_standard(STD_08); input_from_file(TESTDIR "/lower/genpack2.vhd"); parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_PACKAGE); unit_registry_t *ur = get_registry(); vcode_unit_t vu = unit_registry_get(ur, ident_new("WORK.TEST")); fail_if(vu == NULL); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.PACK1" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.TEST.INST" }, { VCODE_OP_STORE, .name = "WORK.TEST.INST" }, { VCODE_OP_LINK_VAR, .name = "G" }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_STORE, .name = "C" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue1155) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1155.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.TEST.B"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_STORE, .name = "IN_LANES" }, { VCODE_OP_CONST, .value = 16 }, { VCODE_OP_STORE, .name = "IN_WIDTH" }, { VCODE_OP_VAR_UPREF, .name = "SOMEARR", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .name = "VALID", .hops = 1 }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_INDEX, .name = "DATAIN" }, { VCODE_OP_RECORD_REF }, { VCODE_OP_UARRAY_LEFT }, { VCODE_OP_UARRAY_RIGHT }, { VCODE_OP_UARRAY_DIR }, { VCODE_OP_CONST, .value = 15 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_UNWRAP }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RECORD_REF, .field = 1 }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_RETURN }, }; CHECK_BB(0); } END_TEST START_TEST(test_issue1191) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1191.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.TEST"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_PACKAGE_INIT, .name = "WORK.TEST.TEST_PKG_INST" }, { VCODE_OP_STORE, .name = "WORK.TEST.TEST_PKG_INST" }, { VCODE_OP_NULL }, { VCODE_OP_PROTECTED_INIT, .name = "WORK.TEST-SIM.TEST_PKG_INST.T_TEST" }, { VCODE_OP_STORE, .name = "S_TEST_PKG_INST" }, { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_issue1194) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1194.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); jit_t *jit = get_jit(); cover_data_t *data = cover_data_init(COVER_MASK_EXPRESSION, 0, 0); rt_model_t *m = model_new(jit, NULL); elab(tree_to_object(a), jit, get_registry(), get_mir(), data, NULL, m); vcode_unit_t vu = find_unit("WORK.ISSUE1194.B.P_actual"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_VAR_UPREF, .hops = 2, .name = "X" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_VAR_UPREF, .hops = 2, .name = "Y" }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_RESOLVED }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_OR }, { VCODE_OP_NOT }, { VCODE_OP_NOT }, { VCODE_OP_AND }, { VCODE_OP_COND, .target = 3, .target_else = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_AND }, { VCODE_OP_COND, .target = 5, .target_else = 4 }, }; CHECK_BB(2); EXPECT_BB(3) = { { VCODE_OP_COVER_EXPR, .tag = 0 }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(3); EXPECT_BB(4) = { { VCODE_OP_AND }, { VCODE_OP_COND, .target = 7, .target_else = 6 }, }; CHECK_BB(4); EXPECT_BB(5) = { { VCODE_OP_COVER_EXPR, .tag = 1 }, { VCODE_OP_JUMP, .target = 4 }, }; CHECK_BB(5); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_issue1196) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1196.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE1196.P1"); vcode_select_unit(vu); EXPECT_BB(1) = { { VCODE_OP_CONST, .value = INT32_MAX + INT64_C(1) }, { VCODE_OP_NEW }, { VCODE_OP_ALL }, { VCODE_OP_LOAD_INDIRECT }, { VCODE_OP_UNWRAP }, { VCODE_OP_NULL }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "i" }, { VCODE_OP_JUMP, .target = 2 }, }; CHECK_BB(1); EXPECT_BB(2) = { { VCODE_OP_LOAD, .name = "i" }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_ADD }, { VCODE_OP_STORE, .name = "i" }, { VCODE_OP_CMP, .cmp = VCODE_CMP_EQ }, { VCODE_OP_COND, .target = 3, .target_else = 2 }, }; CHECK_BB(2); fail_if_errors(); } END_TEST START_TEST(test_issue1199) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1199.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.NVC_BUG"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_CONST, .value = 3 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CONST, .value = 8 }, { VCODE_OP_CONST, .value = 24 }, { VCODE_OP_INDEX, .name = "C_CONSTANT" }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST_ARRAY, .length = 8 }, { VCODE_OP_ADDRESS_OF }, { VCODE_OP_CONTEXT_UPREF, .hops = 0 }, { VCODE_OP_FCALL, .func = "*GET_SLV_ARRAY" }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_ADD }, { VCODE_OP_SUB }, // TODO: this calculation is redundant { VCODE_OP_CAST }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_RANGE_LENGTH }, { VCODE_OP_MUL }, { VCODE_OP_ALLOC }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_COPY }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_CAST }, { VCODE_OP_SUB }, { VCODE_OP_ADD }, // TODO: also redundant { VCODE_OP_INDEX_CHECK }, { VCODE_OP_ARRAY_REF }, { VCODE_OP_MUL }, { VCODE_OP_UNWRAP }, { VCODE_OP_COPY }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_COPY }, // TODO: generate in-place { VCODE_OP_RETURN }, }; CHECK_BB(0); fail_if_errors(); } END_TEST START_TEST(test_issue1208) { set_standard(STD_19); input_from_file(TESTDIR "/lower/issue1208.vhd"); run_elab(); fail_if_errors(); } END_TEST START_TEST(test_issue1234) { set_standard(STD_08); input_from_file(TESTDIR "/lower/issue1234.vhd"); run_elab(); vcode_unit_t vu = find_unit("WORK.ISSUE1234.ENT_INST"); vcode_select_unit(vu); EXPECT_BB(0) = { { VCODE_OP_PACKAGE_INIT, .name = "WORK.PKG" }, { VCODE_OP_PACKAGE_INIT, .name = "STD.STANDARD" }, { VCODE_OP_INDEX, .name = "PARAMS" }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "PARAMS" }, { VCODE_OP_COPY }, { VCODE_OP_VAR_UPREF, .hops = 1, .name = "REC_OUT" }, { VCODE_OP_CONST, .value = 4 }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_CONST, .value = 1 }, { VCODE_OP_FCALL, .func = "*WORK.PKG.INIT" }, { VCODE_OP_NULL }, { VCODE_OP_INDEX, .name = "REC_OUT" }, { VCODE_OP_DEBUG_LOCUS }, { VCODE_OP_CONST, .value = 5 }, { VCODE_OP_UARRAY_LEN }, { VCODE_OP_LENGTH_CHECK }, { VCODE_OP_ALLOC }, { VCODE_OP_WRAP }, { VCODE_OP_STORE_INDIRECT }, { VCODE_OP_CONST, .value = 0 }, { VCODE_OP_STORE, .name = "i1" }, { VCODE_OP_ARRAY_SCOPE }, { VCODE_OP_JUMP, .target = 1 }, }; CHECK_BB(0); fail_if_errors(); } END_TEST Suite *get_lower_tests(void) { Suite *s = suite_create("lower"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_wait1); tcase_add_test(tc, test_assign1); tcase_add_test(tc, test_assign2); tcase_add_test(tc, test_signal1); tcase_add_test(tc, test_cond1); tcase_add_test(tc, test_arith1); tcase_add_test(tc, test_pack1); tcase_add_test(tc, test_func1); tcase_add_test(tc, test_issue94); tcase_add_test(tc, test_arrayop1); tcase_add_test(tc, test_array1); tcase_add_test(tc, test_nest1); tcase_add_test(tc, test_signal2); tcase_add_test(tc, test_attr1); tcase_add_test(tc, test_record1); tcase_add_test(tc, test_assign3); tcase_add_test(tc, test_signal4); tcase_add_test(tc, test_staticwait); tcase_add_test(tc, test_proc1); tcase_add_test(tc, test_while1); tcase_add_test(tc, test_loop1); tcase_add_test(tc, test_proc3); tcase_add_test(tc, test_loop2); tcase_add_test(tc, test_slice1); tcase_add_test(tc, test_funcif); tcase_add_test(tc, test_memset); tcase_add_test(tc, test_func5); tcase_add_test(tc, test_bounds1); tcase_add_test(tc, test_record6); tcase_add_test(tc, test_proc7); tcase_add_test(tc, test_mulphys); tcase_add_test(tc, test_issue116); tcase_add_test(tc, test_cover); tcase_add_test(tc, test_issue122); tcase_add_test(tc, test_issue124); tcase_add_test(tc, test_issue135); tcase_add_test(tc, test_issue134); tcase_add_test(tc, test_issue136); tcase_add_test(tc, test_issue125); tcase_add_test(tc, test_access_bug); tcase_add_test(tc, test_issue149); tcase_add_test(tc, test_issue158); tcase_add_test(tc, test_issue167); tcase_add_test(tc, test_issue164); tcase_add_test(tc, test_sigvar); tcase_add_test(tc, test_issue181); tcase_add_test(tc, test_issue203); tcase_add_test(tc, test_issue215); tcase_add_test(tc, test_choice1); tcase_add_test(tc, test_tag); tcase_add_test(tc, test_iffold); tcase_add_test(tc, test_real1); tcase_add_test(tc, test_assert1); tcase_add_test(tc, test_thunk); tcase_add_test(tc, test_issue303); tcase_add_test(tc, test_dealloc); tcase_add_test(tc, test_issue324); tcase_add_test(tc, test_issue333); tcase_add_test(tc, test_issue338); tcase_add_test(tc, test_issue338b); tcase_add_test(tc, test_issue347); tcase_add_test(tc, test_hintbug); tcase_add_test(tc, test_issue351); tcase_add_test(tc, test_tounsigned); tcase_add_test(tc, test_issue357); tcase_add_test(tc, test_signal11); tcase_add_test(tc, test_access1); tcase_add_test(tc, test_sum); tcase_add_test(tc, test_extern1); tcase_add_test(tc, test_synopsys1); tcase_add_test(tc, test_access2); tcase_add_test(tc, test_vital1); tcase_add_test(tc, test_case1); tcase_add_test(tc, test_incomplete); tcase_add_test(tc, test_issue389); tcase_add_test(tc, test_const1); tcase_add_test(tc, test_const2); tcase_add_test(tc, test_vital2); tcase_add_test(tc, test_conv1); tcase_add_test(tc, test_resfn1); tcase_add_test(tc, test_issue426); tcase_add_test(tc, test_instance1); tcase_add_test(tc, test_sig2var); tcase_add_test(tc, test_protupref); tcase_add_test(tc, test_closefile); tcase_add_test(tc, test_record2); tcase_add_test(tc, test_array2); tcase_add_test(tc, test_concat); tcase_add_test(tc, test_nullarray); tcase_add_test(tc, test_osvvm2); tcase_add_test(tc, test_issue444); tcase_add_test(tc, test_vunit1); tcase_add_test(tc, test_vunit2); tcase_add_test(tc, test_vunit3); tcase_add_test(tc, test_vunit4); tcase_add_test(tc, test_directmap); tcase_add_test(tc, test_directmap2); tcase_add_test(tc, test_recsignal1); tcase_add_test(tc, test_vunit5); tcase_add_test(tc, test_issue462); tcase_add_test(tc, test_directmap3); tcase_add_test(tc, test_issue476); tcase_add_test(tc, test_issue478); tcase_add_test(tc, test_genpack1); tcase_add_test(tc, test_predef1); tcase_add_test(tc, test_signal5); tcase_add_test(tc, test_bigarray); tcase_add_test(tc, test_issue582); tcase_add_test(tc, test_issue591); tcase_add_test(tc, test_case2); tcase_add_test(tc, test_issue613); tcase_add_test(tc, test_wait2); tcase_add_test(tc, test_link1); tcase_add_test(tc, test_driver1); tcase_add_test(tc, test_attr2); tcase_add_test(tc, test_copy1); tcase_add_test(tc, test_issue662); tcase_add_test(tc, test_event1); tcase_add_test(tc, test_issue725); tcase_add_test(tc, test_cond2); tcase_add_test(tc, test_protpcall); tcase_add_test(tc, test_assert2); tcase_add_test(tc, test_issue756); tcase_add_test(tc, test_const3); tcase_add_test(tc, test_transfer1); tcase_add_test(tc, test_subtype1); tcase_add_test(tc, test_alias1); tcase_add_test(tc, test_issue768); tcase_add_test(tc, test_proc4); tcase_add_test(tc, test_issue791); tcase_add_test(tc, test_osvvm3); tcase_add_test(tc, test_bounds2); tcase_add_test(tc, test_subtype2); tcase_add_test(tc, test_directmap5); tcase_add_test(tc, test_issue837); tcase_add_test(tc, test_directmap6); tcase_add_test(tc, test_issue844); tcase_add_test(tc, test_trigger1); tcase_add_test(tc, test_issue859); tcase_add_test(tc, test_issue934); tcase_add_test(tc, test_issue972); tcase_add_test(tc, test_issue1029); tcase_add_test(tc, test_issue1080); tcase_add_test(tc, test_genpack2); tcase_add_test(tc, test_issue1155); tcase_add_test(tc, test_issue1191); tcase_add_test(tc, test_issue1194); tcase_add_test(tc, test_issue1196); tcase_add_test(tc, test_issue1199); tcase_add_test(tc, test_issue1208); tcase_add_test(tc, test_issue1234); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_mir.c000066400000000000000000001063241504111170000155160ustar00rootroot00000000000000// // Copyright (C) 2024-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "mir/mir-node.h" #include "mir/mir-unit.h" #include "object.h" #include "option.h" #include typedef union { struct { uint64_t data : 60; uint64_t tag : 4; }; struct { float real; uint32_t ones : 28; uint32_t zero : 4; }; const void *ptr; uint64_t bits; } mir_pattern_t; STATIC_ASSERT(sizeof(mir_pattern_t) == 8); #define _ (UINT32_MAX + 1) #define VAR(name) ((mir_pattern_t){ .ptr = ("\x8" name) }) #define PARAM(name) ((mir_pattern_t){ .ptr = ("\x2" name) }) #define LINK(name) ((mir_pattern_t){ .ptr = ("\xa" name) }) #define NODE(n) ((mir_pattern_t){ .tag = MIR_TAG_NODE, .data = n }) #define BLOCK(n) ((mir_pattern_t){ .tag = MIR_TAG_BLOCK, .data = n }) #define CONST(n) ((mir_pattern_t){ .tag = MIR_TAG_CONST, .data = n }) #define ENUM(n) ((mir_pattern_t){ .tag = MIR_TAG_ENUM, .data = n }) #define REAL(f) ((mir_pattern_t){ .ones = ~0, .real = (float)(f) }) #define mir_match(mu, b, pat) _mir_match((mu), (b), (pat), ARRAY_LEN((pat))) #define mir_assert_const_eq(mu, value, exp) do { \ int64_t __cval; \ ck_assert(mir_get_const((mu), (value), &__cval)); \ ck_assert_int_eq(__cval, (exp)); \ } while (0) typedef struct { mir_op_t op; mir_pattern_t arg0; mir_pattern_t arg1; mir_pattern_t arg2; } mir_match_t; STATIC_ASSERT(sizeof(mir_match_t) <= 32); static const char *mir_tag_name(int tag) { static const char *map[] = { [MIR_TAG_PARAM] = "parameter", [MIR_TAG_VAR] = "variable", [MIR_TAG_LINKAGE] = "linkage", [MIR_TAG_BLOCK] = "block", [MIR_TAG_NODE] = "node", }; return map[tag]; } static void mir_match_arg(mir_unit_t *mu, mir_value_t node, const mir_pattern_t *arg, int nth) { if (arg->tag == MIR_TAG_NULL && arg->data == 0) return; const char *str = NULL; const int64_t data = arg->data; unsigned tag = arg->tag; if (arg->tag == MIR_TAG_NULL && arg->ones != 0xfffffff) { // Assume this is a pointer to string data tag = *(uint8_t *)arg->ptr; str = arg->ptr + 1; } mir_value_t actual = mir_get_arg(mu, node, nth); if (actual.tag == MIR_TAG_NULL) { mir_dump(mu); ck_abort_msg("expected node to have %s argument", ordinal_str(nth + 1)); } else if (tag == MIR_TAG_CONST) { int64_t value; if (!mir_get_const(mu, actual, &value)) { mir_dump(mu); ck_abort_msg("%s argument is not constant", ordinal_str(nth + 1)); } else if (value != data) { mir_dump(mu); ck_abort_msg("expected %s argument to have constant value %"PRIi64 " but is %"PRIi64, ordinal_str(nth + 1), data, value); } } else if (tag == MIR_TAG_VAR || tag == MIR_TAG_PARAM || tag == MIR_TAG_LINKAGE) { ck_assert_ptr_nonnull(str); if (actual.tag != tag) { mir_dump(mu); ck_abort_msg("expected %s for %s argument", mir_tag_name(tag), ordinal_str(nth + 1)); } ident_t name = mir_get_name(mu, actual); if (!icmp(name, str)) { mir_dump(mu); ck_abort_msg("expected %s for %s argument to have name %s but is %s", mir_tag_name(tag), ordinal_str(nth + 1), str, istr(name)); } } else if (tag == MIR_TAG_NODE || tag == MIR_TAG_BLOCK) { if (actual.tag != tag) { mir_dump(mu); ck_abort_msg("expected %s for %s argument", mir_tag_name(tag), ordinal_str(nth + 1)); } else if (data != _ && actual.id != data) { mir_dump(mu); ck_abort_msg("expected %s %%%u for %s argument but have %%%u", mir_tag_name(tag), (unsigned)data, ordinal_str(nth + 1), actual.id); } } else if (tag == MIR_TAG_ENUM) { if (actual.tag != tag) { mir_dump(mu); ck_abort_msg("expected enum for %s argument", ordinal_str(nth + 1)); } else if (data != _ && actual.id != data) { mir_dump(mu); ck_abort_msg("expected enum %u for %s argument but have %u", (unsigned)data, ordinal_str(nth + 1), actual.id); } } else { mir_dump(mu); ck_abort_msg("cannot check tag %d", tag); } } static void _mir_match(mir_unit_t *mu, int nth, const mir_match_t *mm, size_t length) { ck_assert_int_lt(nth, mir_count_blocks(mu)); mir_block_t block = mir_get_block(mu, nth); const int nops = mir_count_nodes(mu, block); int eptr = 0, actual = nops; for (int i = 0; i < nops; i++) { mir_value_t node = mir_get_node(mu, block, i); ck_assert_int_eq(node.tag, MIR_TAG_NODE); const mir_op_t op = mir_get_op(mu, node); if (op == MIR_OP_COMMENT) { actual--; continue; } mir_set_cursor(mu, block, i); if (eptr >= length) break; const mir_match_t *e = &(mm[eptr++]); if (op != e->op) { mir_dump(mu); ck_abort_msg("expected op %d in block %d to be %s but was %s", i, nth, mir_op_string(e->op), mir_op_string(op)); } if (op == MIR_OP_CONST_REAL && e->arg0.bits != 0) { double dval; ck_assert(mir_get_const_real(mu, node, &dval)); if (fabsl(dval - e->arg0.real) > 0.0001) { mir_dump(mu); ck_abort_msg("expected constant real value %f but have %f", e->arg0.real, dval); } } else { mir_match_arg(mu, node, &(e->arg0), 0); mir_match_arg(mu, node, &(e->arg1), 1); mir_match_arg(mu, node, &(e->arg2), 2); } } if (eptr != length || length != actual) { mir_dump(mu); ck_abort_msg("expected %zd ops in block %d but have %d", length, nth, actual); } } START_TEST(test_sanity1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("test"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t i32 = mir_int_type(mu, INT32_MIN, INT32_MAX); fail_unless(mir_equals(i32, mir_int_type(mu, INT32_MIN, INT32_MAX))); fail_if(mir_equals(i32, mir_int_type(mu, 0, INT32_MAX))); fail_if(mir_equals(i32, mir_int_type(mu, INT32_MIN, 0))); mir_set_result(mu, i32); mir_value_t p1 = mir_add_param(mu, i32, MIR_NULL_STAMP, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, i32, MIR_NULL_STAMP, ident_new("p2")); fail_if(mir_equals(p1, p2)); mir_comment(mu, "hello, world!"); mir_value_t one = mir_const(mu, i32, 1); ck_assert_int_eq(one.tag, MIR_TAG_CONST); mir_value_t two = mir_const(mu, i32, 2); ck_assert_int_eq(two.tag, MIR_TAG_CONST); fail_if(mir_equals(one, two)); mir_value_t three = mir_build_add(mu, i32, one, two); int64_t cval; ck_assert(mir_get_const(mu, three, &cval)); ck_assert_int_eq(cval, 3); mir_build_consume(mu, three); mir_value_t zero = mir_build_sub(mu, i32, one, one); ck_assert(mir_get_const(mu, zero, &cval)); ck_assert_int_eq(cval, 0); mir_value_t cancel = mir_build_sub(mu, i32, p1, p1); ck_assert(mir_get_const(mu, cancel, &cval)); ck_assert_int_eq(cval, 0); mir_value_t var = mir_add_var(mu, i32, MIR_NULL_STAMP, ident_new("var"), 0); ck_assert_int_eq(var.tag, MIR_TAG_VAR); mir_build_store(mu, var, one); mir_value_t load = mir_build_load(mu, var); ck_assert_int_eq(load.tag, MIR_TAG_NODE); mir_type_t t_double = mir_double_type(mu); mir_value_t pi = mir_const_real(mu, t_double, 3.142); ck_assert_int_eq(pi.tag, MIR_TAG_NODE); mir_value_t args[] = { pi, load }; mir_value_t fcall = mir_build_fcall(mu, ident_new("func"), i32, MIR_NULL_STAMP, args, ARRAY_LEN(args)); ck_assert_int_eq(fcall.tag, MIR_TAG_NODE); mir_value_t add = mir_build_add(mu, i32, p1, p2); mir_value_t result = mir_build_add(mu, i32, add, three); mir_build_return(mu, result); static const mir_match_t bb0[] = { { MIR_OP_STORE, VAR("var") }, { MIR_OP_LOAD, VAR("var") }, { MIR_OP_CONST_REAL, REAL(3.142) }, { MIR_OP_FCALL, LINK("func") }, { MIR_OP_ADD }, { MIR_OP_ADD, NODE(_), CONST(3) }, { MIR_OP_RETURN }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_arith1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("arith1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_value_t one = mir_const(mu, t_int32, 1); mir_value_t zero = mir_const(mu, t_int32, 0); mir_value_t min32 = mir_const(mu, t_int32, INT32_MIN); mir_value_t max32 = mir_const(mu, t_int32, INT32_MAX); mir_value_t max64 = mir_const(mu, t_int32, INT64_MAX); mir_value_t add1 = mir_build_add(mu, t_int32, max32, one); ck_assert_int_eq(add1.tag, MIR_TAG_NODE); int64_t cval; ck_assert(mir_get_const(mu, add1, &cval)); ck_assert_int_eq(cval, INT32_MAX + UINT64_C(1)); mir_value_t add2 = mir_build_add(mu, t_int32, max32, zero); ck_assert(mir_equals(add2, max32)); mir_value_t ovf1 = mir_build_add(mu, t_int32, max64, one); ck_assert_int_eq(ovf1.tag, MIR_TAG_NODE); ck_assert(!mir_get_const(mu, ovf1, &cval)); mir_value_t bigconst = mir_const(mu, t_int32, (1 << (_MIR_ID_BITS - 1)) - 1); ck_assert_int_eq(bigconst.tag, MIR_TAG_CONST); mir_value_t add3 = mir_build_add(mu, t_int32, bigconst, one); ck_assert_int_eq(add3.tag, MIR_TAG_NODE); mir_value_t neg1 = mir_build_neg(mu, t_int32, one); mir_assert_const_eq(mu, neg1, -1); mir_value_t locus1 = mir_build_locus(mu, NULL); mir_value_t neg2 = mir_build_trap_neg(mu, t_int32, min32, locus1); ck_assert_int_eq(neg2.tag, MIR_TAG_NODE); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_real1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("real1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_double = mir_double_type(mu); mir_value_t one = mir_const_real(mu, t_double, 1.0); mir_value_t zero = mir_const_real(mu, t_double, 0.0); double cval; mir_value_t add1 = mir_build_add(mu, t_double, one, zero); ck_assert_int_eq(add1.tag, MIR_TAG_NODE); ck_assert(mir_get_const_real(mu, add1, &cval)); ck_assert_double_eq(cval, 1.0); mir_value_t add2 = mir_build_add(mu, t_double, zero, one); ck_assert_int_eq(add2.tag, MIR_TAG_NODE); ck_assert(mir_get_const_real(mu, add2, &cval)); ck_assert_double_eq(cval, 1.0); mir_value_t add3 = mir_build_add(mu, t_double, one, one); ck_assert_int_eq(add3.tag, MIR_TAG_NODE); ck_assert(mir_get_const_real(mu, add3, &cval)); ck_assert_double_eq(cval, 2.0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_control1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("control1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_bool = mir_bool_type(mu); mir_value_t p1 = mir_add_param(mu, t_bool, MIR_NULL_STAMP, ident_new("p1")); mir_block_t b1 = mir_add_block(mu); mir_block_t b2 = mir_add_block(mu); mir_block_t b3 = mir_add_block(mu); mir_build_cond(mu, p1, b1, b2); mir_set_cursor(mu, b1, MIR_APPEND); mir_build_jump(mu, b3); mir_set_cursor(mu, b2, MIR_APPEND); mir_build_cond(mu, mir_const(mu, t_bool, 1), b3, b2); mir_value_t last = mir_get_node(mu, b2, 0); ck_assert_int_eq(mir_get_op(mu, last), MIR_OP_JUMP); mir_set_cursor(mu, b3, MIR_APPEND); mir_build_return(mu, MIR_NULL_VALUE); mir_optimise(mu, MIR_PASS_GVN); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_gvn1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("gvn1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_value_t p1 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p2")); mir_set_result(mu, t_int32); mir_block_t b1 = mir_add_block(mu); mir_block_t b2 = mir_add_block(mu); mir_block_t b3 = mir_add_block(mu); mir_value_t ten = mir_const(mu, t_int32, 10); mir_value_t add1 = mir_build_add(mu, t_int32, p1, p2); mir_value_t sub1 = mir_build_sub(mu, t_int32, add1, p2); mir_value_t mul1 = mir_build_mul(mu, t_int32, sub1, p1); mir_value_t cmp1 = mir_build_cmp(mu, MIR_CMP_EQ, mul1, ten); mir_value_t cmp2 = mir_build_cmp(mu, MIR_CMP_EQ, ten, sub1); mir_value_t and = mir_build_and(mu, cmp1, cmp2); mir_value_t or = mir_build_or(mu, and, cmp2); mir_value_t not = mir_build_not(mu, or); mir_build_cond(mu, not, b1, b2); mir_set_cursor(mu, b1, MIR_APPEND); mir_value_t add2 = mir_build_add(mu, t_int32, p2, p1); mir_build_jump(mu, b3); mir_set_cursor(mu, b2, MIR_APPEND); mir_value_t add3 = mir_build_add(mu, t_int32, p1, p2); mir_build_jump(mu, b3); mir_set_cursor(mu, b3, MIR_APPEND); mir_value_t phi = mir_build_phi(mu, t_int32, 2); mir_set_input(mu, phi, 0, b1, add2); mir_set_input(mu, phi, 1, b2, add3); mir_build_return(mu, phi); mir_optimise(mu, MIR_PASS_GVN); static const mir_match_t bb0[] = { { MIR_OP_ADD, PARAM("p1"), PARAM("p2") }, { MIR_OP_SUB, NODE(0), PARAM("p2") }, { MIR_OP_MUL, PARAM("p1"), PARAM("p1") }, { MIR_OP_CMP, ENUM(MIR_CMP_EQ), NODE(2), CONST(10) }, { MIR_OP_CMP, ENUM(MIR_CMP_EQ), PARAM("p1"), CONST(10) }, { MIR_OP_AND, NODE(3), NODE(4) }, { MIR_OP_OR, NODE(4), NODE(5) }, { MIR_OP_NOT, NODE(6) }, { MIR_OP_COND, NODE(7), BLOCK(1), BLOCK(2) }, }; mir_match(mu, 0, bb0); static const mir_match_t bb3[] = { { MIR_OP_PHI, BLOCK(1), NODE(0) }, { MIR_OP_RETURN, NODE(0) }, }; mir_match(mu, 3, bb3); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_dce1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("dce1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_type_t t_ptr = mir_pointer_type(mu, t_int32); mir_value_t p1 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p2")); mir_value_t p3 = mir_add_param(mu, t_ptr, MIR_NULL_STAMP, ident_new("p3")); mir_set_result(mu, t_int32); mir_build_store(mu, p3, p2); mir_value_t add1 = mir_build_add(mu, t_int32, p1, p2); mir_build_add(mu, t_int32, add1, p2); mir_build_return(mu, p1); mir_optimise(mu, MIR_PASS_DCE); static const mir_match_t bb0[] = { { MIR_OP_STORE, PARAM("p3"), PARAM("p2") }, { MIR_OP_RETURN, PARAM("p1") }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_uarray1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("uarray1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_type_t t_intptr = mir_pointer_type(mu, t_int32); mir_stamp_t stamp1 = mir_int_stamp(mu, 1, 10); mir_value_t p1 = mir_add_param(mu, t_intptr, stamp1, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p2")); const mir_dim_t dims[] = { { mir_const(mu, t_int32, 1), p2, mir_const(mu, t_int32, RANGE_TO) }, }; mir_value_t wrap1 = mir_build_wrap(mu, p1, dims, ARRAY_LEN(dims)); mir_value_t unwrap1 = mir_build_unwrap(mu, wrap1); ck_assert_int_eq(p1.bits, unwrap1.bits); static const mir_match_t bb0[] = { { MIR_OP_WRAP, PARAM("p1") }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_logical1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("logical1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_bool = mir_bool_type(mu); mir_value_t p1 = mir_add_param(mu, t_bool, MIR_NULL_STAMP, ident_new("p1")); mir_value_t t = mir_const(mu, t_bool, 1), f = mir_const(mu, t_bool, 0); mir_value_t not1 = mir_build_not(mu, t); mir_assert_const_eq(mu, not1, 0); mir_value_t not2 = mir_build_not(mu, f); mir_assert_const_eq(mu, not2, 1); mir_value_t not3 = mir_build_not(mu, p1); mir_value_t not4 = mir_build_not(mu, not3); ck_assert_int_eq(not4.bits, p1.bits); mir_value_t or1 = mir_build_or(mu, t, f); mir_assert_const_eq(mu, or1, 1); mir_value_t or2 = mir_build_or(mu, f, f); mir_assert_const_eq(mu, or2, 0); mir_value_t or3 = mir_build_or(mu, p1, t); mir_assert_const_eq(mu, or3, 1); mir_value_t or4 = mir_build_or(mu, f, p1); ck_assert_int_eq(or4.bits, p1.bits); mir_value_t xor1 = mir_build_xor(mu, t, f); mir_assert_const_eq(mu, xor1, 1); mir_value_t xor2 = mir_build_xor(mu, p1, p1); mir_assert_const_eq(mu, xor2, 0); mir_value_t and1 = mir_build_and(mu, t, f); mir_assert_const_eq(mu, and1, 0); mir_value_t and2 = mir_build_and(mu, t, t); mir_assert_const_eq(mu, and2, 1); mir_value_t and3 = mir_build_and(mu, p1, f); mir_assert_const_eq(mu, and3, 0); mir_value_t and4 = mir_build_and(mu, p1, t); ck_assert_int_eq(and4.bits, p1.bits); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_signal1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("uarray1"), NULL, MIR_UNIT_INSTANCE, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_type_t t_intsig = mir_signal_type(mu, t_int32); mir_type_t t_offset = mir_offset_type(mu); mir_stamp_t pos = mir_int_stamp(mu, 1, INT32_MAX); mir_value_t p1 = mir_add_param(mu, t_intsig, pos, ident_new("p1")); mir_value_t r1 = mir_build_resolved(mu, p1); mir_value_t locus1 = mir_build_locus(mu, NULL); mir_value_t s1 = mir_build_init_signal(mu, t_int32, mir_const(mu, t_offset, 1), mir_const(mu, t_offset, 4), mir_const(mu, t_offset, 42), mir_const(mu, t_int32, 0), locus1, MIR_NULL_VALUE); ck_assert(mir_is_signal(mu, s1)); mir_block_t block1 = mir_add_block(mu); mir_build_jump(mu, block1); mir_set_cursor(mu, block1, MIR_APPEND); mir_value_t r2 = mir_build_resolved(mu, p1); mir_value_t load1 = mir_build_load(mu, r2); ck_assert(mir_is_integral(mu, load1)); mir_build_load(mu, r1); mir_build_return(mu, MIR_NULL_VALUE); mir_optimise(mu, MIR_PASS_GVN); static const mir_match_t bb0[] = { { MIR_OP_RESOLVED, PARAM("p1") }, { MIR_OP_LOCUS }, { MIR_OP_INIT_SIGNAL }, { MIR_OP_JUMP, BLOCK(1) }, }; mir_match(mu, 0, bb0); static const mir_match_t bb1[] = { { MIR_OP_RESOLVED, PARAM("p1") }, { MIR_OP_LOAD, NODE(0) }, { MIR_OP_LOAD, NODE(0) }, { MIR_OP_RETURN }, }; mir_match(mu, 1, bb1); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_select1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("select1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_type_t t_bool = mir_bool_type(mu); mir_set_result(mu, t_int32); mir_value_t p1 = mir_add_param(mu, t_bool, MIR_NULL_STAMP, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p2")); mir_value_t zero = mir_const(mu, t_bool, 0); mir_value_t one = mir_const(mu, t_bool, 1); mir_value_t two = mir_const(mu, t_int32, 2); mir_value_t s1 = mir_build_select(mu, t_int32, one, one, two); mir_assert_const_eq(mu, s1, 1); mir_value_t s2 = mir_build_select(mu, t_int32, zero, one, two); mir_assert_const_eq(mu, s2, 2); mir_value_t s3 = mir_build_select(mu, t_int32, p1, two, two); mir_assert_const_eq(mu, s3, 2); mir_value_t s4 = mir_build_select(mu, t_int32, p1, p2, one); mir_value_t s5 = mir_build_select(mu, t_int32, p1, p2, one); mir_build_return(mu, mir_build_add(mu, t_int32, s4, s5)); mir_optimise(mu, MIR_PASS_GVN | MIR_PASS_DCE); static const mir_match_t bb0[] = { { MIR_OP_SELECT, PARAM("p1"), PARAM("p2"), CONST(1) }, { MIR_OP_ADD, NODE(0), NODE(0) }, { MIR_OP_RETURN }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_modrem1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("modrem1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_stamp_t pos = mir_int_stamp(mu, 0, INT32_MAX); mir_set_result(mu, t_int32); mir_value_t p1 = mir_add_param(mu, t_int32, MIR_NULL_STAMP, ident_new("p1")); mir_value_t p2 = mir_add_param(mu, t_int32, pos, ident_new("p2")); mir_value_t zero = mir_const(mu, t_int32, 0); mir_value_t one = mir_const(mu, t_int32, 1); mir_value_t two = mir_const(mu, t_int32, 2); mir_value_t v1 = mir_build_rem(mu, t_int32, p1, p2); mir_value_t v2 = mir_build_rem(mu, t_int32, p1, p2); mir_value_t v3 = mir_build_rem(mu, t_int32, one, two); mir_assert_const_eq(mu, v3, 1); mir_value_t v4 = mir_build_mod(mu, t_int32, p2, two); ck_assert_int_eq(mir_get_op(mu, v4), MIR_OP_REM); mir_value_t v5 = mir_build_mod(mu, t_int32, mir_const(mu, t_int32, -5), mir_const(mu, t_int32, 3)); ck_assert_int_eq(mir_get_op(mu, v5), MIR_OP_MOD); mir_value_t cmp = mir_build_cmp(mu, MIR_CMP_GEQ, v4, zero); mir_value_t sel1 = mir_build_select(mu, t_int32, cmp, v1, v2); mir_value_t sel2 = mir_build_select(mu, t_int32, cmp, v4, v1); mir_build_return(mu, mir_build_select(mu, t_int32, cmp, sel1, sel2)); mir_optimise(mu, MIR_PASS_GVN | MIR_PASS_DCE); static const mir_match_t bb0[] = { { MIR_OP_REM, PARAM("p1"), PARAM("p2") }, { MIR_OP_RETURN }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_cmp1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("cmp1"), NULL, MIR_UNIT_FUNCTION, NULL); static const struct { int64_t left, right; mir_cmp_t cmp; int result; } cases[] = { { 0, 0, MIR_CMP_EQ, 1}, { INT64_MAX, INT64_MAX, MIR_CMP_EQ, 1}, { INT64_MAX, INT64_MIN, MIR_CMP_EQ, 0}, { 1, 0, MIR_CMP_NEQ, 1 }, { 1, 1, MIR_CMP_NEQ, 0 }, { -1, 0, MIR_CMP_LT, 1 }, { 5, 0, MIR_CMP_LT, 0 }, { 1, 0, MIR_CMP_GT, 1 }, { -5, -2, MIR_CMP_GT, 0 }, { 6, 6, MIR_CMP_GEQ, 1 }, { 6, 7, MIR_CMP_GEQ, 0 }, { 6, 6, MIR_CMP_LEQ, 1 }, { 6, 7, MIR_CMP_LEQ, 1 }, }; mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); for (int i = 0; i < ARRAY_LEN(cases); i++) { mir_value_t left = mir_const(mu, t_int32, cases[i].left); mir_value_t right = mir_const(mu, t_int32, cases[i].right); mir_value_t value = mir_build_cmp(mu, cases[i].cmp, left, right); int64_t result; ck_assert(mir_get_const(mu, value, &result)); ck_assert_msg(result == cases[i].result, "%"PRIi64" <%d> %"PRIi64" ==> %"PRIi64" != %d", cases[i].left, cases[i].cmp, cases[i].right, result, cases[i].result); } mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_wait1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("wait1"), NULL, MIR_UNIT_PROCESS, NULL); ident_t pack = ident_new("foo"); ident_t func = ident_new("func"); mir_value_t p1 = mir_build_link_package(mu, pack); mir_value_t p2 = mir_build_link_package(mu, pack); mir_build_fcall(mu, func, MIR_NULL_TYPE, MIR_NULL_STAMP, &p1, 1); mir_build_fcall(mu, func, MIR_NULL_TYPE, MIR_NULL_STAMP, &p2, 1); mir_block_t b1 = mir_add_block(mu); mir_build_wait(mu, b1, MIR_NULL_VALUE); mir_set_cursor(mu, b1, MIR_APPEND); mir_value_t p3 = mir_build_link_package(mu, pack); mir_build_fcall(mu, func, MIR_NULL_TYPE, MIR_NULL_STAMP, &p3, 1); mir_build_return(mu, MIR_NULL_VALUE); mir_optimise(mu, MIR_PASS_GVN | MIR_PASS_DCE); static const mir_match_t bb0[] = { { MIR_OP_LINK_PACKAGE, LINK("foo") }, { MIR_OP_FCALL, LINK("func") }, { MIR_OP_FCALL, LINK("func") }, { MIR_OP_WAIT, BLOCK(1) }, }; mir_match(mu, 0, bb0); static const mir_match_t bb1[] = { { MIR_OP_LINK_PACKAGE, LINK("foo") }, { MIR_OP_FCALL, LINK("func") }, { MIR_OP_RETURN }, }; mir_match(mu, 1, bb1); mir_unit_free(mu); mir_context_free(mc); } END_TEST static void defer1_cb(mir_unit_t *mu, object_t *obj) { ck_assert_int_eq(mir_get_kind(mu), MIR_UNIT_PROCEDURE); } START_TEST(test_defer1) { mir_context_t *mc = mir_context_new(); make_new_arena(); ident_t name = ident_new("testfn"); object_t *obj = tree_to_object(tree_new(T_FUNC_BODY)); mir_defer(mc, name, NULL, MIR_UNIT_PROCEDURE, defer1_cb, obj); mir_unit_t *mu = mir_get_unit(mc, name); ck_assert_int_eq(mir_get_kind(mu), MIR_UNIT_PROCEDURE); mir_shape_t *sh = mir_get_shape(mc, name); ck_assert_ptr_nonnull(sh); mir_unit_free(mu); ck_assert_ptr_eq(sh, mir_get_shape(mc, name)); mir_context_free(mc); } END_TEST START_TEST(test_array1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("array1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_type_t t_array = mir_carray_type(mu, 3, t_int32); mir_type_t t_offset = mir_offset_type(mu); ck_assert_int_eq(mir_get_class(mu, t_array), MIR_TYPE_CARRAY); ck_assert_int_eq(mir_get_size(mu, t_array), 3); const mir_value_t elts[] = { mir_const(mu, t_int32, 1), mir_const(mu, t_int32, 2), mir_const(mu, t_int32, 541241251), }; mir_value_t a1 = mir_const_array(mu, t_array, elts, ARRAY_LEN(elts)); mir_value_t p1 = mir_build_address_of(mu, a1); ck_assert(mir_is(mu, p1, MIR_TYPE_POINTER)); mir_value_t e1 = mir_build_array_ref(mu, p1, mir_const(mu, t_offset, 1)); mir_value_t v1 = mir_build_load(mu, e1); mir_value_t zero = mir_const(mu, t_int32, 0); mir_value_t c1 = mir_build_cmp(mu, MIR_CMP_LT, v1, zero); mir_assert_const_eq(mu, c1, 0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_case1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("case1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_block_t b1 = mir_add_block(mu); mir_block_t b2 = mir_add_block(mu); mir_value_t cases1[] = { mir_const(mu, t_int32, 42) }; mir_block_t blocks1[] = { b2 }; mir_build_case(mu, mir_const(mu, t_int32, 66), b1, cases1, blocks1, 1); mir_set_cursor(mu, b1, MIR_APPEND); mir_value_t cases2[] = { mir_const(mu, t_int32, 5) }; mir_block_t blocks2[] = { b2 }; mir_build_case(mu, mir_const(mu, t_int32, 5), b1, cases2, blocks2, 1); static const mir_match_t bb0[] = { { MIR_OP_JUMP, BLOCK(1) }, }; mir_match(mu, 0, bb0); static const mir_match_t bb1[] = { { MIR_OP_JUMP, BLOCK(2) }, }; mir_match(mu, 1, bb1); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_record1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("record1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_set_result(mu, t_int32); const mir_type_t fields[] = { t_int32, t_int32 }; mir_type_t t_rec = mir_record_type(mu, ident_new("t_rec"), fields, ARRAY_LEN(fields)); mir_type_t dup = mir_record_type(mu, ident_new("t_rec"), fields, ARRAY_LEN(fields)); ck_assert(mir_equals(t_rec, dup)); mir_value_t p1 = mir_add_param(mu, mir_pointer_type(mu, t_rec), MIR_NULL_STAMP, ident_new("p1")); mir_value_t v1 = mir_add_var(mu, t_rec, MIR_NULL_STAMP, ident_new("v1"), 0); mir_value_t vals[] = { mir_const(mu, t_int32, 1), mir_const(mu, t_int32, 2), }; mir_value_t c1 = mir_const_record(mu, t_rec, vals, ARRAY_LEN(vals)); mir_build_copy(mu, v1, mir_build_address_of(mu, c1), MIR_NULL_VALUE); mir_value_t rr1 = mir_build_record_ref(mu, p1, 0); mir_build_return(mu, mir_build_load(mu, rr1)); static const mir_match_t bb0[] = { { MIR_OP_CONST_RECORD, CONST(1), CONST(2) }, { MIR_OP_ADDRESS_OF }, { MIR_OP_COPY, VAR("v1") }, { MIR_OP_RECORD_REF, PARAM("p1") }, { MIR_OP_LOAD }, { MIR_OP_RETURN }, }; mir_match(mu, 0, bb0); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_alias1) { mir_context_t *mc = mir_context_new(); mir_unit_t *mu = mir_unit_new(mc, ident_new("alias1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_char = mir_int_type(mu, 0, UINT8_MAX); mir_type_t t_string3 = mir_carray_type(mu, 3, t_char); mir_type_t t_offset = mir_offset_type(mu); mir_value_t vals[] = { mir_const(mu, t_char, 'a'), mir_const(mu, t_char, 'b'), mir_const(mu, t_char, 'c'), }; mir_value_t array1 = mir_const_array(mu, t_string3, vals, ARRAY_LEN(vals)); ck_assert_int_eq(mir_get_mem(mu, array1), MIR_MEM_CONST); mir_value_t v1 = mir_add_var(mu, t_string3, MIR_NULL_STAMP, ident_new("v1"), 0); ck_assert_int_eq(mir_get_mem(mu, v1), MIR_MEM_STACK); mir_value_t v2 = mir_add_var(mu, t_string3, MIR_NULL_STAMP, ident_new("v2"), MIR_VAR_HEAP); ck_assert_int_eq(mir_get_mem(mu, v2), MIR_MEM_LOCAL); mir_value_t ptr1 = mir_build_address_of(mu, array1); ck_assert_int_eq(mir_get_mem(mu, ptr1), MIR_MEM_CONST); mir_value_t ref1 = mir_build_array_ref(mu, v1, mir_const(mu, t_offset, 1)); ck_assert_int_eq(mir_get_mem(mu, ref1), MIR_MEM_STACK); ck_assert(!mir_may_alias(mu, array1, v1)); ck_assert(!mir_may_alias(mu, array1, ptr1)); ck_assert(!mir_may_alias(mu, v1, ptr1)); ck_assert(mir_may_alias(mu, v1, ref1)); ck_assert(!mir_may_alias(mu, v1, v2)); mir_build_return(mu, MIR_NULL_VALUE); mir_unit_free(mu); mir_context_free(mc); } END_TEST START_TEST(test_cast1) { mir_unit_t *mu = mir_unit_new(get_mir(), ident_new("alias1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_offset = mir_offset_type(mu); mir_type_t t_int32 = mir_int_type(mu, INT32_MIN, INT32_MAX); mir_value_t p1 = mir_add_param(mu, t_offset, mir_int_stamp(mu, 0, INT64_MAX), ident_new("p1")); mir_value_t zero = mir_const(mu, t_int32, 0); mir_value_t cast1 = mir_build_cast(mu, t_int32, p1); mir_value_t cmp1 = mir_build_cmp(mu, MIR_CMP_LT, cast1, zero); mir_assert_const_eq(mu, cmp1, 0); mir_build_return(mu, MIR_NULL_VALUE); mir_unit_free(mu); } END_TEST START_TEST(test_vec1) { mir_unit_t *mu = mir_unit_new(get_mir(), ident_new("vec1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_vec2_8 = mir_vec2_type(mu, 8, false); mir_type_t t_vec2_9 = mir_vec2_type(mu, 9, false); mir_set_result(mu, t_vec2_9); mir_value_t p1 = mir_add_param(mu, t_vec2_8, MIR_NULL_STAMP, ident_new("p1")); mir_value_t c1 = mir_const_vec(mu, t_vec2_8, 5, 0); mir_value_t add1 = mir_build_add(mu, t_vec2_9, p1, c1); mir_value_t add2 = mir_build_add(mu, t_vec2_9, add1, c1); mir_type_t t_carray9 = mir_carray_type(mu, 9, mir_int_type(mu, 0, 3)); mir_value_t tmp1 = mir_add_var(mu, t_carray9, MIR_NULL_STAMP, ident_new("tmp1"), MIR_VAR_TEMP); mir_value_t unpack1 = mir_build_unpack(mu, add2, 0, tmp1); mir_value_t pack1 = mir_build_pack(mu, t_vec2_9, unpack1); mir_build_return(mu, pack1); mir_unit_free(mu); } END_TEST START_TEST(test_vec2) { mir_unit_t *mu = mir_unit_new(get_mir(), ident_new("vec2"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_vec2_8 = mir_vec2_type(mu, 8, false); mir_type_t t_vec2_1 = mir_vec2_type(mu, 1, false); mir_type_t t_offset = mir_offset_type(mu); mir_value_t const1 = mir_const_vec(mu, t_vec2_8, 1, 0); mir_value_t cast1 = mir_build_cast(mu, t_vec2_1, const1); ck_assert_int_eq(mir_get_op(mu, cast1), MIR_OP_CONST_VEC); mir_value_t cast2 = mir_build_cast(mu, t_offset, const1); mir_assert_const_eq(mu, cast2, 1); mir_unit_free(mu); } END_TEST START_TEST(test_check1) { mir_unit_t *mu = mir_unit_new(get_mir(), ident_new("check1"), NULL, MIR_UNIT_FUNCTION, NULL); mir_type_t t_bool = mir_bool_type(mu); mir_value_t p1 = mir_add_param(mu, t_bool, MIR_NULL_STAMP, ident_new("p1")); mir_value_t locus = mir_build_locus(mu, NULL); mir_build_dir_check(mu, p1, mir_const(mu, t_bool, RANGE_TO), locus); mir_build_dir_check(mu, p1, p1, locus); static const mir_match_t bb0[] = { { MIR_OP_LOCUS }, { MIR_OP_DIR_CHECK, PARAM("p1"), CONST(0) }, }; mir_match(mu, 0, bb0); } END_TEST Suite *get_mir_tests(void) { Suite *s = suite_create("mir"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_sanity1); tcase_add_test(tc, test_arith1); tcase_add_test(tc, test_real1); tcase_add_test(tc, test_control1); tcase_add_test(tc, test_gvn1); tcase_add_test(tc, test_dce1); tcase_add_test(tc, test_uarray1); tcase_add_test(tc, test_logical1); tcase_add_test(tc, test_signal1); tcase_add_test(tc, test_select1); tcase_add_test(tc, test_modrem1); tcase_add_test(tc, test_cmp1); tcase_add_test(tc, test_wait1); tcase_add_test(tc, test_defer1); tcase_add_test(tc, test_array1); tcase_add_test(tc, test_case1); tcase_add_test(tc, test_record1); tcase_add_test(tc, test_alias1); tcase_add_test(tc, test_cast1); tcase_add_test(tc, test_vec1); tcase_add_test(tc, test_vec2); tcase_add_test(tc, test_check1); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_misc.c000066400000000000000000000516411504111170000156630ustar00rootroot00000000000000// // Copyright (C) 2021-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "fbuf.h" #include "hash.h" #include "ident.h" #include "mask.h" #include "option.h" #include "rt/copy.h" #include "rt/heap.h" #include "thread.h" #include "util.h" #include #include #include #include #include #include #include #define VOIDP(x) ((void *)(uintptr_t)(x)) START_TEST(test_hash_basic) { hash_t *h = hash_new(8); hash_put(h, VOIDP(1516), VOIDP(6)); hash_put(h, VOIDP(151670), VOIDP(4)); hash_put(h, VOIDP(61), VOIDP(1)); fail_unless(hash_get(h, VOIDP(1516)) == VOIDP(6)); fail_unless(hash_get(h, VOIDP(151670)) == VOIDP(4)); fail_unless(hash_get(h, VOIDP(61)) == VOIDP(1)); hash_free(h); } END_TEST; START_TEST(test_hash_rand) { hash_t *h = hash_new(32); static const int N = 1024; void *keys[N]; void *values[N]; for (int i = 0; i < N; i++) { do { keys[i] = VOIDP(((i << 16) | (rand() & 0xffff))); } while (keys[i] == NULL); values[i] = VOIDP(rand()); } for (int i = 0; i < N; i++) hash_put(h, keys[i], values[i]); for (int i = 0; i < N; i++) fail_unless(hash_get(h, keys[i]) == values[i]); hash_free(h); } END_TEST; START_TEST(test_hash_delete) { hash_t *h = hash_new(8); hash_put(h, VOIDP(10), VOIDP(6)); hash_put(h, VOIDP(11), VOIDP(4)); hash_put(h, VOIDP(2), VOIDP(1)); fail_unless(hash_get(h, VOIDP(10)) == VOIDP(6)); hash_delete(h, VOIDP(10)); fail_unless(hash_get(h, VOIDP(10)) == NULL); fail_unless(hash_get(h, VOIDP(11)) == VOIDP(4)); hash_free(h); } END_TEST START_TEST(test_shash_basic) { shash_t *h = shash_new(8); shash_put(h, "hello", VOIDP(6)); shash_put(h, "world", VOIDP(4)); shash_put(h, "hell", VOIDP(1)); fail_unless(shash_get(h, "hello") == VOIDP(6)); fail_unless(shash_get(h, "world") == VOIDP(4)); fail_unless(shash_get(h, "hell") == VOIDP(1)); char *tmp LOCAL = xstrdup("hello"); fail_unless(shash_get(h, tmp) == VOIDP(6)); shash_free(h); } END_TEST; START_TEST(test_shash_rand) { shash_t *h = shash_new(8); static const int N = 1000; char *strs[N]; for (int i = 0; i < N; i++) { size_t len = 5 + rand() % 40; strs[i] = xmalloc(len + 1); for (size_t j = checked_sprintf(strs[i], len, "%d", i); j < len; j++) strs[i][j] = ' ' + rand() % 80; strs[i][len] = '\0'; shash_put(h, strs[i], VOIDP(i)); } for (int i = 0; i < N; i++) { fail_unless(shash_get(h, strs[i]) == VOIDP(i)); free(strs[i]); } shash_free(h); } END_TEST; START_TEST(test_ihash_rand) { ihash_t *h = ihash_new(32); static const int N = 1024; uint64_t keys[N]; void *values[N]; for (int i = 0; i < N; i++) { keys[i] = (i << 16) | (rand() & 0xffff); values[i] = VOIDP(rand()); } for (int i = 0; i < N; i++) ihash_put(h, keys[i], values[i]); for (int i = 0; i < N; i++) ck_assert_ptr_eq(ihash_get(h, keys[i]), values[i]); ihash_free(h); } END_TEST; START_TEST(test_hset_rand) { hset_t *h = hset_new(32); static const int N = 1024; void *keys[N]; for (int i = 0; i < N; i++) keys[i] = VOIDP((((i + 1) << 16) | (rand() & 0xffff))); for (int i = 0; i < N; i++) hset_insert(h, keys[i]); for (int i = 0; i < N; i++) ck_assert(hset_contains(h, keys[i])); hset_free(h); } END_TEST; START_TEST(test_chash_rand) { chash_t *h = chash_new(32); static const int N = 1024; void *keys[N]; void *values[N]; for (int i = 0; i < N; i++) { do { keys[i] = VOIDP((i << 20) | (rand() & 0xffff0)); } while (keys[i] == NULL); values[i] = VOIDP(rand()); } for (int i = 0; i < N; i++) chash_put(h, keys[i], values[i]); for (int i = 0; i < N; i++) ck_assert_ptr_eq(chash_get(h, keys[i]), values[i]); chash_free(h); } END_TEST; START_TEST(test_chash_cas) { chash_t *h = chash_new(32); ck_assert_ptr_eq(chash_cas(h, VOIDP(0x1000), NULL, VOIDP(0x123)), NULL); ck_assert_ptr_eq(chash_cas(h, VOIDP(0x1000), NULL, VOIDP(0x123)), VOIDP(0x123)); ck_assert_ptr_eq(chash_cas(h, VOIDP(0x1000), VOIDP(0x123), VOIDP(0x456)), VOIDP(0x123)); ck_assert_ptr_eq(chash_get(h, VOIDP(0x1000)), VOIDP(0x456)); chash_free(h); } END_TEST; struct point { double x, y; }; static uint32_t hash_point(const void *ptr) { const struct point *p = ptr; return mix_bits_32(FLOAT_BITS(p->x) + FLOAT_BITS(p->y)); } static bool cmp_point(const void *a, const void *b) { const struct point *pa = a, *pb = b; return pa->x == pb->x && pa->y == pb->y; } START_TEST(test_ghash_basic) { ghash_t *h = ghash_new(4, hash_point, cmp_point); static const struct point data[] = { { 1.0, 5.0 }, { 2.0, 3.5 }, { 1.9, 3.6 }, { 2.2, 5.7 }, { 7.9, 0.1 }, }; for (int i = 0; i < ARRAY_LEN(data); i++) ghash_put(h, &data[i], VOIDP(i + 1)); for (int i = 0; i < ARRAY_LEN(data); i++) ck_assert_ptr_eq(ghash_get(h, &data[i]), VOIDP(i + 1)); const struct point dummy = { 5.5, 1.0 }; ck_assert_ptr_null(ghash_get(h, &dummy)); const struct point elem = { 1.0, 5.0 }; ck_assert_ptr_nonnull(ghash_get(h, &elem)); ghash_delete(h, &elem); ck_assert_ptr_null(ghash_get(h, &elem)); ghash_free(h); } END_TEST; static int magnitude_compar(const void *a, const void *b) { return *(const uintptr_t*)a - *(const uintptr_t*)b; } static void walk_fn(uint64_t key, void *user, void *context) { uint64_t *last = context; fail_if(key != (uintptr_t)user); fail_if(*last > key); *last = key; } START_TEST(test_heap_basic) { heap_t *h = heap_new(128); heap_insert(h, 5, (void*)5); heap_insert(h, 2, (void*)2); heap_insert(h, 62, (void*)62); fail_unless(heap_size(h) == 3); fail_unless(heap_min(h) == (void*)2); fail_unless(heap_extract_min(h) == (void*)2); fail_unless(heap_extract_min(h) == (void*)5); fail_unless(heap_extract_min(h) == (void*)62); fail_unless(heap_size(h) == 0); heap_free(h); } END_TEST START_TEST(test_heap_walk) { heap_t *h = heap_new(128); heap_insert(h, 5, (void*)5); heap_insert(h, 2, (void*)2); heap_insert(h, 62, (void*)62); uint64_t last = 0; heap_walk(h, walk_fn, &last); fail_unless(last == 62); heap_free(h); } END_TEST START_TEST(test_heap_rand) { heap_t *h = heap_new(128); static const int N = 1024; uintptr_t keys[N]; for (int i = 0; i < N; i++) { keys[i] = rand(); heap_insert(h, keys[i], (void*)keys[i]); } qsort(keys, N, sizeof(uintptr_t), magnitude_compar); for (int i = 0; i < N; i++) fail_unless(heap_extract_min(h) == (void*)keys[i]); heap_free(h); } END_TEST static bool heap_delete_cb(uint64_t key, void *value, void *context) { ck_assert_int_eq(key, (uintptr_t)value); return value == context; } START_TEST(test_heap_delete) { heap_t *h = heap_new(128); static const int N = 1024; uintptr_t keys[N]; for (int i = 0; i < N; i++) { keys[i] = 1 + rand() % 10000; heap_insert(h, keys[i], (void*)keys[i]); } int deleted = 0; for (int i = 0; i < N; i++) { if (rand() % 20 == 0) { ck_assert(heap_delete(h, heap_delete_cb, (void*)keys[i])); keys[i] = 0; deleted++; } } ck_assert_int_eq(heap_size(h), N - deleted); qsort(keys, N, sizeof(uintptr_t), magnitude_compar); for (int i = 0; i < deleted; i++) ck_assert_int_eq(keys[i], 0); for (int i = deleted; i < N; i++) ck_assert_ptr_eq(heap_extract_min(h), (void*)keys[i]); heap_free(h); } END_TEST START_TEST(test_color_printf) { setenv("NVC_COLORS", "always", 1); term_init(); char *LOCAL str1 = color_asprintf("$red$hello$$"); ck_assert_str_eq(str1, "\033[31mhello\033[0m"); char *LOCAL str2 = color_asprintf("$#42$world$$"); ck_assert_str_eq(str2, "\033[38;5;42mworld\033[0m"); char *LOCAL str3 = color_asprintf("$!blue$bold$$ normal"); ck_assert_str_eq(str3, "\033[1;34mbold\033[0m normal"); char *LOCAL str4 = color_asprintf("a $bad$ color"); ck_assert_str_eq(str4, "a $bad$ color"); char *LOCAL str5 = color_asprintf("$!wrong$ end"); ck_assert_str_eq(str5, "$!wrong$ end"); char *LOCAL str6 = color_asprintf("$missing"); ck_assert_str_eq(str6, "$missing"); char *LOCAL str7 = color_asprintf("$<$$red$override$$$>$"); ck_assert_str_eq(str7, "override"); } END_TEST START_TEST(test_strip) { LOCAL_TEXT_BUF tb = tb_new(); tb_cat(tb, " hello world \r\n"); tb_strip(tb); ck_assert_str_eq(tb_get(tb), " hello world"); } END_TEST static const int mask_size[] = { 15, 64, 101, 160, 256 }; START_TEST(test_mask) { bit_mask_t m; mask_init(&m, mask_size[_i]); fail_if(mask_test(&m, 0)); fail_if(mask_test(&m, 5)); ck_assert_int_eq(mask_popcount(&m), 0); mask_set(&m, 4); fail_unless(mask_test(&m, 4)); fail_if(mask_test(&m, 5)); ck_assert_int_eq(mask_popcount(&m), 1); mask_clear(&m, 4); fail_if(mask_test(&m, 4)); mask_setall(&m); ck_assert_int_eq(mask_popcount(&m), mask_size[_i]); mask_clearall(&m); ck_assert_int_eq(mask_popcount(&m), 0); ck_assert(!mask_test_and_set(&m, 5)); ck_assert(mask_test_and_set(&m, 5)); mask_free(&m); } END_TEST START_TEST(test_set_clear_range) { bit_mask_t m; mask_init(&m, mask_size[_i]); fail_if(mask_test_range(&m, 0, mask_size[_i])); mask_set_range(&m, 1, 2); fail_if(mask_test(&m, 0)); fail_unless(mask_test(&m, 1)); fail_unless(mask_test(&m, 2)); fail_if(mask_test(&m, 3)); ck_assert_int_eq(mask_popcount(&m), 2); fail_unless(mask_test_range(&m, 0, 5)); if (mask_size[_i] > 64) { mask_set_range(&m, 70, 3); fail_if(mask_test(&m, 69)); fail_unless(mask_test(&m, 70)); fail_unless(mask_test(&m, 71)); fail_unless(mask_test(&m, 72)); fail_if(mask_test(&m, 73)); ck_assert_int_eq(mask_popcount(&m), 5); fail_unless(mask_test_range(&m, 60, 20)); mask_clear_range(&m, 71, 2); fail_if(mask_test(&m, 71)); ck_assert_int_eq(mask_popcount(&m), 3); } mask_free(&m); } END_TEST START_TEST(test_count_clear) { bit_mask_t m; mask_init(&m, mask_size[_i]); mask_set_range(&m, 3, 2); ck_assert_int_eq(mask_count_clear(&m, 0), 3); ck_assert_int_eq(mask_count_clear(&m, 1), 2); ck_assert_int_eq(mask_count_clear(&m, 2), 1); ck_assert_int_eq(mask_count_clear(&m, 3), 0); ck_assert_int_eq(mask_count_clear(&m, 4), 0); ck_assert_int_eq(mask_count_clear(&m, 5), mask_size[_i] - 5); if (mask_size[_i] > 64) { mask_clearall(&m); mask_set_range(&m, 70, 3); ck_assert_int_eq(mask_count_clear(&m, 0), 70); ck_assert_int_eq(mask_count_clear(&m, 64), 6); ck_assert_int_eq(mask_count_clear(&m, mask_size[_i] - 1), 1); } mask_free(&m); } END_TEST START_TEST(test_scan_backwards) { bit_mask_t m; mask_init(&m, mask_size[_i]); mask_set_range(&m, 3, 2); ck_assert_int_eq(mask_scan_backwards(&m, 0), -1); ck_assert_int_eq(mask_scan_backwards(&m, 5), 4); ck_assert_int_eq(mask_scan_backwards(&m, 4), 4); ck_assert_int_eq(mask_scan_backwards(&m, 3), 3); ck_assert_int_eq(mask_scan_backwards(&m, 2), -1); ck_assert_int_eq(mask_scan_backwards(&m, mask_size[_i] - 1), 4); if (mask_size[_i] > 64) { mask_set_range(&m, 70, 3); ck_assert_int_eq(mask_scan_backwards(&m, 0), -1); ck_assert_int_eq(mask_scan_backwards(&m, 75), 72); ck_assert_int_eq(mask_scan_backwards(&m, 72), 72); ck_assert_int_eq(mask_scan_backwards(&m, 71), 71); ck_assert_int_eq(mask_scan_backwards(&m, 69), 4); ck_assert_int_eq(mask_scan_backwards(&m, mask_size[_i] - 1), 72); } mask_free(&m); } END_TEST START_TEST(test_subtract) { bit_mask_t m1, m2; mask_init(&m1, mask_size[_i]); mask_init(&m2, mask_size[_i]); mask_setall(&m1); mask_setall(&m2); mask_subtract(&m1, &m2); ck_assert_int_eq(mask_popcount(&m1), 0); ck_assert_int_eq(mask_popcount(&m2), mask_size[_i]); mask_setall(&m1); mask_clearall(&m2); mask_set(&m2, 5); mask_set(&m2, 1); mask_subtract(&m1, &m2); ck_assert_int_eq(mask_popcount(&m1), mask_size[_i] - 2); fail_if(mask_test(&m1, 5)); fail_if(mask_test(&m1, 1)); fail_unless(mask_test(&m1, 4)); mask_free(&m1); mask_free(&m2); } END_TEST START_TEST(test_empty_mask) { bit_mask_t m; mask_init(&m, 0); mask_clearall(&m); mask_free(&m); } END_TEST START_TEST(test_mask_iter) { bit_mask_t m; mask_init(&m, 32); mask_set(&m, 1); mask_set(&m, 6); mask_set(&m, 17); size_t bit = -1; fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 1); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 6); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 17); fail_if(mask_iter(&m, &bit)); mask_free(&m); mask_init(&m, 600); mask_set(&m, 0); mask_set(&m, 6); mask_set(&m, 93); mask_set(&m, 422); mask_set(&m, 599); bit = -1; fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 0); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 6); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 93); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 422); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 599); fail_if(mask_iter(&m, &bit)); mask_free(&m); mask_init(&m, 85); mask_set(&m, 64); mask_set(&m, 70); bit = -1; fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 64); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 70); fail_if(mask_iter(&m, &bit)); mask_free(&m); mask_init(&m, 124); mask_set(&m, 56); mask_set(&m, 63); mask_set(&m, 69); mask_set(&m, 123); bit = -1; fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 56); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 63); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 69); fail_unless(mask_iter(&m, &bit)); fail_unless(bit == 123); fail_if(mask_iter(&m, &bit)); mask_free(&m); } END_TEST static volatile int counter = 0; static nvc_lock_t lock = 0; static void *thread_fn(void *__arg) { for (int i = 0; i < 10000; i++) { nvc_lock(&lock); counter++; nvc_unlock(&lock); } return NULL; } START_TEST(test_threads) { static const int N = 5; nvc_thread_t *threads[N]; for (int i = 0; i < N; i++) threads[i] = thread_create(thread_fn, NULL, "t%d", i); for (int i = 0; i < N; i++) thread_join(threads[i]); ck_assert_int_eq(counter, N * 10000); } END_TEST static void async_add_cb(void *context, void *arg) { (*(int *)arg)++; } START_TEST(test_async) { int numbers[100]; for (int i = 0; i < ARRAY_LEN(numbers); i++) numbers[i] = i; for (int i = 0; i < ARRAY_LEN(numbers); i++) async_do(async_add_cb, NULL, &(numbers[i])); async_barrier(); for (int i = 0; i < ARRAY_LEN(numbers); i++) ck_assert_int_eq(numbers[i], i + 1); } END_TEST static void stop_world_cb(int thread_id, struct cpu_state *cpu, void *arg) { // Avoid ck_assert* here as it does I/O assert(arg == (void *)0xdeadbeef); } static void *stop_world_thread_fn(void *__arg) { for (int i = 0; i < 100; i++) { stop_world(stop_world_cb, (void *)0xdeadbeef); start_world(); } return NULL; } START_TEST(test_stop_world) { static const int N = 5; nvc_thread_t *threads[N]; for (int i = 0; i < N; i++) threads[i] = thread_create(stop_world_thread_fn, NULL, "t%d", i); for (int i = 0; i < N; i++) thread_join(threads[i]); } END_TEST static void *barrier_fn(void *__arg) { barrier_t *b = __arg; static volatile int ctr = 0; atomic_add(&ctr, 1); barrier_wait(b); const int nthreads = atomic_load(&ctr); barrier_wait(b); for (int i = 0; i < 10; i++) { atomic_add(&ctr, 1); barrier_wait(b); ck_assert_int_eq(atomic_load(&ctr), nthreads * (i + 2)); barrier_wait(b); } return NULL; } START_TEST(test_barrier) { static const int N = 4; barrier_t *b = barrier_new(N); nvc_thread_t *threads[N]; for (int i = 0; i < N; i++) threads[i] = thread_create(barrier_fn, b, "t%d", i); for (int i = 0; i < N; i++) thread_join(threads[i]); barrier_free(b); } END_TEST START_TEST(test_pool_basic) { mem_pool_t *mp = pool_new(); uint8_t *p1 = pool_malloc(mp, 13); ck_assert_ptr_nonnull(p1); memset(p1, 42, 13); uint8_t *p2 = pool_calloc(mp, 3); ck_assert_ptr_nonnull(p2); ck_assert_int_eq(p2[0], 0); memset(p2, 66, 3); ck_assert_int_eq(p1[0], 42); ck_assert_int_eq(p1[12], 42); ck_assert_int_eq(p2[0], 66); ck_assert_int_eq(p2[2], 66); pool_free(mp); } END_TEST START_TEST(test_pool_stats) { mem_pool_t *mp = pool_new(); for (int i = 0; i < 100; i++) pool_malloc(mp, i); size_t alloc, npages; pool_stats(mp, &alloc, &npages); // Will vary with host word size and address sanitiser ck_assert_int_gt(alloc, 5000); ck_assert_int_lt(alloc, 7000); ck_assert_int_eq(npages, 2); pool_free(mp); } END_TEST START_TEST(test_cmp_bytes) { unsigned char a[50 + 15], b[50 + 15]; for (int i = 0; i < ARRAY_LEN(a); i++) a[i] = b[i] = i; for (int size = 0; size < 50; size++) { a[size + 1] = 200; b[size + 1] = 201; ck_assert(cmp_bytes(a, b, size)); for (int diffpos = 0; diffpos < size; diffpos++) { a[diffpos] = 255; ck_assert(!cmp_bytes(a, b, size)); a[diffpos] = diffpos; b[diffpos] = 255; ck_assert(!cmp_bytes(a, b, size)); b[diffpos] = diffpos; } a[size + 1] = b[size + 1] = size + 1; } } END_TEST START_TEST(test_copy2) { unsigned char a[50 + 15], b[50 + 15], c[50 + 15]; for (int i = 0; i < ARRAY_LEN(a); i++) c[i] = 100 + i; for (int size = 0; size < 50; size++) { for (int i = 0; i < ARRAY_LEN(a); i++) { a[i] = 255; b[i] = i; } copy2(a, b, c, size); for (int i = 0; i < ARRAY_LEN(a); i++) { if (i < size) { ck_assert_int_eq(a[i], i); ck_assert_int_eq(b[i], 100 + i); } else { ck_assert_int_eq(a[i], 255); ck_assert_int_eq(b[i], i); } } } } END_TEST Suite *get_misc_tests(void) { Suite *s = suite_create("misc"); TCase *tc_hash = tcase_create("hash"); tcase_add_test(tc_hash, test_hash_basic); tcase_add_test(tc_hash, test_hash_rand); tcase_add_test(tc_hash, test_hash_delete); tcase_add_test(tc_hash, test_shash_basic); tcase_add_test(tc_hash, test_shash_rand); tcase_add_test(tc_hash, test_ihash_rand); tcase_add_test(tc_hash, test_hset_rand); tcase_add_test(tc_hash, test_chash_rand); tcase_add_test(tc_hash, test_chash_cas); tcase_add_test(tc_hash, test_ghash_basic); suite_add_tcase(s, tc_hash); TCase *tc_heap = tcase_create("heap"); tcase_add_test(tc_heap, test_heap_basic); tcase_add_test(tc_heap, test_heap_rand); tcase_add_test(tc_heap, test_heap_walk); tcase_add_test(tc_heap, test_heap_delete); suite_add_tcase(s, tc_heap); TCase *tc_util = tcase_create("util"); tcase_add_test(tc_util, test_color_printf); tcase_add_test(tc_util, test_strip); suite_add_tcase(s, tc_util); TCase *tc_mask = tcase_create("mask"); tcase_add_loop_test(tc_mask, test_mask, 0, ARRAY_LEN(mask_size)); tcase_add_loop_test(tc_mask, test_set_clear_range, 0, ARRAY_LEN(mask_size)); tcase_add_loop_test(tc_mask, test_count_clear, 0, ARRAY_LEN(mask_size)); tcase_add_loop_test(tc_mask, test_scan_backwards, 0, ARRAY_LEN(mask_size)); tcase_add_loop_test(tc_mask, test_subtract, 0, ARRAY_LEN(mask_size)); tcase_add_test(tc_mask, test_empty_mask); tcase_add_test(tc_mask, test_mask_iter); suite_add_tcase(s, tc_mask); TCase *tc_thread = tcase_create("thread"); tcase_add_test(tc_thread, test_threads); tcase_add_test(tc_thread, test_async); #ifndef __SANITIZE_THREAD__ tcase_add_test(tc_thread, test_stop_world); #endif tcase_add_test(tc_thread, test_barrier); suite_add_tcase(s, tc_thread); TCase *tc_pool = tcase_create("pool"); tcase_add_test(tc_pool, test_pool_basic); tcase_add_test(tc_pool, test_pool_stats); suite_add_tcase(s, tc_pool); TCase *tc_copy = tcase_create("copy"); tcase_add_test(tc_pool, test_cmp_bytes); tcase_add_test(tc_pool, test_copy2); suite_add_tcase(s, tc_copy); return s; } nvc-r1.17.1/test/test_model.c000066400000000000000000000275371504111170000160370ustar00rootroot00000000000000// // Copyright (C) 2022-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "jit/jit.h" #include "option.h" #include "phase.h" #include "rt/model.h" #include "rt/structs.h" #include "scan.h" #include "type.h" START_TEST(test_basic1) { input_from_file(TESTDIR "/model/basic1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); tree_t b0 = tree_stmt(top, 0); tree_t x = tree_decl(b0, 1); fail_unless(tree_kind(x) == T_SIGNAL_DECL); tree_t y = tree_decl(b0, 2); fail_unless(tree_kind(y) == T_SIGNAL_DECL); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); model_reset(m); rt_signal_t *xs = find_signal(root, x); fail_if(xs == NULL); ck_assert_int_eq(xs->n_nexus, 1); ck_assert_int_eq(xs->nexus.width, 1); ck_assert_int_eq(xs->shared.size, 4); const int32_t *xp = signal_value(xs); ck_assert_int_eq(*xp, 42); rt_signal_t *ys = find_signal(root, y); fail_if(ys == NULL); const int8_t *yp = signal_value(ys); ck_assert_int_eq(*yp, 1); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_index1) { input_from_file(TESTDIR "/model/index1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); tree_t b0 = tree_stmt(top, 0); tree_t s1 = get_decl(b0, "S1"); tree_t s2 = get_decl(b0, "S2"); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); model_reset(m); rt_signal_t *ss1 = find_signal(root, s1); fail_if(ss1 == NULL); rt_signal_t *ss2 = find_signal(root, s2); fail_if(ss2 == NULL); model_run(m, UINT64_MAX); ck_assert_int_eq(ss1->n_nexus, 21); ck_assert_int_eq(ss1->nexus.width, 8); ck_assert_ptr_nonnull(ss1->index); ck_assert_int_eq(ss1->index->how, 3); ck_assert_ptr_eq(ss1->index->nexus[0], &(ss1->nexus)); ck_assert_ptr_nonnull(ss1->index->nexus[20]); ck_assert_ptr_null(ss1->index->nexus[21]); ck_assert_int_eq(ss2->n_nexus, 41); ck_assert_int_eq(ss2->nexus.width, 10); ck_assert_ptr_nonnull(ss2->index); ck_assert_int_eq(ss2->index->how, -10); ck_assert_ptr_eq(ss2->index->nexus[0], &(ss2->nexus)); ck_assert_ptr_nonnull(ss2->index->nexus[40]); ck_assert_ptr_null(ss2->index->nexus[41]); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_alias1) { input_from_file(TESTDIR "/model/alias1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); model_run(m, UINT64_MAX); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_fast1) { input_from_file(TESTDIR "/model/fast1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); rt_signal_t *sx = find_signal(root, get_decl(b0, "X")); fail_if(sx == NULL); fail_unless(sx->n_nexus == 1); fail_unless(sx->nexus.flags & NET_F_FAST_DRIVER); fail_if(model_step(m)); fail_unless(sx->nexus.flags & NET_F_FAST_DRIVER); fail_unless(sx->nexus.sources.fastqueued); ck_assert_int_eq(*(int32_t *)sx->shared.data, 0); fail_if(model_step(m)); unsigned deltas; ck_assert_int_eq(model_now(m, &deltas), 0); ck_assert_int_eq(deltas, 1); fail_if(sx->nexus.flags & NET_F_FAST_DRIVER); fail_if(sx->nexus.sources.fastqueued); ck_assert_int_eq(*(int32_t *)sx->shared.data, 1); fail_unless(model_step(m)); ck_assert_int_eq(model_now(m, &deltas), 1000000); ck_assert_int_eq(deltas, 0); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_stateless1) { input_from_file(TESTDIR "/model/stateless1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); ck_assert_int_eq(tree_stmts(b0), 2); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); rt_proc_t *p1 = find_proc(root, tree_stmt(b0, 0)); ck_assert_ptr_nonnull(p1); ck_assert_str_eq(istr(p1->name), ":stateless1:p1"); ck_assert_ptr_null(*mptr_get(p1->privdata)); rt_proc_t *p2 = find_proc(root, tree_stmt(b0, 1)); ck_assert_ptr_nonnull(p2); ck_assert_str_eq(istr(p2->name), ":stateless1:p2"); ck_assert_ptr_nonnull(*mptr_get(p2->privdata)); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_pending1) { input_from_file(TESTDIR "/model/pending1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); ck_assert_int_eq(tree_stmts(b0), 2); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); rt_proc_t *pwakeup = find_proc(root, tree_stmt(b0, 0)); ck_assert_ptr_nonnull(pwakeup); ck_assert_str_eq(istr(pwakeup->name), ":pending1:wakeup"); rt_proc_t *pstim = find_proc(root, tree_stmt(b0, 1)); ck_assert_ptr_nonnull(pstim); ck_assert_str_eq(istr(pstim->name), ":pending1:stim"); rt_signal_t *sx = find_signal(root, get_decl(b0, "X")); fail_if(sx == NULL); fail_unless(sx->n_nexus == 1); ck_assert_ptr_null(sx->nexus.pending); model_step(m); ck_assert_int_eq(pointer_tag(sx->nexus.pending), 1); ck_assert_ptr_eq(untag_pointer(sx->nexus.pending, rt_wakeable_t), &(pwakeup->wakeable)); model_step(m); ck_assert_int_eq(pointer_tag(sx->nexus.pending), 1); ck_assert_ptr_eq(untag_pointer(sx->nexus.pending, rt_wakeable_t), &(pwakeup->wakeable)); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_fast2) { input_from_file(TESTDIR "/model/fast2.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); rt_signal_t *sx = find_signal(root, get_decl(b0, "X")); fail_if(sx == NULL); ck_assert_int_eq(sx->n_nexus, 1); fail_unless(sx->nexus.flags & NET_F_FAST_DRIVER); fail_if(sx->shared.flags & NET_F_FAST_DRIVER); rt_source_t *d0 = &(sx->nexus.sources); fail_unless(d0->tag == SOURCE_DRIVER); fail_if(d0->fastqueued); fail_if(d0->sigqueued); fail_if(model_step(m)); unsigned deltas; ck_assert_int_eq(model_now(m, &deltas), 0); ck_assert_int_eq(deltas, 0); ck_assert_int_eq(sx->n_nexus, 8); fail_unless(d0->fastqueued); fail_if(d0->sigqueued); fail_unless(sx->shared.flags & NET_F_FAST_DRIVER); fail_if(model_step(m)); ck_assert_int_eq(model_now(m, &deltas), 0); ck_assert_int_eq(deltas, 1); ck_assert_int_eq(sx->n_nexus, 8); fail_if(d0->fastqueued); fail_if(d0->sigqueued); fail_unless(sx->shared.flags & NET_F_FAST_DRIVER); fail_if(model_step(m)); ck_assert_int_eq(model_now(m, &deltas), 1000000); ck_assert_int_eq(deltas, 0); fail_unless(d0->fastqueued); fail_unless(d0->sigqueued); fail_unless(sx->shared.flags & NET_F_FAST_DRIVER); fail_if(model_step(m)); fail_if(d0->fastqueued); fail_if(d0->sigqueued); fail_unless(sx->shared.flags & NET_F_FAST_DRIVER); fail_if(model_step(m)); fail_if(d0->fastqueued); fail_unless(d0->sigqueued); fail_unless(sx->nexus.chain->sources.fastqueued); fail_if(sx->nexus.chain->sources.sigqueued); fail_unless(sx->shared.flags & NET_F_FAST_DRIVER); fail_unless(model_step(m)); fail_if(d0->fastqueued); fail_if(d0->sigqueued); fail_if(sx->shared.flags & NET_F_FAST_DRIVER); // Not profitable model_free(m); fail_if_errors(); } END_TEST START_TEST(test_event1) { input_from_file(TESTDIR "/model/event1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); jit_t *j = get_jit(); jit_reset(j); rt_model_t *m = model_new(j, NULL); create_scope(m, top, NULL); model_reset(m); tree_t b0 = tree_stmt(top, 0); rt_scope_t *root = find_scope(m, b0); fail_if(root == NULL); rt_signal_t *ss = find_signal(root, get_decl(b0, "S")); fail_if(ss == NULL); fail_if(ss->shared.flags & SIG_F_CACHE_EVENT); rt_signal_t *st = find_signal(root, get_decl(b0, "T")); fail_if(st == NULL); fail_if(st->shared.flags & SIG_F_CACHE_EVENT); fail_if(model_step(m)); fail_unless(ss->shared.flags & SIG_F_CACHE_EVENT); fail_if(ss->shared.flags & SIG_F_EVENT_FLAG); fail_if(st->shared.flags & SIG_F_CACHE_EVENT); fail_if(st->shared.flags & SIG_F_EVENT_FLAG); fail_if(model_step(m)); fail_unless(ss->shared.flags & SIG_F_CACHE_EVENT); fail_unless(ss->shared.flags & SIG_F_EVENT_FLAG); fail_if(st->shared.flags & SIG_F_CACHE_EVENT); fail_if(st->shared.flags & SIG_F_EVENT_FLAG); fail_unless(model_step(m)); fail_unless(ss->shared.flags & SIG_F_CACHE_EVENT); fail_if(ss->shared.flags & SIG_F_EVENT_FLAG); fail_if(st->shared.flags & SIG_F_CACHE_EVENT); fail_if(st->shared.flags & SIG_F_EVENT_FLAG); model_free(m); fail_if_errors(); } END_TEST START_TEST(test_process1) { input_from_file(TESTDIR "/model/process1.vhd"); const error_t expect[] = { { 10, "hello, world" }, { 13, "after 1 ns" }, { -1, NULL }, }; expect_errors(expect); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(a), j, ur, mc, NULL, NULL, m); ck_assert_ptr_nonnull(top); model_reset(m); tree_t b0 = tree_stmt(top, 0); rt_scope_t *root = find_scope(m, b0); ck_assert_ptr_nonnull(root); rt_proc_t *p1 = find_proc(root, tree_stmt(b0, 0)); ck_assert_ptr_nonnull(p1); void *p1_state = *mptr_get(p1->privdata); ck_assert_ptr_nonnull(p1_state); int32_t *fsm_ptr = p1_state + 2*sizeof(void *); ck_assert_int_eq(*fsm_ptr, 1); int32_t *x_ptr = p1_state + 2*sizeof(void *) + sizeof(int32_t); ck_assert_int_eq(*x_ptr, INT32_MIN); model_step(m); ck_assert_int_eq(*fsm_ptr, 2); ck_assert_int_eq(*x_ptr, 42); model_step(m); ck_assert_int_eq(*fsm_ptr, 3); ck_assert_int_eq(*x_ptr, 43); model_free(m); jit_free(j); check_expected_errors(); } END_TEST Suite *get_model_tests(void) { Suite *s = suite_create("model"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_basic1); tcase_add_test(tc, test_index1); tcase_add_test(tc, test_alias1); tcase_add_test(tc, test_fast1); tcase_add_test(tc, test_stateless1); tcase_add_test(tc, test_pending1); tcase_add_test(tc, test_fast2); tcase_add_test(tc, test_event1); tcase_add_test(tc, test_process1); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_mspace.c000066400000000000000000000166631504111170000162050ustar00rootroot00000000000000// // Copyright (C) 2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "rt/mspace.h" #include START_TEST(test_sanity) { mspace_t *m = mspace_new(1024); int *ptr1 = mspace_alloc(m, sizeof(int)); ck_assert_ptr_nonnull(ptr1); *ptr1 = 42; int *ptr2 = mspace_alloc(m, sizeof(int)); ck_assert_ptr_nonnull(ptr2); ck_assert_ptr_ne(ptr1, ptr2); *ptr2 = 55; ck_assert_ptr_null(mspace_alloc(m, 0)); int *array = mspace_alloc(m, 50 * sizeof(int)); array[49] = 1234; array = NULL; // Do enough allocations to trigger a GC for (int i = 0; i < 1000; i++) { int *garbage = mspace_alloc(m, sizeof(int)); ck_assert_ptr_nonnull(garbage); ck_assert_ptr_ne(garbage, ptr1); ck_assert_ptr_ne(garbage, ptr2); *garbage = 0xdead; } ck_assert_int_eq(*ptr1, 42); ck_assert_int_eq(*ptr2, 55); mspace_destroy(m); } END_TEST __attribute__((noinline)) static int **get_indirect(mspace_t *m) { int *ptr1 = mspace_alloc(m, sizeof(int)); ck_assert_ptr_nonnull(ptr1); *ptr1 = 42; int **ptr2 = mspace_alloc(m, sizeof(int *)); ck_assert_ptr_nonnull(ptr2); ck_assert_ptr_ne(ptr1, ptr2); *ptr2 = ptr1; return ptr2; } __attribute__((noinline)) static void generate_garbage(mspace_t *m, int count, size_t size) { for (int i = 0; i < count; i++) { int *garbage = mspace_alloc(m, size); ck_assert_ptr_nonnull(garbage); *garbage = 0xdead; } } START_TEST(test_indirect) { mspace_t *m = mspace_new(1024); // Do a few dummy allocations to ensure the pointer is not in the // first line which is often kept alive by stack pointers to m->space generate_garbage(m, 5, sizeof(int)); int *volatile* ptr2 = get_indirect(m); // Do enough allocations to trigger a GC generate_garbage(m, 1000, sizeof(int)); ck_assert_int_eq(**ptr2, 42); mspace_destroy(m); } END_TEST START_TEST(test_mptr) { mspace_t *m = mspace_new(1024); // Do a few dummy allocations to ensure the pointer is not in the // first line which is often kept alive by stack pointers to m->space generate_garbage(m, 5, sizeof(int)); mptr_t p = mptr_new(m, "test"); *mptr_get(p) = mspace_alloc(m, sizeof(int)); *(int *)*mptr_get(p) = 42; // Do enough allocations to trigger a GC generate_garbage(m, 1000, sizeof(int)); ck_assert_int_eq(*(int *)*mptr_get(p), 42); mptr_free(m, &p); ck_assert_ptr_eq(p, MPTR_INVALID); mspace_destroy(m); } END_TEST START_TEST(test_large) { mspace_t *m = mspace_new(5 * 1024); // Do a few dummy allocations to ensure the pointer is not in the // first line which is often kept alive by stack pointers to m->space generate_garbage(m, 50, sizeof(int)); int *volatile* parray = get_indirect(m); *parray = mspace_alloc(m, 100 * sizeof(int)); (*parray)[99] = 1234; // Do enough allocations to trigger a GC generate_garbage(m, 1000, 5 * sizeof(int)); ck_assert_int_eq((*parray)[99], 1234); mspace_destroy(m); } END_TEST START_TEST(test_interior) { mspace_t *m = mspace_new(5 * 1024); // Do a few dummy allocations to ensure the pointer is not in the // first line which is often kept alive by stack pointers to m->space generate_garbage(m, 10, sizeof(int)); int *volatile* parray = get_indirect(m); // Interior pointers keep the whole allocation alive *parray = mspace_alloc(m, 100 * sizeof(int)) + (13 * sizeof(int)); (*parray)[49] = 1234; // Do enough allocations to trigger a GC generate_garbage(m, 1000, 5 * sizeof(int)); ck_assert_int_eq((*parray)[49], 1234); mspace_destroy(m); } END_TEST static size_t oom_sz = 0; static void test_oom_cb(mspace_t *m, size_t size) { oom_sz = size; } START_TEST(test_oom) { mspace_t *m = mspace_new(1024); mspace_set_oom_handler(m, test_oom_cb); void *p = mspace_alloc(m, 1000000); ck_assert_ptr_null(p); ck_assert_int_eq(oom_sz, 1000000); mspace_destroy(m); } END_TEST START_TEST(test_linked_list) { struct list { struct list *next; int value; }; mspace_t *m = mspace_new(4096); struct list *head = NULL, **tailp = &head; for (int i = 0; i < 40; i++) { struct list *l = mspace_alloc(m, sizeof(struct list)); l->value = i; l->next = NULL; *tailp = l; tailp = &(l->next); // Do some dummy allocations to make sure the nodes are at random // locations in the heap for (int i = 0; i < 10; i++) { int *garbage = mspace_alloc(m, (1 + rand() % 10) * sizeof(int)); ck_assert_ptr_nonnull(garbage); *garbage = 0xdead; } } struct list *it = head; for (int i = 0; i < 40; i++, it = it->next) ck_assert_int_eq(it->value, i); mspace_destroy(m); } END_TEST __attribute__((noinline)) static void put_value(mspace_t *m, int **ptr, int value) { int *st = mspace_alloc(m, sizeof(int)); *st = value; *ptr = st; } START_TEST(test_tlab) { mspace_t *m = mspace_new(2 * TLAB_SIZE); tlab_t *t = tlab_acquire(m); int *precious = tlab_alloc(t, sizeof(int)); *precious = 0xbeef; int **array = tlab_alloc(t, sizeof(int *) * 10); for (int i = 0; i < 10; i++) put_value(m, array + i, i); int **p1 = tlab_alloc(t, sizeof(int *)); *p1 = precious; for (int i = 0; i < 1000; i++) { int *array = tlab_alloc(t, 50 * sizeof(int)); array[0] = 123; for (int i = 0; i < 10; i++) { int *garbage = mspace_alloc(m, sizeof(int)); ck_assert_ptr_nonnull(garbage); *garbage = 0xdead; } } ck_assert_int_eq(*precious, 0xbeef); for (int i = 0; i < 10; i++) ck_assert_int_eq(*array[i], i); tlab_release(t); mspace_destroy(m); } END_TEST START_TEST(test_end_ptr) { mspace_t *m = mspace_new(5 * 1024); // Do a few dummy allocations to ensure the pointer is not in the // first line which is often kept alive by stack pointers to m->space generate_garbage(m, 50, sizeof(int)); // Size is a multiple of LINE_SIZE static const int SIZE = 64; int *volatile array = mspace_alloc(m, SIZE * sizeof(int)); for (int i = 0; i < SIZE; i++) *array++ = i; // Now array points one past the end of the of the allocation // Do enough allocations to trigger a GC generate_garbage(m, 1000, 5 * sizeof(int)); ck_assert_int_eq(array[-SIZE], 0); ck_assert_int_eq(array[-1], SIZE - 1); mspace_destroy(m); } END_TEST Suite *get_mspace_tests(void) { Suite *s = suite_create("mspace"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_sanity); tcase_add_test(tc, test_indirect); tcase_add_test(tc, test_mptr); tcase_add_test(tc, test_large); tcase_add_test(tc, test_interior); tcase_add_test(tc, test_oom); tcase_add_test(tc, test_linked_list); tcase_add_test(tc, test_tlab); tcase_add_test(tc, test_end_ptr); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_native.c000066400000000000000000001203501504111170000162100ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "jit/jit-priv.h" #include "jit/jit.h" #include "option.h" #include #include static jit_handle_t assemble(jit_t *j, const char *text, const char *name, const char *ss) { jit_handle_t h = jit_assemble(j, ident_new(name), text); LOCAL_TEXT_BUF tb = tb_new(); tb_append(tb, 'v'); for (; *ss; ss++) { switch (*ss) { case 'i': tb_append(tb, FFI_INT32); break; case 'I': tb_append(tb, FFI_INT64); break; case 'p': tb_append(tb, FFI_POINTER); break; case 'f': tb_append(tb, FFI_FLOAT); break; default: fatal_trace("invalid character '%c' in spec", *ss); } } ck_assert_int_le(tb_len(tb), 7); // Would have to copy otherwise jit_get_func(j, h)->spec = ffi_spec_new(tb_get(tb), tb_len(tb)); return h; } static jit_t *get_native_jit(void) { opt_set_int(OPT_JIT_THRESHOLD, 1); opt_set_int(OPT_JIT_ASYNC, 0); jit_t *j = jit_new(NULL, NULL); jit_register_native_plugin(j); return j; } START_TEST(test_add) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "add1", "II"); ck_assert_int_eq(jit_call(j, h1, 1, 2).integer, 3); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 5); ck_assert_int_eq(jit_call(j, h1, INT64_MAX, 1).integer, INT64_MIN); ck_assert_int_eq(jit_call(j, h1, 5, INT64_C(-7)).integer, -2); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD.O.32 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "add2", "ii"); ck_assert_int_eq(jit_call(j, h2, 1, 2).integer, 0); ck_assert_int_eq(jit_call(j, h2, INT32_MAX, 1).integer, 1); ck_assert_int_eq(jit_call(j, h2, INT32_MAX, INT32_MAX).integer, 1); ck_assert_int_eq(jit_call(j, h2, INT32_MIN, INT32_MIN).integer, 1); ck_assert_int_eq(jit_call(j, h2, INT32_MIN, INT32_MAX).integer, 0); ck_assert_int_eq(jit_call(j, h2, INT32_MIN, INT32_C(-1)).integer, 1); const char *text3 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD.O.8 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "add3", "ii"); ck_assert_int_eq(jit_call(j, h3, 1, 2).integer, 0); ck_assert_int_eq(jit_call(j, h3, 127, 1).integer, 1); ck_assert_int_eq(jit_call(j, h3, -128, 1).integer, 0); ck_assert_int_eq(jit_call(j, h3, -128, 1000).integer, 1); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD.O.16 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "add4", "ii"); ck_assert_int_eq(jit_call(j, h4, 1, 2).integer, 0); ck_assert_int_eq(jit_call(j, h4, INT16_MAX, 1).integer, 1); ck_assert_int_eq(jit_call(j, h4, INT16_MIN, 1).integer, 0); ck_assert_int_eq(jit_call(j, h4, -128, 5000).integer, 0); const char *text5 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD.C.32 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "add5", "ii"); ck_assert_int_eq(jit_call(j, h5, 1, 2).integer, 0); ck_assert_int_eq(jit_call(j, h5, INT32_MAX, 1).integer, 0); ck_assert_int_eq(jit_call(j, h5, UINT32_MAX, 1).integer, 1); ck_assert_int_eq(jit_call(j, h5, INT32_MAX, INT32_MAX).integer, 0); ck_assert_int_eq(jit_call(j, h5, UINT32_MAX, UINT32_MAX).integer, 1); const char *text6 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD.8 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h6 = assemble(j, text6, "add6", "ii"); ck_assert_int_eq(jit_call(j, h6, 1, 2).integer, 3); ck_assert_int_eq(jit_call(j, h6, 2, 3).integer, 5); ck_assert_int_eq(jit_call(j, h6, 2, -3).integer, -1); const char *text7 = " RECV R0, #0 \n" " ADD.O.8 R1, R0, #1 \n" " CSET R2 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h7 = assemble(j, text7, "add7", "i"); ck_assert_int_eq(jit_call(j, h7, 127).integer, 1); ck_assert_int_eq(jit_call(j, h7, -127).integer, 0); ck_assert_int_eq(jit_call(j, h7, 5).integer, 0); ck_assert_int_eq(jit_call(j, h7, 127).integer, 1); const char *text8 = " RECV R0, #0 \n" " ADD.O.16 R1, R0, #1 \n" " CSET R2 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h8 = assemble(j, text8, "add8", "i"); ck_assert_int_eq(jit_call(j, h8, INT16_MAX).integer, 1); ck_assert_int_eq(jit_call(j, h8, INT16_MIN).integer, 0); ck_assert_int_eq(jit_call(j, h8, 5).integer, 0); ck_assert_int_eq(jit_call(j, h8, INT16_MAX).integer, 1); jit_free(j); } END_TEST START_TEST(test_mul) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "mul1", "II"); ck_assert_int_eq(jit_call(j, h1, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 6); ck_assert_int_eq(jit_call(j, h1, INT64_C(-5), 2).integer, -10); ck_assert_int_eq(jit_call(j, h1, INT64_C(-5), INT64_C(-6)).integer, 30); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL.O.32 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "mul2", "ii"); ck_assert_int_eq(jit_call(j, h2, 4, 1).integer, 0); ck_assert_int_eq(jit_call(j, h2, INT32_MAX/2, 2).integer, 0); ck_assert_int_eq(jit_call(j, h2, INT32_MAX, 2).integer, 1); ck_assert_int_eq(jit_call(j, h2, INT32_MAX, INT32_C(-1)).integer, 0); ck_assert_int_eq(jit_call(j, h2, INT32_MIN, INT32_C(-1)).integer, 1); ck_assert_int_eq(jit_call(j, h2, INT64_C(-5), INT64_C(-6)).integer, 0); const char *text3 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL.C.32 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "mul3", "ii"); ck_assert_int_eq(jit_call(j, h3, 4, 1).integer, 0); ck_assert_int_eq(jit_call(j, h3, INT32_MAX/2, 2).integer, 0); ck_assert_int_eq(jit_call(j, h3, INT32_MAX, 2).integer, 0); ck_assert_int_eq(jit_call(j, h3, UINT32_MAX, 2).integer, 1); ck_assert_int_eq(jit_call(j, h3, UINT32_MAX, UINT32_MAX).integer, 1); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL.32 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "mul4", "ii"); ck_assert_int_eq(jit_call(j, h4, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h4, 2, 3).integer, 6); ck_assert_int_eq(jit_call(j, h4, INT32_C(-5), 2).integer, -10); ck_assert_int_eq(jit_call(j, h4, INT32_C(-5), INT64_C(-6)).integer, 30); const char *text5 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL.O.16 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "mul5", "ii"); ck_assert_int_eq(jit_call(j, h5, 1, 1).integer, 0); ck_assert_int_eq(jit_call(j, h5, 64, 2).integer, 0); ck_assert_int_eq(jit_call(j, h5, 256, 256).integer, 1); ck_assert_int_eq(jit_call(j, h5, 256, 255).integer, 1); const char *text6 = " RECV R0, #0 \n" " RECV R1, #1 \n" " MUL.C.16 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h6 = assemble(j, text6, "mul6", "ii"); ck_assert_int_eq(jit_call(j, h6, 1, 1).integer, 0); ck_assert_int_eq(jit_call(j, h6, 64, 2).integer, 0); ck_assert_int_eq(jit_call(j, h6, 256, 256).integer, 1); ck_assert_int_eq(jit_call(j, h6, 256, 255).integer, 0); const char *text7 = " RECV R0, #0 \n" " MUL R1, R0, #2 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h7 = assemble(j, text7, "mul7", "i"); ck_assert_int_eq(jit_call(j, h7, 1).integer, 2); ck_assert_int_eq(jit_call(j, h7, 64).integer, 128); ck_assert_int_eq(jit_call(j, h7, 256).integer, 512); ck_assert_int_eq(jit_call(j, h7, -8).integer, -16); jit_free(j); } END_TEST START_TEST(test_div) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " DIV R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "div1", "II"); ck_assert_int_eq(jit_call(j, h1, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 0); ck_assert_int_eq(jit_call(j, h1, 100, 5).integer, 20); ck_assert_int_eq(jit_call(j, h1, INT64_C(-50), 6).integer, -8); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " DIV.16 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "div2", "ii"); ck_assert_int_eq(jit_call(j, h2, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h2, 2, 3).integer, 0); ck_assert_int_eq(jit_call(j, h2, 100, 5).integer, 20); ck_assert_int_eq(jit_call(j, h2, INT32_C(-50), 6).integer, -8); const char *text3 = " RECV R0, #0 \n" " RECV R1, #1 \n" " DIV.32 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "div3", "ii"); ck_assert_int_eq(jit_call(j, h3, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h3, 2, 3).integer, 0); ck_assert_int_eq(jit_call(j, h3, 100, 5).integer, 20); ck_assert_int_eq(jit_call(j, h3, INT32_C(-50), 6).integer, -8); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " DIV.8 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "div4", "ii"); ck_assert_int_eq(jit_call(j, h4, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h4, 2, 3).integer, 0); ck_assert_int_eq(jit_call(j, h4, 100, 5).integer, 20); ck_assert_int_eq(jit_call(j, h4, INT32_C(-50), 6).integer, -8); ck_assert_int_eq(jit_call(j, h4, 50, INT32_C(-6)).integer, -8); const char *text5 = " RECV R0, #0 \n" " RECV R1, #1 \n" " DIV.16 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "div5", "ii"); ck_assert_int_eq(jit_call(j, h5, 4, 1).integer, 4); ck_assert_int_eq(jit_call(j, h5, 2, 3).integer, 0); ck_assert_int_eq(jit_call(j, h5, 100, 5).integer, 20); ck_assert_int_eq(jit_call(j, h5, INT32_C(-50), 6).integer, -8); ck_assert_int_eq(jit_call(j, h5, 5000, INT32_C(-6)).integer, -833); jit_free(j); } END_TEST START_TEST(test_rem) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " REM R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "rem1", "II"); ck_assert_int_eq(jit_call(j, h1, 4, 1).integer, 0); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 2); ck_assert_int_eq(jit_call(j, h1, 100, 6).integer, 4); ck_assert_int_eq(jit_call(j, h1, INT64_C(-50), 6).integer, -2); ck_assert_int_eq(jit_call(j, h1, 6, INT64_C(-50)).integer, 6); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " REM.16 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "rem2", "ii"); ck_assert_int_eq(jit_call(j, h2, 4, 1).integer, 0); ck_assert_int_eq(jit_call(j, h2, 2, 3).integer, 2); ck_assert_int_eq(jit_call(j, h2, 100, 6).integer, 4); ck_assert_int_eq(jit_call(j, h2, INT32_C(-50), 6).integer, -2); ck_assert_int_eq(jit_call(j, h2, 6, INT32_C(-50)).integer, 6); jit_free(j); } END_TEST static void test_call_diag_fn(diag_t *d, void *context) { ck_assert_str_eq(diag_get_text(d), "executed unreachable instruction"); int *state = context; switch ((*state)++) { case 0: ck_assert_int_eq(diag_traces(d), 1); ck_assert_str_eq(diag_get_trace(d, 0), "do_unreachable"); break; case 1: case 2: ck_assert_int_eq(diag_traces(d), 2); ck_assert_str_eq(diag_get_trace(d, 0), "do_unreachable"); ck_assert_str_eq(diag_get_trace(d, 1), "do_atest"); break; default: ck_abort_msg("unexpected call to test_call_diag_fn"); } } START_TEST(test_call) { jit_t *j = get_native_jit(); const char *do_add = " RECV R0, #0 \n" " RECV R1, #1 \n" " ADD R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; const char *do_double = " RECV R0, #0 \n" " SEND #1, R0 \n" " CALL \n" " RET \n"; assemble(j, do_add, "do_add", "II"); jit_handle_t h_double = assemble(j, do_double, "do_double", "II"); ck_assert_int_eq(jit_call(j, h_double, 4).integer, 8); ck_assert_int_eq(jit_call(j, h_double, 2).integer, 4); ck_assert_int_eq(jit_call(j, h_double, 5).integer, 10); int state = 0; diag_set_consumer(test_call_diag_fn, &state); const char *do_unreachable = " SEND #0, #0 \n" " $EXIT #4 \n" " RET \n"; jit_handle_t h_unreachable = assemble(j, do_unreachable, "do_unreachable", ""); jit_scalar_t result; fail_if(jit_try_call(j, h_unreachable, &result)); const char *do_atest = " CALL \n" " RET \n"; jit_handle_t h_atest = assemble(j, do_atest, "do_atest", "pI"); fail_if(jit_try_call(j, h_atest, &result)); fail_if(jit_try_call(j, h_atest, &result)); ck_assert_int_eq(state, 3); jit_free(j); } END_TEST START_TEST(test_stack) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " $SALLOC R1, #0, #4 \n" " STORE.32 R0, [R1] \n" " LOAD.32 R2, [R1] \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "stack1", "i"); ck_assert_int_eq(jit_call(j, h1, 4).integer, 4); ck_assert_int_eq(jit_call(j, h1, 5).integer, 5); ck_assert_int_eq(jit_call(j, h1, INT32_C(-5)).integer, -5); const char *text2 = " RECV R0, #0 \n" " $SALLOC R1, #0, #1 \n" " STORE.8 R0, [R1] \n" " MOV R2, #0xdeadbeef \n" " ULOAD.8 R2, [R1] \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "stack2", "i"); ck_assert_int_eq(jit_call(j, h2, 4).integer, 4); ck_assert_int_eq(jit_call(j, h2, 5).integer, 5); ck_assert_int_eq(jit_call(j, h2, 255).integer, 255); const char *text3 = " RECV R0, #0 \n" " $SALLOC R1, #0, #4 \n" " STORE.32 R0, [R1] \n" " MOV R2, #-1 \n" " ULOAD.32 R2, [R1] \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "stack3", "i"); ck_assert_int_eq(jit_call(j, h3, 4).integer, 4); ck_assert_int_eq(jit_call(j, h3, 5).integer, 5); ck_assert_int_eq(jit_call(j, h3, 255).integer, 255); const char *text4 = " RECV R0, #0 \n" " $SALLOC R1, #0, #2 \n" " STORE.16 R0, [R1] \n" " MOV R2, #0xdeadbeef \n" " ULOAD.16 R2, [R1] \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "stack4", "i"); ck_assert_int_eq(jit_call(j, h4, 4).integer, 4); ck_assert_int_eq(jit_call(j, h4, 5).integer, 5); ck_assert_int_eq(jit_call(j, h4, 1000).integer, 1000); jit_free(j); } END_TEST START_TEST(test_bzero) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " $BZERO R1, [R0] \n" " RET \n"; uint8_t mem[16]; memset(mem, 'x', sizeof(mem)); jit_handle_t h1 = assemble(j, text1, "bzero1", "pI"); jit_call(j, h1, mem, sizeof(mem)); for (int i = 0; i < sizeof(mem); i++) ck_assert_int_eq(mem[i], '\0'); memset(mem, 'x', sizeof(mem)); jit_call(j, h1, mem, 4); for (int i = 0; i < 4; i++) ck_assert_int_eq(mem[i], '\0'); for (int i = 4; i < sizeof(mem); i++) ck_assert_int_eq(mem[i], 'x'); memset(mem, 'x', sizeof(mem)); jit_call(j, h1, mem, sizeof(mem)); for (int i = 0; i < sizeof(mem); i++) ck_assert_int_eq(mem[i], '\0'); jit_free(j); } END_TEST START_TEST(test_copy) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $COPY R2, [R0], [R1] \n" " RET \n"; char mem[16]; memset(mem, 'x', sizeof(mem)); jit_handle_t h1 = assemble(j, text1, "copy1", "ppI"); jit_call(j, h1, mem, "hello", sizeof("hello")); ck_assert_str_eq(mem, "hello"); jit_call(j, h1, mem, "world", sizeof("world")); ck_assert_str_eq(mem, "world"); jit_call(j, h1, mem, "123456789", sizeof("123456789")); ck_assert_str_eq(mem, "123456789"); jit_free(j); } END_TEST START_TEST(test_shift) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " SHL R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "shift1", "ii"); ck_assert_int_eq(jit_call(j, h1, 1, 1).integer, 2); ck_assert_int_eq(jit_call(j, h1, 2, 1).integer, 4); ck_assert_int_eq(jit_call(j, h1, 4, 5).integer, 128); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " ASR R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "shift2", "ii"); ck_assert_int_eq(jit_call(j, h2, 8, 1).integer, 4); ck_assert_int_eq(jit_call(j, h2, 128, 5).integer, 4); ck_assert_int_eq(jit_call(j, h2, 4, 5).integer, 0); jit_free(j); } END_TEST START_TEST(test_imm) { jit_t *j = get_native_jit(); const char *text1 = " MOV R0, #-1 \n" " SEND #0, R0 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "imm1", ""); ck_assert_int_eq(jit_call(j, h1).integer, -1); ck_assert_int_eq(jit_call(j, h1).integer, -1); const char *text2 = " MOV R0, #0x11adbeefcafebabe \n" " SEND #0, R0 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "imm2", ""); ck_assert_int_eq(jit_call(j, h2).integer, INT64_C(0x11adbeefcafebabe)); ck_assert_int_eq(jit_call(j, h2).integer, INT64_C(0x11adbeefcafebabe)); jit_free(j); } END_TEST START_TEST(test_lea) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " LEA R1, [R0+5] \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "lea1", "I"); ck_assert_int_eq(jit_call(j, h1, 0).integer, 5); ck_assert_int_eq(jit_call(j, h1, 5).integer, 10); ck_assert_int_eq(jit_call(j, h1, 100).integer, 105); jit_free(j); } END_TEST START_TEST(test_csel) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " CMP.LT R0, R1 \n" " CSEL R2, R1, R0 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "csel1", "ii"); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 3); ck_assert_int_eq(jit_call(j, h1, 100, 2000).integer, 2000); ck_assert_int_eq(jit_call(j, h1, -2, 5).integer, 5); jit_free(j); } END_TEST START_TEST(test_lalloc) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " SHL R4, R0, #2 \n" " $LALLOC R1, R4 \n" " MOV R2, #0 \n" " CMP.GE R2, R0 \n" " JUMP.T L2 \n" "L1: SHL R5, R2, #2 \n" " ADD R3, R1, R5 \n" " STORE.32 R2, [R3] \n" " ADD R2, R2, #1 \n" " CMP.LT R2, R0 \n" " JUMP.T L1 \n" "L2: SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "lalloc1", "i"); static const int trials[] = { 5, 5, 1, 10, 100 }; for (int i = 0; i < ARRAY_LEN(trials); i++) { int *p = jit_call(j, h1, trials[i]).pointer; ck_assert_ptr_nonnull(p); for (int j = 0; j < trials[i]; j++) ck_assert_int_eq(p[j], j); } jit_free(j); } END_TEST START_TEST(test_logical) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " AND R2, R1, R0 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "logical1", "ii"); ck_assert_int_eq(jit_call(j, h1, 1, 0).integer, 0); ck_assert_int_eq(jit_call(j, h1, 1, 1).integer, 1); ck_assert_int_eq(jit_call(j, h1, 0, 0).integer, 0); ck_assert_int_eq(jit_call(j, h1, 0xffff, 0xff00).integer, 0xff00); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " OR R2, R1, R0 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "logical2", "ii"); ck_assert_int_eq(jit_call(j, h2, 1, 0).integer, 1); ck_assert_int_eq(jit_call(j, h2, 1, 1).integer, 1); ck_assert_int_eq(jit_call(j, h2, 0, 0).integer, 0); ck_assert_int_eq(jit_call(j, h2, 1, 2).integer, 3); ck_assert_int_eq(jit_call(j, h2, 0x11223344, 0).integer, 0x11223344); const char *text3 = " RECV R0, #0 \n" " NOT R1, R0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "logical3", "i"); ck_assert_int_eq(jit_call(j, h3, 1).integer, 0); ck_assert_int_eq(jit_call(j, h3, 0).integer, 1); ck_assert_int_eq(jit_call(j, h3, 1).integer, 0); ck_assert_int_eq(jit_call(j, h3, 5).integer, 0); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " XOR R2, R1, R0 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "logical4", "ii"); ck_assert_int_eq(jit_call(j, h4, 1, 0).integer, 1); ck_assert_int_eq(jit_call(j, h4, 1, 1).integer, 0); ck_assert_int_eq(jit_call(j, h4, 0, 0).integer, 0); ck_assert_int_eq(jit_call(j, h4, 0xbeef, 0xbeef).integer, 0); ck_assert_int_eq(jit_call(j, h4, INT64_C(-1), 0).integer, -1); const char *text5 = " RECV R0, #0 \n" " AND.16 R1, R0, #0xf0f0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "logical5", "i"); ck_assert_int_eq(jit_call(j, h5, 0xff).integer, 0xf0); ck_assert_int_eq(jit_call(j, h5, 0xf0f).integer, 0); ck_assert_int_eq(jit_call(j, h5, 0x3333).integer, 0x3030); jit_free(j); } END_TEST START_TEST(test_neg) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " NEG R1, R0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "neg1", "i"); ck_assert_int_eq(jit_call(j, h1, 0).integer, 0); ck_assert_int_eq(jit_call(j, h1, 5).integer, -5); ck_assert_int_eq(jit_call(j, h1, -5).integer, 5); ck_assert_int_eq(jit_call(j, h1, 1000).integer, -1000); jit_free(j); } END_TEST START_TEST(test_clamp) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " CLAMP R1, R0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "clamp1", "i"); ck_assert_int_eq(jit_call(j, h1, 0).integer, 0); ck_assert_int_eq(jit_call(j, h1, 5).integer, 5); ck_assert_int_eq(jit_call(j, h1, -5).integer, 0); ck_assert_int_eq(jit_call(j, h1, 1000).integer, 1000); ck_assert_int_eq(jit_call(j, h1, -1000).integer, 0); jit_free(j); } END_TEST START_TEST(test_case) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " $CASE R0, #1, L1 \n" " $CASE R0, #2, L2 \n" " $CASE R0, #3, L3 \n" " RET \n" "L1: SEND #0, #10 \n" " RET \n" "L2: SEND #0, #20 \n" " RET \n" "L3: SEND #0, #30 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "case1", "i"); ck_assert_int_eq(jit_call(j, h1, 1).integer, 10); ck_assert_int_eq(jit_call(j, h1, 2).integer, 20); ck_assert_int_eq(jit_call(j, h1, 3).integer, 30); ck_assert_int_eq(jit_call(j, h1, 4).integer, 4); jit_free(j); } END_TEST START_TEST(test_exp) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " $EXP R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "exp1", "II"); ck_assert_int_eq(jit_call(j, h1, 2, 3).integer, 8); ck_assert_int_eq(jit_call(j, h1, 2, 4).integer, 16); ck_assert_int_eq(jit_call(j, h1, 3, 5).integer, 243); ck_assert_int_eq(jit_call(j, h1, 7, 4).integer, 2401); ck_assert_int_eq(jit_call(j, h1, 666, 1).integer, 666); ck_assert_int_eq(jit_call(j, h1, 99, 0).integer, 1); jit_free(j); } END_TEST START_TEST(test_float) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " FMUL R3, R1, R0 \n" " FADD R4, R3, R2 \n" " SEND #0, R4 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "float1", "fff"); ck_assert_double_eq(jit_call(j, h1, 2.0, 3.0, 0.0).real, 6.0); ck_assert_double_eq(jit_call(j, h1, 5.0, 3.0, 0.0).real, 15.0); ck_assert_double_eq(jit_call(j, h1, -2.0, 7.0, 0.0).real, -14.0); ck_assert_double_eq(jit_call(j, h1, 2.0, 3.0, 1.0).real, 7.0); ck_assert_double_eq(jit_call(j, h1, 2.5, 1.0, 0.5).real, 3.0); const char *text2 = " RECV R0, #0 \n" " FDIV R1, R0, %2.0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "float2", "f"); ck_assert_double_eq(jit_call(j, h2, 2.0).real, 1.0); ck_assert_double_eq(jit_call(j, h2, 1.0).real, 0.5); ck_assert_double_eq(jit_call(j, h2, 0.5).real, 0.25); const char *text3 = " RECV R0, #0 \n" " RECV R1, #1 \n" " FNEG R1, R1 \n" " FSUB R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "float3", "ff"); ck_assert_double_eq(jit_call(j, h3, 2.0, 3.0).real, 5.0); ck_assert_double_eq(jit_call(j, h3, 2.0, -3.0).real, -1.0); ck_assert_double_eq(jit_call(j, h3, -1.0, 0.5).real, -0.5); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " FCMP.LT R0, R1 \n" " CSET R2 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "float4", "ff"); ck_assert_double_eq(jit_call(j, h4, 2.0, 3.0).integer, 1); ck_assert_double_eq(jit_call(j, h4, 0.0, 0.1).integer, 1); ck_assert_double_eq(jit_call(j, h4, -5.0, 0.0).integer, 1); ck_assert_double_eq(jit_call(j, h4, 5.0, 0.0).integer, 0); const char *text5 = " RECV R0, #0 \n" " FCVTNS R1, R0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "float5", "f"); ck_assert_int_eq(jit_call(j, h5, 2.0).integer, 2); ck_assert_int_eq(jit_call(j, h5, 0.7).integer, 1.0); ck_assert_int_eq(jit_call(j, h5, 0.1).integer, 0.0); ck_assert_int_eq(jit_call(j, h5, -0.1).integer, 0.0); ck_assert_int_eq(jit_call(j, h5, -0.8).integer, -1); const int tie = jit_call(j, h5, 0.5).integer; fail_unless(tie == 0 || tie == 1); // LRM allows either result const char *text6 = " RECV R0, #0 \n" " SCVTF R1, R0 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h6 = assemble(j, text6, "float6", "i"); ck_assert_double_eq(jit_call(j, h6, 2).real, 2.0); ck_assert_double_eq(jit_call(j, h6, 0).real, 0.0); ck_assert_double_eq(jit_call(j, h6, -5).real, -5.0); ck_assert_double_eq(jit_call(j, h6, 123).real, 123.0); const char *text7 = " RECV R0, #0 \n" " RECV R1, #1 \n" " $FEXP R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h7 = assemble(j, text7, "float7", "ff"); ck_assert_double_eq(jit_call(j, h7, 2.0, 3.0).real, 8.0); ck_assert_double_eq(jit_call(j, h7, 1.0, 3.0).real, 1.0); ck_assert_double_eq(jit_call(j, h7, 2.0, -1.0).real, 0.5); ck_assert_double_eq(jit_call(j, h7, 0.5, 2.0).real, 0.25); jit_free(j); } END_TEST START_TEST(test_ccmp) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " CMP.GE R0, #0 \n" " CCMP.LE R0, #10 \n" " CSET R1 \n" " SEND #0, R1 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "ccmp1", "i"); ck_assert_int_eq(jit_call(j, h1, 0).integer, 1); ck_assert_int_eq(jit_call(j, h1, 5).integer, 1); ck_assert_int_eq(jit_call(j, h1, 15).integer, 0); ck_assert_int_eq(jit_call(j, h1, -6).integer, 0); jit_free(j); } END_TEST START_TEST(test_memset) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $MEMSET.8 R2, [R0], R1 \n" " RET \n"; char mem8[16]; memset(mem8, 'x', sizeof(mem8)); jit_handle_t h1 = assemble(j, text1, "memset1", "pII"); jit_call(j, h1, mem8, 42, sizeof(mem8)); for (int i = 0; i < sizeof(mem8); i++) ck_assert_int_eq(mem8[i], 42); jit_call(j, h1, mem8, 55, sizeof(mem8)); for (int i = 0; i < sizeof(mem8); i++) ck_assert_int_eq(mem8[i], 55); const char *text2 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $MEMSET.16 R2, [R0], R1 \n" " RET \n"; uint16_t mem16[16]; jit_handle_t h2 = assemble(j, text2, "memset2", "pII"); jit_call(j, h2, mem16, 42, sizeof(mem16)); for (int i = 0; i < ARRAY_LEN(mem16); i++) ck_assert_int_eq(mem16[i], 42); jit_call(j, h2, mem16, 0xaabb, sizeof(mem16)); for (int i = 0; i < ARRAY_LEN(mem16); i++) ck_assert_int_eq(mem16[i], 0xaabb); jit_call(j, h2, mem16, 0x1234, 4); for (int i = 0; i < ARRAY_LEN(mem16); i++) ck_assert_int_eq(mem16[i], i < 2 ? 0x1234 : 0xaabb); const char *text3 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $MEMSET.32 R2, [R0], R1 \n" " RET \n"; uint32_t mem32[16]; jit_handle_t h3 = assemble(j, text3, "memset3", "pII"); jit_call(j, h3, mem32, 42, sizeof(mem32)); for (int i = 0; i < ARRAY_LEN(mem32); i++) ck_assert_int_eq(mem32[i], 42); jit_call(j, h3, mem32, 0xaabbccdd, sizeof(mem32)); for (int i = 0; i < ARRAY_LEN(mem32); i++) ck_assert_int_eq(mem32[i], 0xaabbccdd); jit_call(j, h3, mem32, 0x12345678, 4); for (int i = 0; i < ARRAY_LEN(mem32); i++) ck_assert_int_eq(mem32[i], i == 0 ? 0x12345678 : 0xaabbccdd); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $MEMSET.64 R2, [R0], R1 \n" " RET \n"; uint64_t mem64[16]; jit_handle_t h4 = assemble(j, text4, "memset4", "pII"); jit_call(j, h4, mem64, 42, sizeof(mem64)); for (int i = 0; i < ARRAY_LEN(mem64); i++) ck_assert_int_eq(mem64[i], 42); jit_call(j, h4, mem64, 0xaabbccdd, sizeof(mem64)); for (int i = 0; i < ARRAY_LEN(mem64); i++) ck_assert_int_eq(mem64[i], 0xaabbccdd); jit_call(j, h4, mem64, 0x12345678, 8); for (int i = 0; i < ARRAY_LEN(mem64); i++) ck_assert_int_eq(mem64[i], i == 0 ? 0x12345678 : 0xaabbccdd); jit_free(j); } END_TEST START_TEST(test_move) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " RECV R2, #2 \n" " $MOVE R2, [R0], [R1] \n" " RET \n"; char mem[16]; strncpy(mem, "hello", sizeof(mem)); jit_handle_t h1 = assemble(j, text1, "move1", "ppI"); jit_call(j, h1, mem, mem + 2, sizeof("hello")); ck_assert_str_eq(mem, "llo"); strncpy(mem, "hello", sizeof(mem)); jit_call(j, h1, mem, mem + 2, sizeof("hello")); ck_assert_str_eq(mem, "llo"); strncpy(mem, "hello", sizeof(mem)); jit_call(j, h1, mem + 2, mem, sizeof("world")); ck_assert_str_eq(mem, "hehello"); memset(mem, 'x', sizeof(mem)); jit_call(j, h1, mem, "world", sizeof("world")); ck_assert_str_eq(mem, "world"); jit_call(j, h1, mem, "123456789", sizeof("123456789")); ck_assert_str_eq(mem, "123456789"); jit_free(j); } END_TEST START_TEST(test_sub) { jit_t *j = get_native_jit(); const char *text1 = " RECV R0, #0 \n" " RECV R1, #1 \n" " SUB.8 R2, R0, R1 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h1 = assemble(j, text1, "sub1", "ii"); ck_assert_int_eq(jit_call(j, h1, 1, 2).integer, -1); ck_assert_int_eq(jit_call(j, h1, 127, 1).integer, 126); ck_assert_int_eq(jit_call(j, h1, 128, 1).integer, 127); const char *text2 = " RECV R0, #0 \n" " SUB.O.8 R1, R0, #1 \n" " CSET R2 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h2 = assemble(j, text2, "sub2", "i"); ck_assert_int_eq(jit_call(j, h2, 127).integer, 0); ck_assert_int_eq(jit_call(j, h2, -127).integer, 0); ck_assert_int_eq(jit_call(j, h2, 5).integer, 0); ck_assert_int_eq(jit_call(j, h2, -128).integer, 1); const char *text3 = " RECV R0, #0 \n" " SUB.O.16 R1, R0, #1 \n" " CSET R2 \n" " SEND #0, R2 \n" " RET \n"; jit_handle_t h3 = assemble(j, text3, "sub3", "i"); ck_assert_int_eq(jit_call(j, h3, INT16_MAX).integer, 0); ck_assert_int_eq(jit_call(j, h3, INT16_MIN).integer, 1); ck_assert_int_eq(jit_call(j, h3, 5).integer, 0); ck_assert_int_eq(jit_call(j, h3, INT16_MAX).integer, 0); const char *text4 = " RECV R0, #0 \n" " RECV R1, #1 \n" " SUB.O.16 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h4 = assemble(j, text4, "sub4", "ii"); ck_assert_int_eq(jit_call(j, h4, 1, 1).integer, 0); ck_assert_int_eq(jit_call(j, h4, -128, 1).integer, 0); ck_assert_int_eq(jit_call(j, h4, INT16_MIN, 1).integer, 1); const char *text5 = " RECV R0, #0 \n" " RECV R1, #1 \n" " SUB.O.8 R2, R0, R1 \n" " CSET R3 \n" " SEND #0, R3 \n" " RET \n"; jit_handle_t h5 = assemble(j, text5, "sub5", "ii"); ck_assert_int_eq(jit_call(j, h5, 1, 1).integer, 0); ck_assert_int_eq(jit_call(j, h5, -128, 1).integer, 1); ck_assert_int_eq(jit_call(j, h5, 127, 1).integer, 0); jit_free(j); } END_TEST Suite *get_native_tests(void) { Suite *s = suite_create("native"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_add); tcase_add_test(tc, test_mul); tcase_add_test(tc, test_div); tcase_add_test(tc, test_rem); tcase_add_test(tc, test_call); tcase_add_test(tc, test_stack); tcase_add_test(tc, test_bzero); tcase_add_test(tc, test_copy); tcase_add_test(tc, test_shift); tcase_add_test(tc, test_imm); tcase_add_test(tc, test_lea); tcase_add_test(tc, test_csel); tcase_add_test(tc, test_lalloc); tcase_add_test(tc, test_logical); tcase_add_test(tc, test_neg); tcase_add_test(tc, test_clamp); tcase_add_test(tc, test_case); tcase_add_test(tc, test_exp); tcase_add_test(tc, test_float); tcase_add_test(tc, test_ccmp); tcase_add_test(tc, test_memset); tcase_add_test(tc, test_move); tcase_add_test(tc, test_sub); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_parse.c000066400000000000000000006147111504111170000160450ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "diag.h" #include "lib.h" #include "option.h" #include "phase.h" #include "scan.h" #include "tree.h" #include "type.h" #include #include #include #include #include START_TEST(test_entity) { tree_t e, p, g, v, x, y; type_t t; input_from_file(TESTDIR "/parse/entity.vhd"); const error_t expect[] = { { 39, "invalid object class signal for generic X" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.ONE")); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.TWO")); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.THREE")); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.FOUR")); fail_unless(tree_ports(e) == 5); p = tree_port(e, 0); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("A")); fail_unless(tree_subkind(p) == PORT_IN); fail_unless(tree_class(p) == C_SIGNAL); t = tree_type(p); fail_unless(type_kind(t) == T_INTEGER); fail_unless(type_ident(t) == ident_new("STD.STANDARD.INTEGER")); fail_unless(tree_has_value(p)); v = tree_value(p); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 4); p = tree_port(e, 1); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("B")); fail_unless(tree_subkind(p) == PORT_OUT); t = tree_type(p); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_ident(t) == ident_new("STD.STANDARD.BIT")); fail_if(tree_has_value(p)); p = tree_port(e, 2); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("BEE")); fail_unless(tree_subkind(p) == PORT_OUT); t = tree_type(p); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_ident(t) == ident_new("STD.STANDARD.BIT")); fail_if(tree_has_value(p)); p = tree_port(e, 3); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("C")); fail_unless(tree_subkind(p) == PORT_INOUT); t = tree_type(p); fail_unless(type_kind(t) == T_INTEGER); fail_unless(type_ident(t) == ident_new("STD.STANDARD.INTEGER")); fail_if(tree_has_value(p)); p = tree_port(e, 4); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("D")); fail_unless(tree_subkind(p) == PORT_BUFFER); t = tree_type(p); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_ident(t) == ident_new("STD.STANDARD.BIT")); fail_if(tree_has_value(p)); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.FIVE")); fail_unless(tree_generics(e) == 2); g = tree_generic(e, 0); fail_unless(tree_kind(g) == T_GENERIC_DECL); fail_unless(tree_ident(g) == ident_new("X")); t = tree_type(g); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_ident(t) == ident_new("STD.STANDARD.BOOLEAN")); fail_if(tree_has_value(p)); g = tree_generic(e, 1); fail_unless(tree_kind(g) == T_GENERIC_DECL); fail_unless(tree_ident(g) == ident_new("Y")); t = tree_type(g); fail_unless(type_kind(t) == T_INTEGER); fail_unless(type_ident(t) == ident_new("STD.STANDARD.INTEGER")); fail_unless(tree_has_value(g)); v = tree_value(g); fail_unless(tree_kind(v) == T_FCALL); fail_unless(tree_ident(v) == ident_new("\"*\"")); fail_unless(tree_params(v) == 2); x = tree_param(v, 0); fail_unless(tree_subkind(x) == P_POS); fail_unless(tree_pos(x) == 0); fail_unless(tree_kind(tree_value(x)) == T_LITERAL); fail_unless(tree_subkind(tree_value(x)) == L_INT); fail_unless(tree_ival(tree_value(x)) == 2); y = tree_param(v, 1); fail_unless(tree_subkind(y) == P_POS); fail_unless(tree_pos(y) == 1); fail_unless(tree_kind(tree_value(y)) == T_LITERAL); fail_unless(tree_subkind(tree_value(y)) == L_INT); fail_unless(tree_ival(tree_value(y)) == 5); fail_unless(tree_ports(e) == 1); p = tree_port(e, 0); fail_unless(tree_kind(p) == T_PORT_DECL); fail_unless(tree_ident(p) == ident_new("P")); fail_unless(tree_subkind(p) == PORT_OUT); fail_unless(tree_class(p) == C_SIGNAL); fail_if(tree_has_value(p)); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_decls(e) == 2); fail_unless(tree_kind(tree_decl(e, 0)) == T_ATTR_DECL); fail_unless(tree_kind(tree_decl(e, 1)) == T_ATTR_SPEC); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_stmts(e) == 2); fail_unless(tree_kind(tree_stmt(tree_stmt(e, 0), 0)) == T_ASSERT); fail_unless(tree_kind(tree_stmt(tree_stmt(e, 1), 0)) == T_ASSERT); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(tree_ident(e) == ident_new("WORK.EIGHT")); fail_unless(tree_generics(e) == 1); g = tree_generic(e, 0); fail_unless(tree_kind(g) == T_GENERIC_DECL); fail_unless(tree_class(g) == C_SIGNAL); e = parse(); fail_unless(e == NULL); check_expected_errors(); } END_TEST START_TEST(test_arch) { tree_t e, a, d, v; input_from_file(TESTDIR "/parse/arch.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_ident(a) == ident_new("WORK.ONE-A")); fail_unless(tree_ident2(a) == ident_new("ONE")); fail_unless(tree_primary(a) == e); fail_unless(tree_decls(a) == 3); d = tree_decl(a, 0); fail_unless(tree_kind(d) == T_SIGNAL_DECL); fail_unless(tree_ident(d) == ident_new("X")); fail_unless(type_kind(tree_type(d)) == T_INTEGER); fail_unless(type_ident(tree_type(d)) == ident_new("STD.STANDARD.INTEGER")); fail_if(tree_has_value(d)); d = tree_decl(a, 1); fail_unless(tree_kind(d) == T_SIGNAL_DECL); fail_unless(tree_ident(d) == ident_new("Y")); fail_unless(type_kind(tree_type(d)) == T_INTEGER); fail_unless(type_ident(tree_type(d)) == ident_new("STD.STANDARD.INTEGER")); fail_unless(tree_has_value(d)); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 7); d = tree_decl(a, 2); fail_unless(tree_kind(d) == T_SIGNAL_DECL); fail_unless(tree_ident(d) == ident_new("Z")); fail_unless(type_kind(tree_type(d)) == T_INTEGER); fail_unless(type_ident(tree_type(d)) == ident_new("STD.STANDARD.INTEGER")); fail_unless(tree_has_value(d)); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 7); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_ident(a) == ident_new("WORK.ONE-B")); fail_unless(tree_ident2(a) == ident_new("ONE")); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_ident(a) == ident_new("WORK.ONE-C")); fail_unless(tree_ident2(a) == ident_new("ONE")); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_process) { tree_t e, a, p, d, s; input_from_file(TESTDIR "/parse/process.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 5); p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_ident(p) == ident_new("P")); p = tree_stmt(a, 1); fail_unless(tree_kind(p) == T_PROCESS); fail_if(tree_ident(p) == NULL); fail_unless(tree_decls(p) == 1); d = tree_decl(p, 0); fail_unless(tree_kind(d) == T_VAR_DECL); fail_unless(tree_stmts(p) == 1); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); p = tree_stmt(a, 2); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_triggers(p) == 1); fail_if(tree_flags(p) & TREE_F_POSTPONED); d = tree_trigger(p, 0); fail_unless(tree_kind(d) == T_REF); fail_unless(tree_ident(d) == ident_new("X")); p = tree_stmt(a, 3); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_flags(p) & TREE_F_POSTPONED); p = tree_stmt(a, 4); fail_unless(tree_kind(p) == T_CONCURRENT); fail_unless(tree_flags(p) & TREE_F_POSTPONED); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_seq) { tree_t a, p, s, e, b, c, r; opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/parse/seq.vhd"); const error_t expect[] = { { 15, "type of slice prefix INTEGER is not an array" }, { 45, "target of variable assignment must be a variable name or" }, { 84, "return statement not allowed outside subprogram" }, { 125, "cannot use exit statement outside loop" }, { 126, "cannot use exit statement outside loop" }, { 136, "positional parameters must precede named parameters" }, { 157, "cannot use next statement outside loop" }, { 158, "cannot use next statement outside loop" }, { 197, "a null waveform element is only valid when the target" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 19); // Wait statements p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 8); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_has_delay(s)); e = tree_delay(s); fail_unless(tree_kind(e) == T_LITERAL); fail_unless(tree_subkind(e) == L_PHYSICAL); fail_unless(type_kind(tree_type(e)) == T_PHYSICAL); fail_unless(tree_ival(e) == 1); fail_unless(tree_ident(e) == ident_new("NS")); fail_unless(tree_kind(tree_ref(e)) == T_UNIT_DECL); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_WAIT); fail_if(tree_has_delay(s)); fail_unless(tree_ident(s) == ident_new("BLOCK_FOREVER")); s = tree_stmt(p, 2); fail_unless(tree_kind(s) == T_WAIT); fail_if(tree_has_delay(s)); fail_unless(tree_triggers(s) == 1); e = tree_trigger(s, 0); fail_unless(tree_kind(e) == T_REF); s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_WAIT); fail_if(tree_has_delay(s)); fail_unless(tree_triggers(s) == 3); e = tree_trigger(s, 2); fail_unless(tree_kind(e) == T_ARRAY_SLICE); s = tree_stmt(p, 4); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_has_delay(s)); fail_if(tree_has_value(s)); s = tree_stmt(p, 5); fail_unless(tree_kind(s) == T_WAIT); fail_if(tree_has_delay(s)); fail_unless(tree_has_value(s)); s = tree_stmt(p, 6); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_has_delay(s)); fail_unless(tree_has_value(s)); s = tree_stmt(p, 7); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_has_delay(s)); fail_unless(tree_has_value(s)); fail_unless(tree_triggers(s) == 1); // Variable assignment p = tree_stmt(a, 1); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_target(s); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("A")); e = tree_value(s); fail_unless(tree_kind(e) == T_LITERAL); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_value(s); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"+\"")); fail_unless(tree_params(e) == 2); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_REF); e = tree_value(tree_param(e, 1)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"*\"")); fail_unless(tree_params(e) == 2); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_REF); fail_unless(tree_kind(tree_value(tree_param(e, 1))) == T_LITERAL); // Assert and report p = tree_stmt(a, 2); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 5); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_ASSERT); fail_unless(tree_kind(tree_value(s)) == T_REF); fail_unless(tree_ident(tree_value(s)) == ident_new("TRUE")); fail_if(tree_has_severity(s)); fail_if(tree_has_message(s)); s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_REPORT); fail_if(tree_has_severity(s)); fail_unless(tree_has_message(s)); fail_unless(tree_kind(tree_message(s)) == T_STRING); // Function calls p = tree_stmt(a, 3); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_value(s); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_params(e) == 3); fail_unless(tree_subkind(tree_param(e, 0)) == P_POS); fail_unless(tree_pos(tree_param(e, 0)) == 0); fail_unless(tree_ival(tree_value(tree_param(e, 0))) == 1); fail_unless(tree_subkind(tree_param(e, 1)) == P_POS); fail_unless(tree_pos(tree_param(e, 1)) == 1); fail_unless(tree_ival(tree_value(tree_param(e, 1))) == 2); fail_unless(tree_subkind(tree_param(e, 2)) == P_POS); fail_unless(tree_pos(tree_param(e, 2)) == 2); fail_unless(tree_ival(tree_value(tree_param(e, 2))) == 3); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_value(s); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"abs\"")); // If statements p = tree_stmt(a, 4); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 4); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_IF); fail_unless(tree_conds(s) == 1); c = tree_cond(s, 0); fail_unless(tree_has_value(c)); e = tree_value(c); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("TRUE")); fail_unless(tree_stmts(c) == 1); s = tree_stmt(p, 2); fail_unless(tree_kind(s) == T_IF); fail_unless(tree_conds(s) == 2); fail_if(tree_has_value(tree_cond(s, 1))); s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_IF); fail_unless(tree_conds(s) == 4); s = tree_stmt(tree_cond(s, 3), 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); // Null statements p = tree_stmt(a, 5); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 1); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_NULL); // Return statements p = tree_stmt(a, 6); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 1); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_RETURN); fail_unless(tree_kind(tree_value(s)) == T_FCALL); // While loops p = tree_stmt(a, 7); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_WHILE); fail_unless(tree_stmts(s) == 1); fail_unless(tree_kind(tree_value(s)) == T_FCALL); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_LOOP); fail_unless(tree_stmts(s) == 1); // Multiple waveforms in signal assignment p = tree_stmt(a, 8); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s) == 1); fail_unless(tree_has_delay(tree_waveform(s, 0))); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s) == 2); fail_unless(tree_has_delay(tree_waveform(s, 0))); fail_unless(tree_has_delay(tree_waveform(s, 1))); s = tree_stmt(p, 2); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s) == 2); fail_if(tree_has_delay(tree_waveform(s, 0))); fail_unless(tree_has_delay(tree_waveform(s, 1))); // For p = tree_stmt(a, 9); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_FOR); fail_unless(tree_stmts(s) == 1); r = tree_range(s, 0); fail_unless(tree_subkind(r) == RANGE_TO); fail_unless(tree_kind(tree_left(r)) == T_TYPE_CONV); fail_unless(tree_kind(tree_left(r)) == T_TYPE_CONV); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_FOR); fail_unless(tree_stmts(s) == 1); fail_unless(tree_subkind(tree_range(s, 0)) == RANGE_EXPR); fail_unless(tree_kind(tree_value(tree_range(s, 0))) == T_ATTR_REF); // Exit p = tree_stmt(a, 10); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_EXIT); fail_if(tree_has_value(s)); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_EXIT); fail_unless(tree_has_value(s)); // Procedure call p = tree_stmt(a, 11); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_ident2(s) == ident_new("FOO")); fail_unless(tree_params(s) == 3); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_ident2(s) == ident_new("BAR")); fail_unless(tree_params(s) == 0); // Case p = tree_stmt(a, 12); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_CASE); fail_unless(tree_stmts(s) == 4); fail_unless(tree_subkind(tree_assoc(tree_stmt(s, 0), 0)) == A_NAMED); fail_unless(tree_subkind(tree_assoc(tree_stmt(s, 3), 0)) == A_OTHERS); b = tree_stmt(s, 0); fail_unless(tree_kind(b) == T_ALTERNATIVE); fail_unless(tree_stmts(b) == 1); fail_unless(tree_kind(tree_stmt(b, 0)) == T_NULL); // Next p = tree_stmt(a, 13); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_NEXT); fail_if(tree_has_value(s)); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_NEXT); fail_unless(tree_has_value(s)); // Signal assignment to aggregate p = tree_stmt(a, 14); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_kind(tree_target(s)) == T_AGGREGATE); // Case statement range bug p = tree_stmt(a, 15); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_CASE); fail_unless(tree_stmts(s) == 1); fail_unless(tree_subkind(tree_assoc(tree_stmt(s, 0), 0)) == A_NAMED); // Process with all-sensitivity p = tree_stmt(a, 16); fail_unless(tree_triggers(p) == 1); fail_unless(tree_kind(tree_trigger(p, 0)) == T_ALL); // Aggregate target of variable assignment p = tree_stmt(a, 17); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); fail_unless(tree_kind(tree_target(s)) == T_AGGREGATE); // Signal assignment with null transaction p = tree_stmt(a, 18); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s) == 2); fail_unless(tree_has_delay(tree_waveform(s, 1))); fail_if(tree_has_value(tree_waveform(s, 1))); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_types) { tree_t a, b, d, f, u, r; type_t t; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/types.vhd"); const error_t expect[] = { { 16, "expected type of range bounds to be RESISTANCE but have " }, { 41, "index constraint cannot be used with non-array type FOO" }, { 55, "no visible declaration for SOME_ARRAY" }, { 57, "duplicate enumeration literal 'a'" }, { -1, NULL } }; expect_errors(expect); b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_ENTITY); lib_put(lib_work(), b); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); d = get_decl(a, "MY_INT"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_INTEGER); fail_unless(type_dims(t) == 1); r = type_dim(t, 0); fail_unless(tree_subkind(r) == RANGE_TO); fail_unless(tree_kind(tree_left(r)) == T_LITERAL); fail_unless(tree_kind(tree_right(r)) == T_LITERAL); d = get_decl(a, "RESISTANCE"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_PHYSICAL); fail_unless(type_dims(t) == 1); r = type_dim(t, 0); fail_unless(tree_subkind(r) == RANGE_TO); fail_unless(tree_kind(tree_left(r)) == T_LITERAL); fail_unless(tree_kind(tree_right(r)) == T_LITERAL); fail_unless(type_units(t) == 3); u = type_unit(t, 0); fail_unless(tree_ident(u) == ident_new("OHM")); fail_unless(tree_kind(tree_value(u)) == T_LITERAL); fail_unless(tree_subkind(tree_value(u)) == L_PHYSICAL); u = type_unit(t, 1); fail_unless(tree_ident(u) == ident_new("KOHM")); fail_unless(tree_kind(tree_value(u)) == T_LITERAL); fail_unless(tree_subkind(tree_value(u)) == L_PHYSICAL); fail_unless(tree_ival(tree_value(u)) == 1000); u = type_unit(t, 2); fail_unless(tree_ident(u) == ident_new("MOHM")); fail_unless(tree_kind(tree_value(u)) == T_LITERAL); fail_unless(tree_subkind(tree_value(u)) == L_PHYSICAL); fail_unless(tree_ival(tree_value(u)) == 1000); fail_unless(tree_ident(tree_value(u)) == ident_new("KOHM")); d = get_decl(a, "BIG_R"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_kind(type_base(t)) == T_PHYSICAL); fail_unless(type_ident(type_base(t)) == ident_new("WORK.B-A.RESISTANCE")); d = get_decl(a, "MY_SMALL_INT"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_kind(type_base(t)) == T_INTEGER); fail_unless(type_ident(type_base(t)) == ident_new("WORK.B-A.MY_INT")); d = get_decl(a, "FOO"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_kind(type_base(t)) == T_INTEGER); fail_unless(type_ident(type_base(t)) == ident_new("WORK.B-A.MY_INT")); r = tree_range(type_constraint(t), 0); fail_unless(tree_kind(tree_left(r)) == T_LITERAL); fail_unless(tree_kind(tree_right(r)) == T_ATTR_REF); fail_unless(tree_ident(tree_name(tree_right(r))) == ident_new("MY_INT")); fail_unless(tree_ident(tree_right(r)) == ident_new("HIGH")); d = get_decl(a, "RINT"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_resolution(t)); f = type_resolution(t); fail_unless(tree_kind(f) == T_REF); fail_unless(tree_ident(f) == ident_new("RESOLVED")); d = get_decl(a, "P"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_ACCESS); fail_unless(type_kind(type_designated(t)) == T_INTEGER); fail_unless(type_ident(type_designated(t)) == ident_new("WORK.B-A.MY_INT")); d = get_decl(a, "F"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_FILE); fail_unless(type_kind(type_designated(t)) == T_INTEGER); fail_unless(type_ident(type_designated(t)) == ident_new("WORK.B-A.MY_INT")); d = get_decl(a, "F1"); fail_unless(tree_kind(d) == T_FILE_DECL); fail_unless(tree_has_value(d)); fail_unless(tree_kind(tree_value(d)) == T_STRING); fail_unless(tree_kind(tree_file_mode(d)) == T_REF); d = get_decl(a, "F2"); fail_unless(tree_kind(d) == T_FILE_DECL); fail_unless(tree_has_value(d)); fail_unless(tree_kind(tree_value(d)) == T_STRING); fail_unless(tree_kind(tree_file_mode(d)) == T_REF); fail_unless(tree_ident(tree_file_mode(d)) == ident_new("READ_MODE")); d = get_decl(a, "F3"); fail_unless(tree_kind(d) == T_FILE_DECL); fail_if(tree_has_value(d)); d = get_decl(a, "R1"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_RECORD); fail_unless(type_fields(t) == 3); f = type_field(t, 1); fail_unless(tree_kind(f) == T_FIELD_DECL); fail_unless(tree_pos(f) == 1); fail_unless(tree_ident(f) == ident_new("B")); d = get_decl(a, "F4"); fail_unless(tree_kind(d) == T_FILE_DECL); fail_unless(tree_has_value(d)); fail_unless(tree_kind(tree_value(d)) == T_STRING); fail_unless(tree_kind(tree_file_mode(d)) == T_REF); fail_unless(tree_ident(tree_file_mode(d)) == ident_new("WRITE_MODE")); d = get_decl(a, "F5"); fail_unless(tree_kind(d) == T_FILE_DECL); fail_unless(tree_has_value(d)); fail_unless(tree_kind(tree_file_mode(d)) == T_REF); fail_unless(tree_ident(tree_file_mode(d)) == ident_new("READ_MODE")); d = get_decl(a, "R2"); fail_unless(tree_kind(d) == T_TYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_RECORD); fail_unless(type_fields(t) == 1); d = get_decl(a, "MY_REAL"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_ident(t)); t = type_base(t); fail_unless(t == std_type(NULL, STD_REAL)); r = type_dim(t, 0); fail_unless(tree_kind(tree_left(r)) == T_LITERAL); fail_unless(tree_subkind(tree_left(r)) == L_REAL); fail_unless(tree_dval(tree_left(r)) == -DBL_MAX); fail_unless(tree_kind(tree_right(r)) == T_LITERAL); fail_unless(tree_subkind(tree_right(r)) == L_REAL); fail_unless(tree_dval(tree_right(r)) == DBL_MAX); d = get_decl(a, "MY_REAL2"); fail_unless(tree_kind(d) == T_SUBTYPE_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_ident(t)); r = tree_range(type_constraint(t), 0); ck_assert_double_eq_tol(tree_dval(tree_left(r)), 0.0, DBL_EPSILON); ck_assert_double_eq_tol(tree_dval(tree_right(r)), 10.0, DBL_EPSILON); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_literal) { tree_t a, e, d, v; input_from_file(TESTDIR "/parse/literal.vhd"); const error_t expect[] = { { 36, "value 9223372036854775808 is outside implementation defined " "range of universal_integer" }, { 37, "value 235423414124e124124 is outside implementation defined " "range of universal_integer" }, { 39, "a literal may not end with an underscore or contain multiple " "consecutive underscores" }, { 40, "a literal may not end with an underscore or contain multiple " "consecutive underscores" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); d = get_decl(a, "POS"); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 64); d = get_decl(a, "POS"); d = get_decl(a, "NEG"); v = tree_value(d); fail_unless(tree_kind(v) == T_FCALL); fail_unless(tree_ident(v) == ident_new("\"-\"")); fail_unless(tree_params(v) == 1); fail_unless(tree_subkind(tree_value(tree_param(v, 0))) == L_INT); fail_unless(tree_ival(tree_value(tree_param(v, 0))) == 265); d = get_decl(a, "C"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("C")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 523); d = get_decl(a, "A"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("A")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 6); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'h'")); fail_unless(tree_ident(tree_char(v, 1)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 2)) == ident_new("'l'")); fail_unless(tree_ident(tree_char(v, 3)) == ident_new("'\"'")); fail_unless(tree_ident(tree_char(v, 4)) == ident_new("'l'")); fail_unless(tree_ident(tree_char(v, 5)) == ident_new("'o'")); d = get_decl(a, "B"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("B")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 7); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'\"'")); fail_unless(tree_ident(tree_char(v, 1)) == ident_new("'q'")); fail_unless(tree_ident(tree_char(v, 2)) == ident_new("'u'")); fail_unless(tree_ident(tree_char(v, 3)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 4)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 5)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 6)) == ident_new("'\"'")); d = get_decl(a, "D"); fail_unless(tree_ident(d) == ident_new("D")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 1000); d = get_decl(a, "E"); fail_unless(tree_ident(d) == ident_new("E")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_REAL); fail_unless(tree_dval(v) == 1.234); d = get_decl(a, "F"); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_REAL); fail_unless(tree_dval(v) == 0.21712); d = get_decl(a, "G"); fail_unless(tree_ident(d) == ident_new("G")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_REAL); fail_unless(tree_dval(v) == 1400000.0); d = get_decl(a, "H"); fail_unless(tree_ident(d) == ident_new("H")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_REAL); fail_unless(tree_dval(v) == 2.351); d = get_decl(a, "I"); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_INT); fail_unless(tree_ival(v) == 1234); d = get_decl(a, "J"); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_REAL); fail_unless(tree_dval(v) == 567.123); d = get_decl(a, "K"); fail_unless(tree_ident(d) == ident_new("K")); v = tree_value(d); fail_unless(tree_kind(v) == T_LITERAL); fail_unless(tree_subkind(v) == L_NULL); d = get_decl(a, "L"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("L")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 23); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'S'")); fail_unless(tree_ident(tree_char(v, 1)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 2)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 3)) == ident_new("'u'")); fail_unless(tree_ident(tree_char(v, 4)) == ident_new("'p'")); fail_unless(tree_ident(tree_char(v, 5)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 6)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 7)) == ident_new("'i'")); fail_unless(tree_ident(tree_char(v, 8)) == ident_new("'m'")); fail_unless(tree_ident(tree_char(v, 9)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 10)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 11)) == ident_new("'i'")); fail_unless(tree_ident(tree_char(v, 12)) == ident_new("'s'")); fail_unless(tree_ident(tree_char(v, 13)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 14)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 15)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 16)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 17)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 18)) == ident_new("'s'")); fail_unless(tree_ident(tree_char(v, 19)) == ident_new("'h'")); fail_unless(tree_ident(tree_char(v, 20)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 21)) == ident_new("'r'")); fail_unless(tree_ident(tree_char(v, 22)) == ident_new("'t'")); d = get_decl(a, "M"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("M")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 0); d = get_decl(a, "N"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("N")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("' '")); d = get_decl(a, "O"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("O")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'A'")); d = get_decl(a, "P"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("P")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'\"'")); d = get_decl(a, "Q"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("Q")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 23); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'S'")); fail_unless(tree_ident(tree_char(v, 1)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 2)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 3)) == ident_new("'u'")); fail_unless(tree_ident(tree_char(v, 4)) == ident_new("'p'")); fail_unless(tree_ident(tree_char(v, 5)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 6)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 7)) == ident_new("'i'")); fail_unless(tree_ident(tree_char(v, 8)) == ident_new("'m'")); fail_unless(tree_ident(tree_char(v, 9)) == ident_new("'e'")); fail_unless(tree_ident(tree_char(v, 10)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 11)) == ident_new("'i'")); fail_unless(tree_ident(tree_char(v, 12)) == ident_new("'s'")); fail_unless(tree_ident(tree_char(v, 13)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 14)) == ident_new("'t'")); fail_unless(tree_ident(tree_char(v, 15)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 16)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 17)) == ident_new("' '")); fail_unless(tree_ident(tree_char(v, 18)) == ident_new("'s'")); fail_unless(tree_ident(tree_char(v, 19)) == ident_new("'h'")); fail_unless(tree_ident(tree_char(v, 20)) == ident_new("'o'")); fail_unless(tree_ident(tree_char(v, 21)) == ident_new("'r'")); fail_unless(tree_ident(tree_char(v, 22)) == ident_new("'t'")); d = get_decl(a, "R"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("R")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 0); d = get_decl(a, "S"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("S")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("' '")); d = get_decl(a, "T"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("T")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'A'")); d = get_decl(a, "U"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("U")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(tree_ident(tree_char(v, 0)) == ident_new("'%'")); d = get_decl(a, "V"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("V")); v = tree_value(d); fail_unless(tree_kind(v) == T_STRING); fail_unless(tree_chars(v) == 1); fail_unless(ident_char(tree_ident(tree_char(v, 0)), 1) == (char)0xa9); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_extended) { tree_t a, e, d, n, s; input_from_file(TESTDIR "/parse/extended.vhd"); const error_t expect[] = { { 12, "unexpected error while parsing signal declaration" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_decls(a) == 8); lib_put(lib_work(), a); d = tree_decl(a, 0); fail_unless(tree_ident(d) == ident_new("\\foo bar\\")); d = tree_decl(a, 1); fail_unless(tree_ident(d) == ident_new("\\a\\b\\")); d = tree_decl(a, 2); fail_unless(tree_ident(d) == ident_new("\\Thing!!! \\")); d = tree_decl(a, 3); fail_unless(tree_ident(d) == ident_new("\\name\\")); n = tree_decl(a, 4); // LRM states extended identifiers distinct from regular fail_if(d == n); fail_unless(tree_stmts(a) == 1); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); fail_unless(tree_ident(tree_target(s)) == ident_new("\\foo.bar.baz\\")); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_package) { tree_t p, d, c; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/package.vhd"); const error_t expect[] = { { 28, "package body may not contain attribute declarations" }, { 34, "library FOO not found" }, { -1, NULL } }; expect_errors(expect); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_contexts(p) == 3); fail_unless(tree_ident(p) == ident_new("WORK.ONE")); lib_put(lib_work(), p); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_decls(p) == 1); fail_unless(tree_contexts(p) == 4); fail_unless(tree_ident(tree_context(p, 3)) == ident_new("WORK.ONE")); fail_unless(icmp(tree_ident2(tree_context(p, 3)), "all")); fail_unless(tree_ident(p) == ident_new("WORK.TWO")); lib_put(lib_work(), p); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACK_BODY); fail_unless(tree_ident(p) == ident_new("WORK.ONE-body")); fail_unless(tree_decls(p) == 4); d = tree_decl(p, 0); fail_unless(tree_kind(d) == T_FUNC_BODY); d = tree_decl(p, 1); fail_unless(tree_kind(d) == T_VAR_DECL); d = tree_decl(p, 2); fail_unless(tree_kind(d) == T_FUNC_DECL); d = tree_decl(p, 3); fail_unless(tree_kind(d) == T_ATTR_SPEC); lib_put(lib_work(), p); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_decls(p) == 2); fail_unless(tree_ident(p) == ident_new("WORK.THREE")); d = tree_decl(p, 0); fail_unless(tree_kind(d) == T_SIGNAL_DECL); d = tree_decl(p, 1); fail_unless(tree_kind(d) == T_ALIAS); fail_unless(tree_contexts(p) == 4); c = tree_context(p, 3); fail_unless(tree_kind(c) == T_LIBRARY); fail_unless(tree_ident(c) == ident_new("FOO")); p = parse(); fail_unless(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_enum) { tree_t p, d, i; type_t t; input_from_file(TESTDIR "/parse/enum.vhd"); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); d = get_decl(p, "A"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("A")); t = tree_type(d); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_enum_literals(t) == 3); i = type_enum_literal(t, 0); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("X")); fail_unless(tree_pos(i) == 0); i = type_enum_literal(t, 1); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("Y")); fail_unless(tree_pos(i) == 1); i = type_enum_literal(t, 2); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("Z")); fail_unless(tree_pos(i) == 2); d = get_decl(p, "B"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("B")); t = tree_type(d); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_enum_literals(t) == 3); i = type_enum_literal(t, 0); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("'x'")); i = type_enum_literal(t, 1); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("'y'")); i = type_enum_literal(t, 2); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("Z")); d = get_decl(p, "C"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("C")); t = tree_type(d); fail_unless(type_kind(t) == T_ENUM); fail_unless(type_enum_literals(t) == 1); i = type_enum_literal(t, 0); fail_unless(tree_kind(i) == T_ENUM_LIT); fail_unless(tree_ident(i) == ident_new("FOO")); fail_unless(tree_pos(i) == 0); p = parse(); fail_unless(p == NULL); fail_if_errors(); } END_TEST START_TEST(test_qual) { tree_t a, p, s, q, e; input_from_file(TESTDIR "/parse/qual.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 1); p = tree_stmt(a, 0); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); q = tree_value(tree_waveform(s, 0)); fail_unless(tree_kind(q) == T_QUALIFIED); fail_unless(tree_ident(q) == ident_new("WORK.BAR-FOO.FOO")); e = tree_value(q); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("B")); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); q = tree_value(tree_waveform(s, 0)); fail_unless(tree_kind(q) == T_QUALIFIED); fail_unless(tree_ident(q) == ident_new("WORK.BAR-FOO.FOO")); e = tree_value(q); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("'c'")); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_func) { tree_t p, f, a; type_t t; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/func.vhd"); const error_t expect[] = { { 20, "\"blah\" is not an operator symbol" }, { -1, NULL } }; expect_errors(expect); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_decls(p) == 4); lib_put(lib_work(), p); f = tree_decl(p, 0); fail_unless(tree_kind(f) == T_FUNC_DECL); fail_unless(tree_ident(f) == ident_new("ADD")); fail_unless(tree_ports(f) == 3); a = tree_port(f, 0); fail_unless(tree_kind(a) == T_PARAM_DECL); fail_unless(tree_ident(a) == ident_new("X")); fail_unless(tree_subkind(a) == PORT_IN); t = tree_type(f); fail_unless(type_kind(t) == T_SIGNATURE); fail_unless(type_has_result(t)); f = tree_decl(p, 1); fail_unless(tree_kind(f) == T_FUNC_DECL); fail_unless(tree_ident(f) == ident_new("NAUGHTY")); fail_unless(tree_ports(f) == 0); fail_unless(tree_flags(f) & TREE_F_IMPURE); f = tree_decl(p, 2); fail_unless(tree_kind(f) == T_FUNC_DECL); fail_unless(tree_ident(f) == ident_new("\"+\"")); fail_unless(tree_ports(f) == 2); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACK_BODY); fail_unless(tree_decls(p) == 2); p = parse(); fail_unless(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_array) { tree_t p, d, a, g, s, e, r; type_t t, i, b; tree_t x, left, right; input_from_file(TESTDIR "/parse/array.vhd"); const error_t expect[] = { { 26, "named and positional associations cannot be mixed in array" }, { 39, "cannot index non-array type INTEGER" }, { 39, "cannot index non-array type INTEGER" }, { 47, "expected 2 constraints for type BV2D but found 1" }, { -1, NULL } }; expect_errors(expect); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); d = get_decl(p, "INT_ARRAY"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("INT_ARRAY")); t = tree_type(d); fail_unless(type_kind(t) == T_ARRAY); fail_unless(type_indexes(t) == 1); i = type_index(t, 0); fail_unless(type_kind(i) == T_INTEGER); fail_unless(type_ident(i) == ident_new("STD.STANDARD.INTEGER")); b = type_elem(t); fail_unless(type_kind(b) == T_INTEGER); fail_unless(type_ident(b) == ident_new("STD.STANDARD.INTEGER")); d = get_decl(p, "TEN_INTS"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("TEN_INTS")); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_ident(t)); fail_unless(tree_ranges(type_constraint(t)) == 1); fail_unless(type_kind(type_base(t)) == T_ARRAY); d = get_decl(p, "CHAR_COUNTS"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("CHAR_COUNTS")); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(tree_ranges(type_constraint(t)) == 1); r = tree_range(type_constraint(t), 0); fail_unless(tree_subkind(r) == RANGE_EXPR); fail_unless(tree_kind(tree_value(r)) == T_ATTR_REF); fail_unless(tree_ident(tree_value(r)) == ident_new("RANGE")); x = tree_name(tree_value(r)); fail_unless(tree_ident(x) == ident_new("CHARS")); fail_unless(tree_kind(x) == T_REF); d = get_decl(p, "TWO_D"); fail_unless(tree_kind(d) == T_TYPE_DECL); fail_unless(tree_ident(d) == ident_new("TWO_D")); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(tree_ranges(type_constraint(t)) == 2); fail_unless(type_indexes(type_base(t)) == 2); r = tree_range(type_constraint(t), 0); left = tree_left(r); fail_unless(tree_kind(left) == T_TYPE_CONV); fail_unless(tree_ival(tree_value(left)) == 1); right = tree_right(r); fail_unless(tree_kind(right) == T_TYPE_CONV); fail_unless(tree_ival(tree_value(right)) == 3); r = tree_range(type_constraint(t), 1); left = tree_left(r); fail_unless(tree_kind(left) == T_TYPE_CONV); fail_unless(tree_ival(tree_value(left)) == 4); right = tree_right(r); fail_unless(tree_kind(right) == T_TYPE_CONV); fail_unless(tree_ival(tree_value(right)) == 6); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_decls(a) == 9); d = get_decl(a, "X"); fail_unless(tree_ident(d) == ident_new("X")); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_constraint(t)); r = tree_range(type_constraint(t), 0); fail_unless(tree_ival(tree_left(r)) == 1); fail_unless(tree_ival(tree_right(r)) == 5); d = get_decl(a, "Y"); fail_unless(tree_ident(d) == ident_new("Y")); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_ident(t) == ident_new("WORK.P.TEN_INTS")); d = get_decl(a, "Z"); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_constraint(t)); r = tree_range(type_constraint(t), 0); fail_unless(tree_ival(tree_left(r)) == 1); fail_unless(tree_ival(tree_right(r)) == 3); fail_unless(tree_has_value(d)); g = tree_value(d); fail_unless(tree_kind(g) == T_AGGREGATE); fail_unless(tree_assocs(g) == 3); for (int i = 0; i < 3; i++) { x = tree_assoc(g, i); fail_unless(tree_subkind(x) == A_POS); fail_unless(tree_pos(x) == i); fail_unless(tree_ival(tree_value(x)) == i); } d = get_decl(a, "N"); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_constraint(t) == 1); r = tree_range(type_constraint(t), 0); fail_unless(tree_ival(tree_left(r)) == 1); fail_unless(tree_ival(tree_right(r)) == 3); fail_unless(tree_has_value(d)); g = tree_value(d); fail_unless(tree_kind(g) == T_AGGREGATE); fail_unless(tree_assocs(g) == 3); x = tree_assoc(g, 0); fail_unless(tree_subkind(x) == A_POS); fail_unless(tree_pos(x) == 0); fail_unless(tree_ival(tree_value(x)) == 0); x = tree_assoc(g, 1); fail_unless(tree_subkind(x) == A_NAMED); fail_unless(tree_kind(tree_name(x)) == T_LITERAL); fail_unless(tree_ival(tree_name(x)) == 1); fail_unless(tree_ival(tree_value(x)) == 1); x = tree_assoc(g, 2); fail_unless(tree_subkind(x) == A_OTHERS); fail_unless(tree_ival(tree_value(x)) == 2); d = get_decl(a, "M"); t = tree_type(d); fail_unless(type_kind(t) == T_SUBTYPE); fail_unless(type_has_constraint(t)); r = tree_range(type_constraint(t), 0); fail_unless(tree_ival(tree_left(r)) == 1); fail_unless(tree_ival(tree_right(r)) == 3); fail_unless(tree_has_value(d)); g = tree_value(d); fail_unless(tree_kind(g) == T_AGGREGATE); fail_unless(tree_assocs(g) == 1); x = tree_assoc(g, 0); fail_unless(tree_subkind(x) == A_RANGE); r = tree_range(x, 0); fail_unless(tree_ival(tree_left(r)) == 1); fail_unless(tree_ival(tree_right(r)) == 3); fail_unless(tree_ival(tree_value(x)) == 0); d = get_decl(a, "U"); fail_unless(tree_assocs(tree_value(d)) == 4); d = get_decl(a, "V"); fail_unless(tree_assocs(tree_value(d)) == 4); p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); s = tree_stmt(p, 0); e = tree_target(s); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_params(e) == 1); fail_unless(tree_subkind(tree_param(e, 0)) == P_POS); fail_unless(tree_pos(tree_param(e, 0)) == 0); fail_unless(tree_ival(tree_value(tree_param(e, 0))) == 0); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s) == 1); e = tree_value(tree_waveform(s, 0)); fail_unless(tree_kind(e) == T_ARRAY_REF); s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); e = tree_target(s); fail_unless(tree_kind(e) == T_ARRAY_SLICE); e = tree_value(tree_waveform(s, 0)); fail_unless(tree_kind(e) == T_ARRAY_SLICE); s = tree_stmt(p, 4); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_value(s); fail_unless(tree_kind(e) == T_AGGREGATE); fail_unless(tree_assocs(e) == 1); fail_unless(tree_subkind(tree_assoc(e, 0)) == A_RANGE); s = tree_stmt(p, 5); fail_unless(tree_kind(s) == T_VAR_ASSIGN); e = tree_value(s); fail_unless(tree_kind(e) == T_AGGREGATE); fail_unless(tree_assocs(e) == 1); fail_unless(tree_subkind(tree_assoc(e, 0)) == A_RANGE); p = parse(); fail_unless(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_instance) { tree_t e, a, s, c, p; input_from_file(TESTDIR "/parse/instance.vhd"); const error_t expect[] = { { 55, "X is not a formal generic of WORK.FOO" }, { 61, "found at least 1 positional actuals but FOO has only 0" }, { 65, "invalid instantiated unit name" }, { 69, "design unit SOMETHING is not a component declaration" }, { 71, "design unit SOMETHING is not a configuration" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 15); lib_put(lib_work(), a); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_COMPONENT); fail_unless(tree_ident(s) == ident_new("A")); fail_unless(tree_ident2(s) == ident_new("FOO")); s = tree_stmt(a, 2); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_ENTITY); fail_unless(tree_ident(s) == ident_new("B1")); fail_unless(tree_ident2(s) == ident_new("WORK.FOO-GOO")); s = tree_stmt(a, 3); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_CONFIGURATION); fail_unless(tree_ident(s) == ident_new("C1")); fail_unless(tree_ident2(s) == ident_new("WORK.BAR")); s = tree_stmt(a, 4); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_COMPONENT); fail_unless(tree_ident(s) == ident_new("D")); fail_unless(tree_ident2(s) == ident_new("FOO")); s = tree_stmt(a, 5); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_ENTITY); fail_unless(tree_ident(s) == ident_new("E")); fail_unless(tree_ident2(s) == ident_new("WORK.FOO")); fail_unless(tree_params(s) == 3); s = tree_stmt(a, 7); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_ENTITY); fail_unless(tree_ident(s) == ident_new("G")); fail_unless(tree_ident2(s) == ident_new("WORK.FOO")); fail_unless(tree_params(s) == 2); fail_unless(tree_genmaps(s) == 1); s = tree_stmt(a, 8); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_ENTITY); fail_unless(tree_subkind(tree_param(s, 0)) == P_NAMED); fail_unless(tree_kind(tree_value(tree_param(s, 0))) == T_OPEN); s = tree_stmt(a, 9); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_COMPONENT); s = tree_stmt(a, 10); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_COMPONENT); fail_unless(tree_has_ref(s)); fail_unless(tree_loc(tree_ref(s))->first_line == 18); s = tree_stmt(a, 12); fail_unless(tree_kind(s) == T_INSTANCE); fail_unless(tree_class(s) == C_ENTITY); fail_unless(tree_has_ref(s)); fail_unless(tree_kind(tree_ref(s)) == T_ENTITY); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_conc) { tree_t e, a, s, c, s0; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/conc.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 8); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); fail_unless(tree_kind(tree_target(s)) == T_REF); fail_unless(tree_conds(s) == 1); c = tree_cond(s, 0); fail_unless(tree_kind(c) == T_COND_STMT); fail_unless(tree_stmts(c) == 1); s0 = tree_stmt(c, 0); fail_unless(tree_kind(s0) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s0) == 1); fail_if(tree_has_value(c)); fail_unless(tree_kind(tree_value(tree_waveform(s0, 0))) == T_FCALL); s = tree_stmt(a, 1); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); fail_unless(tree_kind(tree_target(s)) == T_REF); fail_unless(tree_conds(s) == 3); c = tree_cond(s, 0); fail_unless(tree_kind(c) == T_COND_STMT); s0 = tree_stmt(c, 0); fail_unless(tree_kind(s0) == T_SIGNAL_ASSIGN); fail_unless(tree_waveforms(s0) == 1); fail_unless(tree_has_value(c)); fail_unless(tree_kind(tree_value(tree_waveform(s0, 0))) == T_REF); s = tree_stmt(a, 2); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_SELECT); fail_unless(tree_stmts(s) == 3); fail_unless(tree_kind(tree_stmt(s, 0)) == T_ALTERNATIVE); fail_unless(tree_assocs(tree_stmt(s, 0)) == 1); s = tree_stmt(a, 3); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_params(s) == 2); s = tree_stmt(a, 4); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_ASSERT); s = tree_stmt(a, 5); fail_unless(tree_kind(s) == T_CONCURRENT); fail_unless(tree_has_ident(s)); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); fail_unless(tree_kind(tree_target(s)) == T_AGGREGATE); s = tree_stmt(a, 6); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_has_ident(s)); s = tree_stmt(a, 7); fail_unless(tree_kind(s) == T_BLOCK); fail_unless(tree_generics(s) == 2); fail_unless(tree_genmaps(s) == 1); fail_unless(tree_ports(s) == 1); fail_unless(tree_params(s) == 1); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_alias) { tree_t e, a, d; type_t t; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/alias.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 0); fail_unless(tree_decls(a) == 12); d = tree_decl(a, 6); fail_unless(tree_kind(d) == T_ALIAS); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_kind(tree_value(d)) == T_REF); fail_if(tree_has_type(d)); d = tree_decl(a, 7); fail_unless(tree_kind(d) == T_ALIAS); fail_unless(tree_ident(d) == ident_new("BLAH")); fail_unless(tree_kind(tree_value(d)) == T_REF); fail_unless(tree_has_type(d)); d = tree_decl(a, 8); fail_unless(tree_kind(d) == T_ALIAS); fail_unless(tree_ident(d) == ident_new("FUNCI")); fail_unless(tree_kind(tree_value(d)) == T_REF); fail_unless(tree_has_type(d)); t = tree_type(d); fail_unless(type_kind(t) == T_SIGNATURE); fail_unless(type_has_result(t)); d = tree_decl(a, 9); fail_unless(tree_kind(d) == T_ALIAS); fail_unless(tree_ident(d) == ident_new("PROCI")); fail_unless(tree_kind(tree_value(d)) == T_REF); fail_unless(tree_has_type(d)); t = tree_type(d); fail_unless(type_kind(t) == T_SIGNATURE); fail_if(type_has_result(t)); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_attr) { tree_t e, a, d, s, r, v; input_from_file(TESTDIR "/parse/attr.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 2); d = tree_decl(a, 2); fail_unless(tree_kind(d) == T_ATTR_DECL); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(type_kind(tree_type(d)) == T_INTEGER); fail_unless(type_ident(tree_type(d)) == ident_new("STD.STANDARD.INTEGER")); d = tree_decl(a, 3); fail_unless(tree_kind(d) == T_ATTR_SPEC); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_ident2(d) == ident_new("X")); fail_unless(tree_kind(tree_value(d)) == T_LITERAL); fail_unless(tree_class(d) == C_SIGNAL); d = tree_decl(a, 4); fail_unless(tree_kind(d) == T_ATTR_SPEC); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_ident2(d) == ident_new("C")); fail_unless(tree_kind(tree_value(d)) == T_LITERAL); fail_unless(tree_class(d) == C_COMPONENT); d = tree_decl(a, 12); fail_unless(tree_kind(d) == T_ATTR_SPEC); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_ident2(d) == ident_new("'1'")); fail_unless(tree_kind(tree_value(d)) == T_LITERAL); fail_unless(tree_class(d) == C_LITERAL); d = tree_decl(a, 14); fail_unless(tree_kind(d) == T_ATTR_SPEC); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_ident2(d) == ident_new("INTEGER")); fail_unless(tree_kind(tree_value(d)) == T_LITERAL); fail_unless(tree_class(d) == C_TYPE); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_ASSERT); r = tree_value(s); fail_unless(tree_kind(r) == T_FCALL); fail_unless(tree_params(r) == 2); v = tree_value(tree_param(r, 0)); fail_unless(tree_kind(v) == T_ATTR_REF); fail_unless(tree_params(v) == 0); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_procedure) { tree_t p, d; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/procedure.vhd"); const error_t expect[] = { { 34, "unexpected procedure while parsing subprogram specification" }, { 41, "condition conversion is not supported in VHDL-1993" }, { 44, "unexpected end while parsing subprogram declarative item" }, { -1, NULL } }; expect_errors(expect); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); d = get_decl(p, "FOO"); fail_unless(tree_kind(d) == T_PROC_DECL); fail_unless(tree_ports(d) == 2); fail_unless(tree_ident(d) == ident_new("FOO")); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACK_BODY); fail_unless(tree_decls(p) == 5); d = get_decl(p, "FOO"); fail_unless(tree_kind(d) == T_PROC_BODY); fail_unless(tree_ports(d) == 2); fail_unless(tree_ident(d) == ident_new("FOO")); fail_unless(tree_decls(d) == 1); fail_unless(tree_stmts(d) == 1); d = get_decl(p, "BAR"); fail_unless(tree_kind(d) == T_PROC_DECL); fail_unless(tree_ports(d) == 1); fail_unless(tree_ident(d) == ident_new("BAR")); fail_unless(tree_class(tree_port(d, 0)) == C_FILE); d = tree_decl(p, 2); fail_unless(tree_kind(d) == T_PROC_BODY); fail_unless(tree_ports(d) == 0); fail_unless(tree_ident(d) == ident_new("BAZ")); d = tree_decl(p, 3); fail_unless(tree_kind(d) == T_PROC_BODY); fail_unless(tree_ports(d) == 0); fail_unless(tree_kind(tree_decl(d, 0)) == T_USE); p = parse(); fail_unless(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_ir1045) { tree_t e, a, s, q, v, c; input_from_file(TESTDIR "/parse/ir1045.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_unless(tree_kind(a) == T_ARCH); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); c = tree_cond(s, 0); q = tree_value(tree_waveform(tree_stmt(c, 0), 0)); fail_unless(tree_kind(q) == T_QUALIFIED); v = tree_value(q); fail_unless(tree_kind(v) == T_AGGREGATE); s = tree_stmt(a, 1); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); c = tree_cond(s, 0); q = tree_value(tree_waveform(tree_stmt(c, 0), 0)); fail_unless(tree_kind(q) == T_QUALIFIED); v = tree_value(q); fail_unless(tree_kind(v) == T_REF); fail_unless(tree_ident(v) == ident_new("'1'")); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_concat) { tree_t a, s, e, s0; input_from_file(TESTDIR "/parse/concat.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_unless(tree_kind(a) == T_ARCH); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_COND_ASSIGN); s0 = tree_stmt(tree_cond(s, 0), 0); fail_unless(tree_kind(s0) == T_SIGNAL_ASSIGN); e = tree_value(tree_waveform(s0, 0)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_params(e) == 2); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_based) { tree_t p, d; input_from_file(TESTDIR "/parse/based.vhd"); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); d = tree_decl(p, 0); fail_unless(tree_ival(tree_value(d)) == 13); d = tree_decl(p, 1); fail_unless(tree_ival(tree_value(d)) == 6); d = tree_decl(p, 2); fail_unless(tree_ival(tree_value(d)) == 7); d = tree_decl(p, 3); fail_unless(tree_ival(tree_value(d)) == 1234); d = tree_decl(p, 4); fail_unless(tree_ival(tree_value(d)) == 0xbeef01); d = tree_decl(p, 5); fail_unless(tree_ival(tree_value(d)) == 2); d = tree_decl(p, 6); fail_unless(tree_ival(tree_value(d)) == 2); d = tree_decl(p, 7); fail_unless(tree_ival(tree_value(d)) == 0xabababab); d = tree_decl(p, 8); fail_unless(tree_ival(tree_value(d)) == 0x1a); d = tree_decl(p, 9); fail_unless(tree_ival(tree_value(d)) == 255); d = tree_decl(p, 10); fail_unless(tree_ival(tree_value(d)) == 255); d = tree_decl(p, 11); fail_unless(tree_ival(tree_value(d)) == 255); d = tree_decl(p, 12); fail_unless(tree_ival(tree_value(d)) == 224); d = tree_decl(p, 13); fail_unless(tree_ival(tree_value(d)) == 224); d = tree_decl(p, 14); fail_unless(tree_dval(tree_value(d)) == 4095.0); d = tree_decl(p, 15); fail_unless(tree_dval(tree_value(d)) == 4095.0); d = tree_decl(p, 16); fail_unless(tree_ival(tree_value(d)) == 224); d = tree_decl(p, 17); fail_unless(tree_dval(tree_value(d)) == 4095.0); p = parse(); fail_unless(p == NULL); fail_if_errors(); } END_TEST START_TEST(test_bitstring) { tree_t p, a; input_from_file(TESTDIR "/parse/bitstring.vhd"); const error_t expect[] = { { 22, "invalid digit '9' in bit string" }, { 24, "a bit string literal may not start or end with an underscore" }, { 25, "a bit string literal may not start or end with an underscore" }, { 26, "a bit string literal may not contain multiple consecutive " "underscores" }, { 28, "unterminated string literal" }, { 28, "unexpected string while parsing constant declaration" }, { 29, "unterminated string literal" }, { -1, NULL } }; expect_errors(expect); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); ident_t one = ident_new("'1'"); ident_t zero = ident_new("'0'"); a = tree_value(tree_decl(p, 0)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 16); fail_unless(tree_ident(tree_char(a, 0)) == zero); fail_unless(tree_ident(tree_char(a, 1)) == zero); fail_unless(tree_ident(tree_char(a, 2)) == zero); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == zero); fail_unless(tree_ident(tree_char(a, 5)) == zero); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == zero); fail_unless(tree_ident(tree_char(a, 8)) == zero); fail_unless(tree_ident(tree_char(a, 9)) == zero); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); fail_unless(tree_ident(tree_char(a, 12)) == zero); fail_unless(tree_ident(tree_char(a, 13)) == one); fail_unless(tree_ident(tree_char(a, 14)) == zero); fail_unless(tree_ident(tree_char(a, 15)) == zero); a = tree_value(tree_decl(p, 1)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == zero); fail_unless(tree_ident(tree_char(a, 1)) == zero); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == zero); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == zero); fail_unless(tree_ident(tree_char(a, 6)) == zero); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == zero); fail_unless(tree_ident(tree_char(a, 11)) == zero); a = tree_value(tree_decl(p, 2)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 8); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == zero); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == zero); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == zero); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); a = tree_value(tree_decl(p, 3)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 3); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == zero); fail_unless(tree_ident(tree_char(a, 2)) == one); a = tree_value(tree_decl(p, 4)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 4); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); a = tree_value(tree_decl(p, 5)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 8); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == zero); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == zero); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == zero); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); a = tree_value(tree_decl(p, 6)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); a = tree_value(tree_decl(p, 7)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); a = tree_value(tree_decl(p, 8)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 9); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); a = tree_value(tree_decl(p, 9)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == zero); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == zero); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == zero); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); a = tree_value(tree_decl(p, 10)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); a = tree_value(tree_decl(p, 11)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); a = tree_value(tree_decl(p, 12)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 9); fail_unless(tree_ident(tree_char(a, 0)) == one); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == one); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == one); a = tree_value(tree_decl(p, 13)); fail_unless(tree_kind(a) == T_STRING); fail_unless(tree_chars(a) == 12); fail_unless(tree_ident(tree_char(a, 0)) == zero); fail_unless(tree_ident(tree_char(a, 1)) == one); fail_unless(tree_ident(tree_char(a, 2)) == one); fail_unless(tree_ident(tree_char(a, 3)) == one); fail_unless(tree_ident(tree_char(a, 4)) == zero); fail_unless(tree_ident(tree_char(a, 5)) == one); fail_unless(tree_ident(tree_char(a, 6)) == one); fail_unless(tree_ident(tree_char(a, 7)) == one); fail_unless(tree_ident(tree_char(a, 8)) == zero); fail_unless(tree_ident(tree_char(a, 9)) == one); fail_unless(tree_ident(tree_char(a, 10)) == one); fail_unless(tree_ident(tree_char(a, 11)) == one); p = parse(); fail_if(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_block) { tree_t e, a, b; input_from_file(TESTDIR "/parse/block.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 2); b = tree_stmt(a, 0); fail_unless(tree_kind(b) == T_BLOCK); fail_unless(tree_decls(b) == 0); fail_unless(tree_stmts(b) == 0); b = tree_stmt(a, 1); fail_unless(tree_kind(b) == T_BLOCK); fail_unless(tree_decls(b) == 2); fail_unless(tree_stmts(b) == 1); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_comp) { tree_t p, c; input_from_file(TESTDIR "/parse/comp.vhd"); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_decls(p) == 2); c = tree_decl(p, 0); fail_unless(tree_kind(c) == T_COMPONENT); fail_unless(tree_ident(c) == ident_new("C")); fail_unless(tree_ports(c) == 1); fail_unless(tree_generics(c) == 1); c = tree_decl(p, 1); fail_unless(tree_kind(c) == T_COMPONENT); fail_unless(tree_ident(c) == ident_new("FOO")); fail_unless(tree_ports(c) == 1); fail_unless(tree_generics(c) == 0); p = parse(); fail_unless(p == NULL); fail_if_errors(); } END_TEST START_TEST(test_generate) { tree_t e, a, g, i, c; input_from_file(TESTDIR "/parse/generate.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 7); g = tree_stmt(a, 0); fail_unless(tree_kind(g) == T_IF_GENERATE); fail_unless(tree_conds(g) == 1); fail_unless(icmp(tree_ident(g), "G1")); c = tree_cond(g, 0); fail_unless(tree_decls(c) == 1); fail_unless(tree_stmts(c) == 1); g = tree_stmt(a, 1); fail_unless(tree_kind(g) == T_IF_GENERATE); fail_unless(icmp(tree_ident(g), "G2")); c = tree_cond(g, 0); fail_unless(tree_decls(c) == 0); fail_unless(tree_stmts(c) == 1); g = tree_stmt(c, 0); fail_unless(tree_kind(g) == T_IF_GENERATE); fail_unless(icmp(tree_ident(g), "G2A")); c = tree_cond(g, 0); fail_unless(tree_decls(c) == 0); fail_unless(tree_stmts(c) == 1); g = tree_stmt(a, 2); fail_unless(tree_kind(g) == T_FOR_GENERATE); fail_unless(tree_decls(g) == 2); fail_unless(tree_stmts(g) == 1); fail_unless(icmp(tree_ident(g), "G3")); i = tree_decl(g, 0); fail_unless(tree_kind(i) == T_GENERIC_DECL); fail_unless(icmp(tree_ident(i), "I")); fail_unless(tree_class(i) == C_CONSTANT); fail_unless(tree_subkind(i) == PORT_IN); g = tree_stmt(a, 3); fail_unless(tree_kind(g) == T_FOR_GENERATE); fail_unless(tree_decls(g) == 1); fail_unless(tree_stmts(g) == 0); fail_unless(icmp(tree_ident(g), "G4")); i = tree_decl(g, 0); fail_unless(tree_kind(i) == T_GENERIC_DECL); fail_unless(icmp(tree_ident(i), "I")); g = tree_stmt(a, 4); fail_unless(tree_kind(g) == T_FOR_GENERATE); fail_unless(tree_decls(g) == 1); fail_unless(tree_stmts(g) == 0); fail_unless(icmp(tree_ident(g), "G5")); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_access) { tree_t e, a, p, s; input_from_file(TESTDIR "/parse/access.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 1); p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 5); s = tree_stmt(p, 0); fail_unless(tree_kind(tree_target(s)) == T_ALL); s = tree_stmt(p, 2); fail_unless(tree_kind(tree_value(s)) == T_NEW); s = tree_stmt(p, 3); fail_unless(tree_kind(tree_value(s)) == T_ARRAY_SLICE); fail_unless(tree_kind(tree_value(tree_value(s))) == T_ALL); s = tree_stmt(p, 4); fail_unless(tree_kind(tree_value(s)) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_value(s))) == T_ALL); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_spec) { tree_t a, d, b, e, c; input_from_file(TESTDIR "/parse/spec.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 5); fail_unless(tree_decls(a) == 9); lib_put(lib_work(), a); d = tree_decl(a, 2); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("X")); fail_unless(tree_ident2(d) == ident_new("Y")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_ENTITY); fail_unless(tree_ident(b) == ident_new("WORK.FOO")); d = tree_decl(a, 3); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("X1")); fail_unless(tree_ident2(d) == ident_new("Y")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_ENTITY); fail_unless(tree_ident(b) == ident_new("WORK.FOO")); d = tree_decl(a, 4); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("X2")); fail_unless(tree_ident2(d) == ident_new("Y")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_ENTITY); fail_unless(tree_ident(b) == ident_new("WORK.FOO")); d = tree_decl(a, 5); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("X3")); fail_unless(tree_ident2(d) == ident_new("Y")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_ENTITY); fail_unless(tree_ident(b) == ident_new("WORK.FOO")); fail_unless(tree_ident2(b) == ident_new("ARCH")); d = tree_decl(a, 6); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("X4")); fail_unless(tree_ident2(d) == ident_new("Y")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_ENTITY); fail_unless(tree_ident(b) == ident_new("WORK.FOO")); fail_unless(tree_ident2(b) == ident_new("ARCH")); fail_unless(tree_genmaps(b) == 1); fail_unless(tree_params(b) == 1); d = tree_decl(a, 7); fail_unless(tree_kind(d) == T_SPEC); fail_unless(tree_ident(d) == ident_new("all")); fail_unless(tree_ident2(d) == ident_new("P")); b = tree_value(d); fail_unless(tree_kind(b) == T_BINDING); fail_unless(tree_class(b) == C_CONFIGURATION); fail_unless(tree_ident(b) == ident_new("WORK.YAH")); d = tree_decl(a, 8); fail_unless(tree_kind(d) == T_SPEC); fail_if(tree_has_ident(d)); fail_unless(tree_ident2(d) == ident_new("Y")); fail_if(tree_has_value(d)); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_loc) { tree_t a, s, p, e; const loc_t *l; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/loc.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); s = tree_stmt(a, 0); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_PCALL); l = tree_loc(s); fail_unless(l->first_line == 7); fail_unless(l->line_delta == 0); fail_unless(l->first_column == 4); fail_unless(l->column_delta == 14); p = tree_param(s, 0); l = tree_loc(p); fail_unless(l->first_line == 7); fail_unless(l->line_delta == 0); fail_unless(l->first_column == 6); fail_unless(l->column_delta == 0); p = tree_param(s, 2); l = tree_loc(p); fail_unless(l->first_line == 7); fail_unless(l->line_delta == 0); fail_unless(l->first_column == 12); fail_unless(l->column_delta == 4); s = tree_stmt(a, 1); fail_unless(tree_kind(s) == T_CONCURRENT); s = tree_stmt(s, 0); fail_unless(tree_kind(s) == T_ASSERT); l = tree_loc(s); fail_unless(l->first_line == 8); fail_unless(l->line_delta == 0); fail_unless(l->first_column == 4); fail_unless(l->column_delta == 15); e = tree_value(s); fail_unless(tree_kind(e) == T_ATTR_REF); l = tree_loc(e); fail_unless(l->first_line == 8); fail_unless(l->line_delta == 0); fail_unless(l->first_column == 11); fail_unless(l->column_delta == 7); a = parse(); fail_unless(a == NULL); fail_if_errors(); } END_TEST START_TEST(test_expr) { tree_t a, p, e; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/expr.vhd"); const error_t expect[] = { { 37, "unexpected + while parsing primary" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 2); p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 14); e = tree_value(tree_stmt(p, 0)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"not\"")); fail_unless(tree_params(e) == 1); e = tree_value(tree_stmt(p, 1)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"abs\"")); fail_unless(tree_params(e) == 1); e = tree_value(tree_stmt(p, 2)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"**\"")); fail_unless(tree_params(e) == 2); e = tree_value(tree_stmt(p, 3)); fail_unless(tree_kind(e) == T_RECORD_REF); fail_unless(tree_ident(e) == ident_new("Z")); fail_unless(tree_kind(tree_value(e)) == T_FCALL); fail_unless(tree_has_ref(e)); fail_unless(tree_kind(tree_ref(e)) == T_FIELD_DECL); fail_unless(tree_ident(tree_ref(e)) == ident_new("Z")); const char *shift_ops[] = { "sll", "srl", "sla", "sra", "rol", "ror" }; for (size_t i = 0; i < ARRAY_LEN(shift_ops); i++) { char buf[16]; snprintf(buf, sizeof(buf), "\"%s\"", shift_ops[i]); e = tree_value(tree_stmt(p, 4 + i)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new(buf)); fail_unless(tree_params(e) == 2); } e = tree_value(tree_stmt(p, 10)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("WORK.FOO.\"and\"")); e = tree_target(tree_stmt(p, 11)); fail_unless(tree_kind(e) == T_ARRAY_SLICE); e = tree_value(tree_stmt(p, 12)); fail_unless(tree_kind(e) == T_AGGREGATE); fail_unless(tree_assocs(e) == 2); fail_unless(tree_subkind(tree_assoc(e, 0)) == A_NAMED); fail_unless(tree_subkind(tree_assoc(e, 1)) == A_RANGE); // See note under LRM 93 section 7.2.5 e = tree_value(tree_stmt(p, 13)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"+\"")); fail_unless(tree_params(e) == 2); e = tree_value(tree_param(e, 0)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"-\"")); fail_unless(tree_params(e) == 1); e = tree_value(tree_param(e, 0)); fail_unless(tree_kind(e) == T_FCALL); fail_unless(tree_ident(e) == ident_new("\"*\"")); fail_unless(tree_params(e) == 2); a = parse(); fail_unless(a == NULL); check_expected_errors(); } END_TEST START_TEST(test_error) { input_from_file(TESTDIR "/parse/error.vhd"); const error_t expect[] = { { 7, "unexpected identifier while parsing concurrent procedure call " "statement, expecting one of ( or ;" }, { 11, "unexpected identifier while parsing concurrent procedure call " "statement, expecting one of ( or ;" }, { 17, "unexpected ; while parsing process statement, expecting process" }, { 23, "expected trailing process statement label to match FOO" }, { 27, "trailing label for process statement without label" }, { 34, "expected trailing if statement label to match MY_IF" }, { 35, "signal X is not a formal parameter and subprogram" }, { 35, "signal X is not a formal parameter and subprogram" }, { 36, "expected trailing subprogram body label to match \"+\"" }, { 46, "P1 already declared in this region" }, { 49, "A1 already declared in this region" }, { 52, "S1 already declared in this region" }, { 55, "B1 already declared in this region" }, { 61, "C1 already declared in this region" }, { 64, "no visible declaration for NOT_A_LIBRARY" }, { 69, "design unit NOT_HERE not found in library WORK" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); for (int i = 0; i < 3; i++) { tree_t a = parse(); fail_if(a == NULL); } check_expected_errors(); } END_TEST START_TEST(test_config) { tree_t e, c, s, b, a, p; input_from_file(TESTDIR "/parse/config.vhd"); const error_t expect[] = { { 29, "no visible declaration for X" }, { 38, "design unit CONF is not an entity" }, { 39, "no visible declaration for ARCH" }, { 45, "cannot find architecture BAD of entity WORK.ENT" }, { 52, "P is not a block that can be configured" }, { 55, "instance P not found" }, { 85, "a binding indication in an explicit configuration " "specification must contain an entity aspect" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); fail_unless(tree_ident(c) == ident_new("WORK.CONF")); fail_unless(tree_ident2(c) == ident_new("ENT")); fail_unless(tree_decls(c) == 3); fail_unless(tree_kind(tree_decl(c, 0)) == T_USE); fail_unless(tree_kind(tree_decl(c, 1)) == T_ATTR_SPEC); lib_put(lib_work(), c); b = tree_decl(c, 2); fail_unless(tree_kind(b) == T_BLOCK_CONFIG); fail_unless(tree_ident(b) == ident_new("ARCH")); fail_unless(tree_decls(b) == 2); s = tree_decl(b, 0); fail_unless(tree_kind(s) == T_SPEC); fail_unless(tree_ident(s) == ident_new("all")); fail_unless(tree_ident2(s) == ident_new("COMP")); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); lib_put(lib_work(), c); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ARCH); lib_put(lib_work(), e); c = parse(); fail_unless(c == NULL); check_expected_errors(); } END_TEST START_TEST(test_protected) { tree_t p, d, s; type_t t; opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_00); input_from_file(TESTDIR "/parse/protected.vhd"); p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); d = get_decl(p, "SHAREDCOUNTER"); fail_unless(tree_kind(d) == T_PROT_DECL); t = tree_type(d); fail_unless(type_kind(t) == T_PROTECTED); fail_unless(type_fields(t) == 3); s = type_field(t, 0); fail_unless(tree_kind(s) == T_PROC_DECL); fail_unless(tree_ident(s) == ident_new("INCREMENT")); fail_unless(tree_flags(s) & TREE_F_PROTECTED); d = get_nth_decl(p, "SHAREDCOUNTER", 1); fail_unless(tree_kind(d) == T_PROT_BODY); fail_unless(tree_decls(d) == 5); d = get_decl(d, "ADD10"); fail_unless(tree_kind(d) == T_PROC_BODY); fail_unless(tree_flags(d) & TREE_F_PROTECTED); s = tree_stmt(d, 0); fail_unless(tree_kind(s) == T_PROT_PCALL); p = parse(); fail_unless(p == NULL); fail_if_errors(); } END_TEST START_TEST(test_empty) { input_from_file(TESTDIR "/parse/empty.vhd"); fail_unless(parse() == NULL); } END_TEST START_TEST(test_issue205) { input_from_file(TESTDIR "/parse/issue205.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t s = tree_message(tree_stmt(tree_stmt(a, 0), 0)); fail_unless(tree_kind(s) == T_STRING); fail_unless(tree_chars(s) == 2); fail_unless(tree_ident(tree_char(s, 0)) == ident_new("'\"'")); fail_unless(tree_ident(tree_char(s, 1)) == ident_new("'\"'")); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_context) { set_standard(STD_08); input_from_file(TESTDIR "/parse/context.vhd"); const error_t expect[] = { { 19, "context clause preceeding context declaration must be empty" }, { -1, NULL } }; expect_errors(expect); lib_t widget_lib = lib_tmp("widget_lib"); lib_set_work(widget_lib); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t c1 = parse(); fail_if(c1 == NULL); fail_unless(tree_kind(c1) == T_CONTEXT); fail_unless(tree_ident(c1) == ident_new("WIDGET_LIB.WIDGET_CONTEXT")); fail_unless(tree_contexts(c1) == 5); tree_t u3 = tree_context(c1, 3); fail_unless(tree_kind(u3) == T_USE); fail_unless(tree_ident(u3) == ident_new("WIDGET_LIB.WIDGET_DEFS")); fail_unless(tree_ident2(u3) == well_known(W_ALL)); fail_unless(tree_ref(u3) == p1); lib_put(lib_work(), c1); lib_t project = lib_tmp("project"); lib_set_work(project); tree_t c2 = parse(); fail_if(c2 == NULL); fail_unless(tree_kind(c2) == T_CONTEXT); fail_unless(tree_ident(c2) == ident_new("PROJECT.DONGLE_CONTEXT")); fail_unless(tree_contexts(c2) == 5); lib_put(lib_work(), c2); tree_t r = tree_context(c2, 4); fail_unless(tree_kind(r) == T_CONTEXT_REF); fail_unless(tree_ident(r) == ident_new("WIDGET_LIB.WIDGET_CONTEXT")); fail_if(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue222) { input_from_file(TESTDIR "/parse/issue222.vhd"); const error_t expect[] = { { 13, "component instantiation statement must have a label" }, { 22, "block statement must have a label" }, { 32, "component instantiation statement must have a label" }, { 37, "generate statement must have a label" }, { 58, "generate statement must have a label" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 8; i++) { tree_t t = parse(); fail_if(t == NULL); lib_put(lib_work(), t); } fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_guarded) { input_from_file(TESTDIR "/parse/guarded.vhd"); const error_t expect[] = { { 7, "guarded assignment has no visible guard signal" }, { 9, "guarded assignment has no visible guard signal" }, { 25, "Q in disconnection specification must denote a guarded" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_stmts(a) == 4); tree_t b2 = tree_stmt(a, 2); fail_unless(tree_kind(b2) == T_BLOCK); fail_unless(tree_stmts(b2) == 3); fail_unless(tree_decls(b2) == 1); tree_t g = tree_decl(b2, 0); fail_unless(tree_kind(g) == T_IMPLICIT_SIGNAL); fail_unless(tree_ident(g) == ident_new("GUARD")); tree_t s0 = tree_stmt(b2, 0); fail_unless(tree_kind(s0) == T_CONCURRENT); tree_t s0s0 = tree_stmt(s0, 0); fail_unless(tree_kind(s0s0) == T_COND_ASSIGN); fail_unless(tree_has_guard(s0s0)); tree_t gref = tree_guard(s0s0); fail_unless(tree_kind(gref) == T_GUARD); fail_unless(tree_ref(gref) == g); tree_t s1 = tree_stmt(b2, 1); fail_unless(tree_kind(s1) == T_CONCURRENT); tree_t s1s0 = tree_stmt(s1, 0); fail_unless(tree_kind(s1s0) == T_SELECT); fail_unless(tree_has_guard(s1s0)); tree_t b3 = tree_stmt(a, 3); fail_unless(tree_kind(b3) == T_BLOCK); fail_unless(tree_stmts(b3) == 2); fail_unless(tree_decls(b3) == 3); tree_t d2 = tree_decl(b3, 2); fail_unless(tree_kind(d2) == T_DISCONNECT); fail_unless(tree_ident(d2) == ident_new("Q")); fail_unless(type_eq(tree_type(d2), std_type(NULL, STD_BIT))); fail_unless(tree_has_ref(d2)); fail_unless(tree_ref(d2) == tree_decl(b3, 1)); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_cond1) { input_from_file(TESTDIR "/parse/cond1.vhd"); const error_t expect[] = { { 10, "\"this is a warning\"" }, { 13, "\"Using nvc\"" }, { 21, "\"correct\"" }, { 25, "\"VHDL version is correct\"" }, { 32, "undefined conditional analysis identifier FOO" }, { 35, "unterminated conditional analysis block" }, { 38, "unexpected end of file while parsing package declaration" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_decls(p) == 1); fail_unless(tree_ident(tree_decl(p, 0)) == ident_new("C")); fail_unless(parse() != NULL); check_expected_errors(); } END_TEST START_TEST(test_issue360) { input_from_file(TESTDIR "/parse/issue360.vhd"); const error_t expect[] = { { 8, "unexpected ; while parsing process statement, expecting process" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); fail_unless(parse() != NULL); check_expected_errors(); } END_TEST START_TEST(test_issue367) { input_from_file(TESTDIR "/parse/issue367.vhd"); const error_t expect[] = { { 13, "declaration of I hides an earlier declaration with the same " }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); tree_t f = tree_decl(b, 0); fail_unless(tree_kind(f) == T_FUNC_BODY); tree_t d = tree_decl(f, 1); fail_unless(tree_kind(d) == T_VAR_DECL); fail_unless(tree_ident(d) == ident_new("I")); type_t type = tree_type(d); fail_unless(type_kind(type) == T_SUBTYPE); tree_t c = type_constraint(type); fail_unless(tree_ranges(c) == 1); tree_t r = tree_range(c, 0); fail_unless(tree_subkind(r) == RANGE_EXPR); fail_unless(tree_kind(tree_value(r)) == T_ATTR_REF); fail_if(parse() != NULL); check_expected_errors(); } END_TEST START_TEST(test_issue369) { input_from_file(TESTDIR "/parse/issue369.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t p = tree_stmt(a, 0); tree_t aspec = get_nth_decl(p, "A", 1); fail_unless(tree_kind(aspec) == T_ATTR_SPEC); fail_unless(tree_class(aspec) == C_LITERAL); tree_t cmp = tree_value(tree_stmt(p, 0)); fail_unless(tree_kind(cmp) == T_FCALL); tree_t aref = tree_value(tree_param(cmp, 0)); fail_unless(tree_kind(aref) == T_ATTR_REF); fail_unless(tree_ident(aref) == ident_new("A")); tree_t ref = tree_name(aref); fail_unless(tree_ident(ref) == ident_new("THIS_PROCESS.'1'")); fail_if(parse() != NULL); fail_if_errors(); } END_TEST; START_TEST(test_vests1) { input_from_file(TESTDIR "/parse/vests1.vhd"); tree_t e0 = parse(); fail_if(e0 == NULL); fail_unless(tree_kind(e0) == T_ENTITY); lib_put(lib_work(), e0); tree_t a0 = parse(); fail_if(a0 == NULL); fail_unless(tree_kind(a0) == T_ARCH); lib_put(lib_work(), a0); tree_t c0 = parse(); fail_if(c0 == NULL); fail_unless(tree_kind(c0) == T_CONFIGURATION); fail_unless(tree_primary(c0) == e0); lib_put(lib_work(), c0); tree_t e1 = parse(); fail_if(e1 == NULL); fail_unless(tree_kind(e1) == T_ENTITY); lib_put(lib_work(), e1); tree_t a1 = parse(); fail_if(a1 == NULL); fail_unless(tree_kind(a1) == T_ARCH); lib_put(lib_work(), a1); tree_t c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); fail_unless(tree_decls(c) == 1); fail_unless(tree_primary(c) == e1); lib_put(lib_work(), c); tree_t b = tree_decl(c, 0); fail_unless(tree_kind(b) == T_BLOCK_CONFIG); fail_unless(tree_decls(b) == 1); fail_unless(tree_ref(b) == a1); tree_t b2 = tree_decl(b, 0); fail_unless(tree_kind(b2) == T_BLOCK_CONFIG); fail_unless(tree_decls(b2) == 3); fail_unless(tree_has_ref(b2)); fail_unless(tree_ref(b2) == tree_stmt(a1, 0)); tree_t b3 = tree_decl(b2, 2); fail_unless(tree_kind(b3) == T_BLOCK_CONFIG); fail_unless(tree_ident(b3) == ident_new("G")); fail_unless(tree_decls(b3) == 1); fail_unless(tree_ref(b3) == tree_stmt(tree_stmt(a1, 0), 1)); fail_if(parse() != NULL); fail_if_errors(); } END_TEST; START_TEST(test_synth) { input_from_file(TESTDIR "/parse/synth.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_decls(a) == 2); fail_unless(tree_ident(tree_decl(a, 1)) == ident_new("Y")); fail_unless(tree_stmts(a) == 2); fail_unless(tree_pragmas(a) == 4); tree_t p0 = tree_pragma(a, 0); fail_unless(tree_kind(p0) == T_PRAGMA); fail_unless(tree_subkind(p0) == PRAGMA_SYNTHESIS_OFF); fail_if(parse() != NULL); fail_if_errors(); } END_TEST; START_TEST(test_issue388) { input_from_file(TESTDIR "/parse/issue388.vhd"); const error_t expect[] = { { 11, "unexpected => while parsing slice name, expecting one of" }, { 12, "expected concurrent statement" }, { 14, "no visible declaration for CALL" }, { 14, "expected concurrent statement" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t p = parse(); fail_if(p == NULL); check_expected_errors(); } END_TEST START_TEST(test_names) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/names.vhd"); const error_t expect[] = { { 14, "FUNC4 [INTEGER return INTEGER] already declared" }, { 42, "ambiguous use of enumeration literal '1'" }, { 46, "no possible overload of FUNC5 has formal Z" }, { 46, "ambiguous use of enumeration literal '1'" }, { 47, "type of string literal cannot be determined from the" }, { 50, "type of aggregate cannot be determined from the surrounding" }, { 0, "could be BIT_VECTOR or BOOL_VECTOR" }, { 0, "context contains overload FUNC6 [BIT_VECTOR return INTEGER]" }, { 0, "context contains overload FUNC6 [BOOL_VECTOR return INTEGER]" }, { 51, "type of aggregate cannot be determined from the surrounding" }, { 54, "no matching subprogram FUNC7 [universal_integer return INT" }, { 0, "no implicit conversion was performed on the first argument" }, { 56, "type of string literal cannot be determined from the" }, { 69, "PROC4 [INTEGER] already declared in this region" }, { 84, "PROC8 already declared in this region" }, { 92, "ambiguous use of enumeration literal '1'" }, { 96, "no possible overload of PROC5 has formal Z" }, { 96, "ambiguous use of enumeration literal '1'" }, { 97, "type of string literal cannot be determined from the" }, { 100, "type of aggregate cannot be determined from the surrounding" }, { 101, "type of aggregate cannot be determined from the surrounding" }, { 104, "no matching subprogram PROC7 [universal_integer]" }, { 0, "no implicit conversion was performed on the first argument" }, { 106, "type of string literal cannot be determined from the" }, { 0, "could be BIT_VECTOR or STRING" }, { 107, "expected procedure name" }, { 108, "no visible declaration for FOO" }, { 222, "ambiguous use of name FOO" }, { 233, "name X not found in \"+\"" }, { 256, "no visible declaration for NOTHERE" }, { 313, "no visible declaration for FNORK" }, { 323, "no matching subprogram P26_1 [universal_integer" }, { 332, "no matching operator \"and\" [BIT, BOOLEAN return BOOLEAN]" }, { 360, "object X with type INTEGER cannot be selected" }, { 362, "no visible declaration for FOO" }, { 386, "expecting type mark while parsing qualified expression" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); type_t std_int = std_type(NULL, STD_INTEGER); tree_t p = tree_stmt(a, 0); tree_t s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_VAR_ASSIGN); tree_t t = tree_value(s); fail_unless(tree_kind(t) == T_FCALL); fail_unless(type_eq(tree_type(t), std_int)); tree_t d = tree_ref(t); fail_unless(tree_loc(d)->first_line == 5); t = tree_value(tree_param(t, 0)); fail_unless(tree_kind(t) == T_LITERAL); fail_unless(type_eq(tree_type(t), std_type(NULL, STD_INTEGER))); p = tree_stmt(a, 4); d = get_decl(p, "TABLE"); fail_unless(tree_kind(d) == T_CONST_DECL); tree_t v = tree_value(d); fail_unless(tree_kind(v) == T_AGGREGATE); fail_unless(tree_assocs(v) == 2); tree_t a0 = tree_assoc(v, 0); fail_unless(tree_subkind(a0) == A_NAMED); tree_t n0 = tree_name(a0); fail_unless(tree_kind(n0) == T_REF); fail_unless(tree_ident(n0) == ident_new("'0'")); fail_unless(type_ident(tree_type(n0)) == ident_new("STD.STANDARD.BIT")); tree_t b = tree_stmt(a, 7); fail_unless(tree_kind(b) == T_BLOCK); d = tree_decl(b, 0); fail_unless(tree_kind(d) == T_FUNC_DECL); fail_unless(tree_ident2(d) == ident_new("WORK.EE-AA.B8.GET_FOO()I")); p = tree_stmt(a, 8); fail_unless(tree_kind(p) == T_PROCESS); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_ASSERT); v = tree_value(s); fail_unless(tree_kind(v) == T_FCALL); fail_unless(tree_ident(v) == ident_new("\"<\"")); d = tree_ref(v); fail_unless(tree_kind(d) == T_FUNC_BODY); fail_if(tree_flags(d) & TREE_F_PREDEFINED); check_expected_errors(); } END_TEST START_TEST(test_implicit) { opt_set_int(OPT_MISSING_BODY, 1); input_from_file(TESTDIR "/parse/names.vhd"); fail_if_errors(); } END_TEST START_TEST(test_error2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_00); input_from_file(TESTDIR "/parse/error2.vhd"); const error_t expect[] = { { 1, "design unit DUNNO not found in library WORK" }, { 2, "no visible declaration for BAR" }, { 5, "no visible declaration for SDFF" }, { 10, "no visible declaration for SGHBBX" }, { 17, "design unit NOTHERE not found in library STD" }, { 22, "unexpected identifier while parsing range" }, { 29, "expected physical type definition trailing" }, { 33, "expected record type definition trailing identifier" }, { 38, "unexpected procedure while parsing subprogram body" }, { 42, "unexpected function while parsing subprogram body" }, { 45, "trailing protected type declaration label to match OTHER" }, { 47, "unexpected integer while parsing subtype declaration" }, { 53, "cannot index non-array type FT" }, { 57, "type mark does not denote a type or a subtype" }, { -1, NULL } }; expect_errors(expect); parse(); check_expected_errors(); } END_TEST START_TEST(test_vhdl2008) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/parse/vhdl2008.vhd"); const error_t expect[] = { { 84, "no matching operator \"+\" [DELAY_LENGTH, TIME" }, { 111, "excess non-zero digits in bit string literal" }, { 112, "excess non-zero digits in bit string literal" }, { 121, "excess significant digits in bit string literal" }, { 124, "invalid digit 'C' in decimal bit string" }, { 127, "excess non-zero digits in decimal bit string literal" }, { 171, "unexpected ; while parsing case statement, expecting ?" }, { 181, "prefix of 'SUBTYPE attribute does not have a type" }, { 183, "prefix of 'ELEMENT attribute must be an array type" }, { 184, "prefix of 'ELEMENT attribute does not have a type" }, { 230, "unexpected trailing label for generate statement body without" }, { 232, "expected trailing generate statement body label to match FOO" }, { 249, "expected trailing case generate statement label to match G3" }, { 264, "signed bit string literal cannot be an empty string" }, { 282, "the reserved word INERTIAL can only be used in port map " }, { 290, "the reserved word INERTIAL can only be used in port map " }, { 295, "parameter interface list cannot contain type interface " }, { 307, "record type T_REC has no field named G" }, { 309, "record type T_REC has no field named H" }, { 0, "did you mean F?" }, { 0, "type T_REC has field F" }, { 318, "type of aggregate cannot be determined from the surrounding " }, { 0, "context contains type BIT which is not a composite type" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(tree_generics(p) == 2); fail_unless(tree_genmaps(p) == 2); lib_put(lib_work(), p); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); fail_unless(package_needs_body(p2)); lib_put(lib_work(), p2); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(tree_primary(b) == p2); lib_put(lib_work(), b); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACK_INST); fail_unless(tree_generics(p3) == 2); fail_unless(tree_genmaps(p3) == 2); fail_unless(tree_decls(p3) == 2); fail_unless(tree_kind(tree_decl(p3, 1)) == T_FUNC_BODY); lib_put(lib_work(), p3); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t d = get_decl(a, "MY_TYPE_VECTOR"); type_t type = tree_type(d); fail_unless(type_kind(type) == T_SUBTYPE); fail_unless(type_has_resolution(type)); tree_t r = type_resolution(type); fail_unless(tree_kind(r) == T_ELEM_RESOLUTION); tree_t p4 = tree_stmt(a, 4); fail_unless(tree_chars(tree_value(tree_stmt(p4, 0))) == 8); fail_unless(tree_chars(tree_value(tree_stmt(p4, 1))) == 6); fail_unless(tree_chars(tree_value(tree_stmt(p4, 2))) == 4); fail_unless(tree_chars(tree_value(tree_stmt(p4, 3))) == 0); fail_unless(tree_chars(tree_value(tree_stmt(p4, 4))) == 0); fail_unless(tree_chars(tree_value(tree_stmt(p4, 5))) == 18); fail_unless(tree_chars(tree_value(tree_stmt(p4, 6))) == 0); fail_unless(tree_chars(tree_value(tree_stmt(p4, 7))) == 3); tree_t p6 = tree_stmt(a, 6); fail_unless(tree_kind(p6) == T_PROCESS); type_t p6t0 = tree_type(tree_decl(p6, 0)); fail_unless(type_is_unconstrained(p6t0)); type_t p6t1 = tree_type(get_decl(p6, "A")); fail_if(type_is_unconstrained(p6t1)); fail_unless(type_has_constraint(p6t1)); type_t p6t1e = type_elem(p6t1); fail_unless(type_kind(p6t1e) == T_SUBTYPE); fail_unless(type_has_constraint(p6t1e)); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vhdl2019) { set_standard(STD_19); input_from_file(TESTDIR "/parse/vhdl2019.vhd"); tree_t p006f = parse(); fail_if(p006f == NULL); fail_unless(tree_kind(p006f) == T_PACKAGE); lib_put(lib_work(), p006f); tree_t pb006f = parse(); fail_if(pb006f == NULL); fail_unless(tree_kind(pb006f) == T_PACK_BODY); tree_t p055a = parse(); fail_if(p055a == NULL); fail_unless(tree_kind(p055a) == T_PACKAGE); tree_t e071a = parse(); fail_if(e071a == NULL); fail_unless(tree_kind(e071a) == T_ENTITY); tree_t p072b = parse(); fail_if(p072b == NULL); fail_unless(tree_kind(p072b) == T_PACKAGE); lib_put(lib_work(), p072b); tree_t pb072b = parse(); fail_if(pb072b == NULL); fail_unless(tree_kind(pb072b) == T_PACK_BODY); tree_t p082 = parse(); fail_if(p082 == NULL); fail_unless(tree_kind(p082) == T_PACKAGE); tree_t e086 = parse(); fail_if(e086 == NULL); fail_unless(tree_kind(e086) == T_ENTITY); tree_t e059 = parse(); fail_if(e059 == NULL); fail_unless(tree_kind(e059) == T_ENTITY); tree_t e059g0 = tree_generic(e059, 0); fail_unless(tree_class(e059g0) == C_TYPE); fail_unless(type_subkind(tree_type(e059g0)) == GTYPE_PRIVATE); tree_t e059g3 = tree_generic(e059, 3); fail_unless(tree_class(e059g3) == C_TYPE); fail_unless(type_subkind(tree_type(e059g3)) == GTYPE_SCALAR); tree_t e059g6 = tree_generic(e059, 13); fail_unless(tree_class(e059g6) == C_TYPE); fail_unless(type_subkind(tree_type(e059g6)) == GTYPE_DISCRETE); tree_t e059g9 = tree_generic(e059, 23); fail_unless(tree_class(e059g9) == C_TYPE); fail_unless(type_subkind(tree_type(e059g9)) == GTYPE_INTEGER); tree_t e059g12 = tree_generic(e059, 43); fail_unless(tree_class(e059g12) == C_TYPE); fail_unless(type_subkind(tree_type(e059g12)) == GTYPE_PHYSICAL); tree_t e059g15 = tree_generic(e059, 60); fail_unless(tree_class(e059g15) == C_TYPE); fail_unless(type_subkind(tree_type(e059g15)) == GTYPE_FLOATING); tree_t e059g18 = tree_generic(e059, 77); fail_unless(tree_class(e059g18) == C_TYPE); fail_unless(type_subkind(tree_type(e059g18)) == GTYPE_ARRAY); tree_t e016 = parse(); fail_if(e016 == NULL); fail_unless(tree_kind(e016) == T_ENTITY); fail_unless(tree_generics(e016) == 1); tree_t e016g0 = tree_generic(e016, 0); fail_unless(tree_class(e016g0) == C_TYPE); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue416) { opt_set_int(OPT_RELAXED, 1); input_from_file(TESTDIR "/parse/issue416.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_explicit_93) { set_standard(STD_93); input_from_file(TESTDIR "/parse/explicit.vhd"); const error_t expect[] = { { 25, "ambiguous use of operator \"<=\"" }, { -1, NULL } }; expect_errors(expect); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_explicit_08) { set_standard(STD_08); input_from_file(TESTDIR "/parse/explicit.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_homograph) { input_from_file(TESTDIR "/parse/homograph.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_group) { input_from_file(TESTDIR "/parse/group.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_decls(a) == 3); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_alias2) { input_from_file(TESTDIR "/parse/alias2.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_badprimary) { input_from_file(TESTDIR "/parse/badprimary.vhd"); const error_t expect[] = { { 17, "design unit NOT_HERE not found in library WORK" }, { 26, "depends on WORK.NOT_HERE-BAD which was analysed with errors" }, { -1, NULL } }; expect_errors(expect); tree_t top = parse(); fail_if(top == NULL); fail_unless(tree_kind(top) == T_ENTITY); lib_put(lib_work(), top); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); tree_t bad = parse(); fail_if(bad == NULL); fail_unless(tree_kind(bad) == T_ARCH); fail_if(tree_has_primary(bad)); lib_put_error(lib_work(), bad); tree_t cfg = parse(); fail_if(cfg == NULL); fail_unless(tree_kind(cfg) == T_CONFIGURATION); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error3) { set_standard(STD_93); input_from_file(TESTDIR "/parse/error3.vhd"); const error_t expect[] = { { 15, "PROTECTED is a reserved word in VHDL-2000" }, { 15, "unexpected identifier while parsing type definition" }, { 26, "unexpected ; while parsing library unit, expecting one" }, { 28, "unexpected end while parsing library unit, expecting" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(parse() == NULL); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_protected2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/parse/protected2.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); tree_t pb = get_decl(b, "RANDOMPTYPE"); fail_if(pb == NULL); fail_unless(tree_kind(pb) == T_PROT_BODY); tree_t f = get_decl(pb, "LOCALUNIFORM"); fail_if(f == NULL); fail_unless(tree_kind(f) == T_FUNC_BODY); tree_t s0 = tree_stmt(f, 0); fail_unless(tree_kind(s0) == T_RETURN); tree_t call = tree_value(tree_param(tree_value(s0), 0)); fail_unless(tree_kind(call) == T_PROT_FCALL); fail_unless(tree_params(call) == 0); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_error4) { set_standard(STD_93); input_from_file(TESTDIR "/parse/error4.vhd"); const error_t expect[] = { { 2, "no visible declaration for IEEE" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_tc1012) { input_from_file(TESTDIR "/parse/tc1012.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t s0 = tree_stmt(a, 0); fail_unless(tree_kind(s0) == T_PROCESS); fail_unless(tree_triggers(s0) == 2); fail_unless(tree_kind(tree_trigger(s0, 0)) == T_REF); fail_unless(tree_ident(tree_trigger(s0, 0)) == ident_new("C06S03B00X00P10N01I01012ENT.P")); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue443) { input_from_file(TESTDIR "/parse/issue443.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t d = tree_decl(a, 1); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(tree_ident(d) == ident_new("PARAM")); tree_t f = tree_ref(tree_value(d)); fail_unless(tree_kind(f) == T_FUNC_DECL); fail_unless(tree_ports(f) == 3); fail_unless(tree_loc(f)->first_line == 28); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_vunit5) { input_from_file(TESTDIR "/parse/vunit5.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); tree_t d = tree_decl(a, 0); fail_unless(tree_kind(d) == T_SIGNAL_DECL); fail_unless(tree_ident(d) == ident_new("X")); tree_t r = tree_value(d); fail_unless(tree_kind(r) == T_REF); fail_unless(tree_kind(tree_ref(r)) == T_GENERIC_DECL); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_vunit6) { set_standard(STD_08); input_from_file(TESTDIR "/parse/vunit6.vhd"); lib_t foo_lib = lib_tmp("foo"); lib_set_work(foo_lib); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONTEXT); lib_put(lib_work(), c); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_external) { set_standard(STD_08); input_from_file(TESTDIR "/parse/external.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t p0 = tree_stmt(a, 0); const struct { const class_t class; const int nparts; struct { const path_elt_t kind; const char *name; const tree_kind_t treek; } parts[5]; } expect[] = { { C_SIGNAL, 3, { { PE_RELATIVE }, { PE_SIMPLE, "FOO" }, { PE_SIMPLE, "BAR" } } }, { C_CONSTANT, 4, { { PE_RELATIVE }, { PE_SIMPLE, "X" }, { PE_SIMPLE, "Y" }, { PE_SIMPLE, "Z" } } }, { C_VARIABLE, 3, { { PE_RELATIVE }, { PE_SIMPLE, "AYE" }, { PE_SIMPLE, "BEE" } } }, { C_CONSTANT, 4, { { PE_ABSOLUTE }, { PE_SIMPLE, "X" }, { PE_SIMPLE, "Y" }, { PE_SIMPLE, "Z" } } }, { C_CONSTANT, 4, { { PE_RELATIVE }, { PE_CARET }, { PE_CARET }, { PE_SIMPLE, "FOO" } } }, { C_CONSTANT, 3, { { PE_LIBRARY, "WORK" }, { PE_SIMPLE, "PACK" }, { PE_SIMPLE, "FOO" } } }, { C_SIGNAL, 4, { { PE_RELATIVE }, { PE_GENERATE, "G", T_LITERAL }, { PE_GENERATE, "X", T_LITERAL }, { PE_SIMPLE, "BAZ" } } }, }; for (int i = 0; i < ARRAY_LEN(expect); i++) { tree_t v = tree_value(tree_stmt(p0, i)); fail_unless(tree_kind(v) == T_EXTERNAL_NAME); ck_assert_int_eq(tree_class(v), expect[i].class); const int nparts = tree_parts(v); ck_assert_int_eq(nparts, expect[i].nparts); for (int j = 0; j < nparts; j++) { tree_t p = tree_part(v, j); ck_assert_int_eq(tree_subkind(p), expect[i].parts[j].kind); switch (expect[i].parts[j].kind) { case PE_SIMPLE: case PE_LIBRARY: ck_assert_str_eq(istr(tree_ident(p)), expect[i].parts[j].name); break; case PE_GENERATE: ck_assert_str_eq(istr(tree_ident(p)), expect[i].parts[j].name); ck_assert_int_eq(tree_kind(tree_value(p)), expect[i].parts[j].treek); break; default: break; } } } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_error5) { input_from_file(TESTDIR "/parse/error5.vhd"); const error_t expect[] = { { 2, "design unit NOTHERE not found in library WORK" }, // It would be better to avoid the following errors { 8, "no visible declaration for MYTYPE" }, { 8, "no visible declaration for MYFUNC" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vunit7) { input_from_file(TESTDIR "/parse/vunit7.vhd"); const error_t expect[] = { { 23, "ambiguous use of enumeration literal ERROR" }, { 23, "ambiguous use of enumeration literal FAILURE" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_error6) { set_standard(STD_08); input_from_file(TESTDIR "/parse/error6.vhd"); const error_t expect[] = { { 15, "unexpected end of file while parsing package declaration" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_names2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_02); input_from_file(TESTDIR "/parse/names2.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue457) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue457.vhd"); lib_t test_context_lib = lib_tmp("test_context"); lib_set_work(test_context_lib); const error_t expect[] = { { 7, "TEST_CONTEXT.TEST_CONTEXT is not a library or instantiated " "package" }, { -1, NULL } }; expect_errors(expect); tree_t c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONTEXT); lib_put(test_context_lib, c); lib_t other_lib = lib_tmp("other"); lib_set_work(other_lib); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue458) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue458.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); ident_t one = ident_new("'1'"); ident_t zero = ident_new("'0'"); ident_t expect[5][5] = { { zero, zero, zero, zero, zero }, { zero, zero, zero, zero, one }, { zero, zero, zero, one, zero }, { zero, zero, zero, one, one }, { one, zero, one, zero, zero } }; for (int i = 0; i < 5; i++) { tree_t d0 = tree_value(tree_decl(p, i)); fail_unless(tree_kind(d0) == T_STRING); fail_unless(tree_chars(d0) == 5); for (int j = 0; j < 5; j++) fail_unless(tree_ident(tree_char(d0, j)) == expect[i][j]); } fail_if_errors(); } END_TEST START_TEST(test_issue461a) { input_from_file(TESTDIR "/parse/issue461.vhd"); const error_t expect[] = { { 13, "multiple conflicting visible declarations of T_TEST" }, { -1, NULL } }; expect_errors(expect); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue461b) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue461.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_error7) { input_from_file(TESTDIR "/parse/error7.vhd"); const error_t expect[] = { { 4, "FOO already declared in this region" }, { 7, "depends on WORK.ERROR7 which was analysed with errors" }, { 11, "depends on WORK.ERROR7 which was analysed with errors" }, { 17, "unexpected ; while parsing use clause, expecting ." }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(error_count() > 0); lib_put_error(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error8) { set_standard(STD_02); input_from_file(TESTDIR "/parse/error8.vhd"); const error_t expect[] = { { 33, "expanded name cannot reference NEXT_ID in type PT outside of " "the construct itself" }, { 33, "record type REC has no field named ID" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vunit8) { input_from_file(TESTDIR "/parse/vunit8.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue464) { input_from_file(TESTDIR "/parse/issue464.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_osvvm6) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/parse/osvvm6.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue468) { input_from_file(TESTDIR "/parse/issue468.vhd"); const error_t expect[] = { { 2, "design unit TEST3 not found in library WORK" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_names3) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/parse/names3.vhd"); const error_t expect[] = { { 21, "no visible subprogram declaration for BAR" }, { 52, "no applicable subprogram declaration for \"=\"" }, { 0, "expecting T_LOGIC" }, { 0, "context contains overload \"and\" [T_LOGIC, T_LOGIC return T" }, { 0, "there are 15 visible overloads of \"=\" but" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_uvvm1) { set_standard(STD_08); input_from_file(TESTDIR "/parse/uvvm1.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_range1) { input_from_file(TESTDIR "/parse/range1.vhd"); const error_t expect[] = { { 17, "object prefix of attribute RANGE must be an array" }, { 19, "name X in discrete range does not refer to a type" }, { 21, "expecting a discrete range" }, { 25, "expected type mark while parsing discrete range" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error9) { input_from_file(TESTDIR "/parse/error9.vhd"); const error_t expect[] = { { 13, "object with type STRING cannot be selected" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_uvvm2) { set_standard(STD_08); input_from_file(TESTDIR "/parse/uvvm2.vhd"); const error_t expect[] = { { 24, "initial value T does not match type of declaration INTEGER" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 4; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_visibility1) { input_from_file(TESTDIR "/parse/visibility1.vhd"); const error_t expect[] = { { 17, "multiple conflicting visible declarations of K" }, { 20, "multiple conflicting visible declarations of T" }, { 21, "ambiguous use of enumeration literal BAR" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 3; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_visibility2) { input_from_file(TESTDIR "/parse/visibility2.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 2; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_visibility3) { set_standard(STD_08); input_from_file(TESTDIR "/parse/visibility3.vhd"); for (int i = 0; i < 2; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility4) { lib_t foo_lib = lib_tmp("FOO"); lib_set_work(foo_lib); input_from_file(TESTDIR "/parse/visibility4.vhd"); const error_t expect[] = { { 18, "unexpected * while parsing use clause, expecting one of id" }, { -1, NULL } }; expect_errors(expect); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); lib_t bar_lib = lib_tmp("BAR"); lib_set_work(bar_lib); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); lib_t baz_lib = lib_tmp("BAZ"); lib_set_work(baz_lib); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACKAGE); lib_put(lib_work(), p3); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_visibility5) { input_from_file(TESTDIR "/parse/visibility5.vhd"); for (int i = 0; i < 2; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility6) { set_standard(STD_08); input_from_file(TESTDIR "/parse/visibility6.vhd"); for (int i = 0; i < 2; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue479) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue479.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); for (int i = 0; i < 2; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_typo) { set_standard(STD_02); input_from_file(TESTDIR "/parse/typo.vhd"); const error_t expect[] = { { 6, "no visible declaration for BOLEAN" }, { 0, "did you mean BOOLEAN?" }, { 23, "no visible declaration for RSET" }, { 0, "did you mean RESET?" }, { 31, "no visible declaration for NOEW" }, { 0, "did you mean NOW?" }, { 32, "no visible declaration for MY_FUNC" }, { 0, "did you mean MYFUNC?" }, { 38, "record type REC has no field named FRODO" }, { 0, "did you mean FOO?" }, { 44, "protected type PT has no method named ONN" }, { 0, "did you mean ONE?" }, { 53, "no possible overload of MYFUNC has formal X" }, { 0, "formal argument name X" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue532) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue532.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue539) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue539.vhd"); const error_t expect[] = { { 10, "declaration of variable FOO cannot have unconstrained type SLV" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue568) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue568.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue569) { input_from_file(TESTDIR "/parse/issue569.vhd"); lib_t foo = lib_tmp("foo"); lib_t bar = lib_tmp("bar"); lib_set_work(foo); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(foo, p); lib_set_work(bar); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(bar, e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_osvvm7) { set_standard(STD_08); input_from_file(TESTDIR "/parse/osvvm7.vhd"); lib_t work = lib_work(); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(work, p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(work, b); tree_t i1 = parse(); fail_if(i1 == NULL); fail_unless(tree_kind(i1) == T_PACK_INST); lib_put(work, i1); tree_t i2 = parse(); fail_if(i2 == NULL); fail_unless(tree_kind(i2) == T_PACK_INST); lib_put(work, i2); tree_t d1 = get_decl(i1, "SCOREBOARDIDTYPE"); fail_if(d1 == NULL); fail_unless(tree_kind(d1) == T_TYPE_DECL); tree_t d2 = get_decl(i2, "SCOREBOARDIDTYPE"); fail_unless(tree_kind(d2) == T_TYPE_DECL); fail_if(type_eq(tree_type(d1), tree_type(d2))); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(work, e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue580) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue580.vhd"); const error_t expect[] = { { 14, "declaration of signal S2 cannot have unconstrained type SUB_T" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_visibility7) { lib_t foo = lib_tmp("foo"); lib_set_work(foo); input_from_file(TESTDIR "/parse/visibility7.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(foo, p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(foo, e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue541) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue541.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue604) { set_standard(STD_19); const error_t expect[] = { { 11, "\"Tool is NVC\"" }, { 18, "unexpected `elsif outside conditional analysis block" }, { 19, "unexpected `end outside conditional analysis block" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/parse/issue604.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vunit9) { input_from_file(TESTDIR "/parse/vunit9.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_alias3) { input_from_file(TESTDIR "/parse/alias3.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_subtype2008) { set_standard(STD_08); input_from_file(TESTDIR "/parse/subtype2008.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); type_t sub1 = tree_type(get_decl(p, "SUB1")); fail_if(type_has_constraint(sub1)); fail_unless(type_is_unconstrained(sub1)); type_t sub2 = tree_type(get_decl(p, "SUB2")); fail_unless(type_is_unconstrained(sub2)); type_t sub3 = tree_type(get_decl(p, "SUB3")); fail_if(type_has_constraint(sub3)); fail_unless(type_is_unconstrained(sub3)); type_t sub4 = tree_type(get_decl(p, "SUB4")); fail_if(type_has_constraint(sub4)); fail_unless(type_is_unconstrained(sub4)); type_t sub5 = tree_type(get_decl(p, "SUB5")); fail_unless(type_has_constraint(sub5)); fail_unless(tree_subkind(type_constraint(sub5)) == C_INDEX); fail_unless(type_is_unconstrained(sub5)); ck_assert_ptr_eq(type_elem(sub5), type_elem(sub4)); type_t sub6 = tree_type(get_decl(p, "SUB6")); fail_if(type_is_unconstrained(sub6)); type_t sub7 = tree_type(get_decl(p, "SUB7")); fail_if(type_has_constraint(sub7)); fail_if(type_is_unconstrained(sub7)); type_t sub10 = tree_type(get_decl(p, "SUB10")); fail_unless(type_has_constraint(sub10)); fail_unless(type_is_unconstrained(sub10)); type_t sub11 = tree_type(get_decl(p, "SUB11")); fail_unless(type_has_constraint(sub11)); fail_unless(tree_subkind(type_constraint(sub11)) == C_INDEX); fail_unless(type_is_unconstrained(sub11)); type_t sub13 = tree_type(get_decl(p, "SUB13")); fail_if(type_is_unconstrained(sub13)); type_t sub15 = tree_type(get_decl(p, "SUB15")); fail_if(type_is_unconstrained(sub15)); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue644) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue644.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e1 = parse(); fail_if(e1 == NULL); fail_unless(tree_kind(e1) == T_ENTITY); lib_put(lib_work(), e1); tree_t a1 = parse(); fail_if(a1 == NULL); fail_unless(tree_kind(a1) == T_ARCH); tree_t e2 = parse(); fail_if(e2 == NULL); fail_unless(tree_kind(e2) == T_ENTITY); lib_put(lib_work(), e2); tree_t a2 = parse(); fail_if(a2 == NULL); fail_unless(tree_kind(a2) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue653) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue653.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACK_INST); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue654) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); const error_t expect[] = { { 22, "no visible uninstantiated subprogram GENERATE_CLOCK matches " "signature [return INTEGER]" }, { 23, "no visible uninstantiated subprogram declaration for \"+\"" }, { 30, "multiple visible uninstantiated subprograms with name GENE" }, { 40, "invalid use of type BIT" }, { 37, "subprogram WORK.FREQUENCY.GENERATE_CLOCK [BIT, FREQUENCY, " "NATURAL] cannot be instantiated until its body has been analysed" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/parse/issue654.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(tree_decls(b) == 2); tree_t d0 = tree_decl(b, 0); fail_unless(tree_kind(d0) == T_PROC_BODY); tree_t d1 = tree_decl(b, 1); fail_unless(tree_kind(d1) == T_PROC_INST); fail_unless(tree_ref(d1) == d0); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue687) { const error_t expect[] = { { 11, "record type MY_RECORD has no field named INTEGER" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/parse/issue687.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue688) { input_from_file(TESTDIR "/parse/issue688.vhd"); lib_t test = lib_tmp("test"); lib_set_work(test); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); lib_t work = lib_tmp("work"); lib_set_work(work); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue686) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue686.vhd"); const error_t expect[] = { { 15, "no visible subprogram \"=\" matches signature [G, G return BOO" }, { 0, "while resolving interface subprogram default for \"=\"" }, { 0, "add a use clause that makes the operators for WORK.PACK1.T" }, { 0, "the 2008 LRM is unclear" }, { -1, NULL } }; expect_errors(expect); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACK_INST); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_interface) { set_standard(STD_19); input_from_file(TESTDIR "/parse/interface.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue701) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue701.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue708) { set_standard(STD_19); input_from_file(TESTDIR "/parse/issue708.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue727) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue727.vhd"); lib_t work = lib_work(); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(work, p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(work, p2); tree_t b1 = parse(); fail_if(b1 == NULL); fail_unless(tree_kind(b1) == T_PACK_BODY); lib_put(work, b1); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACKAGE); lib_put(work, p3); tree_t p4 = parse(); fail_if(p4 == NULL); fail_unless(tree_kind(p4) == T_PACKAGE); lib_put(work, p4); tree_t b2 = parse(); fail_if(b2 == NULL); fail_unless(tree_kind(b2) == T_PACK_BODY); lib_put(work, b2); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility8) { input_from_file(TESTDIR "/parse/visibility8.vhd"); const error_t expect[] = { { 16, "declaration of S1 is hidden" }, { 21, "declaration of C1 is hidden" }, { 22, "declaration of T1 is hidden" }, { 23, "declaration of T2 is hidden" }, { 24, "declaration of V1 is hidden" }, { 25, "declaration of A1 is hidden" }, { 26, "declaration of F1 is hidden" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue751) { input_from_file(TESTDIR "/parse/issue751.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t p0 = tree_stmt(a, 0); fail_unless(tree_ident(p0) == ident_new("_P0")); fail_unless(tree_flags(p0) & TREE_F_SYNTHETIC_NAME); tree_t outer = tree_decl(p0, 0); fail_unless(tree_kind(outer) == T_FUNC_BODY); fail_unless(tree_ident2(outer) == ident_new( "WORK.ISSUE751-TEST._P0.OUTER()I")); tree_t inner = tree_decl(outer, 0); fail_unless(tree_kind(inner) == T_FUNC_BODY); fail_unless(tree_ident2(inner) == ident_new( "WORK.ISSUE751-TEST._P0.OUTER()I.INNER()I")); tree_t abc = tree_decl(p0, 1); fail_unless(tree_kind(abc) == T_TYPE_DECL); fail_unless(type_ident(tree_type(abc)) == ident_new( "WORK.ISSUE751-TEST._P0.ABC")); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility9) { set_standard(STD_08); input_from_file(TESTDIR "/parse/visibility9.vhd"); const error_t expect[] = { { 21, "no matching operator \"=\" [T_XYZ, T_XYZ return BOOLEAN]" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); simplify_local(p, NULL, NULL, NULL); // XXX: remove me lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t c2 = tree_decl(a, 1); fail_unless(tree_kind(c2) == T_CONST_DECL); tree_t eq = tree_ref(tree_value(c2)); fail_if(tree_flags(eq) & TREE_F_PREDEFINED); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue753) { input_from_file(TESTDIR "/parse/issue753.vhd"); const error_t expect[] = { { 3, "no matching coverage on directive seen before end of design " }, { 17, "no matching synthesis translate_on directive seen before end" }, { 14, "no matching pragma translate_on directive seen before end" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue760) { set_standard(STD_19); input_from_file(TESTDIR "/parse/issue760.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue761) { input_from_file(TESTDIR "/parse/issue761.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue776) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue776.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility10) { input_from_file(TESTDIR "/parse/visibility10.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACKAGE); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_error10) { input_from_file(TESTDIR "/parse/error10.vhd"); const error_t expect[] = { { 6, "unexpected in while parsing paremeter specification" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue783) { input_from_file(TESTDIR "/parse/issue783.vhd"); lib_t foo = lib_tmp("foo"); lib_set_work(foo); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); lib_put(lib_work(), a); tree_t c = parse(); fail_if(c == NULL); fail_unless(tree_kind(c) == T_CONFIGURATION); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue792) { set_standard(STD_02); input_from_file(TESTDIR "/parse/issue792.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t p3 = parse(); fail_if(p3 == NULL); fail_unless(tree_kind(p3) == T_PACKAGE); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue789) { input_from_file(TESTDIR "/parse/issue789.vhd"); const error_t expect[] = { { 15, "invalid use of architecture RTL" }, { 0, "declaration of literal RTL is hidden" }, { 0, "name RTL refers to this architecture" }, { 31, "design unit WORK.TEST1 is not a component declaration" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e1 = parse(); fail_if(e1 == NULL); fail_unless(tree_kind(e1) == T_ENTITY); lib_put(lib_work(), e1); tree_t a1 = parse(); fail_if(a1 == NULL); fail_unless(tree_kind(a1) == T_ARCH); tree_t e2 = parse(); fail_if(e2 == NULL); fail_unless(tree_kind(e2) == T_ENTITY); lib_put(lib_work(), e2); tree_t a2 = parse(); fail_if(a2 == NULL); fail_unless(tree_kind(a2) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue793) { input_from_file(TESTDIR "/parse/issue793.vhd"); const error_t expect[] = { { 41, "no possible overload of CHECK_SETUP has formal POL1" }, { 0, "did you mean POL?" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_slow1) { input_from_file(TESTDIR "/parse/slow1.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue802) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue802.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue805) { input_from_file(TESTDIR "/parse/issue805.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility11) { set_standard(STD_08); input_from_file(TESTDIR "/parse/visibility11.vhd"); const error_t expect[] = { { 16, "cannot reference G in uninstantiated package WORK.PACK outside " "of the package itself" }, { 24, "expanded name cannot reference S in label B outside of the " "construct itself" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue837) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue837.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t s = tree_decl(a, 0); fail_unless(tree_kind(s) == T_SIGNAL_DECL); type_t t = tree_type(s); fail_unless(type_kind(t) == T_SUBTYPE); tree_t r = range_of(t, 0); fail_unless(tree_subkind(r) == RANGE_EXPR); fail_unless(tree_kind(tree_value(r)) == T_ATTR_REF); fail_if_errors(); } END_TEST START_TEST(test_issue845) { input_from_file(TESTDIR "/parse/issue845.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue848) { input_from_file(TESTDIR "/parse/issue848.vhd"); const error_t expect[] = { { 37, "pure function TEST cannot call procedure PROC which references " "a shared variable" }, { 44, "pure function TEST2 cannot call procedure PROC2 which references " "a shared variable" }, { 51, "pure function TEST3 cannot call procedure PROC3 which references " "a shared variable" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue870) { opt_set_int(OPT_RELAXED, 1); input_from_file(TESTDIR "/parse/issue870.vhd"); const error_t expect[] = { { 13, "declaration of SEED1 hides an earlier declaration with the " }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_aggregate) { set_standard(STD_08); input_from_file(TESTDIR "/parse/aggregate.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); static const struct { const char *name; int64_t left; range_kind_t dir; int64_t right; } cases[] = { { "C1", 1, RANGE_TO, 2 }, { "C2", 1, RANGE_TO, 2 }, { "C3", 0, RANGE_TO, 1 }, { "C4", 100, RANGE_DOWNTO, 98 }, { "C5", 2, RANGE_DOWNTO, 1 }, { "C6", 0, RANGE_TO, 3 }, { "C7", 0, RANGE_TO, 2 }, }; for (int i = 0; i < ARRAY_LEN(cases); i++) { tree_t d = get_decl(p, cases[i].name); type_t type = tree_type(tree_value(d)); fail_unless(type_is_array(type)); tree_t r = range_of(type, 0); const range_kind_t kind = tree_subkind(r); const int64_t left = assume_int(tree_left(r)); const int64_t right = assume_int(tree_right(r)); if (kind != cases[i].dir || left != cases[i].left || right != cases[i].right) { fmt_loc(stdout, tree_loc(d)); ck_abort_msg("range mismatch: %d %"PRIi64" %"PRIi64, kind, left, right); } } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue875) { input_from_file(TESTDIR "/parse/issue875.vhd"); const error_t expect[] = { { 6, "homograph of HAS_RD [INSTRUCTION32_T return BOOLEAN] already " "declared in this region" }, { 0, "duplicate declaration" }, { 0, "only the base type is considered when determining" }, { 0, "previous declaration was here" }, { 9, "design unit depends on WORK.REPRO which was analysed " "with errors" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put_error(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error11) { set_standard(STD_08); input_from_file(TESTDIR "/parse/error11.vhd"); const error_t expect[] = { { 26, "no visible subprogram STD_MATCH matches signature [T_ELEMENT, " "T_ELEMENT return BOOLEAN]" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error12) { set_standard(STD_08); input_from_file(TESTDIR "/parse/error12.vhd"); const error_t expect[] = { { 34, "SB_QUEUE_PKG has no generic named SCOPE" }, { -1, NULL } }; expect_errors(expect); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); lib_put(lib_work(), b); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue892) { input_from_file(TESTDIR "/parse/issue892.vhd"); const error_t expect[] = { { 25, "prefix of attribute name with signature does not denote a " "subprogram or enumeration literal" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue889) { input_from_file(TESTDIR "/parse/issue889.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_vests2) { input_from_file(TESTDIR "/parse/vests2.vhd"); const error_t expect[] = { { 39, "design unit FAIL-C12S03B02X02P05N01I03064ARCH_A not found in " }, { 41, "no visible declaration for TEST" }, { 41, "cannot determine type of OPEN expression" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vests3) { input_from_file(TESTDIR "/parse/vests3.vhd"); const error_t expect[] = { { 38, "unterminated string literal" }, { 0, "a string literal must fit on one line" }, { 39, "unexpected begin while parsing variable declaration" }, { 38, "invalid character '%' in string literal of type BIT_VECTOR" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vests4) { input_from_file(TESTDIR "/parse/vests4.vhd"); const error_t expect[] = { { 44, "invalid use of label SIG" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vests5) { input_from_file(TESTDIR "/parse/vests5.vhd"); const error_t expect[] = { { 47, "ambiguous use of name MC" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 2; i++) { tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); } tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_basic_identifier) { input_from_file(TESTDIR "/parse/basic_identifier.vhd"); const error_t expect[] = { { 1, "basic identifier must not start or end with an underscore" }, { 2, "basic identifier must not start or end with an underscore" }, { 3, "basic identifier must not start or end with an underscore" }, { 8, "basic identifier must not start or end with an underscore" }, { 12, "basic identifier must not start or end with an underscore" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 5; i++) { tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); } for (int i = 0; i < 3; i++) { tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); } fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue893) { input_from_file(TESTDIR "/parse/issue893.vhd"); for (int i = 0; i < 2; i++) { tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); } tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_alias4) { input_from_file(TESTDIR "/parse/alias4.vhd"); for (int i = 0; i < 3; i++) { tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_defer1) { set_standard(STD_02); opt_set_int(OPT_MISSING_BODY, 1); input_from_file(TESTDIR "/parse/defer1.vhd"); const error_t expect[] = { { 3, "subprogram FUNC1 [return INTEGER] called before its body has " "been elaborated" }, { 5, "cannot reference deferred constant C2 before the elaboration " "of the corresponding full declaration" }, { 18, "cannot declare instance of protected type PT1 before its body " "has been elaborated" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_error13) { input_from_file(TESTDIR "/parse/error13.vhd"); const error_t expect[] = { { 20, "ambiguous use of name SUB" }, { 0, "use of name SUB here" }, { 0, "visible declaration of SUB as CHARACTER from STD.STANDARD" }, { 0, "potentially visible declaration of SUB from WORK.COMPONENTS" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue917) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue917.vhd"); const error_t expect[] = { { 31, "cannot associate impure function IMPURE_FUNC [INTEGER return " "INTEGER] with pure generic subprogram F1" }, { 38, "no visible subprogram ADD matches signature [INTEGER return " }, { 42, "no visible subprogram F1 matches signature [INTEGER, INTEGER " "return INTEGER]" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue905) { input_from_file(TESTDIR "/parse/issue905.vhd"); const error_t expect[] = { { 36, "declaration of I hides an earlier declaration with the " "same type" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_vunit10) { set_standard(STD_93); input_from_file(TESTDIR "/parse/vunit10.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue942) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue942.vhd"); const error_t expect[] = { { 8, "interface list cannot be empty" }, { 13, "wait statement not allowed in process with sensitvity list" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_i03) { set_standard(STD_19); input_from_file(TESTDIR "/parse/lcs2016_i03.vhd"); const error_t expect[] = { { 27, "a signature is only allowed in a generic formal designator" }, { 33, "no visible subprogram or enumeration literal F1 matches " "signature [return BOOLEAN]" }, { 39, "no visible subprogram or enumeration literal G matches " "signature [return INTEGER]" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue952) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue952.vhd"); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(tree_kind(tree_stmt(a, 0)) == T_CONCURRENT); fail_unless(tree_kind(tree_stmt(a, 1)) == T_PSL_DIRECT); fail_unless(tree_kind(tree_stmt(a, 2)) == T_PSL_DIRECT); fail_unless(tree_kind(tree_stmt(a, 3)) == T_PSL_DIRECT); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_visibility12) { input_from_file(TESTDIR "/parse/visibility12.vhd"); const error_t expect[] = { { 29, "name CNTR not found in package MYLIB" }, { 0, "library MYLIB is hidden" }, { -1, NULL } }; expect_errors(expect); lib_t mylib = lib_tmp("mylib"); lib_set_work(mylib); parse_and_check(T_PACKAGE, T_ENTITY, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue956) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue956.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); const int nstmts = tree_stmts(a); for (int i = 0; i < nstmts; i++) { tree_t c = tree_stmt(a, i); fail_unless(tree_kind(c) == T_CONCURRENT); tree_t s = tree_stmt(c, 0); fail_unless(tree_kind(tree_value(s)) == T_FCALL); } fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue961) { input_from_file(TESTDIR "/parse/issue961.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue977) { input_from_file(TESTDIR "/parse/issue977.vhd"); const error_t expect[] = { { 10, "duplicate specification for attribute FOREIGN of procedure FOO" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue991) { lib_t lib = lib_tmp("issue991"); lib_set_work(lib); input_from_file(TESTDIR "/parse/issue991.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1038) { opt_set_int(OPT_RELAXED, 1); set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1038.vhd"); const error_t expect[] = { { 26, "unexpected next while parsing primary, expecting one of ??, (, " "integer, real, null, identifier, string, bit string or new" }, { 41, "no visible subprogram declaration for NATURAL" }, { 49, "not a valid resolution function for type POSITIVE" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_ENTITY, T_ARCH, T_PACKAGE, T_PACK_BODY, T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1055) { input_from_file(TESTDIR "/parse/issue1055.vhd"); parse_and_check(T_PACKAGE, T_PACKAGE); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_hang) { set_standard(STD_08); input_from_file(TESTDIR "/parse/hang.vhd"); const error_t expect[] = { { 17, "sorry, bit strings longer than 2147483647 elements " "are not supported" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_protected3) { opt_set_int(OPT_RELAXED, 1); set_standard(STD_08); input_from_file(TESTDIR "/parse/protected3.vhd"); const error_t expect[] = { { 4, "type mark does not denote a type or a subtype" }, { 11, "no visible declaration for SHAREDCOUNTER" }, { 14, "unexpected package while parsing protected type body, " "expecting protected" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_pkgindecl) { set_standard(STD_08); input_from_file(TESTDIR "/parse/pkgindecl.vhd"); const error_t expect[] = { { 5, "unexpected end while parsing interface package declaration, " "expecting new" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1090) { input_from_file(TESTDIR "/parse/issue1090.vhd"); const error_t expect[] = { { 6, "design unit WORK.P1 replaces a previously analysed unit with " "the same name" }, { 12, "design unit WORK.P1 replaces a previously analysed unit with " "the same name" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_ENTITY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1091) { input_from_file(TESTDIR "/parse/issue1091.vhd"); const error_t expect[] = { { 10, "illegal formal designator" }, { 23, "invalid formal name WORK.SETUPHIGH" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_PACKAGE, T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1091b) { input_from_file(TESTDIR "/parse/issue1091b.vhd"); const error_t expect[] = { { 17, "subprogram MEMORYTABLECORRUPTMASK [INTEGER] " "has no parameter named ENABLEINDEX" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1096) { input_from_file(TESTDIR "/parse/issue1096.vhd"); const error_t expect[] = { { 24, "sorry, binding indication with generic map aspect and OPEN " "entity aspect is not yet supported" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ENTITY, T_ARCH, T_CONFIGURATION); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_alias5) { input_from_file(TESTDIR "/parse/alias5.vhd"); const error_t expect[] = { { 2, "no visible declaration for TYPE_T" }, { 9, "no visible declaration for X" }, { 10, "no visible subprogram PROC matches signature [INTEGER]" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_gensub) { set_standard(STD_08); input_from_file(TESTDIR "/parse/gensub.vhd"); const error_t expect[] = { { 2, "expecting uninstantiated subprogram name" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACK_BODY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_aggregate2) { set_standard(STD_19); input_from_file(TESTDIR "/parse/aggregate2.vhd"); const error_t expect[] = { { 4, "no visible declaration for DATA" }, { 4, "association choice must be a field name" }, { 11, "no visible declaration for WORD" }, { 11, "unexpected => while parsing signature" }, { 11, "association choice must be a field name" }, { 18, "no visible declaration for T_DIRECTION" }, { 19, "index range of array aggregate with others choice cannot be " "determined from the context" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1124) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1124.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1129) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1129.vhd"); parse_and_check(T_ENTITY, T_ARCH, T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1138) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1138.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1152) { input_from_file(TESTDIR "/parse/issue1152.vhd"); const error_t expect[] = { { 15, "design unit WORK.P1 replaces a previously analysed" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1174) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1174.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_vests6) { input_from_file(TESTDIR "/parse/vests6.vhd"); parse_and_check(T_ENTITY, T_ARCH, T_CONFIGURATION); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1188) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1188.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_issue1202) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1202.vhd"); const error_t expect[] = { { 7, "unexpected identifier while parsing interface package " "declaration, expecting new" }, // TODO: error recovery could be better here { 14, "unexpected architecture while parsing entity declaration" }, { 14, "unexpected ; while parsing library unit" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_issue1249) { set_standard(STD_08); input_from_file(TESTDIR "/parse/issue1249.vhd"); const error_t expect[] = { { 21, "actual for formal Y with class VARIABLE must be a name denoting " "a variable" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST Suite *get_parse_tests(void) { Suite *s = suite_create("parse"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_entity); tcase_add_test(tc_core, test_arch); tcase_add_test(tc_core, test_process); tcase_add_test(tc_core, test_seq); tcase_add_test(tc_core, test_types); tcase_add_test(tc_core, test_literal); tcase_add_test(tc_core, test_extended); tcase_add_test(tc_core, test_package); tcase_add_test(tc_core, test_enum); tcase_add_test(tc_core, test_qual); tcase_add_test(tc_core, test_func); tcase_add_test(tc_core, test_array); tcase_add_test(tc_core, test_instance); tcase_add_test(tc_core, test_conc); tcase_add_test(tc_core, test_alias); tcase_add_test(tc_core, test_attr); tcase_add_test(tc_core, test_procedure); tcase_add_test(tc_core, test_ir1045); tcase_add_test(tc_core, test_concat); tcase_add_test(tc_core, test_based); tcase_add_test(tc_core, test_bitstring); tcase_add_test(tc_core, test_block); tcase_add_test(tc_core, test_comp); tcase_add_test(tc_core, test_generate); tcase_add_test(tc_core, test_access); tcase_add_test(tc_core, test_spec); tcase_add_test(tc_core, test_loc); tcase_add_test(tc_core, test_expr); tcase_add_test(tc_core, test_error); tcase_add_test(tc_core, test_config); tcase_add_test(tc_core, test_protected); tcase_add_test(tc_core, test_empty); tcase_add_test(tc_core, test_issue205); tcase_add_test(tc_core, test_context); tcase_add_test(tc_core, test_issue222); tcase_add_test(tc_core, test_guarded); tcase_add_test(tc_core, test_cond1); tcase_add_test(tc_core, test_issue360); tcase_add_test(tc_core, test_issue367); tcase_add_test(tc_core, test_issue369); tcase_add_test(tc_core, test_vests1); tcase_add_test(tc_core, test_synth); tcase_add_test(tc_core, test_issue388); tcase_add_test(tc_core, test_names); tcase_add_test(tc_core, test_implicit); tcase_add_test(tc_core, test_error2); tcase_add_test(tc_core, test_vhdl2008); tcase_add_test(tc_core, test_vhdl2019); tcase_add_test(tc_core, test_issue416); tcase_add_test(tc_core, test_explicit_93); tcase_add_test(tc_core, test_explicit_08); tcase_add_test(tc_core, test_homograph); tcase_add_test(tc_core, test_group); tcase_add_test(tc_core, test_alias2); tcase_add_test(tc_core, test_badprimary); tcase_add_test(tc_core, test_error3); tcase_add_test(tc_core, test_protected2); tcase_add_test(tc_core, test_error4); tcase_add_test(tc_core, test_tc1012); tcase_add_test(tc_core, test_issue443); tcase_add_test(tc_core, test_vunit5); tcase_add_test(tc_core, test_vunit6); tcase_add_test(tc_core, test_external); tcase_add_test(tc_core, test_error5); tcase_add_test(tc_core, test_vunit7); tcase_add_test(tc_core, test_error6); tcase_add_test(tc_core, test_names2); tcase_add_test(tc_core, test_issue457); tcase_add_test(tc_core, test_issue458); tcase_add_test(tc_core, test_issue461a); tcase_add_test(tc_core, test_issue461b); tcase_add_test(tc_core, test_error7); tcase_add_test(tc_core, test_error8); tcase_add_test(tc_core, test_vunit8); tcase_add_test(tc_core, test_issue464); tcase_add_test(tc_core, test_osvvm6); tcase_add_test(tc_core, test_issue468); tcase_add_test(tc_core, test_names3); tcase_add_test(tc_core, test_range1); tcase_add_test(tc_core, test_error9); tcase_add_test(tc_core, test_uvvm1); tcase_add_test(tc_core, test_uvvm2); tcase_add_test(tc_core, test_visibility1); tcase_add_test(tc_core, test_visibility2); tcase_add_test(tc_core, test_visibility3); tcase_add_test(tc_core, test_visibility4); tcase_add_test(tc_core, test_visibility5); tcase_add_test(tc_core, test_visibility6); tcase_add_test(tc_core, test_issue479); tcase_add_test(tc_core, test_typo); tcase_add_test(tc_core, test_issue532); tcase_add_test(tc_core, test_issue539); tcase_add_test(tc_core, test_issue568); tcase_add_test(tc_core, test_issue569); tcase_add_test(tc_core, test_osvvm7); tcase_add_test(tc_core, test_issue580); tcase_add_test(tc_core, test_visibility7); tcase_add_test(tc_core, test_issue541); tcase_add_test(tc_core, test_issue604); tcase_add_test(tc_core, test_vunit9); tcase_add_test(tc_core, test_alias3); tcase_add_test(tc_core, test_subtype2008); tcase_add_test(tc_core, test_issue644); tcase_add_test(tc_core, test_issue653); tcase_add_test(tc_core, test_issue654); tcase_add_test(tc_core, test_issue687); tcase_add_test(tc_core, test_issue688); tcase_add_test(tc_core, test_issue686); tcase_add_test(tc_core, test_interface); tcase_add_test(tc_core, test_issue701); tcase_add_test(tc_core, test_issue708); tcase_add_test(tc_core, test_issue727); tcase_add_test(tc_core, test_visibility8); tcase_add_test(tc_core, test_issue751); tcase_add_test(tc_core, test_visibility9); tcase_add_test(tc_core, test_issue753); tcase_add_test(tc_core, test_issue760); tcase_add_test(tc_core, test_issue761); tcase_add_test(tc_core, test_issue776); tcase_add_test(tc_core, test_visibility10); tcase_add_test(tc_core, test_error10); tcase_add_test(tc_core, test_issue783); tcase_add_test(tc_core, test_issue792); tcase_add_test(tc_core, test_issue789); tcase_add_test(tc_core, test_issue793); tcase_add_test(tc_core, test_slow1); tcase_add_test(tc_core, test_issue802); tcase_add_test(tc_core, test_issue805); tcase_add_test(tc_core, test_visibility11); tcase_add_test(tc_core, test_issue837); tcase_add_test(tc_core, test_issue845); tcase_add_test(tc_core, test_issue848); tcase_add_test(tc_core, test_issue870); tcase_add_test(tc_core, test_aggregate); tcase_add_test(tc_core, test_issue875); tcase_add_test(tc_core, test_error11); tcase_add_test(tc_core, test_error12); tcase_add_test(tc_core, test_issue892); tcase_add_test(tc_core, test_issue889); tcase_add_test(tc_core, test_vests2); tcase_add_test(tc_core, test_vests3); tcase_add_test(tc_core, test_vests4); tcase_add_test(tc_core, test_vests5); tcase_add_test(tc_core, test_basic_identifier); tcase_add_test(tc_core, test_issue893); tcase_add_test(tc_core, test_alias4); tcase_add_test(tc_core, test_defer1); tcase_add_test(tc_core, test_error13); tcase_add_test(tc_core, test_issue917); tcase_add_test(tc_core, test_issue905); tcase_add_test(tc_core, test_vunit10); tcase_add_test(tc_core, test_issue942); tcase_add_test(tc_core, test_lcs2016_i03); tcase_add_test(tc_core, test_issue952); tcase_add_test(tc_core, test_visibility12); tcase_add_test(tc_core, test_issue956); tcase_add_test(tc_core, test_issue961); tcase_add_test(tc_core, test_issue977); tcase_add_test(tc_core, test_issue991); tcase_add_test(tc_core, test_issue1038); tcase_add_test(tc_core, test_issue1055); tcase_add_test(tc_core, test_hang); tcase_add_test(tc_core, test_protected3); tcase_add_test(tc_core, test_pkgindecl); tcase_add_test(tc_core, test_issue1090); tcase_add_test(tc_core, test_issue1091); tcase_add_test(tc_core, test_issue1091b); tcase_add_test(tc_core, test_issue1096); tcase_add_test(tc_core, test_alias5); tcase_add_test(tc_core, test_gensub); tcase_add_test(tc_core, test_aggregate2); tcase_add_test(tc_core, test_issue1124); tcase_add_test(tc_core, test_issue1129); tcase_add_test(tc_core, test_issue1138); tcase_add_test(tc_core, test_issue1152); tcase_add_test(tc_core, test_issue1174); tcase_add_test(tc_core, test_vests6); tcase_add_test(tc_core, test_issue1188); tcase_add_test(tc_core, test_issue1202); tcase_add_test(tc_core, test_issue1249); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_psl.c000066400000000000000000000313451504111170000155250ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "lib.h" #include "option.h" #include "phase.h" #include "psl/psl-node.h" #include "psl/psl-phase.h" #include "scan.h" START_TEST(test_parse1) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/parse1.vhd"); const error_t expect[] = { { 12, "no visible declaration for E" }, { 19, "no visible declaration for FFF" }, { 28, "FOO already declared in this region" }, { 34, "no visible declaration for XXXX" }, { 41, "no visible declaration for XXX" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_parse2) { set_standard(STD_08); input_from_file(TESTDIR "/psl/parse2.vhd"); const error_t expect[] = { { 12, "no visible declaration for E" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t s0 = tree_stmt(a, 0); fail_unless(tree_kind(s0) == T_PSL_DIRECT); psl_node_t p0 = tree_psl(s0); fail_unless(psl_kind(p0) == P_ASSERT); tree_t s3 = tree_stmt(a, 3); fail_unless(tree_kind(s3) == T_CONCURRENT); tree_t s3a = tree_stmt(s3, 0); fail_unless(tree_kind(s3a) == T_ASSERT); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_sem1) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/sem1.vhd"); const error_t expect[] = { { 12, "expression must be a PSL Boolean but have type INTEGER" }, { 16, "expression must be a PSL Number but have type BIT" }, { 17, "expression must be static" }, { 19, "expression must be a PSL Boolean but have type INTEGER" }, { 20, "property is not in the simple subset as the left hand side of " "this implication is non-Boolean" }, { 21, "property is not in the simple subset as the right hand side of " "this overlapping until operator is non-Boolean" }, { 22, "property is not in the simple subset as the left hand side of " "this until operator is non-Boolean" }, { 23, "property is not in the simple subset as the operand of this " "next_e operator is non-Boolean" }, { 25, "property is not in the simple subset as the left hand side of " "this implication is non-Boolean" }, { 26, "property is not in the simple subset as the right hand side of " "this implication is non-Boolean" }, { 27, "property is not in the simple subset as the operand of " "eventually! is not a Boolean or Sequence" }, { 28, "property is not in the simple subset as the operand of never " "is not a Boolean or Sequence" }, { 29, "no visible declaration for BAD" }, { 30, "no visible declaration for BAD" }, { 32, "no visible declaration for F" }, { 33, "property is not in the simple subset as the left hand side of " "this before operator is non-Boolean" }, { 34, "property is not in the simple subset as the right hand side of " "this before operator is non-Boolean" }, { 35, "left hand side of suffix implication operator must be a " "Sequence" }, { 36, "property is not in the simple subset as both operands of this " "logical OR are non-Boolean" }, { 37, "operand of non-consecutive repetition operator must be Boolean" }, { 38, "operand of goto repetition operator must be Boolean" }, { 39, "expression must be a PSL Number but have type BIT" }, { 40, "no visible declaration for FOO" }, { 40, "no visible declaration for Z" }, { 41, "PSL endpoint declarations are not supported" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_parse3) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/parse3.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); psl_node_t p0 = tree_psl(tree_stmt(a, 1)); fail_unless(psl_kind(p0) == P_ASSERT); psl_node_t p0_v = psl_value(p0); fail_unless(psl_kind(p0_v) == P_CLOCKED); psl_node_t p1 = tree_psl(tree_stmt(a, 7)); fail_unless(psl_kind(p1) == P_COVER); psl_node_t p2 = tree_psl(tree_stmt(a, 9)); fail_unless(psl_kind(p2) == P_ASSUME); psl_node_t p3 = tree_psl(tree_stmt(a, 12)); fail_unless(psl_kind(p3) == P_RESTRICT); psl_node_t p4 = tree_psl(tree_stmt(a, 15)); fail_unless(psl_kind(p4) == P_FAIRNESS); fail_if_errors(); } END_TEST START_TEST(test_parse4) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/parse4.vhd"); const error_t expect[] = { { 54, "P1 is not a PSL sequence" }, { 60, "unexpected ; while parsing architecture statement part" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH); psl_node_t p0 = tree_psl(tree_decl(a, 5)); fail_unless(psl_kind(p0) == P_SEQUENCE_DECL); psl_node_t p1 = tree_psl(tree_decl(a, 6)); fail_unless(psl_kind(p1) == P_SEQUENCE_DECL); psl_node_t p3 = tree_psl(tree_stmt(a, 0)); psl_node_t p3_v = psl_value(psl_value(p3)); fail_unless(psl_kind(p3) == P_COVER); fail_unless(psl_kind(p3_v) == P_SEQUENCE_INST); psl_node_t p6 = tree_psl(tree_stmt(a, 3)); psl_node_t p6_v = psl_value(psl_value(p6)); fail_unless(psl_kind(p6_v) == P_REPEAT); fail_unless(psl_subkind(p6_v) == PSL_TIMES_REPEAT); psl_node_t p7 = tree_psl(tree_stmt(a, 4)); psl_node_t p7_v_3 = psl_value(psl_value(p7)); fail_unless(psl_kind(p7_v_3) == P_REPEAT); fail_unless(psl_subkind(p7_v_3) == PSL_TIMES_REPEAT); fail_unless(tree_ival(psl_tree(psl_delay(p7_v_3))) == 3); psl_node_t p7_v_2 = psl_value(p7_v_3); fail_unless(psl_kind(p7_v_2) == P_REPEAT); fail_unless(psl_subkind(p7_v_2) == PSL_TIMES_REPEAT); fail_unless(tree_ival(psl_tree(psl_delay(p7_v_2))) == 2); psl_node_t p7_v_1 = psl_value(p7_v_2); fail_unless(psl_kind(p7_v_1) == P_REPEAT); fail_unless(psl_subkind(p7_v_1) == PSL_TIMES_REPEAT); fail_unless(tree_ival(psl_tree(psl_delay(p7_v_1))) == 1); psl_node_t p11 = tree_psl(tree_stmt(a, 8)); psl_node_t p11_v = psl_value(psl_value(p11)); fail_unless(psl_kind(p11_v) == P_REPEAT); fail_unless(tree_ival(psl_tree(psl_left(psl_delay(p11_v)))) == 5); fail_unless(tree_ival(psl_tree(psl_right(psl_delay(p11_v)))) == 10); psl_node_t p9 = tree_psl(tree_stmt(a, 9)); psl_node_t p9_v = psl_value(psl_value(p9)); fail_unless(psl_kind(p9_v) == P_REPEAT); fail_unless(psl_subkind(p9_v) == PSL_PLUS_REPEAT); psl_node_t p14 = tree_psl(tree_stmt(a, 14)); fail_unless(psl_kind(p14) == P_COVER); psl_node_t p14_v = psl_value(psl_value(p14)); fail_unless(psl_kind(p14_v) == P_PROC_BLOCK); fail_unless(tree_kind(psl_tree(p14_v)) == T_SEQUENCE); fail_unless(psl_kind(psl_value(p14_v)) == P_HDL_EXPR); check_expected_errors(); } END_TEST START_TEST(test_parse5) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/parse5.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); psl_node_t p0 = tree_psl(tree_stmt(a, 0)); psl_node_t p0_v = psl_value(psl_value(p0)); fail_unless(psl_kind(p0) == P_COVER); fail_unless(psl_kind(p0_v) == P_SERE); fail_unless(psl_subkind(p0_v) == PSL_SERE_FUSION); fail_unless(psl_operands(p0_v) == 4); psl_node_t p1 = tree_psl(tree_stmt(a, 1)); psl_node_t p1_v = psl_value(psl_value(p1)); psl_node_t p1_v0 = psl_operand(p1_v, 0); psl_node_t p1_v1 = psl_operand(p1_v, 1); fail_unless(psl_kind(p1_v) == P_SERE); fail_unless(psl_subkind(p1_v) == PSL_SERE_CONCAT); fail_unless(psl_kind(p1_v0) == P_HDL_EXPR); fail_unless(psl_kind(p1_v1) == P_SERE); psl_node_t p2 = tree_psl(tree_stmt(a, 2)); psl_node_t p2_v = psl_value(psl_value(p2)); fail_unless(psl_kind(p2_v) == P_SERE); fail_unless(psl_subkind(p2_v) == PSL_SERE_OR); psl_node_t p3 = tree_psl(tree_stmt(a, 3)); psl_node_t p3_v = psl_value(psl_value(p3)); psl_node_t p3_v0 = psl_operand(p3_v, 0); psl_node_t p3_v1 = psl_operand(p3_v, 1); fail_unless(psl_kind(p3_v) == P_SERE); fail_unless(psl_subkind(p3_v) == PSL_SERE_OR); fail_unless(psl_kind(p3_v0) == P_REPEAT); fail_unless(psl_kind(p3_v1) == P_REPEAT); fail_unless(psl_subkind(p3_v0) == PSL_TIMES_REPEAT); psl_node_t p4 = tree_psl(tree_stmt(a, 4)); psl_node_t p4_v = psl_value(psl_value(p4)); psl_node_t p4_v0 = psl_operand(p4_v, 0); fail_unless(psl_kind(p4_v) == P_SERE); fail_unless(psl_subkind(p4_v) == PSL_SERE_OR); fail_unless(psl_subkind(p4_v0) == PSL_SERE_CONCAT); psl_node_t p5 = tree_psl(tree_stmt(a, 5)); psl_node_t p5_v = psl_value(psl_value(p5)); fail_unless(psl_kind(p5_v) == P_SERE); fail_unless(psl_subkind(p5_v) == PSL_SERE_WITHIN); psl_node_t p6 = tree_psl(tree_stmt(a, 6)); psl_node_t p6_v = psl_value(psl_value(p6)); fail_unless(psl_kind(p6_v) == P_SERE); fail_unless(psl_subkind(p6_v) == PSL_SERE_EQU_AND); psl_node_t p7 = tree_psl(tree_stmt(a, 7)); psl_node_t p7_v = psl_value(psl_value(p7)); fail_unless(psl_kind(p7_v) == P_SERE); fail_unless(psl_subkind(p7_v) == PSL_SERE_NEQ_AND); fail_if_errors(); } END_TEST START_TEST(test_issue910) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/issue910.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); psl_node_t p0 = tree_psl(tree_stmt(a, 0)); fail_unless(psl_kind(p0) == P_COVER); psl_node_t p0_clk = psl_value(p0); fail_unless(psl_kind(p0_clk) == P_CLOCKED); fail_unless(psl_kind(psl_value(p0_clk)) == P_HDL_EXPR); psl_node_t p1 = tree_psl(tree_stmt(a, 0)); fail_unless(psl_kind(p1) == P_COVER); psl_node_t p1_clk = psl_value(p1); fail_unless(psl_kind(p1_clk) == P_CLOCKED); fail_unless(psl_kind(psl_value(p1_clk)) == P_HDL_EXPR); fail_if_errors(); } END_TEST START_TEST(test_issue1001) { set_standard(STD_08); input_from_file(TESTDIR "/psl/issue1001.vhd"); const error_t expect[] = { { 15, "no matching subprogram ONEHOT [BIT return BOOLEAN | BIT]" }, { 16, "type of actual BIT does not match formal V type BIT_VECTOR" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_clock1) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/clock1.vhd"); const error_t expect[] = { { 9, "sorry, unclocked properties are not supported" }, { 11, "sorry, clock expressions are only supported at the outermost" }, { 12, "expression must be a PSL Boolean but have type " "universal_integer" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_sem2) { opt_set_int(OPT_PSL_COMMENTS, 1); input_from_file(TESTDIR "/psl/sem2.vhd"); const error_t expect[] = { { 13, "expression must be a PSL Bit but have type INTEGER" }, { 16, "expression must be static" }, { 17, "PSL union operands must be the same type" }, { 0, "have BIT and INTEGER" }, { 18, "no visible declaration for XXXX" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST Suite *get_psl_tests(void) { Suite *s = suite_create("psl"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_parse1); tcase_add_test(tc_core, test_parse2); tcase_add_test(tc_core, test_sem1); tcase_add_test(tc_core, test_parse3); tcase_add_test(tc_core, test_parse4); tcase_add_test(tc_core, test_parse5); tcase_add_test(tc_core, test_issue910); tcase_add_test(tc_core, test_issue1001); tcase_add_test(tc_core, test_clock1); tcase_add_test(tc_core, test_sem2); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_sdf.c000066400000000000000000000177411504111170000155070ustar00rootroot00000000000000// // Copyright (C) 2022-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "lib.h" #include "option.h" #include "phase.h" #include "sdf/sdf-phase.h" #include "scan.h" #include "type.h" #include #define fail_unless_floats_equal(a, b) fail_unless(fabs(a - b) < 0.00001); START_TEST(test_parse1) { input_from_file(TESTDIR "/sdf/parse1.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse2) { input_from_file(TESTDIR "/sdf/parse2.sdf"); const error_t expect[] = { { 2, "Invalid SDF version: \"FOR_SURE_INVALID_SDF_VERSION\". " "SDF version shall contain one of: \"1.0\", \"2.0\", \"2.1\", \"3.0\" or \"4.0\"" }, { -1, NULL } }; expect_errors(expect); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); check_expected_errors(); } END_TEST START_TEST(test_parse3) { input_from_file(TESTDIR "/sdf/parse3.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse4) { input_from_file(TESTDIR "/sdf/parse4.sdf"); const error_t expect[] = { { 6, "Used hierarchy separator: / but hierarchy separator defined in SDF header is: ." }, { -1, NULL } }; expect_errors(expect); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); check_expected_errors(); } END_TEST START_TEST(test_parse5) { input_from_file(TESTDIR "/sdf/parse5.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse6) { input_from_file(TESTDIR "/sdf/parse6.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse7) { input_from_file(TESTDIR "/sdf/parse7.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse8) { input_from_file(TESTDIR "/sdf/parse8.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse9) { input_from_file(TESTDIR "/sdf/parse9.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse10) { input_from_file(TESTDIR "/sdf/parse10.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse11) { input_from_file(TESTDIR "/sdf/parse11.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse12) { input_from_file(TESTDIR "/sdf/parse12.sdf"); const error_t expect[] = { // { 9, "'delval_list' shall have at most 12 'delval' entries" }, { -1, NULL } }; expect_errors(expect); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); check_expected_errors(); } END_TEST START_TEST(test_parse13) { input_from_file(TESTDIR "/sdf/parse13.sdf"); const error_t expect[] = { { 4, "unexpected ( while parsing delay file, expecting )" }, // { 7, "Duplicit header item" }, { -1, NULL } }; expect_errors(expect); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); check_expected_errors(); } END_TEST START_TEST(test_parse14) { input_from_file(TESTDIR "/sdf/parse14.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse15) { input_from_file(TESTDIR "/sdf/parse15.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse16) { input_from_file(TESTDIR "/sdf/parse16.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse17) { input_from_file(TESTDIR "/sdf/parse17.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse18) { input_from_file(TESTDIR "/sdf/parse18.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse19) { input_from_file(TESTDIR "/sdf/parse19.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse20) { input_from_file(TESTDIR "/sdf/parse20.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse21) { input_from_file(TESTDIR "/sdf/parse21.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse22) { input_from_file(TESTDIR "/sdf/parse22.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse23) { input_from_file(TESTDIR "/sdf/parse23.sdf"); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); fail_if_errors(); } END_TEST START_TEST(test_parse24) { input_from_file(TESTDIR "/sdf/parse24.sdf"); const error_t expect[] = { { 8, "'rtripple' shall have at least one number specified"}, { 12, "'tripple' shall have at least one number specified"}, { -1, NULL } }; expect_errors(expect); sdf_file_t *file = sdf_parse("dummy.sdf", S_F_MIN_MAX_SPEC_ALL); ck_assert_ptr_nonnull(file); check_expected_errors(); } END_TEST Suite *get_sdf_tests(void) { Suite *s = suite_create("sdf"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_parse1); tcase_add_test(tc_core, test_parse2); tcase_add_test(tc_core, test_parse3); tcase_add_test(tc_core, test_parse4); tcase_add_test(tc_core, test_parse5); tcase_add_test(tc_core, test_parse6); tcase_add_test(tc_core, test_parse7); tcase_add_test(tc_core, test_parse8); tcase_add_test(tc_core, test_parse9); tcase_add_test(tc_core, test_parse10); tcase_add_test(tc_core, test_parse11); tcase_add_test(tc_core, test_parse12); tcase_add_test(tc_core, test_parse13); tcase_add_test(tc_core, test_parse14); tcase_add_test(tc_core, test_parse15); tcase_add_test(tc_core, test_parse16); tcase_add_test(tc_core, test_parse17); tcase_add_test(tc_core, test_parse18); tcase_add_test(tc_core, test_parse19); tcase_add_test(tc_core, test_parse20); tcase_add_test(tc_core, test_parse21); tcase_add_test(tc_core, test_parse22); tcase_add_test(tc_core, test_parse23); tcase_add_test(tc_core, test_parse24); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_sem.c000066400000000000000000003643651504111170000155260ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "diag.h" #include "lib.h" #include "option.h" #include "phase.h" #include "scan.h" #include "type.h" #include #include #include #include START_TEST(test_integer) { tree_t a, d, p, s, e; type_t t; const error_t expect[] = { { 20, "MY_INT1 does not match type of target MY_INT2" }, { 30, "MY_INT1 does not match type of target MY_INT2_SUB" }, { 35, "no visible declaration for NOTHING" }, { 48, "no matching operator \"*\" [MY_INT2, MY_INT1 return MY_INT2]" }, { 57, "MY_INT2 has no attribute CAKE" }, { 61, "right bound must be of some integer type but have universal" }, { 63, "range bounds must be of some integer type but have BOOLEAN" }, { 68, "range constraint of type BAD3 must be locally static" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/sem/integer.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); d = get_decl(a, "X"); t = tree_type(d); fail_unless(type_kind(t) == T_INTEGER); e = tree_value(d); fail_unless(tree_kind(e) == T_LITERAL); t = tree_type(e); fail_unless(type_kind(t) == T_INTEGER); fail_unless(tree_stmts(a) == 8); // Process 1 p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); d = get_decl(p, "Z"); fail_unless(type_kind(tree_type(d)) == T_INTEGER); s = tree_stmt(p, 0); fail_unless(tree_ref(tree_target(s)) == d); // Process 6 p = tree_stmt(a, 4); fail_unless(tree_kind(p) == T_PROCESS); } END_TEST START_TEST(test_ports) { opt_set_int(OPT_MISSING_BODY, 1); input_from_file(TESTDIR "/sem/ports.vhd"); const error_t expect[] = { { 31, "cannot read output port O" }, { 42, "cannot assign to input port I" }, { 81, "missing actual for port I of mode IN without a default " }, { 85, "formal port I already has an actual" }, { 89, "at least 3 positional actuals but WORK.FOO has only 2 ports" }, { 92, "WORK.FOO has no port named CAKE" }, { 94, "design unit BAD not found in library WORK" }, { 103, "unconnected port I with mode IN must have a default value" }, { 116, "object X is not a component declaration" }, { 148, "port O of mode OUT must be a static signal name or OPEN" }, { 155, "BAR has no port named Q" }, { 163, "BAR has no port named U" }, { 168, "formal name must be locally static" }, { 177, "formal name must be locally static" }, { 185, "no visible declaration for HELLO" }, { 217, "port O of unconstrained type INT_VEC cannot be unconnected" }, { 221, "type of actual universal_real does not match type INTEGER" }, { 272, "result of conversion for unconstrained formal I must" }, { 280, "port N of mode IN must be a globally static expression or " }, { 284, "conversion not allowed for formal O with mode OUT" }, { 294, "output conversion not allowed for formal I with mode IN" }, { 298, "output conversion for formal B must not have OPEN actual" }, { 304, "port B of mode INOUT must be a static signal name or OPEN" }, { 307, "port B of mode INOUT must be a static signal name or OPEN" }, { 256, "missing body for function FUNC1 [BIT return MY_INT1]" }, { 257, "missing body for function FUNC2 [BIT, INTEGER return MY_INT1]" }, { 258, "missing body for function FUNC3 [BIT return INTEGER]" }, { 259, "missing body for function FUNC4 [INTEGER return BIT]" }, { 318, "cannot assign to input port X" }, { 319, "cannot read output port Y" }, { 339, "parameter X of mode IN with formal X of mode OUT" }, { 363, "associated with port I of mode IN must be a globally static" }, { 367, "actual associated with port I of mode IN must be a globally " }, { 375, "invalid output conversion \"not\"" }, { 373, "missing actual for port I of mode IN without a default " }, { 353, "missing body for function \"not\" [INTEGER return INTEGER]" }, { 354, "missing body for function FOO" }, { 394, "port UIO with mode INOUT cannot be associated with formal port " "LB with mode BUFFER" }, { 395, "port UB with mode BUFFER cannot be associated with formal port " "LIO with mode INOUT" }, { 396, "port UO with mode OUT cannot be associated with formal port LI " "with mode IN" }, { 397, "port UI with mode IN cannot be associated with formal port LO " "with mode OUT" }, { 405, "port UO with mode OUT cannot be associated with formal port " "LIO with mode INOUT" }, { 407, "port UL with mode LINKAGE cannot be associated with formal " "port LI with mode IN" }, { 416, "port UI with mode IN cannot be associated with formal port " "LB with mode BUFFER" }, { 417, "port UB with mode BUFFER cannot be associated with formal port " "LO with mode OUT" }, { 436, "INOUT port IO1 has output conversion but no corresponding input " "conversion" }, { 437, "type of actual REAL does not match type INTEGER of formal " "port IO2" }, { 451, "OPEN actual for formal parameter C without default value" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ARCH, T_ARCH, T_ENTITY, T_ARCH, T_ARCH, T_ARCH, T_ARCH, T_ARCH, T_ARCH); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_scope) { input_from_file(TESTDIR "/sem/scope.vhd"); const error_t expect[] = { { 31, "WORK.PACK1.MY_INT1 does not match type" " of target WORK.PACK2.MY_INT1" }, { 44, "WORK.PACK1.MY_INT1 does not match type of target " "WORK.NO_USE_CLAUSE-A.MY_INT1" }, { 63, "G already declared in this region" }, { 71, "P already declared in this region" }, { 114, "no visible declaration for MY_INT1" }, { 137, "no visible declaration for E1" }, { 160, "no visible declaration for FUNC2" }, { 167, "name NOT_HERE not found in package WORK.PACK5" }, { 189, "no visible declaration for MY_INT1" }, { 211, "no visible declaration for PACK5" }, { 236, "no visible declaration for FOO" }, { 302, "declaration of I hides an earlier declaration with the same " }, { 306, "name X not found in L1" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ARCH, T_ARCH, T_ENTITY, T_ARCH, T_ENTITY, T_PACKAGE, T_PACKAGE, T_ARCH, T_PACKAGE, T_ARCH, T_ARCH, T_ENTITY, T_ARCH, T_ARCH, T_PACKAGE, T_ARCH, T_ARCH, T_PACKAGE, T_ARCH, T_ARCH, T_PACKAGE, T_ARCH, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_ambiguous) { tree_t a, e, p, s; type_t lhs, rhs; opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/ambiguous.vhd"); const error_t expect[] = { { 35, "type of value BAR does not match type of target FOO" }, { 56, "type of aggregate cannot be determined" }, { 86, "ambiguous use of enumeration literal FALSE" }, { 86, "ambiguous use of enumeration literal FALSE" }, { 93, "ambiguous use of name NOW" }, { 93, "ambiguous use of name NOW" }, { 103, "ambiguous use of name FALSE" }, { 103, "ambiguous use of name FALSE" }, { 0, "use of name FALSE here" }, { 0, "visible declaration of FALSE as BOOLEAN from STD.STANDARD" }, { 0, "visible declaration of FALSE as FALSE [return INTEGER]" }, { 141, "ambiguous use of operator \"<\"" }, { 0, "use of name \"<\" here" }, { 0, "candidate \"<\" [MY_INT, MY_INT return BOOLEAN]" }, { 0, "candidate \"<\" [MY_INT, MY_INT return BOOLEAN]" }, { 0, "this would be resolved in favour of the explicitly defined " "operator with --relaxed" }, { 222, "type of aggregate cannot be determined" }, { -1, NULL } }; expect_errors(expect); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); p = tree_stmt(a, 0); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(tree_waveform(s, 0))); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.FOO")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.FOO")); s = tree_stmt(p, 1); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(tree_waveform(s, 0))); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.BAR")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.BAR")); p = tree_stmt(a, 1); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(tree_waveform(s, 0))); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.FOO")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.FOO")); s = tree_stmt(p, 1); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(tree_waveform(s, 0))); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.BAR")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.BAR")); p = tree_stmt(a, 2); fail_unless(tree_stmts(p) == 3); s = tree_stmt(p, 0); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(s)); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.P3.BAZ")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.P3.BAZ")); s = tree_stmt(p, 1); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(s)); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.P3.BAZ")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.P3.BAZ")); s = tree_stmt(p, 2); lhs = tree_type(tree_target(s)); rhs = tree_type(tree_value(tree_waveform(s, 0))); fail_unless(type_ident(lhs) == ident_new("WORK.E-A.FOO")); fail_unless(type_ident(rhs) == ident_new("WORK.E-A.FOO")); parse_and_check(T_PACKAGE, T_PACKAGE, T_ARCH, T_ARCH, T_ARCH, T_ARCH, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_const) { input_from_file(TESTDIR "/sem/const.vhd"); const error_t expect[] = { { 24, "target of variable assignment must be a variable name" }, { 28, "deferred constant declarations are only permitted" }, { 58, "C already declared in this region" }, { 59, "expected type INTEGER for deferred constant F" }, { 49, "deferred constant D was not given a value" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_const2) { input_from_file(TESTDIR "/sem/const2.vhd"); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put(lib_work(), p); fail_unless(error_count() == 0); fail_unless(tree_kind(p) == T_PACKAGE); tree_t d = get_decl(p, "DEF_ARR"); fail_unless(tree_kind(d) == T_CONST_DECL); fail_unless(type_is_unconstrained(tree_type(d))); fail_if(tree_has_value(d)); tree_t pb = parse(); fail_if(pb == NULL); fail_unless(tree_kind(pb) == T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_std) { input_from_file(TESTDIR "/sem/std.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_wait) { input_from_file(TESTDIR "/sem/wait.vhd"); const error_t expect[] = { { 17, "type of delay must be TIME" }, { 26, "name V in sensitivity list is not a signal" }, { 35, "invalid use of entity A" }, { 43, "wait statement not allowed in process" }, { 51, "type of condition must be BOOLEAN" }, { 53, "type of delay must be TIME" }, { 66, "name in sensitivity list is not a static signal name" }, { 69, "name in sensitivity list is not a static signal name" }, { -1, NULL } }; expect_errors(expect); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); tree_t p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 4); ident_t time = ident_new("STD.STANDARD.TIME"); tree_t w = tree_stmt(p, 0); fail_unless(tree_kind(w) == T_WAIT); fail_unless(type_ident(tree_type(tree_delay(w))) == time); w = tree_stmt(p, 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(type_ident(tree_type(tree_delay(w))) == time); w = tree_stmt(p, 2); fail_unless(tree_kind(w) == T_WAIT); fail_unless(type_ident(tree_type(tree_delay(w))) == time); fail_unless(parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_func) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/func.vhd"); const error_t expect[] = { { 5, "function parameters must have mode IN" }, { 19, "must be an unconstrained array type" }, { 23, "resolution function must have a single argument" }, { 25, "no visible subprogram declaration for UENUM" }, { 27, "type of default value universal_integer does not" }, { 29, "subprogram body is not allowed in package specification" }, { 36, "design unit BAD not found in library WORK" }, { 48, "expected return type INTEGER but have UENUM" }, { 51, "function parameters must have mode IN" }, { 62, "FOO [INTEGER, INTEGER, INTEGER return INTEGER] already " }, { 114, "positional parameters must precede named parameters" }, { 115, "formal parameter X already has an associated actual" }, { 124, "class of function parameters must be CONSTANT, SIGNAL, or FILE" }, { 146, "B with class VARIABLE must be a name denoting a variable" }, { 161, "pure function TEST18 cannot call impure function" }, { 166, "formal parameter X with access type must have class VARIABLE" }, { 180, "universal_real does not match formal X type INTEGER" }, { 181, "missing actual for formal parameter Y without default value" }, { 182, "type of actual universal_integer does not match formal Y" }, { 239, "class variable of subprogram body TEST25 parameter" }, { 245, "class constant of subprogram body TEST26 parameter" }, { 271, "cannot reference signal X in pure function NESTED" }, { 288, "no visible declaration for FNORK" }, { 293, "function CONSTPURE [INTEGER return INTEGER] cannot be called " }, { 294, "procedure NOTDEF not allowed in an expression" }, { 297, "no visible declaration for BAD_TYPE" }, { 297, "no visible declaration for FOO" }, { 303, "default value of parameter X in subprogram body FUNC1" }, { 310, "default value of parameter X in subprogram body FUNC2" }, { 317, "default value of parameter X in subprogram body FUNC3" }, { 324, "function FUNC4 declaration was pure but body is impure" }, { 331, "function FUNC5 declaration was impure but body is pure" }, { 336, "class of function parameters must be CONSTANT, SIGNAL, or FILE" }, { 338, "function parameters must have mode IN" }, { 342, "return in function must have an expression" }, { 345, "logical operator must have two operands" }, { 346, "unary operator must have one operand" }, { 348, "binary operator must have two operands" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACK_BODY, T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_array) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/array.vhd"); const error_t expect[] = { { 27, "positional associations must appear first in aggregate" }, { 33, "named association must not follow others" }, { 39, "only a single others association allowed" }, { 46, "type of initial value universal_integer does not match" }, { 55, "type of value universal_integer does not match type of" }, { 57, "type of value INT_ARRAY does not match type" }, { 65, "operator \"=\" [INT_ARRAY, TEN_INTS return BOOLEAN]" }, { 88, "prefix of indexed name has 2 dimensions but 1 indices given" }, { 89, "prefix of indexed name has 2 dimensions but 3 indices given" }, { 98, "type of index universal_integer does not match type" }, { 102, "named and positional associations cannot be mixed in" }, { 111, "a choice that is not locally static is allowed" }, { 119, "type of aggregate cannot be determined from the surrounding" }, { 0, "context contains type INTEGER which is not a composite type" }, { 119, "type of slice prefix INTEGER is not an array" }, { 120, "range direction of slice TO does not match prefix DOWNTO" }, { 121, "index range of array aggregate with others choice cannot" }, { 130, "ambiguous use of enumeration literal '0'" }, { 130, "range direction of slice DOWNTO does not match prefix TO" }, { 207, "array BAD cannot have unconstrained element type" }, { 215, "array aggregate with others choice cannot be determined" }, { 232, "aliased name is not static" }, { 233, "aliased name is not static" }, { 234, "type of aliased object INT_ARRAY does not match" }, { 241, "cannot index non-array type INTEGER" }, { 252, "expected 1 constraints for type INT_ARRAY but found 2" }, { 269, "no matching operator \"<\" [TEN_TEN_INTS, TEN_TEN_INTS " }, { 270, "no matching operator \">\" [TEN_TEN_INTS, TEN_TEN_INTS " }, { 272, "no matching operator \"<\" [INT2D, INT2D" }, { 277, "no visible declaration for NOT_HERE" }, { 279, "variable A2 cannot have unconstrained type NUM_ARRAY" }, { 285, "name K in discrete range does not refer to a type" }, { 295, "type of index universal_integer does not match" }, { 343, "invalid character 'f' in string literal of type BIT_VECTOR" }, { 365, "cannot change constraints of constrained array type TEN_INTS" }, { 366, "cannot change constraints of constrained array type TEN_INTS" }, { 379, "array T_FILE_ARRAY cannot have element of file type" }, { 391, "index type REAL is not discrete" }, { 392, "index type BIT_VECTOR is not discrete" }, { 399, "type of array aggregate choice BOOLEAN does not match INT_" }, { 400, "in range: left is INTEGER, right is BOOLEAN" }, { 401, "expected type of range bounds to be INTEGER but have BOOLEAN" }, { 403, "a choice that is not locally static is allowed" }, { 404, "a choice that is not locally static is allowed" }, { 424, "ambiguous call to function F" }, { 436, "type mismatch in range: left is universal_real, right is" }, { 442, "dimension index 5 out of range for type INT_ARRAY" }, { 446, "no visible declaration for FOO" }, { 480, "cannot index non-array type MY_RECORD" }, { 488, "the prefix of an indexed name must be a name or a function" }, { 489, "the prefix of a slice name must be a name or a function call" }, { 497, "prefix of indexed name has 2 dimensions but 1 indices given" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_assert) { input_from_file(TESTDIR "/sem/assert.vhd"); const error_t expect[] = { { 17, "type of assertion expression must be BOOLEAN" }, { 22, "type of message be STRING" }, { 27, "type of severity must be SEVERITY_LEVEL" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_generics) { opt_set_int(OPT_MISSING_BODY, 1); input_from_file(TESTDIR "/sem/generics.vhd"); const error_t expect[] = { { 34, "missing actual for generic N" }, { 38, "2 positional actuals but WORK.BOT has only 1 generic" }, { 48, "no visible declaration for X" }, { 58, "invalid object class signal for generic Y" }, { 68, "no visible declaration for Y" }, { 116, "unexpected integer while parsing name" }, { 115, "missing actual for generic X without a default expression" }, { 119, "invalid name in generic map" }, { 118, "missing actual for generic X without a default expression" }, { 122, "invalid use of label I6" }, { 125, "invalid use of architecture A" }, { 128, "invalid use of package STD.STANDARD" }, { 131, "formal generic name must be a locally static name" }, { 134, "generic B with class CONSTANT must have mode IN" }, { 141, "generic G without a default expression cannot be associated " "with OPEN" }, { 147, "formal generic G associated with OPEN cannot be individually " "associated" }, { 153, "formal generic G associated with OPEN cannot be individually " "associated" }, { 87, "missing body for function F [BIT_VECTOR return INTEGER]" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ENTITY, T_ENTITY, T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_seq) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/seq.vhd"); const error_t expect[] = { { 15, "type of condition must be BOOLEAN" }, { 19, "no visible declaration for X" }, { 25, "type of value BOOLEAN does not match type of target INTEGER" }, { 33, "no visible declaration for G" }, { 48, "return statement not allowed outside subprogram" }, { 62, "return statement not allowed outside subprogram" }, { 64, "type of loop condition must be BOOLEAN" }, { 79, "no visible declaration for X" }, { 107, "others choice must appear last" }, { 113, "case choice must be locally static" }, { 126, "case choice must be locally static" }, { 136, "case choice must be locally static" }, { 139, "invalid use of type BIT" }, { 146, "type mismatch in range" }, { 150, "expected type of range bounds to be INTEGER but have BIT" }, { 154, "right index of case choice range is not locally static" }, { 164, "type of exit condition must be BOOLEAN" }, { 179, "actual for formal Y with class VARIABLE must be" }, { 187, "type of next condition must be BOOLEAN" }, { 190, "cannot use next statement outside loop" }, { 192, "no visible declaration for FOO" }, { 205, "DUP already declared in this region" }, { 214, "type of range bounds REAL is not discrete" }, { 222, "variable I is not a valid target of signal assignment" }, { 228, "expected type mark while parsing discrete range" }, { 230, "range bounds to be INTEGER but have universal_real" }, { 232, "type of range bounds REAL is not discrete" }, { 243, "target of variable assignment must be a variable name" }, { 244, "aggregate element must be locally static name" }, { 245, "others association not allowed in aggregate target" }, { 246, "range association not allowed in aggregate target" }, { 247, "variable A is identifed more than once in aggregate target" }, { 255, "X with class SIGNAL must be a name denoting a signal" }, { 256, "X with class SIGNAL must be a name denoting a signal" }, { 264, "target of variable assignment must be a variable name or" }, { 265, "actual for formal X with class VARIABLE must be a name" }, { 271, "no visible declaration for BAD_TYPE" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_conc) { input_from_file(TESTDIR "/sem/conc.vhd"); const error_t expect[] = { { 12, "type of value CHARACTER does not match type of target INTEGER" }, { 16, "type of condition must be BOOLEAN" }, { 18, "reject interval must have type TIME" }, { 26, "choice must be locally static" }, { 29, "type of value BOOLEAN does not match type of target INTEGER" }, { 32, "case choice must have type INTEGER" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_procedure) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/procedure.vhd"); const error_t expect[] = { { 5, "subprogram body is not allowed in package specification" }, { 28, "cannot return a value from a procedure" }, { 45, "type of default value universal_integer does not match" }, { 63, "missing actual for formal parameter X without default value" }, { 64, "positional parameters must precede named parameters" }, { 83, "cannot read OUT parameter Y" }, { 84, "target of variable assignment must be a variable name" }, { 90, "implicit signal STABLE cannot be used in a subprogram body" }, { 91, "implicit signal QUIET cannot be used in a subprogram body" }, { 92, "implicit signal TRANSACTION cannot be used in a subprogram" }, { 93, "implicit signal DELAYED cannot be used in a subprogram" }, { 98, "formal parameter X with access type must have class VARIABLE" }, { 99, "formal parameter X with access type must have class VARIABLE" }, { 100, "formal parameter X with access type must have class VARIABLE" }, { 142, "cannot read OUT parameter X" }, { 148, "X is not a valid target of signal assignment" }, { 157, "formal parameter ARG with type containing an access type " }, { 162, "formal parameter ARG with type containing an access type " }, { 167, "formal parameter ARG with type containing an access type " }, { 172, "formal parameter ARG with type containing an access type " }, { 180, "expected procedure name" }, { 183, "declaration may not include the reserved word BUS" }, { 193, "signal parameter Y must be denoted by a static signal name" }, { 201, "formal parameter X already has an associated actual" }, { 202, "no possible overload of TEST17_A has formal Z" }, { 0, "did you mean X?" }, { 0, "subprogram TEST17_A [INTEGER, INTEGER] has arguments X, Y" }, { 207, "cannot assign to input parameter X" }, { 224, "no possible overload of P1 has formal B" }, { 227, "procedure name must be an identifier" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_concat) { input_from_file(TESTDIR "/sem/concat.vhd"); const error_t expect[] = { { 24, "no matching operator \"&\" [universal_integer, STRING" }, { 26, "no matching operator \"&\" [universal_integer, CHARACTER" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_conv) { input_from_file(TESTDIR "/sem/conv.vhd"); const error_t expect[] = { { 32, "conversion only allowed between closely related types" }, { 33, "type of value B does not match type of target A" }, { 35, "conversion only allowed between closely related types" }, { 42, "conversion only allowed between closely related types" }, { 43, "conversion only allowed between closely related types" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_attr) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/attr.vhd"); const error_t expect[] = { { 30, "Z has no attribute FOO" }, { 54, "prefix of user defined attribute reference cannot denote" }, { 65, "expected attribute specification for FOO to have type INTEGER " "but found STRING" }, { 66, "expected attribute specification for BAR to have type STRING " "but found universal_integer" }, { 67, "no visible declaration for Q" }, { 85, "dimension parameter of attribute LEFT must be a locally " "static expression of type universal_integer" }, { 0, "expression has type INTEGER" }, { 101, "prefix of SIMPLE_NAME attribute must be a named entity" }, { 133, "cannot index non-array type INTEGER" }, { 139, "class of object I is variable not signal" }, { 146, "prefix of attribute LAST_EVENT must denote a signal" }, { 158, "attribute RANGE with unconstrained array type BIT_VECTOR" }, { 159, "object prefix of attribute RANGE must be an array" }, { 160, "prefix does not have a range" }, { 204, "prefix does not have LENGTH attribute" }, { 212, "cannot use attribute IMAGE with non-scalar type INT2_" }, { 222, "prefix of 'BASE attribute must be a type or subtype declara" }, { 223, "BASE attribute is allowed only as the prefix of the name" }, { 229, "no visible declaration for NOT_HERE" }, { 252, "parameter of attribute VAL must have an integer type but " "found universal_real" }, { 253, "attribute VAL requires a parameter" }, { 261, "cannot use attribute VALUE with non-scalar type BIT2D" }, { 304, "expression must be a BOOLEAN literal" }, { 306, "NEVER_WAITS attribute can only be applied to procedures" }, { 319, "cannot read output port X" }, { 320, "cannot read output port X" }, { 321, "cannot read output port X" }, { 322, "cannot read output port X" }, { 323, "cannot read output port X" }, { 324, "cannot read output port X" }, { 325, "cannot read output port X" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ARCH, T_ARCH, T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_generate) { input_from_file(TESTDIR "/sem/generate.vhd"); const error_t expect[] = { { 15, "type of condition must be BOOLEAN but have INTEGER" }, { 26, "no visible declaration for Y" }, { 33, "declaration of X hides an earlier declaration " }, { 39, "declaration of X hides an earlier declaration " }, { 45, "condition of generate statement must be static" }, { 48, "range of generate statement must be static" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_record) { input_from_file(TESTDIR "/sem/record.vhd"); const error_t expect[] = { { 9, "duplicate field name X" }, { 13, "no visible declaration for R3" }, { 28, "record field X cannot have unconstrained array type" }, { 37, "field Z does not have a value" }, { 38, "does not match type INTEGER of field Y" }, { 40, "field Y does not have a value" }, { 41, "record type R1 has no field named Q" }, { 42, "type of value R1 does not match type INTEGER of" }, { 45, "field X was already given a value by earlier named choice" }, { 46, "field X was already given a value by earlier positional choice" }, { 62, "variable A1 cannot have unconstrained type R1_VEC" }, { 70, "record type R1 has no field named F" }, { 80, "record type R1_SUB has no field named Z" }, { 84, "index constraint cannot be used with non-array type R1" }, { 104, "record type R1 has no field named Z" }, { 109, "record field A cannot be of file type" }, { 122, "record type R8 has no field named ACK" }, { 151, "cannot index non-array type UNIT_SPEC_T" }, { 153, "cannot index non-array type UNIT_SPEC_T" }, { 155, "cannot index non-array type UNIT_SPEC_T" }, { 164, "association choice must be a field name" }, { 165, "3 positional associations given but record type R1 only has 2" }, { 166, "others association must represent at least one element" }, { 167, "discrete range is only allowed in an array aggregate" }, { 168, "discrete range is only allowed in an array aggregate" }, { 172, "no visible declaration for FOO" }, { 182, "type INTEGER is not a record" }, { 186, "prefix does not have attribute LEFT" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); tree_t d = get_decl(p, "P9"); d = tree_decl(d, 0); fail_unless(tree_kind(d) == T_VAR_DECL); fail_if(tree_has_value(d)); } END_TEST START_TEST(test_file) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/file.vhd"); const error_t expect[] = { { 6, "files may not be of access type" }, { 8, "files may not be of file type" }, { 12, "file declarations must have file type" }, { 16, "open mode must have type FILE_OPEN_KIND" }, { 20, "file name must have type STRING" }, { 28, "array type for file type must be one-dimensional" }, { 30, "array type for file type must be one-dimensional" }, { 46, "type T_PTR_ARR has a subelement with an access type" }, { 47, "type SUB_PTR_ARR has a subelement with an access type" }, { 48, "type T_REC has a subelement with an access type" }, { 49, "type T_REC2 has a subelement with an access type" }, { 60, "function result subtype may not denote a file type" }, { 62, "index constraint cannot be used with non-array type FT" }, { 78, "no matching subprogram READ [FT, FILE_OPEN_STATUS]" }, { 84, "no matching operator \"=\" [FT, FT return BOOLEAN]" }, { 85, "no matching operator \"/=\" [FT, FT return BOOLEAN]" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_access) { set_standard(STD_00); input_from_file(TESTDIR "/sem/access.vhd"); const error_t expect[] = { { 5, "no visible declaration for FOO" }, { 34, "type of null expression cannot be determined from the " "surrounding context" }, { 38, "unexpected integer while parsing name, expecting" }, { 39, "type mark I does not denote a type or a subtype" }, { 41, "does not match type of target INT_PTR" }, { 47, "type of value REC does not match type of" }, { 55, "type of allocator expresion INTEGER does not match" }, { 56, "type mark does not denote a type or a subtype" }, { 76, "unconstrained array type INT_PTR_ARRAY not allowed" }, { 84, "index constraint cannot be used with non-array type INTEGER" }, { 90, "invalid use of incomplete type FOO" }, { 97, "cannot determine type of allocator expression from the surro" }, { 105, "invalid use of incomplete type A" }, { 111, "prefix of a selected name with suffix ALL must have access " }, { 125, "access type PTP cannot designate protected type" }, { 127, "access type FTP cannot designate file type" }, { 133, "cannot read OUT parameter P" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_real) { input_from_file(TESTDIR "/sem/real.vhd"); const error_t expect[] = { { 16, "type of value MY_REAL does not match type of target" }, { 25, "conversion only allowed between closely related types" }, { 38, "type of right bound must be of some floating-point type " "but have INTEGER" }, { 39, "type of right bound must be of some integer type but have REAL" }, { 52, "range constraint of type BAD must be locally static" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_entity) { input_from_file(TESTDIR "/sem/entity.vhd"); const error_t expect[] = { { 23, "design unit E-INVALID not found in library WORK" }, { 26, "design unit WORK.PACK is not an entity" }, { 30, "design unit PACK is not an entity" }, { 61, "signal assignment statement not allowed inside passive process" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_PACKAGE, T_ARCH, T_ARCH, T_ENTITY, T_ARCH, T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_signal) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/signal.vhd"); const error_t expect[] = { { 14, "type of aggregate cannot be determined from the surrounding" }, { 15, "type of string literal cannot be determined from the surrou" }, { 16, "target of signal assignment must be a signal name" }, { 17, "others association not allowed in aggregate target" }, { 18, "cannot assign to input port P" }, { 22, "cannot be determined from the surrounding context" }, { 0, "context contains type BIT which is not a composite type" }, { 23, "target of signal assignment must be a signal name" }, { 24, "others association not allowed in aggregate target" }, { 25, "cannot assign to input port P" }, { 30, "aggregate element must be locally static name" }, { 40, "signal X is not a formal parameter and subprogram PROC1 [BIT] " "is not contained within a process statement" }, { 48, "implicit signal may not be assigned" }, { 54, "guard signal must have BOOLEAN type but found INTEGER" }, { 57, "guard expression must have type BOOLEAN but found BIT_VECTOR" }, { 64, "assignment guard must be a signal" }, { 65, "null waveform element is only valid when the target is" }, { 69, "guarded signal must have resolved subtype" }, { 78, "disconnection specification must denote a guarded signal" }, { 79, "disconnection specification must denote a guarded signal" }, { 80, "S$disconnect already declared in this region" }, // XXX { 80, "type of declared signal RBIT does not match type BIT_VECTOR in" }, { 81, "S$disconnect already declared in this region" }, // XXX { 81, "disconnection specification must have type TIME but found RBIT" }, { 83, "S$disconnect already declared in this region" }, // XXX { 83, "time expression in disconnection specificiation must be static" }, { 88, "invalid use of entity E" }, { 95, "target of signal assignment must be a signal name or aggregate" }, { 100, "signal X is identifed more than once in aggregate target" }, { 109, "guarded signal S cannot be the target of an unguarded " }, { 110, "aggregate target of signal assignment contains both guarded " "and unguarded signals" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_static) { input_from_file(TESTDIR "/sem/static.vhd"); const error_t expect[] = { { 42, "case choice must be locally static" }, { 65, "with port X of mode IN must be a globally static" }, { 85, "formal name must be locally static" }, { 104, "no visible declaration for BAD_FUNC" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); tree_t p1 = tree_stmt(a, 5); fail_unless(tree_kind(p1) == T_PROCESS); fail_unless(tree_ident(p1) == ident_new("P1")); tree_t tvalue = tree_value(tree_decl(p1, 0)); fail_unless(type_eq(tree_type(tvalue), std_type(NULL, STD_TIME))); fail_unless(tree_kind(tvalue) == T_FCALL); fail_if(tree_flags(tvalue) & TREE_F_LOCALLY_STATIC); fail_unless(tree_flags(tvalue) & TREE_F_GLOBALLY_STATIC); check_expected_errors(); } END_TEST START_TEST(test_subtype) { input_from_file(TESTDIR "/sem/subtype.vhd"); const error_t expect[] = { { 9, "expected type of range bound to be INTEGER but is" }, { 16, "no visible subprogram declaration for NOT_HERE" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse_and_check(T_PACKAGE); tree_t d = get_decl(p, "BIT_VECTOR_ARRAY"); type_t type = type_elem(tree_type(d)); fail_unless(type_kind(type) == T_SUBTYPE); tree_t right = tree_right(range_of(type, 0)); fail_if(type_is_universal(tree_type(right))); check_expected_errors(); } END_TEST START_TEST(test_universal) { input_from_file(TESTDIR "/sem/universal.vhd"); const error_t expect[] = { { 11, "operator \"*\" [REAL, universal_integer return REAL]" }, { 12, "operator \"*\" [REAL, universal_integer return REAL]" }, { 13, "operator \"*\" [universal_integer, universal_real return REAL]" }, { 14, "operator \"*\" [INTEGER, universal_real return REAL]" }, { 15, "operator \"/\" [REAL, universal_integer return REAL]" }, { 16, "operator \"/\" [universal_real, INTEGER return REAL]" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue52) { input_from_file(TESTDIR "/sem/issue52.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue58) { input_from_file(TESTDIR "/sem/issue58.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_spec1) { input_from_file(TESTDIR "/sem/spec1.vhd"); const error_t expect[] = { { 24, "E does not name a component" }, { 24, "duplicate specification for instance I1" }, { 32, "duplicate specification for instance I1" }, { 34, "design unit NOT_HERE not found in library WORK" }, { 36, "design unit WORK.P is not an entity" }, { 36, "duplicate specification for instance I3" }, { 22, "component mismatch for instance I1: expected C1" }, { 30, "specification may only be used with component instances" }, { 28, "instance BAD not found" }, { 40, "instance I5 not found" }, { 79, "component mismatch for instance I1: expected C1 but " }, { 81, "specification may only be used with component instances" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_PACKAGE, T_ENTITY, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue53) { input_from_file(TESTDIR "/sem/issue53.vhd"); parse_and_check(T_ENTITY); fail_if_errors(); } END_TEST START_TEST(test_supersede) { input_from_file(TESTDIR "/sem/supersede.vhd"); const error_t expect[] = { { 8, "design unit WORK.PORTLISTTEST replaces a previously " "analysed unit with the same name" }, { 18, "WORK.PORTLISTTEST has no port named A" }, { 19, "WORK.PORTLISTTEST has no port named B" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_implicit) { input_from_file(TESTDIR "/sem/implicit.vhd"); const error_t expect[] = { { 12, "parameter of attribute DELAYED must have type TIME" }, { 19, "parameter of attribute STABLE must be a static expression" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_config) { input_from_file(TESTDIR "/sem/config.vhd"); const error_t expect[] = { { 42, "no visible declaration for O" }, { 48, "instance BAD not found" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_CONFIGURATION); check_expected_errors(); } END_TEST START_TEST(test_protected) { opt_set_int(OPT_MISSING_BODY, 1); set_standard(STD_00); input_from_file(TESTDIR "/sem/protected.vhd"); const error_t expect[] = { { 13, "no visible declaration for NOT_HERE" }, { 19, "no visible declaration for BAD2" }, { 22, "object BOOLEAN is not a protected type declaration" }, { 25, "object NOW is not a protected type declaration" }, { 47, "SHAREDCOUNTER already declared in this region" }, { 7, "missing body for procedure INCREMENT [INTEGER]" }, { 8, "missing body for procedure DECREMENT [INTEGER]" }, { 9, "missing body for function VALUE [return INTEGER]" }, { 50, "subtypes may not have protected base types" }, { 52, "shared variable X must have protected type" }, { 56, "variable Z with protected type may not have an initial value" }, { 58, "function result subtype may not denote a protected type" }, { 64, "parameter with protected type cannot have a default value" }, { 118, "invalid use of name COUNTER" }, { 119, "too many positional parameters for subprogram DECREMENT [INTEG" }, { 124, "formal parameter X with protected type must have class VAR" }, { 126, "pure function GET_VALUE cannot call impure function VALUE" }, { 135, "may not assign to variable of a protected type" }, { 154, "missing body for procedure DOIT []" }, { 150, "missing body for protected type PROTECTED_T" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ARCH, T_PACKAGE, T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_protected2) { set_standard(STD_00); input_from_file(TESTDIR "/sem/protected2.vhd"); const error_t expect[] = { { 5, "constants may not have protected type" }, { 5, "deferred constant C was not given a value in the package body" }, { 20, "files may not be of protected type" }, { 22, "array T_PROTECTED_ARRAY cannot have element of protected type" }, { 26, "record field B cannot be of protected type" }, { 30, "signals may not have protected type" }, { 31, "attributes may not have protected type" }, { 35, "generic G1 may not have protected type" }, { 41, "port P1 with class signal cannot be declared with protected " "type T_PROTECTED" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_alias) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/alias.vhd"); const error_t expect[] = { { 10, "nonobject alias may not have a subtype indication" }, { 12, "type mark AX does not denote a type or a subtype" }, { 22, "no visible subprogram FOO matches signature [INTEGER " "return INTEGER]" }, { 23, "no visible subprogram FOO matches signature [BIT]" }, { 24, "name cannot be indexed or sliced" }, { 25, "no visible declaration for BLAH" }, { 32, "no visible subprogram BAR matches signature [INTEGER]" }, { 40, "ambiguous use of enumeration literal '1'" }, { 41, "no visible subprogram declaration for FOO_INT" }, { 42, "type of actual CHARACTER does not match formal X type BIT" }, { 43, "operand of qualified expression must have type CHARACTER" }, { 50, "aliased name is not static" }, { 68, "unexpected identifier while parsing subtype declaration" }, { 81, "object alias may not have multidimensional array type" }, { 83, "invalid use of alias INT_VECTOR" }, { 88, "aliased name is not static" }, { 89, "aliased name is not static" }, { -1, NULL } }; expect_errors(expect); tree_t arch = parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); tree_t x_decl = get_decl(arch, "X"); fail_unless(tree_kind(x_decl) == T_SIGNAL_DECL); } END_TEST START_TEST(test_issue102) { input_from_file(TESTDIR "/sem/issue102.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue105) { set_standard(STD_08); const error_t expect[] = { { 12, "case choice must be locally static" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/sem/issue105.vhd"); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue105a) { set_standard(STD_93); input_from_file(TESTDIR "/sem/issue105.vhd"); const error_t expect[] = { { 12, "case choice must be locally static" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue88) { input_from_file(TESTDIR "/sem/issue88.vhd"); const error_t expect[] = { { 31, "record type REC2 has no field named P" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue128) { input_from_file(TESTDIR "/sem/issue128.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue130) { input_from_file(TESTDIR "/sem/issue130.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue132) { input_from_file(TESTDIR "/sem/issue132.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue131) { input_from_file(TESTDIR "/sem/issue131.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue133) { input_from_file(TESTDIR "/sem/issue133.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue140) { set_standard(STD_02); input_from_file(TESTDIR "/sem/issue140.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH, T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue144) { input_from_file(TESTDIR "/sem/issue144.vhd"); const error_t expect[] = { { 11, "duplicate subprogram body FUN [return INTEGER]" }, { 20, "duplicate subprogram body PROC [INTEGER]" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue151) { input_from_file(TESTDIR "/sem/issue151.vhd"); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_duplicate) { input_from_file(TESTDIR "/sem/duplicate.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue165) { input_from_file(TESTDIR "/sem/issue165.vhd"); const error_t expect[] = { { 5, "no visible declaration for TYPE_T" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue162) { input_from_file(TESTDIR "/sem/issue162.vhd"); tree_t body = parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); fail_unless(tree_kind(body) == T_PACK_BODY); tree_t p = tree_decl(body, 2); fail_unless(tree_kind(p) == T_PROC_BODY); fail_unless(icmp(tree_ident(p), "CALLING_PROC")); fail_unless(tree_loc(tree_ref(tree_stmt(p, 0)))->first_line == 10); fail_unless(tree_loc(tree_ref(tree_stmt(p, 1)))->first_line == 10); fail_unless(tree_loc(tree_ref(tree_stmt(p, 2)))->first_line == 5); fail_unless(tree_loc(tree_ref(tree_stmt(p, 3)))->first_line == 5); fail_unless(tree_loc(tree_ref(tree_stmt(p, 4)))->first_line == 10); tree_t f1 = tree_decl(body, 5); fail_unless(tree_kind(f1) == T_FUNC_BODY); fail_unless(icmp(tree_ident(f1), "CALLING_FUN_WORKS")); tree_t c0 = tree_value(tree_param(tree_value(tree_stmt(f1, 0)), 0)); fail_unless(tree_loc(tree_ref(c0))->first_line == 29); tree_t c1 = tree_value(tree_param(tree_value(tree_stmt(f1, 1)), 0)); fail_unless(tree_loc(tree_ref(c1))->first_line == 23); tree_t c2 = tree_value(tree_param(tree_value(tree_stmt(f1, 2)), 0)); fail_unless(tree_loc(tree_ref(c2))->first_line == 23); tree_t f2 = tree_decl(body, 6); fail_unless(tree_kind(f2) == T_FUNC_BODY); fail_unless(icmp(tree_ident(f2), "CALLING_FUN")); tree_t c3 = tree_value(tree_stmt(f2, 0)); fail_unless(tree_loc(tree_ref(c3))->first_line == 29); } END_TEST START_TEST(test_issue178) { set_standard(STD_00); input_from_file(TESTDIR "/sem/issue178.vhd"); const error_t expect[] = { { 13, "wait statement not allowed in protected subprogram body" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue177) { input_from_file(TESTDIR "/sem/issue177.vhd"); const error_t expect[] = { { 9, "wait statement not allowed in function body" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_use) { input_from_file(TESTDIR "/sem/use.vhd"); const error_t expect[] = { { 25, "no visible declaration for MY_INT3" }, { 33, "design unit SPAM not found in library WORK" }, { 34, "unexpected integer while parsing use clause" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACK_BODY, T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_afunc) { set_standard(STD_02); input_from_file(TESTDIR "/sem/afunc.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); tree_t f = tree_value(tree_stmt(tree_stmt(a, 0), 0)); fail_unless(tree_kind(f) == T_FCALL); tree_t r = tree_value(tree_param(f, 0)); fail_unless(tree_kind(r) == T_ARRAY_REF); tree_t c = tree_value(r); fail_unless(tree_kind(c) == T_FCALL); fail_unless(icmp(tree_ident(c), "GET")); fail_unless(tree_params(c) == 0); fail_if_errors(); } END_TEST START_TEST(test_issue173) { input_from_file(TESTDIR "/sem/issue173.vhd"); lib_t other = lib_tmp("lib"); lib_set_work(other); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue174) { input_from_file(TESTDIR "/sem/issue174.vhd"); lib_t other = lib_tmp("lib"); lib_set_work(other); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_varinit) { input_from_file(TESTDIR "/sem/varinit.vhd"); parse_and_check(T_ENTITY, T_PACKAGE, T_ARCH, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue201) { set_standard(STD_00); input_from_file(TESTDIR "/sem/issue201.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue176) { input_from_file(TESTDIR "/sem/issue176.vhd"); const error_t expect[] = { { 36, "function FUN cannot call procedure PROC_WAIT_INDIRECT" }, { 37, "function FUN cannot call procedure PROC_WAIT which" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_context) { set_standard(STD_08); input_from_file(TESTDIR "/sem/context.vhd"); const error_t expect[] = { { 27, "no visible declaration for FOO.PACK" }, { 42, "design unit BLAH not found in library WORK" }, { 40, "library clause in a context declaration may not have logical" }, { 41, "context declaration use clause may not have WORK" }, { 42, "context declaration context reference may not have WORK" }, { -1, NULL } }; expect_errors(expect); lib_t foo = lib_tmp("foo"); lib_t bar = lib_tmp("bar"); lib_set_work(foo); parse_and_check(T_PACKAGE, T_CONTEXT, -1); lib_set_work(bar); parse_and_check(T_ENTITY, T_ENTITY, T_PACKAGE, T_CONTEXT, T_CONTEXT, T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_issue89) { input_from_file(TESTDIR "/sem/issue89.vhd"); tree_t e = parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); tree_t p = tree_stmt(e, 0); tree_t c1 = tree_stmt(p, 0); fail_unless(tree_kind(c1) == T_PCALL); fail_unless(tree_loc(tree_ref(c1))->first_line == 6); tree_t c2 = tree_stmt(p, 1); fail_unless(tree_kind(c2) == T_PCALL); fail_unless(tree_loc(tree_ref(c2))->first_line == 10); } END_TEST START_TEST(test_issue188) { input_from_file(TESTDIR "/sem/issue188.vhd"); const error_t expect[] = { { 9, "cannot declare a file object in a pure function" }, { 29, "cannot reference file F in pure function FILE_FUNC2" }, { 46, "call procedure CALL_READ_B which references a file object" }, { 66, "call procedure UPDATE_X which references a shared variable" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue219) { input_from_file(TESTDIR "/sem/issue219.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue220) { input_from_file(TESTDIR "/sem/issue220.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue224) { input_from_file(TESTDIR "/sem/issue224.vhd"); const error_t expect[] = { { 6, "parameter of class SIGNAL cannot have a default value" }, { 18, "formal A with class SIGNAL must be a name denoting a signal" }, { 24, "parameter of class VARIABLE with mode OUT or INOUT cannot have" }, { 34, "parameter of class VARIABLE with mode OUT or INOUT cannot have" }, { 43, "port with mode LINKAGE cannot have a default value" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ARCH, T_ARCH, T_ARCH, T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_issue221) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue221.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue236) { input_from_file(TESTDIR "/sem/issue236.vhd"); const error_t expect[] = { { 25, "missing actual for port B of mode IN without a default" }, { 37, "missing actual for port C with unconstrained array type" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ENTITY, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue239) { input_from_file(TESTDIR "/sem/issue239.vhd"); const error_t expect[] = { { 16, "default value must be a static expression" }, { 23, "default value must be a static expression" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_interfaces) { input_from_file(TESTDIR "/sem/interfaces.vhd"); const error_t expect[] = { { 13, "ports may not have variable class in VHDL-1993" }, { 17, "invalid object class constant for port P" }, { 21, "invalid object class file for port P" }, { 30, "invalid object class signal for generic P" }, { 34, "invalid object class variable for generic P" }, { 38, "invalid object class file for generic P" }, { 41, "subprogram formal parameters cannot have mode BUFFER" }, { 42, "subprogram formal parameters cannot have mode LINKAGE" }, { 44, "parameter of class CONSTANT must have mode IN" }, { 45, "parameter of class CONSTANT must have mode IN" }, { 47, "formal parameter C with class FILE must have file type" }, { 48, "formal parameter C with file type must have class FILE" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_file_and_access) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/file_and_access.vhd"); const error_t expect[] = { { 10, "constants may not have access type" }, { 11, "constants may not have a type with a subelement of access type" }, { 12, "constants may not have a type with a subelement of access type" }, { 13, "constants may not have file type" }, { 15, "signals may not have access type" }, { 16, "signals may not have a type with a subelement of access type" }, { 17, "signals may not have a type with a subelement of access type" }, { 18, "signals may not have file type" }, { 20, "attributes may not have access type" }, { 21, "attributes may not have a type with a subelement of access type" }, { 22, "attributes may not have a type with a subelement of access type" }, { 23, "attributes may not have file type" }, { 27, "generic G1 may not have access type" }, { 28, "generic G2 may not have a type with a subelement of access type" }, { 29, "generic G3 may not have a type with a subelement of access type" }, { 30, "generic G4 may not have file type" }, { 36, "port P1 cannot be declared with access type T_INT_ACCESS" }, { 37, "port P2 cannot be declared with type T_ACCESS_ARRAY which has " "a subelement of access type" }, { 38, "port P3 cannot be declared with type T_ACCESS_RECORD which has " "a subelement of access type" }, { 39, "port P4 cannot be declared with file type T_INT_FILE" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue264) { input_from_file(TESTDIR "/sem/issue264.vhd"); const error_t expect[] = { { 19, "case expression must have locally static subtype" }, { 23, "no matching operator \"&\" [INTEGER, INTEGER]" }, { 26, "ambiguous use of operator \"&\"" }, { 35, "case expression must have a discrete type or one dimensional" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue226) { input_from_file(TESTDIR "/sem/issue226.vhd"); const error_t expect[] = { { 20, "no visible declaration for FOO" }, { -1, NULL } }; expect_errors(expect); lib_t foo = lib_tmp("foo"); lib_t bar = lib_tmp("bar"); lib_set_work(foo); parse_and_check(T_PACKAGE, -1); lib_set_work(bar); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue197) { input_from_file(TESTDIR "/sem/issue197.vhd"); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue276) { set_standard(STD_02); input_from_file(TESTDIR "/sem/issue276.vhd"); lib_t foo = lib_tmp("foo"); lib_set_work(foo); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_dwlau) { input_from_file(TESTDIR "/sem/dwlau.vhd"); const error_t expect[] = { { 20, "FS is not a physical unit" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_jcore1) { input_from_file(TESTDIR "/sem/jcore1.vhd"); const error_t expect[] = { { 15, "no visible declaration for STD_LOGIC" }, { 33, "no visible declaration for MEM_WDATA_SEL_T" }, { 36, "no visible declaration for SHIFTFUNC_T" }, { 45, "no visible declaration for PIPELINE_EX_T" }, { 47, "no visible declaration for PIPELINE_WB_T" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue293) { input_from_file(TESTDIR "/sem/issue293.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue311) { input_from_file(TESTDIR "/sem/issue311.vhd"); const error_t expect[] = { { 32, "type of initial value WORK.P2.EVENT_TYPE does not match" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH, T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_foreign1) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/foreign1.vhd"); tree_t body = parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); tree_t decl = tree_decl(body, 0); fail_unless(icmp(tree_ident(decl), "PROC")); fail_unless(tree_flags(decl) & TREE_F_NEVER_WAITS); } END_TEST START_TEST(test_issue316) { input_from_file(TESTDIR "/sem/issue316.vhd"); const error_t expect[] = { { 38, "actual for formal REG_IN with class SIGNAL must be a name" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue350) { input_from_file(TESTDIR "/sem/issue350.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue246) { input_from_file(TESTDIR "/sem/issue246.vhd"); const error_t expect[] = { { 2, "index constraint cannot be used with non-array type INTEGER" }, { 3, "range constraint cannot be used with non-scalar type STRING" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue356) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/issue356.vhd"); const error_t expect[] = { { 17, "case expression must have locally static subtype" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue359) { input_from_file(TESTDIR "/sem/issue359.vhd"); const error_t expect[] = { { 8, "FOO already declared in this region" }, { 16, "cannot index non-array type INTEGER" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue359a) { input_from_file(TESTDIR "/sem/issue359a.vhd"); const error_t expect[] = { { 15, "procedure HOST_WRITE not allowed in an expression" }, { 15, "target of signal assignment must be a signal name or aggregate" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue368) { input_from_file(TESTDIR "/sem/issue368.vhd"); const error_t expect[] = { { 17, "with mode IN does not match mode OUT in specification" }, { 18, "parameter SIG_OUT of subprogram body IN_THROUGH_THE_OUT_DOOR" }, { 23, "parameter name Y in subprogram FOO body does not match name " "X in declaration" }, { 27, "class constant of subprogram body BAR" }, { 31, "parameter name Y in subprogram BAZ body does not match name X" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue363) { input_from_file(TESTDIR "/sem/issue363.vhd"); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_vests1) { input_from_file(TESTDIR "/sem/vests1.vhd"); lib_t foo = lib_tmp("foo"); lib_set_work(foo); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue369) { input_from_file(TESTDIR "/sem/issue369.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue326) { input_from_file(TESTDIR "/sem/issue326.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_issue232) { input_from_file(TESTDIR "/sem/issue232.vhd"); const error_t expect[] = { { 20, "sub-elements of composite port cannot be associated with OPEN" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue341) { input_from_file(TESTDIR "/sem/issue341.vhd"); const error_t expect[] = { { 23, "type of actual CHARACTER does not match formal B type BIT" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue340) { input_from_file(TESTDIR "/sem/issue340.vhd"); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue225) { input_from_file(TESTDIR "/sem/issue225.vhd"); tree_t a = parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE, T_PACKAGE, T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); fail_if_errors(); fail_unless(tree_contexts(a) == 3); tree_t e = tree_primary(a); fail_unless(tree_contexts(e) == 3); } END_TEST START_TEST(test_issue377_strict) { input_from_file(TESTDIR "/sem/issue377.vhd"); const error_t expect[] = { { 20, "ambiguous use of operator \"=\"" }, { 29, "ambiguous use of operator \"=\"" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue377_relaxed) { opt_set_int(OPT_RELAXED, 1); input_from_file(TESTDIR "/sem/issue377.vhd"); tree_t a1 = parse_and_check(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH, -1); { tree_t s0 = tree_stmt(a1, 0); fail_unless(tree_kind(s0) == T_CONCURRENT); tree_t fcall = tree_value(tree_stmt(s0, 0)); fail_unless(tree_kind(fcall) == T_FCALL); tree_t decl = tree_ref(fcall); fail_unless(tree_subkind(decl) == S_USER); fail_unless(tree_ident(decl) == ident_new("\"=\"")); } tree_t a2 = parse_and_check(T_ARCH); { tree_t s0 = tree_stmt(a2, 0); fail_unless(tree_kind(s0) == T_CONCURRENT); tree_t fcall = tree_value(tree_stmt(s0, 0)); fail_unless(tree_kind(fcall) == T_FCALL); tree_t decl = tree_ref(fcall); fail_unless(tree_subkind(decl) == S_USER); fail_unless(tree_ident(decl) == ident_new("\"=\"")); } fail_if_errors(); } END_TEST START_TEST(test_issue386) { input_from_file(TESTDIR "/sem/issue386.vhd"); const error_t expect[] = { { 7, "type of parameter BYTE does not match type BIT_VECTOR" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_textio) { input_from_file(TESTDIR "/sem/textio.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_vital1) { input_from_file(TESTDIR "/sem/vital1.vhd"); parse_and_check(T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_physical) { opt_set_int(OPT_MISSING_BODY, 0); input_from_file(TESTDIR "/sem/physical.vhd"); const error_t expect[] = { { 7, "the abstract literal portion of a secondary unit declaration" }, { 14, "secondary unit BAR must have type MYOTHERTIME" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_block) { input_from_file(TESTDIR "/sem/block.vhd"); const error_t expect[] = { { 19, "missing actual for generic G1 without a default" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue407) { input_from_file(TESTDIR "/sem/issue407.vhd"); const error_t expect[] = { { 28, "expected type of range bound to be NATURAL but is BIT" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH); tree_t s0 = tree_stmt(a, 0); fail_unless(tree_kind(s0) == T_CONCURRENT); tree_t sel = tree_stmt(s0, 0); fail_unless(tree_kind(sel) == T_SELECT); tree_t alt0 = tree_stmt(sel, 0); fail_unless(tree_kind(alt0) == T_ALTERNATIVE); tree_t w = tree_waveform(tree_stmt(alt0, 0), 0); tree_t assoc = tree_assoc(tree_value(w), 0); fail_unless(tree_kind(assoc) == T_ASSOC); fail_unless(tree_subkind(assoc) == A_RANGE); check_expected_errors(); } END_TEST START_TEST(test_resolution) { set_standard(STD_08); input_from_file(TESTDIR "/sem/resolution.vhd"); const error_t expect[] = { { 6, "no visible subprogram declaration for BIT_VECTOR" }, { 10, "not a valid resolution function for type MY_UTYPE" }, { 17, "non-record type MY_UTYPE_VECTOR may not have record element" }, { 29, "non-composite type MY_UTYPE may not have element resolution" }, { 33, "resolution function name PROC is not a function" }, { 37, "parameter of resolution function must be an array of MY_UTYPE" }, { 41, "result of resolution function must be MY_UTYPE but have UREC" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_osvvm1) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/sem/osvvm1.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_osvvm2) { set_standard(STD_08); input_from_file(TESTDIR "/sem/osvvm2.vhd"); parse_and_check(T_PACKAGE, T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_osvvm3) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/sem/osvvm3.vhd"); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACK_BODY); fail_if_errors(); } END_TEST START_TEST(test_murax) { input_from_file(TESTDIR "/sem/murax.vhd"); tree_t p1 = parse(); fail_if(p1 == NULL); fail_unless(tree_kind(p1) == T_PACKAGE); lib_put(lib_work(), p1); tree_t p2 = parse(); fail_if(p2 == NULL); fail_unless(tree_kind(p2) == T_PACKAGE); lib_put(lib_work(), p2); tree_t e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); tree_t a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_unless(parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_driving) { input_from_file(TESTDIR "/sem/driving.vhd"); const error_t expect[] = { { 15, "prefix of attribute DRIVING must denote a signal" }, { 17, "prefix of attribute DRIVING must denote a signal or a port " "with mode IN, INOUT, or BUFFER" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_error1) { input_from_file(TESTDIR "/sem/error1.vhd"); const error_t expect[] = { { 25, "unexpected ; while parsing port map aspect, expecting" }, { 23, "missing actual for port Y of mode IN without a default" }, { 26, "type of aggregate cannot be determined from the surrounding " }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_tc251) { input_from_file(TESTDIR "/sem/tc251.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_linkage) { input_from_file(TESTDIR "/sem/linkage.vhd"); const error_t expect[] = { { 8, "linkage port X may not be updated except" }, { 9, "linkage port X may not be read except" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_error2) { input_from_file(TESTDIR "/sem/error2.vhd"); const error_t expect[] = { { 2, "unexpected ) while parsing element association, expecting one of " "**, | or =>" }, { 2, "type of aggregate cannot be determined from the surrounding " }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_error3) { input_from_file(TESTDIR "/sem/error3.vhd"); const error_t expect[] = { { 7, "unexpected integer while parsing type definition" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_tc792) { input_from_file(TESTDIR "/sem/tc792.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ENTITY, T_ENTITY, T_ENTITY, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_vhdl2008) { set_standard(STD_08); input_from_file(TESTDIR "/sem/vhdl2008.vhd"); const error_t expect[] = { { 13, "type of condition must be BOOLEAN but have INTEGER" }, { 14, "expected type of conditional expression to be INTEGER " "but is BOOLEAN" }, { 31, "case choice must be locally static" }, { 40, "no visible declaration for BAZ" }, { 41, "SUBTYPE attribute is only allowed in a type mark" }, { 49, "case choice must be globally static" }, { 59, "range choice expression must have same type as aggregate" }, { 70, "conversion only allowed between closely related types" }, { 86, "no visible declaration for Q" }, { 102, "expression associated with unconstrained formal port P1 " "must have a globally static subtype" }, { 109, "parameter interface list cannot contain type interface" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_genpack) { set_standard(STD_08); input_from_file(TESTDIR "/sem/genpack.vhd"); const error_t expect[] = { { 45, "unit WORK.ENT is not an uninstantiated package" }, { 46, "unit STD.STANDARD is not an uninstantiated package" }, { 47, "design unit NOT_HERE not found in library WORK" }, { 48, "missing actual for generic FRAC without a default expression" }, { 77, "unit STD.STANDARD is not an uninstantiated package" }, { 82, "actual for generic FIXED_PKG is not an instantiated package " }, { 91, "expected an instance of package WORK.MYFIXED but have instance " "of WORK.MYFLOAT for generic FIXED_PKG" }, { 94, "actual for generic FIXED_PKG is not an instantiated package" }, { 99, "missing actual for generic package FIXED_PKG" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_INST, T_ENTITY, T_ARCH, T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_INST, T_ARCH, T_PACKAGE, T_PACK_INST, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_gentype) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/sem/gentype.vhd"); const error_t expect[] = { { 10, "range constraint cannot be used with non-scalar type T" }, { 66, "type of actual universal_real does not match type T of" }, { 69, "positional generic actual is associated with implicit generic " "subprogram \"=\" for type T" }, { 69, "positional generic actual is associated with implicit generic " "subprogram \"/=\" for type T" }, { 72, "unexpected integer while parsing name" }, { 72, "type of actual universal_integer does not match type T of " }, { 81, "no visible subprogram MY_FUNC matches signature [T return T]" }, { 80, "missing actual for generic type T" }, { 84, "no visible subprogram MY_FUNC matches signature [T return T]" }, { 83, "no visible subprogram PROC1 matches signature [T]" }, { 90, "ambiguous use of name MY_FUNC" }, { 90, "universal_integer does not match type T of formal generic INIT" }, { 93, "invalid use of label U12" }, { 93, "universal_integer does not match type T of formal generic INIT" }, { 96, "invalid use of incomplete type INCOMPLETE" }, { 96, "universal_integer does not match type T of formal generic INIT" }, { 95, "no visible subprogram \"=\" matches signature [T, T return BOO" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_record2008) { set_standard(STD_08); input_from_file(TESTDIR "/sem/record2008.vhd"); const error_t expect[] = { { 10, "declaration of signal S1 cannot have unconstrained type REC1" }, { 12, "record type REC1 has no field named Y" }, { 13, "record type REC1 has no field named R2" }, { 22, "duplicate record element constraint for field X" }, { 23, "record type REC2 has no field named P" }, { 24, "field B in record element constraint is already constrained" }, { 25, "declaration of signal R8 cannot have unconstrained type REC2" }, { 30, "declaration of signal R10 cannot have unconstrained type T2" }, { 34, "array element is already constrained" }, { 41, "declaration of signal R12 cannot have unconstrained type REC3" }, { 43, "declaration of signal R14 cannot have unconstrained type REC3" }, { 110, "variable A1 cannot have unconstrained type REC1_ARRAY" }, { 122, "declaration of variable R cannot have unconstrained type " "INTERLACED16BSIGNAL" }, { 127, "no visible declaration for NOT_AN_ARRAY" }, { 127, "unexpected open while parsing primary, expecting one of" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_osvvm4) { input_from_file(TESTDIR "/sem/osvvm4.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_agg2008) { set_standard(STD_08); input_from_file(TESTDIR "/sem/agg2008.vhd"); const error_t expect[] = { { 16, "type of positional association universal_real does not match " "aggregate element type INTEGER or the aggregate type itself " "INTEGER_VECTOR" }, { 17, "type of named association BOOLEAN does not match aggregate " "element type INTEGER" }, { 19, "type of named association INTEGER_VECTOR does not match " "aggregate element type INTEGER" }, { 30, "second dimension of 2 dimensional array type INT2D must be " "specified by a sub-aggregate, string, or bit-string literal" }, { 71, "variable V1 cannot have unconstrained type T_BYTE_ARRAY" }, { 73, "array constraint cannot be used with non-array type INTEGER" }, { 74, "array element is already constrained" }, { 75, "array element is already constrained" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_force) { set_standard(STD_08); input_from_file(TESTDIR "/sem/force.vhd"); const error_t expect[] = { { 13, "variable V is not a valid target of simple force assignment" }, { 14, "type of force expression universal_real does not match type " "of target INTEGER" }, { 15, "target of a simple force assignment may not be an aggregate" }, { 29, "force mode OUT may not be used with target of mode IN" }, { 30, "target of simple force assignment must be a signal name" }, { 31, "force expression BOOLEAN does not match type of target BIT" }, { 39, "variable V is not a valid target of simple release assignment" }, { 40, "target of a simple release assignment may not be an aggregate" }, { -1, NULL } }; expect_errors(expect); tree_t a = parse_and_check(T_ENTITY, T_ARCH); tree_t s4 = tree_stmt(tree_stmt(a, 0), 4); fail_unless(tree_kind(s4) == T_FORCE); fail_unless(tree_subkind(s4) == PORT_IN); check_expected_errors(); } END_TEST START_TEST(test_ename) { set_standard(STD_08); input_from_file(TESTDIR "/sem/ename.vhd"); const error_t expect[] = { { 3, "relative pathname has no enclosing concurrent region" }, { 16, "initial value BIT does not match type of declaration INTEGER" }, { 22, "target of variable assignment must be a variable name or " }, { 25, "external name Y is not a valid target of simple release " }, { 26, "generate index must be a static expression" }, { 40, "actual for formal X with class VARIABLE must be a name denoting " "a variable" }, { 44, "an alias of an external name cannot have a subtype indication" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_mcase) { set_standard(STD_08); input_from_file(TESTDIR "/sem/mcase.vhd"); const error_t expect[] = { { 19, "type of expression in a matching case statement must be BIT, " "STD_ULOGIC, or a one-dimensional array of these types" }, { 38, "case expression must have a discrete type or one dimensional " "character array type" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_generics2008) { set_standard(STD_08); input_from_file(TESTDIR "/sem/generics2008.vhd"); const error_t expect[] = { { 5, "no visible declaration for D" }, { 7, "no visible declaration for E" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_osvvm5) { set_standard(STD_08); input_from_file(TESTDIR "/sem/osvvm5.vhd"); const error_t expect[] = { { 48, "cannot use an uninstantiated package" }, { -1, NULL } }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_PACK_INST, T_PACK_INST, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue465) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue465.vhd"); const error_t expect[] = { { 1, "design unit TESTTEST_PKG not found in library WORK" }, { 8, "design unit depends on WORK.TEST2_PKG which was analysed with" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse(); fail_if(p == NULL); fail_unless(tree_kind(p) == T_PACKAGE); lib_put_error(lib_work(), p); tree_t b = parse(); fail_if(b == NULL); fail_unless(tree_kind(b) == T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_gensub) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/sem/gensub.vhd"); const error_t expect[] = { { 21, "function NOT_GENERIC is not an uninstantiated subprogram" }, { 24, "subprogram NO_BODY cannot be instantiated until its body has " "been analysed" }, { 42, "type of actual universal_integer does not match type T of " "formal generic N" }, { 42, "no visible subprogram \"+\" matches signature [T, T return T]" }, { 44, "cannot call uninstantiated function ADDER" }, { 50, "cannot call uninstantiated procedure DO_STUFF" }, { 57, "no applicable subprogram declaration for \"+\"" }, { 0, "expecting Q" }, { 0, "there are 10 visible overloads of \"+\"" }, { 69, "subtype of generic X does not match type INTEGER in spec" }, { 75, "subprogram TEST2 declaration has 1 generic but body has 2" }, { 93, "multiple visible uninstantiated subprograms with name TEST1" }, { 93, "TEST_ERROR has no generic named T" }, { 94, "no visible uninstantiated subprogram declaration for TEST444" }, { 94, "TEST_ERROR2 has no generic named T" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue482) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue482.vhd"); parse_and_check(T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_gensub2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_08); input_from_file(TESTDIR "/sem/gensub2.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_altera1) { input_from_file(TESTDIR "/sem/altera1.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue509) { opt_set_int(OPT_RELAXED, 1); input_from_file(TESTDIR "/sem/issue509.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_genpack2) { set_standard(STD_08); input_from_file(TESTDIR "/sem/genpack2.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACK_INST, T_PACKAGE, T_PACK_BODY, T_PACK_INST, T_ENTITY, T_ARCH, T_PACKAGE, T_PACKAGE, T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_issue655) { input_from_file(TESTDIR "/sem/issue655.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue659) { input_from_file(TESTDIR "/sem/issue659.vhd"); const error_t expect[] = { { 8, "cannot assign to parameter Y with mode IN" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue660) { input_from_file(TESTDIR "/sem/issue660.vhd"); const error_t expect[] = { { 11, "class of subprogram BLAH parameter X was constant in " "specification but default in body" }, { 16, "mode indication of subprogram DOSOMETHING parameter X was " "default in specification but IN in body" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_genpack3) { set_standard(STD_08); input_from_file(TESTDIR "/sem/genpack3.vhd"); const error_t expect[] = { { 21, "WORK.PACK1 has no generic named Z" }, { 31, "generic X in package WORK.PACK2 does not have a default value" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_condexpr) { set_standard(STD_19); input_from_file(TESTDIR "/sem/condexpr.vhd"); const error_t expect[] = { { 7, "type of condition must be BOOLEAN but have universal_integer" }, { 8, "expected type of conditional expression to be INTEGER " "but is universal_real" }, { 24, "expected return type INTEGER but have universal_real" }, { 25, "conditional return statement without value is only valid " "inside a procedure" }, { 31, "type of condition must be BOOLEAN but have INTEGER" }, { 34, "return statement not allowed outside subprogram" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_72b) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_72b.vhd"); const error_t expect[] = { { 37, "function IOTA with return identifier RESULT_T cannot be called" }, { 40, "type of value RESULT_T does not match type of target INTEGER" }, { 41, "function IOTA with return identifier RESULT_T cannot be called " "in this context as the result subtype is not known" }, { 42, "function IOTA with return identifier RESULT_T cannot be "}, { 47, "type mark of return identifier must denote an unconstrained " }, { 55, "type mark of return identifier must denote an unconstrained " }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_47) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_47.vhd"); const error_t expect[] = { { 35, "formal variable port X must have mode INOUT" }, { 36, "formal variable port Y must have protected type" }, { 44, "actual associated with port X of mode OUT" }, { 44, "formal variable port Y must either be a shared variable " "or a formal variable port of another design entity" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_45a) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_45a.vhd"); const error_t expect[] = { { 20, "record type REC_T has no field named X" }, { 23, "missing mode view element defintion for B, C" }, { 27, "subtype indication of a mode view declaration must denote " "a record type" }, { 37, "subtype indication of a mode view declaration must denote an " "unresolved record type" }, { 42, "record type REC_T has no field named INTEGER" }, { 0, "type REC_T has fields A, B, C, and D" }, { 48, "duplicate mode view element definition for field B" }, { 51, "type mark MASTER1 does not denote a type or a subtype" }, { 53, "prefix of 'CONVERSE attribute must be a named mode view or " }, { 64, "name in mode view indication does not denote a mode view" }, { 65, "subtype INTEGER is not compatible with mode view MASTER1" }, { 74, "element mode indication cannot have mode LINKAGE" }, { 88, "name in element mode view indication of field R does not " }, { 94, "port Y with array mode view indication has non-array type REC_T" }, { 95, "subtype BIT is not compatible with mode view MASTER1" }, { 105, "R with array mode view indication has non-array type REC_T" }, { 109, "S subtype REC_VEC_T is not compatible with mode view MASTER1" }, { 157, "cannot assign to element B of port R which has mode IN from " "mode view indication" }, { 158, "cannot assign to port R with mode view indication as one or " "more sub-elements have mode IN" }, { 160, "cannot assign to element B of port A which has mode IN from " "mode view indication" }, { 165, "mode view indication of formal port P element A is not " "compatible with actual" }, { 167, "actual associated with port P with mode view indication must " "be a static signal name" }, { 172, "name in mode view indication of parameter X does not denote a " "mode view" }, { 173, "parameter X with array mode view indication has non-array " "type REC_T" }, { 174, "subtype INTEGER is not compatible with mode view MASTER_REC_T" }, { 177, "mode view indication of formal parameter X element A is not " "compatible with actual" }, { 178, "missing actual for formal parameter X with mode view indication " "MASTER_REC_T" }, { 181, "actual for port P with mode view indication MASTER_REC_T" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_18) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_18.vhd"); const error_t expect[] = { { 7, "prefix of 'DESIGNATED_SUBTYPE attribute does not have a type" }, { 8, "prefix of 'DESIGNATED_SUBTYPE attribute must be an access " "or file type" }, { 15, "type of initial value BOOLEAN does not match type of " "declaration INTEGER" }, { 23, "type of initial value universal_integer does not match type of " "declaration BOOLEAN" }, { 24, "'INDEX parameter for type INT_MAP must be between 1 and 2" }, { 25, "'INDEX parameter for type INT_MAP must be between 1 and 2" }, { 26, "prefix of 'INDEX attribute must be an array type" }, { 29, "only integer literals are supported for 'INDEX parameter" }, { 38, "prefix of attribute IMAGE must be a type" }, { 40, "prefix of attribute LENGTH must be an array or a discrete " "type but have type REAL" }, { 41, "cannot use attribute IMAGE with non-representable type " "FILE_OF_INT" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue713) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue713.vhd"); const error_t expect[] = { { 17, "invalid use of type A" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACK_INST); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_41) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_41.vhd"); const error_t expect[] = { { 20, "value SUBTYPE_MIRROR does not match type of target INTEGER" }, { 21, "value VALUE_MIRROR does not match type of target INTEGER" }, { 25, "prefix of attribute REFLECT is not a type mark or an object " "with a type" }, { 27, "prefix of 'REFLECT attribute must be a fully constrained " }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_14a) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_14a.vhd"); const error_t expect[] = { { 35, "prefix of a selected name with suffix ALL must have access type" }, { 38, "protected type PT cannot have initial value" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_19) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_19.vhd"); const error_t expect[] = { { 6, "declaration of signal S2 without an initial value cannot " "have unconstrained type INTEGER_VECTOR" }, { 11, "declaration of variable V2 without an initial value cannot " "have unconstrained type INTEGER_VECTOR" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_07) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_07.vhd"); const error_t expect[] = { { 16, "no visible declaration for C" }, { 18, "unexpected shared while parsing process declarative item" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_23) { set_standard(_i); input_from_file(TESTDIR "/sem/lcs2016_23.vhd"); const error_t expect[] = { { 14, "configuration declaration FOO_CFG must reside in the same " "library as entity FOO_E" }, { -1, NULL } }; expect_errors(expect); lib_t foo = lib_tmp("foo"); lib_set_work(foo); parse_and_check(T_ENTITY, T_ARCH, -1); lib_t bar = lib_tmp("bar"); lib_set_work(bar); parse_and_check(T_CONFIGURATION); if (_i < STD_19) check_expected_errors(); else fail_if_errors(); } END_TEST START_TEST(test_config2) { input_from_file(TESTDIR "/sem/config2.vhd"); const error_t expect[] = { { 55, "generic G in component COMP has no corresponding generic in " "entity WORK.OTHER" }, { 55, "generic G2 in component COMP has type BIT which is incompatible " "with type REAL in entity WORK.OTHER" }, { 55, "generic GG in entity WORK.OTHER without a default value has no " "corresponding generic in component COMP" }, { 55, "port I in component COMP has no corresponding port in entity " "WORK.OTHER" }, { 55, "port O in component COMP has no corresponding port in entity " }, { 55, "port K in component COMP has no corresponding port in entity " }, { 55, "port ZZ in component COMP has type REAL which is incompatible " "with type INTEGER in entity WORK.OTHER" }, { 55, "port II in entity WORK.OTHER without a default value has no " "corresponding port in component COMP" }, { 55, "port OO in entity WORK.OTHER without a default value has no " "corresponding port in component COMP" }, { 58, "port K in component COMP has no corresponding port in entity " "WORK.SUB" }, { 58, "port ZZ in component COMP has no corresponding port in entity " }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH, T_CONFIGURATION); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_02) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_02.vhd"); const error_t expect[] = { { 4, "pure function parameters must have mode IN" }, { 6, "class of pure function parameters must be CONSTANT, SIGNAL, " "or FILE" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_04) { set_standard(_i); input_from_file(TESTDIR "/sem/lcs2016_04.vhd"); const error_t expect[] = { { 9, "parameters of protected type methods cannot be of an access" }, { 10, "parameters of protected type methods cannot be of an access" }, { 11, "parameters of protected type methods cannot be of a file type" }, { 12, "return type of a protected type method cannot be of a file "}, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); if (_i < STD_19) check_expected_errors(); else fail_if_errors(); } END_TEST START_TEST(test_lcs2016_75) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_75.vhd"); const error_t expect[] = { { 38, "conversion only allowed between closely related types" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_alias2) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_19); input_from_file(TESTDIR "/sem/alias2.vhd"); const error_t expect[] = { { 39, "no visible method FOOBAR in protected type T_TEST matches " "signature []" }, { 40, "no visible declaration for XX" }, { 42, "invalid use of name INCREMENT" }, { 42, "aliased name is not static" }, { 53, "function GET_BITS with return identifier RV cannot be called " "in this context as the result subtype is not known" }, { 54, "function GET_BITS with return identifier RV cannot be called" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_33) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_33.vhd"); const error_t expect[] = { { 17, "an alias declared within a protected type declaration must " "denote a protected type method" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_59) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_59.vhd"); const error_t expect[] = { { 52, "signals may not have access type" }, { 53, "signals may not have file type" }, { 63, "cannot map type BIT_VECTOR to generic interface type T which " "requires a scalar type" }, { 85, "cannot map type REAL to generic interface type T which " "requires a discrete type" }, { 96, "cannot map type BIT to generic interface type T which " "requires an integer type" }, { 112, "cannot map type INTEGER to generic interface type T which " "requires a floating-point type" }, { 124, "cannot map type INTEGER to generic interface type T which " "requires a physical type" }, { 146, "cannot map type REAL to generic interface type T which " "requires an access type" }, { 149, "cannot map type T7 to generic interface type T as the " "designated type (an anonymous type) is not a scalar type" }, { 155, "cannot map type T_INT_PTR to generic interface type T " "as the designated type INTEGER is not BIT" }, { 201, "cannot map type REAL to generic interface type T which " "requires a file type" }, { 210, "cannot map type T_INT_FILE to generic interface type T as " "the designated type INTEGER is not BIT" }, { 228, "cannot map type INTEGER to generic interface type T which " "requires an array type" }, { 231, "cannot map type T_BOOL_MAP to generic interface type T as " "the index type BOOLEAN of the first dimension is not NATURAL" }, { 234, "cannot map type T6 to generic interface type T as the element " "type (an anonymous type) is not a discrete type" }, { 237, "cannot map type T_BOOL_MAP to generic interface type T as the " "index type BOOLEAN of the first dimension is not an integer type" }, { 240, "cannot map type T_TIME_MAP to generic interface type T as the " "element type TIME is not BOOLEAN" }, { 243, "cannot map type T_MATRIX to generic interface type T as it has " "2 dimensions but the incomplete type definition has 1" }, { 247, "declaration of variable V2 without an initial value cannot have " "unconstrained type T6" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue770) { opt_set_int(OPT_RELAXED, 1); input_from_file(TESTDIR "/sem/issue770.vhd"); const error_t expect[] = { { 7, "class of subprogram IDENTITY_A parameter A was default in " "specification but constant in body" }, { 0, "parameter A declared with constant class in body" }, { 0, "parameter A declared with default class in specification" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_genpack4) { set_standard(STD_08); input_from_file(TESTDIR "/sem/genpack4.vhd"); parse_and_check(T_PACKAGE, T_PACKAGE, T_PACKAGE); fail_if_errors(); } END_TEST START_TEST(test_lcs2016_16) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_16.vhd"); const error_t expect[] = { { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY); check_expected_errors(); } END_TEST START_TEST(test_spec2) { input_from_file(TESTDIR "/sem/spec2.vhd"); const error_t expect[] = { { 33, "generic G1 in entity WORK.ENT1 without a default value has no " "corresponding generic in component COMP1" }, { 44, "generic G3 in component COMP2 has no corresponding generic in " "entity WORK.ENT1" }, { 44, "generic G1 in entity WORK.ENT1 without a default value has no " "corresponding generic in component COMP2" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_CONFIGURATION, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_incomplete) { opt_set_int(OPT_MISSING_BODY, 0); set_standard(STD_02); input_from_file(TESTDIR "/sem/incomplete.vhd"); const error_t expect[] = { { 6, "invalid use of incomplete type T1" }, { 30, "invalid use of incomplete type T1" }, { 31, "invalid use of incomplete type T1" }, { 34, "invalid use of incomplete type T1" }, { 37, "invalid use of incomplete type T1" }, { 38, "invalid use of incomplete type T1" }, { 40, "invalid use of incomplete type T1" }, { 46, "invalid use of incomplete type T1" }, { 50, "invalid use of incomplete type T1" }, { 51, "invalid use of incomplete type T1" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue884) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue884.vhd"); const error_t expect[] = { { 7, "cannot create driver for external name as subprogram PROC [] " "is not contained within a process statement" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_genpack5) { set_standard(STD_08); input_from_file(TESTDIR "/sem/genpack5.vhd"); const error_t expect[] = { { 69, "type of actual INTEGER does not match type T of formal port X" }, { 0, "generic type T is mapped to REAL" }, { 82, "generic package P in component SUB does not match entity " "WORK.SUB2" }, { 0, "declaration of generic P in component as instance of WORK.ADDER" }, { 0, "declaration of generic P in entity as instance of WORK.ADDER2" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY, T_PACKAGE, T_ENTITY, T_ARCH, T_ENTITY, T_ENTITY, T_ARCH, T_CONFIGURATION); check_expected_errors(); } END_TEST START_TEST(test_issue945) { input_from_file(TESTDIR "/sem/issue945.vhd"); const error_t expect[] = { { 51, "type of conversion function actual LARGER_RECORD does not match " "formal R type TEST_RECORD" }, { 58, "type of conversion function actual BIT does not match formal R " "type TEST_RECORD" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue958) { input_from_file(TESTDIR "/sem/issue958.vhd"); const error_t expect[] = { { 10, "mode indication of subprogram \"-\" parameter ARG was IN " "in specification but default in body" }, { 14, "mode indication of subprogram \"+\" parameter LHS was IN " "in specification but default in body" }, { 18, "declaration of parameter RHS in subprogram body does not " "match specification" }, { 0, "RHS appears first in identifier list" }, { 0, "the --relaxed option downgrades this to a warning" }, { 0, "RHS appears second in identifier list" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue965) { input_from_file(TESTDIR "/sem/issue965.vhd"); const error_t expect[] = { { 19, "signal S is not a formal parameter and subprogram " "DO_SOMETHING [] is not contained within a process statement" }, { 20, "signal S is not a formal parameter and subprogram " "DO_SOMETHING [] is not contained within a process statement" }, { 21, "signal S is not a formal parameter and subprogram " "DO_SOMETHING [] is not contained within a process statement" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_lcs2016_49) { set_standard(STD_19); input_from_file(TESTDIR "/sem/lcs2016_49.vhd"); const error_t expect[] = { { 20, "procedure PROC1 not allowed in an expression" }, { 21, "type of actual universal_integer does not match formal X " "type BIT" }, { 22, "type mark FUNC1 does not denote a type or a subtype" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue980) { input_from_file(TESTDIR "/sem/issue980.vhd"); const error_t expect[] = { { 10, "return type of function body FOO does not match type T_SUB in " "specification" }, { 0, "body has return type T_ENUM" }, { 0, "specification has return type T_SUB" }, { 14, "subtype of parameter X does not match type T_SUB" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue1010) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1010.vhd"); const error_t expect[] = { { 8, "cannot reference external name with class signal in pure " "function GET_ABS_EXT" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST START_TEST(test_issue1025) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1025.vhd"); parse_and_check(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue1020) { input_from_file(TESTDIR "/sem/issue1020.vhd"); const error_t expect[] = { { 13, "invalid formal name V" }, { 13, "sorry, conversions are not yet supported here" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_missingwait) { opt_set_int(OPT_MISSING_WAIT, 1); set_standard(STD_08); input_from_file(TESTDIR "/sem/missingwait.vhd"); const error_t expect[] = { { 23, "potential infinite loop in process with no sensitivity list and" " no wait statements" }, { 53, "potential infinite loop in process with no sensitivity list and" " no wait statements" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue1024) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1024.vhd"); parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); } END_TEST START_TEST(test_issue1038) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1038.vhd"); const error_t expect[] = { { 2, "cannot use attribute HIGH as range" }, { 3, "cannot use attribute LOW as range" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue1057) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1057.vhd"); const error_t expect[] = { { 7, "duplicate index constraint for type MY_REC" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue1067) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1067.vhd"); const error_t expect[] = { { 10, "object prefix of attribute RANGE must be an array" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_ENTITY, T_ARCH); check_expected_errors(); } END_TEST START_TEST(test_issue1173) { opt_set_int(OPT_RELAXED, 1); set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1173.vhd"); const error_t expect[] = { { 8, "type mark cannot be the prefix of a selected name" }, { 17, "invalid use of type T_TEST_2" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_issue1212) { set_standard(STD_08); input_from_file(TESTDIR "/sem/issue1212.vhd"); const error_t expect[] = { { 11, "cannot read OUT signal parameter CLK" }, { -1, NULL } }; expect_errors(expect); parse_and_check(T_PACKAGE, T_PACK_BODY); check_expected_errors(); } END_TEST Suite *get_sem_tests(void) { Suite *s = suite_create("sem"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_integer); tcase_add_test(tc_core, test_ports); tcase_add_test(tc_core, test_scope); tcase_add_test(tc_core, test_ambiguous); tcase_add_test(tc_core, test_const); tcase_add_test(tc_core, test_const2); tcase_add_test(tc_core, test_std); tcase_add_test(tc_core, test_wait); tcase_add_test(tc_core, test_func); tcase_add_test(tc_core, test_array); tcase_add_test(tc_core, test_assert); tcase_add_test(tc_core, test_generics); tcase_add_test(tc_core, test_seq); tcase_add_test(tc_core, test_conc); tcase_add_test(tc_core, test_procedure); tcase_add_test(tc_core, test_concat); tcase_add_test(tc_core, test_conv); tcase_add_test(tc_core, test_attr); tcase_add_test(tc_core, test_generate); tcase_add_test(tc_core, test_record); tcase_add_test(tc_core, test_file); tcase_add_test(tc_core, test_access); tcase_add_test(tc_core, test_real); tcase_add_test(tc_core, test_entity); tcase_add_test(tc_core, test_signal); tcase_add_test(tc_core, test_static); tcase_add_test(tc_core, test_subtype); tcase_add_test(tc_core, test_universal); tcase_add_test(tc_core, test_issue52); tcase_add_test(tc_core, test_issue58); tcase_add_test(tc_core, test_spec1); tcase_add_test(tc_core, test_issue53); tcase_add_test(tc_core, test_supersede); tcase_add_test(tc_core, test_implicit); tcase_add_test(tc_core, test_config); tcase_add_test(tc_core, test_protected); tcase_add_test(tc_core, test_protected2); tcase_add_test(tc_core, test_alias); tcase_add_test(tc_core, test_issue102); tcase_add_test(tc_core, test_issue105); tcase_add_test(tc_core, test_issue105a); tcase_add_test(tc_core, test_issue88); tcase_add_test(tc_core, test_issue128); tcase_add_test(tc_core, test_issue130); tcase_add_test(tc_core, test_issue132); tcase_add_test(tc_core, test_issue131); tcase_add_test(tc_core, test_issue133); tcase_add_test(tc_core, test_issue140); tcase_add_test(tc_core, test_issue144); tcase_add_test(tc_core, test_issue151); tcase_add_test(tc_core, test_duplicate); tcase_add_test(tc_core, test_issue165); tcase_add_test(tc_core, test_issue162); tcase_add_test(tc_core, test_issue178); tcase_add_test(tc_core, test_issue177); tcase_add_test(tc_core, test_use); tcase_add_test(tc_core, test_afunc); tcase_add_test(tc_core, test_issue173); tcase_add_test(tc_core, test_issue174); tcase_add_test(tc_core, test_varinit); tcase_add_test(tc_core, test_issue201); tcase_add_test(tc_core, test_issue176); tcase_add_test(tc_core, test_context); tcase_add_test(tc_core, test_issue89); tcase_add_test(tc_core, test_issue188); tcase_add_test(tc_core, test_issue219); tcase_add_test(tc_core, test_issue220); tcase_add_test(tc_core, test_issue224); tcase_add_test(tc_core, test_issue221); tcase_add_test(tc_core, test_issue236); tcase_add_test(tc_core, test_issue239); tcase_add_test(tc_core, test_interfaces); tcase_add_test(tc_core, test_file_and_access); tcase_add_test(tc_core, test_issue264); tcase_add_test(tc_core, test_issue226); tcase_add_test(tc_core, test_issue197); tcase_add_test(tc_core, test_issue276); tcase_add_test(tc_core, test_dwlau); tcase_add_test(tc_core, test_jcore1); tcase_add_test(tc_core, test_issue293); tcase_add_test(tc_core, test_issue311); tcase_add_test(tc_core, test_foreign1); tcase_add_test(tc_core, test_issue316); tcase_add_test(tc_core, test_issue350); tcase_add_test(tc_core, test_issue246); tcase_add_test(tc_core, test_issue356); tcase_add_test(tc_core, test_issue359); tcase_add_test(tc_core, test_issue359a); tcase_add_test(tc_core, test_issue368); tcase_add_test(tc_core, test_issue363); tcase_add_test(tc_core, test_vests1); tcase_add_test(tc_core, test_issue369); tcase_add_test(tc_core, test_issue326); tcase_add_test(tc_core, test_issue232); tcase_add_test(tc_core, test_issue341); tcase_add_test(tc_core, test_issue340); tcase_add_test(tc_core, test_issue225); tcase_add_test(tc_core, test_issue377_strict); tcase_add_test(tc_core, test_issue377_relaxed); tcase_add_test(tc_core, test_issue386); tcase_add_test(tc_core, test_textio); tcase_add_test(tc_core, test_vital1); tcase_add_test(tc_core, test_physical); tcase_add_test(tc_core, test_block); tcase_add_test(tc_core, test_issue407); tcase_add_test(tc_core, test_resolution); tcase_add_test(tc_core, test_osvvm1); tcase_add_test(tc_core, test_osvvm2); tcase_add_test(tc_core, test_osvvm3); tcase_add_test(tc_core, test_murax); tcase_add_test(tc_core, test_driving); tcase_add_test(tc_core, test_error1); tcase_add_test(tc_core, test_tc251); tcase_add_test(tc_core, test_linkage); tcase_add_test(tc_core, test_error2); tcase_add_test(tc_core, test_error3); tcase_add_test(tc_core, test_tc792); tcase_add_test(tc_core, test_vhdl2008); tcase_add_test(tc_core, test_genpack); tcase_add_test(tc_core, test_gentype); tcase_add_test(tc_core, test_record2008); tcase_add_test(tc_core, test_osvvm4); tcase_add_test(tc_core, test_agg2008); tcase_add_test(tc_core, test_force); tcase_add_test(tc_core, test_ename); tcase_add_test(tc_core, test_mcase); tcase_add_test(tc_core, test_generics2008); tcase_add_test(tc_core, test_osvvm5); tcase_add_test(tc_core, test_issue465); tcase_add_test(tc_core, test_gensub); tcase_add_test(tc_core, test_issue482); tcase_add_test(tc_core, test_gensub2); tcase_add_test(tc_core, test_altera1); tcase_add_test(tc_core, test_issue509); tcase_add_test(tc_core, test_genpack2); tcase_add_test(tc_core, test_issue655); tcase_add_test(tc_core, test_issue659); tcase_add_test(tc_core, test_issue660); tcase_add_test(tc_core, test_genpack3); tcase_add_test(tc_core, test_condexpr); tcase_add_test(tc_core, test_lcs2016_72b); tcase_add_test(tc_core, test_lcs2016_47); tcase_add_test(tc_core, test_lcs2016_45a); tcase_add_test(tc_core, test_lcs2016_18); tcase_add_test(tc_core, test_issue713); tcase_add_test(tc_core, test_lcs2016_41); tcase_add_test(tc_core, test_lcs2016_14a); tcase_add_test(tc_core, test_lcs2016_19); tcase_add_test(tc_core, test_lcs2016_07); tcase_add_loop_test(tc_core, test_lcs2016_23, STD_08, STD_19 + 1); tcase_add_test(tc_core, test_config2); tcase_add_test(tc_core, test_lcs2016_02); tcase_add_loop_test(tc_core, test_lcs2016_04, STD_08, STD_19 + 1); tcase_add_test(tc_core, test_lcs2016_75); tcase_add_test(tc_core, test_alias2); tcase_add_test(tc_core, test_lcs2016_33); tcase_add_test(tc_core, test_lcs2016_59); tcase_add_test(tc_core, test_issue770); tcase_add_test(tc_core, test_genpack4); tcase_add_test(tc_core, test_lcs2016_16); tcase_add_test(tc_core, test_spec2); tcase_add_test(tc_core, test_incomplete); tcase_add_test(tc_core, test_issue884); tcase_add_test(tc_core, test_genpack5); tcase_add_test(tc_core, test_issue945); tcase_add_test(tc_core, test_issue958); tcase_add_test(tc_core, test_issue965); tcase_add_test(tc_core, test_lcs2016_49); tcase_add_test(tc_core, test_issue980); tcase_add_test(tc_core, test_issue1010); tcase_add_test(tc_core, test_issue1025); tcase_add_test(tc_core, test_issue1020); tcase_add_test(tc_core, test_missingwait); tcase_add_test(tc_core, test_issue1024); tcase_add_test(tc_core, test_issue1038); tcase_add_test(tc_core, test_issue1057); tcase_add_test(tc_core, test_issue1067); tcase_add_test(tc_core, test_issue1173); tcase_add_test(tc_core, test_issue1212); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_server.c000066400000000000000000000325351504111170000162370ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "jit/jit.h" #include "lib.h" #include "mir/mir-unit.h" #include "option.h" #include "rt/shell.h" #include "scan.h" #include "server.h" #include "thread.h" #include #include #include #include #ifdef __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #else #include #include #include #endif static void server_ready_cb(void *arg) { int wfd = (intptr_t)arg; static const uint8_t token[1] = { 0x42 }; if (write(wfd, token, 1) != 1) fatal_errno("write pipe"); close(wfd); } static pid_t fork_server(server_kind_t kind, tree_t top, const char *init_cmd) { #ifdef __MINGW32__ ck_abort_msg("not supported on Windows"); #else int rfd, wfd; open_pipe(&rfd, &wfd); pid_t pid = fork(); if (pid == 0) { close(rfd); start_server(kind, get_jit(), top, server_ready_cb, (void *)(intptr_t)wfd, init_cmd); exit(0); } else if (pid < 0) fatal_errno("fork"); else { close(wfd); uint8_t token[1]; if (read(rfd, token, 1) != 1) fatal_errno("read pipe"); close(rfd); ck_assert_int_eq(token[0], 0x42); return pid; } #endif } static void join_server(pid_t pid) { #ifdef __MINGW32__ ck_abort_msg("not supported on Windows"); #else int status; if (waitpid(pid, &status, 0) != pid) fatal_errno("waitpid"); ck_assert_int_eq(WEXITSTATUS(status), 0); #endif } static void write_fully(int fd, const void *data, size_t len) { while (len > 0) { ssize_t nbytes = write(fd, data, len); if (nbytes <= 0) fatal_errno("write"); data += nbytes; len -= nbytes; } } static int open_connection(void) { int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sock == -1) fatal_errno("socket"); const int port = opt_get_int(OPT_SERVER_PORT); struct sockaddr_in addr; memset(&addr, '\0', sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); addr.sin_port = htons(port); if (connect(sock, &addr, sizeof(addr)) == -1) fatal_errno("connect"); return sock; } static void websocket_upgrade(int sock) { static const char req[] = "GET / HTTP/1.1\r\n" "Host: example.com:80\r\n" "User-Agent: curl/7.87.0\r\n" "Accept: */*\r\n" "Connection: Upgrade\r\n" "Upgrade: websocket\r\n" "Origin: http://example.com:80\r\n" "Sec-WebSocket-Key: 111SGVsbG8sIHdvcmaxkIQ==\r\n" "Sec-WebSocket-Version: 13\r\n" "\r\n"; write_fully(sock, req, sizeof(req)); char resp[256]; size_t respsz = 0; for (;;) { const ssize_t nbytes = read(sock, resp + respsz, sizeof(resp) - respsz); if (nbytes <= 0) fatal_errno("recv"); respsz += nbytes; ck_assert_int_gt(nbytes, 0); ck_assert_int_lt(respsz, sizeof(resp)); resp[respsz - 1] = '\0'; const char *accept = strstr(resp, "Sec-WebSocket-Accept:"); if (accept != NULL && strstr(accept, "\r\n")) break; } fail_unless(strstr(resp, "HTTP/1.1 101\r\n")); fail_unless(strstr(resp, "Connection: upgrade\r\n")); } static void shutdown_server(web_socket_t *ws) { static const uint8_t packet[] = { C2S_SHUTDOWN }; ws_send_binary(ws, packet, sizeof(packet)); ws_flush(ws); ws_poll(ws); ck_assert(ws_closing(ws)); } static void sanity_text_frame(web_socket_t *ws, const char *text, void *context) { ck_assert_str_eq(text, "3"); } START_TEST(test_sanity) { pid_t pid = fork_server(SERVER_HTTP, NULL, NULL); int sock = open_connection(); websocket_upgrade(sock); ws_handler_t handler = { .text_frame = sanity_text_frame }; web_socket_t *ws = ws_new(sock, &handler, true); ws_send_text(ws, "expr 1 + 2"); ws_flush(ws); ws_poll(ws); static const uint8_t packet[] = { C2S_SHUTDOWN }; ws_send_binary(ws, packet, sizeof(packet)); ws_flush(ws); ws_poll(ws); ck_assert(ws_closing(ws)); ws_free(ws); close(sock); join_server(pid); } END_TEST START_TEST(test_second_connection) { pid_t pid = fork_server(SERVER_HTTP, NULL, NULL); int sock1 = open_connection(); websocket_upgrade(sock1); ws_handler_t handler = { .text_frame = sanity_text_frame }; web_socket_t *ws1 = ws_new(sock1, &handler, true); ws_send_text(ws1, "expr 1 + 2"); ws_flush(ws1); ws_poll(ws1); int sock2 = open_connection(); websocket_upgrade(sock2); web_socket_t *ws2 = ws_new(sock2, &handler, true); ws_send_text(ws2, "expr 1 + 2"); ws_flush(ws2); ws_poll(ws2); ws_poll(ws1); ck_assert(ws_closing(ws1)); ws_free(ws1); close(sock1); shutdown_server(ws2); ws_free(ws2); close(sock2); join_server(pid); } END_TEST START_TEST(test_dirty_close) { pid_t pid = fork_server(SERVER_HTTP, NULL, NULL); int sock = open_connection(); websocket_upgrade(sock); ws_handler_t handler = { .text_frame = sanity_text_frame }; web_socket_t *ws = ws_new(sock, &handler, true); ws_send_text(ws, "expr 1 + 2"); ws_flush(ws); ws_poll(ws); ws_free(ws); close(sock); sock = open_connection(); websocket_upgrade(sock); ws = ws_new(sock, &handler, true); ws_send_text(ws, "expr 1 + 2"); ws_flush(ws); ws_poll(ws); shutdown_server(ws); ws_free(ws); close(sock); join_server(pid); } END_TEST static void wave_text_frame(web_socket_t *ws, const char *text, void *context) { ck_abort_msg("not expecting a text frame"); } static void wave_binary_frame(web_socket_t *ws, const void *data, size_t len, void *context) { int *state = context; const uint8_t *bytes = data; switch ((*state)++) { case 0: ck_assert_int_eq(len, 18); ck_assert_int_eq(bytes[0], S2C_START_SIM); ck_assert_int_eq(bytes[1] << 8 | bytes[2], 15); ck_assert_mem_eq(bytes + 3, "WORK.WAVE1.elab", 15); break; case 1: ck_assert_int_eq(len, 8); ck_assert_int_eq(bytes[0], S2C_INIT_CMD); ck_assert_int_eq(bytes[1] << 8 | bytes[2], 5); ck_assert_mem_eq(bytes + 3, "hello", 5); break; case 2: ck_assert_int_eq(len, 9); ck_assert_int_eq(bytes[0], S2C_ADD_WAVE); ck_assert_int_eq(bytes[1] << 8 | bytes[2], 2); ck_assert_int_eq(bytes[3], '/'); ck_assert_int_eq(bytes[4], 'x'); ck_assert_int_eq(bytes[5] << 8 | bytes[6], 2); ck_assert_int_eq(bytes[7], 'b'); ck_assert_int_eq(bytes[8], '0'); break; case 3: case 4: ck_assert_int_eq(len, 9); ck_assert_int_eq(bytes[0], S2C_NEXT_TIME_STEP); break; case 5: ck_assert_int_eq(len, 9); ck_assert_int_eq(bytes[0], S2C_SIGNAL_UPDATE); ck_assert_int_eq(bytes[1] << 8 | bytes[2], 2); ck_assert_int_eq(bytes[3], '/'); ck_assert_int_eq(bytes[4], 'x'); ck_assert_int_eq(bytes[5] << 8 | bytes[6], 2); ck_assert_int_eq(bytes[7], 'b'); ck_assert_int_eq(bytes[8], '1'); break; case 6: ck_assert_int_eq(len, 1); ck_assert_int_eq(bytes[0], S2C_RESTART_SIM); break; default: ck_abort_msg("unexpected call to binary_frame in state %d", *state - 1); } } START_TEST(test_wave) { input_from_file(TESTDIR "/shell/wave1.vhd"); tree_t top = run_elab(); pid_t pid = fork_server(SERVER_HTTP, top, "hello"); int sock = open_connection(); websocket_upgrade(sock); int state = 0; ws_handler_t handler = { .text_frame = wave_text_frame, .binary_frame = wave_binary_frame, .context = &state }; web_socket_t *ws = ws_new(sock, &handler, true); ws_send_text(ws, "add wave /x"); ws_flush(ws); ws_poll(ws); ws_send_text(ws, "run 1 ns"); ws_flush(ws); ws_poll(ws); ck_assert_int_eq(state, 6); ws_send_text(ws, "restart"); ws_flush(ws); ws_poll(ws); shutdown_server(ws); ws_free(ws); ck_assert_int_eq(state, 7); close(sock); join_server(pid); } END_TEST static void pong_handler(web_socket_t *ws, const void *data, size_t len, void *user) { int *state = user; switch ((*state)++) { case 0: ck_assert_int_eq(len, 5); ck_assert_mem_eq(data, "hello", 5); break; case 1: ck_assert_int_eq(len, 2000); for (int i = 0; i < 2000; i++) ck_assert_int_eq(((const uint8_t *)data)[i], i & 0xff); break; case 2: ck_assert_int_eq(len, 70000); break; default: ck_abort_msg("unexpected call to pong_handler in state %d", *state - 1); } } START_TEST(test_ping) { pid_t pid = fork_server(SERVER_HTTP, NULL, NULL); int sock = open_connection(); websocket_upgrade(sock); int state = 0; ws_handler_t handler = { .pong_frame = pong_handler, .context = &state }; web_socket_t *ws = ws_new(sock, &handler, true); ws_send_ping(ws, "hello", 5); ws_flush(ws); ws_poll(ws); ck_assert_int_eq(state, 1); unsigned char big[2000]; for (int i = 0; i < ARRAY_LEN(big); i++) big[i] = i & 0xff; ws_send_ping(ws, big, ARRAY_LEN(big)); ws_flush(ws); ws_poll(ws); ck_assert_int_eq(state, 2); unsigned char *huge LOCAL = xcalloc(70000); ws_send_ping(ws, huge, 70000); ws_flush(ws); ws_poll(ws); ck_assert_int_eq(state, 3); shutdown_server(ws); ws_free(ws); close(sock); join_server(pid); } END_TEST static json_t *read_json(int sock) { size_t bufsz = 0, wptr = 0; char *buf LOCAL = NULL; do { if (wptr == bufsz) buf = xrealloc(buf, (bufsz = MAX(bufsz * 2, 1))); const ssize_t nbytes = recv(sock, buf + wptr, 1, 0); if (nbytes < 0) fatal_errno("recv"); ck_assert_int_eq(nbytes, 1); } while (buf[wptr++] != '\0'); json_error_t error; json_t *json = json_loads(buf, 0, &error); ck_assert_msg(json != NULL, "failed to parse '%s'", buf); return json; } static void cxxrtl_greeting(int sock) { { json_t *json = json_object(); json_object_set_new(json, "type", json_string("greeting")); json_object_set_new(json, "version", json_integer(0)); char *str LOCAL = json_dumps(json, JSON_COMPACT); write_fully(sock, str, strlen(str) + 1); json_decref(json); } { json_t *json = read_json(sock); json_t *commands = json_object_get(json, "commands"); ck_assert_ptr_nonnull(commands); ck_assert(json_is_array(commands)); ck_assert_int_gt(json_array_size(commands), 0); json_t *features = json_object_get(json, "features"); ck_assert_ptr_nonnull(features); ck_assert(json_is_object(features)); json_decref(json); } } static json_t *cxxrtl_command(int sock, const char *cmd, json_t *req) { json_object_set_new(req, "type", json_string("command")); json_object_set_new(req, "command", json_string(cmd)); char *str LOCAL = json_dumps(req, JSON_COMPACT); write_fully(sock, str, strlen(str) + 1); json_decref(req); json_t *resp = read_json(sock); json_t *type = json_object_get(resp, "type"); ck_assert(json_is_string(type)); ck_assert_str_eq(json_string_value(type), "response"); json_t *cmdobj = json_object_get(resp, "command"); ck_assert(json_is_string(cmdobj)); ck_assert_str_eq(json_string_value(cmdobj), cmd); return resp; } static void cxxrtl_quit_simulation(int sock) { json_t *resp = cxxrtl_command(sock, "nvc.quit_simulation", json_object()); json_decref(resp); } START_TEST(test_greeting) { pid_t pid = fork_server(SERVER_CXXRTL, NULL, NULL); int sock = open_connection(); cxxrtl_greeting(sock); cxxrtl_quit_simulation(sock); close(sock); join_server(pid); } END_TEST START_TEST(test_bad_command) { pid_t pid = fork_server(SERVER_CXXRTL, NULL, NULL); int sock = open_connection(); cxxrtl_greeting(sock); json_t *req = json_object(); json_object_set_new(req, "type", json_string("command")); json_object_set_new(req, "command", json_string("BAD COMMAND")); char *str LOCAL = json_dumps(req, JSON_COMPACT); write_fully(sock, str, strlen(str) + 1); json_decref(req); json_t *resp = read_json(sock); json_t *type = json_object_get(resp, "type"); ck_assert(json_is_string(type)); json_decref(resp); cxxrtl_quit_simulation(sock); close(sock); join_server(pid); } END_TEST Suite *get_server_tests(void) { Suite *s = suite_create("server"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_sanity); tcase_add_test(tc, test_dirty_close); tcase_add_test(tc, test_second_connection); tcase_add_test(tc, test_wave); tcase_add_test(tc, test_ping); tcase_add_test(tc, test_greeting); tcase_add_test(tc, test_bad_command); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_shell.c000066400000000000000000000313061504111170000160330ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "ident.h" #include "jit/jit.h" #include "lower.h" #include "phase.h" #include "rt/model.h" #include "rt/shell.h" #include "rt/structs.h" #include "scan.h" START_TEST(test_sanity) { tcl_shell_t *sh = shell_new(NULL); const char *result = NULL; fail_unless(shell_eval(sh, "expr 1 + 2", &result)); ck_assert_str_eq(result, "3"); shell_free(sh); } END_TEST START_TEST(test_examine1) { const error_t expect[] = { { -1, NULL } }; expect_errors(expect); const char *result = NULL; mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); input_from_file(TESTDIR "/shell/examine1.vhd"); tree_t arch = parse_check_and_simplify(T_ENTITY, T_ARCH); rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(arch), j, ur, mc, NULL, NULL, m); fail_if(top == NULL); tcl_shell_t *sh = shell_new(j); shell_reset(sh, top); const char *tests[][2] = { { "/x", "5" }, { "-binary /x", "00000000000000000000000000000101" }, { "-hex /x", "0x5" }, { "/x /y", "5 -2147483648" }, { "-radix hex /y", "0x80000000" }, { "/a", "'1'" }, { "/b", "\"01XU\"" }, { "-hex /b", "\"01XU\"" }, // TODO { "/s", "\"hello\"" }, { "/v", "(FOO, BAR, BAZ)" }, { "/p", "42000000 FS" }, { "/ss", "('a', NUL)" }, }; for (int i = 0; i < ARRAY_LEN(tests); i++) { char script[128]; checked_sprintf(script, ARRAY_LEN(script), "examine %s", tests[i][0]); shell_eval(sh, script, &result); ck_assert_msg(strcmp(result, tests[i][1]) == 0, "'%s' ==> '%s' (expected '%s')", script, result, tests[i][1]); } shell_free(sh); model_free(m); jit_free(j); check_expected_errors(); } END_TEST static void wave1_add_wave(ident_t path, const char *enc, void *user) { int *state = user; switch ((*state)++) { case 1: ck_assert_str_eq(istr(path), "/x"); ck_assert_str_eq(enc, "b0"); break; case 2: ck_assert_str_eq(istr(path), "/b"); ck_assert_str_eq(enc, "eFALSE"); break; case 7: ck_assert_str_eq(istr(path), "/x"); ck_assert_str_eq(enc, "b1"); break; case 8: ck_assert_str_eq(istr(path), "/u/y"); ck_assert_str_eq(enc, "b1"); break; default: ck_abort_msg("unexpected call to wave1_add_wave in state %d", *state - 1); } } static void wave1_signal_update(ident_t path, uint64_t now, rt_signal_t *s, const char *enc, void *user) { int *state = user; switch ((*state)++) { case 5: ck_assert_str_eq(istr(path), "/x"); ck_assert_int_eq(now, 1000000); ck_assert_int_eq(s->shared.data[0], 1); ck_assert_str_eq(enc, "b1"); break; case 6: ck_assert_str_eq(istr(path), "/b"); ck_assert_int_eq(now, 1000000); ck_assert_str_eq(enc, "eTRUE"); break; case 10: ck_assert_str_eq(istr(path), "/x"); ck_assert_int_eq(now, 2000000); ck_assert_int_eq(s->shared.data[0], 0); ck_assert_str_eq(enc, "b0"); break; case 11: ck_assert_str_eq(istr(path), "/u/y"); ck_assert_int_eq(now, 2000000); ck_assert_int_eq(s->shared.data[0], 0); ck_assert_str_eq(enc, "b0"); break; default: ck_abort_msg("unexpected call to wave1_signal_update in state %d", *state - 1); } } static void wave1_start_sim(ident_t top, void *user) { int *state = user; switch ((*state)++) { case 0: ck_assert_str_eq(istr(top), "WORK.WAVE1.elab"); break; default: ck_abort_msg("unexpected call to wave1_start_sim in state %d", *state - 1); } } static void wave1_next_time_step(uint64_t now, void *user) { int *state = user; switch ((*state)++) { case 3: ck_assert_int_eq(now, UINT64_C(0000000)); break; case 4: ck_assert_int_eq(now, UINT64_C(1000000)); break; case 9: ck_assert_int_eq(now, UINT64_C(2000000)); break; default: ck_abort_msg("unexpected call to wave1_next_time_step in state %d", *state - 1); } } START_TEST(test_wave1) { mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); tcl_shell_t *sh = shell_new(j); int state = 0; shell_handler_t handler = { .add_wave = wave1_add_wave, .signal_update = wave1_signal_update, .start_sim = wave1_start_sim, .next_time_step = wave1_next_time_step, .context = &state, }; shell_set_handler(sh, &handler); input_from_file(TESTDIR "/shell/wave1.vhd"); tree_t arch = parse_check_and_simplify(T_ENTITY, T_ARCH, T_ENTITY, T_ARCH); rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(tree_primary(arch)), j, ur, mc, NULL, NULL, m); fail_if(top == NULL); shell_reset(sh, top); const char *result = NULL; shell_eval(sh, "add wave /x /b", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 3); shell_eval(sh, "run 1 ns", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 7); shell_eval(sh, "add wave /x", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 8); shell_eval(sh, "add wave /u/y", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 9); shell_eval(sh, "run", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 12); shell_free(sh); model_free(m); jit_free(j); fail_if_errors(); } END_TEST static void stdout_handler(const char *buf, size_t nchars, void *ctx) { int *state = ctx; ck_assert_str_eq(buf, "hello, world!\n"); ck_assert_int_eq(nchars, 14); (*state)++; } static void stderr_handler(const char *buf, size_t nchars, void *ctx) { // Error stream is unbuffered int *state = ctx; if ((*state)++ == 1) { ck_assert_str_eq(buf, "error"); ck_assert_int_eq(nchars, 5); } else { ck_assert_str_eq(buf, "\n"); ck_assert_int_eq(nchars, 1); } } static void backchannel_handler(const char *buf, size_t nchars, void *ctx) { int *state = ctx; ck_assert_str_eq(buf, "{}\n"); ck_assert_int_eq(nchars, 3); (*state)++; } START_TEST(test_redirect) { tcl_shell_t *sh = shell_new(NULL); int state = 0; shell_handler_t handler = { .stdout_write = stdout_handler, .stderr_write = stderr_handler, .backchannel_write = backchannel_handler, .context = &state, }; shell_set_handler(sh, &handler); const char *result = NULL; fail_unless(shell_eval(sh, "puts \"hello, world!\"", &result)); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 1); fail_unless(shell_eval(sh, "puts stderr error", &result)); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 3); fail_unless(shell_eval(sh, "puts backchannel \"{}\"; flush backchannel", &result)); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 4); shell_free(sh); } END_TEST static void exit_handler(int status, void *ctx) { ck_assert_int_eq(status, 5); } START_TEST(test_exit) { tcl_shell_t *sh = shell_new(NULL); shell_handler_t handler = { .exit = exit_handler }; shell_set_handler(sh, &handler); const char *result = NULL; fail_unless(shell_eval(sh, "exit -code 5", &result)); ck_abort_msg("should have exited"); } END_TEST static void force1_stdout_handler(const char *buf, size_t nchars, void *user) { static const char *expect[] = { "force /x '1'\n", "force /y 42\n", "force /z \"110\"\n" }; int *state = user; ck_assert_int_lt(*state, ARRAY_LEN(expect)); ck_assert_int_eq(nchars, strlen(expect[*state])); ck_assert_mem_eq(buf, expect[*state], nchars); (*state)++; } START_TEST(test_force1) { const error_t expect[] = { { LINE_INVALID, "expected 3 elements for signal /z but have 5" }, { LINE_INVALID, "value '11' is not valid for type BIT" }, { LINE_INVALID, "signal /x is not forced" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/shell/force1.vhd"); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); tree_t arch = parse_check_and_simplify(T_ENTITY, T_ARCH); rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(arch), j, ur, mc, NULL, NULL, m); fail_if(top == NULL); tcl_shell_t *sh = shell_new(j); shell_reset(sh, top); int state = 0; shell_handler_t handler = { .stdout_write = force1_stdout_handler, .context = &state }; shell_set_handler(sh, &handler); const char *result = NULL; shell_eval(sh, "run 1 ns", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "force /x '1'", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "force /y 42", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "force /z \"110\"", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "force", &result); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 3); shell_eval(sh, "run 1 ns", &result); ck_assert_str_eq(result, ""); fail_if(shell_eval(sh, "force /z \"11011\"", &result)); fail_if(shell_eval(sh, "force /x {11}", &result)); shell_eval(sh, "noforce /x", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "run 1 ns", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "noforce *", &result); ck_assert_str_eq(result, ""); shell_eval(sh, "noforce /x", &result); shell_eval(sh, "run", &result); ck_assert_str_eq(result, ""); shell_free(sh); model_free(m); jit_free(j); check_expected_errors(); } END_TEST static void echo_stdout_handler(const char *buf, size_t nchars, void *ctx) { int *state = ctx; ck_assert_str_eq(buf, "hello 3\n"); ck_assert_int_eq(nchars, 8); (*state)++; } START_TEST(test_echo) { tcl_shell_t *sh = shell_new(NULL); int state = 0; shell_handler_t handler = { .stdout_write = echo_stdout_handler, .context = &state, }; shell_set_handler(sh, &handler); const char *result = NULL; fail_unless(shell_eval(sh, "echo hello [expr 1 + 2]", &result)); ck_assert_str_eq(result, ""); ck_assert_int_eq(state, 1); shell_free(sh); } END_TEST START_TEST(test_describe1) { const error_t expect[] = { { LINE_INVALID, "cannot find name '/not/here'" }, { -1, NULL } }; expect_errors(expect); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = jit_new(ur, mc); input_from_file(TESTDIR "/shell/describe1.vhd"); tree_t arch = parse_check_and_simplify(T_ENTITY, T_ARCH); rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(arch), j, ur, mc, NULL, NULL, m); fail_if(top == NULL); tcl_shell_t *sh = shell_new(j); shell_reset(sh, top); const char *result = NULL; const char *tests[][2] = { { "/x", "name x path /x kind signal type INTEGER" }, { "/", "name describe1 path / kind region" }, { "/b1/", "name b1 path /b1/ kind region" }, { "/b1/y", "name y path /b1/y kind signal type BIT" }, { "/not/here", "cannot find name '/not/here'" }, }; for (int i = 0; i < ARRAY_LEN(tests); i++) { char script[128]; checked_sprintf(script, ARRAY_LEN(script), "describe %s", tests[i][0]); shell_eval(sh, script, &result); ck_assert_msg(strcmp(result, tests[i][1]) == 0, "'%s' ==> '%s' (expected '%s')", script, result, tests[i][1]); } shell_free(sh); model_free(m); jit_free(j); check_expected_errors(); } END_TEST Suite *get_shell_tests(void) { Suite *s = suite_create("shell"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_sanity); tcase_add_test(tc, test_examine1); tcase_add_test(tc, test_wave1); tcase_add_test(tc, test_redirect); tcase_add_test(tc, test_force1); tcase_add_exit_test(tc, test_exit, 5); tcase_add_test(tc, test_echo); tcase_add_test(tc, test_describe1); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/test_simp.c000066400000000000000000001553701504111170000157040ustar00rootroot00000000000000// // Copyright (C) 2011-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "jit/jit.h" #include "lib.h" #include "option.h" #include "phase.h" #include "scan.h" #include "type.h" #include #include #include #include static bool folded_i(tree_t t, int64_t i) { if (tree_kind(t) != T_LITERAL) return false; if (tree_subkind(t) != L_INT) return false; return tree_ival(t) == i; } static bool folded_r(tree_t t, double r) { if (tree_kind(t) != T_LITERAL) return false; if (tree_subkind(t) != L_REAL) return false; const double dval = tree_dval(t); return (dval > r * 0.9999) && (dval < r * 1.0001); } static bool folded_b(tree_t t, bool b) { if (type_ident(tree_type(t)) != ident_new("STD.STANDARD.BOOLEAN")) return false; bool actual; if (folded_bool(t, &actual)) return actual == b; else return false; } START_TEST(test_cfold) { tree_t e, a, p, s, r; input_from_file(TESTDIR "/simp/cfold.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_if_errors(); unit_registry_t *ur = get_registry(); mir_context_t *mc = get_mir(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); fail_unless(folded_i(tree_value(tree_decl(a, 0)), -10)); r = type_dim(tree_type(tree_decl(a, 1)), 0); fail_unless(folded_i(tree_left(r), -5)); fail_unless(folded_i(tree_right(r), 8)); p = tree_stmt(a, 0); s = tree_stmt(p, 0); fail_unless(folded_i(tree_value(tree_waveform(s, 0)), 2)); s = tree_stmt(p, 1); fail_unless(folded_i(tree_value(tree_waveform(s, 0)), 8)); s = tree_stmt(p, 2); fail_unless(folded_i(tree_value(tree_waveform(s, 0)), -5)); s = tree_stmt(p, 3); fail_unless(folded_b(tree_value(s), true)); s = tree_stmt(p, 4); fail_unless(folded_b(tree_value(s), false)); s = tree_stmt(p, 5); fail_unless(folded_b(tree_value(s), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 6)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 7)), false)); fail_unless(folded_b(tree_value(tree_stmt(p, 8)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 9)), false)); fail_unless(folded_b(tree_value(tree_stmt(p, 10)), false)); fail_unless(folded_b(tree_value(tree_stmt(p, 11)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 12)), false)); fail_unless(folded_b(tree_value(tree_stmt(p, 13)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 14)), false)); fail_unless(folded_b(tree_value(tree_stmt(p, 15)), false)); s = tree_stmt(p, 16); fail_unless(tree_kind(tree_value(tree_waveform(s, 0))) == T_ARRAY_REF); fail_unless(folded_i(tree_value(tree_waveform(tree_stmt(p, 20), 0)), 5)); fail_unless(folded_i(tree_value(tree_waveform(tree_stmt(p, 23), 0)), 16)); p = tree_stmt(a, 1); fail_unless(tree_stmts(p) == 4); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_DUMMY_DRIVER); s = tree_stmt(p, 2); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_SEQUENCE); fail_unless(tree_stmts(s) == 2); p = tree_stmt(a, 2); fail_unless(folded_r(tree_value(tree_stmt(p, 0)), 1.0)); fail_unless(folded_r(tree_value(tree_stmt(p, 1)), 6.0)); fail_unless(folded_r(tree_value(tree_stmt(p, 2)), 1.0)); fail_unless(folded_b(tree_value(tree_stmt(p, 3)), true)); p = tree_stmt(a, 4); fail_unless(folded_b(tree_value(tree_stmt(p, 0)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 1)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 2)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 3)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 4)), true)); p = tree_stmt(a, 5); fail_unless(tree_stmts(p) == 1); fail_unless(tree_kind(tree_stmt(p, 0)) == T_DUMMY_DRIVER); p = tree_stmt(a, 6); fail_unless(folded_r(tree_value(tree_stmt(p, 0)), 3.0)); fail_unless(folded_r(tree_value(tree_stmt(p, 1)), 0.6)); fail_unless(folded_r(tree_value(tree_stmt(p, 2)), 2.5)); fail_unless(folded_r(tree_value(tree_stmt(p, 3)), 16.0)); p = tree_stmt(a, 7); fail_unless(folded_b(tree_value(tree_stmt(p, 0)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 1)), true)); // Constant real attributes are currently not folded p = tree_stmt(a, 8); fail_unless(tree_stmts(p) == 1); p = tree_stmt(a, 9); fail_unless(folded_b(tree_value(tree_stmt(p, 0)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 1)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 2)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 3)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 4)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 5)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 6)), true)); fail_unless(folded_b(tree_value(tree_stmt(p, 7)), true)); } END_TEST START_TEST(test_proc) { tree_t e, a, p, s, r; input_from_file(TESTDIR "/simp/proc.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_if_errors(); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); //////// p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_if(tree_triggers(p) > 0); fail_unless(tree_stmts(p) == 2); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_REPORT); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_triggers(s) == 2); r = tree_trigger(s, 0); fail_unless(tree_kind(r) == T_REF); fail_unless(tree_ident(r) == ident_new("X")); r = tree_trigger(s, 1); fail_unless(tree_kind(r) == T_REF); fail_unless(tree_ident(r) == ident_new("Y")); //////// p = tree_stmt(a, 1); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); fail_if(tree_flags(p) & TREE_F_POSTPONED); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_SIGNAL_ASSIGN); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_triggers(s) == 1); fail_unless(tree_ident(tree_trigger(s, 0)) == ident_new("Y")); //////// p = tree_stmt(a, 2); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); fail_unless(tree_flags(p) & TREE_F_POSTPONED); s = tree_stmt(p, 0); fail_unless(tree_kind(s) == T_IF); fail_unless(tree_conds(s) == 3); s = tree_stmt(p, 1); fail_unless(tree_kind(s) == T_WAIT); fail_unless(tree_triggers(s) == 2); fail_unless(tree_ident(tree_trigger(s, 0)) == ident_new("Y")); fail_unless(tree_ident(tree_trigger(s, 1)) == ident_new("X")); //////// p = tree_stmt(a, 3); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); } END_TEST START_TEST(test_args) { tree_t e, a, p, s, c; input_from_file(TESTDIR "/simp/args.vhd"); e = parse(); fail_if(e == NULL); fail_unless(tree_kind(e) == T_ENTITY); lib_put(lib_work(), e); a = parse(); fail_if(a == NULL); fail_unless(tree_kind(a) == T_ARCH); fail_if_errors(); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); //////// p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); for (int i = 0; i < 3; i++) { s = tree_stmt(p, i); fail_unless(tree_kind(s) == T_VAR_ASSIGN); c = tree_value(s); fail_unless(tree_kind(c) == T_FCALL); fail_unless(tree_params(c) == 2); fail_unless(tree_subkind(tree_param(c, 0)) == P_POS); fail_unless(icmp(tree_ident(tree_value(tree_param(c, 0))), "A")); fail_unless(tree_subkind(tree_param(c, 1)) == P_POS); fail_unless(icmp(tree_ident(tree_value(tree_param(c, 1))), "B")); } s = tree_stmt(p, 3); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_params(s) == 2); fail_unless(tree_subkind(tree_param(s, 0)) == P_POS); fail_unless(icmp(tree_ident(tree_value(tree_param(s, 0))), "A")); fail_unless(tree_subkind(tree_param(s, 1)) == P_POS); fail_unless(icmp(tree_ident(tree_value(tree_param(s, 1))), "B")); s = tree_stmt(p, 4); fail_unless(tree_kind(s) == T_PCALL); fail_unless(tree_params(s) == 2); fail_unless(tree_subkind(tree_param(s, 0)) == P_POS); fail_unless(tree_kind(tree_value(tree_param(s, 0))) == T_OPEN); fail_unless(tree_subkind(tree_param(s, 1)) == P_POS); fail_unless(icmp(tree_ident(tree_value(tree_param(s, 1))), "A")); } END_TEST START_TEST(test_ffold) { input_from_file(TESTDIR "/simp/ffold.vhd"); tree_t a = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); fail_if_errors(); tree_t b = tree_stmt(a, 0); fail_unless(tree_kind(b) == T_BLOCK); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_global(b, NULL, jit, ur, mc); jit_free(jit); fail_if_errors(); fail_unless(folded_i(tree_value(tree_decl(b, 0)), 6)); fail_unless(folded_i(tree_value(tree_decl(b, 2)), 4)); fail_unless(folded_i(tree_value(tree_decl(b, 3)), 3)); fail_unless(folded_i(tree_value(tree_decl(b, 4)), 2)); fail_unless(folded_i(tree_value(tree_decl(b, 5)), 5)); fail_unless(folded_i(tree_value(tree_decl(b, 6)), 10)); fail_unless(folded_b(tree_value(tree_decl(b, 7)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 8)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 9)), false)); fail_unless(folded_r(tree_value(tree_decl(b, 10)), 0.62)); fail_unless(folded_r(tree_value(tree_decl(b, 11)), 71.7)); fail_unless(folded_b(tree_value(tree_decl(b, 12)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 13)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 14)), false)); fail_unless(folded_b(tree_value(tree_decl(b, 15)), true)); fail_if(folded_b(tree_value(tree_decl(b, 16)), true)); // Cannot fold now fail_unless(folded_b(tree_value(tree_decl(b, 17)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 18)), true)); fail_unless(folded_i(tree_value(tree_decl(b, 19)), 80)); fail_unless(folded_i(tree_value(tree_decl(b, 20)), 5)); fail_unless(folded_i(tree_value(tree_decl(b, 21)), 2)); fail_unless(folded_b(tree_value(tree_decl(b, 22)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 23)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 24)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 25)), true)); fail_unless(folded_b(tree_value(tree_decl(b, 26)), false)); int64_t bval; fail_unless(folded_int(tree_value(tree_decl(b, 27)), &bval)); fail_unless(bval == 0); } END_TEST START_TEST(test_ffold2) { input_from_file(TESTDIR "/simp/ffold2.vhd"); tree_t a = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, T_ENTITY, T_ARCH); tree_t b = tree_stmt(a, 0); fail_unless(tree_kind(b) == T_BLOCK); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_global(b, NULL, jit, ur, mc); jit_free(jit); fail_if_errors(); fail_unless(folded_i(tree_value(tree_decl(b, 0)), 3)); } END_TEST START_TEST(test_issue49) { input_from_file(TESTDIR "/simp/issue49.vhd"); tree_t a = parse_and_check(T_ENTITY, T_ARCH); fail_if_errors(); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(a, jit, ur, mc); jit_free(jit); } END_TEST START_TEST(test_issue155) { input_from_file(TESTDIR "/simp/issue155.vhd"); tree_t p = parse_and_check(T_PACKAGE); fail_if_errors(); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_global(p, NULL, jit, ur, mc); jit_free(jit); tree_t ar = range_of(tree_type(tree_decl(p, 4)), 0); fail_unless(folded_i(tree_left(ar), 7)); fail_unless(folded_i(tree_right(ar), 0)); tree_t br = range_of(tree_type(tree_decl(p, 5)), 0); fail_unless(folded_i(tree_left(br), 3)); fail_unless(folded_i(tree_right(br), 0)); tree_t cr = range_of(tree_type(tree_decl(p, 6)), 0); fail_unless(folded_i(tree_left(cr), 1)); fail_unless(folded_i(tree_right(cr), 0)); tree_t dr = range_of(tree_type(tree_decl(p, 8)), 0); fail_unless(folded_i(tree_left(dr), 2)); fail_unless(tree_kind(tree_right(dr)) == T_RECORD_REF); } END_TEST START_TEST(test_context) { set_standard(STD_08); input_from_file(TESTDIR "/simp/context.vhd"); lib_t foo = lib_tmp("foo"); lib_t bar = lib_tmp("bar"); lib_set_work(foo); parse_and_check(T_PACKAGE, T_CONTEXT, -1); lib_set_work(bar); tree_t e = parse_and_check(T_ENTITY); fail_if_errors(); fail_unless(tree_contexts(e) == 5); mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *jit = jit_new(ur, mc); simplify_local(e, jit, ur, mc); jit_free(jit); fail_unless(tree_contexts(e) == 7); fail_unless(tree_kind(tree_context(e, 5)) == T_LIBRARY); fail_unless(tree_kind(tree_context(e, 6)) == T_USE); } END_TEST START_TEST(test_issue212) { input_from_file(TESTDIR "/simp/issue212.vhd"); tree_t top = run_elab(); fail_unless(tree_stmts(top) == 1); } END_TEST START_TEST(test_shift2) { input_from_file(TESTDIR "/simp/shift2.vhd"); tree_t top = run_elab(); fail_unless(tree_stmts(tree_stmt(top, 0)) == 0); } END_TEST START_TEST(test_issue194) { input_from_file(TESTDIR "/simp/issue194.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY, -1); fail_if(p == NULL); bounds_check(p); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if(a == NULL); bounds_check(a); } END_TEST START_TEST(test_issue309) { input_from_file(TESTDIR "/simp/issue309.vhd"); tree_t top = run_elab(); fail_unless(tree_stmts(tree_stmt(top, 0)) == 2); fail_unless(tree_stmts(tree_stmt(tree_stmt(top, 0), 0)) == 0); fail_unless(tree_stmts(tree_stmt(tree_stmt(top, 0), 1)) == 0); } END_TEST START_TEST(test_issue320) { input_from_file(TESTDIR "/simp/issue320.vhd"); tree_t top = run_elab(); tree_t b0 = tree_stmt(top, 0); tree_t d = get_decl(b0, "INIT_VALUE"); fail_unless(tree_kind(d) == T_CONST_DECL); // This used to be folded but no longer is fail_unless(tree_kind(tree_value(d)) == T_FCALL); } END_TEST START_TEST(test_issue321) { input_from_file(TESTDIR "/simp/issue321.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t test_ng = tree_stmt(top, 0); fail_unless(tree_decls(test_ng) == 5); tree_t d5 = tree_decl(test_ng, 3); fail_unless(tree_kind(tree_value(d5)) == T_LITERAL); fail_unless(tree_ival(tree_value(d5)) == 23); tree_t d6 = tree_decl(test_ng, 4); fail_unless(tree_kind(tree_value(d6)) == T_LITERAL); fail_unless(tree_ival(tree_value(d6)) == 5); } END_TEST START_TEST(test_issue331) { input_from_file(TESTDIR "/simp/issue331.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t test_ng = tree_stmt(top, 0); tree_t vec_range = get_decl(test_ng, "VEC_RANGE"); fail_unless(tree_kind(vec_range) == T_CONST_DECL); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(tree_value(vec_range)) == T_FCALL); } END_TEST START_TEST(test_issue322) { input_from_file(TESTDIR "/simp/issue322.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t p0 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t d0 = tree_decl(p0, 0); fail_unless(tree_kind(d0) == T_VAR_DECL); fail_unless(tree_kind(tree_value(d0)) == T_FCALL); } END_TEST START_TEST(test_issue332) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue332.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if(a == NULL); tree_t p0 = tree_stmt(a, 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t p0s1 = tree_stmt(p0, 1); fail_unless(tree_kind(p0s1) == T_WAIT); fail_unless(tree_triggers(p0s1) == 1); fail_unless(icmp(tree_ident(tree_trigger(p0s1, 0)), "CURR_VALUE")); tree_t p1 = tree_stmt(a, 1); fail_unless(tree_kind(p1) == T_PROCESS); tree_t p1s1 = tree_stmt(p1, 1); fail_unless(tree_kind(p1s1) == T_WAIT); fail_unless(tree_triggers(p1s1) == 1); fail_unless(icmp(tree_ident(tree_trigger(p1s1, 0)), "REGS_RDATA")); } END_TEST START_TEST(test_issue344) { input_from_file(TESTDIR "/simp/issue344.vhd"); tree_t top = run_elab(); // The assertions could be folded but aren't currently tree_t p0 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_stmts(p0) == 6); fail_unless(tree_kind(tree_value(tree_stmt(p0, 0))) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_issue345) { input_from_file(TESTDIR "/simp/issue345.vhd"); tree_t top = run_elab(); fail_unless(tree_stmts(tree_stmt(top, 0)) == 0); } END_TEST START_TEST(test_issue362) { input_from_file(TESTDIR "/simp/issue362.vhd"); tree_t top = run_elab(); // Used to be optimised out fail_unless(tree_stmts(tree_stmt(top, 0)) == 1); } END_TEST START_TEST(test_constarr) { input_from_file(TESTDIR "/simp/constarr.vhd"); tree_t top = run_elab(); tree_t b0 = tree_stmt(top, 0); tree_t c1 = get_decl(b0, "C1"); fail_unless(tree_ident(tree_value(c1)) == ident_new("'1'")); tree_t c2 = get_decl(b0, "C2"); fail_unless(tree_ident(tree_value(c2)) == ident_new("'0'")); } END_TEST START_TEST(test_table) { input_from_file(TESTDIR "/simp/table.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); fail_if(p == NULL); tree_t table = get_decl(p, "RESOLUTION_TABLE"); tree_t r0 = tree_range(type_constraint(tree_type(table)), 0); fail_unless(tree_subkind(r0) == RANGE_TO); fail_unless(assume_int(tree_left(r0)) == 0); fail_unless(assume_int(tree_right(r0)) == 8); } END_TEST START_TEST(test_func9) { input_from_file(TESTDIR "/simp/func9.vhd"); tree_t e = run_elab(); // All statements are optimised out fail_unless(tree_stmts(tree_stmt(e, 0)) == 0); } END_TEST START_TEST(test_allsens) { set_standard(STD_08); input_from_file(TESTDIR "/simp/allsens.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if(a == NULL); tree_t w, e; // P0: y w = tree_stmt(tree_stmt(a, 0), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Y")); // P1: v(1) w = tree_stmt(tree_stmt(a, 1), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_kind(tree_value(e)) == T_REF); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); // P2: v, n w = tree_stmt(tree_stmt(a, 2), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("V")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P3: z(1)(2) w = tree_stmt(tree_stmt(a, 3), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); e = tree_value(e); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_kind(tree_value(e)) == T_REF); fail_unless(tree_ident(tree_value(e)) == ident_new("Z")); // P4: z, n w = tree_stmt(tree_stmt(a, 4), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Z")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P5: z(2), n w = tree_stmt(tree_stmt(a, 5), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("Z")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P6: v(1 to 2) w = tree_stmt(tree_stmt(a, 6), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_SLICE); fail_unless(tree_kind(tree_left(tree_range(e, 0))) == T_LITERAL); fail_unless(tree_kind(tree_right(tree_range(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); // P7: v, n w = tree_stmt(tree_stmt(a, 7), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("V")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P8: z, n w = tree_stmt(tree_stmt(a, 8), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Z")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P9: z(1 to 2), n w = tree_stmt(tree_stmt(a, 9), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_SLICE); fail_unless(tree_kind(tree_left(tree_range(e, 0))) == T_LITERAL); fail_unless(tree_kind(tree_left(tree_range(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("Z")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P10: y, n w = tree_stmt(tree_stmt(a, 10), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Y")); // P11: n, y, v(1), z(1) w = tree_stmt(tree_stmt(a, 11), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 4); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Y")); e = tree_trigger(w, 2); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); e = tree_trigger(w, 3); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("Z")); // P12: v(2), x, v(1) w = tree_stmt(tree_stmt(a, 12), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 3); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("X")); e = tree_trigger(w, 2); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); // P13: n, v w = tree_stmt(tree_stmt(a, 13), 2); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 2); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("V")); // P14: x, y, v(2) w = tree_stmt(tree_stmt(a, 14), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 3); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("X")); e = tree_trigger(w, 1); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("Y")); e = tree_trigger(w, 2); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); // P15: n w = tree_stmt(tree_stmt(a, 15), 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_REF); fail_unless(tree_ident(e) == ident_new("N")); // P16: v(1) w = tree_stmt(tree_stmt(a, 16), 2); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); e = tree_trigger(w, 0); fail_unless(tree_kind(e) == T_ARRAY_REF); fail_unless(tree_kind(tree_value(tree_param(e, 0))) == T_LITERAL); fail_unless(tree_ident(tree_value(e)) == ident_new("V")); } END_TEST START_TEST(test_issue425) { input_from_file(TESTDIR "/simp/issue425.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t test_ng = tree_stmt(top, 0); tree_t m = tree_stmt(test_ng, 0); fail_unless(tree_ident(m) == ident_new("M")); tree_t c0 = tree_stmt(m, 0); fail_unless(tree_ident(c0) == ident_new("C0")); tree_t init = tree_decl(c0, 2); fail_unless(tree_kind(init) == T_CONST_DECL); fail_unless(tree_ident(init) == ident_new("INIT_SIGNALS")); // Earlier versions of nvc folded this to a T_AGGREGATE fail_unless(tree_kind(tree_value(init)) == T_FCALL); } END_TEST START_TEST(test_static1) { input_from_file(TESTDIR "/simp/static1.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t bigram = tree_stmt(top, 0); fail_unless(tree_kind(bigram) == T_BLOCK); fail_unless(tree_ident(bigram) == ident_new("BIGRAM")); tree_t addr = tree_decl(bigram, 5); fail_unless(tree_kind(addr) == T_SIGNAL_DECL); fail_unless(tree_ident(addr) == ident_new("ADDR")); fail_unless(folded_i(tree_left(range_of(tree_type(addr), 0)), 9)); tree_t uut = tree_stmt(tree_stmt(top, 0), 1); fail_unless(tree_kind(uut) == T_BLOCK); fail_unless(tree_ident(uut) == ident_new("UUT")); tree_t addr_p = tree_port(uut, 1); fail_unless(tree_kind(addr_p) == T_PORT_DECL); fail_unless(tree_ident(addr_p) == ident_new("ADDR")); fail_unless(folded_i(tree_left(range_of(tree_type(addr_p), 0)), 9)); tree_t addr_r = get_decl(uut, "ADDR_R"); fail_unless(tree_kind(addr_r) == T_SIGNAL_DECL); fail_unless(folded_i(tree_left(range_of(tree_type(addr_r), 0)), 9)); } END_TEST START_TEST(test_predef) { input_from_file(TESTDIR "/simp/predef.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); fail_if(p == NULL); tree_t c1 = tree_decl(p, 1); fail_unless(tree_kind(c1) == T_CONST_DECL); fail_unless(tree_ident(c1) == ident_new("C1")); fail_unless(folded_i(tree_value(c1), 3)); tree_t c2 = tree_decl(p, 2); fail_unless(tree_kind(c2) == T_CONST_DECL); fail_unless(tree_ident(c2) == ident_new("C2")); fail_unless(folded_b(tree_value(c2), true)); tree_t c3 = tree_decl(p, 3); fail_unless(tree_kind(c3) == T_CONST_DECL); fail_unless(tree_ident(c3) == ident_new("C3")); fail_unless(tree_kind(tree_value(c3)) == T_FCALL); } END_TEST START_TEST(test_guard) { input_from_file(TESTDIR "/simp/guard.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if(a == NULL); tree_t b0 = tree_stmt(a, 0); fail_unless(tree_kind(b0) == T_BLOCK); tree_t p1 = tree_stmt(b0, 0); fail_unless(tree_kind(p1) == T_PROCESS); fail_unless(tree_stmts(p1) == 2); tree_t g_if1 = tree_stmt(p1, 0); fail_unless(tree_kind(g_if1) == T_IF); fail_unless(tree_ident(g_if1) == ident_new("guard_if")); fail_unless(tree_conds(g_if1) == 1); tree_t p2 = tree_stmt(b0, 1); fail_unless(tree_kind(p2) == T_PROCESS); fail_unless(tree_stmts(p2) == 2); tree_t g_if2 = tree_stmt(p2, 0); fail_unless(tree_kind(g_if2) == T_IF); fail_unless(tree_ident(g_if2) == ident_new("guard_if")); fail_unless(tree_conds(g_if2) == 1); fail_unless(tree_kind(tree_stmt(tree_cond(g_if2, 0), 0)) == T_CASE); } END_TEST START_TEST(test_copysub) { input_from_file(TESTDIR "/simp/copysub.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t sub1 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(sub1) == T_BLOCK); fail_unless(tree_ident(sub1) == ident_new("SUB_1")); tree_t sub1_x = get_decl(sub1, "X"); fail_unless(tree_kind(sub1_x) == T_CONST_DECL); // No longer folded fail_unless(tree_kind(tree_value(sub1_x)) == T_FCALL); tree_t sub2 = tree_stmt(tree_stmt(top, 0), 1); fail_unless(tree_kind(sub2) == T_BLOCK); fail_unless(tree_ident(sub2) == ident_new("SUB_2")); tree_t sub2_x = get_decl(sub2, "X"); fail_unless(tree_kind(sub2_x) == T_CONST_DECL); // No longer folded fail_unless(tree_kind(tree_value(sub2_x)) == T_FCALL); } END_TEST START_TEST(test_recrange) { input_from_file(TESTDIR "/simp/recrange.vhd"); tree_t a = parse_check_and_simplify(T_PACKAGE, T_ENTITY, T_ARCH); tree_t p1 = tree_stmt(a, 0); fail_unless(tree_kind(p1) == T_PROCESS); tree_t s0 = tree_stmt(p1, 0); fail_unless(tree_kind(s0) == T_ASSERT); tree_t slice = tree_value(tree_param(tree_value(s0), 0)); fail_unless(tree_kind(slice) == T_ARRAY_SLICE); // Simplify pass should rewite the 'RANGE expression as the field // bounds are known tree_t r = tree_range(slice, 0); fail_unless(folded_i(tree_left(r), 1)); fail_unless(folded_i(tree_right(r), 8)); tree_t rref = tree_value(slice); fail_unless(tree_kind(rref) == T_RECORD_REF); } END_TEST START_TEST(test_order1) { input_from_file(TESTDIR "/simp/order1.vhd"); const error_t expect[] = { { 6, "design unit WORK.ORDER1 replaces a previously analysed unit with " "the same name" }, { -1, NULL } }; expect_errors(expect); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACKAGE); tree_t x = get_decl(p, "X"); fail_unless(tree_kind(tree_value(x)) == T_FCALL); check_expected_errors(); } END_TEST START_TEST(test_genmap) { input_from_file(TESTDIR "/simp/genmap.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_PACKAGE, T_ENTITY, T_ENTITY, T_ARCH); tree_t u1 = tree_stmt(a, 0); fail_unless(tree_genmaps(u1) == 2); fail_unless(tree_subkind(tree_genmap(u1, 0)) == P_POS); fail_unless(tree_kind(tree_value((tree_genmap(u1, 0)))) == T_LITERAL); fail_unless(tree_subkind(tree_genmap(u1, 1)) == P_POS); fail_unless(tree_kind(tree_value((tree_genmap(u1, 1)))) == T_AGGREGATE); tree_t u2 = tree_stmt(a, 1); fail_unless(tree_genmaps(u2) == 2); tree_t u3 = tree_stmt(a, 2); fail_unless(tree_genmaps(u3) == 2); fail_unless(tree_kind(tree_value(tree_genmap(u3, 1))) == T_AGGREGATE); fail_unless(tree_assocs(tree_value(tree_genmap(u3, 1))) == 3); tree_t u4 = tree_stmt(a, 3); fail_unless(tree_genmaps(u4) == 1); fail_unless(tree_kind(tree_value(tree_genmap(u4, 0))) == T_AGGREGATE); fail_unless(tree_assocs(tree_value(tree_genmap(u4, 0))) == 2); fail_if_errors(); } END_TEST START_TEST(test_issue436) { input_from_file(TESTDIR "/simp/issue436.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t b0 = tree_stmt(top, 0); tree_t vec_range = get_decl(b0, "VEC_RANGE"); fail_unless(tree_kind(vec_range) == T_CONST_DECL); fail_unless(tree_kind(tree_value(vec_range)) == T_FCALL); tree_t data = get_decl(b0, "DATA"); fail_unless(tree_kind(data) == T_SIGNAL_DECL); // This used to be folded by simp but no longer is tree_t r1 = range_of(tree_type(data), 0); fail_unless(tree_kind(tree_left(r1)) == T_RECORD_REF); tree_t c2 = get_decl(b0, "C2"); fail_unless(tree_kind(c2) == T_CONST_DECL); fail_unless(tree_kind(tree_value(c2)) == T_FCALL); tree_t data2 = get_decl(b0, "DATA2"); fail_unless(tree_kind(data2) == T_SIGNAL_DECL); // This used to be folded by simp but no longer is tree_t r2 = range_of(tree_type(data2), 0); fail_unless(tree_kind(tree_left(r2)) == T_ARRAY_REF); } END_TEST START_TEST(test_issue437) { input_from_file(TESTDIR "/simp/issue437.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t b0 = tree_stmt(top, 0); tree_t u = tree_stmt(b0, 0); fail_unless(tree_kind(u) == T_BLOCK); fail_unless(tree_ident(u) == ident_new("U")); fail_unless(tree_genmaps(u) == 1); // This is no longer folded fail_unless(tree_kind(tree_value(tree_genmap(u, 0))) == T_ATTR_REF); } END_TEST START_TEST(test_condvar) { set_standard(STD_19); input_from_file(TESTDIR "/simp/condvar.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t p = tree_stmt(a, 0); fail_unless(tree_kind(p) == T_PROCESS); fail_unless(tree_stmts(p) == 2); tree_t s0 = tree_stmt(p, 0); fail_unless(tree_kind(s0) == T_IF); fail_unless(tree_conds(s0) == 2); tree_t s0c0 = tree_cond(s0, 0); fail_unless(tree_has_value(s0c0)); fail_unless(tree_stmts(s0c0) == 1); fail_unless(tree_kind(tree_stmt(s0c0, 0)) == T_VAR_ASSIGN); tree_t s0c1 = tree_cond(s0, 1); fail_if(tree_has_value(s0c1)); fail_unless(tree_stmts(s0c1) == 1); fail_unless(tree_kind(tree_stmt(s0c1, 0)) == T_VAR_ASSIGN); tree_t s1 = tree_stmt(p, 0); fail_unless(tree_kind(s1) == T_IF); fail_unless(tree_conds(s1) == 2); tree_t s1c0 = tree_cond(s1, 0); fail_unless(tree_has_value(s1c0)); fail_unless(tree_stmts(s1c0) == 1); fail_unless(tree_kind(tree_stmt(s1c0, 0)) == T_VAR_ASSIGN); } END_TEST START_TEST(test_issue438) { input_from_file(TESTDIR "/simp/issue438.vhd"); tree_t top = run_elab(); fail_if(top == NULL); tree_t b0 = tree_stmt(top, 0); tree_t data = get_decl(b0, "DATA"); fail_unless(tree_kind(data) == T_SIGNAL_DECL); // This is no longer folded tree_t r = range_of(tree_type(data), 0); fail_unless(tree_kind(tree_left(r)) == T_RECORD_REF); } END_TEST START_TEST(test_ports2008) { set_standard(STD_08); input_from_file(TESTDIR "/simp/ports2008.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ENTITY, T_ARCH); tree_t b = tree_stmt(a, 0); fail_unless(tree_kind(b) == T_BLOCK); fail_unless(tree_decls(b) == 1); fail_unless(tree_stmts(b) == 1); tree_t inst = tree_stmt(b, 0); fail_unless(tree_kind(inst) == T_INSTANCE); fail_unless(tree_kind(tree_value(tree_param(inst, 0))) == T_INERTIAL); fail_unless(tree_kind(tree_value(tree_param(inst, 1))) == T_INERTIAL); } END_TEST START_TEST(test_gentype) { set_standard(STD_08); input_from_file(TESTDIR "/simp/gentype.vhd"); tree_t top = run_elab(); // This used to get folded tree_t b0 = tree_stmt(top, 0); fail_unless(tree_stmts(b0) == 1); } END_TEST START_TEST(test_osvvm4) { set_standard(STD_08); input_from_file(TESTDIR "/simp/osvvm4.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_PACK_INST); fail_unless(tree_genmaps(p) == 9); } END_TEST START_TEST(test_grlib1) { input_from_file(TESTDIR "/simp/grlib1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_PACKAGE); tree_t width = tree_decl(p, 0); fail_unless(tree_ident(width) == ident_new("WIDTH")); fail_unless(tree_kind(width) == T_CONST_DECL); // This expression is globally static so not folded fail_unless(tree_kind(tree_value(width)) == T_FCALL); } END_TEST START_TEST(test_protfold1) { set_standard(STD_02); input_from_file(TESTDIR "/simp/protfold1.vhd"); tree_t top = run_elab(); // Protected type should not prevent folding tree_t b0 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_stmts(b0) == 1); } END_TEST START_TEST(test_protfold2) { set_standard(STD_02); input_from_file(TESTDIR "/simp/protfold2.vhd"); tree_t top = run_elab(); // Protected type should not prevent folding tree_t b0 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_stmts(b0) == 2); } END_TEST START_TEST(test_foreign1) { input_from_file(TESTDIR "/simp/foreign1.vhd"); const error_t expect[] = { { 8, "foreign function symbol not found" }, { -1, NULL } }; expect_errors(expect); run_elab(); check_expected_errors(); } END_TEST START_TEST(test_simpif1) { input_from_file(TESTDIR "/simp/simpif1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t p1 = tree_stmt(a, 0); fail_unless(tree_kind(p1) == T_PROCESS); fail_unless(tree_stmts(p1) == 2); tree_t s0 = tree_stmt(p1, 0); fail_unless(tree_kind(s0) == T_SEQUENCE); fail_unless(tree_stmts(s0) == 2); } END_TEST START_TEST(test_concat) { set_standard(STD_08); input_from_file(TESTDIR "/simp/concat.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); static const char *strings[] = { "100", "xyz", "10", "foo" }; for (int i = 0; i < ARRAY_LEN(strings); i++) { tree_t c = tree_decl(p, i); fail_unless(tree_kind(c) == T_CONST_DECL); tree_t str = tree_value(c); fail_unless(tree_kind(str) == T_STRING); const int len = strlen(strings[i]); ck_assert_int_eq(tree_chars(str), len); for (int j = 0; j < len; j++) { tree_t lit = tree_char(str, j); fail_unless(tree_kind(lit) == T_REF); ck_assert_int_eq(ident_char(tree_ident(lit), 1), strings[i][j]); } } static const assoc_kind_t concat[][5] = { { A_POS, A_POS, -1 }, { A_POS, A_POS, A_POS, -1 }, { A_CONCAT, A_POS, -1 }, { A_POS, A_POS, A_POS, -1 }, { A_POS, A_CONCAT, -1 }, { A_CONCAT, A_CONCAT, -1 }, { A_POS, A_POS, A_POS, A_POS, -1 }, }; for (int i = 0; i < ARRAY_LEN(concat); i++) { tree_t c = tree_decl(p, i + ARRAY_LEN(strings)); fail_unless(tree_kind(c) == T_CONST_DECL); tree_t str = tree_value(c); fail_unless(tree_kind(str) == T_AGGREGATE); const int nassocs = tree_assocs(str); for (int j = 0; concat[i][j] != -1; j++) { if (j >= nassocs || tree_subkind(tree_assoc(str, j)) != concat[i][j]) { dump(c); ck_abort_msg("wrong association kind at position %d", j); } } } fail_if_errors(); } END_TEST START_TEST(test_issue496) { input_from_file(TESTDIR "/simp/issue496.vhd"); tree_t top = run_elab(); tree_t test = tree_stmt(top, 0); fail_unless(tree_kind(test) == T_BLOCK); tree_t one = tree_decl(test, 1); fail_unless(tree_kind(one) == T_CONST_DECL); fail_unless(folded_i(tree_value(one), 1)); fail_if_errors(); } END_TEST START_TEST(test_genpack1) { set_standard(STD_08); input_from_file(TESTDIR "/simp/genpack1.vhd"); tree_t top = run_elab(); tree_t b0 = tree_stmt(top, 0); fail_unless(tree_kind(b0) == T_BLOCK); fail_unless(tree_stmts(b0) == 1); tree_t p1 = tree_stmt(b0, 0); fail_unless(tree_kind(p1) == T_PROCESS); fail_unless(tree_stmts(p1) == 2); // Should have been eliminated fail_if_errors(); } END_TEST START_TEST(test_casefold1) { input_from_file(TESTDIR "/simp/casefold1.vhd"); tree_t top = run_elab(); tree_t b0 = tree_stmt(top, 0); fail_unless(tree_kind(b0) == T_BLOCK); fail_unless(tree_stmts(b0) == 2); tree_t uut = tree_stmt(b0, 1); fail_unless(tree_kind(uut) == T_BLOCK); fail_unless(tree_ident(uut) == ident_new("UUT")); fail_unless(tree_stmts(uut) == 1); tree_t mycomp = tree_stmt(uut, 0); fail_unless(tree_kind(mycomp) == T_BLOCK); fail_unless(tree_ident(mycomp) == ident_new("MYCOMP")); fail_unless(tree_stmts(mycomp) == 2); tree_t casep = tree_stmt(mycomp, 1); fail_unless(tree_kind(casep) == T_PROCESS); fail_unless(tree_ident(casep) == ident_new("CASEP")); tree_t seq = tree_stmt(casep, 0); fail_unless(tree_kind(seq) == T_REPORT); fail_if_errors(); } END_TEST START_TEST(test_issue574) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue574.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); tree_t d = get_decl(p, "C_MEMORY_MAP_DEFAULT"); tree_t agg = tree_value(d); fail_unless(tree_kind(agg) == T_AGGREGATE); tree_t n0 = tree_name(tree_assoc(agg, 0)); fail_unless(tree_kind(n0) == T_LITERAL); fail_unless(tree_subkind(n0) == L_INT); fail_unless(tree_ival(n0) == 1); fail_if_errors(); } END_TEST START_TEST(test_casegen) { set_standard(STD_08); input_from_file(TESTDIR "/simp/casegen.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); ck_assert_int_eq(tree_stmts(a), 1); tree_t five = tree_stmt(a, 0); fail_unless(tree_kind(five) == T_BLOCK); fail_unless(tree_ident(five) == ident_new("FIVE")); fail_unless(tree_stmts(five) == 1); fail_if_errors(); } END_TEST START_TEST(test_condexpr) { set_standard(STD_19); input_from_file(TESTDIR "/simp/condexpr.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t c1 = tree_decl(a, 0); fail_unless(tree_kind(c1) == T_CONST_DECL); fail_unless(tree_kind(tree_value(c1)) == T_LITERAL); tree_t foo = tree_decl(a, 1); fail_unless(tree_stmts(foo) == 3); tree_t s0 = tree_stmt(foo, 0); fail_unless(tree_kind(s0) == T_IF); fail_unless(tree_conds(s0) == 1); tree_t s0c0s0 = tree_stmt(tree_cond(s0, 0), 0); fail_unless(tree_kind(s0c0s0) == T_RETURN); tree_t s1 = tree_stmt(foo, 1); fail_unless(tree_kind(s1) == T_IF); fail_unless(tree_conds(s1) == 2); tree_t s1c0s0 = tree_stmt(tree_cond(s1, 0), 0); fail_unless(tree_kind(s1c0s0) == T_RETURN); tree_t s1c1s0 = tree_stmt(tree_cond(s1, 1), 0); fail_unless(tree_kind(s1c1s0) == T_RETURN); tree_t s2 = tree_stmt(foo, 2); fail_unless(tree_kind(s2) == T_IF); fail_unless(tree_conds(s2) == 1); tree_t bar = tree_decl(a, 2); fail_unless(tree_stmts(bar) == 2); fail_unless(tree_kind(tree_stmt(bar, 0)) == T_IF); fail_unless(tree_kind(tree_stmt(bar, 1)) == T_RETURN); fail_if_errors(); } END_TEST START_TEST(test_ieee1) { set_standard(STD_08); input_from_file(TESTDIR "/simp/ieee1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE); tree_t b1 = tree_decl(p, 0); fail_unless(tree_ident(tree_value(b1)) == ident_new("'1'")); tree_t b2 = tree_decl(p, 1); fail_unless(tree_ident(tree_value(b2)) == ident_new("'0'")); tree_t b3 = tree_decl(p, 2); fail_unless(tree_ident(tree_value(b3)) == ident_new("'1'")); fail_if_errors(); } END_TEST START_TEST(test_issue742) { input_from_file(TESTDIR "/simp/issue742.vhd"); tree_t b = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); tree_t test = tree_decl(b, 0); fail_unless(tree_kind(test) == T_PROC_BODY); fail_unless(tree_stmts(test) == 1); fail_unless(tree_kind(tree_stmt(test, 0)) == T_VAR_ASSIGN); fail_if_errors(); } END_TEST START_TEST(test_cpcall) { input_from_file(TESTDIR "/simp/cpcall.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t w0 = tree_stmt(tree_stmt(a, 0), 1); fail_unless(tree_kind(w0) == T_WAIT); fail_unless(tree_flags(w0) & TREE_F_STATIC_WAIT); tree_t w1 = tree_stmt(tree_stmt(a, 1), 1); fail_unless(tree_kind(w1) == T_WAIT); fail_if(tree_flags(w1) & TREE_F_STATIC_WAIT); fail_if_errors(); } END_TEST START_TEST(test_length) { set_standard(STD_19); input_from_file(TESTDIR "/simp/length.vhd"); const error_t expect[] = { { 3, "value of LENGTH attribute exceeds universal integer range" }, { -1, NULL }, }; expect_errors(expect); parse_check_and_simplify(T_PACKAGE); check_expected_errors(); } END_TEST START_TEST(test_casearray1) { set_standard(STD_08); input_from_file(TESTDIR "/simp/casearray1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t b = tree_decl(tree_stmt(a, 0), 0); fail_unless(tree_kind(b) == T_CONST_DECL); fail_unless(tree_kind(tree_value(b)) == T_AGGREGATE); tree_t s0 = tree_stmt(tree_stmt(a, 0), 0); fail_unless(tree_kind(s0) == T_CASE); for (int i = 0; i < 4; i++) { tree_t n0 = tree_name(tree_assoc(tree_stmt(s0, i), 0)); fail_unless(tree_kind(n0) == T_STRING); fail_unless(tree_chars(n0) == 8); } fail_if_errors(); } END_TEST START_TEST(test_conv1) { set_standard(STD_08); input_from_file(TESTDIR "/simp/conv1.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t p1 = tree_stmt(a, 0); fail_unless(tree_kind(p1) == T_PROCESS); tree_t c1 = tree_decl(p1, 0); fail_unless(tree_kind(tree_value(c1)) == T_AGGREGATE); tree_t c2 = tree_decl(p1, 1); fail_unless(tree_kind(tree_value(c2)) == T_AGGREGATE); tree_t c3 = tree_decl(p1, 2); fail_unless(tree_kind(tree_value(c3)) == T_TYPE_CONV); tree_t c4 = tree_decl(p1, 3); fail_unless(tree_kind(tree_value(c4)) == T_TYPE_CONV); fail_if_errors(); } END_TEST START_TEST(test_issue782) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue782.vhd"); tree_t top = run_elab(); tree_t b_block = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(b_block) == T_BLOCK); tree_t s = tree_decl(b_block, 1); fail_unless(tree_kind(s) == T_SIGNAL_DECL); // This used to be folded but is not currently tree_t left = tree_left(range_of(tree_type(s), 0)); fail_unless(tree_kind(left) == T_FCALL); fail_if_errors(); } END_TEST START_TEST(test_order2) { input_from_file(TESTDIR "/simp/order2.vhd"); tree_t b = parse_check_and_simplify(T_PACKAGE, T_PACK_BODY); tree_t p = tree_primary(b); fail_unless(tree_kind(tree_value(tree_decl(p, 0))) == T_STRING); fail_unless(tree_kind(tree_value(tree_decl(p, 1))) == T_STRING); fail_unless(tree_kind(tree_value(tree_decl(b, 0))) == T_STRING); fail_if_errors(); } END_TEST START_TEST(test_issue812) { input_from_file(TESTDIR "/simp/issue812.vhd"); run_elab(); fail_if_errors(); } END_TEST START_TEST(test_issue821) { input_from_file(TESTDIR "/simp/issue821.vhd"); tree_t top = run_elab(); tree_t g1 = tree_stmt(tree_stmt(top, 0), 0); fail_unless(tree_kind(g1) == T_BLOCK); tree_t seq = tree_stmt(tree_stmt(g1, 0), 0); fail_unless(tree_kind(seq) == T_SEQUENCE); fail_unless(tree_stmts(seq) == 2); fail_unless(tree_kind(tree_stmt(seq, 0)) == T_IF); fail_unless(tree_kind(tree_stmt(seq, 1)) == T_DUMMY_DRIVER); fail_if_errors(); } END_TEST START_TEST(test_issue867) { input_from_file(TESTDIR "/simp/issue867.vhd"); tree_t top = run_elab(); tree_t ent = tree_stmt(top, 0); tree_t s1 = get_decl(ent, "S1"); tree_t r = range_of(tree_type(s1), 0); fail_unless(tree_subkind(r) == RANGE_DOWNTO); int64_t low, high; fail_unless(folded_bounds(r, &low, &high)); fail_unless(low == 0); fail_unless(high == 4); fail_if_errors(); } END_TEST START_TEST(test_issue882) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue882.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); fail_if(a == NULL); tree_t p0 = tree_stmt(a, 0); fail_unless(tree_kind(p0) == T_PROCESS); tree_t p0s1 = tree_stmt(p0, 1); fail_unless(tree_kind(p0s1) == T_WAIT); fail_unless(tree_triggers(p0s1) == 1); fail_unless(icmp(tree_ident(tree_trigger(p0s1, 0)), "MY_A")); fail_if_errors(); } END_TEST START_TEST(test_packinst1) { set_standard(STD_08); input_from_file(TESTDIR "/simp/packinst1.vhd"); tree_t p = parse_check_and_simplify(T_PACKAGE, T_PACK_INST); fail_if(p == NULL); tree_t k = get_decl(p, "K"); double val; fail_unless(folded_real(tree_value(k), &val)); ck_assert_double_eq(val, 2.0); fail_if_errors(); } END_TEST START_TEST(test_physical) { input_from_file(TESTDIR "/simp/physical.vhd"); const error_t expect[] = { { 2, "physical literal 1000 HR exceeds range of type TIME" }, { 3, "physical literal 42141.4 HR exceeds range of type TIME" }, { -1, NULL }, }; expect_errors(expect); tree_t p = parse_check_and_simplify(T_PACKAGE); tree_t c3 = get_decl(p, "C3"); int64_t val; fail_unless(folded_int(tree_value(c3), &val)); ck_assert_int_eq(val, INT64_C(8200000000000)); check_expected_errors(); } END_TEST START_TEST(test_synth1) { opt_set_int(OPT_CHECK_SYNTHESIS, 1); input_from_file(TESTDIR "/simp/synth1.vhd"); const error_t expect[] = { { 22, "signal Z is read in process P1 but is not in the sensitivity" }, { 22, "signal Y is read in process P1 but is not in the sensitivity" }, { 39, "signal CLK is read in process P4 but is not in the" }, { 55, "signal RESET is read in process P6 but is not in the" }, { 80, "signal R is read in the process but is not in the sensitivity" }, { -1, NULL }, }; expect_errors(expect); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t p1 = tree_stmt(a, 0); fail_unless(tree_kind(p1) == T_PROCESS); tree_t w = tree_stmt(p1, 1); fail_unless(tree_kind(w) == T_WAIT); fail_unless(tree_triggers(w) == 1); // Should not be modified check_expected_errors(); } END_TEST START_TEST(test_genpack2) { set_standard(STD_08); input_from_file(TESTDIR "/simp/genpack2.vhd"); tree_t p3 = parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_PACKAGE); ck_assert_int_eq(tree_generics(p3), 1); tree_t p3g0 = tree_generic(p3, 0); fail_unless(tree_class(p3g0) == C_PACKAGE); tree_t p3g0v = tree_value(p3g0); fail_unless(tree_kind(p3g0v) == T_PACKAGE_MAP); fail_unless(tree_subkind(p3g0v) == PACKAGE_MAP_BOX); fail_unless(tree_genmaps(p3g0v) == 0); tree_t pi = tree_decl(p3, 0); fail_unless(tree_kind(pi) == T_PACK_INST); tree_t c = tree_decl(pi, 0); fail_unless(tree_kind(c) == T_CONST_DECL); int64_t val; fail_unless(folded_int(tree_value(c), &val)); ck_assert_int_eq(val, 3); fail_if_errors(); } END_TEST START_TEST(test_issue1182) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue1182.vhd"); tree_t a = parse_check_and_simplify(T_PACKAGE, T_PACKAGE, T_ENTITY, T_ARCH); tree_t p_proc = tree_stmt(a, 0); fail_unless(tree_stmts(p_proc) == 4); tree_t a0 = tree_stmt(p_proc, 0); fail_unless(tree_kind(a0) == T_ASSERT); fail_unless(tree_kind(tree_value(a0)) == T_FCALL); // Could be folded tree_t a2 = tree_stmt(p_proc, 2); fail_unless(tree_kind(a2) == T_ASSERT); fail_unless(tree_kind(tree_value(a2)) == T_FCALL); // Could be folded fail_if_errors(); } END_TEST START_TEST(test_issue1239) { set_standard(STD_08); input_from_file(TESTDIR "/simp/issue1239.vhd"); tree_t a = parse_check_and_simplify(T_ENTITY, T_ARCH); tree_t r = tree_stmt(tree_stmt(a, 0), 0); fail_unless(tree_kind(r) == T_REPORT); tree_t s = tree_message(r); fail_unless(tree_kind(s) == T_STRING); fail_unless(tree_chars(s) == 1); fail_unless(tree_ident(tree_char(s, 0)) == ident_new("'2'")); fail_if_errors(); } END_TEST Suite *get_simp_tests(void) { Suite *s = suite_create("simplify"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_cfold); tcase_add_test(tc_core, test_proc); tcase_add_test(tc_core, test_args); tcase_add_test(tc_core, test_ffold); tcase_add_test(tc_core, test_issue49); tcase_add_test(tc_core, test_issue155); tcase_add_test(tc_core, test_context); tcase_add_test(tc_core, test_issue212); tcase_add_test(tc_core, test_shift2); tcase_add_test(tc_core, test_issue194); tcase_add_test(tc_core, test_issue309); tcase_add_test(tc_core, test_issue320); tcase_add_test(tc_core, test_issue321); tcase_add_test(tc_core, test_issue322); tcase_add_test(tc_core, test_ffold2); tcase_add_test(tc_core, test_issue331); tcase_add_test(tc_core, test_issue332); tcase_add_test(tc_core, test_issue344); tcase_add_test(tc_core, test_issue345); tcase_add_test(tc_core, test_issue362); tcase_add_test(tc_core, test_constarr); tcase_add_test(tc_core, test_table); tcase_add_test(tc_core, test_func9); tcase_add_test(tc_core, test_allsens); tcase_add_test(tc_core, test_issue425); tcase_add_test(tc_core, test_static1); tcase_add_test(tc_core, test_predef); tcase_add_test(tc_core, test_guard); tcase_add_test(tc_core, test_copysub); tcase_add_test(tc_core, test_recrange); tcase_add_test(tc_core, test_order1); tcase_add_test(tc_core, test_genmap); tcase_add_test(tc_core, test_issue436); tcase_add_test(tc_core, test_issue437); tcase_add_test(tc_core, test_condvar); tcase_add_test(tc_core, test_issue438); tcase_add_test(tc_core, test_ports2008); tcase_add_test(tc_core, test_gentype); tcase_add_test(tc_core, test_osvvm4); tcase_add_test(tc_core, test_grlib1); tcase_add_test(tc_core, test_protfold1); tcase_add_test(tc_core, test_protfold2); tcase_add_test(tc_core, test_foreign1); tcase_add_test(tc_core, test_simpif1); tcase_add_test(tc_core, test_concat); tcase_add_test(tc_core, test_issue496); tcase_add_test(tc_core, test_genpack1); tcase_add_test(tc_core, test_casefold1); tcase_add_test(tc_core, test_issue574); tcase_add_test(tc_core, test_casegen); tcase_add_test(tc_core, test_condexpr); tcase_add_test(tc_core, test_ieee1); tcase_add_test(tc_core, test_issue742); tcase_add_test(tc_core, test_cpcall); tcase_add_test(tc_core, test_length); tcase_add_test(tc_core, test_casearray1); tcase_add_test(tc_core, test_conv1); tcase_add_test(tc_core, test_issue782); tcase_add_test(tc_core, test_order2); tcase_add_test(tc_core, test_issue812); tcase_add_test(tc_core, test_issue821); tcase_add_test(tc_core, test_issue867); tcase_add_test(tc_core, test_issue882); tcase_add_test(tc_core, test_packinst1); tcase_add_test(tc_core, test_physical); tcase_add_test(tc_core, test_synth1); tcase_add_test(tc_core, test_genpack2); tcase_add_test(tc_core, test_issue1182); tcase_add_test(tc_core, test_issue1239); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_util.c000066400000000000000000000146771504111170000157150ustar00rootroot00000000000000// // Copyright (C) 2014-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "diag.h" #include "diag.h" #include "eval.h" #include "jit/jit.h" #include "lib.h" #include "lower.h" #include "mir/mir-unit.h" #include "option.h" #include "phase.h" #include "rt/model.h" #include "vcode.h" #include #include #include static const error_t *error_lines = NULL; static lib_t test_lib = NULL; static unsigned errors_seen = 0; static unit_registry_t *registry = NULL; static mir_context_t *mir_context = NULL; static jit_t *jit = NULL; static void test_error_fn(diag_t *d, void *context) { fail_if(error_lines == NULL); const char *msg = diag_get_text(d); const loc_t *loc = diag_get_loc(d); bool unexpected = error_lines->line == -1 || error_lines->snippet == NULL || error_lines->line != (loc ? loc->first_line : LINE_INVALID) || strstr(msg, error_lines->snippet) == NULL; if (unexpected) { diag_set_consumer(NULL, NULL); diag_emit(d); printf("expected line %d '%s'\n", error_lines->line, error_lines->snippet); ck_abort_msg("expected line %d '%s'", error_lines->line, error_lines->snippet); } error_lines++; errors_seen++; for (int hint = 0; error_lines->line == 0; hint++, error_lines++) { if (error_lines->snippet == NULL) ck_assert_int_eq(hint, diag_hints(d)); // Test for absence of hint else { ck_assert_int_lt(hint, diag_hints(d)); char *copy LOCAL = xstrdup(diag_get_hint(d, hint)); if (strstr(copy, error_lines->snippet) == NULL) { diag_set_consumer(NULL, NULL); diag_emit(d); printf("expected hint '%s' got '%s'\n", error_lines->snippet, copy); ck_abort_msg("expected hint '%s'", error_lines->snippet); } } } } static void setup_per_test(void) { test_lib = lib_tmp("work"); lib_set_work(test_lib); reset_error_count(); set_standard(STD_93); error_lines = NULL; errors_seen = 0; diag_set_consumer(NULL, NULL); } static void teardown_per_test(void) { if (jit != NULL) { jit_free(jit); jit = NULL; } if (registry != NULL) { unit_registry_free(registry); registry = NULL; } if (mir_context != NULL) { mir_context_free(mir_context); mir_context = NULL; } lib_set_work(NULL); lib_free(test_lib); test_lib = NULL; } void expect_errors(const error_t *lines) { diag_set_consumer(test_error_fn, NULL); error_lines = lines; errors_seen = 0; } void check_expected_errors(void) { ck_assert_ptr_nonnull(error_lines); if (error_lines->snippet != NULL || error_lines->line != -1) ck_abort_msg("missing expected error line %d '%s'", error_lines->line, error_lines->snippet); ck_assert_int_eq(errors_seen, diag_count(DIAG_NOTE)); } TCase *nvc_unit_test(void) { TCase *tc_core = tcase_create("Core"); tcase_add_checked_fixture(tc_core, setup_per_test, teardown_per_test); return tc_core; } unit_registry_t *get_registry(void) { if (registry == NULL) registry = unit_registry_new(get_mir()); return registry; } mir_context_t *get_mir(void) { if (mir_context == NULL) mir_context = mir_context_new(); return mir_context; } jit_t *get_jit(void) { if (jit == NULL) jit = jit_new(get_registry(), get_mir()); return jit; } tree_t run_elab(void) { mir_context_t *mc = get_mir(); unit_registry_t *ur = get_registry(); jit_t *j = get_jit(); tree_t t, last_ent = NULL; while ((t = parse())) { fail_if(error_count() > 0); lib_put(lib_work(), t); simplify_local(t, j, ur, mc); bounds_check(t); fail_if(error_count() > 0); const tree_kind_t kind = tree_kind(t); if (kind == T_ENTITY || kind == T_CONFIGURATION) last_ent = t; } rt_model_t *m = model_new(j, NULL); tree_t top = elab(tree_to_object(last_ent), j, ur, mc, NULL, NULL, m); model_free(m); return top; } tree_t _parse_and_check(const tree_kind_t *array, int num, bool simp) { jit_t *jit = NULL; tree_t last = NULL; for (int i = 0; i < num; i++) { if (array[i] == (tree_kind_t)-1) goto out; last = parse(); if (last == NULL) { ck_abort_msg("expected %s but have NULL", tree_kind_str(array[i])); continue; } const tree_kind_t kind = tree_kind(last); ck_assert_msg(tree_kind(last) == array[i], "expected %s have %s", tree_kind_str(array[i]), tree_kind_str(kind)); lib_put(lib_work(), last); if (simp && error_count() == 0) { unit_registry_t *ur = get_registry(); mir_context_t *mc = get_mir(); if (jit == NULL) jit = jit_new(ur, mc); else unit_registry_purge(ur, tree_ident(last)); simplify_local(last, jit, ur, mc); bounds_check(last); } } fail_unless(parse() == NULL); out: if (jit != NULL) jit_free(jit); return last; } void fail_if_errors(void) { ck_assert_msg(diag_count(DIAG_WARN) == 0, "have errors"); ck_assert_msg(errors_seen == 0, "have errors or diagnostics"); } tree_t get_nth_decl(tree_t container, const char *name, int nth) { const int ndecls = tree_decls(container); ident_t id = ident_new(name); for (int i = 0; i < ndecls; i++) { tree_t d = tree_decl(container, i); if (!tree_has_ident(d)) continue; else if (tree_ident(d) == id && nth-- == 0) return d; } dump(container); ck_abort_msg("object %s not found in %s", name, istr(tree_ident(container))); should_not_reach_here(); } tree_t get_decl(tree_t container, const char *name) { return get_nth_decl(container, name, 0); } nvc-r1.17.1/test/test_util.h000066400000000000000000000047211504111170000157070ustar00rootroot00000000000000// // Copyright (C) 2014-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _TEST_UTIL_H #define _TEST_UTIL_H #include "util.h" #include "prim.h" #include "tree.h" #include #ifndef ck_assert_ptr_nonnull #define ck_assert_ptr_nonnull(p) ck_assert_ptr_ne(p, NULL) #endif #ifndef ck_assert_ptr_null #define ck_assert_ptr_null(p) ck_assert_ptr_eq(p, NULL) #endif #ifndef ck_assert_double_eq_tol #include #define ck_assert_double_eq_tol(x, y, t) ck_assert(fabs((x) - (y)) < (t)) #endif #ifndef ck_assert_double_eq #define ck_assert_double_eq(x, y) ck_assert((x) == (y)) #endif #ifndef ck_assert_mem_eq #define ck_assert_mem_eq(x, y, l) ck_assert(memcmp((x), (y), (l)) == 0) #endif #ifndef ck_assert_mem_ne #define ck_assert_mem_ne(x, y, l) ck_assert(memcmp((x), (y), (l)) != 0) #endif #undef fail #define fail(...) ck_abort_msg(__VA_ARGS__) #define parse_and_check(...) ({ \ static const tree_kind_t array[] = { __VA_ARGS__ }; \ _parse_and_check(array, ARRAY_LEN(array), false); \ }) #define parse_check_and_simplify(...) ({ \ static const tree_kind_t array[] = { __VA_ARGS__ }; \ _parse_and_check(array, ARRAY_LEN(array), true); \ }) typedef struct { int line; const char *snippet; } error_t; void expect_errors(const error_t *lines); void check_expected_errors(void); void fail_if_errors(void); TCase *nvc_unit_test(void); int nvc_run_test(Suite *s); unit_registry_t *get_registry(void); mir_context_t *get_mir(void); jit_t *get_jit(void); tree_t run_elab(void); tree_t _parse_and_check(const tree_kind_t *array, int num, bool simp); tree_t get_decl(tree_t container, const char *name) RETURNS_NONNULL; tree_t get_nth_decl(tree_t container, const char *name, int nth); #endif // _TEST_UTIL_H nvc-r1.17.1/test/test_value.c000066400000000000000000000152301504111170000160360ustar00rootroot00000000000000// // Copyright (C) 2013-2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "object.h" #include "tree.h" #include "type.h" #include #include #include START_TEST(test_integer) { make_new_arena(); tree_t dummy = tree_new(T_ENTITY); (void)dummy; // Ensure at least one object survives GC type_t t = type_new(T_INTEGER); parsed_value_t v; fail_unless(parse_value(t, "0", &v)); fail_unless(v.integer == 0); fail_unless(parse_value(t, "1", &v)); fail_unless(v.integer == 1); fail_unless(parse_value(t, "-1", &v)); fail_unless(v.integer == -1); fail_unless(parse_value(t, "2147483648", &v)); fail_unless(v.integer == 2147483648); fail_unless(parse_value(t, "-2147483648", &v)); fail_unless(v.integer == -2147483648); fail_unless(parse_value(t, " 14124 ", &v)); fail_unless(v.integer == 14124); fail_unless(parse_value(t, "25252781781981", &v)); fail_unless(v.integer == INT64_C(25252781781981)); fail_unless(parse_value(t, "1_2_3", &v)); fail_unless(v.integer == 123); } END_TEST START_TEST(test_enum) { make_new_arena(); tree_t dummy = tree_new(T_ENTITY); (void)dummy; // Ensure at least one object survives GC parsed_value_t v; type_t t = type_new(T_ENUM); { tree_t lit1 = tree_new(T_ENUM_LIT); tree_set_ident(lit1, ident_new("'x'")); tree_t lit2 = tree_new(T_ENUM_LIT); tree_set_ident(lit2, ident_new("HELLO")); tree_t lit3 = tree_new(T_ENUM_LIT); tree_set_ident(lit3, ident_new("A_B_C")); type_enum_add_literal(t, lit1); type_enum_add_literal(t, lit2); type_enum_add_literal(t, lit3); } fail_unless(parse_value(t, "HELLO", &v)); fail_unless(v.integer == 1); fail_unless(parse_value(t, "'x' ", &v)); fail_unless(v.integer == 0); fail_unless(parse_value(t, " \tA_B_C ", &v)); fail_unless(v.integer == 2); } END_TEST START_TEST(test_subtype) { make_new_arena(); tree_t dummy = tree_new(T_ENTITY); (void)dummy; // Ensure at least one object survives GC parsed_value_t v; type_t t = type_new(T_ENUM); type_t s = type_new(T_SUBTYPE); { tree_t lit1 = tree_new(T_ENUM_LIT); tree_set_ident(lit1, ident_new("A")); tree_set_type(lit1, t); tree_t lit2 = tree_new(T_ENUM_LIT); tree_set_ident(lit2, ident_new("B")); tree_set_type(lit2, t); tree_t lit3 = tree_new(T_ENUM_LIT); tree_set_ident(lit3, ident_new("C")); tree_set_type(lit3, t); type_enum_add_literal(t, lit1); type_enum_add_literal(t, lit2); type_enum_add_literal(t, lit3); type_set_base(s, t); tree_t r = tree_new(T_RANGE); tree_set_subkind(r, RANGE_TO); tree_set_left(r, make_ref(lit1)); tree_set_right(r, make_ref(lit2)); tree_t c = tree_new(T_CONSTRAINT); tree_set_subkind(c, C_RANGE); tree_add_range(c, r); type_set_constraint(s, c); } fail_unless(parse_value(s, "A", &v)); fail_unless(v.integer == 0); fail_unless(parse_value(s, " C ", &v)); fail_unless(v.integer == 2); // Bounds check would happen later } END_TEST START_TEST(test_real) { type_t t = std_type(NULL, STD_REAL); parsed_value_t v; fail_unless(parse_value(t, "0", &v)); ck_assert_double_eq(v.real, 0.0); fail_unless(parse_value(t, "1.0", &v)); ck_assert_double_eq(v.real, 1.0); fail_unless(parse_value(t, "2.5", &v)); ck_assert_double_eq(v.real, 2.5); fail_unless(parse_value(t, " -4.25", &v)); ck_assert_double_eq(v.real, -4.25); fail_unless(parse_value(t, " 2e3 ", &v)); ck_assert_double_eq(v.real, 2000.0); } END_TEST START_TEST(test_physical) { type_t t = std_type(NULL, STD_TIME); parsed_value_t v; fail_unless(parse_value(t, "0ps", &v)); ck_assert_int_eq(v.integer, 0); fail_unless(parse_value(t, "2.5 ns", &v)); ck_assert_int_eq(v.integer, 2500000); fail_unless(parse_value(t, " 3 ps ", &v)); ck_assert_int_eq(v.integer, 3000); fail_if(parse_value(t, " 5", &v)); } END_TEST START_TEST(test_string) { type_t str = std_type(NULL, STD_STRING); type_t bv = std_type(NULL, STD_BIT_VECTOR); parsed_value_t v; fail_unless(parse_value(str, " \"hello\"", &v)); ck_assert_int_eq(v.enums->count, 8); ck_assert_mem_eq(v.enums->values, " \"hello\"", 8); free(v.enums); fail_unless(parse_value(bv, " \"10101\" ", &v)); ck_assert_int_eq(v.enums->count, 5); const uint8_t bits1[] = { 1, 0, 1, 0, 1 }; ck_assert_mem_eq(v.enums->values, bits1, 5); free(v.enums); fail_unless(parse_value(bv, "110 ", &v)); ck_assert_int_eq(v.enums->count, 3); const uint8_t bits2[] = { 1, 1, 0 }; ck_assert_mem_eq(v.enums->values, bits2, 3); free(v.enums); fail_if(parse_value(bv, " \"101012\" ", &v)); fail_if(parse_value(bv, " 1010121 ", &v)); fail_unless(parse_value(str, " unquoted ", &v)); ck_assert_int_eq(v.enums->count, 12); ck_assert_mem_eq(v.enums->values, " unquoted ", 12); free(v.enums); } END_TEST START_TEST(test_hex) { type_t bv = std_type(NULL, STD_BIT_VECTOR); parsed_value_t v; fail_unless(parse_value(bv, "X\"12\" ", &v)); ck_assert_int_eq(v.enums->count, 8); const uint8_t bits1[] = { 0, 0, 0, 1, 0, 0, 1, 0 }; ck_assert_mem_eq(v.enums->values, bits1, 8); free(v.enums); fail_unless(parse_value(bv, " x\"4A\" ", &v)); ck_assert_int_eq(v.enums->count, 8); const uint8_t bits2[] = { 0, 1, 0, 0, 1, 0, 1, 0 }; ck_assert_mem_eq(v.enums->values, bits2, 8); free(v.enums); fail_if(parse_value(bv, " X\"10101h\" ", &v)); fail_if(parse_value(bv, " X1010121 ", &v)); } END_TEST Suite *get_value_tests(void) { Suite *s = suite_create("value"); TCase *tc_core = nvc_unit_test(); tcase_add_test(tc_core, test_integer); tcase_add_test(tc_core, test_enum); tcase_add_test(tc_core, test_subtype); tcase_add_test(tc_core, test_real); tcase_add_test(tc_core, test_physical); tcase_add_test(tc_core, test_string); tcase_add_test(tc_core, test_hex); suite_add_tcase(s, tc_core); return s; } nvc-r1.17.1/test/test_vlog.c000066400000000000000000000654471504111170000157100ustar00rootroot00000000000000// // Copyright (C) 2022-2025 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "phase.h" #include "common.h" #include "ident.h" #include "lib.h" #include "object.h" #include "prim.h" #include "scan.h" #include "test_util.h" #include "vlog/vlog-node.h" #include "vlog/vlog-number.h" #include "vlog/vlog-phase.h" #include START_TEST(test_dff) { input_from_file(TESTDIR "/vlog/dff.v"); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); fail_unless(vlog_stmts(m) == 1); fail_unless(vlog_ports(m) == 4); fail_unless(vlog_decls(m) == 5); vlog_node_t p0 = vlog_port(m, 0); fail_unless(vlog_kind(p0) == V_REF); fail_unless(vlog_ident(p0) == ident_new("d")); vlog_node_t p1 = vlog_port(m, 1); fail_unless(vlog_kind(p1) == V_REF); fail_unless(vlog_ident(p1) == ident_new("clk")); vlog_node_t p3 = vlog_port(m, 3); fail_unless(vlog_kind(p3) == V_REF); fail_unless(vlog_ident(p3) == ident_new("q")); vlog_node_t d0 = vlog_decl(m, 0); fail_unless(vlog_kind(d0) == V_PORT_DECL); fail_unless(vlog_subkind(d0) == V_PORT_INPUT); fail_unless(vlog_ident(d0) == ident_new("d")); fail_unless(vlog_ident2(d0) == ident_new("D")); vlog_node_t d1 = vlog_decl(m, 1); fail_unless(vlog_kind(d1) == V_PORT_DECL); fail_unless(vlog_subkind(d1) == V_PORT_INPUT); fail_unless(vlog_ident(d1) == ident_new("clk")); fail_unless(vlog_ident2(d1) == ident_new("CLK")); vlog_node_t d3 = vlog_decl(m, 3); fail_unless(vlog_kind(d3) == V_PORT_DECL); fail_unless(vlog_subkind(d3) == V_PORT_OUTPUT); fail_unless(vlog_ident(d3) == ident_new("q")); fail_unless(vlog_ident2(d3) == ident_new("Q")); vlog_node_t d4 = vlog_decl(m, 4); fail_unless(vlog_kind(d4) == V_VAR_DECL); fail_unless(vlog_ident(d4) == ident_new("q")); vlog_node_t a = vlog_stmt(m, 0); fail_unless(vlog_kind(a) == V_ALWAYS); fail_unless(vlog_stmts(a) == 1); vlog_node_t e = vlog_stmt(a, 0); fail_unless(vlog_kind(e) == V_TIMING); fail_unless(vlog_stmts(e) == 1); vlog_node_t ctrl = vlog_value(e); fail_unless(vlog_kind(ctrl) == V_EVENT_CONTROL); fail_unless(vlog_params(ctrl) == 1); vlog_node_t v = vlog_param(ctrl, 0); fail_unless(vlog_kind(v) == V_EVENT); fail_unless(vlog_subkind(v) == V_EVENT_POSEDGE); vlog_node_t clk = vlog_value(v); fail_unless(vlog_kind(clk) == V_REF); fail_unless(vlog_ident(clk) == ident_new("clk")); vlog_node_t s = vlog_stmt(e, 0); fail_unless(vlog_kind(s) == V_NBASSIGN); vlog_node_t t = vlog_target(s); fail_unless(vlog_kind(t) == V_REF); fail_unless(vlog_ident(t) == ident_new("q")); fail_unless(vlog_parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_simple_sem) { const error_t expect[] = { { 7, "duplicate declaration of x" }, { 13, "no visible declaration for qq" }, { 13, "no visible declaration for dd" }, { 19, "'r' cannot be driven by continuous assignment" }, { 20, "'q' cannot be assigned in a procedural block" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/vlog/simple_sem.v"); for (int i = 0; i < 4; i++) { vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); } fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_ports) { const error_t expect[] = { { 4, "duplicate declaration of y" }, { 11, "no visible declaration for y" }, { 19, "duplicate declaration of x" }, { 22, "duplicate declaration of y" }, { 31, "'o3' cannot be assigned in a procedural block" }, { 43, "inconsistent dimensions for 'y'" }, { 44, "cannot reference net 'x' in constant expression" }, { -1, NULL } }; expect_errors(expect); input_from_file(TESTDIR "/vlog/ports.v"); for (int i = 0; i < 8; i++) { vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); } fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_parse1) { input_from_file(TESTDIR "/vlog/parse1.v"); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); ck_assert_int_eq(vlog_stmts(m), 33); ck_assert_int_eq(vlog_ports(m), 0); ck_assert_int_eq(vlog_decls(m), 28); vlog_node_t x = vlog_decl(m, 0); fail_unless(vlog_kind(x) == V_NET_DECL); fail_unless(vlog_ranges(x) == 0); fail_unless(vlog_subkind(x) == V_NET_WIRE); vlog_node_t xdt = vlog_type(x); fail_unless(vlog_kind(xdt) == V_DATA_TYPE); fail_unless(vlog_subkind(xdt) == DT_LOGIC); fail_unless(vlog_ranges(xdt) == 1); vlog_node_t xd0 = vlog_range(xdt, 0); fail_unless(vlog_kind(xd0) == V_DIMENSION); fail_unless(vlog_subkind(xd0) == V_DIM_PACKED); vlog_node_t s1 = vlog_stmt(m, 1); fail_unless(vlog_kind(s1) == V_ALWAYS); fail_unless(vlog_stmts(s1) == 1); vlog_node_t s1s0 = vlog_stmt(s1, 0); fail_unless(vlog_kind(s1s0) == V_BLOCK); fail_unless(vlog_ident(s1s0) == ident_new("foo")); vlog_node_t s1s0s0 = vlog_stmt(s1s0, 0); fail_unless(vlog_kind(s1s0s0) == V_SYS_TCALL); fail_unless(vlog_ident(s1s0s0) == ident_new("$display")); fail_unless(vlog_params(s1s0s0) == 1); vlog_node_t hello = vlog_param(s1s0s0, 0); fail_unless(vlog_kind(hello) == V_STRING); number_t n1 = vlog_number(hello); ck_assert_int_eq(number_byte(n1, 0), 'o'); ck_assert_int_eq(number_byte(n1, 1), 'l'); ck_assert_int_eq(number_byte(n1, 2), 'l'); ck_assert_int_eq(number_byte(n1, 3), 'e'); ck_assert_int_eq(number_byte(n1, 4), 'h'); vlog_node_t s1s0s1 = vlog_stmt(s1s0, 1); fail_unless(vlog_kind(s1s0s1) == V_SYS_TCALL); fail_unless(vlog_ident(s1s0s1) == ident_new("$finish")); vlog_node_t s1s0s2 = vlog_stmt(s1s0, 2); fail_unless(vlog_kind(s1s0s2) == V_IF); fail_unless(vlog_conds(s1s0s2) == 1); vlog_node_t s1s0s3 = vlog_stmt(s1s0, 3); fail_unless(vlog_kind(s1s0s3) == V_IF); fail_unless(vlog_conds(s1s0s3) == 1); vlog_node_t s1s0s4 = vlog_stmt(s1s0, 4); fail_unless(vlog_kind(s1s0s4) == V_IF); fail_unless(vlog_conds(s1s0s4) == 3); vlog_node_t s2 = vlog_stmt(m, 2); fail_unless(vlog_kind(s2) == V_ASSIGN); vlog_node_t s2or = vlog_value(s2); fail_unless(vlog_kind(s2or) == V_BINARY); fail_unless(vlog_subkind(s2or) == V_BINARY_OR); vlog_node_t s1s0s5 = vlog_stmt(s1s0, 5); fail_unless(vlog_kind(s1s0s5) == V_BASSIGN); vlog_node_t s3 = vlog_stmt(m, 3); fail_unless(vlog_kind(s3) == V_GATE_INST); ck_assert_int_eq(vlog_subkind(s3), V_GATE_PULLDOWN); ck_assert_int_eq(vlog_params(s3), 1); fail_unless(vlog_ident(s3) == ident_new("p1")); fail_unless(vlog_kind(vlog_target(s3)) == V_REF); vlog_node_t s4 = vlog_stmt(m, 4); fail_unless(vlog_kind(s4) == V_GATE_INST); ck_assert_int_eq(vlog_subkind(s4), V_GATE_PULLDOWN); ck_assert_int_eq(vlog_params(s4), 1); fail_unless(vlog_ident(s4) == ident_new("p2")); fail_unless(vlog_kind(vlog_target(s4)) == V_REF); vlog_node_t s5 = vlog_stmt(m, 5); fail_unless(vlog_kind(s5) == V_GATE_INST); ck_assert_int_eq(vlog_subkind(s5), V_GATE_PULLUP); ck_assert_int_eq(vlog_params(s5), 1); fail_unless(vlog_ident(s5) == ident_new("p3")); fail_unless(vlog_kind(vlog_target(s5)) == V_REF); vlog_node_t s6 = vlog_stmt(m, 6); fail_unless(vlog_kind(s6) == V_GATE_INST); ck_assert_int_eq(vlog_subkind(s6), V_GATE_PULLUP); ck_assert_int_eq(vlog_params(s6), 1); fail_unless(vlog_ident(s6) == ident_new("p4")); fail_unless(vlog_kind(vlog_target(s6)) == V_REF); vlog_node_t s7 = vlog_stmt(m, 7); fail_unless(vlog_kind(s7) == V_GATE_INST); ck_assert_int_eq(vlog_subkind(s7), V_GATE_PULLUP); ck_assert_int_eq(vlog_params(s7), 1); fail_unless(vlog_has_ident(s7)); fail_unless(vlog_kind(vlog_target(s7)) == V_REF); vlog_node_t s8 = vlog_stmt(m, 8); fail_unless(vlog_kind(s8) == V_ALWAYS); vlog_node_t s8ctrl = vlog_value(vlog_stmt(s8, 0)); fail_unless(vlog_kind(s8ctrl) == V_EVENT_CONTROL); fail_unless(vlog_params(s8ctrl) == 3); vlog_node_t s9 = vlog_stmt(m, 9); fail_unless(vlog_kind(s9) == V_INITIAL); vlog_node_t s9b = vlog_stmt(s9, 0); fail_unless(vlog_kind(s9b) == V_BLOCK); fail_unless(vlog_kind(vlog_stmt(s9b, 0)) == V_WHILE); fail_unless(vlog_kind(vlog_stmt(s9b, 1)) == V_REPEAT); fail_unless(vlog_kind(vlog_stmt(s9b, 2)) == V_DO_WHILE); vlog_node_t d15 = vlog_decl(m, 15); fail_unless(vlog_kind(d15) == V_LOCALPARAM); vlog_node_t d17 = vlog_decl(m, 17); fail_unless(vlog_kind(d17) == V_VAR_DECL); ck_assert_int_eq(vlog_ranges(d17), 1); fail_unless(vlog_subkind(vlog_range(d17, 0)) == V_DIM_UNPACKED); vlog_node_t d20 = vlog_decl(m, 20); fail_unless(vlog_kind(d20) == V_VAR_DECL); vlog_node_t d20t = vlog_type(d20); fail_unless(vlog_subkind(d20t) == DT_EVENT); vlog_node_t s10 = vlog_stmt(m, 16); fail_unless(vlog_kind(s10) == V_ALWAYS); fail_unless(vlog_subkind(s10) == V_ALWAYS_COMB); vlog_node_t s11 = vlog_stmt(m, 17); fail_unless(vlog_kind(s11) == V_ALWAYS); fail_unless(vlog_subkind(s11) == V_ALWAYS_FF); vlog_node_t s12 = vlog_stmt(m, 18); fail_unless(vlog_kind(s12) == V_ALWAYS); fail_unless(vlog_subkind(s12) == V_ALWAYS_LATCH); vlog_node_t s19 = vlog_stmt(m, 19); fail_unless(vlog_kind(s19) == V_ALWAYS); vlog_node_t s19b = vlog_stmt(s19, 0); vlog_node_t et = vlog_stmt(s19b, 0); fail_unless(vlog_kind(et) == V_EVENT_TRIGGER); fail_unless(vlog_parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_number1) { number_t x = number_new("1'b1", NULL); ck_assert_int_eq(x.common.tag, TAG_BIGNUM); fail_unless(number_is_defined(x)); fail_if(number_signed(x)); ck_assert_int_eq(number_width(x), 1); ck_assert_int_eq(number_integer(x), 1); number_t y = number_new("5'b101", NULL); ck_assert_int_eq(y.common.tag, TAG_BIGNUM); fail_unless(number_is_defined(y)); fail_if(number_signed(y)); ck_assert_int_eq(number_width(y), 5); ck_assert_int_eq(number_integer(y), 5); number_t z = number_new("5'b1xx", NULL); ck_assert_int_eq(z.common.tag, TAG_BIGNUM); fail_if(number_is_defined(z)); fail_if(number_signed(z)); ck_assert_int_eq(number_width(z), 5); number_t n1 = number_new("1'bx", NULL); ck_assert_int_eq(n1.common.tag, TAG_BIGNUM); fail_if(number_is_defined(n1)); fail_if(number_signed(n1)); ck_assert_int_eq(number_width(n1), 1); number_t n2 = number_new("456", NULL); ck_assert_int_eq(n2.common.tag, TAG_BIGNUM); fail_unless(number_is_defined(n2)); fail_unless(number_signed(n2)); ck_assert_int_eq(number_width(n2), 32); } END_TEST START_TEST(test_number2) { struct { const char *input; unsigned width; int64_t ival; const char *string; } cases[] = { { "1'b1", 1, 1, "1'b1" }, { "5'b100", 5, 4, "5'd4" }, { "1", 32, 1, "1" }, { "42", 32, 42, "42" }, { "251251", 32, 251251, "251251" }, { "'hffffFFff", 32, 0xffffffff, "32'd4294967295" }, { "33'h100000000", 33, 0x100000000, "33'b100000000000000000000000000000000" }, { "64'b0", 64, 0, "64'b0" }, { "64'b101", 64, 5, "64'b101" }, { "8'b00_01", 8, 1, "8'd1" }, { "128'bx", 128, 0, "128'bx" }, { "4'h12", 4, 2, "4'd2" }, { "1'b110", 1, 0, "1'b0" }, { "1_000", 32, 1000, "1000" }, }; const error_t expect[] = { { LINE_INVALID, "excess digits in hex constant 4'h12" }, { LINE_INVALID, "excess digits in binary constant 1'b110" }, { -1, NULL } }; expect_errors(expect); LOCAL_TEXT_BUF tb = tb_new(); for (int i = 0; i < ARRAY_LEN(cases); i++) { number_t n = number_new(cases[i].input, NULL); ck_assert_int_eq(number_width(n), cases[i].width); if (cases[i].width <= 64) ck_assert_int_eq(number_integer(n), cases[i].ival); tb_rewind(tb); number_print(n, tb); ck_assert_str_eq(tb_get(tb), cases[i].string); } check_expected_errors(); } END_TEST START_TEST(test_pp1) { input_from_file(TESTDIR "/vlog/pp1.v"); LOCAL_TEXT_BUF tb = tb_new(); vlog_preprocess(tb, false); ck_assert_str_eq( tb_get(tb), "\n" "\n" " // comment\n" "bar = 1\n" " // Another comment\n" "pass\n" "\n" "\n" "\n" "\n" "\n" "\n" "pass\n" "\n" TESTDIR "/vlog/pp1.v\n" "16\n" "\n"); } END_TEST START_TEST(test_empty1) { input_from_buffer("", 0, SOURCE_VERILOG); fail_unless(vlog_parse() == NULL); freeze_global_arena(); // Should not crash fail_if_errors(); } END_TEST START_TEST(test_timescale1) { input_from_file(TESTDIR "/vlog/timescale1.v"); const error_t expect[] = { { 2, "invalid time unit name 'hello'" }, { 3, "invalid order of magnitude in `timescale directive" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_gate1) { input_from_file(TESTDIR "/vlog/gate1.v"); const error_t expect[] = { { 6, "duplicate declaration of p1" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_pp2) { input_from_file(TESTDIR "/vlog/pp2.v"); const error_t expect[] = { { 1, "`else outside of `ifdef" }, { 2, "`endif outside of `ifdef" }, { 3, "expected macro name after `ifdef" }, { 4, "expected macro name after `ifndef" }, { 5, "expected macro name after `define" }, { 6, "no corresponding `endif before end of file" }, { -1, NULL } }; expect_errors(expect); LOCAL_TEXT_BUF tb = tb_new(); vlog_preprocess(tb, false); check_expected_errors(); } END_TEST START_TEST(test_specify1) { input_from_file(TESTDIR "/vlog/specify1.v"); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_udp1) { input_from_file(TESTDIR "/vlog/udp1.v"); const error_t expect[] = { { 13, "no visible declaration for z" }, { 13, "the first port of a primitive must be an output" }, { 13, "all ports of a primitive except the first must be inputs" }, { 25, "expected 3 symbols in UDP table entry but have 2" }, { 58, "a sequential input list may have at most one edge indicator" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 6; i++) { vlog_node_t udp = vlog_parse(); fail_if(udp == NULL); fail_unless(vlog_kind(udp) == V_PRIMITIVE); vlog_check(udp); } fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_implicit1) { input_from_file(TESTDIR "/vlog/implicit1.v"); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); ck_assert_int_eq(vlog_decls(m), 6); fail_unless(vlog_parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_struct1) { input_from_file(TESTDIR "/vlog/struct1.v"); const error_t expect[] = { { 13, "duplicate declaration of a" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); ck_assert_int_eq(vlog_decls(m), 3); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_enum1) { input_from_file(TESTDIR "/vlog/enum1.v"); const error_t expect[] = { { 5, "'a' is not a data type" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); ck_assert_int_eq(vlog_decls(m), 4); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_union1) { input_from_file(TESTDIR "/vlog/union1.v"); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); ck_assert_int_eq(vlog_decls(m), 2); fail_unless(vlog_parse() == NULL); fail_if_errors(); } END_TEST START_TEST(test_param1) { input_from_file(TESTDIR "/vlog/param1.v"); const error_t expect[] = { { 4, "duplicate declaration of p1" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_param2) { input_from_file(TESTDIR "/vlog/param2.v"); const error_t expect[] = { { 13, "duplicate declaration" }, { 18, "local parameter declaration must have a default value" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); vlog_node_t m2 = vlog_parse(); fail_if(m2 == NULL); fail_unless(vlog_kind(m2) == V_MODULE); vlog_node_t p2 = vlog_decl(m2, 1); fail_unless(vlog_kind(p2) == V_LOCALPARAM); vlog_check(m2); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_pp3) { input_from_file(TESTDIR "/vlog/pp3.v"); const error_t expect[] = { { 3, "macro FOO undefined" }, { -1, NULL } }; expect_errors(expect); LOCAL_TEXT_BUF tb = tb_new(); vlog_preprocess(tb, false); ck_assert_str_eq( tb_get(tb), "\n" "\n" " // Warning\n"); check_expected_errors(); } END_TEST START_TEST(test_concat1) { input_from_file(TESTDIR "/vlog/concat1.v"); const error_t expect[] = { { 10, "'q' cannot be driven by continuous assignment" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_pp4) { input_from_file(TESTDIR "/vlog/pp4.v"); const error_t expect[] = { { 11, "unexpected module while parsing expression" }, { 0, "this token was unexpected" }, { 0, "while expanding macro MACRO2" }, { 0, "while expanding macro MACRO1" }, { 16, "unexpected wire while parsing net declaration assignment" }, { -1, NULL } }; expect_errors(expect); LOCAL_TEXT_BUF tb = tb_new(); vlog_preprocess(tb, true); input_from_buffer(tb_get(tb), tb_len(tb), SOURCE_VERILOG); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_casename) { input_from_file(TESTDIR "/vlog/casename.v"); const error_t expect[] = { { 4, "design unit WORK.NAME replaces a previously analysed unit with " "the same name" }, { -1, NULL } }; expect_errors(expect); for (int i = 0; i < 2; i++) { vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); lib_put_vlog(lib_work(), m); } fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_const1) { input_from_file(TESTDIR "/vlog/const1.v"); const error_t expect[] = { { 4, "cannot reference net 'w1' in constant expression" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_case1) { input_from_file(TESTDIR "/vlog/case1.v"); const error_t expect[] = { { 10, "no visible declaration for aaa" }, { 15, "multiple default statements within a single case statement" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m = vlog_parse(); fail_if(m == NULL); fail_unless(vlog_kind(m) == V_MODULE); vlog_check(m); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_direct1) { input_from_file(TESTDIR "/vlog/direct1.v"); const error_t expect[] = { { 11, "unexpected identifier while parsing default_nettype directive, " "expecting one of wire, tri, tri0, tri1, wand, triand, wor, trior," }, { 15, "no visible declaration for x" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); vlog_node_t m2 = vlog_parse(); fail_if(m2 == NULL); fail_unless(vlog_kind(m2) == V_MODULE); vlog_check(m2); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_string1) { static const struct { const char *input; const char *output; } cases[] = { { "\"hello\"", "hello" }, { "\"\"", "" }, }; for (int i = 0; i < ARRAY_LEN(cases); i++) { number_t n = number_new(cases[i].input, NULL); ck_assert(number_is_defined(n)); const int width = number_width(n); ck_assert_int_eq(width, strlen(cases[i].output) * 8); for (int j = 0; j < width / 8; j++) ck_assert_msg(number_byte(n, width/8 - 1 - j) == cases[i].output[j], "%s != %s", cases[i].input, cases[i].output); } } END_TEST START_TEST(test_generate1) { input_from_file(TESTDIR "/vlog/generate1.v"); const error_t expect[] = { { 11, "cannot specify both a label and a name for the same block" }, { 12, "'g2' does not match label 'g1'" }, { 13, "block does not have a label" }, { 3, "cannot reference net 'x' in constant expression" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_tfcall1) { input_from_file(TESTDIR "/vlog/tfcall1.v"); const error_t expect[] = { { 8, "expected 2 arguments for 'sum' but have 1" }, { 9, "expected 2 arguments for 'sum' but have 3" }, { 13, "'x4' is not a function" }, { 27, "'no_args' is not a task" }, { 12, "no visible declaration for not_here" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_attr1) { input_from_file(TESTDIR "/vlog/attr1.v"); const error_t expect[] = { { 11, "attribute instance is not allowed here" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_initial1) { input_from_file(TESTDIR "/vlog/initial1.v"); const error_t expect[] = { { 9, "unexpected reg while parsing statement item, expecting one of " }, { 14, "initial block does not have a label" }, { 16, "'another_label' does not match label 'a_label'" }, { 22, "unexpected reg while parsing statement item, expecting one of " }, { 28, "fork block does not have a label" }, { 30, "'fork5' does not match label 'fork4'" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST START_TEST(test_nets1) { input_from_file(TESTDIR "/vlog/nets1.v"); const error_t expect[] = { { 10, "charge strength only allowed with the trireg keyword" }, { 13, "vectored and scalared keywords are only allowed with at least " "a packed dimension" }, { 27, "unexpected highz1 while parsing strength1, expecting one of " "supply1, strong1, pull1 or weak1" }, { -1, NULL } }; expect_errors(expect); vlog_node_t m1 = vlog_parse(); fail_if(m1 == NULL); fail_unless(vlog_kind(m1) == V_MODULE); vlog_check(m1); fail_unless(vlog_parse() == NULL); check_expected_errors(); } END_TEST Suite *get_vlog_tests(void) { Suite *s = suite_create("vlog"); TCase *tc = nvc_unit_test(); tcase_add_test(tc, test_dff); tcase_add_test(tc, test_simple_sem); tcase_add_test(tc, test_ports); tcase_add_test(tc, test_parse1); tcase_add_test(tc, test_number1); tcase_add_test(tc, test_number2); tcase_add_test(tc, test_pp1); tcase_add_test(tc, test_empty1); tcase_add_test(tc, test_timescale1); tcase_add_test(tc, test_gate1); tcase_add_test(tc, test_pp2); tcase_add_test(tc, test_specify1); tcase_add_test(tc, test_udp1); tcase_add_test(tc, test_implicit1); tcase_add_test(tc, test_struct1); tcase_add_test(tc, test_enum1); tcase_add_test(tc, test_union1); tcase_add_test(tc, test_param1); tcase_add_test(tc, test_param2); tcase_add_test(tc, test_pp3); tcase_add_test(tc, test_concat1); tcase_add_test(tc, test_pp4); tcase_add_test(tc, test_casename); tcase_add_test(tc, test_const1); tcase_add_test(tc, test_case1); tcase_add_test(tc, test_direct1); tcase_add_test(tc, test_string1); tcase_add_test(tc, test_generate1); tcase_add_test(tc, test_tfcall1); tcase_add_test(tc, test_attr1); tcase_add_test(tc, test_initial1); tcase_add_test(tc, test_nets1); suite_add_tcase(s, tc); return s; } nvc-r1.17.1/test/tsan-suppress.txt000066400000000000000000000002461504111170000171100ustar00rootroot00000000000000# This happens inside LLVM, appears benign race:getValueTypeList race:llvm::TimerGroup::TimerGroup # Harmless race on jit->shutdown variable race_top:jit_async_cgen nvc-r1.17.1/test/unit_test.c000066400000000000000000000064561504111170000157130ustar00rootroot00000000000000// // Copyright (C) 2018-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "test_util.h" #include "common.h" #include "option.h" #include "phase.h" #include "rt/mspace.h" #include "thread.h" #include "scan.h" #include #include #include #include #include Suite *get_ident_tests(void); Suite *get_lower_tests(void); #define RUN_TESTS(name) \ ({ extern Suite *get_##name##_tests(void); \ run_suite(get_##name##_tests(), #name, argc, argv); }) const char copy_string[] = ""; const char version_string[] = ""; static int run_suite(Suite *s, const char *name, int argc, char **argv) { bool should_run = argc == 1; for (int i = 1; i < argc; i++) { if (strcmp(argv[i], name) == 0) should_run = true; } SRunner *sr = srunner_create(s); if (srunner_fork_status(sr) == CK_NOFORK) { static bool warned_fork = false; if (!warned_fork) { printf("WARNING: skipping unit tests due to CK_FORK=no\n"); warned_fork = true; } return 0; } int nfail = 0; if (should_run) { srunner_run_all(sr, CK_NORMAL); nfail = srunner_ntests_failed(sr); } srunner_free(sr); return nfail; } int main(int argc, char **argv) { srand((unsigned)time(NULL)); term_init(); thread_init(); set_default_options(); intern_strings(); register_signal_handlers(); mspace_stack_limit(MSPACE_CURRENT_FRAME); opt_set_int(OPT_UNIT_TEST, 1); opt_set_size(OPT_ARENA_SIZE, 1 << 20); opt_set_str(OPT_GC_VERBOSE, getenv("NVC_GC_VERBOSE")); opt_set_size(OPT_HEAP_SIZE, 128 * 1024); opt_set_int(OPT_GC_STRESS, getenv("NVC_GC_STRESS") != 0); opt_set_int(OPT_MISSING_WAIT, 0); if (getenv("NVC_LIBPATH") == NULL) setenv("NVC_LIBPATH", "./lib", 1); int nfail = 0; nfail += RUN_TESTS(ident); nfail += RUN_TESTS(misc); nfail += RUN_TESTS(lib); nfail += RUN_TESTS(parse); nfail += RUN_TESTS(charset); nfail += RUN_TESTS(sem); nfail += RUN_TESTS(bounds); nfail += RUN_TESTS(simp); nfail += RUN_TESTS(value); nfail += RUN_TESTS(lower); nfail += RUN_TESTS(elab); nfail += RUN_TESTS(debug); nfail += RUN_TESTS(jit); nfail += RUN_TESTS(mspace); nfail += RUN_TESTS(model); #if defined ARCH_X86_64 nfail += RUN_TESTS(native); #endif nfail += RUN_TESTS(psl); nfail += RUN_TESTS(vlog); nfail += RUN_TESTS(sdf); #ifdef ENABLE_TCL nfail += RUN_TESTS(shell); #endif nfail += RUN_TESTS(dump); #ifdef ENABLE_SERVER nfail += RUN_TESTS(server); #endif nfail += RUN_TESTS(driver); nfail += RUN_TESTS(mir); return nfail == 0 ? EXIT_SUCCESS : EXIT_FAILURE; } nvc-r1.17.1/test/vhpi/000077500000000000000000000000001504111170000144645ustar00rootroot00000000000000nvc-r1.17.1/test/vhpi/Makemodule.am000066400000000000000000000017601504111170000170720ustar00rootroot00000000000000check_PROGRAMS += lib/vhpi_test.so lib_vhpi_test_so_SOURCES = \ test/vhpi/vhpi_test.c \ test/vhpi/vhpi1.c \ test/vhpi/vhpi2.c \ test/vhpi/vhpi3.c \ test/vhpi/vhpi4.c \ test/vhpi/vhpi5.c \ test/vhpi/issue612.c \ test/vhpi/vhpi6.c \ test/vhpi/vhpi7.c \ test/vhpi/vhpi8.c \ test/vhpi/vhpi9.c \ test/vhpi/vhpi_test.h \ test/vhpi/issue744.c \ test/vhpi/vhpi10.c \ test/vhpi/vhpi11.c \ test/vhpi/issue762.c \ test/vhpi/vhpi12.c \ test/vhpi/vhpi13.c \ test/vhpi/vhpi14.c \ test/vhpi/vhpi15.c \ test/vhpi/issue978.c \ test/vhpi/issue988.c \ test/vhpi/issue1035.c \ test/vhpi/issue1045.c \ test/vhpi/issue1057.c \ test/vhpi/issue1060.c \ test/vhpi/issue1161.c \ test/vhpi/issue1192.c \ test/vhpi/issue1213.c \ test/vhpi/issue1233.c \ test/vhpi/issue1240.c \ test/vhpi/vhpi16.c lib_vhpi_test_so_CFLAGS = $(SHLIB_CFLAGS) -I$(top_srcdir)/src/vhpi $(AM_CFLAGS) lib_vhpi_test_so_LDFLAGS = $(SHLIB_LDFLAGS) $(AM_LDFLAGS) if IMPLIB_REQUIRED lib_vhpi_test_so_LDADD = lib/libnvcimp.a endif nvc-r1.17.1/test/vhpi/issue1035.c000066400000000000000000000045421504111170000162760ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void check_record(vhpiHandleT uRec, const char *prefix) { vhpiHandleT type = vhpi_handle(vhpiType, uRec); check_error(); fail_if(type == NULL); fail_unless(vhpi_get(vhpiIsCompositeP, type)); check_error(); fail_if(vhpi_get(vhpiIsScalarP, type)); check_error(); vhpi_release_handle(type); static const struct { const char *name; vhpiIntT size; } expect[] = { { "A", 1 }, { "B", 2 } }; vhpiHandleT names = vhpi_iterator(vhpiSelectedNames, uRec); for (int i = 0; i < sizeof(expect) / sizeof(expect[0]); i++) { vhpiHandleT e = vhpi_scan(names); fail_if(e == NULL); vhpi_printf("elem %s", vhpi_get_str(vhpiNameP, e)); vhpi_printf("size %d", vhpi_get(vhpiSizeP, e)); char buf[32]; snprintf(buf, sizeof(buf), "%s.%s", prefix, expect[i].name); fail_unless(strcmp((const char *)vhpi_get_str(vhpiNameP, e), buf) == 0); fail_unless(vhpi_get(vhpiSizeP, e) == expect[i].size); vhpiHandleT typ = VHPI_CHECK(vhpi_handle(vhpiType, e)); vhpiHandleT base = VHPI_CHECK(vhpi_handle(vhpiBaseType, e)); fail_unless(vhpi_compare_handles(typ, base)); vhpi_release_handle(typ); vhpi_release_handle(base); vhpi_release_handle(e); } vhpi_release_handle(names); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); const vhpiCharT *root_name = vhpi_get_str(vhpiNameP, root); vhpi_printf("root name is %s", root_name); vhpiHandleT uRec = vhpi_handle_by_name("uRec", root); check_error(); fail_if(uRec == NULL); vhpi_printf("uRec handle %p", uRec); check_record(uRec, "UREC"); vhpi_release_handle(uRec); vhpiHandleT uRecC = vhpi_handle_by_name("uRecC", root); check_error(); fail_if(uRecC == NULL); vhpi_printf("uRecC handle %p", uRecC); check_record(uRecC, "URECC"); vhpi_release_handle(uRecC); vhpi_release_handle(root); } void issue1035_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/issue1045.c000066400000000000000000000043641504111170000163010ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static vhpiHandleT s_cb, i_cb; static void s_value_change(const vhpiCbDataT *cb_data) { static int state = 0; vhpiHandleT handle_i = VHPI_CHECK(vhpi_handle_by_name("i", cb_data->obj)); vhpi_printf("i handle %p", handle_i); vhpiValueT buf = { .format = vhpiIntVal, }; VHPI_CHECK(vhpi_get_value(handle_i, &buf)); vhpi_release_handle(handle_i); vhpi_printf("s value change --> %d", buf.value.intg); switch (state++) { case 0: fail_unless(buf.value.intg == 5); break; case 1: fail_unless(buf.value.intg == 5); break; case 2: fail_unless(buf.value.intg == 6); vhpi_disable_cb(s_cb); break; default: vhpi_assert(vhpiFailure, "unexpected value change on signal S"); } } static void i_value_change(const vhpiCbDataT *cb_data) { static int state = 0; vhpiValueT buf = { .format = vhpiIntVal, }; VHPI_CHECK(vhpi_get_value(cb_data->obj, &buf)); vhpi_printf("i value change --> %d", buf.value.intg); switch (state++) { case 0: fail_unless(buf.value.intg == 5); break; case 1: fail_unless(buf.value.intg == 6); vhpi_disable_cb(i_cb); break; default: vhpi_assert(vhpiFailure, "unexpected value change on signal I"); } } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT handle_s = VHPI_CHECK(vhpi_handle_by_name("issue1045.s", NULL)); vhpi_printf("s handle %p", handle_s); vhpiHandleT handle_i = VHPI_CHECK(vhpi_handle_by_name("i", handle_s)); vhpi_printf("i handle %p", handle_i); vhpiCbDataT s_change_cb = { .reason = vhpiCbValueChange, .cb_rtn = s_value_change, .obj = handle_s, }; s_cb = VHPI_CHECK(vhpi_register_cb(&s_change_cb, vhpiReturnCb)); vhpiCbDataT i_change_cb = { .reason = vhpiCbValueChange, .cb_rtn = i_value_change, .obj = handle_i, }; i_cb = VHPI_CHECK(vhpi_register_cb(&i_change_cb, vhpiReturnCb)); } void issue1045_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/issue1057.c000066400000000000000000000034321504111170000162770ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT sigA = VHPI_CHECK(vhpi_handle_by_name("issue1057.sigA", NULL)); vhpi_printf("sigA handle %p", sigA); fail_unless(vhpi_get(vhpiSizeP, sigA) == 8); vhpiHandleT sub = VHPI_CHECK(vhpi_handle(vhpiType, sigA)); fail_unless(vhpi_get(vhpiKindP, sub) == vhpiArrayTypeDeclK); // XX: subtype? vhpiHandleT it1 = VHPI_CHECK(vhpi_iterator(vhpiConstraints, sub)); vhpiHandleT range1 = VHPI_CHECK(vhpi_scan(it1)); vhpi_printf("sub left bound %d", vhpi_get(vhpiLeftBoundP, range1)); vhpi_printf("sub right bound %d", vhpi_get(vhpiRightBoundP, range1)); fail_unless(vhpi_get(vhpiLeftBoundP, range1) == 7); fail_unless(vhpi_get(vhpiRightBoundP, range1) == 0); fail_unless(vhpi_scan(it1) == NULL); vhpi_release_handle(it1); vhpiHandleT elem = VHPI_CHECK(vhpi_handle(vhpiElemType, sub)); fail_unless(vhpi_get(vhpiKindP, elem) == vhpiArrayTypeDeclK); // XX: subtype? vhpiHandleT it2 = VHPI_CHECK(vhpi_iterator(vhpiConstraints, elem)); vhpiHandleT range2 = VHPI_CHECK(vhpi_scan(it2)); vhpi_printf("elem left bound %d", vhpi_get(vhpiLeftBoundP, range2)); vhpi_printf("elem right bound %d", vhpi_get(vhpiRightBoundP, range2)); fail_unless(vhpi_get(vhpiLeftBoundP, range2) == 0); fail_unless(vhpi_get(vhpiRightBoundP, range2) == 0); fail_unless(vhpi_scan(it2) == NULL); vhpi_release_handle(it2); vhpi_release_handle(elem); vhpi_release_handle(sub); vhpi_release_handle(sigA); } void issue1057_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue1060.c000066400000000000000000000012701504111170000162670ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void after_5ns(const vhpiCbDataT *cb_data) { vhpi_assert(vhpiError, "this is an error"); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiTimeT time_5ns = { .low = 5000000 }; vhpiCbDataT cb_data2 = { .reason = vhpiCbAfterDelay, .cb_rtn = after_5ns, .time = &time_5ns }; vhpi_register_cb(&cb_data2, 0); check_error(); } void issue1060_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue1161.c000066400000000000000000000045531504111170000163000ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpi_printf("root handle %p", root); const vhpiCharT *root_name = vhpi_get_str(vhpiNameP, root); vhpi_printf("root name is %s", root_name); vhpiHandleT datain = VHPI_CHECK(vhpi_handle_by_name("b.datain", root)); { vhpiHandleT type = VHPI_CHECK(vhpi_handle(vhpiType, datain)); fail_unless(vhpi_get(vhpiKindP, type) == vhpiSubtypeDeclK); vhpiHandleT e = VHPI_CHECK(vhpi_handle_by_name("data", datain)); vhpi_printf("elem %s", vhpi_get_str(vhpiNameP, e)); vhpi_printf("size %d", vhpi_get(vhpiSizeP, e)); fail_unless(vhpi_get(vhpiSizeP, e) == 128); vhpiHandleT etype = VHPI_CHECK(vhpi_handle(vhpiType, e)); fail_unless(vhpi_get(vhpiKindP, etype) == vhpiArrayTypeDeclK); vhpi_release_handle(e); vhpi_release_handle(etype); vhpi_release_handle(type); } vhpiHandleT ain = VHPI_CHECK(vhpi_handle_by_name("b.ain", root)); { vhpiHandleT type = VHPI_CHECK(vhpi_handle(vhpiType, ain)); fail_unless(vhpi_get(vhpiKindP, type) == vhpiArrayTypeDeclK); // XX: should be subtype vhpi_release_handle(type); vhpiHandleT it = vhpi_iterator(vhpiIndexedNames, ain); int num = 0; for (vhpiHandleT elt = vhpi_scan(it); elt; elt = vhpi_scan(it), num++) { vhpiHandleT e = VHPI_CHECK(vhpi_handle_by_name("data", elt)); vhpi_printf("elem %s", vhpi_get_str(vhpiNameP, e)); vhpi_printf("size %d", vhpi_get(vhpiSizeP, e)); // XXX: should be 128? fail_unless(vhpi_get(vhpiSizeP, e) == 256); vhpiHandleT etype = VHPI_CHECK(vhpi_handle(vhpiType, e)); fail_unless(vhpi_get(vhpiKindP, etype) == vhpiArrayTypeDeclK); vhpi_release_handle(e); vhpi_release_handle(etype); vhpi_release_handle(elt); } vhpi_release_handle(it); fail_unless(num == 16); } vhpi_release_handle(datain); vhpi_release_handle(ain); vhpi_release_handle(root); } void issue1161_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue1192.c000066400000000000000000000032351504111170000163000ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpi_printf("root handle %p", root); const vhpiCharT *root_name = vhpi_get_str(vhpiNameP, root); vhpi_printf("root name is %s", root_name); vhpiHandleT t_int_ptr = VHPI_CHECK(vhpi_handle_by_name("t_int_ptr", root)); fail_unless(vhpi_get(vhpiKindP, t_int_ptr) == vhpiAccessTypeDeclK); vhpiHandleT int_valtyp = VHPI_CHECK(vhpi_handle(vhpiValType, t_int_ptr)); fail_unless(vhpi_get(vhpiKindP, int_valtyp) == vhpiIntTypeDeclK); vhpiHandleT t_rec_ptr = VHPI_CHECK(vhpi_handle_by_name("t_rec_ptr", root)); fail_unless(vhpi_get(vhpiKindP, t_rec_ptr) == vhpiAccessTypeDeclK); vhpiHandleT rec_valtyp = VHPI_CHECK(vhpi_handle(vhpiValType, t_rec_ptr)); fail_unless(rec_valtyp == NULL); // Not currently supported vhpiHandleT t_file = VHPI_CHECK(vhpi_handle_by_name("t_file", root)); fail_unless(vhpi_get(vhpiKindP, t_file) == vhpiFileTypeDeclK); vhpiHandleT file_valtyp = VHPI_CHECK(vhpi_handle(vhpiValType, t_file)); fail_unless(vhpi_get(vhpiKindP, file_valtyp) == vhpiIntTypeDeclK); vhpi_release_handle(file_valtyp); vhpi_release_handle(int_valtyp); vhpi_release_handle(t_int_ptr); vhpi_release_handle(t_rec_ptr); vhpi_release_handle(t_file); vhpi_release_handle(root); } void issue1192_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue1213.c000066400000000000000000000024451504111170000162740ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT ifgen = VHPI_CHECK(vhpi_handle_by_name("ifgen_label", root)); vhpi_printf("ifgen handle %p", ifgen); fail_unless(vhpi_get(vhpiKindP, ifgen) == vhpiIfGenerateK); vhpiHandleT inst = VHPI_CHECK(vhpi_handle_by_name("and_gate_inst", ifgen)); vhpi_printf("and gate inst handle %p", inst); fail_unless(vhpi_get(vhpiKindP, inst) == vhpiCompInstStmtK); vhpiHandleT du = VHPI_CHECK(vhpi_handle(vhpiDesignUnit, inst)); fail_unless(du == NULL); vhpiHandleT casegen = VHPI_CHECK(vhpi_handle_by_name("casegen_label", root)); vhpi_printf("casgen handle %p", casegen); // No VHPI kind for this fail_unless(vhpi_get(vhpiKindP, casegen) == vhpiIfGenerateK); vhpi_release_handle(casegen); vhpi_release_handle(inst); vhpi_release_handle(ifgen); vhpi_release_handle(root); } void issue1213_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue1233.c000066400000000000000000000013751504111170000162770ustar00rootroot00000000000000#include "vhpi_test.h" static void vhpi_intout(const vhpiCbDataT *cb_data) { vhpiHandleT i_h = vhpi_handle_by_index(vhpiParamDecls, cb_data->obj, 0); vhpiValueT int_v = {.format = vhpiIntVal}; int_v.value.intg = 1; vhpi_put_value(i_h, &int_v, vhpiDepositPropagate); vhpi_release_handle(i_h); } void issue1233_startup(void) { vhpiHandleT cb_h; vhpiForeignDataT foreign_intout = { vhpiProcF, "vhpi.so", "vhpi_intout", NULL, vhpi_intout}; cb_h = vhpi_register_foreignf(&foreign_intout); vhpi_release_handle(cb_h); vhpiForeignDataT foreign_rangedintout = { vhpiProcF, "vhpi.so", "vhpi_rangedintout", NULL, vhpi_intout}; cb_h = vhpi_register_foreignf(&foreign_rangedintout); vhpi_release_handle(cb_h); } nvc-r1.17.1/test/vhpi/issue1240.c000066400000000000000000000023111504111170000162640ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT t1 = VHPI_CHECK(vhpi_handle_by_name("issue1240.t1", NULL)); vhpi_printf("tt1 handle %p", t1); fail_unless(vhpi_get(vhpiKindP, t1) == vhpiArrayTypeDeclK); vhpiHandleT t1e = VHPI_CHECK(vhpi_handle(vhpiElemType, t1)); vhpi_printf("elem handle %p", t1e); fail_unless(vhpi_get(vhpiKindP, t1e) == vhpiArrayTypeDeclK); // XXX: vhpiSubtypeDeclK vhpi_release_handle(t1e); vhpi_release_handle(t1); vhpiHandleT t2 = VHPI_CHECK(vhpi_handle_by_name("issue1240.t2", NULL)); vhpi_printf("tt2 handle %p", t2); fail_unless(vhpi_get(vhpiKindP, t2) == vhpiArrayTypeDeclK); vhpiHandleT t2e = VHPI_CHECK(vhpi_handle(vhpiElemType, t2)); vhpi_printf("elem handle %p", t2e); fail_unless(vhpi_get(vhpiKindP, t2e) == vhpiArrayTypeDeclK); // XXX: vhpiSubtypeDeclK vhpi_release_handle(t2e); vhpi_release_handle(t2); } void issue1240_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/issue612.c000066400000000000000000000015251504111170000162140ustar00rootroot00000000000000#include void many_args(int32_t *arg0, int32_t *arg1, int32_t *arg2, int32_t *arg3, int32_t *arg4, int32_t *arg5, int32_t *arg6, int32_t *arg7, int32_t *arg8, int32_t *arg9, int32_t *arg10, int32_t *arg11, int32_t *arg12, int32_t *arg13, int32_t *arg14, int32_t *arg15, int32_t *arg16, int32_t *arg17, int32_t *arg18, int32_t *arg19, int32_t *arg20, int32_t *arg21, int32_t *arg22, int32_t *arg23) { *arg0 = 0; *arg1 = 1; *arg2 = 2; *arg3 = 3; *arg4 = 4; *arg5 = 5; *arg6 = 6; *arg7 = 7; *arg8 = 8; *arg9 = 9; *arg10 = 10; *arg11 = 11; *arg12 = 12; *arg13 = 13; *arg14 = 14; *arg15 = 15; *arg16 = 16; *arg17 = 17; *arg18 = 18; *arg19 = 19; *arg20 = 20; *arg21 = 21; *arg22 = 22; *arg23 = 23; } nvc-r1.17.1/test/vhpi/issue744.c000066400000000000000000000031731504111170000162230ustar00rootroot00000000000000#include "vhpi_test.h" #include static void end_of_init(const vhpiCbDataT *cb_data) { vhpi_printf("end of init callback"); vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT b_signal = vhpi_handle_by_name("b", root); check_error(); fail_if(b_signal == NULL); vhpi_printf("x handle %p", b_signal); fail_unless(vhpi_get(vhpiKindP, b_signal) == vhpiSigDeclK); vhpiHandleT b_type = vhpi_handle(vhpiType, b_signal); check_error(); fail_if(b_type == NULL); vhpi_printf("b type handle %p", b_type); vhpi_printf("b type name is %s", vhpi_get_str(vhpiNameP, b_type)); vhpi_printf("b type full name is %s", vhpi_get_str(vhpiFullNameP, b_type)); fail_unless(vhpi_get(vhpiNumDimensionsP, b_type) == 1); fail_if(vhpi_get(vhpiIsUnconstrainedP, b_type)); vhpiHandleT b_constrs = vhpi_iterator(vhpiConstraints, b_type); check_error(); fail_if(b_constrs == NULL); vhpiHandleT b_range = vhpi_scan(b_constrs); check_error(); fail_if(b_range == NULL); fail_unless(vhpi_scan(b_constrs) == NULL); vhpi_printf("v type range handle %p", b_range); vhpi_printf("v left bound %d", vhpi_get(vhpiLeftBoundP, b_range)); vhpi_printf("v right bound %d", vhpi_get(vhpiRightBoundP, b_range)); fail_unless(vhpi_get(vhpiLeftBoundP, b_range) == 5); fail_unless(vhpi_get(vhpiRightBoundP, b_range) == 0); } void issue744_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbEndOfInitialization, .cb_rtn = end_of_init }; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/issue762.c000066400000000000000000000051511504111170000162210ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include static vhpiHandleT handle_sos; static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT delay_signal = vhpi_handle_by_name("delay", root); check_error(); fail_if(delay_signal == NULL); vhpi_printf("x handle %p", delay_signal); fail_unless(vhpi_get(vhpiKindP, delay_signal) == vhpiSigDeclK); vhpiHandleT delay_type = vhpi_handle(vhpiType, delay_signal); check_error(); fail_if(delay_type == NULL); vhpi_printf("delay type handle %p", delay_type); vhpi_printf("delay type name is %s", vhpi_get_str(vhpiNameP, delay_type)); vhpi_printf("delay type full name is %s", vhpi_get_str(vhpiFullNameP, delay_type)); fail_unless(vhpi_get(vhpiNumDimensionsP, delay_type) == 1); fail_if(vhpi_get(vhpiIsUnconstrainedP, delay_type)); vhpiHandleT delay_constrs = vhpi_iterator(vhpiConstraints, delay_type); check_error(); fail_if(delay_constrs == NULL); vhpiHandleT delay_range = vhpi_scan(delay_constrs); check_error(); fail_if(delay_range == NULL); fail_unless(vhpi_scan(delay_constrs) == NULL); vhpi_printf("delay type range handle %p", delay_range); vhpi_printf("delay left bound %d", vhpi_get(vhpiLeftBoundP, delay_range)); vhpi_printf("delay right bound %d", vhpi_get(vhpiRightBoundP, delay_range)); fail_unless(vhpi_get(vhpiLeftBoundP, delay_range) == 9); fail_unless(vhpi_get(vhpiRightBoundP, delay_range) == 0); fail_if(vhpi_get(vhpiIsUpP, delay_range)); vhpi_release_handle(handle_sos); } void issue762_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable); } nvc-r1.17.1/test/vhpi/issue978.c000066400000000000000000000054061504111170000162350ustar00rootroot00000000000000#include "vhpi_test.h" #include #include static void test_period(void) { vhpiHandleT period = vhpi_handle_by_name("issue978.period", NULL); check_error(); vhpiHandleT delay_length = vhpi_handle(vhpiType, period); check_error(); fail_if(delay_length == NULL); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, delay_length), "DELAY_LENGTH") == 0); fail_unless(vhpi_get(vhpiKindP, delay_length) == vhpiSubtypeDeclK); fail_if(vhpi_get(vhpiIsUnconstrainedP, delay_length)); vhpiHandleT constrs = vhpi_iterator(vhpiConstraints, delay_length); check_error(); fail_if(constrs == NULL); vhpiHandleT range = vhpi_scan(constrs); vhpiPhysT left = vhpi_get_phys(vhpiPhysLeftBoundP, range); fail_unless(left.low == 0); fail_unless(left.high == 0); vhpiPhysT right = vhpi_get_phys(vhpiPhysRightBoundP, range); fail_unless(right.low == (uint32_t)INT64_MAX); fail_unless(right.high == (int32_t)(INT64_MAX >> 32)); } static void test_one(void) { vhpiHandleT one = vhpi_handle_by_name("issue978.one", NULL); check_error(); vhpiHandleT t_int64 = vhpi_handle(vhpiType, one); check_error(); fail_if(t_int64 == NULL); check_string(vhpi_get_str(vhpiNameP, t_int64), "T_INT64"); fail_unless(vhpi_get(vhpiKindP, t_int64) == vhpiIntTypeDeclK); fail_if(vhpi_get(vhpiIsUnconstrainedP, t_int64)); vhpiHandleT constrs = vhpi_iterator(vhpiConstraints, t_int64); check_error(); fail_if(constrs == NULL); vhpiHandleT range = vhpi_scan(constrs); fail_unless(vhpi_get(vhpiLeftBoundP, range) == 0); // XXX: VHPI limitation fail_unless(vhpi_get(vhpiRightBoundP, range) == -1); // XXX: VHPI limitation } static void test_two(void) { vhpiHandleT two = vhpi_handle_by_name("issue978.two", NULL); check_error(); vhpiHandleT t_sub = vhpi_handle(vhpiType, two); check_error(); fail_if(t_sub == NULL); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, t_sub), "T_SUB") == 0); fail_unless(vhpi_get(vhpiKindP, t_sub) == vhpiSubtypeDeclK); fail_if(vhpi_get(vhpiIsUnconstrainedP, t_sub)); vhpiHandleT constrs = vhpi_iterator(vhpiConstraints, t_sub); check_error(); fail_if(constrs == NULL); vhpiHandleT range = vhpi_scan(constrs); fail_unless(vhpi_get(vhpiLeftBoundP, range) == 1); fail_unless(vhpi_get(vhpiRightBoundP, range) == 100); vhpiValueT value = { .format = vhpiLongIntVal, }; vhpi_get_value(two, &value); check_error(); fail_unless(value.value.longintg == 42); } static void start_of_sim(const vhpiCbDataT *cb_data) { test_period(); test_one(); test_two(); } void issue978_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/issue988.c000066400000000000000000000011211504111170000162240ustar00rootroot00000000000000#include "vhpi_test.h" #include static void init(const vhpiCbDataT *cb_data_p) { vhpiValueT result = { .format = vhpiIntVal, .value = { .intg = 42 } }; vhpi_put_value(cb_data_p->obj, &result, vhpiDeposit); check_error(); } int32_t __vhpi_init_direct(void) { return 66; } void issue988_startup(void) { vhpiForeignDataT init_data = { .kind = vhpiFuncF, .libraryName = "issue988", .modelName = "init", .execf = init, }; vhpiHandleT h = vhpi_register_foreignf(&init_data); check_error(); vhpi_release_handle(h); } nvc-r1.17.1/test/vhpi/vhpi1.c000066400000000000000000000441111504111170000156600ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include static vhpiHandleT handle_x; static vhpiHandleT handle_y; static vhpiHandleT handle_sos; static void test_bin_str(void) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); vhpiHandleT hb = vhpi_handle_by_name("b", root); check_error(); vhpiHandleT hv = vhpi_handle_by_name("v", root); check_error(); vhpiHandleT hi = vhpi_handle_by_name("i", root); check_error(); char b_str[2] = { 0xff, 0xff }; vhpiValueT b_value = { .format = vhpiBinStrVal, .bufSize = sizeof(b_str), .value.str = (vhpiCharT *)b_str }; vhpi_get_value(hb, &b_value); check_error(); vhpi_printf("b bit string '%s' %x", b_str); fail_unless(strcmp(b_str, "0") == 0); b_value.format = vhpiLogicVal; vhpi_get_value(hb, &b_value); check_error(); vhpi_printf("b logic %x", b_value.value.smallenumv); fail_unless(b_value.value.smallenumv == 0); b_value.format = vhpiIntVal; vhpi_get_value(hb, &b_value); check_error(); vhpi_printf("b integer %x", b_value.value.intg); fail_unless(b_value.value.intg == 0); vhpiValueT i_value = { .format = vhpiIntVal, .bufSize = 0, .value.str = NULL }; vhpi_get_value(hi, &i_value); check_error(); vhpi_printf("i integer %x", i_value.value.intg); fail_unless(i_value.value.intg == 42); i_value.format = vhpiLongIntVal; i_value.value.longintg = 0xdead; vhpi_get_value(hi, &i_value); check_error(); vhpi_printf("i long integer %lx", i_value.value.longintg); fail_unless(i_value.value.longintg == 42); i_value.format = vhpiSmallEnumVal; i_value.value.smallenumv = 0xde; int result = vhpi_get_value(hi, &i_value); fail_unless(result == -1); vhpiErrorInfoT errorinfo; fail_unless(vhpi_check_error(&errorinfo)); fail_unless(errorinfo.severity == vhpiError); vhpiValueT v_value = { .format = vhpiBinStrVal, .bufSize = 0, .value.str = NULL }; int need = vhpi_get_value(hv, &v_value); check_error(); vhpi_printf("need %d bytes for v string", need); v_value.value.str = malloc(need); v_value.bufSize = need; fail_if(v_value.value.str == NULL); fail_unless(vhpi_get_value(hv, &v_value) == 0); check_error(); vhpi_printf("v bit string '%s'", v_value.value.str); fail_unless(strcmp((char *)v_value.value.str, "0011") == 0); fail_unless(v_value.numElems == 4); free(v_value.value.str); v_value.bufSize = 0; v_value.value.enumvs = NULL; v_value.format = vhpiLogicVecVal; need = vhpi_get_value(hv, &v_value); check_error(); fail_unless(need = 4 * sizeof(vhpiEnumT)); v_value.bufSize = 4 * sizeof(vhpiEnumT); v_value.value.enumvs = malloc(v_value.bufSize); fail_unless(vhpi_get_value(hv, &v_value) == 0); fail_unless(v_value.numElems == 4); fail_unless(v_value.value.enumvs[0] == 0); fail_unless(v_value.value.enumvs[1] == 0); fail_unless(v_value.value.enumvs[2] == 1); fail_unless(v_value.value.enumvs[3] == 1); free(v_value.value.enumvs); vhpi_release_handle(root); vhpi_release_handle(hb); vhpi_release_handle(hv); } static void y_value_change(const vhpiCbDataT *cb_data) { vhpiTimeT now; vhpi_get_time(&now, NULL); fail_unless(now.low == cb_data->time->low); fail_unless(now.high == cb_data->time->high); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.numElems == 1); vhpi_printf("y value changed to %d", value.value.intg); if (value.value.intg == 75) { test_bin_str(); vhpi_put_value(handle_x, &value, vhpiRelease); check_error(); vhpi_control(vhpiFinish); check_error(); } else { value.value.intg++; vhpi_put_value(handle_x, &value, vhpiForcePropagate); check_error(); } } static vhpiHandleT defer_disable; static vhpiHandleT defer_enable; static void deferred_work(const vhpiCbDataT *cb_data) { vhpi_printf("deferred work callback!"); vhpi_disable_cb(defer_disable); vhpi_enable_cb(defer_enable); } static vhpiHandleT mutual_cb1[2], mutual_cb2[2], mutual_cb3[2]; static void mutual(const vhpiCbDataT *cb_data) { vhpi_printf("mutual callback!"); vhpiHandleT *cb = cb_data->user_data; vhpi_remove_cb(cb[0]); vhpi_remove_cb(cb[1]); } static void disabled_callback(const vhpiCbDataT *cb_data) { vhpi_printf("disabled callback!"); fail_if(1); } static void enabled_callback(const vhpiCbDataT *cb_data) { vhpi_printf("enabled callback!"); vhpiTimeT now; vhpi_get_time(&now, NULL); fail_unless(now.low == 5000002); fail_unless(now.high == 0); } static void after_5ns(const vhpiCbDataT *cb_data) { vhpi_printf("after_5ns callback!"); long cycles; vhpiTimeT now; vhpi_get_time(&now, &cycles); fail_unless(now.low == 5000000); fail_unless(now.high == 0); fail_unless(cycles == 0); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 6); value.value.intg = 70; vhpi_put_value(handle_x, &value, vhpiForcePropagate); check_error(); vhpiCbDataT cb_data2 = { .reason = vhpiCbValueChange, .cb_rtn = y_value_change, .obj = handle_y, .time = (vhpiTimeT *)-1 }; vhpi_register_cb(&cb_data2, 0); check_error(); cb_data2.cb_rtn = disabled_callback; vhpiHandleT cb = vhpi_register_cb(&cb_data2, vhpiReturnCb); check_error(); fail_if(vhpi_disable_cb(cb)); cb_data2.cb_rtn = mutual; cb_data2.user_data = mutual_cb1; mutual_cb1[0] = vhpi_register_cb(&cb_data2, vhpiReturnCb); check_error(); mutual_cb1[1] = vhpi_register_cb(&cb_data2, vhpiReturnCb); check_error(); vhpiTimeT time = { .low = 1 }; vhpiCbDataT cb_data3 = { .reason = vhpiCbAfterDelay, .cb_rtn = disabled_callback, .time = &time }; cb = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); fail_if(vhpi_disable_cb(cb)); cb = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); fail_if(vhpi_remove_cb(cb)); cb = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); fail_if(vhpi_disable_cb(cb)); fail_if(vhpi_remove_cb(cb)); vhpi_register_cb(&cb_data3, vhpiDisableCb); check_error(); time.low = 2; defer_disable = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); cb_data3.cb_rtn = enabled_callback; defer_enable = vhpi_register_cb(&cb_data3, vhpiReturnCb | vhpiDisableCb); check_error(); vhpiCbDataT cb_data4 = { .reason = vhpiCbAfterDelay, .cb_rtn = deferred_work, .time = &time, }; time.low = 1; vhpi_register_cb(&cb_data4, 0); check_error(); cb_data4.cb_rtn = mutual; cb_data4.user_data = mutual_cb2; mutual_cb2[0] = vhpi_register_cb(&cb_data4, vhpiReturnCb); check_error(); mutual_cb2[1] = vhpi_register_cb(&cb_data4, vhpiReturnCb); check_error(); vhpiCbDataT cb_data5 = { .reason = vhpiCbNextTimeStep, .cb_rtn = disabled_callback, }; cb = vhpi_register_cb(&cb_data5, vhpiReturnCb); check_error(); fail_if(vhpi_remove_cb(cb)); vhpi_release_handle(cb); cb_data5.cb_rtn = mutual; cb_data5.user_data = mutual_cb3; mutual_cb3[0] = vhpi_register_cb(&cb_data5, vhpiReturnCb); check_error(); mutual_cb3[1] = vhpi_register_cb(&cb_data5, vhpiReturnCb); check_error(); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("start of sim callback! user data is '%s'", (char *)cb_data->user_data); long cycles; vhpiTimeT now; vhpi_get_time(&now, &cycles); fail_unless(now.low == 0); fail_unless(now.high == 0); fail_unless(cycles == 0); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_x, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 0); value.value.intg = 5; vhpi_put_value(handle_x, &value, vhpiForcePropagate); check_error(); vhpiTimeT time_5ns = { .low = 5000000 }; vhpiCbDataT cb_data2 = { .reason = vhpiCbAfterDelay, .cb_rtn = after_5ns, .time = &time_5ns }; vhpi_register_cb(&cb_data2, 0); check_error(); vhpiTimeT next; fail_unless(vhpi_get_next_time(&next) == 0); fail_unless(next.high == 0); fail_unless(next.low == 5000000); } static void end_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("end of sim callback"); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 75); vhpi_release_handle(handle_x); vhpi_release_handle(handle_y); vhpi_release_handle(handle_sos); } static void end_of_init(const vhpiCbDataT *cb_data) { vhpi_printf("end of init callback"); vhpiHandleT tool = VHPI_CHECK(vhpi_handle(vhpiTool, NULL)); fail_if(tool == NULL); vhpi_printf("tool is %s", vhpi_get_str(vhpiNameP, tool)); vhpi_printf("tool version is %s", vhpi_get_str(vhpiToolVersionP, tool)); fail_unless(cb_data->time == NULL); fail_unless(cb_data->value == NULL); fail_unless(cb_data->obj == NULL); vhpiHandleT args = vhpi_iterator(vhpiArgvs, tool); fail_if(args == NULL); int i = 0; for (vhpiHandleT arg = vhpi_scan(args); arg != NULL; arg = vhpi_scan(args), i++) vhpi_printf("arg is %s", vhpi_get_str(vhpiStrValP, arg)); fail_unless(vhpi_get(vhpiArgcP, tool) == i); vhpi_release_handle(tool); vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpi_printf("root handle %p", root); const vhpiCharT *root_name = vhpi_get_str(vhpiNameP, root); vhpi_printf("root name is %s", root_name); vhpi_printf("root case name is %s", vhpi_get_str(vhpiCaseNameP, root)); vhpi_printf("root full name is %s", vhpi_get_str(vhpiFullNameP, root)); vhpi_printf("root full case name is %s", vhpi_get_str(vhpiFullCaseNameP, root)); fail_unless(vhpi_scan(root) == NULL); vhpiHandleT root_ports = vhpi_iterator(vhpiPortDecls, root); fail_if(root_ports == NULL); i = 0; for (vhpiHandleT port = vhpi_scan(root_ports); port != NULL; port = vhpi_scan(root_ports), i++) { vhpi_printf("root port is %s", vhpi_get_str(vhpiNameP, port)); vhpiHandleT by_index = vhpi_handle_by_index(vhpiPortDecls, root, i); fail_unless(vhpi_compare_handles(port, by_index)); } vhpiHandleT root_signals = vhpi_iterator(vhpiSigDecls, root); fail_if(root_signals == NULL); i = 0; for (vhpiHandleT decl = vhpi_scan(root_signals); decl != NULL; decl = vhpi_scan(root_signals)) vhpi_printf("root signal is %s", vhpi_get_str(vhpiNameP, decl)); vhpiHandleT root_decls = vhpi_iterator(vhpiDecls, root); fail_if(root_decls == NULL); i = 0; for (vhpiHandleT decl = vhpi_scan(root_decls); decl != NULL; decl = vhpi_scan(root_decls), i++) { vhpi_printf("root decl is %s", vhpi_get_str(vhpiNameP, decl)); vhpiHandleT by_index = vhpi_handle_by_index(vhpiDecls, root, i); fail_unless(vhpi_compare_handles(decl, by_index)); } vhpiHandleT arch = VHPI_CHECK(vhpi_handle(vhpiDesignUnit, root)); fail_if(arch == NULL); vhpi_printf("arch handle %p", arch); vhpi_printf("arch name is %s", vhpi_get_str(vhpiNameP, arch)); vhpi_printf("arch unit name is %s", vhpi_get_str(vhpiUnitNameP, arch)); vhpiHandleT entity = VHPI_CHECK(vhpi_handle(vhpiPrimaryUnit, arch)); fail_if(entity == NULL); vhpi_printf("entity handle %p", entity); vhpi_printf("entity name is %s", vhpi_get_str(vhpiNameP, entity)); vhpi_printf("entity unit name is %s", vhpi_get_str(vhpiUnitNameP, entity)); vhpi_release_handle(entity); vhpi_release_handle(arch); handle_x = VHPI_CHECK(vhpi_handle_by_name("x", root)); fail_if(handle_x == NULL); vhpi_printf("x handle %p", handle_x); vhpi_printf("x name %s", vhpi_get_str(vhpiNameP, handle_x)); vhpi_printf("x full name is %s", vhpi_get_str(vhpiFullNameP, handle_x)); handle_y = VHPI_CHECK(vhpi_handle_by_name("y", root)); fail_if(handle_y == NULL); vhpi_printf("y handle %p", handle_y); vhpi_printf("y name %s", vhpi_get_str(vhpiNameP, handle_y)); vhpi_printf("y full name is %s", vhpi_get_str(vhpiFullNameP, handle_y)); vhpiHandleT handle_y2 = VHPI_CHECK(vhpi_handle_by_name(":vhpi1.y", NULL)); fail_unless(vhpi_compare_handles(handle_y, handle_y2)); vhpi_release_handle(handle_y2); vhpiHandleT handle_y3 = VHPI_CHECK(vhpi_handle_by_name("vhpi1.y", NULL)); fail_unless(vhpi_compare_handles(handle_y, handle_y3)); vhpi_release_handle(handle_y3); fail_unless(vhpi_get(vhpiKindP, handle_x) == vhpiPortDeclK); fail_unless(vhpi_get(vhpiModeP, handle_x) == vhpiInMode); fail_unless(vhpi_get(vhpiModeP, handle_y) == vhpiOutMode); fail_unless(vhpi_get(vhpiIsLocalP, handle_x) == vhpiUndefined); vhpiErrorInfoT info; fail_unless(vhpi_check_error(&info)); vhpiHandleT handle_r = VHPI_CHECK(vhpi_handle_by_name("r", root)); fail_if(handle_r == NULL); vhpi_printf("r handle %p", handle_r); vhpiHandleT r_type = VHPI_CHECK(vhpi_handle(vhpiType, handle_r)); fail_if(r_type == NULL); vhpi_printf("r type handle %p", r_type); vhpi_printf("r type name is %s", vhpi_get_str(vhpiNameP, r_type)); vhpi_printf("r type full name is %s", vhpi_get_str(vhpiFullNameP, r_type)); vhpiHandleT r_constrs = VHPI_CHECK(vhpi_iterator(vhpiConstraints, r_type)); fail_if(r_constrs == NULL); vhpiHandleT r_range = VHPI_CHECK(vhpi_scan(r_constrs)); fail_if(r_range == NULL); fail_unless(vhpi_scan(r_constrs) == NULL); vhpi_printf("r type range handle %p", r_range); vhpi_printf("r left bound %f", vhpi_get_real(vhpiFloatLeftBoundP, r_range)); vhpi_printf("r right bound %f", vhpi_get_real(vhpiFloatRightBoundP, r_range)); fail_unless(vhpi_get_real(vhpiFloatLeftBoundP, r_range) == 0.0); fail_unless(vhpi_get_real(vhpiFloatRightBoundP, r_range) == 1.0); vhpi_release_handle(r_range); vhpi_release_handle(r_constrs); vhpi_release_handle(r_type); vhpiHandleT handle_v = VHPI_CHECK(vhpi_handle_by_name("v", root)); fail_if(handle_v == NULL); vhpi_printf("v handle %p", handle_v); vhpi_printf("v name is %s", vhpi_get_str(vhpiNameP, handle_v)); vhpi_printf("v full name is %s", vhpi_get_str(vhpiFullNameP, handle_v)); fail_unless(vhpi_get(vhpiStaticnessP, handle_v) == vhpiDynamic); vhpiHandleT v_type = VHPI_CHECK(vhpi_handle(vhpiType, handle_v)); fail_if(v_type == NULL); vhpi_printf("v type handle %p", v_type); vhpi_printf("v type name is %s", vhpi_get_str(vhpiNameP, v_type)); vhpi_printf("v type full name is %s", vhpi_get_str(vhpiFullNameP, v_type)); vhpi_printf("v dimensions %d", vhpi_get(vhpiNumDimensionsP, v_type)); fail_if(vhpi_get(vhpiIsUnconstrainedP, v_type)); vhpiHandleT v_constrs = VHPI_CHECK(vhpi_iterator(vhpiConstraints, v_type)); fail_if(v_constrs == NULL); vhpiHandleT v_range = VHPI_CHECK(vhpi_scan(v_constrs)); fail_if(v_range == NULL); fail_unless(vhpi_scan(v_constrs) == NULL); vhpi_printf("v type range handle %p", v_range); vhpi_printf("v left bound %d", vhpi_get(vhpiLeftBoundP, v_range)); vhpi_printf("v right bound %d", vhpi_get(vhpiRightBoundP, v_range)); vhpiHandleT v_elem = VHPI_CHECK(vhpi_handle(vhpiElemType, v_type)); vhpi_printf("v elem type handle %p", v_elem); vhpi_printf("v elem type name is %s", vhpi_get_str(vhpiNameP, v_elem)); vhpi_printf("v elem type full name is %s", vhpi_get_str(vhpiFullNameP, v_elem)); vhpiIntT nlits = VHPI_CHECK(vhpi_get(vhpiNumLiteralsP, v_elem)); vhpiHandleT v_lits = vhpi_iterator(vhpiEnumLiterals, v_elem); i = 0; for (vhpiHandleT lit = vhpi_scan(v_lits); lit != NULL; lit = vhpi_scan(v_lits), i++) { vhpi_printf("v elem literal %d is %s", i, vhpi_get_str(vhpiStrValP, lit)); fail_unless(vhpi_get(vhpiPositionP, lit) == i); } fail_unless(i == nlits); vhpiHandleT v_names = vhpi_iterator(vhpiIndexedNames, handle_v); fail_if(v_names == NULL); for (vhpiHandleT name = vhpi_scan(v_names); name != NULL; name = vhpi_scan(v_names)) vhpi_printf("v indexed name is %s", vhpi_get_str(vhpiNameP, name)); vhpiHandleT handle_case = VHPI_CHECK(vhpi_handle_by_name("a_name_with_mixed_case", root)); fail_if(handle_case == NULL); vhpi_printf("handle %p", handle_case); vhpi_printf("name is %s", vhpi_get_str(vhpiNameP, handle_case)); vhpi_printf("case name is %s", vhpi_get_str(vhpiCaseNameP, handle_case)); vhpi_printf("full case name is %s", vhpi_get_str(vhpiFullCaseNameP, handle_case)); vhpiHandleT handle_error = vhpi_handle_by_name("sfdf", root); fail_unless(vhpi_check_error(&info)); fail_unless(handle_error == NULL); vhpi_release_handle(root); check_error(); // Releasing the handle twice should report an error vhpi_release_handle(root); fail_unless(vhpi_check_error(&info)); } void vhpi1_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, .user_data = (char *)"some user data", }; handle_sos = VHPI_CHECK(vhpi_register_cb(&cb_data1, vhpiReturnCb)); fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable); vhpiCbDataT cb_data_rtn; vhpi_get_cb_info(handle_sos, &cb_data_rtn); fail_unless(cb_data_rtn.reason == vhpiCbStartOfSimulation); fail_unless(cb_data_rtn.cb_rtn == start_of_sim); fail_unless(cb_data_rtn.user_data == cb_data1.user_data); vhpiCbDataT cb_data2 = { .reason = vhpiCbEndOfSimulation, .cb_rtn = end_of_sim }; VHPI_CHECK(vhpi_register_cb(&cb_data2, 0)); vhpiCbDataT cb_data3 = { .reason = vhpiCbEndOfInitialization, .cb_rtn = end_of_init, .obj = (vhpiHandleT)0x123456, .time = (vhpiTimeT *)0xdeadbeef, .value = (vhpiValueT *)0x5add00d, }; vhpi_register_cb(&cb_data3, 0); vhpiErrorInfoT info; fail_unless(vhpi_check_error(&info)); fail_unless(info.severity == vhpiWarning); } nvc-r1.17.1/test/vhpi/vhpi10.c000066400000000000000000000225101504111170000157370ustar00rootroot00000000000000#include "vhpi_test.h" #include static vhpiHandleT handle_sos; static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT g0 = vhpi_handle_by_name("g0", root); check_error(); fail_if(g0 == NULL); vhpi_printf("g0 handle %p", g0); fail_unless(vhpi_get(vhpiKindP, g0) == vhpiGenericDeclK); fail_unless(vhpi_get(vhpiModeP, g0) == vhpiInMode); fail_unless(vhpi_get(vhpiIsLocalP, g0) == vhpiFalse); vhpiHandleT it1 = vhpi_iterator(vhpiGenericDecls, root); fail_if(it1 == NULL); fail_unless(vhpi_compare_handles(vhpi_scan(it1), g0)); vhpiHandleT g1 = vhpi_scan(it1); fail_if(g1 == NULL); fail_unless(vhpi_scan(it1) == NULL); vhpiHandleT c0 = vhpi_handle_by_name("c0", root); check_error(); fail_if(c0 == NULL); vhpi_printf("c0 handle %p", c0); fail_unless(vhpi_get(vhpiKindP, c0) == vhpiConstDeclK); vhpiHandleT it2 = vhpi_iterator(vhpiConstDecls, root); fail_if(it2 == NULL); fail_unless(vhpi_compare_handles(vhpi_scan(it2), c0)); vhpiHandleT c1 = vhpi_scan(it2); fail_if(c1 == NULL); fail_unless(vhpi_get(vhpiKindP, c1) == vhpiConstDeclK); fail_unless(vhpi_scan(it2) == NULL); vhpi_release_handle(it2); vhpiHandleT s0 = vhpi_handle_by_name("s0", root); check_error(); fail_if(s0 == NULL); fail_unless(vhpi_get(vhpiKindP, s0) == vhpiSigDeclK); vhpiHandleT b0 = vhpi_handle_by_name("b0", root); check_error(); fail_if(b0 == NULL); vhpi_printf("b0 handle %p", b0); fail_unless(vhpi_get(vhpiKindP, b0) == vhpiBlockStmtK); fail_if(vhpi_get(vhpiIsGuardedP, b0)); fail_if(vhpi_get(vhpiIsSeqStmtP, b0)); vhpi_printf("b0 label %s", vhpi_get_str(vhpiLabelNameP, b0)); check_string(vhpi_get_str(vhpiLabelNameP, b0), "b0"); vhpiHandleT b0s0 = vhpi_handle_by_name("s0", b0); check_error(); fail_if(b0s0 == NULL); fail_unless(vhpi_get(vhpiKindP, b0s0) == vhpiSigDeclK); vhpiHandleT it3 = vhpi_iterator(vhpiBlockStmts, root); fail_if(it3 == NULL); fail_unless(vhpi_compare_handles(vhpi_scan(it3), b0)); vhpiHandleT b1 = vhpi_scan(it3); fail_if(b1 == NULL); fail_unless(vhpi_get(vhpiIsGuardedP, b1)); fail_unless(vhpi_scan(it3) == NULL); vhpi_release_handle(it3); vhpiHandleT b1s0 = vhpi_handle_by_name("s0", b1); check_error(); fail_if(b1s0 == NULL); fail_unless(vhpi_get(vhpiKindP, b1s0) == vhpiSigDeclK); vhpiHandleT i0 = vhpi_handle_by_name("i0", root); check_error(); fail_if(i0 == NULL); vhpi_printf("i0 handle %p", i0); fail_unless(vhpi_get(vhpiKindP, i0) == vhpiCompInstStmtK); fail_if(vhpi_get(vhpiIsSeqStmtP, i0)); vhpi_printf("io label %s", vhpi_get_str(vhpiLabelNameP, i0)); check_string(vhpi_get_str(vhpiLabelNameP, i0), "i0"); vhpiHandleT i0_du = vhpi_handle(vhpiDesignUnit, i0); check_error(); fail_if(i0_du == NULL); fail_unless(vhpi_get(vhpiKindP, i0_du) == vhpiArchBodyK); vhpiHandleT i0_primary = vhpi_handle(vhpiPrimaryUnit, i0_du); check_error(); fail_if(i0_primary == NULL); fail_unless(vhpi_get(vhpiKindP, i0_primary) == vhpiEntityDeclK); vhpiHandleT it4 = vhpi_iterator(vhpiCompInstStmts, root); fail_if(it4 == NULL); fail_unless(vhpi_compare_handles(vhpi_scan(it4), i0)); fail_unless(vhpi_scan(it4) == NULL); vhpi_release_handle(it4); vhpiHandleT sub_b0 = vhpi_handle_by_name("sub_b0", i0); check_error(); fail_if(sub_b0 == NULL); fail_unless(vhpi_get(vhpiKindP, sub_b0) == vhpiBlockStmtK); vhpi_printf("sub_b0 label %s", vhpi_get_str(vhpiLabelNameP, sub_b0)); check_string(vhpi_get_str(vhpiLabelNameP, sub_b0), "sub_b0"); vhpiHandleT sub_b0_2 = VHPI_CHECK(vhpi_handle_by_name("i0.sub_b0", root)); fail_unless(vhpi_compare_handles(sub_b0, sub_b0_2)); vhpiHandleT it5 = vhpi_iterator(vhpiBlockStmts, i0); fail_if(it5 == NULL); fail_unless(vhpi_compare_handles(vhpi_scan(it5), sub_b0)); fail_unless(vhpi_scan(it5) == NULL); vhpi_release_handle(it5); vhpiHandleT genblk1 = vhpi_handle_by_name("I0.FORGEN1(1)", root); check_error(); fail_if(genblk1 == NULL); fail_unless(vhpi_get(vhpiKindP, genblk1) == vhpiForGenerateK); fail_unless(vhpi_get(vhpiGenerateIndexP, genblk1) == 1); vhpi_printf("genblk1 CaseName is %s", (char *)vhpi_get_str(vhpiCaseNameP, genblk1)); //fail_unless(strcmp((char *)vhpi_get_str(vhpiCaseNameP, genblk1), "ForGen1(1)") == 0); vhpiHandleT genblk1_i = vhpi_handle_by_name("I", genblk1); check_error(); fail_if(genblk1_i == NULL); fail_unless(vhpi_get(vhpiKindP, genblk1_i) == vhpiConstDeclK); vhpiHandleT genblk1_i_2 = vhpi_handle(vhpiParamDecl, genblk1); fail_unless(vhpi_compare_handles(genblk1_i, genblk1_i_2)); vhpiHandleT genblk1_s = vhpi_handle_by_name("S", genblk1); check_error(); fail_if(genblk1_s == NULL); fail_unless(vhpi_get(vhpiKindP, genblk1_s) == vhpiSigDeclK); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(g0, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 42); fail_unless(value.numElems == 1); vhpi_get_value(genblk1_i, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 1); fail_unless(value.numElems == 1); value.format = vhpiObjTypeVal; vhpi_get_value(c0, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 5); fail_unless(value.numElems == 1); value.format = vhpiObjTypeVal; vhpi_get_value(c1, &value); check_error(); fail_unless(value.format == vhpiRealVal); vhpi_printf("value=%f", value.value.real); fail_unless(value.value.real == 1.5); fail_unless(value.numElems == 1); vhpiHandleT i0g0 = vhpi_handle_by_name("i0.g0", root); check_error(); fail_if(i0g0 == NULL); vhpi_printf("i0g0 handle %p", i0g0); fail_unless(vhpi_get(vhpiKindP, i0g0) == vhpiGenericDeclK); value.format = vhpiObjTypeVal; vhpi_get_value(i0g0, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 100); fail_unless(value.numElems == 1); value.format = vhpiObjTypeVal; value.bufSize = 0; value.value.str = NULL; const int bufsz = vhpi_get_value(g1, &value); check_error(); fail_unless(value.format == vhpiStrVal); fail_unless(bufsz == 6); vhpiCharT str[6]; value.value.str = str; value.bufSize = sizeof(str); vhpi_get_value(g1, &value); check_error(); fail_unless(value.numElems == 5); vhpi_printf("g1 value '%s'", (char *)str); fail_unless(strcmp((char *)str, "hello") == 0); fail_unless(vhpi_get(vhpiSizeP, g1) == 5); vhpiHandleT i0g1 = vhpi_handle_by_name("i0.g1", root); check_error(); fail_if(i0g1 == NULL); vhpi_printf("i0g1 handle %p", i0g1); fail_unless(vhpi_get(vhpiKindP, i0g1) == vhpiGenericDeclK); value.value.str = str; value.bufSize = sizeof(str); vhpi_get_value(i0g1, &value); check_error(); fail_unless(value.numElems == 5); vhpi_printf("i0g1 value '%s'", (char *)str); fail_unless(strcmp((char *)str, "world") == 0); fail_unless(vhpi_get(vhpiSizeP, i0g1) == 5); vhpiHandleT i0g1_type = vhpi_handle(vhpiType, i0g1); check_error(); fail_if(i0g1_type == NULL); vhpi_printf("i0g1 type handle %p", i0g1_type); vhpi_printf("i0g1 type name is %s", vhpi_get_str(vhpiNameP, i0g1_type)); vhpi_printf("i0g1 type full name is %s", vhpi_get_str(vhpiFullNameP, i0g1_type)); vhpi_printf("i0g1 dimensions %d", vhpi_get(vhpiNumDimensionsP, i0g1_type)); fail_unless(vhpi_get(vhpiKindP, i0g1_type) == vhpiSubtypeDeclK); fail_if(vhpi_get(vhpiIsUnconstrainedP, i0g1_type)); vhpiHandleT i0g1_constrs = vhpi_iterator(vhpiConstraints, i0g1_type); check_error(); fail_if(i0g1_constrs == NULL); vhpiHandleT i0g1_range = vhpi_scan(i0g1_constrs); check_error(); fail_if(i0g1_range == NULL); fail_unless(vhpi_scan(i0g1_constrs) == NULL); vhpi_printf("i0g1 type range handle %p", i0g1_range); vhpi_printf("i0g1 left bound %d", vhpi_get(vhpiLeftBoundP, i0g1_range)); vhpi_printf("i0g1 right bound %d", vhpi_get(vhpiRightBoundP, i0g1_range)); fail_unless(vhpi_get(vhpiLeftBoundP, i0g1_range) == 1); fail_unless(vhpi_get(vhpiRightBoundP, i0g1_range) == 5); vhpiHandleT i0p0 = vhpi_handle_by_name("i0.p0", root); check_error(); fail_if(i0g1 == NULL); vhpi_printf("i0p0 handle %p", i0p0); fail_unless(vhpi_get(vhpiKindP, i0p0) == vhpiPortDeclK); value.format = vhpiBinStrVal; value.value.str = str; value.bufSize = sizeof(str); vhpi_get_value(i0p0, &value); check_error(); fail_unless(value.numElems == 3); vhpi_printf("i0p0 value '%s'", (char *)str); fail_unless(strcmp((char *)str, "101") == 0); fail_unless(vhpi_get(vhpiSizeP, i0g1) == 5); vhpi_release_handle(handle_sos); } void vhpi10_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, .user_data = (char *)"some user data", }; handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable); } nvc-r1.17.1/test/vhpi/vhpi11.c000066400000000000000000000170621504111170000157460ustar00rootroot00000000000000// // Copyright (C) 2023 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include static vhpiHandleT handle_sos; static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT g0 = vhpi_handle_by_name("g0", root); check_error(); fail_if(g0 == NULL); vhpi_printf("g0 handle %p", g0); fail_unless(vhpi_get(vhpiKindP, g0) == vhpiGenericDeclK); fail_unless(vhpi_get(vhpiModeP, g0) == vhpiInMode); fail_unless(vhpi_get(vhpiIsLocalP, g0) == vhpiFalse); vhpiHandleT g0x = vhpi_handle_by_name("g0.x", root); check_error(); fail_if(g0x == NULL); vhpi_printf("g0x handle %p", g0x); fail_unless(vhpi_get(vhpiKindP, g0x) == vhpiSelectedNameK); check_string(vhpi_get_str(vhpiNameP, g0x), "G0.X"); check_string(vhpi_get_str(vhpiCaseNameP, g0x), "g0.x"); check_string(vhpi_get_str(vhpiFullNameP, g0x), ":VHPI11:G0.X"); check_string(vhpi_get_str(vhpiFullCaseNameP, g0x), ":vhpi11:g0.x"); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(g0x, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("g0.x value=%d", value.value.intg); fail_unless(value.value.intg == 55); fail_unless(value.numElems == 1); vhpiHandleT g0y = vhpi_handle_by_name("g0.y", root); check_error(); value.format = vhpiObjTypeVal; value.bufSize = 0; value.value.str = NULL; const int bufsz = vhpi_get_value(g0y, &value); check_error(); fail_unless(value.format == vhpiStrVal); fail_unless(bufsz == 6); vhpiCharT str[6]; value.value.str = str; value.bufSize = sizeof(str); vhpi_get_value(g0y, &value); check_error(); fail_unless(value.numElems == 5); vhpi_printf("g0.y value '%s'", (char *)str); fail_unless(strcmp((char *)str, "hello") == 0); fail_unless(vhpi_get(vhpiSizeP, g0y) == 5); vhpiHandleT g0y2 = vhpi_handle_by_index(vhpiIndexedNames, g0y, 2); check_error(); fail_if(g0y2 == NULL); value.format = vhpiCharVal; VHPI_CHECK(vhpi_get_value(g0y2, &value)); vhpi_printf("g0.y(2) value=%c", value.value.ch); fail_unless(value.value.ch == 'l'); fail_unless(value.numElems == 1); vhpiHandleT s_sig = VHPI_CHECK(vhpi_handle_by_name("s", root)); vhpi_printf("s_sig handle %p", s_sig); vhpiHandleT s_type = VHPI_CHECK(vhpi_handle(vhpiBaseType, s_sig)); fail_unless(vhpi_get(vhpiKindP, s_type) == vhpiRecordTypeDeclK); { vhpiHandleT it = VHPI_CHECK(vhpi_iterator(vhpiRecordElems, s_type)); vhpiHandleT x_elem = VHPI_CHECK(vhpi_scan(it)); fail_if(x_elem == NULL); fail_unless(vhpi_get(vhpiKindP, x_elem) == vhpiElemDeclK); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, x_elem), "X") == 0); fail_unless(vhpi_get(vhpiPositionP, x_elem) == 0); vhpiHandleT x_type = VHPI_CHECK(vhpi_handle(vhpiType, x_elem)); fail_unless(vhpi_get(vhpiKindP, x_type) == vhpiSubtypeDeclK); vhpiHandleT x_base = VHPI_CHECK(vhpi_handle(vhpiBaseType, x_elem)); fail_unless(vhpi_get(vhpiKindP, x_base) == vhpiIntTypeDeclK); fail_if(vhpi_compare_handles(x_type, x_base)); vhpiHandleT y_elem = VHPI_CHECK(vhpi_scan(it)); fail_if(y_elem == NULL); fail_unless(vhpi_get(vhpiKindP, y_elem) == vhpiElemDeclK); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, y_elem), "Y") == 0); fail_unless(vhpi_get(vhpiPositionP, y_elem) == 1); vhpiHandleT y_type = VHPI_CHECK(vhpi_handle(vhpiType, y_elem)); fail_unless(vhpi_get(vhpiKindP, y_type) == vhpiArrayTypeDeclK); vhpiHandleT y_base = VHPI_CHECK(vhpi_handle(vhpiBaseType, y_elem)); fail_unless(vhpi_get(vhpiKindP, y_base) == vhpiArrayTypeDeclK); fail_unless(vhpi_compare_handles(y_type, y_base)); fail_unless(vhpi_scan(it) == NULL); vhpi_release_handle(it); } vhpi_release_handle(s_type); vhpi_release_handle(s_sig); vhpiHandleT t_sig = VHPI_CHECK(vhpi_handle_by_name("t", root)); vhpi_printf("t_sig handle %p", t_sig); vhpiHandleT t_base = VHPI_CHECK(vhpi_handle(vhpiBaseType, t_sig)); fail_unless(vhpi_get(vhpiKindP, t_base) == vhpiArrayTypeDeclK); { vhpiHandleT it = VHPI_CHECK(vhpi_iterator(vhpiConstraints, t_base)); vhpiHandleT range = VHPI_CHECK(vhpi_scan(it)); vhpi_printf("t_base left bound %d", vhpi_get(vhpiLeftBoundP, range)); vhpi_printf("t_base right bound %d", vhpi_get(vhpiRightBoundP, range)); // XXX: should be undefined/unconstrained! fail_unless(vhpi_get(vhpiLeftBoundP, range) == 1); fail_unless(vhpi_get(vhpiRightBoundP, range) == 3); fail_unless(vhpi_get(vhpiIsUpP, range)); vhpi_release_handle(range); fail_unless(vhpi_scan(it) == NULL); vhpi_release_handle(it); } vhpiHandleT t_elem = VHPI_CHECK(vhpi_handle(vhpiElemType, t_base)); // XXX: should be vhpiSubtypeDeclk fail_unless(vhpi_get(vhpiKindP, t_elem) == vhpiArrayTypeDeclK); { vhpiHandleT it = VHPI_CHECK(vhpi_iterator(vhpiConstraints, t_elem)); vhpiHandleT range = VHPI_CHECK(vhpi_scan(it)); vhpi_printf("t_elem left bound %d", vhpi_get(vhpiLeftBoundP, range)); vhpi_printf("t_elem right bound %d", vhpi_get(vhpiRightBoundP, range)); fail_unless(vhpi_get(vhpiLeftBoundP, range) == 7); fail_unless(vhpi_get(vhpiRightBoundP, range) == 0); fail_if(vhpi_get(vhpiIsUpP, range)); vhpi_release_handle(range); fail_unless(vhpi_scan(it) == NULL); vhpi_release_handle(it); } vhpi_release_handle(t_elem); vhpi_release_handle(t_base); vhpi_release_handle(t_sig); vhpiHandleT u_sig = VHPI_CHECK(vhpi_handle_by_name("u", root)); vhpi_printf("u_sig handle %p", u_sig); vhpiHandleT u_base = VHPI_CHECK(vhpi_handle(vhpiBaseType, u_sig)); fail_unless(vhpi_get(vhpiKindP, u_base) == vhpiArrayTypeDeclK); vhpiHandleT u_elem = VHPI_CHECK(vhpi_handle(vhpiElemType, u_base)); fail_unless(vhpi_get(vhpiKindP, u_elem) == vhpiSubtypeDeclK); { vhpiHandleT it = VHPI_CHECK(vhpi_iterator(vhpiConstraints, u_elem)); vhpiHandleT range = VHPI_CHECK(vhpi_scan(it)); vhpi_printf("u_elem left bound %d", vhpi_get(vhpiLeftBoundP, range)); vhpi_printf("u_elem right bound %d", vhpi_get(vhpiRightBoundP, range)); fail_unless(vhpi_get(vhpiLeftBoundP, range) == 3); fail_unless(vhpi_get(vhpiRightBoundP, range) == 0); fail_if(vhpi_get(vhpiIsUpP, range)); vhpi_release_handle(range); fail_unless(vhpi_scan(it) == NULL); vhpi_release_handle(it); } vhpi_release_handle(u_elem); vhpi_release_handle(u_base); vhpi_release_handle(u_sig); vhpi_release_handle(handle_sos); } void vhpi11_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable); } nvc-r1.17.1/test/vhpi/vhpi12.c000066400000000000000000000100701504111170000157370ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" static vhpiHandleT h_sos; static vhpiHandleT h_clk; static vhpiHandleT h_d; static vhpiHandleT h_q; static vhpiHandleT h_timeout; static void register_timeout(void); static void set_clk(vhpiSmallEnumT bit) { vhpiValueT val = { .format = vhpiLogicVal, }; val.value.enumv = bit; vhpi_put_value(h_clk, &val, vhpiDepositPropagate); check_error(); } static vhpiSmallEnumT get_clk(void) { vhpiValueT val = { .format = vhpiLogicVal, }; vhpi_get_value(h_clk, &val); check_error(); return val.value.enumv; } static void set_d(vhpiSmallEnumT bit) { vhpiValueT val = { .format = vhpiLogicVal, }; val.value.enumv = bit; vhpi_put_value(h_d, &val, vhpiDepositPropagate); check_error(); } static vhpiSmallEnumT get_q(void) { vhpiValueT val = { .format = vhpiLogicVal, }; vhpi_get_value(h_q, &val); check_error(); return val.value.enumv; } static void check_q_2(const vhpiCbDataT *cb_data) { vhpi_printf("check q 2"); vhpiSmallEnumT q = get_q(); vhpi_printf("q value %x", q); fail_unless(q == vhpiH); // XXX: vhpi1 } static void check_q_1(const vhpiCbDataT *cb_data) { vhpi_printf("check q 1"); vhpiSmallEnumT q = get_q(); vhpi_printf("q value %x", q); fail_unless(q == vhpi1); // XXX: vhpiH set_clk(vhpi1); vhpiCbDataT next_cb = { .reason = vhpiCbStartOfNextCycle, .cb_rtn = check_q_2, }; vhpi_register_cb(&next_cb, 0); check_error(); } static void toggle_clock(const vhpiCbDataT *cb_data) { vhpi_printf("toggle clock"); if (get_clk() == vhpi1) { set_clk(vhpi0); vhpiSmallEnumT q = get_q(); vhpi_printf("q value %x", q); fail_unless(q == vhpi1); } else set_clk(vhpi1); vhpi_release_handle(h_timeout); static int rep = 11; if (rep-- > 0) register_timeout(); else { vhpiValueT val = { .format = vhpiLogicVal, .value = { .enumv = vhpiH }, }; vhpi_put_value(h_q, &val, vhpiDepositPropagate); vhpiCbDataT next_cb = { .reason = vhpiCbStartOfNextCycle, .cb_rtn = check_q_1, }; vhpi_register_cb(&next_cb, 0); check_error(); } } static void register_timeout(void) { vhpiTimeT time = { .low = 1000000 }; vhpiCbDataT delay_cb = { .reason = vhpiCbAfterDelay, .cb_rtn = toggle_clock, .time = &time }; h_timeout = vhpi_register_cb(&delay_cb, vhpiReturnCb); check_error(); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); h_clk = vhpi_handle_by_name("clk", root); check_error(); fail_if(h_clk == NULL); vhpi_printf("clk handle %p", h_clk); h_d = vhpi_handle_by_name("d", root); check_error(); fail_if(h_d == NULL); vhpi_printf("d handle %p", h_d); h_q = vhpi_handle_by_name("q", root); check_error(); fail_if(h_q == NULL); vhpi_printf("q handle %p", h_q); set_clk(vhpi0); set_d(vhpi1); set_d(vhpi1); // Should not crash if called twice register_timeout(); vhpi_release_handle(h_sos); } void vhpi12_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; h_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); } nvc-r1.17.1/test/vhpi/vhpi13.c000066400000000000000000000053351504111170000157500ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include #include static bool end_of_sim_called = false; static int num_next_time_step = 0; static vhpiHandleT never_call_handle_1 = NULL; static vhpiHandleT never_call_handle_2 = NULL; static void rep_next_time_step(const vhpiCbDataT *cb_data) { vhpi_printf("rep_next_time_step"); num_next_time_step++; if (num_next_time_step == 2) { vhpi_enable_cb(never_call_handle_1); vhpi_release_handle(never_call_handle_1); } } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("start of sim"); vhpi_disable_cb(never_call_handle_1); vhpi_disable_cb(never_call_handle_2); } static void end_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("end of sim"); end_of_sim_called = true; vhpi_printf("num_next_time_step = %d", num_next_time_step); fail_unless(num_next_time_step == 4); vhpi_remove_cb(never_call_handle_2); } static void never_call(const vhpiCbDataT *cb_data) { vhpi_printf("callback should never be called!"); fail_if(1); } static void check_end_of_sim_called(void) { fail_unless(end_of_sim_called); } void vhpi13_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data1, 0); check_error(); vhpiCbDataT cb_data2 = { .reason = vhpiCbEndOfSimulation, .cb_rtn = end_of_sim, }; vhpi_register_cb(&cb_data2, 0); check_error(); vhpiCbDataT cb_data3 = { .reason = vhpiCbRepNextTimeStep, .cb_rtn = rep_next_time_step, }; vhpi_register_cb(&cb_data3, 0); check_error(); vhpiCbDataT cb_data4 = { .reason = vhpiCbNextTimeStep, .cb_rtn = never_call, }; never_call_handle_1 = vhpi_register_cb(&cb_data4, vhpiReturnCb); check_error(); vhpiCbDataT cb_data5 = { .reason = vhpiCbRepNextTimeStep, .cb_rtn = never_call, }; never_call_handle_2 = vhpi_register_cb(&cb_data5, vhpiReturnCb); check_error(); atexit(check_end_of_sim_called); } nvc-r1.17.1/test/vhpi/vhpi14.c000066400000000000000000000166151504111170000157540ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include #include #include #include static void add2(const vhpiCbDataT *cb_data_p) { vhpiHandleT p0 = vhpi_handle_by_index(vhpiParamDecls, cb_data_p->obj, 0); check_error(); fail_if(p0 == NULL); fail_unless(vhpi_get(vhpiKindP, p0) == vhpiConstParamDeclK); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, p0), "X") == 0); vhpiValueT p0val = { .format = vhpiIntVal }; fail_unless(vhpi_get_value(p0, &p0val) == 0); check_error(); printf("add2 called p0=%p[%d]\n", p0, p0val.value.intg); vhpiValueT result = { .format = vhpiIntVal, .value = { .intg = p0val.value.intg + 2 } }; vhpi_put_value(cb_data_p->obj, &result, vhpiDeposit); check_error(); vhpi_release_handle(p0); } static void popcount(const vhpiCbDataT *cb_data_p) { vhpiHandleT p0 = vhpi_handle_by_index(vhpiParamDecls, cb_data_p->obj, 0); check_error(); fail_if(p0 == NULL); fail_unless(vhpi_get(vhpiKindP, p0) == vhpiConstParamDeclK); vhpiValueT arg = { .format = vhpiBinStrVal, .bufSize = 0, .value.str = NULL }; int need = vhpi_get_value(p0, &arg); check_error(); vhpi_printf("need %d bytes for p0 string", need); arg.value.str = malloc(need); arg.bufSize = need; fail_unless(vhpi_get_value(p0, &arg) == 0); check_error(); vhpi_printf("argument %s", arg.value.str); vhpiValueT result = { .format = vhpiIntVal, .value = { .intg = 0 } }; for (int i = 0; i < need; i++) { if (arg.value.str[i] == '1') result.value.intg++; } vhpi_put_value(cb_data_p->obj, &result, vhpiDeposit); check_error(); free(arg.value.str); vhpi_release_handle(p0); } static void test1(const vhpiCbDataT *cb_data_p) { vhpiHandleT p0 = vhpi_handle_by_index(vhpiParamDecls, cb_data_p->obj, 0); check_error(); fail_if(p0 == NULL); fail_unless(vhpi_get(vhpiKindP, p0) == vhpiVarParamDeclK); vhpiHandleT p1 = vhpi_handle_by_index(vhpiParamDecls, cb_data_p->obj, 1); check_error(); fail_if(p1 == NULL); fail_unless(vhpi_get(vhpiKindP, p1) == vhpiConstParamDeclK); vhpiValueT p1_value = { .format = vhpiIntVal }; fail_unless(vhpi_get_value(p1, &p1_value) == 0); check_error(); vhpiValueT p0_value = { .format = vhpiIntVecVal, .bufSize = 0, .value.intgs = NULL }; int need = vhpi_get_value(p0, &p0_value); check_error(); vhpi_printf("need %d bytes for p0 array", need); p0_value.value.intgs = malloc(need * 2); p0_value.bufSize = need; fail_if(vhpi_get_value(p0, &p0_value) == -1); check_error(); fail_unless(p0_value.numElems == 4); for (int i = 0; i < p0_value.numElems; i++) { vhpi_printf("[%d] = %d + %d\n", i, p0_value.value.intgs[i], p1_value.value.intg); p0_value.value.intgs[i] += p1_value.value.intg; } vhpi_put_value(p0, &p0_value, vhpiDeposit); check_error(); fail_unless(vhpi_put_value(cb_data_p->obj, &p0_value, vhpiSizeConstraint) == 1); p0_value.bufSize = need * 2; // Out of bounds fail_if(vhpi_put_value(p0, &p0_value, vhpiDeposit) == 0); free(p0_value.value.intgs); vhpi_release_handle(p0); vhpi_release_handle(p1); } static void iota(const vhpiCbDataT *cb_data_p) { vhpiHandleT p0 = vhpi_handle_by_index(vhpiParamDecls, cb_data_p->obj, 0); check_error(); fail_if(p0 == NULL); fail_unless(vhpi_get(vhpiKindP, p0) == vhpiConstParamDeclK); fail_unless(strcmp((char *)vhpi_get_str(vhpiNameP, p0), "N") == 0); vhpiValueT p0_value = { .format = vhpiIntVal }; fail_unless(vhpi_get_value(p0, &p0_value) == 0); check_error(); vhpiValueT result = { .format = vhpiIntVecVal, .bufSize = p0_value.value.intg * sizeof(vhpiIntT), .numElems = p0_value.value.intg, }; vhpi_put_value(cb_data_p->obj, &result, vhpiSizeConstraint); check_error(); result.value.intgs = malloc(result.bufSize); for (int i = 0; i < p0_value.value.intg; i++) result.value.intgs[i] = i; vhpi_put_value(cb_data_p->obj, &result, vhpiDeposit); check_error(); free(result.value.intgs); vhpi_release_handle(p0); } static void no_args(const vhpiCbDataT *cb_data_p) { vhpi_printf("no_args called\n"); vhpiHandleT it = vhpi_iterator(vhpiParamDecls, cb_data_p->obj); check_error(); fail_if(it == NULL); fail_unless(vhpi_scan(it) == NULL); vhpi_release_handle(it); } static void set_logic(const vhpiCbDataT *cb_data_p) { vhpiHandleT iter, var_param, dummy_param; iter = vhpi_iterator(vhpiParamDecls, cb_data_p->obj); var_param = vhpi_scan(iter); // -> first out argument "var" dummy_param = vhpi_scan(iter); vhpi_release_handle(iter); vhpiValueT value; value.format = vhpiLogicVal; value.value.enumv = vhpi1; vhpi_put_value(var_param, &value, vhpiDepositPropagate); check_error(); vhpiErrorInfoT info; vhpi_put_value(dummy_param, &value, vhpiDepositPropagate); fail_unless(vhpi_check_error(&info)); vhpi_release_handle(var_param); vhpi_release_handle(dummy_param); } void vhpi14_startup(void) { vhpiForeignDataT add2_data = { .kind = vhpiFuncF, .libraryName = "lib", .modelName = "add2", .execf = add2, }; vhpiHandleT h = vhpi_register_foreignf(&add2_data); check_error(); vhpiForeignDataT popcount_data = { .kind = vhpiFuncF, .libraryName = "lib", .modelName = "popcount", .execf = popcount, }; vhpi_register_foreignf(&popcount_data); check_error(); vhpiForeignDataT test1_data = { .kind = vhpiFuncF, .libraryName = "lib", .modelName = "test1", .execf = test1, }; vhpi_register_foreignf(&test1_data); check_error(); vhpiForeignDataT test2_data = { .kind = vhpiFuncF, .libraryName = "lib", .modelName = "test2", .execf = test1, // Can reuse same code }; vhpi_register_foreignf(&test2_data); check_error(); vhpiForeignDataT iota_data = { .kind = vhpiFuncF, .libraryName = "lib", .modelName = "iota", .execf = iota, }; vhpi_register_foreignf(&iota_data); check_error(); vhpiForeignDataT no_args_data = { .kind = vhpiProcF, .libraryName = "lib", .modelName = "no_args", .execf = no_args, }; vhpi_register_foreignf(&no_args_data); check_error(); vhpiForeignDataT set_logic_data = { .kind = vhpiProcF, .libraryName = "lib", .modelName = "set_logic", .execf = set_logic, }; vhpi_register_foreignf(&set_logic_data); check_error(); vhpiForeignDataT check; fail_if(vhpi_get_foreignf_info(h, &check)); fail_unless(check.kind == vhpiFuncF); fail_unless(strcmp(check.modelName, "add2") == 0); } nvc-r1.17.1/test/vhpi/vhpi15.c000066400000000000000000000064501504111170000157510ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include #include static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT bad1 = vhpi_handle_by_name(":bad", NULL); fail_unless(bad1 == NULL); vhpiHandleT root2 = vhpi_handle_by_name(":vhpi15", NULL); fail_unless(vhpi_compare_handles(root2, root)); vhpi_release_handle(root2); vhpiHandleT pack1 = vhpi_handle_by_name(":pack1", NULL); check_handle(pack1); vhpi_printf("pack1 handle %p", pack1); vhpiHandleT du = vhpi_handle(vhpiDesignUnit, pack1); check_handle(du); fail_unless(vhpi_get(vhpiKindP, du) == vhpiPackDeclK); vhpiHandleT su = vhpi_handle(vhpiPrimaryUnit, du); fail_unless(su == NULL); vhpiHandleT c1 = vhpi_handle_by_name("c1", pack1); check_handle(c1); vhpi_printf("c1 full name is %s", vhpi_get_str(vhpiFullNameP, c1)); fail_unless(vhpi_get(vhpiKindP, c1) == vhpiConstDeclK); vhpiValueT c1_value = { .format = vhpiIntVal, }; vhpi_get_value(c1, &c1_value); check_error(); vhpi_printf("c1 value is %d", c1_value.value.intg); fail_unless(c1_value.value.intg == 42); vhpiHandleT c2 = vhpi_handle_by_name("c2", pack1); check_handle(c2); vhpi_printf("c2 full name is %s", vhpi_get_str(vhpiFullNameP, c2)); fail_unless(vhpi_get(vhpiKindP, c2) == vhpiConstDeclK); vhpiCharT c2_str[6]; vhpiValueT c2_value = { .format = vhpiStrVal, .bufSize = sizeof(c2_str), .value.str = c2_str }; vhpi_get_value(c2, &c2_value); check_error(); vhpi_printf("c2 value is %s", c2_str); fail_unless(strcmp((char *)c2_str, "hello") == 0); vhpiHandleT it = vhpi_iterator(vhpiPackInsts, NULL); fail_if(it == NULL); bool found = false; int i = 0; for (vhpiHandleT h = vhpi_scan(it); h != NULL; h = vhpi_scan(it), i++) { vhpi_printf("found package %s", vhpi_get_str(vhpiNameP, h)); found |= vhpi_compare_handles(h, pack1); vhpiHandleT h2 = vhpi_handle_by_index(vhpiPackInsts, NULL, i); fail_unless(vhpi_compare_handles(h, h2)); vhpi_release_handle(h); vhpi_release_handle(h2); } vhpi_release_handle(it); fail_unless(found); fail_unless(i == 2); vhpi_release_handle(root); vhpi_release_handle(pack1); vhpi_release_handle(c1); vhpi_release_handle(c2); vhpi_release_handle(du); } void vhpi15_startup(void) { vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data1, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi16.c000066400000000000000000000023271504111170000157510ustar00rootroot00000000000000#include "vhpi_test.h" #include #include static void x_value_change(const vhpiCbDataT *cb_data) { const vhpiCharT *name = VHPI_CHECK(vhpi_get_str(vhpiFullNameP, cb_data->obj)); vhpi_printf("%s value change", name); // VHPI spec says releasing the passed-in handle is erroneous vhpi_release_handle(cb_data->obj); vhpiErrorInfoT info; fail_unless(vhpi_check_error(&info)); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT x = VHPI_CHECK(vhpi_handle_by_name("x", root)); vhpiCbDataT x_cb_data = { .obj = x, .cb_rtn = x_value_change, .reason = vhpiCbValueChange, }; VHPI_CHECK(vhpi_register_cb(&x_cb_data, 0)); vhpi_release_handle(root); // This should not invalidate the handle passed to the callback vhpi_release_handle(x); } void vhpi16_startup(void) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); fail_unless(root == NULL); vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/vhpi2.c000066400000000000000000000065261504111170000156710ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include static vhpiHandleT handle_x; static vhpiHandleT handle_y; static vhpiHandleT end_of_timestep_cb; static int sequence = 0; static void end_of_processes(const vhpiCbDataT *cb_data) { vhpi_printf("end_of_processes"); fail_unless(sequence++ == 0); } static void last_known_delta_cycle(const vhpiCbDataT *cb_data) { vhpi_printf("last_known_delta_cycle"); fail_unless(sequence++ == 1); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_x, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 1); value.value.intg = 1; vhpi_put_value(handle_x, &value, vhpiForcePropagate); check_error(); } static void end_of_timestep(const vhpiCbDataT *cb_data) { vhpi_printf("end_of_timestep"); fail_unless(sequence++ == 2); vhpiValueT value = { .format = vhpiIntVal, .value.intg = 0 }; fail_unless(vhpi_put_value(handle_x, &value, vhpiForcePropagate)); vhpi_remove_cb(end_of_timestep_cb); check_error(); vhpi_release_handle(end_of_timestep_cb); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("start_of_sim"); vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); fail_unless(vhpi_get(vhpiKindP, root) == vhpiRootInstK); handle_x = vhpi_handle_by_name("x", root); check_error(); fail_if(handle_x == NULL); vhpi_printf("x handle %p", handle_x); handle_y = vhpi_handle_by_name("y", root); check_error(); fail_if(handle_y == NULL); vhpi_printf("y handle %p", handle_y); vhpiHandleT y_type = vhpi_handle(vhpiBaseType, handle_y); check_error(); fail_if(vhpi_get(vhpiIsCompositeP, y_type)); check_error(); fail_unless(vhpi_get(vhpiIsScalarP, y_type)); check_error(); vhpiHandleT y_base = vhpi_handle(vhpiBaseType, y_type); fail_unless(vhpi_compare_handles(y_base, y_type)); vhpi_release_handle(y_type); vhpi_release_handle(y_base); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_x, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 0); value.value.intg = 1; vhpi_put_value(handle_x, &value, vhpiForcePropagate); check_error(); vhpiCbDataT cb_data1 = { .reason = vhpiCbEndOfProcesses, .cb_rtn = end_of_processes, }; vhpi_register_cb(&cb_data1, 0); check_error(); vhpiCbDataT cb_data2 = { .reason = vhpiCbLastKnownDeltaCycle, .cb_rtn = last_known_delta_cycle, }; vhpi_register_cb(&cb_data2, 0); check_error(); vhpiCbDataT cb_data3 = { .reason = vhpiCbRepEndOfTimeStep, .cb_rtn = end_of_timestep, }; end_of_timestep_cb = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); vhpi_release_handle(root); } void vhpi2_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, .user_data = (char *)"some user data", }; vhpiHandleT handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); fail_unless(vhpi_get(vhpiStateP, handle_sos) == vhpiEnable); vhpi_release_handle(handle_sos); } nvc-r1.17.1/test/vhpi/vhpi3.c000066400000000000000000000055721504111170000156720ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include static int64_t phys_to_i64(vhpiPhysT phys) { return ((uint64_t)phys.high) << 32 | phys.low; } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("start_of_sim"); fail_unless(phys_to_i64(vhpiFS) == 1ll); fail_unless(phys_to_i64(vhpiPS) == 1000ll); fail_unless(phys_to_i64(vhpiNS) == 1000000ll); fail_unless(phys_to_i64(vhpiUS) == 1000000000ll); fail_unless(phys_to_i64(vhpiMS) == 1000000000000ll); fail_unless(phys_to_i64(vhpiS) == 1000000000000000ll); fail_unless(phys_to_i64(vhpiMN) == 1000000000000000ll * 60); fail_unless(phys_to_i64(vhpiHR) == 1000000000000000ll * 60 * 60); vhpiPhysT res_limit = VHPI_CHECK(vhpi_get_phys(vhpiResolutionLimitP, NULL)); fail_unless(phys_to_i64(res_limit) == phys_to_i64(vhpiFS)); vhpiHandleT root = VHPI_CHECK(vhpi_handle(vhpiRootInst, NULL)); fail_if(root == NULL); vhpiHandleT handle_x = VHPI_CHECK(vhpi_handle_by_name("x", root)); fail_if(handle_x == NULL); vhpi_printf("x handle %p", handle_x); vhpiPhysT x_val = VHPI_CHECK(vhpi_get_phys(vhpiPhysValP, handle_x)); fail_unless(phys_to_i64(x_val) == 2); vhpiHandleT handle_weight_type = VHPI_CHECK(vhpi_handle(vhpiType, handle_x)); fail_if(handle_weight_type == NULL); const char *weight_name = (char *)vhpi_get_str(vhpiNameP, handle_weight_type); fail_if(strcmp("WEIGHT", weight_name)); const char *weight_fullname = (char *)vhpi_get_str(vhpiFullNameP, handle_weight_type); fail_if(strcmp("@WORK:VHPI3-TEST:WEIGHT", weight_fullname)); vhpiHandleT handle_weight_cons = VHPI_CHECK(vhpi_handle_by_index(vhpiConstraints, handle_weight_type, 0)); fail_if(handle_weight_cons == NULL); vhpiHandleT handle_weight_cons_iter = VHPI_CHECK(vhpi_iterator(vhpiConstraints, handle_weight_type)); vhpiHandleT next = VHPI_CHECK(vhpi_scan(handle_weight_cons_iter)); fail_unless(vhpi_compare_handles(next, handle_weight_cons)); VHPI_CHECK(vhpi_release_handle(next)); fail_unless(vhpi_scan(handle_weight_cons_iter) == NULL); vhpiPhysT weight_left = VHPI_CHECK(vhpi_get_phys(vhpiPhysLeftBoundP, handle_weight_cons)); fail_unless(phys_to_i64(weight_left) == -100); vhpiPhysT weight_right = VHPI_CHECK(vhpi_get_phys(vhpiPhysRightBoundP, handle_weight_cons)); fail_unless(phys_to_i64(weight_right) == 4000); vhpi_release_handle(handle_weight_cons); vhpi_release_handle(handle_weight_type); vhpi_release_handle(handle_x); vhpi_release_handle(root); } void vhpi3_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, .user_data = NULL, }; vhpi_register_cb(&cb_data1, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi4.c000066400000000000000000000012331504111170000156610ustar00rootroot00000000000000#include #include typedef enum { U = 0, X, ZERO, ONE, Z, W, L, H, D } std_logic; int32_t __vhpi_sum(int32_t x, int32_t y) { printf("__vhpi_sum(%d, %d)\n", x, y); return x + y; } int32_t __vhpi_sum_array(int32_t *a, int32_t length) { int32_t sum = 0; for (int i = 0; i < length; i++) sum += a[i]; return sum; } uint8_t __vhpi_my_not(uint8_t x) { switch (x) { case ZERO: return ONE; case ONE: return ZERO; default: return x; } } int __vhpi_test_proc(int32_t *x, int32_t *arr) { *x = 42; arr[1] = 5; return 66; // Should be ignored } void __vhpi_no_args(void) { printf("no_args called!\n"); } nvc-r1.17.1/test/vhpi/vhpi5.c000066400000000000000000000124731504111170000156720ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include #include static vhpiHandleT m, n, o; static vhpiIntT swan(vhpiIntT x) { return (x & 0xf000) >> 12 | (x & 0x0f00) >> 4 | (x & 0x00f0) << 4 | (x & 0x000f) << 12; } void delta_recursive(vhpiHandleT parent, int base, int scale) { int i = 0; vhpiHandleT children = vhpi_iterator(vhpiSelectedNames, parent); for (vhpiHandleT child = vhpi_scan(children); child; child = vhpi_scan(children), i++) { delta_recursive(child, base + i * scale, scale / 16); vhpi_release_handle(child); } vhpi_release_handle(children); children = vhpi_iterator(vhpiIndexedNames, parent); for (vhpiHandleT child = vhpi_scan(children); child; child = vhpi_scan(children), i++) { if (parent == n) delta_recursive(child, base + i / 5 * scale + i % 5 * scale / 16, scale / 256); else delta_recursive(child, base + i * scale, scale / 16); vhpi_release_handle(child); } vhpi_release_handle(children); if (!i) { vhpiValueT val = { .format = vhpiIntVal, }; vhpi_get_value(parent, &val); check_error(); vhpi_printf("%-14s = %.04x", vhpi_get_str(vhpiNameP, parent), val.value.intg); fail_unless(val.value.intg == swan(base)); } } static void last_delta(const vhpiCbDataT *cb_data) { delta_recursive(m, 0, 16); delta_recursive(n, 0, 4096); delta_recursive(o, 0, 4096); } void start_recursive(vhpiHandleT parent, int base, int scale, bool by_name) { int i = 0; char name[64]; const vhpiCharT *parent_name = vhpi_get_str(vhpiNameP, parent); const vhpiCharT *parent_full_name = vhpi_get_str(vhpiFullNameP, parent); vhpiHandleT children = vhpi_iterator(vhpiSelectedNames, parent); for (vhpiHandleT child = vhpi_scan(children); child; child = vhpi_scan(children), i++) { vhpiHandleT prefix = vhpi_handle(vhpiPrefix, child); fail_unless(vhpi_compare_handles(parent, prefix)); vhpiHandleT suffix = vhpi_handle(vhpiSuffix, child); fail_unless(vhpi_get(vhpiPositionP, suffix) == i); snprintf(name, sizeof(name), "%s.%s", parent_name, vhpi_get_str(vhpiNameP, suffix)); fail_if(strcmp(name, (char *)vhpi_get_str(vhpiNameP, child))); if (by_name) { snprintf(name, sizeof(name), "%s.%s", parent_full_name, vhpi_get_str(vhpiNameP, suffix)); vhpiHandleT child2 = vhpi_handle_by_name(name, NULL); fail_unless(vhpi_compare_handles(child2, child)); vhpi_release_handle(child2); } start_recursive(child, base + i * scale, scale / 16, by_name); vhpi_release_handle(prefix); vhpi_release_handle(suffix); vhpi_release_handle(child); } children = vhpi_iterator(vhpiIndexedNames, parent); for (vhpiHandleT child = vhpi_scan(children); child; child = vhpi_scan(children), i++) { if (parent == n) start_recursive(child, base + i / 5 * scale + i % 5 * scale / 16, scale / 256, false); else start_recursive(child, base + i * scale, scale / 16, false); vhpi_release_handle(child); } if (!i) { vhpiValueT val = { .format = vhpiIntVal, }; vhpi_get_value(parent, &val); check_error(); vhpi_printf("%-14s = %.04x", parent_name, val.value.intg); fail_unless(val.value.intg == base); val.value.intg = swan(val.value.intg); vhpi_put_value(parent, &val, vhpiDepositPropagate); check_error(); } } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); const vhpiCharT *root_name = vhpi_get_str(vhpiNameP, root); vhpi_printf("root name is %s", root_name); m = vhpi_handle_by_name("m", root); check_error(); fail_if(m == NULL); vhpi_printf("m handle %p", m); vhpiHandleT m_type = vhpi_handle(vhpiType, m); check_error(); fail_if(m_type == NULL); fail_unless(vhpi_get(vhpiIsCompositeP, m_type)); check_error(); fail_if(vhpi_get(vhpiIsScalarP, m_type)); check_error(); int i = 0; vhpiHandleT elems = vhpi_iterator(vhpiRecordElems, m_type); for (vhpiHandleT elem = vhpi_scan(elems); elem; elem = vhpi_scan(elems), i++) { vhpi_printf("m elem %d is %s", i, vhpi_get_str(vhpiNameP, elem)); fail_unless(vhpi_get(vhpiPositionP, elem) == i); vhpi_release_handle(elem); } vhpi_release_handle(elems); fail_unless(vhpi_get(vhpiNumFieldsP, m_type) == i); n = vhpi_handle_by_name("n", root); check_error(); fail_if(n == NULL); o = vhpi_handle_by_name("o", root); check_error(); fail_if(n == NULL); start_recursive(m, 0, 16, true); start_recursive(n, 0, 4096, true); start_recursive(o, 0, 4096, true); vhpi_release_handle(root); } void vhpi5_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); cb_data.reason = vhpiCbLastKnownDeltaCycle; cb_data.cb_rtn = last_delta; VHPI_CHECK(vhpi_register_cb(&cb_data, 0)); } nvc-r1.17.1/test/vhpi/vhpi6.c000066400000000000000000000103601504111170000156640ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include static vhpiHandleT handle_x; static vhpiHandleT handle_y; static vhpiHandleT handle_sos; static void y_value_change(const vhpiCbDataT *cb_data) { vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("y value changed to %d", value.value.intg); if (value.value.intg == 75) { vhpi_control(vhpiFinish); check_error(); } else { value.value.intg++; vhpi_put_value(handle_x, &value, vhpiDepositPropagate); check_error(); } } static void after_after_5ns(const vhpiCbDataT *cb_data) { vhpi_printf("after_after_5ns callback!"); fail_if(1); } static void next_timestep(const vhpiCbDataT *cb_data) { vhpi_printf("next_timestep callback!"); fail_if(1); } static void after_5ns(const vhpiCbDataT *cb_data) { vhpi_printf("after_5ns callback!"); long cycles; vhpiTimeT now; vhpi_get_time(&now, &cycles); fail_unless(now.low == 5000000); fail_unless(now.high == 0); fail_unless(cycles == 0); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); vhpi_printf("value=%d", value.value.intg); fail_unless(value.value.intg == 6); value.value.intg = 70; vhpi_put_value(handle_x, &value, vhpiDepositPropagate); check_error(); vhpiCbDataT cb_data2 = { .reason = vhpiCbValueChange, .cb_rtn = y_value_change, .obj = handle_y }; vhpi_register_cb(&cb_data2, 0); check_error(); vhpiTimeT time_1fs = { .low = 1 }; vhpiCbDataT cb_data3 = { .reason = vhpiCbAfterDelay, .cb_rtn = after_after_5ns, .time = &time_1fs }; vhpiHandleT cb3 = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); fail_if(vhpi_disable_cb(cb3)); vhpi_release_handle(cb3); vhpiHandleT cb4 = vhpi_register_cb(&cb_data3, vhpiReturnCb); check_error(); fail_if(vhpi_remove_cb(cb4)); vhpiCbDataT cb_data5 = { .reason = vhpiCbNextTimeStep, .cb_rtn = next_timestep, }; vhpiHandleT cb5 = vhpi_register_cb(&cb_data5, vhpiReturnCb); check_error(); fail_if(vhpi_remove_cb(cb5)); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("start of sim callback! user data is '%s'", (char *)cb_data->user_data); vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); handle_x = vhpi_handle_by_name("x", root); check_error(); handle_y = vhpi_handle_by_name("y", root); check_error(); vhpi_release_handle(root); long cycles; vhpiTimeT now; vhpi_get_time(&now, &cycles); fail_unless(now.low == 0); fail_unless(now.high == 0); fail_unless(cycles == 0); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_x, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 0); value.value.intg = 5; vhpi_put_value(handle_x, &value, vhpiDepositPropagate); check_error(); vhpiTimeT time_5ns = { .low = 5000000 }; vhpiCbDataT cb_data2 = { .reason = vhpiCbAfterDelay, .cb_rtn = after_5ns, .time = &time_5ns }; vhpi_register_cb(&cb_data2, 0); check_error(); } static void end_of_sim(const vhpiCbDataT *cb_data) { vhpi_printf("end of sim callback"); vhpiValueT value = { .format = vhpiObjTypeVal }; vhpi_get_value(handle_y, &value); check_error(); fail_unless(value.format == vhpiIntVal); fail_unless(value.value.intg == 75); vhpi_release_handle(handle_x); vhpi_release_handle(handle_y); vhpi_release_handle(handle_sos); } void vhpi6_startup(void) { vhpi_printf("hello, world!"); vhpiCbDataT cb_data1 = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; handle_sos = vhpi_register_cb(&cb_data1, vhpiReturnCb); check_error(); vhpiCbDataT cb_data2 = { .reason = vhpiCbEndOfSimulation, .cb_rtn = end_of_sim }; vhpi_register_cb(&cb_data2, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi7.c000066400000000000000000000136361504111170000156760ustar00rootroot00000000000000#include "vhpi_test.h" #include #include static vhpiHandleT m_outer[3]; static vhpiHandleT m_inner[3][2]; static vhpiHandleT n_outer[7][5]; static vhpiHandleT n_inner[7][5][3][2]; static vhpiHandleT o_outer[3]; static vhpiHandleT o_inner[3][2]; static void last_delta_2d(char *sig, vhpiHandleT inner[3][2]) { vhpiValueT val = { .format = vhpiIntVal, }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { vhpi_get_value(inner[i][j], &val); check_error(); vhpi_printf("%s(%d)(%d) = %.02x", sig, i, j, val.value.intg); fail_unless(val.value.intg == j * 16 + i); } } } static void last_delta(const vhpiCbDataT *cb_data) { last_delta_2d("m", m_inner); vhpiValueT val = { .format = vhpiIntVal, }; for (int i = 0; i < 7; i++) { for (int j = 0; j < 5; j++) { for (int k = 0; k < 3; k++) { for (int l = 0; l < 2; l++) { vhpi_get_value(n_inner[i][j][k][l], &val); check_error(); vhpi_printf("n(%d,%d)(%d,%d) = %.04x", i, j, k, l, val.value.intg); fail_unless(val.value.intg == l * 4096 + k * 256 + j * 16 + i); } } } } last_delta_2d("o", o_inner); } static void start_of_sim_2d(char *sig, vhpiHandleT inner[3][2]) { vhpiValueT val = { .format = vhpiIntVal, }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { vhpi_get_value(inner[i][j], &val); check_error(); vhpi_printf("%s(%d)(%d) = %.02x", sig, i, j, val.value.intg); fail_unless(val.value.intg == i * 16 + j); val.value.intg = j * 16 + i; vhpi_put_value(inner[i][j], &val, vhpiDepositPropagate); check_error(); } } } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiValueT val = { .format = vhpiIntVal, }; start_of_sim_2d("m", m_inner); for (int i = 0; i < 7; i++) { for (int j = 0; j < 5; j++) { for (int k = 0; k < 3; k++) { for (int l = 0; l < 2; l++) { vhpi_get_value(n_inner[i][j][k][l], &val); check_error(); vhpi_printf("n(%d,%d)(%d,%d) = %.04x", i, j, k, l, val.value.intg); fail_unless(val.value.intg == i * 4096 + j * 256 + k * 16 + l); val.value.intg = l * 4096 + k * 256 + j * 16 + i; vhpi_put_value(n_inner[i][j][k][l], &val, vhpiDepositPropagate); check_error(); } } } } start_of_sim_2d("o", o_inner); } static void startup_2d(vhpiHandleT root, char *sig, vhpiHandleT outer[3], vhpiHandleT inner[3][2]) { vhpiHandleT handle = vhpi_handle_by_name(sig, root); check_error(); fail_if(handle == NULL); char name[64]; for (int i = 0; i < 3; i++) { outer[i] = vhpi_handle_by_index(vhpiIndexedNames, handle, i); check_error(); fail_if(outer[i] == NULL); fail_unless(vhpi_get(vhpiBaseIndexP, outer[i]) == i); vhpiHandleT prefix = vhpi_handle(vhpiPrefix, outer[i]); fail_unless(vhpi_compare_handles(prefix, handle)); snprintf(name, sizeof(name), "%s(%d)", sig, i); fail_if(strcmp(name, (char *)vhpi_get_str(vhpiNameP, outer[i]))); for (int j = 0; j < 2; j++) { inner[i][j] = vhpi_handle_by_index(vhpiIndexedNames, outer[i], j); check_error(); fail_if(inner[i][j] == NULL); fail_unless(vhpi_get(vhpiBaseIndexP, inner[i][j]) == j); vhpiHandleT prefix = vhpi_handle(vhpiPrefix, inner[i][j]); fail_unless(vhpi_compare_handles(prefix, outer[i])); snprintf(name, sizeof(name), "%s(%d)(%d)", sig, i, j); fail_if(strcmp(name, (char *)vhpi_get_str(vhpiNameP, inner[i][j]))); } } vhpi_release_handle(handle); } static void end_of_init(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); startup_2d(root, "M", m_outer, m_inner); vhpiHandleT n = vhpi_handle_by_name("n", root); check_error(); fail_if(n == NULL); char name[64]; for (int i = 0; i < 7; i++) { for (int j = 0; j < 5; j++) { n_outer[i][j] = vhpi_handle_by_index(vhpiIndexedNames, n, i * 5 + j); check_error(); fail_if(n_outer[i][j] == NULL); fail_unless(vhpi_get(vhpiBaseIndexP, n_outer[i][j]) == i * 5 + j); vhpiHandleT prefix = vhpi_handle(vhpiPrefix, n_outer[i][j]); fail_unless(vhpi_compare_handles(prefix, n)); snprintf(name, sizeof(name), "N(%d,%d)", i, j); fail_if(strcmp(name, (char *)vhpi_get_str(vhpiNameP, n_outer[i][j]))); for (int k = 0; k < 3; k++) { for (int l = 0; l < 2; l++) { n_inner[i][j][k][l] = vhpi_handle_by_index(vhpiIndexedNames, n_outer[i][j], k * 2 + l); check_error(); fail_if(n_inner[i][j][k][l] == NULL); fail_unless(vhpi_get(vhpiBaseIndexP, n_inner[i][j][k][l]) == k * 2 + l); vhpiHandleT prefix = vhpi_handle(vhpiPrefix, n_inner[i][j][k][l]); fail_unless(vhpi_compare_handles(prefix, n_outer[i][j])); snprintf(name, sizeof(name), "N(%d,%d)(%d,%d)", i, j, k, l); fail_if(strcmp(name, (char *)vhpi_get_str(vhpiNameP, n_inner[i][j][k][l]))); } } } } vhpi_release_handle(n); startup_2d(root, "O", o_outer, o_inner); vhpi_release_handle(root); } void vhpi7_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data, 0); check_error(); cb_data.reason = vhpiCbEndOfInitialization; cb_data.cb_rtn = end_of_init; vhpi_register_cb(&cb_data, 0); check_error(); cb_data.reason = vhpiCbLastKnownDeltaCycle; cb_data.cb_rtn = last_delta; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi8.c000066400000000000000000000166051504111170000156760ustar00rootroot00000000000000#include "vhpi_test.h" #include #include #include #include static vhpiHandleT lv, sv, ev, bv, cv, rv, lv2, sv2, ev2, cv2, rv2; static void last_delta(const vhpiCbDataT *cb_data) { vhpiSmallEnumT s[4]; vhpiValueT sval = { .format = vhpiSmallEnumVecVal, .bufSize = sizeof(s), .value.smallenumvs = s, }; vhpi_get_value(sv, &sval); check_error(); fail_unless(s[0] == 3); fail_unless(s[1] == 2); fail_unless(s[2] == 1); fail_unless(s[3] == 0); vhpiValueT sval2 = { .format = vhpiSmallEnumVal, }; vhpi_get_value(sv2, &sval2); check_error(); fail_unless(sval2.value.smallenumv == 1); vhpiEnumT l[4]; vhpiValueT lval = { .format = vhpiEnumVecVal, .bufSize = sizeof(l), .value.enumvs = l, }; vhpi_get_value(ev, &lval); check_error(); fail_unless(l[0] == 299); fail_unless(l[1] == 298); fail_unless(l[2] == 297); fail_unless(l[3] == 296); vhpiValueT lval2 = { .format = vhpiEnumVal, }; vhpi_get_value(ev2, &lval2); check_error(); fail_unless(lval2.value.enumv == 297); lval.format = vhpiLogicVecVal; vhpi_get_value(lv, &lval); check_error(); fail_unless(l[0] == 8); fail_unless(l[1] == 7); fail_unless(l[2] == 6); fail_unless(l[3] == 5); lval2.format = vhpiLogicVal, vhpi_get_value(lv2, &lval2); check_error(); fail_unless(lval2.value.enumv == 6); vhpiCharT c[5]; vhpiValueT cval = { .format = vhpiStrVal, .bufSize = sizeof(c), .value.str = c, }; vhpi_get_value(cv, &cval); check_error(); fail_unless(c[0] == 0); fail_unless(c[1] == 1); fail_unless(c[2] == 254); fail_unless(c[3] == 255); fail_unless(c[4] == 0); vhpiValueT cval2 = { .format = vhpiCharVal, }; vhpi_get_value(cv2, &cval2); check_error(); fail_unless(cval2.value.ch == 254); vhpiRealT r[4]; vhpiValueT rval = { .format = vhpiRealVecVal, .bufSize = sizeof(r), .value.reals = r, }; vhpi_get_value(rv, &rval); check_error(); fail_unless(isnan(r[0])); fail_unless(r[1] == DBL_TRUE_MIN); fail_unless(r[2] == DBL_MAX); fail_unless(r[3] == HUGE_VAL); vhpiValueT rval2 = { .format = vhpiRealVal, }; vhpi_get_value(rv2, &rval2); check_error(); fail_unless(rval2.value.real == DBL_MAX); } static void start_of_sim(const vhpiCbDataT *cb_data) { vhpiSmallEnumT s[4]; vhpiValueT sval = { .format = vhpiSmallEnumVecVal, .bufSize = sizeof(s), .value.smallenumvs = s, }; vhpi_get_value(sv, &sval); check_error(); fail_unless(s[0] == 0); fail_unless(s[1] == 1); fail_unless(s[2] == 2); fail_unless(s[3] == 3); vhpiValueT sval2 = { .format = vhpiSmallEnumVal, }; vhpi_get_value(sv2, &sval2); check_error(); fail_unless(sval2.value.smallenumv == 2); s[0] = 3; s[1] = 2; s[2] = 1; s[3] = 0; vhpi_put_value(sv, &sval, vhpiDepositPropagate); check_error(); vhpiEnumT l[5]; vhpiValueT lval = { .format = vhpiEnumVecVal, .bufSize = sizeof(vhpiEnumT) * 4, .value.enumvs = l, }; vhpi_get_value(ev, &lval); check_error(); fail_unless(l[0] == 0); fail_unless(l[1] == 1); fail_unless(l[2] == 2); fail_unless(l[3] == 3); vhpiValueT lval2 = { .format = vhpiEnumVal, }; vhpi_get_value(ev2, &lval2); check_error(); fail_unless(lval2.value.enumv == 2); l[0] = 299; l[1] = 298; l[2] = 297; l[3] = 296; vhpi_put_value(ev, &lval, vhpiDepositPropagate); check_error(); lval.format = vhpiLogicVecVal; vhpi_get_value(lv, &lval); check_error(); fail_unless(l[0] == 0); fail_unless(l[1] == 1); fail_unless(l[2] == 2); fail_unless(l[3] == 3); lval.format = vhpiLogicVecVal; vhpi_get_value(bv, &lval); check_error(); fail_unless(lval.numElems == 0); fail_unless(vhpi_put_value(bv, &lval, vhpiDepositPropagate)); lval.bufSize = 0; vhpi_put_value(bv, &lval, vhpiDepositPropagate); check_error(); lval.bufSize = sizeof(vhpiEnumT) * 4; lval2.format = vhpiLogicVal, vhpi_get_value(lv2, &lval2); check_error(); fail_unless(lval2.value.enumv == 2); l[0] = 8; l[1] = 7; l[2] = 6; l[3] = 5; vhpi_put_value(lv, &lval, vhpiDepositPropagate); check_error(); lval.bufSize = sizeof(l); fail_unless(vhpi_put_value(lv, &lval, vhpiDepositPropagate)); vhpiCharT c[5]; vhpiValueT cval = { .format = vhpiStrVal, .bufSize = sizeof(c), .value.str = c, }; vhpi_get_value(cv, &cval); check_error(); fail_unless(c[0] == 'N'); fail_unless(c[1] == 'V'); fail_unless(c[2] == 'C'); fail_unless(c[3] == '!'); fail_unless(c[4] == '\0'); vhpiValueT cval2 = { .format = vhpiCharVal, }; vhpi_get_value(cv2, &cval2); check_error(); fail_unless(cval2.value.ch == 'C'); c[0] = 0; c[1] = 1; c[2] = 254; c[3] = 255; vhpi_put_value(cv, &cval, vhpiDepositPropagate); check_error(); vhpiRealT r[4]; vhpiValueT rval = { .format = vhpiRealVecVal, .bufSize = sizeof(r), .value.reals = r, }; vhpi_get_value(rv, &rval); check_error(); fail_unless(r[0] == 0.0); fail_unless(r[1] == 0.5); fail_unless(r[2] == 1.0); fail_unless(r[3] == -1.0); vhpiValueT rval2 = { .format = vhpiRealVal, }; vhpi_get_value(rv2, &rval2); check_error(); fail_unless(rval2.value.real == 1.0); r[0] = NAN; r[1] = DBL_TRUE_MIN; r[2] = DBL_MAX; r[3] = HUGE_VAL; vhpi_put_value(rv, &rval, vhpiDepositPropagate); check_error(); } static void end_of_init(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); lv = vhpi_handle_by_name("lv", root); check_error(); fail_if(lv == NULL); lv2 = vhpi_handle_by_index(vhpiIndexedNames, lv, 2); check_error(); fail_if(lv2 == NULL); sv = vhpi_handle_by_name("sv", root); check_error(); fail_if(sv == NULL); sv2 = vhpi_handle_by_index(vhpiIndexedNames, sv, 2); check_error(); fail_if(sv2 == NULL); ev = vhpi_handle_by_name("ev", root); check_error(); fail_if(ev == NULL); ev2 = vhpi_handle_by_index(vhpiIndexedNames, ev, 2); check_error(); fail_if(ev2 == NULL); bv = vhpi_handle_by_name("bv", root); check_error(); fail_if(bv == NULL); fail_unless(vhpi_get(vhpiSizeP, bv) == 0); vhpiHandleT bv_names = vhpi_iterator(vhpiIndexedNames, bv); check_error(); fail_if(bv_names == NULL); fail_unless(vhpi_scan(bv_names) == NULL); cv = vhpi_handle_by_name("cv", root); check_error(); fail_if(cv == NULL); cv2 = vhpi_handle_by_index(vhpiIndexedNames, cv, 2); check_error(); fail_if(cv2 == NULL); rv = vhpi_handle_by_name("rv", root); check_error(); fail_if(rv == NULL); rv2 = vhpi_handle_by_index(vhpiIndexedNames, rv, 2); check_error(); fail_if(rv2 == NULL); vhpi_release_handle(root); } void vhpi8_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbStartOfSimulation, .cb_rtn = start_of_sim, }; vhpi_register_cb(&cb_data, 0); check_error(); cb_data.reason = vhpiCbLastKnownDeltaCycle; cb_data.cb_rtn = last_delta; vhpi_register_cb(&cb_data, 0); check_error(); cb_data.reason = vhpiCbEndOfInitialization; cb_data.cb_rtn = end_of_init; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi9.c000066400000000000000000000124121504111170000156670ustar00rootroot00000000000000#include "vhpi_test.h" #include static void end_of_init(const vhpiCbDataT *cb_data) { vhpiHandleT root = vhpi_handle(vhpiRootInst, NULL); check_error(); fail_if(root == NULL); vhpi_printf("root handle %p", root); vhpiHandleT s_signal = vhpi_handle_by_name("s", root); check_error(); fail_if(s_signal == NULL); vhpi_printf("x handle %p", s_signal); fail_unless(vhpi_get(vhpiKindP, s_signal) == vhpiSigDeclK); vhpiHandleT s_type = vhpi_handle(vhpiType, s_signal); check_error(); fail_if(s_type == NULL); vhpi_printf("s type handle %p", s_type); vhpi_printf("s type name is %s", vhpi_get_str(vhpiNameP, s_type)); vhpi_printf("s type full name is %s", vhpi_get_str(vhpiFullNameP, s_type)); fail_unless(vhpi_get(vhpiNumDimensionsP, s_type) == 1); fail_if(vhpi_get(vhpiIsUnconstrainedP, s_type)); vhpiHandleT s_constrs = vhpi_iterator(vhpiConstraints, s_type); check_error(); fail_if(s_constrs == NULL); vhpiHandleT s_range = vhpi_scan(s_constrs); check_error(); fail_if(s_range == NULL); fail_unless(vhpi_scan(s_constrs) == NULL); vhpi_printf("s type range handle %p", s_range); vhpi_printf("s left bound %d", vhpi_get(vhpiLeftBoundP, s_range)); vhpi_printf("s right bound %d", vhpi_get(vhpiRightBoundP, s_range)); fail_unless(vhpi_get(vhpiLeftBoundP, s_range) == 1); fail_unless(vhpi_get(vhpiRightBoundP, s_range) == 5); vhpiHandleT s_elem = vhpi_handle(vhpiElemType, s_type); check_error(); fail_if(s_elem == NULL); vhpi_printf("s elem type handle %p", s_elem); const char *s_elem_type_name = (char *)vhpi_get_str(vhpiNameP, s_elem); vhpi_printf("s elem type name is %s", s_elem_type_name); fail_unless(strcmp(s_elem_type_name, "BIT_VECTOR") == 0); const char *s_elem_name = (char *)vhpi_get_str(vhpiFullNameP, s_elem); vhpi_printf("s elem type full name is %s", s_elem_name); fail_unless(strcmp(s_elem_name, "@STD:STANDARD:BIT_VECTOR") == 0); vhpiHandleT s_elem_constrs = vhpi_iterator(vhpiConstraints, s_elem); check_error(); fail_if(s_elem_constrs == NULL); vhpiHandleT s_elem_range = vhpi_scan(s_elem_constrs); check_error(); fail_if(s_elem_range == NULL); fail_unless(vhpi_scan(s_constrs) == NULL); vhpi_printf("s type range handle %p", s_elem_range); vhpi_printf("s left bound %d", vhpi_get(vhpiLeftBoundP, s_elem_range)); vhpi_printf("s right bound %d", vhpi_get(vhpiRightBoundP, s_elem_range)); fail_unless(vhpi_get(vhpiLeftBoundP, s_elem_range) == 3); fail_unless(vhpi_get(vhpiRightBoundP, s_elem_range) == 0); vhpiHandleT s3_signal = vhpi_handle_by_name("s3", root); check_error(); fail_if(s3_signal == NULL); vhpi_printf("s3 handle %p", s3_signal); fail_unless(vhpi_get(vhpiKindP, s3_signal) == vhpiSigDeclK); vhpiHandleT s3f = vhpi_handle_by_name("s3.f", root); check_error(); fail_if(s3f == NULL); fail_unless(vhpi_get(vhpiKindP, s3f) == vhpiSelectedNameK); vhpi_printf("s3.f size %d", vhpi_get(vhpiSizeP, s3f)); fail_unless(vhpi_get(vhpiSizeP, s3f) == 4); vhpiHandleT s3f_type = vhpi_handle(vhpiBaseType, s3f); check_error(); fail_if(s3f_type == NULL); vhpi_printf("s3.f type handle %p", s3f_type); vhpi_printf("s3.f type name is %s", vhpi_get_str(vhpiNameP, s3f_type)); vhpiHandleT s3f_constrs = vhpi_iterator(vhpiConstraints, s3f_type); check_error(); fail_if(s3f_constrs == NULL); vhpiHandleT s3f_range = vhpi_scan(s3f_constrs); check_error(); fail_if(s3f_range == NULL); fail_unless(vhpi_scan(s_constrs) == NULL); vhpi_printf("s3.f type range handle %p", s3f_range); vhpi_printf("s3.f left bound %d", vhpi_get(vhpiLeftBoundP, s3f_range)); vhpi_printf("s3.f right bound %d", vhpi_get(vhpiRightBoundP, s3f_range)); fail_unless(vhpi_get(vhpiLeftBoundP, s3f_range) == 1); fail_unless(vhpi_get(vhpiRightBoundP, s3f_range) == 4); fail_unless(vhpi_get(vhpiIsUpP, s3f_range)); fail_if(vhpi_get(vhpiIsNullP, s3f_range)); fail_unless(vhpi_get(vhpiIsDiscreteP, s3f_range)); vhpiHandleT s3g = vhpi_handle_by_name("s3.g", root); check_error(); fail_if(s3g == NULL); fail_unless(vhpi_get(vhpiKindP, s3g) == vhpiSelectedNameK); vhpi_printf("s3.g size %d", vhpi_get(vhpiSizeP, s3g)); fail_unless(vhpi_get(vhpiSizeP, s3g) == 4); vhpiHandleT s3g_type = vhpi_handle(vhpiBaseType, s3g); check_error(); fail_if(s3g_type == NULL); vhpi_printf("s3.g type handle %p", s3g_type); vhpi_printf("s3.g type name is %s", vhpi_get_str(vhpiNameP, s3g_type)); vhpiHandleT s3g_constrs = vhpi_iterator(vhpiConstraints, s3g_type); check_error(); fail_if(s3g_constrs == NULL); vhpiHandleT s3g_range = vhpi_scan(s3g_constrs); check_error(); fail_if(s3g_range == NULL); fail_unless(vhpi_scan(s_constrs) == NULL); vhpi_printf("s3.g type range handle %p", s3g_range); vhpi_printf("s3.g left bound %d", vhpi_get(vhpiLeftBoundP, s3g_range)); vhpi_printf("s3.g right bound %d", vhpi_get(vhpiRightBoundP, s3g_range)); fail_unless(vhpi_get(vhpiLeftBoundP, s3g_range) == 4); fail_unless(vhpi_get(vhpiRightBoundP, s3g_range) == 1); fail_if(vhpi_get(vhpiIsUpP, s3g_range)); } void vhpi9_startup(void) { vhpiCbDataT cb_data = { .reason = vhpiCbEndOfInitialization, .cb_rtn = end_of_init, }; vhpi_register_cb(&cb_data, 0); check_error(); } nvc-r1.17.1/test/vhpi/vhpi_test.c000066400000000000000000000061741504111170000166450ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "vhpi_test.h" #include #include typedef struct { const char *name; void (*startup)(); } vhpi_test_t; static const vhpi_test_t tests[] = { { "vhpi1", vhpi1_startup }, { "vhpi2", vhpi2_startup }, { "vhpi3", vhpi3_startup }, { "vhpi4", NULL }, { "vhpi5", vhpi5_startup }, { "issue612", NULL }, { "vhpi6", vhpi6_startup }, { "vhpi7", vhpi7_startup }, { "vhpi8", vhpi8_startup }, { "vhpi9", vhpi9_startup }, { "issue744", issue744_startup }, { "vhpi10", vhpi10_startup }, { "vhpi11", vhpi11_startup }, { "issue762", issue762_startup }, { "vhpi12", vhpi12_startup }, { "vhpi13", vhpi13_startup }, { "vhpi14", vhpi14_startup }, { "vhpi15", vhpi15_startup }, { "issue978", issue978_startup }, { "issue988", issue988_startup }, { "issue1035", issue1035_startup }, { "issue1045", issue1045_startup }, { "issue1057", issue1057_startup }, { "issue1060", issue1060_startup }, { "issue1161", issue1161_startup }, { "issue1192", issue1192_startup }, { "issue1213", issue1213_startup }, { "issue1233", issue1233_startup }, { "issue1240", issue1240_startup }, { "vhpi16", vhpi16_startup }, { NULL, NULL }, }; void __check_error(const char *file, int lineno) { vhpiErrorInfoT info; if (vhpi_check_error(&info)) vhpi_assert(vhpiFailure, "%s:%d: unexpected error '%s'", file, lineno, info.message); } void __check_handle(vhpiHandleT h, const char *file, int lineno) { __check_error(file, lineno); if (h == NULL) vhpi_assert(vhpiFailure, "%s:%d: unexpected NULL handle", file, lineno); } void __check_string(const vhpiCharT *v, const char *s, const char *file, int lineno) { if (strcmp((const char *)v, s) != 0) vhpi_assert(vhpiFailure, "%s:%d: %s != %s", file, lineno, v, s); } static void shared_startup(void) { const char *test_name = getenv("TEST_NAME"); if (test_name == NULL) vhpi_assert(vhpiFailure, "TEST_NAME environment variable not set"); vhpi_printf("test name is %s", test_name); for (const vhpi_test_t *p = tests; p->name; p++) { if (strcmp(p->name, test_name) == 0) { if (p->startup != NULL) (*p->startup)(); return; } } vhpi_assert(vhpiFailure, "unknown test %s", test_name); } void (*vhpi_startup_routines[])() = { shared_startup, NULL }; nvc-r1.17.1/test/vhpi/vhpi_test.h000066400000000000000000000047421504111170000166510ustar00rootroot00000000000000// // Copyright (C) 2023-2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #ifndef _VHPI_TEST_H #define _VHPI_TEST_H #include "vhpi_user.h" #define fail_if(x) \ if (x) vhpi_assert(vhpiFailure, "assertion '%s' failed at %s:%d", \ #x, __FILE__, __LINE__) #define fail_unless(x) fail_if(!(x)) #define check_error() __check_error(__FILE__, __LINE__) #define check_handle(h) __check_handle((h), __FILE__, __LINE__) #define check_string(v, s) __check_string((v), (s), __FILE__, __LINE__) void __check_error(const char *file, int lineno); void __check_handle(vhpiHandleT h, const char *file, int lineno); void __check_string(const vhpiCharT *v, const char *s, const char *file, int lineno); #define VHPI_CHECK(call) ({ \ typeof((call)) _r = (call); \ check_error(); \ _r; \ }) void vhpi1_startup(void); void vhpi2_startup(void); void vhpi3_startup(void); void vhpi5_startup(void); void vhpi6_startup(void); void vhpi7_startup(void); void vhpi8_startup(void); void vhpi9_startup(void); void vhpi10_startup(void); void vhpi11_startup(void); void vhpi12_startup(void); void vhpi13_startup(void); void vhpi14_startup(void); void vhpi15_startup(void); void vhpi16_startup(void); void issue744_startup(void); void issue762_startup(void); void issue978_startup(void); void issue988_startup(void); void issue1035_startup(void); void issue1045_startup(void); void issue1057_startup(void); void issue1060_startup(void); void issue1161_startup(void); void issue1192_startup(void); void issue1213_startup(void); void issue1233_startup(void); void issue1240_startup(void); #endif // _VHPI_TEST_H nvc-r1.17.1/test/vi_suite/000077500000000000000000000000001504111170000153455ustar00rootroot00000000000000nvc-r1.17.1/test/vi_suite/README.nvc000066400000000000000000000013471504111170000170170ustar00rootroot00000000000000To run the VI VHDL test suite on NVC do the following: 1. Download vi_suite.tar.Z: http://replay.web.archive.org/20110514235929/http://mikro.e-technik.uni-ulm.de/vhdl/upload_data/vi_suite.tar.Z 2. Extract in nvc/test (i.e. over the top of this directory) 3. Install csh on your computer 4. Change "acc" in cfiles/*.mkf to "gcc". With GNU sed you can do sed -i'' s/acc/gcc/g cfiles/*.mkf 5. Set the VI_TEST environment variable to the vi_suite directory export VI_TEST=$(pwd) 6. Add $VI_TEST to your PATH export PATH=$PATH:$VI_TEST 7. Patch the install script to support NVC patch -p0 < install.patch 8. Run ./install 9. Run ./tcp 10. At the TCP# prompt: set branch on all set entorcfg entity execute nvc-r1.17.1/test/vi_suite/install.patch000066400000000000000000000025731504111170000200430ustar00rootroot00000000000000--- install.old 2012-02-04 21:36:38.059578767 +0000 +++ install 2012-02-04 21:38:37.776668713 +0000 @@ -89,7 +89,7 @@ # Choose Simulator #-------------------------------------------------------------------- set simulator = "" -while (($simulator != '1') && ($simulator != '2') && ($simulator != '3') && ($simulator != '4') && ($simulator != '5')) +while (($simulator != '1') && ($simulator != '2') && ($simulator != '3') && ($simulator != '4') && ($simulator != '5') && ($simulator != '6')) echo "" echo "Simulators For which Install Scripts are Available...." echo "Mentor Graphics. = 1" @@ -97,6 +97,7 @@ echo "Synopsys........ = 3" echo "Model Technology = 4" echo "Other........... = 5" + echo "NVC............. = 6" echo -n "Please enter the number of your choice : " set simulator = ($<) end @@ -158,6 +159,18 @@ echo "" echo "" +else if ($simulator == '6') then +# --------------------------------------------------------------------- +# NVC +# --------------------------------------------------------------------- + /bin/ln -s nvc/SSF SSF + /bin/ln -s nvc/create_library create_library + /bin/ln -s nvc/compile compile + /bin/ln -s nvc/simulate simulate + + echo "The installation is now complete." + + endif echo "Remember to add the line: setenv VI_TEST install_directory/vi_suite" nvc-r1.17.1/test/vi_suite/nvc/000077500000000000000000000000001504111170000161335ustar00rootroot00000000000000nvc-r1.17.1/test/vi_suite/nvc/SSF000066400000000000000000000004021504111170000165050ustar00rootroot00000000000000compiler_error: Error simulator_error: Fatal create_library: $work $work_path $suite_dir compile: $src_file $src_path $out_path $work $work_path $suite_dir simulate: $src_file $out_path $work $work_path $entity $arch $config $time_unit $time $suite_dir end nvc-r1.17.1/test/vi_suite/nvc/compile000077500000000000000000000001201504111170000175020ustar00rootroot00000000000000#!/bin/bash #set -x cd $6$5 nvc --work $4 --std=1993 -a $6$2$1.vhd &> $6$3$1.co nvc-r1.17.1/test/vi_suite/nvc/create_library000077500000000000000000000000311504111170000210420ustar00rootroot00000000000000#!/bin/sh # Nothing to donvc-r1.17.1/test/vi_suite/nvc/simulate000077500000000000000000000004521504111170000177050ustar00rootroot00000000000000#!/bin/bash #set -x cd ${10}$4 if [ $7 != - ]; then # TODO: configurations echo "Cannot elaborate configuration" > ${10}$2$1.so exit 1 else timeout 5s nvc --work $3 --std=1993 -e $5 &> ${10}$2$1.so timeout 5s nvc --work $3 --std=1993 -r $5 --stop-time=$9$8 &>> ${10}$2$1.so fi nvc-r1.17.1/test/vlog/000077500000000000000000000000001504111170000144655ustar00rootroot00000000000000nvc-r1.17.1/test/vlog/attr1.v000066400000000000000000000004541504111170000157120ustar00rootroot00000000000000(* foo *) // OK (* bar *) // OK module mod1((* foo *) output o); (* x *) reg x; // OK task task1; (* a *) int p; // OK foo: (* b *) p = 5; // OK endtask // task1 task task2; (* a *) int p; // OK (* error *) bar: (* b *) p = 6; // Error endtask // task2 endmodule // mod1 nvc-r1.17.1/test/vlog/case1.v000066400000000000000000000005221504111170000156470ustar00rootroot00000000000000module case1; reg x, y, z; reg [7:0] a, b, c; initial begin case (a) // OK 1, 2: b = 5; default: b = 6; endcase // case (a) case (aaa) // Error default: b = 2; endcase // case (aaa) case (a) default b = 6; default b = 7; // Error endcase // case (a) end endmodule // case1 nvc-r1.17.1/test/vlog/casename.v000066400000000000000000000000771504111170000164340ustar00rootroot00000000000000module Name; endmodule // Name module name; endmodule // name nvc-r1.17.1/test/vlog/concat1.v000066400000000000000000000004271504111170000162070ustar00rootroot00000000000000module concat1; wire x, y; wire [7:0] z; real r1; reg q; assign a1 = {x, y}; // OK assign a2 = {r1, x}; // Error assign {z[0], z[4]} = {x, y}; // OK assign {x, q} = 2'b11; // Error assign a3 = {5{x}}; // OK endmodule // concat1 nvc-r1.17.1/test/vlog/const1.v000066400000000000000000000002771504111170000160710ustar00rootroot00000000000000module const1; parameter int p1 = 5; wire [p1-1:0] w1; // OK wire [w1-1:0] w2; // Error wire [+p1:6] w3; // OK wire [p1[0]:0] w4; // OK wire [7:-1] w5; // OK endmodule // const1 nvc-r1.17.1/test/vlog/dff.v000066400000000000000000000001601504111170000154100ustar00rootroot00000000000000module dff (input d, clk, rstb, output reg q); always @(posedge clk) q <= d; endmodule // dff nvc-r1.17.1/test/vlog/direct1.v000066400000000000000000000010231504111170000162030ustar00rootroot00000000000000`default_nettype wire // OK `default_nettype tri // OK `default_nettype tri0 // OK `default_nettype tri1 // OK `default_nettype wand // OK `default_nettype triand // OK `default_nettype wor // OK `default_nettype trior // OK `default_nettype trireg // OK `default_nettype uwire // OK `default_nettype foo // Error `default_nettype none // OK module foo; assign x = 5; // Error endmodule // foo `resetall // OK module bar; assign x = 5; // OK endmodule // foo nvc-r1.17.1/test/vlog/enum1.v000066400000000000000000000002171504111170000157010ustar00rootroot00000000000000module enum1; enum { a, b } [3:0] t_x; // OK typedef enum { c, d } t_y; // OK t_y var1; // OK a var2; // Error endmodule // enum1 nvc-r1.17.1/test/vlog/gate1.v000066400000000000000000000002201504111170000156470ustar00rootroot00000000000000module gate1; wire w; reg r; pullup (w); // OK pulldown (supply0) p1 (r); // OK pullup (supply1) p1 (w); // Error endmodule // gate1 nvc-r1.17.1/test/vlog/generate1.v000066400000000000000000000004121504111170000165240ustar00rootroot00000000000000module mod1; wire x; if (x) begin // Error end localparam p = 5; if (p) begin // OK mod2 u1(); end else begin mod2 u1(); // OK end if (p) g1: begin: g1 // Error end : g2 // Error if (p) begin end : g2 // Error endmodule // mod1 nvc-r1.17.1/test/vlog/implicit1.v000066400000000000000000000002671504111170000165540ustar00rootroot00000000000000module implicit1; assign x1 = 1'b1; // OK and u1(x2, x1); // OK or u2(x1, x3, y); // OK mymod u3(x3, x4); // OK pulldown (x5); // OK endmodule // implicit1 nvc-r1.17.1/test/vlog/initial1.v000066400000000000000000000012271504111170000163700ustar00rootroot00000000000000module initial1; reg z = 0; initial begin : label0 reg w; (* attr0 *) reg e; w = 1; #1 z = 1; $display("ok"); reg q = 0; // Error declarative part must be at the beginnig end : label0 initial begin : label1 end // label1 initial begin end : label2 // error initial begin : a_label end : another_label // error initial fork : fork0 (* attr0 *) reg w; reg e; w = 1; reg q = 0; // Error declarative part must be at the beginnig #2 z = 2; join : fork0 initial fork : fork1 join // fork1 initial fork join : fork3 // Error initial fork : fork4 join : fork5 // Error endmodule // initial1 nvc-r1.17.1/test/vlog/nets1.v000066400000000000000000000007671504111170000157200ustar00rootroot00000000000000module nets1; wand #2 n1; wor #(2,8,1) n2; trior n3; triand n4; trireg (medium) n5; tri0 n6; tri1 (small) n7; //Error tri0 vectored [3:0] #(1, 2, 4) n8; tri0 scalared #1 n9; // Error interconnect #3 n10 [2:1]; tri0 (weak0, strong1) #(2, 3, 5) n11; tri1 (pull0, highz1) n12; reg r1; reg r2; reg r3; assign (highz1, strong0) n2 = r1; assign (weak0, pull1) #5 n4 = r2; assign (highz0, highz1) #(3, 2, 1) n5 = r3; // Error endmodule // nets1 nvc-r1.17.1/test/vlog/param1.v000066400000000000000000000002711504111170000160350ustar00rootroot00000000000000module param1; parameter [7:0] p1 = 8'd5; // OK assign w1 = p1; // OK parameter logic p1 = 1; // Error localparam bit p2 = 0; assign w2 = !p2; // OK endmodule // param1 nvc-r1.17.1/test/vlog/param2.v000066400000000000000000000005411504111170000160360ustar00rootroot00000000000000module param2 # ( logic [7:0] p1 = 8'd5, parameter p2 = 8, p3 = 7, localparam bit p4 = 0, p5 = 5, parameter p6 = 4 ) ( input x, y, output reg z ); assign w1 = p1; // OK parameter logic p1 = 1; // Error endmodule // param2 module mod2 #(p1); parameter p2 = 5; // OK (really a localparam) parameter p3; // Error endmodule nvc-r1.17.1/test/vlog/parse1.v000066400000000000000000000047331504111170000160560ustar00rootroot00000000000000module parse1; wire [8:0] x, y, z; reg zz; assign y = x; always begin : foo $display("hello"); $finish; if (x); if (x) z <= 1; if (x) $display("yes"); else if (z); else $display("no"); z = 0; z = ~x; z = !x; end assign x = x | y; pulldown (supply0) p1 (x); pulldown p2 (x); pullup p3 (y); pullup (supply0, supply1) p4 (y); pullup (y); always @(x or y or (posedge z)) begin end initial begin while (z); repeat (x) x = ~x; do x = y; while (1); end initial begin x = x << 1; x = x >> 1; x = y <<< x; x = x >>> y; end int r1 = 5; wire w1 = 0; task task1; input int x = 6; bit y; @(x) y = 2; endtask // task1 task task2(input int x, inout logic, output logic y); y = !x; endtask // task2 function sum(input int a, b); sum = a + b; endfunction // sum initial begin wait (x) y = 1; x = x ? 1 : y; x = x - y * x + 1 % y / x; x = x ** y; task2(1, x, y); end parameter xx = 6; integer r2 = 66; real r3 = 1.0; shortreal r4 = 6.7; realtime r5 = 1.0; assign r2 = {x, y}; assign {r1, r2} = {x, y}; initial begin for (r1 = 1; r1 < 5; r1++) x = x + 1; for (;;r2 = r2 * x); for (int i = 0; i > 0; --i); for (var reg x = 5;;); end localparam [7:0] yy = 5; localparam bit zzz = 0; wire [y-1:0] w2; reg [7:0] array1 [31:0]; wire [3:0] array2 [6:0]; assign w3 = &(y) | ^(|y); event e; always_comb x = 1; always_ff x = 2; always_latch begin x = 3; end always @(w2) ->e; always @( *) x <= y; initial case (x) 2'b00: y = 1; 2'b01, 2'b10: ; default: y = 2; endcase // case (x) mymod #(.x(1),.y(2)) m1(), m2(.foo(5)); mymod #(1+2) m3(x); myudp (1); buf (x, 1'b0); initial x[1:0] = y[7+:6]; generate if (y == 7) begin mod1 m4(x); end else begin mod1 m5(x); end endgenerate assign x = sum(y, z); function automatic real min(input real a, input real b); if (a < b) min = a; else min = b; endfunction // min time t1; initial begin x = y ^ z; x = y ~^ z; x = y ^~ z; end triand w4; trior w5; (* foo=1 *) tri w6 = w5; uwire w7; assign x = array1[array2[y]]; initial fork #1 x = 1; #5 y = 2; join genvar i; for (i = 0; i < 5; i++) begin genvar j; for (j = 0; j < 10; j = j * 2) assign x[i] = 1_000; for (j = 0; j < 10; ++j) begin end end endmodule // parse1 nvc-r1.17.1/test/vlog/ports.v000066400000000000000000000017451504111170000160320ustar00rootroot00000000000000module ports1 (x, y, z, y); // Error input x; output reg y; output y; // Error output z; reg z; // OK endmodule module ports2 (x, y, z); input x; always @(x) y <= x; // Error (iverilog accepts it?) output reg y; inout z; // OK endmodule // ports2 module ports3 (x, y, z); reg x; output x; output x; // Error input y; reg y; reg y; // Error input z; wire z; endmodule // ports3 module ports4 (input i0, i1, output reg o1, o2, output o3); initial begin o1 = 1; o2 = 0; o3 = 1; // Error end endmodule // ports4 module ports5 (x, y, z); input x, y; // OK output reg z; endmodule // ports5 module ports6 (x, y, z); input [7:0] x; // OK output [3:0] y; // OK wire [5:0] y; // Error input [x:0] z; // Error endmodule // ports6 module ports7 (x, y, z, zz /* Error */); input x, y, z; // OK endmodule // ports7 module ports8 (input wire i0); endmodule // ports8 nvc-r1.17.1/test/vlog/pp1.v000066400000000000000000000002451504111170000153550ustar00rootroot00000000000000`define FOO bar `define BAZ 1 // comment `FOO = `BAZ `ifdef FOO // Another comment pass `else fail `endif `ifndef BAZ fail `else pass `endif `__FILE__ `__LINE__ nvc-r1.17.1/test/vlog/pp2.v000066400000000000000000000001621504111170000153540ustar00rootroot00000000000000`else // Error `endif // Error `ifdef // Error `ifndef // Error `define 1 // Error `ifndef FOO // Error nvc-r1.17.1/test/vlog/pp3.v000066400000000000000000000000541504111170000153550ustar00rootroot00000000000000`define FOO 1 `undef FOO `FOO // Warning nvc-r1.17.1/test/vlog/pp4.v000066400000000000000000000004001504111170000153510ustar00rootroot00000000000000`define MACRO1 \ \ \ \ module \ 123 `define MACRO2 `MACRO1 module pp4; wire x = `MACRO2; // Error wire a = 1; wire b = 2; wire c = 3; wire wire wire; // Error endmodule // pp4 nvc-r1.17.1/test/vlog/simple_sem.v000066400000000000000000000010461504111170000170120ustar00rootroot00000000000000module dff (input d, clk, rstb, output reg q); always @(posedge clk) q <= d; endmodule // dff module duplicate_x (input x, x /* error */); endmodule // duplicate_x module bad_ref1 (input d, clk, rstb, output reg q); always @(posedge clk) qq /* error */ <= dd /* error */; endmodule // dff module bad_target (input d, output q, output reg r); //reg x; wire [7:0] bus; assign r = 1; // Error initial q <= 5; // Error endmodule // bad_target `begin_keywords "1800-2023" `end_keywords // End of file nvc-r1.17.1/test/vlog/specify1.v000066400000000000000000000023331504111170000164000ustar00rootroot00000000000000module test1(a, b, c, d); input a, b, c, d, e, f, clk, rst; output r, s, t, u, v, w; reg notifier; wire delayed_clk, delayed_d; specify specparam t1 = 5.2; specparam [7:0] t2 = 2; (a => r) = 1; (b => s) = (1.2, t1); (c + => t) = t2; (a,b,c -*> u,v,w) = 2.5; if (a) (posedge d,e *> (u,v: (5+6))) = (2.3,4.5); if (b) (negedge e,f - *> (r,s +:1)) = 7; if (c == 1'b0 & b == 1'b1) (edge d => (w : 1)) = 8; if (a) (a => r) = 1; ifnone (a => r) = 1; (negedge e,f - *> (r,s +:1)) = 7; ifnone (posedge c => (f+:(a&&b))) = 0; // Not really allowed (posedge a *> (b : c)) = (1.0, 1.0); (posedge a +*> (b : c)) = (1.0, 1.0); (a[1],b,c -*> u,v,w) = 2.5; (a[1] -*> u,v,w) = 2.5; $setup(a &&& b == 1, clk, 0.5); $setup(b &&& ~c, clk, 0.4,); $setup(c, clk &&& a !== 1'b0, 0.4, notifier); $hold (clk, a &&& (b), 0.1); $hold (clk, b, 0.2,); $hold (clk, c, 0.2, notifier); $recovery(rst, d, 0.5); $removal(rst, e, 0.2); $width(posedge clk, 10, 11); $setuphold (posedge clk, negedge a, 0, 0, notifier,,, delayed_clk, delayed_d); $recrem (negedge rst, posedge clk, 0, 0, notifier,,,,); endspecify endmodule // test1 nvc-r1.17.1/test/vlog/struct1.v000066400000000000000000000002641504111170000162630ustar00rootroot00000000000000module struct1; struct { int a; byte b; } s1; typedef struct { int x, y; } t_pair; struct { int a; int a; // Error } s2; endmodule // struct1 nvc-r1.17.1/test/vlog/tfcall1.v000066400000000000000000000013761504111170000162110ustar00rootroot00000000000000module tfcall1; function [7:0] sum; input [7:0] x, y; // OK sum = x + y; // OK endfunction // sum assign x1 = sum(1, 2); // OK assign x2 = sum(1); // Error assign x3 = sum(1, 2, 3); // Error assign x4 = double(2); // OK assign x5 = not_here(1); // Error assign x6 = x4(6); // Error assign x7 = no_args(); // OK function [3:0] double(input [3:0] x); double = x * 2; endfunction // double function [3:0] no_args( ); no_args = 1; endfunction // no_args reg x, y; initial begin task1(x, y); // OK no_args(); // Error void'(no_args()); // OK end task task1(input x, output y); //y = x * 2; // OK (TODO) endtask // task1 endmodule // tfcall1 nvc-r1.17.1/test/vlog/timescale1.v000066400000000000000000000002041504111170000166770ustar00rootroot00000000000000`timescale 1ps/1ps // OK `timescale 1ps/1hello // Error `timescale 5s/1ps // Error module foo; endmodule // foo nvc-r1.17.1/test/vlog/udp1.v000066400000000000000000000023231504111170000155250ustar00rootroot00000000000000primitive multiplexer (mux, control, dataA, dataB); output mux; input control, dataA, dataB; table // control dataA dataB mux 0 1 ? : 1 ; // ? = 0 1 x 0 0 ? : 0 ; 1 ? 1 : 1 ; 1 ? 0 : 0 ; endtable endprimitive primitive test1 (x, y, z /* Error */); input x; // Error output y; // Error table 0 0 : 1 ; endtable endprimitive primitive test2 (x, y, z); output x; input y, z; table 0 : 1 ; // Error 0 0 0 : 0; // Error endtable endprimitive primitive dff(q, cp, d); output q; input cp, d; reg q; table // (cp) d : q : q ; ? * : ? : - ; (?0) ? : ? : - ; (1x) ? : ? : - ; (x1) 0 : 0 : 0 ; (x1) 1 : 1 : 1 ; (0x) 0 : 0 : 0 ; (0x) 1 : 1 : 1 ; (01) 0 : ? : 0 ; (01) 1 : ? : 1 ; endtable endprimitive primitive test3 (x, y, z); output reg x; input y, z; initial x = 1'b1; table r ? : 0 : 1 ; r ? : 1 : 0 ; r (01) : 1 : 0 ; // Error endtable endprimitive primitive id_0(output reg id_2, input id_1); table ? : 0 : 0; endtable endprimitive nvc-r1.17.1/test/vlog/union1.v000066400000000000000000000001551504111170000160660ustar00rootroot00000000000000module union1; union { int x; logic y; } u1; typedef union { int a; logic b; } t_u2; endmodule // union1 nvc-r1.17.1/test/vpi-dump.c000066400000000000000000000073311504111170000154270ustar00rootroot00000000000000// // Copyright (C) 2024 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "vpi/vpi_user.h" #include #include #include static void visit_object(vpiHandle obj, int indent); const char *get_type_str(PLI_INT32 type) { switch (type) { case vpiSysFuncCall: return "vpiSysFuncCall"; case vpiSysTaskCall: return "vpiSysTaskCall"; case vpiIterator: return "vpiIterator"; case vpiCallback: return "vpiCallback"; case vpiConstant: return "vpiConstant"; case vpiOperation: return "vpiOperation"; case vpiModule: return "vpiModule"; case vpiScope: return "vpiScope"; case vpiPort: return "vpiPort"; case vpiNet: return "vpiNet"; case vpiReg: return "vpiReg"; default: { static char buf[16]; snprintf(buf, sizeof(buf), "%d", type); return buf; } } } static int get_uid(vpiHandle obj) { static struct { vpiHandle handle; int uid; } tab[1024] = {}; static int next_uid = 0; for (int pos = mix_bits_64(obj) % ARRAY_LEN(tab), reprobe = 100;; pos = (pos + 1) % ARRAY_LEN(tab), reprobe--) { if (tab[pos].handle == obj) return tab[pos].uid; else if (tab[pos].handle == NULL) { tab[pos].handle = obj; return (tab[pos].uid = next_uid++); } else if (reprobe == 0) { fprintf(stderr, "too many objects\n"); exit(1); } } } static bool visit_children(vpiHandle obj, int indent) { vpiHandle it = vpi_iterate(vpiScope, obj); if (it == NULL) return false; vpiHandle child = vpi_scan(it); if (child == NULL) return false; do { visit_object(child, indent + 2); } while ((child = vpi_scan(it))); return true; } static bool visit_module(vpiHandle obj, int indent) { printf(" name=\"%s\">\n", vpi_get_str(vpiName, obj)); return visit_children(obj, indent); } static bool visit_net_reg(vpiHandle obj, int indent) { printf(" name=\"%s\"", vpi_get_str(vpiName, obj)); return false; } static bool visit_port(vpiHandle obj, int indent) { printf(" name=\"%s\"", vpi_get_str(vpiName, obj)); return false; } static void visit_object(vpiHandle obj, int indent) { PLI_INT32 type = vpi_get(vpiType, obj); printf("%*.s<%s uid=\"%d\"", indent, "", get_type_str(type), get_uid(obj)); bool children = false; switch (vpi_get(vpiType, obj)) { case vpiModule: children = visit_module(obj, indent); break; case vpiReg: case vpiNet: children = visit_net_reg(obj, indent); break; case vpiPort: children = visit_port(obj, indent); break; } if (children) printf("%*.s\n", indent, "", get_type_str(type)); else printf("/>\n"); } static PLI_INT32 start_of_sim(p_cb_data cb) { vpiHandle it = vpi_iterate(vpiModule, NULL), top; while ((top = vpi_scan(it))) visit_object(top, 0); return 0; } static void startup(void) { s_cb_data cb = { .reason = cbStartOfSimulation, .cb_rtn = start_of_sim, }; vpi_register_cb(&cb); } void (*vlog_startup_routines[])(void) = { startup, 0 }; nvc-r1.17.1/test/workqbench.c000066400000000000000000000043301504111170000160250ustar00rootroot00000000000000// // Copyright (C) 2022 Nick Gasson // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // #include "util.h" #include "option.h" #include "thread.h" #include #include #include #include #include #include const char copy_string[] = ""; const char version_string[] = ""; #define NUM_JOBS 100000 static int *results; #define PAUSE_MS 0 static void is_prime_cb(void *context, void *arg) { int n = (intptr_t)arg; for (int i = 2; i <= n / 2; i++) { if (n % i == 0) { results[n] = 1; break; } } } static void empty_cb(void *context, void *arg) { spin_wait(); } int main(int argc, char **argv) { srand((unsigned)time(NULL)); term_init(); set_default_options(); thread_init(); register_signal_handlers(); results = calloc(sizeof(int), NUM_JOBS); workq_t *wq1 = workq_new(NULL); workq_t *wq2 = workq_new(NULL); for (int i = 0; i < 10; i++) { if (i > 0 && PAUSE_MS > 0) usleep(PAUSE_MS * 1000); printf("iteration %d start\n", i); for (int j = 1; j < NUM_JOBS; j++) workq_do(wq1, is_prime_cb, (void *)(intptr_t)j); for (int j = 0; j < NUM_JOBS; j++) workq_do(wq2, empty_cb, NULL); workq_start(wq1); workq_start(wq2); workq_drain(wq1); workq_drain(wq2); } workq_free(wq1); workq_free(wq2); printf("\nFirst 100 primes:"); for (int i = 2, nth = 0; nth < 100; i++) { if (!results[i]) { if (nth++ % 10 == 0) printf("\n "); printf(" %3d", i); } } printf("\n\n"); return 0; } nvc-r1.17.1/thirdparty/000077500000000000000000000000001504111170000147315ustar00rootroot00000000000000nvc-r1.17.1/thirdparty/Makemodule.am000066400000000000000000000017711504111170000173410ustar00rootroot00000000000000noinst_LIBRARIES += \ lib/libfst.a \ lib/libfastlz.a \ lib/libcpustate.a \ lib/libgnulib.a \ lib/libsha1.a lib_libfst_a_SOURCES = thirdparty/fstapi.c thirdparty/lz4.c thirdparty/fstapi.h \ thirdparty/lz4.h lib_libfastlz_a_SOURCES = thirdparty/fastlz.c thirdparty/fastlz.h lib_libcpustate_a_SOURCES = thirdparty/cpustate.c thirdparty/cpustate.h lib_libsha1_a_SOURCES = thirdparty/sha1.c thirdparty/sha1.h lib_libgnulib_a_SOURCES = if GNULIB_MEMMEM lib_libgnulib_a_SOURCES += thirdparty/memmem.c thirdparty/str-two-way.h endif if GNULIB_STRCASESTR lib_libgnulib_a_SOURCES += thirdparty/strcasestr.c thirdparty/str-two-way.h endif if GNULIB_GETLINE lib_libgnulib_a_SOURCES += thirdparty/getline.c thirdparty/getdelim.c endif if GNULIB_STRCHRNUL lib_libgnulib_a_SOURCES += thirdparty/strchrnul.c thirdparty/rawmemchr.c endif if GNULIB_STRNDUP lib_libgnulib_a_SOURCES += thirdparty/strndup.c endif EXTRA_PROGRAMS += bin/sha1test bin_sha1test_SOURCES = thirdparty/sha1.c bin_sha1test_CFLAGS = -DSHA1TEST nvc-r1.17.1/thirdparty/cpustate.c000066400000000000000000000200021504111170000167170ustar00rootroot00000000000000/* * Copyright (c) 2022 Nick Gasson * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include "cpustate.h" #include #if defined __MINGW32__ #include #endif #if GCC_VERSION > 40600 #define STATIC_ASSERT(x) _Static_assert((x), "Static assertion failed"); #else #define STATIC_ASSERT(x) #endif #if defined __unix__ || defined __APPLE__ void fill_cpu_state(struct cpu_state *cpu, ucontext_t *uc) { memset(cpu, '\0', sizeof(struct cpu_state)); #if defined __linux__ && defined __x86_64__ cpu->pc = uc->uc_mcontext.gregs[REG_RIP]; cpu->sp = uc->uc_mcontext.gregs[REG_RSP]; cpu->regs[0] = uc->uc_mcontext.gregs[REG_RAX]; cpu->regs[1] = uc->uc_mcontext.gregs[REG_RCX]; cpu->regs[2] = uc->uc_mcontext.gregs[REG_RDX]; cpu->regs[3] = uc->uc_mcontext.gregs[REG_RBX]; cpu->regs[4] = uc->uc_mcontext.gregs[REG_RSP]; cpu->regs[5] = uc->uc_mcontext.gregs[REG_RBP]; cpu->regs[6] = uc->uc_mcontext.gregs[REG_RSI]; cpu->regs[7] = uc->uc_mcontext.gregs[REG_RDI]; cpu->regs[8] = uc->uc_mcontext.gregs[REG_R8]; cpu->regs[9] = uc->uc_mcontext.gregs[REG_R9]; cpu->regs[10] = uc->uc_mcontext.gregs[REG_R10]; cpu->regs[11] = uc->uc_mcontext.gregs[REG_R11]; cpu->regs[12] = uc->uc_mcontext.gregs[REG_R12]; cpu->regs[13] = uc->uc_mcontext.gregs[REG_R13]; cpu->regs[14] = uc->uc_mcontext.gregs[REG_R14]; cpu->regs[15] = uc->uc_mcontext.gregs[REG_R15]; #elif defined __linux__ && defined __aarch64__ cpu->pc = uc->uc_mcontext.pc; cpu->sp = uc->uc_mcontext.sp; for (int i = 0; i < 31; i++) cpu->regs[i] = uc->uc_mcontext.regs[i]; #elif defined __linux__ && defined __arm__ cpu->pc = uc->uc_mcontext.arm_pc; cpu->sp = uc->uc_mcontext.arm_sp; cpu->regs[0] = uc->uc_mcontext.arm_r0; cpu->regs[1] = uc->uc_mcontext.arm_r1; cpu->regs[2] = uc->uc_mcontext.arm_r2; cpu->regs[3] = uc->uc_mcontext.arm_r3; cpu->regs[4] = uc->uc_mcontext.arm_r4; cpu->regs[5] = uc->uc_mcontext.arm_r5; cpu->regs[6] = uc->uc_mcontext.arm_r6; cpu->regs[7] = uc->uc_mcontext.arm_r7; cpu->regs[8] = uc->uc_mcontext.arm_r8; cpu->regs[9] = uc->uc_mcontext.arm_r9; cpu->regs[10] = uc->uc_mcontext.arm_r10; cpu->regs[11] = uc->uc_mcontext.arm_fp; cpu->regs[12] = uc->uc_mcontext.arm_ip; cpu->regs[13] = uc->uc_mcontext.arm_lr; #elif defined __FreeBSD__ && defined __x86_64__ cpu->pc = uc->uc_mcontext.mc_rip; cpu->sp = uc->uc_mcontext.mc_rsp; cpu->regs[0] = uc->uc_mcontext.mc_rax; cpu->regs[1] = uc->uc_mcontext.mc_rcx; cpu->regs[2] = uc->uc_mcontext.mc_rdx; cpu->regs[3] = uc->uc_mcontext.mc_rbx; cpu->regs[4] = uc->uc_mcontext.mc_rsp; cpu->regs[5] = uc->uc_mcontext.mc_rbp; cpu->regs[6] = uc->uc_mcontext.mc_rsi; cpu->regs[7] = uc->uc_mcontext.mc_rdi; cpu->regs[8] = uc->uc_mcontext.mc_r8; cpu->regs[9] = uc->uc_mcontext.mc_r9; cpu->regs[10] = uc->uc_mcontext.mc_r10; cpu->regs[11] = uc->uc_mcontext.mc_r11; cpu->regs[12] = uc->uc_mcontext.mc_r12; cpu->regs[13] = uc->uc_mcontext.mc_r13; cpu->regs[14] = uc->uc_mcontext.mc_r14; cpu->regs[15] = uc->uc_mcontext.mc_r15; #elif defined __FreeBSD__ && defined __i386__ cpu->pc = uc->uc_mcontext.mc_eip; cpu->sp = uc->uc_mcontext.mc_esp; cpu->regs[0] = uc->uc_mcontext.mc_eax; cpu->regs[1] = uc->uc_mcontext.mc_ecx; cpu->regs[2] = uc->uc_mcontext.mc_edx; cpu->regs[3] = uc->uc_mcontext.mc_ebx; cpu->regs[4] = uc->uc_mcontext.mc_esp; cpu->regs[5] = uc->uc_mcontext.mc_ebp; cpu->regs[6] = uc->uc_mcontext.mc_esi; cpu->regs[7] = uc->uc_mcontext.mc_edi; #elif defined __FreeBSD__ && defined __aarch64__ cpu->pc = uc->uc_mcontext.mc_gpregs.gp_elr; cpu->sp = uc->uc_mcontext.mc_gpregs.gp_sp; for (int i = 0; i < 30; i++) cpu->regs[i] = uc->uc_mcontext.mc_gpregs.gp_x[i]; cpu->regs[30] = uc->uc_mcontext.mc_gpregs.gp_lr; #elif defined __FreeBSD__ && defined __arm__ cpu->pc = uc->uc_mcontext.__gregs[_REG_PC]; cpu->sp = uc->uc_mcontext.__gregs[_REG_SP]; for (int i = 0; i < 16; i++) cpu->regs[i] = uc->uc_mcontext.__gregs[i]; #elif defined __FreeBSD__ && defined __powerpc__ cpu->pc = uc->uc_mcontext.mc_srr0; cpu->sp = uc->uc_mcontext.mc_gpr[1]; for (int i = 0; i < 32; i++) cpu->regs[i] = uc->uc_mcontext.mc_gpr[i]; #elif defined __OpenBSD__ && defined __x86_64__ cpu->pc = uc->sc_rip; cpu->sp = uc->sc_rsp; cpu->regs[0] = uc->sc_rax; cpu->regs[1] = uc->sc_rcx; cpu->regs[2] = uc->sc_rdx; cpu->regs[3] = uc->sc_rbx; cpu->regs[4] = uc->sc_rsp; cpu->regs[5] = uc->sc_rbp; cpu->regs[6] = uc->sc_rsi; cpu->regs[7] = uc->sc_rdi; cpu->regs[8] = uc->sc_r8; cpu->regs[9] = uc->sc_r9; cpu->regs[10] = uc->sc_r10; cpu->regs[11] = uc->sc_r11; cpu->regs[12] = uc->sc_r12; cpu->regs[13] = uc->sc_r13; cpu->regs[14] = uc->sc_r14; cpu->regs[15] = uc->sc_r15; #elif defined __APPLE__ && defined __arm64__ cpu->pc = uc->uc_mcontext->__ss.__pc; cpu->sp = uc->uc_mcontext->__ss.__sp; for (int i = 0; i < 29; i++) cpu->regs[i] = uc->uc_mcontext->__ss.__x[i]; #elif defined __APPLE__ && defined __x86_64__ cpu->pc = uc->uc_mcontext->__ss.__rip; cpu->sp = uc->uc_mcontext->__ss.__rsp; cpu->regs[0] = uc->uc_mcontext->__ss.__rax; cpu->regs[1] = uc->uc_mcontext->__ss.__rcx; cpu->regs[2] = uc->uc_mcontext->__ss.__rdx; cpu->regs[3] = uc->uc_mcontext->__ss.__rbx; cpu->regs[4] = uc->uc_mcontext->__ss.__rsp; cpu->regs[5] = uc->uc_mcontext->__ss.__rbp; cpu->regs[6] = uc->uc_mcontext->__ss.__rsi; cpu->regs[7] = uc->uc_mcontext->__ss.__rdi; cpu->regs[8] = uc->uc_mcontext->__ss.__r8; cpu->regs[9] = uc->uc_mcontext->__ss.__r9; cpu->regs[10] = uc->uc_mcontext->__ss.__r10; cpu->regs[11] = uc->uc_mcontext->__ss.__r11; cpu->regs[12] = uc->uc_mcontext->__ss.__r12; cpu->regs[13] = uc->uc_mcontext->__ss.__r13; cpu->regs[14] = uc->uc_mcontext->__ss.__r14; cpu->regs[15] = uc->uc_mcontext->__ss.__r15; #else #error Please port fill_cpu_state to this OS/CPU combination #endif } #elif defined __MINGW32__ void fill_cpu_state(struct cpu_state *cpu, PCONTEXT context) { memset(cpu, '\0', sizeof(struct cpu_state)); #if defined __x86_64__ cpu->pc = context->Rip; cpu->sp = context->Rsp; cpu->regs[0] = context->Rax; cpu->regs[1] = context->Rcx; cpu->regs[2] = context->Rdx; cpu->regs[3] = context->Rbx; cpu->regs[4] = context->Rsp; cpu->regs[5] = context->Rbp; cpu->regs[6] = context->Rsi; cpu->regs[7] = context->Rdi; cpu->regs[8] = context->R8; cpu->regs[9] = context->R9; cpu->regs[10] = context->R10; cpu->regs[11] = context->R11; cpu->regs[12] = context->R12; cpu->regs[13] = context->R13; cpu->regs[14] = context->R14; cpu->regs[15] = context->R15; #elif defined __i386__ cpu->pc = context->Eip; cpu->sp = context->Esp; cpu->regs[0] = context->Eax; cpu->regs[1] = context->Ecx; cpu->regs[2] = context->Edx; cpu->regs[3] = context->Ebx; cpu->regs[4] = context->Esp; cpu->regs[5] = context->Ebp; cpu->regs[6] = context->Esi; cpu->regs[7] = context->Edi; #elif defined __aarch64__ cpu->pc = context->Pc; cpu->sp = context->Sp; for (int i = 0; i < 31; i++) cpu->regs[i] = context->X[i]; #else #error Windows not supported on this architecture #endif } #else #error Please port fill_cpu_state to this platform #endif nvc-r1.17.1/thirdparty/cpustate.h000066400000000000000000000023351504111170000167350ustar00rootroot00000000000000/* * Copyright (c) 2022 Nick Gasson * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef _CPUSTATE_H #define _CPUSTATE_H #include #if defined __MINGW32__ #include #elif defined __OpenBSD__ #include #else #include #endif #define MAX_CPU_REGS 32 struct cpu_state { uintptr_t pc; uintptr_t sp; uintptr_t regs[MAX_CPU_REGS]; }; #if defined __MINGW32__ void fill_cpu_state(struct cpu_state *cpu, PCONTEXT context); #else void fill_cpu_state(struct cpu_state *cpu, ucontext_t *uc); #endif #endif nvc-r1.17.1/thirdparty/fastlz.c000066400000000000000000000323711504111170000164060ustar00rootroot00000000000000/* FastLZ - lightning-fast lossless compression library Copyright (C) 2007 Ariya Hidayat (ariya@kde.org) Copyright (C) 2006 Ariya Hidayat (ariya@kde.org) Copyright (C) 2005 Ariya Hidayat (ariya@kde.org) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. SPDX-License-Identifier: MIT */ #include "fastlz.h" #if !defined(FASTLZ__COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) /* * Always check for bound when decompressing. * Generally it is best to leave it defined. */ #define FASTLZ_SAFE /* * Give hints to the compiler for branch prediction optimization. */ #if defined(__GNUC__) && (__GNUC__ > 2) #define FASTLZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1)) #define FASTLZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0)) #else #define FASTLZ_EXPECT_CONDITIONAL(c) (c) #define FASTLZ_UNEXPECT_CONDITIONAL(c) (c) #endif /* * Use inlined functions for supported systems. */ #if defined(__GNUC__) || defined(__DMC__) || defined(__POCC__) || defined(__WATCOMC__) || defined(__SUNPRO_C) #define FASTLZ_INLINE inline #elif defined(__BORLANDC__) || defined(_MSC_VER) || defined(__LCC__) #define FASTLZ_INLINE __inline #else #define FASTLZ_INLINE #endif /* * Prevent accessing more than 8-bit at once, except on x86 architectures. */ #if !defined(FASTLZ_STRICT_ALIGN) #define FASTLZ_STRICT_ALIGN #if defined(__i386__) || defined(__386) /* GNU C, Sun Studio */ #undef FASTLZ_STRICT_ALIGN #elif defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(__amd64) /* GNU C */ #undef FASTLZ_STRICT_ALIGN #elif defined(_M_IX86) /* Intel, MSVC */ #undef FASTLZ_STRICT_ALIGN #elif defined(__386) #undef FASTLZ_STRICT_ALIGN #elif defined(_X86_) /* MinGW */ #undef FASTLZ_STRICT_ALIGN #elif defined(__I86__) /* Digital Mars */ #undef FASTLZ_STRICT_ALIGN #endif #endif /* prototypes */ int fastlz_compress(const void* input, int length, void* output); int fastlz_compress_level(int level, const void* input, int length, void* output); int fastlz_decompress(const void* input, int length, void* output, int maxout); #define MAX_COPY 32 #define MAX_LEN 264 /* 256 + 8 */ #define MAX_DISTANCE 8192 #if !defined(FASTLZ_STRICT_ALIGN) #define FASTLZ_READU16(p) *((const flzuint16*)(p)) #else #define FASTLZ_READU16(p) ((p)[0] | (p)[1]<<8) #endif #define HASH_LOG 13 #define HASH_SIZE (1<< HASH_LOG) #define HASH_MASK (HASH_SIZE-1) #define HASH_FUNCTION(v,p) { v = FASTLZ_READU16(p); v ^= FASTLZ_READU16(p+1)^(v>>(16-HASH_LOG));v &= HASH_MASK; } #undef FASTLZ_LEVEL #define FASTLZ_LEVEL 1 #undef FASTLZ_COMPRESSOR #undef FASTLZ_DECOMPRESSOR #define FASTLZ_COMPRESSOR fastlz1_compress #define FASTLZ_DECOMPRESSOR fastlz1_decompress static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output); static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout); #include "fastlz.c" #undef FASTLZ_LEVEL #define FASTLZ_LEVEL 2 #undef MAX_DISTANCE #define MAX_DISTANCE 8191 #define MAX_FARDISTANCE (65535+MAX_DISTANCE-1) #undef FASTLZ_COMPRESSOR #undef FASTLZ_DECOMPRESSOR #define FASTLZ_COMPRESSOR fastlz2_compress #define FASTLZ_DECOMPRESSOR fastlz2_decompress static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output); static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout); #include "fastlz.c" int fastlz_compress(const void* input, int length, void* output) { /* for short block, choose fastlz1 */ if(length < 65536) return fastlz1_compress(input, length, output); /* else... */ return fastlz2_compress(input, length, output); } int fastlz_decompress(const void* input, int length, void* output, int maxout) { /* magic identifier for compression level */ int level = ((*(const flzuint8*)input) >> 5) + 1; if(level == 1) return fastlz1_decompress(input, length, output, maxout); if(level == 2) return fastlz2_decompress(input, length, output, maxout); /* unknown level, trigger error */ return 0; } int fastlz_compress_level(int level, const void* input, int length, void* output) { if(level == 1) return fastlz1_compress(input, length, output); if(level == 2) return fastlz2_compress(input, length, output); return 0; } #else /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */ static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output) { const flzuint8* ip = (const flzuint8*) input; const flzuint8* ip_bound = ip + length - 2; const flzuint8* ip_limit = ip + length - 12; flzuint8* op = (flzuint8*) output; const flzuint8* htab[HASH_SIZE]; const flzuint8** hslot; flzuint32 hval; flzuint32 copy; /* sanity check */ if(FASTLZ_UNEXPECT_CONDITIONAL(length < 4)) { if(length) { /* create literal copy only */ *op++ = length-1; ip_bound++; while(ip <= ip_bound) *op++ = *ip++; return length+1; } else return 0; } /* initializes hash table */ for (hslot = htab; hslot < htab + HASH_SIZE; hslot++) *hslot = ip; /* we start with literal copy */ copy = 2; *op++ = MAX_COPY-1; *op++ = *ip++; *op++ = *ip++; /* main loop */ while(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit)) { const flzuint8* ref; flzuint32 distance; /* minimum match length */ flzuint32 len = 3; /* comparison starting-point */ const flzuint8* anchor = ip; /* check for a run */ #if FASTLZ_LEVEL==2 if(ip[0] == ip[-1] && FASTLZ_READU16(ip-1)==FASTLZ_READU16(ip+1)) { distance = 1; /* ip += 3; */ /* scan-build, never used */ ref = anchor - 1 + 3; goto match; } #endif /* find potential match */ HASH_FUNCTION(hval,ip); hslot = htab + hval; ref = htab[hval]; /* calculate distance to the match */ distance = anchor - ref; /* update hash table */ *hslot = anchor; /* is this a match? check the first 3 bytes */ if(distance==0 || #if FASTLZ_LEVEL==1 (distance >= MAX_DISTANCE) || #else (distance >= MAX_FARDISTANCE) || #endif *ref++ != *ip++ || *ref++!=*ip++ || *ref++!=*ip++) goto literal; #if FASTLZ_LEVEL==2 /* far, needs at least 5-byte match */ if(distance >= MAX_DISTANCE) { if(*ip++ != *ref++ || *ip++!= *ref++) goto literal; len += 2; } match: #endif /* last matched byte */ ip = anchor + len; /* distance is biased */ distance--; if(!distance) { /* zero distance means a run */ flzuint8 x = ip[-1]; while(ip < ip_bound) if(*ref++ != x) break; else ip++; } else for(;;) { /* safe because the outer check against ip limit */ if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; if(*ref++ != *ip++) break; while(ip < ip_bound) if(*ref++ != *ip++) break; break; } /* if we have copied something, adjust the copy count */ if(copy) /* copy is biased, '0' means 1 byte copy */ *(op-copy-1) = copy-1; else /* back, to overwrite the copy count */ op--; /* reset literal counter */ copy = 0; /* length is biased, '1' means a match of 3 bytes */ ip -= 3; len = ip - anchor; /* encode the match */ #if FASTLZ_LEVEL==2 if(distance < MAX_DISTANCE) { if(len < 7) { *op++ = (len << 5) + (distance >> 8); *op++ = (distance & 255); } else { *op++ = (7 << 5) + (distance >> 8); for(len-=7; len >= 255; len-= 255) *op++ = 255; *op++ = len; *op++ = (distance & 255); } } else { /* far away, but not yet in the another galaxy... */ if(len < 7) { distance -= MAX_DISTANCE; *op++ = (len << 5) + 31; *op++ = 255; *op++ = distance >> 8; *op++ = distance & 255; } else { distance -= MAX_DISTANCE; *op++ = (7 << 5) + 31; for(len-=7; len >= 255; len-= 255) *op++ = 255; *op++ = len; *op++ = 255; *op++ = distance >> 8; *op++ = distance & 255; } } #else if(FASTLZ_UNEXPECT_CONDITIONAL(len > MAX_LEN-2)) while(len > MAX_LEN-2) { *op++ = (7 << 5) + (distance >> 8); *op++ = MAX_LEN - 2 - 7 -2; *op++ = (distance & 255); len -= MAX_LEN-2; } if(len < 7) { *op++ = (len << 5) + (distance >> 8); *op++ = (distance & 255); } else { *op++ = (7 << 5) + (distance >> 8); *op++ = len - 7; *op++ = (distance & 255); } #endif /* update the hash at match boundary */ HASH_FUNCTION(hval,ip); htab[hval] = ip++; HASH_FUNCTION(hval,ip); htab[hval] = ip++; /* assuming literal copy */ *op++ = MAX_COPY-1; continue; literal: *op++ = *anchor++; ip = anchor; copy++; if(FASTLZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY)) { copy = 0; *op++ = MAX_COPY-1; } } /* left-over as literal copy */ ip_bound++; while(ip <= ip_bound) { *op++ = *ip++; copy++; if(copy == MAX_COPY) { copy = 0; *op++ = MAX_COPY-1; } } /* if we have copied something, adjust the copy length */ if(copy) *(op-copy-1) = copy-1; else op--; #if FASTLZ_LEVEL==2 /* marker for fastlz2 */ *(flzuint8*)output |= (1 << 5); #endif return op - (flzuint8*)output; } static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout) { const flzuint8* ip = (const flzuint8*) input; const flzuint8* ip_limit = ip + length; flzuint8* op = (flzuint8*) output; flzuint8* op_limit = op + maxout; flzuint32 ctrl = (*ip++) & 31; int loop = 1; do { const flzuint8* ref = op; flzuint32 len = ctrl >> 5; flzuint32 ofs = (ctrl & 31) << 8; if(ctrl >= 32) { #if FASTLZ_LEVEL==2 flzuint8 code; #endif len--; ref -= ofs; if (len == 7-1) #if FASTLZ_LEVEL==1 len += *ip++; ref -= *ip++; #else do { code = *ip++; len += code; } while (code==255); code = *ip++; ref -= code; /* match from 16-bit distance */ if(FASTLZ_UNEXPECT_CONDITIONAL(code==255)) if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8))) { ofs = (*ip++) << 8; ofs += *ip++; ref = op - ofs - MAX_DISTANCE; } #endif #ifdef FASTLZ_SAFE if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit)) return 0; if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output)) return 0; #endif if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit)) ctrl = *ip++; else loop = 0; if(ref == op) { /* optimize copy for a run */ flzuint8 b = ref[-1]; *op++ = b; *op++ = b; *op++ = b; for(; len; --len) *op++ = b; } else { #if !defined(FASTLZ_STRICT_ALIGN) const flzuint16* p; flzuint16* q; #endif /* copy from reference */ ref--; *op++ = *ref++; *op++ = *ref++; *op++ = *ref++; #if !defined(FASTLZ_STRICT_ALIGN) /* copy a byte, so that now it's word aligned */ if(len & 1) { *op++ = *ref++; len--; } /* copy 16-bit at once */ q = (flzuint16*) op; op += len; p = (const flzuint16*) ref; for(len>>=1; len > 4; len-=4) { *q++ = *p++; *q++ = *p++; *q++ = *p++; *q++ = *p++; } for(; len; --len) *q++ = *p++; #else for(; len; --len) *op++ = *ref++; #endif } } else { ctrl++; #ifdef FASTLZ_SAFE if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit)) return 0; if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit)) return 0; #endif *op++ = *ip++; for(--ctrl; ctrl; ctrl--) *op++ = *ip++; loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit); if(loop) ctrl = *ip++; } } while(FASTLZ_EXPECT_CONDITIONAL(loop)); return op - (flzuint8*)output; } #endif /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */ nvc-r1.17.1/thirdparty/fastlz.h000066400000000000000000000071451504111170000164140ustar00rootroot00000000000000/* FastLZ - lightning-fast lossless compression library Copyright (C) 2007 Ariya Hidayat (ariya@kde.org) Copyright (C) 2006 Ariya Hidayat (ariya@kde.org) Copyright (C) 2005 Ariya Hidayat (ariya@kde.org) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. SPDX-License-Identifier: MIT */ #ifndef FASTLZ_H #define FASTLZ_H #include #define flzuint8 uint8_t #define flzuint16 uint16_t #define flzuint32 uint32_t #define FASTLZ_VERSION 0x000100 #define FASTLZ_VERSION_MAJOR 0 #define FASTLZ_VERSION_MINOR 0 #define FASTLZ_VERSION_REVISION 0 #define FASTLZ_VERSION_STRING "0.1.0" #if defined (__cplusplus) extern "C" { #endif /** Compress a block of data in the input buffer and returns the size of compressed block. The size of input buffer is specified by length. The minimum input buffer size is 16. The output buffer must be at least 5% larger than the input buffer and can not be smaller than 66 bytes. If the input is not compressible, the return value might be larger than length (input buffer size). The input buffer and the output buffer can not overlap. */ int fastlz_compress(const void* input, int length, void* output); /** Decompress a block of compressed data and returns the size of the decompressed block. If error occurs, e.g. the compressed data is corrupted or the output buffer is not large enough, then 0 (zero) will be returned instead. The input buffer and the output buffer can not overlap. Decompression is memory safe and guaranteed not to write the output buffer more than what is specified in maxout. */ int fastlz_decompress(const void* input, int length, void* output, int maxout); /** Compress a block of data in the input buffer and returns the size of compressed block. The size of input buffer is specified by length. The minimum input buffer size is 16. The output buffer must be at least 5% larger than the input buffer and can not be smaller than 66 bytes. If the input is not compressible, the return value might be larger than length (input buffer size). The input buffer and the output buffer can not overlap. Compression level can be specified in parameter level. At the moment, only level 1 and level 2 are supported. Level 1 is the fastest compression and generally useful for short data. Level 2 is slightly slower but it gives better compression ratio. Note that the compressed data, regardless of the level, can always be decompressed using the function fastlz_decompress above. */ int fastlz_compress_level(int level, const void* input, int length, void* output); #if defined (__cplusplus) } #endif #endif /* FASTLZ_H */ nvc-r1.17.1/thirdparty/fst_win_unistd.h000066400000000000000000000030711504111170000201420ustar00rootroot00000000000000/* * Copyright (c) 2009-2018 Tony Bybell. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * SPDX-License-Identifier: MIT */ #ifndef WIN_UNISTD_H #define WIN_UNISTD_H #include #ifdef _WIN64 #include #else #include #endif #include #define ftruncate _chsize_s #define unlink _unlink #define fileno _fileno #define lseek _lseeki64 #ifdef _WIN64 #define ssize_t __int64 #define SSIZE_MAX 9223372036854775807i64 #else #define ssize_t long #define SSIZE_MAX 2147483647L #endif #include "stdint.h" #endif //WIN_UNISTD_H nvc-r1.17.1/thirdparty/fstapi.c000066400000000000000000007157201504111170000163770ustar00rootroot00000000000000/* * Copyright (c) 2009-2023 Tony Bybell. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * SPDX-License-Identifier: MIT */ /* * possible disables: * * FST_DYNAMIC_ALIAS_DISABLE : dynamic aliases are not processed * FST_DYNAMIC_ALIAS2_DISABLE : new encoding for dynamic aliases is not generated * FST_WRITEX_DISABLE : fast write I/O routines are disabled * * possible enables: * * FST_DEBUG : not for production use, only enable for development * FST_REMOVE_DUPLICATE_VC : glitch removal (has writer performance impact) * HAVE_LIBPTHREAD -> FST_WRITER_PARALLEL : enables inclusion of parallel writer code * */ #define FST_INCLUDE_CONFIG 1 #ifdef FST_INCLUDE_CONFIG #include #endif #include "fstapi.h" #include "fastlz.h" #include "lz4.h" #include #ifndef HAVE_LIBPTHREAD #undef FST_WRITER_PARALLEL #endif #ifdef FST_WRITER_PARALLEL #include #endif #ifdef __MINGW32__ #define WIN32_LEAN_AND_MEAN #include #endif #ifndef PATH_MAX #define PATH_MAX (4096) #endif #if defined(_MSC_VER) typedef int64_t fst_off_t; #else typedef off_t fst_off_t; #endif /* should be more than enough for fstWriterSetSourceStem() */ #define FST_PATH_HASHMASK ((1UL << 16) - 1) typedef const void *Pcvoid_t; typedef void *Pvoid_t; typedef void **PPvoid_t; void JenkinsFree(void *base_i, uint32_t hashmask); void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint32_t hashmask); #ifndef FST_WRITEX_DISABLE #define FST_WRITEX_MAX (64 * 1024) #else #define fstWritex(a, b, c) fstFwrite((b), (c), 1, fv) #endif /* these defines have a large impact on writer speed when a model has a */ /* huge number of symbols. as a default, use 128MB and increment when */ /* every 1M signals are defined. */ #define FST_BREAK_SIZE (1UL << 27) #define FST_BREAK_ADD_SIZE (1UL << 22) #define FST_BREAK_SIZE_MAX (1UL << 31) #define FST_ACTIVATE_HUGE_BREAK (1000000) #define FST_ACTIVATE_HUGE_INC (1000000) #define FST_WRITER_STR "fstWriter" #define FST_ID_NAM_SIZ (512) #define FST_ID_NAM_ATTR_SIZ (65536 + 4096) #define FST_DOUBLE_ENDTEST (2.7182818284590452354) #define FST_HDR_SIM_VERSION_SIZE (128) #define FST_HDR_DATE_SIZE (119) #define FST_HDR_FILETYPE_SIZE (1) #define FST_HDR_TIMEZERO_SIZE (8) #define FST_GZIO_LEN (32768) #define FST_HDR_FOURPACK_DUO_SIZE (4 * 1024 * 1024) #define FST_ZWRAPPER_HDR_SIZE (1 + 8 + 8) #if defined(__APPLE__) && defined(__MACH__) #define FST_MACOSX #include #endif #if defined(FST_MACOSX) || defined(__MINGW32__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \ defined(__NetBSD__) #define FST_UNBUFFERED_IO #endif #ifdef __GNUC__ /* Boolean expression more often true than false */ #define FST_LIKELY(x) __builtin_expect(!!(x), 1) /* Boolean expression more often false than true */ #define FST_UNLIKELY(x) __builtin_expect(!!(x), 0) #else #define FST_LIKELY(x) (!!(x)) #define FST_UNLIKELY(x) (!!(x)) #endif #define FST_APIMESS "FSTAPI | " /***********************/ /*** ***/ /*** common function ***/ /*** ***/ /***********************/ #ifdef __MINGW32__ #include #ifndef HAVE_FSEEKO #define ftello _ftelli64 #define fseeko _fseeki64 #endif #endif /* * the recoded "extra" values... * note that FST_RCV_Q is currently unused and is for future expansion. * its intended use is as another level of escape such that any arbitrary * value can be stored as the value: { time_delta, 8 bits, FST_RCV_Q }. * this is currently not implemented so that the branchless decode is: * uint32_t shcnt = 2 << (vli & 1); tdelta = vli >> shcnt; */ #define FST_RCV_X (1 | (0 << 1)) #define FST_RCV_Z (1 | (1 << 1)) #define FST_RCV_H (1 | (2 << 1)) #define FST_RCV_U (1 | (3 << 1)) #define FST_RCV_W (1 | (4 << 1)) #define FST_RCV_L (1 | (5 << 1)) #define FST_RCV_D (1 | (6 << 1)) #define FST_RCV_Q (1 | (7 << 1)) #define FST_RCV_STR "xzhuwl-?" /* 01234567 */ /* * report abort messages */ #ifdef NDEBUG #define chk_report_abort(s) #else #define chk_report_abort(s) abort() #endif /* * prevent old file overwrite when currently being read */ static FILE *unlink_fopen(const char *nam, const char *mode) { unlink(nam); return (fopen(nam, mode)); } /* * system-specific temp file handling */ #ifdef __MINGW32__ static FILE *tmpfile_open(char **nam) { char *fname = NULL; TCHAR szTempFileName[MAX_PATH]; TCHAR lpTempPathBuffer[MAX_PATH]; DWORD dwRetVal = 0; UINT uRetVal = 0; FILE *fh = NULL; if (nam) /* cppcheck warning fix: nam is always defined, so this is not needed */ { dwRetVal = GetTempPath(MAX_PATH, lpTempPathBuffer); if ((dwRetVal > MAX_PATH) || (dwRetVal == 0)) { fprintf(stderr, FST_APIMESS "GetTempPath() failed in " __FILE__ " line %d, exiting.\n", __LINE__); exit(255); } else { uRetVal = GetTempFileName(lpTempPathBuffer, TEXT("FSTW"), 0, szTempFileName); if (uRetVal == 0) { fprintf(stderr, FST_APIMESS "GetTempFileName() failed in " __FILE__ " line %d, exiting.\n", __LINE__); exit(255); } else { fname = strdup(szTempFileName); } } if (fname) { *nam = fname; fh = unlink_fopen(fname, "w+b"); } } return (fh); } #else static FILE *tmpfile_open(char **nam) { FILE *f = tmpfile(); /* replace with mkstemp() + fopen(), etc if this is not good enough */ if (nam) { *nam = NULL; } return (f); } #endif static void tmpfile_close(FILE **f, char **nam) { if (f) { if (*f) { fclose(*f); *f = NULL; } } if (nam) { if (*nam) { unlink(*nam); free(*nam); *nam = NULL; } } } /*****************************************/ /* * to remove warn_unused_result compile time messages * (in the future there needs to be results checking) */ static size_t fstFread(void *buf, size_t siz, size_t cnt, FILE *fp) { return (fread(buf, siz, cnt, fp)); } static size_t fstFwrite(const void *buf, size_t siz, size_t cnt, FILE *fp) { return (fwrite(buf, siz, cnt, fp)); } static int fstFtruncate(int fd, fst_off_t length) { return (ftruncate(fd, length)); } /* * realpath compatibility */ static char *fstRealpath(const char *path, char *resolved_path) { #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED || defined __CYGWIN__ || defined HAVE_REALPATH #if (defined(__MACH__) && defined(__APPLE__)) if (!resolved_path) { resolved_path = (char *)malloc(PATH_MAX + 1); /* fixes bug on Leopard when resolved_path == NULL */ } #endif return (realpath(path, resolved_path)); #else #ifdef __MINGW32__ if (!resolved_path) { resolved_path = (char *)malloc(PATH_MAX + 1); } return (_fullpath(resolved_path, path, PATH_MAX)); #else (void)path; (void)resolved_path; return (NULL); #endif #endif } /* * mmap compatibility */ #if defined __MINGW32__ #include #define fstMmap(__addr, __len, __prot, __flags, __fd, __off) fstMmap2((__len), (__fd), (__off)) #define fstMunmap(__addr, __len) UnmapViewOfFile((LPCVOID)__addr) static void *fstMmap2(size_t __len, int __fd, fst_off_t __off) { DWORD64 len64 = __len; /* Must be 64-bit for shift below */ HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(__fd), NULL, PAGE_READWRITE, (DWORD)(len64 >> 32), (DWORD)__len, NULL); if (!handle) { return NULL; } void *ptr = MapViewOfFileEx(handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, (DWORD)__off, (SIZE_T)__len, (LPVOID)NULL); CloseHandle(handle); return ptr; } #else #include #if defined(__SUNPRO_C) #define FST_CADDR_T_CAST (caddr_t) #else #define FST_CADDR_T_CAST #endif #define fstMmap(__addr, __len, __prot, __flags, __fd, __off) \ (void *)mmap(FST_CADDR_T_CAST(__addr), (__len), (__prot), (__flags), (__fd), (__off)) #define fstMunmap(__addr, __len) \ { \ if (__addr) \ munmap(FST_CADDR_T_CAST(__addr), (__len)); \ } #endif /* * regular and variable-length integer access functions */ static uint32_t fstGetUint32(unsigned char *mem) { uint32_t u32; unsigned char *buf = (unsigned char *)(&u32); memcpy(buf, mem, sizeof(uint32_t)); return (*(uint32_t *)buf); } static int fstWriterUint64(FILE *handle, uint64_t v) { unsigned char buf[8]; int i; for (i = 7; i >= 0; i--) { buf[i] = v & 0xff; v >>= 8; } fstFwrite(buf, 8, 1, handle); return (8); } static uint64_t fstReaderUint64(FILE *f) { uint64_t val = 0; unsigned char buf[sizeof(uint64_t)]; unsigned int i; fstFread(buf, sizeof(uint64_t), 1, f); for (i = 0; i < sizeof(uint64_t); i++) { val <<= 8; val |= buf[i]; } return (val); } static uint32_t fstGetVarint32(unsigned char *mem, int *skiplen) { unsigned char *mem_orig = mem; uint32_t rc = 0; while (*mem & 0x80) { mem++; } *skiplen = mem - mem_orig + 1; for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); if (mem == mem_orig) { break; } mem--; } return (rc); } static uint32_t fstGetVarint32Length(unsigned char *mem) { unsigned char *mem_orig = mem; while (*mem & 0x80) { mem++; } return (mem - mem_orig + 1); } static uint32_t fstGetVarint32NoSkip(unsigned char *mem) { unsigned char *mem_orig = mem; uint32_t rc = 0; while (*mem & 0x80) { mem++; } for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); if (mem == mem_orig) { break; } mem--; } return (rc); } static unsigned char *fstCopyVarint32ToLeft(unsigned char *pnt, uint32_t v) { unsigned char *spnt; uint32_t nxt = v; int cnt = 1; int i; while ((nxt = nxt >> 7)) /* determine len to avoid temp buffer copying to cut down on load-hit-store */ { cnt++; } pnt -= cnt; spnt = pnt; cnt--; for (i = 0; i < cnt; i++) /* now generate left to right as normal */ { nxt = v >> 7; *(spnt++) = ((unsigned char)v) | 0x80; v = nxt; } *spnt = (unsigned char)v; return (pnt); } static unsigned char *fstCopyVarint64ToRight(unsigned char *pnt, uint64_t v) { uint64_t nxt; while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; } *(pnt++) = (unsigned char)v; return (pnt); } static uint64_t fstGetVarint64(unsigned char *mem, int *skiplen) { unsigned char *mem_orig = mem; uint64_t rc = 0; while (*mem & 0x80) { mem++; } *skiplen = mem - mem_orig + 1; for (;;) { rc <<= 7; rc |= (uint64_t)(*mem & 0x7f); if (mem == mem_orig) { break; } mem--; } return (rc); } static uint32_t fstReaderVarint32(FILE *f) { const int chk_len_max = 5; /* TALOS-2023-1783 */ int chk_len = chk_len_max; unsigned char buf[chk_len_max]; unsigned char *mem = buf; uint32_t rc = 0; int ch; do { ch = fgetc(f); *(mem++) = ch; } while ((ch & 0x80) && (--chk_len)); if (ch & 0x80) chk_report_abort("TALOS-2023-1783"); mem--; for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); if (mem == buf) { break; } mem--; } return (rc); } static uint32_t fstReaderVarint32WithSkip(FILE *f, uint32_t *skiplen) { const int chk_len_max = 5; /* TALOS-2023-1783 */ int chk_len = chk_len_max; unsigned char buf[chk_len_max]; unsigned char *mem = buf; uint32_t rc = 0; int ch; do { ch = fgetc(f); *(mem++) = ch; } while ((ch & 0x80) && (--chk_len)); if (ch & 0x80) chk_report_abort("TALOS-2023-1783"); *skiplen = mem - buf; mem--; for (;;) { rc <<= 7; rc |= (uint32_t)(*mem & 0x7f); if (mem == buf) { break; } mem--; } return (rc); } static uint64_t fstReaderVarint64(FILE *f) { const int chk_len_max = 16; /* TALOS-2023-1783 */ int chk_len = chk_len_max; unsigned char buf[chk_len_max]; unsigned char *mem = buf; uint64_t rc = 0; int ch; do { ch = fgetc(f); *(mem++) = ch; } while ((ch & 0x80) && (--chk_len)); if (ch & 0x80) chk_report_abort("TALOS-2023-1783"); mem--; for (;;) { rc <<= 7; rc |= (uint64_t)(*mem & 0x7f); if (mem == buf) { break; } mem--; } return (rc); } static int fstWriterVarint(FILE *handle, uint64_t v) { uint64_t nxt; unsigned char buf[10]; /* ceil(64/7) = 10 */ unsigned char *pnt = buf; int len; while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; } *(pnt++) = (unsigned char)v; len = pnt - buf; fstFwrite(buf, len, 1, handle); return (len); } /* signed integer read/write routines are currently unused */ static int64_t fstGetSVarint64(unsigned char *mem, int *skiplen) { unsigned char *mem_orig = mem; int64_t rc = 0; const int64_t one = 1; const int siz = sizeof(int64_t) * 8; int shift = 0; unsigned char byt; do { byt = *(mem++); rc |= ((int64_t)(byt & 0x7f)) << shift; shift += 7; } while (byt & 0x80); if ((shift < siz) && (byt & 0x40)) { rc |= -(one << shift); /* sign extend */ } *skiplen = mem - mem_orig; return (rc); } #ifndef FST_DYNAMIC_ALIAS2_DISABLE static int fstWriterSVarint(FILE *handle, int64_t v) { unsigned char buf[15]; /* ceil(64/7) = 10 + sign byte padded way up */ unsigned char byt; unsigned char *pnt = buf; int more = 1; int len; do { byt = v | 0x80; v >>= 7; if (((!v) && (!(byt & 0x40))) || ((v == -1) && (byt & 0x40))) { more = 0; byt &= 0x7f; } *(pnt++) = byt; } while (more); len = pnt - buf; fstFwrite(buf, len, 1, handle); return (len); } #endif /***********************/ /*** ***/ /*** writer function ***/ /*** ***/ /***********************/ /* * private structs */ struct fstBlackoutChain { struct fstBlackoutChain *next; uint64_t tim; unsigned active : 1; }; struct fstWriterContext { FILE *handle; FILE *hier_handle; FILE *geom_handle; FILE *valpos_handle; FILE *curval_handle; FILE *tchn_handle; unsigned char *vchg_mem; fst_off_t hier_file_len; uint32_t *valpos_mem; unsigned char *curval_mem; unsigned char *outval_mem; /* for two-state / Verilator-style value changes */ uint32_t outval_alloc_siz; char *filename; fstHandle maxhandle; fstHandle numsigs; uint32_t maxvalpos; unsigned vc_emitted : 1; unsigned is_initial_time : 1; unsigned fourpack : 1; unsigned fastpack : 1; int64_t timezero; fst_off_t section_header_truncpos; uint32_t tchn_cnt, tchn_idx; uint64_t curtime; uint64_t firsttime; uint32_t vchg_siz; uint32_t vchg_alloc_siz; uint32_t secnum; fst_off_t section_start; uint32_t numscopes; double nan; /* nan value for uninitialized doubles */ struct fstBlackoutChain *blackout_head; struct fstBlackoutChain *blackout_curr; uint32_t num_blackouts; uint64_t dump_size_limit; unsigned char filetype; /* default is 0, FST_FT_VERILOG */ unsigned compress_hier : 1; unsigned repack_on_close : 1; unsigned skip_writing_section_hdr : 1; unsigned size_limit_locked : 1; unsigned section_header_only : 1; unsigned flush_context_pending : 1; unsigned parallel_enabled : 1; unsigned parallel_was_enabled : 1; /* should really be semaphores, but are bytes to cut down on read-modify-write window size */ unsigned char already_in_flush; /* in case control-c handlers interrupt */ unsigned char already_in_close; /* in case control-c handlers interrupt */ #ifdef FST_WRITER_PARALLEL pthread_mutex_t mutex; pthread_t thread; pthread_attr_t thread_attr; struct fstWriterContext *xc_parent; #endif unsigned in_pthread : 1; size_t fst_orig_break_size; size_t fst_orig_break_add_size; size_t fst_break_size; size_t fst_break_add_size; size_t fst_huge_break_size; fstHandle next_huge_break; Pvoid_t path_array; uint32_t path_array_count; unsigned fseek_failed : 1; char *geom_handle_nam; char *valpos_handle_nam; char *curval_handle_nam; char *tchn_handle_nam; fstEnumHandle max_enumhandle; }; static int fstWriterFseeko(struct fstWriterContext *xc, FILE *stream, fst_off_t offset, int whence) { int rc = fseeko(stream, offset, whence); if (rc < 0) { xc->fseek_failed = 1; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "Seek to #%" PRId64 " (whence = %d) failed!\n", offset, whence); perror("Why"); #endif } return (rc); } static uint32_t fstWriterUint32WithVarint32(struct fstWriterContext *xc, uint32_t *u, uint32_t v, const void *dbuf, uint32_t siz) { unsigned char *buf = xc->vchg_mem + xc->vchg_siz; unsigned char *pnt = buf; uint32_t nxt; uint32_t len; memcpy(pnt, u, sizeof(uint32_t)); pnt += 4; while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; } *(pnt++) = (unsigned char)v; memcpy(pnt, dbuf, siz); len = pnt - buf + siz; return (len); } static uint32_t fstWriterUint32WithVarint32AndLength(struct fstWriterContext *xc, uint32_t *u, uint32_t v, const void *dbuf, uint32_t siz) { unsigned char *buf = xc->vchg_mem + xc->vchg_siz; unsigned char *pnt = buf; uint32_t nxt; uint32_t len; memcpy(pnt, u, sizeof(uint32_t)); pnt += 4; while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; } *(pnt++) = (unsigned char)v; v = siz; while ((nxt = v >> 7)) { *(pnt++) = ((unsigned char)v) | 0x80; v = nxt; } *(pnt++) = (unsigned char)v; memcpy(pnt, dbuf, siz); len = pnt - buf + siz; return (len); } /* * header bytes, write here so defines are set up before anything else * that needs to use them */ static void fstWriterEmitHdrBytes(struct fstWriterContext *xc) { char vbuf[FST_HDR_SIM_VERSION_SIZE]; char dbuf[FST_HDR_DATE_SIZE]; double endtest = FST_DOUBLE_ENDTEST; time_t walltime; #define FST_HDR_OFFS_TAG (0) fputc(FST_BL_HDR, xc->handle); /* +0 tag */ #define FST_HDR_OFFS_SECLEN (FST_HDR_OFFS_TAG + 1) fstWriterUint64(xc->handle, 329); /* +1 section length */ #define FST_HDR_OFFS_START_TIME (FST_HDR_OFFS_SECLEN + 8) fstWriterUint64(xc->handle, 0); /* +9 start time */ #define FST_HDR_OFFS_END_TIME (FST_HDR_OFFS_START_TIME + 8) fstWriterUint64(xc->handle, 0); /* +17 end time */ #define FST_HDR_OFFS_ENDIAN_TEST (FST_HDR_OFFS_END_TIME + 8) fstFwrite(&endtest, 8, 1, xc->handle); /* +25 endian test for reals */ #define FST_HDR_OFFS_MEM_USED (FST_HDR_OFFS_ENDIAN_TEST + 8) fstWriterUint64(xc->handle, xc->fst_break_size); /* +33 memory used by writer */ #define FST_HDR_OFFS_NUM_SCOPES (FST_HDR_OFFS_MEM_USED + 8) fstWriterUint64(xc->handle, 0); /* +41 scope creation count */ #define FST_HDR_OFFS_NUM_VARS (FST_HDR_OFFS_NUM_SCOPES + 8) fstWriterUint64(xc->handle, 0); /* +49 var creation count */ #define FST_HDR_OFFS_MAXHANDLE (FST_HDR_OFFS_NUM_VARS + 8) fstWriterUint64(xc->handle, 0); /* +57 max var idcode */ #define FST_HDR_OFFS_SECTION_CNT (FST_HDR_OFFS_MAXHANDLE + 8) fstWriterUint64(xc->handle, 0); /* +65 vc section count */ #define FST_HDR_OFFS_TIMESCALE (FST_HDR_OFFS_SECTION_CNT + 8) fputc((-9) & 255, xc->handle); /* +73 timescale 1ns */ #define FST_HDR_OFFS_SIM_VERSION (FST_HDR_OFFS_TIMESCALE + 1) memset(vbuf, 0, FST_HDR_SIM_VERSION_SIZE); strcpy(vbuf, FST_WRITER_STR); fstFwrite(vbuf, FST_HDR_SIM_VERSION_SIZE, 1, xc->handle); /* +74 version */ #define FST_HDR_OFFS_DATE (FST_HDR_OFFS_SIM_VERSION + FST_HDR_SIM_VERSION_SIZE) memset(dbuf, 0, FST_HDR_DATE_SIZE); time(&walltime); strcpy(dbuf, asctime(localtime(&walltime))); fstFwrite(dbuf, FST_HDR_DATE_SIZE, 1, xc->handle); /* +202 date */ /* date size is deliberately overspecified at 119 bytes (originally 128) in order to provide * backfill for new args */ #define FST_HDR_OFFS_FILETYPE (FST_HDR_OFFS_DATE + FST_HDR_DATE_SIZE) fputc(xc->filetype, xc->handle); /* +321 filetype */ #define FST_HDR_OFFS_TIMEZERO (FST_HDR_OFFS_FILETYPE + FST_HDR_FILETYPE_SIZE) fstWriterUint64(xc->handle, xc->timezero); /* +322 timezero */ #define FST_HDR_LENGTH (FST_HDR_OFFS_TIMEZERO + FST_HDR_TIMEZERO_SIZE) /* +330 next section starts here */ fflush(xc->handle); } /* * mmap functions */ static void fstWriterMmapSanity(void *pnt, const char *file, int line, const char *usage) { if (pnt == NULL #ifdef MAP_FAILED || pnt == MAP_FAILED #endif ) { fprintf(stderr, "fstMmap() assigned to %s failed: errno: %d, file %s, line %d.\n", usage, errno, file, line); #if !defined(__MINGW32__) perror("Why"); #else LPSTR mbuf = NULL; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&mbuf, 0, NULL); fprintf(stderr, "%s", mbuf); LocalFree(mbuf); #endif pnt = NULL; } } static void fstWriterCreateMmaps(struct fstWriterContext *xc) { fst_off_t curpos = ftello(xc->handle); fflush(xc->hier_handle); /* write out intermediate header */ fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_START_TIME, SEEK_SET); fstWriterUint64(xc->handle, xc->firsttime); fstWriterUint64(xc->handle, xc->curtime); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_NUM_SCOPES, SEEK_SET); fstWriterUint64(xc->handle, xc->numscopes); fstWriterUint64(xc->handle, xc->numsigs); fstWriterUint64(xc->handle, xc->maxhandle); fstWriterUint64(xc->handle, xc->secnum); fstWriterFseeko(xc, xc->handle, curpos, SEEK_SET); fflush(xc->handle); /* do mappings */ if (!xc->valpos_mem) { fflush(xc->valpos_handle); errno = 0; if (xc->maxhandle) { fstWriterMmapSanity(xc->valpos_mem = (uint32_t *)fstMmap(NULL, xc->maxhandle * 4 * sizeof(uint32_t), PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->valpos_handle), 0), __FILE__, __LINE__, "xc->valpos_mem"); } } if (!xc->curval_mem) { fflush(xc->curval_handle); errno = 0; if (xc->maxvalpos) { fstWriterMmapSanity(xc->curval_mem = (unsigned char *)fstMmap(NULL, xc->maxvalpos, PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->curval_handle), 0), __FILE__, __LINE__, "xc->curval_handle"); } } } static void fstDestroyMmaps(struct fstWriterContext *xc, int is_closing) { (void)is_closing; fstMunmap(xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t)); xc->valpos_mem = NULL; fstMunmap(xc->curval_mem, xc->maxvalpos); xc->curval_mem = NULL; } /* * set up large and small memory usages * crossover point in model is FST_ACTIVATE_HUGE_BREAK number of signals */ static void fstDetermineBreakSize(struct fstWriterContext *xc) { #if defined(__linux__) || defined(FST_MACOSX) int was_set = 0; #ifdef __linux__ FILE *f = fopen("/proc/meminfo", "rb"); if (f) { char buf[257]; char *s; while (!feof(f)) { buf[0] = 0; s = fgets(buf, 256, f); if (s && *s) { if (!strncmp(s, "MemTotal:", 9)) { size_t v = atol(s + 10); v *= 1024; /* convert to bytes */ v /= 8; /* chop down to 1/8 physical memory */ if (v > FST_BREAK_SIZE) { if (v > FST_BREAK_SIZE_MAX) { v = FST_BREAK_SIZE_MAX; } xc->fst_huge_break_size = v; was_set = 1; break; } } } } fclose(f); } if (!was_set) { xc->fst_huge_break_size = FST_BREAK_SIZE; } #else int mib[2]; int64_t v; size_t length; mib[0] = CTL_HW; mib[1] = HW_MEMSIZE; length = sizeof(int64_t); if (!sysctl(mib, 2, &v, &length, NULL, 0)) { v /= 8; if (v > (int64_t)FST_BREAK_SIZE) { if (v > (int64_t)FST_BREAK_SIZE_MAX) { v = FST_BREAK_SIZE_MAX; } xc->fst_huge_break_size = v; was_set = 1; } } if (!was_set) { xc->fst_huge_break_size = FST_BREAK_SIZE; } #endif #else xc->fst_huge_break_size = FST_BREAK_SIZE; #endif xc->fst_break_size = xc->fst_orig_break_size = FST_BREAK_SIZE; xc->fst_break_add_size = xc->fst_orig_break_add_size = FST_BREAK_ADD_SIZE; xc->next_huge_break = FST_ACTIVATE_HUGE_BREAK; } /* * file creation and close */ fstWriterContext *fstWriterCreate(const char *nam, int use_compressed_hier) { fstWriterContext *xc = (fstWriterContext *)calloc(1, sizeof(fstWriterContext)); xc->compress_hier = use_compressed_hier; fstDetermineBreakSize(xc); if ((!nam) || (!(xc->handle = unlink_fopen(nam, "w+b")))) { free(xc); xc = NULL; } else { int flen = strlen(nam); char *hf = (char *)calloc(1, flen + 6); memcpy(hf, nam, flen); strcpy(hf + flen, ".hier"); xc->hier_handle = unlink_fopen(hf, "w+b"); xc->geom_handle = tmpfile_open(&xc->geom_handle_nam); /* .geom */ xc->valpos_handle = tmpfile_open(&xc->valpos_handle_nam); /* .offs */ xc->curval_handle = tmpfile_open(&xc->curval_handle_nam); /* .bits */ xc->tchn_handle = tmpfile_open(&xc->tchn_handle_nam); /* .tchn */ xc->vchg_alloc_siz = xc->fst_break_size + xc->fst_break_add_size; xc->vchg_mem = (unsigned char *)malloc(xc->vchg_alloc_siz); if (xc->hier_handle && xc->geom_handle && xc->valpos_handle && xc->curval_handle && xc->vchg_mem && xc->tchn_handle) { xc->filename = strdup(nam); xc->is_initial_time = 1; fstWriterEmitHdrBytes(xc); xc->nan = strtod("NaN", NULL); #ifdef FST_WRITER_PARALLEL pthread_mutex_init(&xc->mutex, NULL); pthread_attr_init(&xc->thread_attr); pthread_attr_setdetachstate(&xc->thread_attr, PTHREAD_CREATE_DETACHED); #endif } else { fclose(xc->handle); if (xc->hier_handle) { fclose(xc->hier_handle); unlink(hf); } tmpfile_close(&xc->geom_handle, &xc->geom_handle_nam); tmpfile_close(&xc->valpos_handle, &xc->valpos_handle_nam); tmpfile_close(&xc->curval_handle, &xc->curval_handle_nam); tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); free(xc->vchg_mem); free(xc); xc = NULL; } free(hf); } return (xc); } /* * generation and writing out of value change data sections */ static void fstWriterEmitSectionHeader(fstWriterContext *xc) { if (xc) { unsigned long destlen; unsigned char *dmem; int rc; destlen = xc->maxvalpos; dmem = (unsigned char *)malloc(compressBound(destlen)); rc = compress2(dmem, &destlen, xc->curval_mem, xc->maxvalpos, 4); /* was 9...which caused performance drag on traces with many signals */ fputc(FST_BL_SKIP, xc->handle); /* temporarily tag the section, use FST_BL_VCDATA on finalize */ xc->section_start = ftello(xc->handle); #ifdef FST_WRITER_PARALLEL if (xc->xc_parent) xc->xc_parent->section_start = xc->section_start; #endif xc->section_header_only = 1; /* indicates truncate might be needed */ fstWriterUint64(xc->handle, 0); /* placeholder = section length */ fstWriterUint64(xc->handle, xc->is_initial_time ? xc->firsttime : xc->curtime); /* begin time of section */ fstWriterUint64(xc->handle, xc->curtime); /* end time of section (placeholder) */ fstWriterUint64( xc->handle, 0); /* placeholder = amount of buffer memory required in reader for full vc traversal */ fstWriterVarint(xc->handle, xc->maxvalpos); /* maxvalpos = length of uncompressed data */ if ((rc == Z_OK) && (destlen < xc->maxvalpos)) { fstWriterVarint(xc->handle, destlen); /* length of compressed data */ } else { fstWriterVarint(xc->handle, xc->maxvalpos); /* length of (unable to be) compressed data */ } fstWriterVarint(xc->handle, xc->maxhandle); /* max handle associated with this data (in case of dynamic facility adds) */ if ((rc == Z_OK) && (destlen < xc->maxvalpos)) { fstFwrite(dmem, destlen, 1, xc->handle); } else /* comparison between compressed / decompressed len tells if compressed */ { fstFwrite(xc->curval_mem, xc->maxvalpos, 1, xc->handle); } free(dmem); } } /* * only to be called directly by fst code...otherwise must * be synced up with time changes */ #ifdef FST_WRITER_PARALLEL static void fstWriterFlushContextPrivate2(fstWriterContext *xc) #else static void fstWriterFlushContextPrivate(fstWriterContext *xc) #endif { #ifdef FST_DEBUG int cnt = 0; #endif unsigned int i; unsigned char *vchg_mem; FILE *f; fst_off_t fpos, indxpos, endpos; uint32_t prevpos; int zerocnt; unsigned char *scratchpad; unsigned char *scratchpnt; unsigned char *tmem; fst_off_t tlen; fst_off_t unc_memreq = 0; /* for reader */ unsigned char *packmem; unsigned int packmemlen; uint32_t *vm4ip; #ifdef FST_WRITER_PARALLEL struct fstWriterContext *xc2 = xc->xc_parent; #else struct fstWriterContext *xc2 = xc; #endif #ifndef FST_DYNAMIC_ALIAS_DISABLE Pvoid_t PJHSArray = (Pvoid_t)NULL; uint32_t hashmask = xc->maxhandle; hashmask |= hashmask >> 1; hashmask |= hashmask >> 2; hashmask |= hashmask >> 4; hashmask |= hashmask >> 8; hashmask |= hashmask >> 16; #endif if ((xc->vchg_siz <= 1) || (xc->already_in_flush)) return; xc->already_in_flush = 1; /* should really do this with a semaphore */ xc->section_header_only = 0; scratchpad = (unsigned char *)malloc(xc->vchg_siz); vchg_mem = xc->vchg_mem; f = xc->handle; fstWriterVarint(f, xc->maxhandle); /* emit current number of handles */ fputc(xc->fourpack ? '4' : (xc->fastpack ? 'F' : 'Z'), f); fpos = 1; packmemlen = 1024; /* maintain a running "longest" allocation to */ packmem = (unsigned char *)malloc(packmemlen); /* prevent continual malloc...free every loop iter */ for (i = 0; i < xc->maxhandle; i++) { vm4ip = &(xc->valpos_mem[4 * i]); if (vm4ip[2]) { uint32_t offs = vm4ip[2]; uint32_t next_offs; unsigned int wrlen; vm4ip[2] = fpos; scratchpnt = scratchpad + xc->vchg_siz; /* build this buffer backwards */ if (vm4ip[1] <= 1) { if (vm4ip[1] == 1) { wrlen = fstGetVarint32Length(vchg_mem + offs + 4); /* used to advance and determine wrlen */ #ifndef FST_REMOVE_DUPLICATE_VC xc->curval_mem[vm4ip[0]] = vchg_mem[offs + 4 + wrlen]; /* checkpoint variable */ #endif while (offs) { unsigned char val; uint32_t time_delta, rcv; next_offs = fstGetUint32(vchg_mem + offs); offs += 4; time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); val = vchg_mem[offs + wrlen]; offs = next_offs; switch (val) { case '0': case '1': rcv = ((val & 1) << 1) | (time_delta << 2); break; /* pack more delta bits in for 0/1 vchs */ case 'x': case 'X': rcv = FST_RCV_X | (time_delta << 4); break; case 'z': case 'Z': rcv = FST_RCV_Z | (time_delta << 4); break; case 'h': case 'H': rcv = FST_RCV_H | (time_delta << 4); break; case 'u': case 'U': rcv = FST_RCV_U | (time_delta << 4); break; case 'w': case 'W': rcv = FST_RCV_W | (time_delta << 4); break; case 'l': case 'L': rcv = FST_RCV_L | (time_delta << 4); break; default: rcv = FST_RCV_D | (time_delta << 4); break; } scratchpnt = fstCopyVarint32ToLeft(scratchpnt, rcv); } } else { /* variable length */ /* fstGetUint32 (next_offs) + fstGetVarint32 (time_delta) + fstGetVarint32 (len) * + payload */ unsigned char *pnt; uint32_t record_len; uint32_t time_delta; while (offs) { next_offs = fstGetUint32(vchg_mem + offs); offs += 4; pnt = vchg_mem + offs; offs = next_offs; time_delta = fstGetVarint32(pnt, (int *)&wrlen); pnt += wrlen; record_len = fstGetVarint32(pnt, (int *)&wrlen); pnt += wrlen; scratchpnt -= record_len; memcpy(scratchpnt, pnt, record_len); scratchpnt = fstCopyVarint32ToLeft(scratchpnt, record_len); scratchpnt = fstCopyVarint32ToLeft( scratchpnt, (time_delta << 1)); /* reserve | 1 case for future expansion */ } } } else { wrlen = fstGetVarint32Length(vchg_mem + offs + 4); /* used to advance and determine wrlen */ #ifndef FST_REMOVE_DUPLICATE_VC memcpy(xc->curval_mem + vm4ip[0], vchg_mem + offs + 4 + wrlen, vm4ip[1]); /* checkpoint variable */ #endif while (offs) { unsigned int idx; char is_binary = 1; unsigned char *pnt; uint32_t time_delta; next_offs = fstGetUint32(vchg_mem + offs); offs += 4; time_delta = fstGetVarint32(vchg_mem + offs, (int *)&wrlen); pnt = vchg_mem + offs + wrlen; offs = next_offs; for (idx = 0; idx < vm4ip[1]; idx++) { if ((pnt[idx] == '0') || (pnt[idx] == '1')) { continue; } else { is_binary = 0; break; } } if (is_binary) { unsigned char acc = 0; /* new algorithm */ idx = ((vm4ip[1] + 7) & ~7); switch (vm4ip[1] & 7) { case 0: do { acc = (pnt[idx + 7 - 8] & 1) << 0; /* fallthrough */ case 7: acc |= (pnt[idx + 6 - 8] & 1) << 1; /* fallthrough */ case 6: acc |= (pnt[idx + 5 - 8] & 1) << 2; /* fallthrough */ case 5: acc |= (pnt[idx + 4 - 8] & 1) << 3; /* fallthrough */ case 4: acc |= (pnt[idx + 3 - 8] & 1) << 4; /* fallthrough */ case 3: acc |= (pnt[idx + 2 - 8] & 1) << 5; /* fallthrough */ case 2: acc |= (pnt[idx + 1 - 8] & 1) << 6; /* fallthrough */ case 1: acc |= (pnt[idx + 0 - 8] & 1) << 7; *(--scratchpnt) = acc; idx -= 8; } while (idx); } scratchpnt = fstCopyVarint32ToLeft(scratchpnt, (time_delta << 1)); } else { scratchpnt -= vm4ip[1]; memcpy(scratchpnt, pnt, vm4ip[1]); scratchpnt = fstCopyVarint32ToLeft(scratchpnt, (time_delta << 1) | 1); } } } wrlen = scratchpad + xc->vchg_siz - scratchpnt; unc_memreq += wrlen; if (wrlen > 32) { unsigned long destlen = wrlen; unsigned char *dmem; unsigned int rc; if (!xc->fastpack) { if (wrlen <= packmemlen) { dmem = packmem; } else { free(packmem); dmem = packmem = (unsigned char *)malloc(compressBound(packmemlen = wrlen)); } rc = compress2(dmem, &destlen, scratchpnt, wrlen, 4); if (rc == Z_OK) { #ifndef FST_DYNAMIC_ALIAS_DISABLE PPvoid_t pv = JenkinsIns(&PJHSArray, dmem, destlen, hashmask); if (*pv) { uint32_t pvi = (intptr_t)(*pv); vm4ip[2] = -pvi; } else { *pv = (void *)(intptr_t)(i + 1); #endif fpos += fstWriterVarint(f, wrlen); fpos += destlen; fstFwrite(dmem, destlen, 1, f); #ifndef FST_DYNAMIC_ALIAS_DISABLE } #endif } else { #ifndef FST_DYNAMIC_ALIAS_DISABLE PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); if (*pv) { uint32_t pvi = (intptr_t)(*pv); vm4ip[2] = -pvi; } else { *pv = (void *)(intptr_t)(i + 1); #endif fpos += fstWriterVarint(f, 0); fpos += wrlen; fstFwrite(scratchpnt, wrlen, 1, f); #ifndef FST_DYNAMIC_ALIAS_DISABLE } #endif } } else { /* this is extremely conservative: fastlz needs +5% for worst case, lz4 needs * siz+(siz/255)+16 */ if (((wrlen * 2) + 2) <= packmemlen) { dmem = packmem; } else { free(packmem); dmem = packmem = (unsigned char *)malloc(packmemlen = (wrlen * 2) + 2); } rc = (xc->fourpack) ? LZ4_compress_default((char *)scratchpnt, (char *)dmem, wrlen, packmemlen) : fastlz_compress(scratchpnt, wrlen, dmem); if (rc < destlen) { #ifndef FST_DYNAMIC_ALIAS_DISABLE PPvoid_t pv = JenkinsIns(&PJHSArray, dmem, rc, hashmask); if (*pv) { uint32_t pvi = (intptr_t)(*pv); vm4ip[2] = -pvi; } else { *pv = (void *)(intptr_t)(i + 1); #endif fpos += fstWriterVarint(f, wrlen); fpos += rc; fstFwrite(dmem, rc, 1, f); #ifndef FST_DYNAMIC_ALIAS_DISABLE } #endif } else { #ifndef FST_DYNAMIC_ALIAS_DISABLE PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); if (*pv) { uint32_t pvi = (intptr_t)(*pv); vm4ip[2] = -pvi; } else { *pv = (void *)(intptr_t)(i + 1); #endif fpos += fstWriterVarint(f, 0); fpos += wrlen; fstFwrite(scratchpnt, wrlen, 1, f); #ifndef FST_DYNAMIC_ALIAS_DISABLE } #endif } } } else { #ifndef FST_DYNAMIC_ALIAS_DISABLE PPvoid_t pv = JenkinsIns(&PJHSArray, scratchpnt, wrlen, hashmask); if (*pv) { uint32_t pvi = (intptr_t)(*pv); vm4ip[2] = -pvi; } else { *pv = (void *)(intptr_t)(i + 1); #endif fpos += fstWriterVarint(f, 0); fpos += wrlen; fstFwrite(scratchpnt, wrlen, 1, f); #ifndef FST_DYNAMIC_ALIAS_DISABLE } #endif } /* vm4ip[3] = 0; ...redundant with clearing below */ #ifdef FST_DEBUG cnt++; #endif } } #ifndef FST_DYNAMIC_ALIAS_DISABLE JenkinsFree(&PJHSArray, hashmask); #endif free(packmem); packmem = NULL; /* packmemlen = 0; */ /* scan-build */ prevpos = 0; zerocnt = 0; free(scratchpad); scratchpad = NULL; indxpos = ftello(f); xc->secnum++; #ifndef FST_DYNAMIC_ALIAS2_DISABLE if (1) { uint32_t prev_alias = 0; for (i = 0; i < xc->maxhandle; i++) { vm4ip = &(xc->valpos_mem[4 * i]); if (vm4ip[2]) { if (zerocnt) { fpos += fstWriterVarint(f, (zerocnt << 1)); zerocnt = 0; } if (vm4ip[2] & 0x80000000) { if (vm4ip[2] != prev_alias) { int32_t t_i32 = ((int32_t)(prev_alias = vm4ip[2])); /* vm4ip is generic unsigned data */ int64_t t_i64 = (int64_t)t_i32; /* convert to signed */ uint64_t t_u64 = (uint64_t)t_i64; /* sign extend through 64b */ fpos += fstWriterSVarint( f, (int64_t)((t_u64 << 1) | 1)); /* all in this block was: fpos += fstWriterSVarint(f, (((int64_t)((int32_t)(prev_alias = vm4ip[2]))) << 1) | 1); */ } else { fpos += fstWriterSVarint(f, (0 << 1) | 1); } } else { fpos += fstWriterSVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); prevpos = vm4ip[2]; } vm4ip[2] = 0; vm4ip[3] = 0; /* clear out tchn idx */ } else { zerocnt++; } } } else #endif { for (i = 0; i < xc->maxhandle; i++) { vm4ip = &(xc->valpos_mem[4 * i]); if (vm4ip[2]) { if (zerocnt) { fpos += fstWriterVarint(f, (zerocnt << 1)); zerocnt = 0; } if (vm4ip[2] & 0x80000000) { fpos += fstWriterVarint(f, 0); /* signal, note that using a *signed* varint would be more efficient than this byte escape! */ fpos += fstWriterVarint(f, (-(int32_t)vm4ip[2])); } else { fpos += fstWriterVarint(f, ((vm4ip[2] - prevpos) << 1) | 1); prevpos = vm4ip[2]; } vm4ip[2] = 0; vm4ip[3] = 0; /* clear out tchn idx */ } else { zerocnt++; } } } if (zerocnt) { /* fpos += */ fstWriterVarint(f, (zerocnt << 1)); /* scan-build */ } #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "value chains: %d\n", cnt); #endif xc->vchg_mem[0] = '!'; xc->vchg_siz = 1; endpos = ftello(xc->handle); fstWriterUint64(xc->handle, endpos - indxpos); /* write delta index position at very end of block */ /*emit time changes for block */ fflush(xc->tchn_handle); tlen = ftello(xc->tchn_handle); fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); errno = 0; fstWriterMmapSanity( tmem = (unsigned char *) fstMmap(NULL, tlen, PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->tchn_handle), 0), __FILE__, __LINE__, "tmem"); if (tmem) { unsigned long destlen = tlen; unsigned char *dmem = (unsigned char *)malloc(compressBound(destlen)); int rc = compress2(dmem, &destlen, tmem, tlen, 9); if ((rc == Z_OK) && (((fst_off_t)destlen) < tlen)) { fstFwrite(dmem, destlen, 1, xc->handle); } else /* comparison between compressed / decompressed len tells if compressed */ { fstFwrite(tmem, tlen, 1, xc->handle); destlen = tlen; } free(dmem); fstMunmap(tmem, tlen); fstWriterUint64(xc->handle, tlen); /* uncompressed */ fstWriterUint64(xc->handle, destlen); /* compressed */ fstWriterUint64(xc->handle, xc->tchn_cnt); /* number of time items */ } xc->tchn_cnt = xc->tchn_idx = 0; fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); fstFtruncate(fileno(xc->tchn_handle), 0); /* write block trailer */ endpos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, xc->section_start, SEEK_SET); fstWriterUint64(xc->handle, endpos - xc->section_start); /* write block length */ fstWriterFseeko(xc, xc->handle, 8, SEEK_CUR); /* skip begin time */ fstWriterUint64(xc->handle, xc->curtime); /* write end time for section */ fstWriterUint64(xc->handle, unc_memreq); /* amount of buffer memory required in reader for full traversal */ fflush(xc->handle); fstWriterFseeko(xc, xc->handle, xc->section_start - 1, SEEK_SET); /* write out FST_BL_VCDATA over FST_BL_SKIP */ #ifndef FST_DYNAMIC_ALIAS_DISABLE #ifndef FST_DYNAMIC_ALIAS2_DISABLE fputc(FST_BL_VCDATA_DYN_ALIAS2, xc->handle); #else fputc(FST_BL_VCDATA_DYN_ALIAS, xc->handle); #endif #else fputc(FST_BL_VCDATA, xc->handle); #endif fflush(xc->handle); fstWriterFseeko(xc, xc->handle, endpos, SEEK_SET); /* seek to end of file */ xc2->section_header_truncpos = endpos; /* cache in case of need to truncate */ if (xc->dump_size_limit) { if (endpos >= ((fst_off_t)xc->dump_size_limit)) { xc2->skip_writing_section_hdr = 1; xc2->size_limit_locked = 1; xc2->is_initial_time = 1; /* to trick emit value and emit time change */ #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "<< dump file size limit reached, stopping dumping >>\n"); #endif } } if (!xc2->skip_writing_section_hdr) { fstWriterEmitSectionHeader(xc); /* emit next section header */ } fflush(xc->handle); xc->already_in_flush = 0; } #ifdef FST_WRITER_PARALLEL static void *fstWriterFlushContextPrivate1(void *ctx) { struct fstWriterContext *xc = (struct fstWriterContext *)ctx; struct fstWriterContext *xc_parent; pthread_mutex_lock(&(xc->xc_parent->mutex)); fstWriterFlushContextPrivate2(xc); #ifdef FST_REMOVE_DUPLICATE_VC free(xc->curval_mem); #endif free(xc->valpos_mem); free(xc->vchg_mem); tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); xc_parent = xc->xc_parent; free(xc); xc_parent->in_pthread = 0; pthread_mutex_unlock(&(xc_parent->mutex)); return (NULL); } static void fstWriterFlushContextPrivate(fstWriterContext *xc) { if (xc->parallel_enabled) { struct fstWriterContext *xc2 = (struct fstWriterContext *)malloc(sizeof(struct fstWriterContext)); unsigned int i; pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); xc->xc_parent = xc; memcpy(xc2, xc, sizeof(struct fstWriterContext)); if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1777 for 32b overflow */ uint64_t chk_64 = xc->maxhandle * 4 * sizeof(uint32_t); size_t chk_32 = xc->maxhandle * 4 * sizeof(uint32_t); if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1777"); } xc2->valpos_mem = (uint32_t *)malloc(xc->maxhandle * 4 * sizeof(uint32_t)); memcpy(xc2->valpos_mem, xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t)); /* curval mem is updated in the thread */ #ifdef FST_REMOVE_DUPLICATE_VC xc2->curval_mem = (unsigned char *)malloc(xc->maxvalpos); memcpy(xc2->curval_mem, xc->curval_mem, xc->maxvalpos); #endif xc->vchg_mem = (unsigned char *)malloc(xc->vchg_alloc_siz); xc->vchg_mem[0] = '!'; xc->vchg_siz = 1; for (i = 0; i < xc->maxhandle; i++) { uint32_t *vm4ip = &(xc->valpos_mem[4 * i]); vm4ip[2] = 0; /* zero out offset val */ vm4ip[3] = 0; /* zero out last time change val */ } xc->tchn_cnt = xc->tchn_idx = 0; xc->tchn_handle = tmpfile_open(&xc->tchn_handle_nam); /* child thread will deallocate file/name */ fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET); fstFtruncate(fileno(xc->tchn_handle), 0); xc->section_header_only = 0; xc->secnum++; while (xc->in_pthread) { pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); }; pthread_mutex_lock(&xc->mutex); xc->in_pthread = 1; pthread_mutex_unlock(&xc->mutex); pthread_create(&xc->thread, &xc->thread_attr, fstWriterFlushContextPrivate1, xc2); } else { if (xc->parallel_was_enabled) /* conservatively block */ { pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); } xc->xc_parent = xc; fstWriterFlushContextPrivate2(xc); } } #endif /* * queues up a flush context operation */ void fstWriterFlushContext(fstWriterContext *xc) { if (xc) { if (xc->tchn_idx > 1) { xc->flush_context_pending = 1; } } } /* * close out FST file */ void fstWriterClose(fstWriterContext *xc) { #ifdef FST_WRITER_PARALLEL if (xc) { pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); } #endif if (xc && !xc->already_in_close && !xc->already_in_flush) { unsigned char *tmem = NULL; fst_off_t fixup_offs, tlen, hlen; xc->already_in_close = 1; /* never need to zero this out as it is freed at bottom */ if (xc->section_header_only && xc->section_header_truncpos && (xc->vchg_siz <= 1) && (!xc->is_initial_time)) { fstFtruncate(fileno(xc->handle), xc->section_header_truncpos); fstWriterFseeko(xc, xc->handle, xc->section_header_truncpos, SEEK_SET); xc->section_header_only = 0; } else { xc->skip_writing_section_hdr = 1; if (!xc->size_limit_locked) { if (FST_UNLIKELY(xc->is_initial_time)) /* simulation time never advanced so mock up the changes as time zero ones */ { fstHandle dupe_idx; fstWriterEmitTimeChange(xc, 0); /* emit some time change just to have one */ for (dupe_idx = 0; dupe_idx < xc->maxhandle; dupe_idx++) /* now clone the values */ { fstWriterEmitValueChange(xc, dupe_idx + 1, xc->curval_mem + xc->valpos_mem[4 * dupe_idx]); } } fstWriterFlushContextPrivate(xc); #ifdef FST_WRITER_PARALLEL pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); while (xc->in_pthread) { pthread_mutex_lock(&xc->mutex); pthread_mutex_unlock(&xc->mutex); }; #endif } } fstDestroyMmaps(xc, 1); if (xc->outval_mem) { free(xc->outval_mem); xc->outval_mem = NULL; xc->outval_alloc_siz = 0; } /* write out geom section */ fflush(xc->geom_handle); tlen = ftello(xc->geom_handle); errno = 0; if (tlen) { fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->geom_handle), 0), __FILE__, __LINE__, "tmem"); } if (tmem) { unsigned long destlen = tlen; unsigned char *dmem = (unsigned char *)malloc(compressBound(destlen)); int rc = compress2(dmem, &destlen, tmem, tlen, 9); if ((rc != Z_OK) || (((fst_off_t)destlen) > tlen)) { destlen = tlen; } fixup_offs = ftello(xc->handle); fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ fstWriterUint64(xc->handle, destlen + 24); /* section length */ fstWriterUint64(xc->handle, tlen); /* uncompressed */ /* compressed len is section length - 24 */ fstWriterUint64(xc->handle, xc->maxhandle); /* maxhandle */ fstFwrite((((fst_off_t)destlen) != tlen) ? dmem : tmem, destlen, 1, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); fputc(FST_BL_GEOM, xc->handle); /* actual tag */ fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ fflush(xc->handle); free(dmem); fstMunmap(tmem, tlen); } if (xc->num_blackouts) { uint64_t cur_bl = 0; fst_off_t bpos, eos; uint32_t i; fixup_offs = ftello(xc->handle); fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ bpos = fixup_offs + 1; fstWriterUint64(xc->handle, 0); /* section length */ fstWriterVarint(xc->handle, xc->num_blackouts); for (i = 0; i < xc->num_blackouts; i++) { fputc(xc->blackout_head->active, xc->handle); fstWriterVarint(xc->handle, xc->blackout_head->tim - cur_bl); cur_bl = xc->blackout_head->tim; xc->blackout_curr = xc->blackout_head->next; free(xc->blackout_head); xc->blackout_head = xc->blackout_curr; } eos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, bpos, SEEK_SET); fstWriterUint64(xc->handle, eos - bpos); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); fputc(FST_BL_BLACKOUT, xc->handle); /* actual tag */ fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ fflush(xc->handle); } if (xc->compress_hier) { fst_off_t hl, eos; gzFile zhandle; int zfd; int fourpack_duo = 0; #ifndef __MINGW32__ int fnam_len = strlen(xc->filename) + 5 + 1; char *fnam = (char *)malloc(fnam_len); #endif fixup_offs = ftello(xc->handle); fputc(FST_BL_SKIP, xc->handle); /* temporary tag */ hlen = ftello(xc->handle); fstWriterUint64(xc->handle, 0); /* section length */ fstWriterUint64(xc->handle, xc->hier_file_len); /* uncompressed length */ if (!xc->fourpack) { unsigned char *mem = (unsigned char *)malloc(FST_GZIO_LEN); zfd = dup(fileno(xc->handle)); fflush(xc->handle); zhandle = gzdopen(zfd, "wb4"); if (zhandle) { fstWriterFseeko(xc, xc->hier_handle, 0, SEEK_SET); for (hl = 0; hl < xc->hier_file_len; hl += FST_GZIO_LEN) { unsigned len = ((xc->hier_file_len - hl) > FST_GZIO_LEN) ? FST_GZIO_LEN : (xc->hier_file_len - hl); fstFread(mem, len, 1, xc->hier_handle); gzwrite(zhandle, mem, len); } gzclose(zhandle); } else { close(zfd); } free(mem); } else { int lz4_maxlen; unsigned char *mem; unsigned char *hmem = NULL; int packed_len; fflush(xc->handle); lz4_maxlen = LZ4_compressBound(xc->hier_file_len); mem = (unsigned char *)malloc(lz4_maxlen); errno = 0; if (xc->hier_file_len) { fstWriterMmapSanity(hmem = (unsigned char *)fstMmap(NULL, xc->hier_file_len, PROT_READ | PROT_WRITE, MAP_SHARED, fileno(xc->hier_handle), 0), __FILE__, __LINE__, "hmem"); } packed_len = LZ4_compress_default((char *)hmem, (char *)mem, xc->hier_file_len, lz4_maxlen); fstMunmap(hmem, xc->hier_file_len); fourpack_duo = (!xc->repack_on_close) && (xc->hier_file_len > FST_HDR_FOURPACK_DUO_SIZE); /* double pack when hierarchy is large */ if (fourpack_duo) /* double packing with LZ4 is faster than gzip */ { unsigned char *mem_duo; int lz4_maxlen_duo; int packed_len_duo; lz4_maxlen_duo = LZ4_compressBound(packed_len); mem_duo = (unsigned char *)malloc(lz4_maxlen_duo); packed_len_duo = LZ4_compress_default((char *)mem, (char *)mem_duo, packed_len, lz4_maxlen_duo); fstWriterVarint(xc->handle, packed_len); /* 1st round compressed length */ fstFwrite(mem_duo, packed_len_duo, 1, xc->handle); free(mem_duo); } else { fstFwrite(mem, packed_len, 1, xc->handle); } free(mem); } fstWriterFseeko(xc, xc->handle, 0, SEEK_END); eos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, hlen, SEEK_SET); fstWriterUint64(xc->handle, eos - hlen); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fixup_offs, SEEK_SET); fputc(xc->fourpack ? (fourpack_duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4) : FST_BL_HIER, xc->handle); /* actual tag now also == compression type */ fstWriterFseeko(xc, xc->handle, 0, SEEK_END); /* move file pointer to end for any section adds */ fflush(xc->handle); #ifndef __MINGW32__ snprintf(fnam, fnam_len, "%s.hier", xc->filename); unlink(fnam); free(fnam); #endif } /* finalize out header */ fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_START_TIME, SEEK_SET); fstWriterUint64(xc->handle, xc->firsttime); fstWriterUint64(xc->handle, xc->curtime); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_NUM_SCOPES, SEEK_SET); fstWriterUint64(xc->handle, xc->numscopes); fstWriterUint64(xc->handle, xc->numsigs); fstWriterUint64(xc->handle, xc->maxhandle); fstWriterUint64(xc->handle, xc->secnum); fflush(xc->handle); tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam); free(xc->vchg_mem); xc->vchg_mem = NULL; tmpfile_close(&xc->curval_handle, &xc->curval_handle_nam); tmpfile_close(&xc->valpos_handle, &xc->valpos_handle_nam); tmpfile_close(&xc->geom_handle, &xc->geom_handle_nam); if (xc->hier_handle) { fclose(xc->hier_handle); xc->hier_handle = NULL; } if (xc->handle) { if (xc->repack_on_close) { FILE *fp; fst_off_t offpnt, uclen; int flen = strlen(xc->filename); char *hf = (char *)calloc(1, flen + 5); strcpy(hf, xc->filename); strcpy(hf + flen, ".pak"); fp = fopen(hf, "wb"); if (fp) { gzFile dsth; int zfd; char gz_membuf[FST_GZIO_LEN]; fstWriterFseeko(xc, xc->handle, 0, SEEK_END); uclen = ftello(xc->handle); fputc(FST_BL_ZWRAPPER, fp); fstWriterUint64(fp, 0); fstWriterUint64(fp, uclen); fflush(fp); fstWriterFseeko(xc, xc->handle, 0, SEEK_SET); zfd = dup(fileno(fp)); dsth = gzdopen(zfd, "wb4"); if (dsth) { for (offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) { size_t this_len = ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); fstFread(gz_membuf, this_len, 1, xc->handle); gzwrite(dsth, gz_membuf, this_len); } gzclose(dsth); } else { close(zfd); } fstWriterFseeko(xc, fp, 0, SEEK_END); offpnt = ftello(fp); fstWriterFseeko(xc, fp, 1, SEEK_SET); fstWriterUint64(fp, offpnt - 1); fclose(fp); fclose(xc->handle); xc->handle = NULL; unlink(xc->filename); rename(hf, xc->filename); } else { xc->repack_on_close = 0; fclose(xc->handle); xc->handle = NULL; } free(hf); } else { fclose(xc->handle); xc->handle = NULL; } } #ifdef __MINGW32__ { int flen = strlen(xc->filename); char *hf = (char *)calloc(1, flen + 6); strcpy(hf, xc->filename); if (xc->compress_hier) { strcpy(hf + flen, ".hier"); unlink(hf); /* no longer needed as a section now exists for this */ } free(hf); } #endif #ifdef FST_WRITER_PARALLEL pthread_mutex_destroy(&xc->mutex); pthread_attr_destroy(&xc->thread_attr); #endif if (xc->path_array) { const uint32_t hashmask = FST_PATH_HASHMASK; JenkinsFree(&(xc->path_array), hashmask); } free(xc->filename); xc->filename = NULL; free(xc); } } /* * functions to set miscellaneous header/block information */ void fstWriterSetDate(fstWriterContext *xc, const char *dat) { if (xc) { char s[FST_HDR_DATE_SIZE]; fst_off_t fpos = ftello(xc->handle); int len = strlen(dat); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_DATE, SEEK_SET); memset(s, 0, FST_HDR_DATE_SIZE); memcpy(s, dat, (len < FST_HDR_DATE_SIZE) ? len : FST_HDR_DATE_SIZE); fstFwrite(s, FST_HDR_DATE_SIZE, 1, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } } void fstWriterSetVersion(fstWriterContext *xc, const char *vers) { if (xc && vers) { char s[FST_HDR_SIM_VERSION_SIZE]; fst_off_t fpos = ftello(xc->handle); int len = strlen(vers); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_SIM_VERSION, SEEK_SET); memset(s, 0, FST_HDR_SIM_VERSION_SIZE); memcpy(s, vers, (len < FST_HDR_SIM_VERSION_SIZE) ? len : FST_HDR_SIM_VERSION_SIZE); fstFwrite(s, FST_HDR_SIM_VERSION_SIZE, 1, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } } void fstWriterSetFileType(fstWriterContext *xc, enum fstFileType filetype) { if (xc) { if (/*(filetype >= FST_FT_MIN) &&*/ (filetype <= FST_FT_MAX)) { fst_off_t fpos = ftello(xc->handle); xc->filetype = filetype; fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_FILETYPE, SEEK_SET); fputc(xc->filetype, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } } } static void fstWriterSetAttrDoubleArgGeneric(fstWriterContext *xc, int typ, uint64_t arg1, uint64_t arg2) { if (xc) { unsigned char buf[11]; /* ceil(64/7) = 10 + null term */ unsigned char *pnt = fstCopyVarint64ToRight(buf, arg1); if (arg1) { *pnt = 0; /* this converts any *nonzero* arg1 when made a varint into a null-term string */ } fstWriterSetAttrBegin(xc, FST_AT_MISC, typ, (char *)buf, arg2); } } static void fstWriterSetAttrGeneric(fstWriterContext *xc, const char *comm, int typ, uint64_t arg) { if (xc && comm) { char *s = strdup(comm); char *sf = s; while (*s) { if ((*s == '\n') || (*s == '\r')) *s = ' '; s++; } fstWriterSetAttrBegin(xc, FST_AT_MISC, typ, sf, arg); free(sf); } } static void fstWriterSetSourceStem_2(fstWriterContext *xc, const char *path, unsigned int line, unsigned int use_realpath, int typ) { if (xc && path && path[0]) { uint64_t sidx = 0; int slen = strlen(path); const uint32_t hashmask = FST_PATH_HASHMASK; const unsigned char *path2 = (const unsigned char *)path; PPvoid_t pv; pv = JenkinsIns(&(xc->path_array), path2, slen, hashmask); if (*pv) { sidx = (intptr_t)(*pv); } else { char *rp = NULL; sidx = ++xc->path_array_count; *pv = (void *)(intptr_t)(xc->path_array_count); if (use_realpath) { rp = fstRealpath((const char *)path2, NULL); } fstWriterSetAttrGeneric(xc, rp ? rp : (const char *)path2, FST_MT_PATHNAME, sidx); if (rp) { free(rp); } } fstWriterSetAttrDoubleArgGeneric(xc, typ, sidx, line); } } void fstWriterSetSourceStem(fstWriterContext *ctx, const char *path, unsigned int line, unsigned int use_realpath) { fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCESTEM); } void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx, const char *path, unsigned int line, unsigned int use_realpath) { fstWriterSetSourceStem_2(ctx, path, line, use_realpath, FST_MT_SOURCEISTEM); } void fstWriterSetComment(fstWriterContext *ctx, const char *comm) { fstWriterSetAttrGeneric(ctx, comm, FST_MT_COMMENT, 0); } void fstWriterSetValueList(fstWriterContext *ctx, const char *vl) { fstWriterSetAttrGeneric(ctx, vl, FST_MT_VALUELIST, 0); } void fstWriterSetEnvVar(fstWriterContext *ctx, const char *envvar) { fstWriterSetAttrGeneric(ctx, envvar, FST_MT_ENVVAR, 0); } void fstWriterSetTimescale(fstWriterContext *xc, int ts) { if (xc) { fst_off_t fpos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMESCALE, SEEK_SET); fputc(ts & 255, xc->handle); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } } void fstWriterSetTimescaleFromString(fstWriterContext *xc, const char *s) { if (xc && s) { int mat = 0; int seconds_exp = -9; int tv = atoi(s); const char *pnt = s; while (*pnt) { switch (*pnt) { case 'm': seconds_exp = -3; mat = 1; break; case 'u': seconds_exp = -6; mat = 1; break; case 'n': seconds_exp = -9; mat = 1; break; case 'p': seconds_exp = -12; mat = 1; break; case 'f': seconds_exp = -15; mat = 1; break; case 'a': seconds_exp = -18; mat = 1; break; case 'z': seconds_exp = -21; mat = 1; break; case 's': seconds_exp = 0; mat = 1; break; default: break; } if (mat) break; pnt++; } if (tv == 10) { seconds_exp++; } else if (tv == 100) { seconds_exp += 2; } fstWriterSetTimescale(xc, seconds_exp); } } void fstWriterSetTimezero(fstWriterContext *xc, int64_t tim) { if (xc) { fst_off_t fpos = ftello(xc->handle); fstWriterFseeko(xc, xc->handle, FST_HDR_OFFS_TIMEZERO, SEEK_SET); fstWriterUint64(xc->handle, (xc->timezero = tim)); fflush(xc->handle); fstWriterFseeko(xc, xc->handle, fpos, SEEK_SET); } } void fstWriterSetPackType(fstWriterContext *xc, enum fstWriterPackType typ) { if (xc) { xc->fastpack = (typ != FST_WR_PT_ZLIB); xc->fourpack = (typ == FST_WR_PT_LZ4); } } void fstWriterSetRepackOnClose(fstWriterContext *xc, int enable) { if (xc) { xc->repack_on_close = (enable != 0); } } void fstWriterSetParallelMode(fstWriterContext *xc, int enable) { if (xc) { xc->parallel_was_enabled |= xc->parallel_enabled; /* make sticky */ xc->parallel_enabled = (enable != 0); #ifndef FST_WRITER_PARALLEL if (xc->parallel_enabled) { fprintf(stderr, FST_APIMESS "fstWriterSetParallelMode(), FST_WRITER_PARALLEL not enabled " "during compile, exiting.\n"); exit(255); } #endif } } void fstWriterSetDumpSizeLimit(fstWriterContext *xc, uint64_t numbytes) { if (xc) { xc->dump_size_limit = numbytes; } } int fstWriterGetDumpSizeLimitReached(fstWriterContext *xc) { if (xc) { return (xc->size_limit_locked != 0); } return (0); } int fstWriterGetFseekFailed(fstWriterContext *xc) { if (xc) { return (xc->fseek_failed != 0); } return (0); } static int fstWriterGetFlushContextPendingInternal(fstWriterContext *xc) { return (xc->vchg_siz >= xc->fst_break_size) || (xc->flush_context_pending); } int fstWriterGetFlushContextPending(fstWriterContext *xc) { return xc && !xc->is_initial_time && fstWriterGetFlushContextPendingInternal(xc); } /* * writer attr/scope/var creation: * fstWriterCreateVar2() is used to dump VHDL or other languages, but the * underlying variable needs to map to Verilog/SV via the proper fstVarType vt */ fstHandle fstWriterCreateVar2(fstWriterContext *ctx, enum fstVarType vt, enum fstVarDir vd, uint32_t len, const char *nam, fstHandle aliasHandle, const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt) { fstWriterSetAttrGeneric(ctx, type ? type : "", FST_MT_SUPVAR, (svt << FST_SDT_SVT_SHIFT_COUNT) | (sdt & FST_SDT_ABS_MAX)); return (fstWriterCreateVar(ctx, vt, vd, len, nam, aliasHandle)); } fstHandle fstWriterCreateVar(fstWriterContext *xc, enum fstVarType vt, enum fstVarDir vd, uint32_t len, const char *nam, fstHandle aliasHandle) { unsigned int i; int nlen, is_real; if (xc && nam) { if (xc->valpos_mem) { fstDestroyMmaps(xc, 0); } fputc(vt, xc->hier_handle); fputc(vd, xc->hier_handle); nlen = strlen(nam); fstFwrite(nam, nlen, 1, xc->hier_handle); fputc(0, xc->hier_handle); xc->hier_file_len += (nlen + 3); if ((vt == FST_VT_VCD_REAL) || (vt == FST_VT_VCD_REAL_PARAMETER) || (vt == FST_VT_VCD_REALTIME) || (vt == FST_VT_SV_SHORTREAL)) { is_real = 1; len = 8; /* recast number of bytes to that of what a double is */ } else { is_real = 0; if (vt == FST_VT_GEN_STRING) { len = 0; } } xc->hier_file_len += fstWriterVarint(xc->hier_handle, len); if (aliasHandle > xc->maxhandle) aliasHandle = 0; xc->hier_file_len += fstWriterVarint(xc->hier_handle, aliasHandle); xc->numsigs++; if (xc->numsigs == xc->next_huge_break) { if (xc->fst_break_size < xc->fst_huge_break_size) { xc->next_huge_break += FST_ACTIVATE_HUGE_INC; xc->fst_break_size += xc->fst_orig_break_size; xc->fst_break_add_size += xc->fst_orig_break_add_size; xc->vchg_alloc_siz = xc->fst_break_size + xc->fst_break_add_size; if (xc->vchg_mem) { xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); } } } if (!aliasHandle) { uint32_t zero = 0; if (len) { fstWriterVarint(xc->geom_handle, !is_real ? len : 0); /* geom section encodes reals as zero byte */ } else { fstWriterVarint(xc->geom_handle, 0xFFFFFFFF); /* geom section encodes zero len as 32b -1 */ } fstFwrite(&xc->maxvalpos, sizeof(uint32_t), 1, xc->valpos_handle); fstFwrite(&len, sizeof(uint32_t), 1, xc->valpos_handle); fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); fstFwrite(&zero, sizeof(uint32_t), 1, xc->valpos_handle); if (!is_real) { for (i = 0; i < len; i++) { fputc('x', xc->curval_handle); } } else { fstFwrite(&xc->nan, 8, 1, xc->curval_handle); /* initialize doubles to NaN rather than x */ } xc->maxvalpos += len; xc->maxhandle++; return (xc->maxhandle); } else { return (aliasHandle); } } return (0); } void fstWriterSetScope(fstWriterContext *xc, enum fstScopeType scopetype, const char *scopename, const char *scopecomp) { if (xc) { fputc(FST_ST_VCD_SCOPE, xc->hier_handle); if (/*(scopetype < FST_ST_VCD_MODULE) ||*/ (scopetype > FST_ST_MAX)) { scopetype = FST_ST_VCD_MODULE; } fputc(scopetype, xc->hier_handle); fprintf(xc->hier_handle, "%s%c%s%c", scopename ? scopename : "", 0, scopecomp ? scopecomp : "", 0); if (scopename) { xc->hier_file_len += strlen(scopename); } if (scopecomp) { xc->hier_file_len += strlen(scopecomp); } xc->hier_file_len += 4; /* FST_ST_VCD_SCOPE + scopetype + two string terminating zeros */ xc->numscopes++; } } void fstWriterSetUpscope(fstWriterContext *xc) { if (xc) { fputc(FST_ST_VCD_UPSCOPE, xc->hier_handle); xc->hier_file_len++; } } void fstWriterSetAttrBegin(fstWriterContext *xc, enum fstAttrType attrtype, int subtype, const char *attrname, uint64_t arg) { if (xc) { fputc(FST_ST_GEN_ATTRBEGIN, xc->hier_handle); if (/*(attrtype < FST_AT_MISC) ||*/ (attrtype > FST_AT_MAX)) { attrtype = FST_AT_MISC; subtype = FST_MT_UNKNOWN; } fputc(attrtype, xc->hier_handle); switch (attrtype) { case FST_AT_ARRAY: if ((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) subtype = FST_AR_NONE; break; case FST_AT_ENUM: if ((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) subtype = FST_EV_SV_INTEGER; break; case FST_AT_PACK: if ((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) subtype = FST_PT_NONE; break; case FST_AT_MISC: default: break; } fputc(subtype, xc->hier_handle); fprintf(xc->hier_handle, "%s%c", attrname ? attrname : "", 0); if (attrname) { xc->hier_file_len += strlen(attrname); } xc->hier_file_len += 4; /* FST_ST_GEN_ATTRBEGIN + type + subtype + string terminating zero */ xc->hier_file_len += fstWriterVarint(xc->hier_handle, arg); } } void fstWriterSetAttrEnd(fstWriterContext *xc) { if (xc) { fputc(FST_ST_GEN_ATTREND, xc->hier_handle); xc->hier_file_len++; } } fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *xc, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr) { fstEnumHandle handle = 0; unsigned int *literal_lens = NULL; unsigned int *val_lens = NULL; int lit_len_tot = 0; int val_len_tot = 0; int name_len; char elem_count_buf[16]; int elem_count_len; int total_len; int pos = 0; char *attr_str = NULL; if (xc && name && literal_arr && val_arr && (elem_count != 0)) { uint32_t i; name_len = strlen(name); elem_count_len = snprintf(elem_count_buf, 16, "%" PRIu32, elem_count); literal_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int)); val_lens = (unsigned int *)calloc(elem_count, sizeof(unsigned int)); for (i = 0; i < elem_count; i++) { literal_lens[i] = strlen(literal_arr[i]); lit_len_tot += fstUtilityBinToEscConvertedLen((unsigned char *)literal_arr[i], literal_lens[i]); val_lens[i] = strlen(val_arr[i]); val_len_tot += fstUtilityBinToEscConvertedLen((unsigned char *)val_arr[i], val_lens[i]); if (min_valbits > 0) { if (val_lens[i] < min_valbits) { val_len_tot += (min_valbits - val_lens[i]); /* additional converted len is same for '0' character */ } } } total_len = name_len + 1 + elem_count_len + 1 + lit_len_tot + elem_count + val_len_tot + elem_count; attr_str = (char *)malloc(total_len); pos = 0; memcpy(attr_str + pos, name, name_len); pos += name_len; attr_str[pos++] = ' '; memcpy(attr_str + pos, elem_count_buf, elem_count_len); pos += elem_count_len; attr_str[pos++] = ' '; for (i = 0; i < elem_count; i++) { pos += fstUtilityBinToEsc((unsigned char *)attr_str + pos, (unsigned char *)literal_arr[i], literal_lens[i]); attr_str[pos++] = ' '; } for (i = 0; i < elem_count; i++) { if (min_valbits > 0) { if (val_lens[i] < min_valbits) { memset(attr_str + pos, '0', min_valbits - val_lens[i]); pos += (min_valbits - val_lens[i]); } } pos += fstUtilityBinToEsc((unsigned char *)attr_str + pos, (unsigned char *)val_arr[i], val_lens[i]); attr_str[pos++] = ' '; } attr_str[pos - 1] = 0; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "fstWriterCreateEnumTable() total_len: %d, pos: %d\n", total_len, pos); fprintf(stderr, FST_APIMESS "*%s*\n", attr_str); #endif fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, attr_str, handle = ++xc->max_enumhandle); free(attr_str); free(val_lens); free(literal_lens); } return (handle); } void fstWriterEmitEnumTableRef(fstWriterContext *xc, fstEnumHandle handle) { if (xc && handle) { fstWriterSetAttrBegin(xc, FST_AT_MISC, FST_MT_ENUMTABLE, NULL, handle); } } /* * value and time change emission */ void fstWriterEmitValueChange(fstWriterContext *xc, fstHandle handle, const void *val) { const unsigned char *buf = (const unsigned char *)val; uint32_t offs; int len; if (FST_LIKELY((xc) && (handle <= xc->maxhandle))) { uint32_t fpos; uint32_t *vm4ip; if (FST_UNLIKELY(!xc->valpos_mem)) { xc->vc_emitted = 1; fstWriterCreateMmaps(xc); } handle--; /* move starting at 1 index to starting at 0 */ vm4ip = &(xc->valpos_mem[4 * handle]); len = vm4ip[1]; if (FST_LIKELY(len)) /* len of zero = variable length, use fstWriterEmitVariableLengthValueChange */ { if (FST_LIKELY(!xc->is_initial_time)) { fpos = xc->vchg_siz; if (FST_UNLIKELY((fpos + len + 10) > xc->vchg_alloc_siz)) { xc->vchg_alloc_siz += (xc->fst_break_add_size + len); /* +len added in the case of extremely long vectors and small break add sizes */ xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); if (FST_UNLIKELY(!xc->vchg_mem)) { fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitValueChange, exiting.\n"); exit(255); } } #ifdef FST_REMOVE_DUPLICATE_VC offs = vm4ip[0]; if (len != 1) { if ((vm4ip[3] == xc->tchn_idx) && (vm4ip[2])) { unsigned char *old_value = xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ while (*(old_value++) & 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ } memcpy(old_value, buf, len); /* overlay new value */ memcpy(xc->curval_mem + offs, buf, len); return; } else { if (!memcmp(xc->curval_mem + offs, buf, len)) { if (!xc->curtime) { int i; for (i = 0; i < len; i++) { if (buf[i] != 'x') break; } if (i < len) return; } else { return; } } } memcpy(xc->curval_mem + offs, buf, len); } else { if ((vm4ip[3] == xc->tchn_idx) && (vm4ip[2])) { unsigned char *old_value = xc->vchg_mem + vm4ip[2] + 4; /* the +4 skips old vm4ip[2] value */ while (*(old_value++) & 0x80) { /* skips over varint encoded "xc->tchn_idx - vm4ip[3]" */ } *old_value = *buf; /* overlay new value */ *(xc->curval_mem + offs) = *buf; return; } else { if ((*(xc->curval_mem + offs)) == (*buf)) { if (!xc->curtime) { if (*buf != 'x') return; } else { return; } } } *(xc->curval_mem + offs) = *buf; } #endif xc->vchg_siz += fstWriterUint32WithVarint32(xc, &vm4ip[2], xc->tchn_idx - vm4ip[3], buf, len); /* do one fwrite op only */ vm4ip[3] = xc->tchn_idx; vm4ip[2] = fpos; } else { offs = vm4ip[0]; memcpy(xc->curval_mem + offs, buf, len); } } } } void fstWriterEmitValueChange32(fstWriterContext *ctx, fstHandle handle, uint32_t bits, uint32_t val) { char buf[32]; char *s = buf; uint32_t i; for (i = 0; i < bits; ++i) { *s++ = '0' + ((val >> (bits - i - 1)) & 1); } fstWriterEmitValueChange(ctx, handle, buf); } void fstWriterEmitValueChange64(fstWriterContext *ctx, fstHandle handle, uint32_t bits, uint64_t val) { char buf[64]; char *s = buf; uint32_t i; for (i = 0; i < bits; ++i) { *s++ = '0' + ((val >> (bits - i - 1)) & 1); } fstWriterEmitValueChange(ctx, handle, buf); } void fstWriterEmitValueChangeVec32(fstWriterContext *xc, fstHandle handle, uint32_t bits, const uint32_t *val) { if (FST_UNLIKELY(bits <= 32)) { fstWriterEmitValueChange32(xc, handle, bits, val[0]); } else if (FST_LIKELY(xc)) { int bq = bits / 32; int br = bits & 31; int i; int w; uint32_t v; unsigned char *s; if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) { xc->outval_alloc_siz = bits * 2 + 1; xc->outval_mem = (unsigned char *)realloc(xc->outval_mem, xc->outval_alloc_siz); if (FST_UNLIKELY(!xc->outval_mem)) { fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec32, exiting.\n"); exit(255); } } s = xc->outval_mem; { w = bq; v = val[w]; for (i = 0; i < br; ++i) { *s++ = '0' + ((v >> (br - i - 1)) & 1); } } for (w = bq - 1; w >= 0; --w) { v = val[w]; for (i = (32 - 4); i >= 0; i -= 4) { s[0] = '0' + ((v >> (i + 3)) & 1); s[1] = '0' + ((v >> (i + 2)) & 1); s[2] = '0' + ((v >> (i + 1)) & 1); s[3] = '0' + ((v >> (i + 0)) & 1); s += 4; } } fstWriterEmitValueChange(xc, handle, xc->outval_mem); } } void fstWriterEmitValueChangeVec64(fstWriterContext *xc, fstHandle handle, uint32_t bits, const uint64_t *val) { if (FST_UNLIKELY(bits <= 64)) { fstWriterEmitValueChange64(xc, handle, bits, val[0]); } else if (FST_LIKELY(xc)) { int bq = bits / 64; int br = bits & 63; int i; int w; uint32_t v; unsigned char *s; if (FST_UNLIKELY(bits > xc->outval_alloc_siz)) { xc->outval_alloc_siz = bits * 2 + 1; xc->outval_mem = (unsigned char *)realloc(xc->outval_mem, xc->outval_alloc_siz); if (FST_UNLIKELY(!xc->outval_mem)) { fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec64, exiting.\n"); exit(255); } } s = xc->outval_mem; { w = bq; v = val[w]; for (i = 0; i < br; ++i) { *s++ = '0' + ((v >> (br - i - 1)) & 1); } } for (w = bq - 1; w >= 0; --w) { v = val[w]; for (i = (64 - 4); i >= 0; i -= 4) { s[0] = '0' + ((v >> (i + 3)) & 1); s[1] = '0' + ((v >> (i + 2)) & 1); s[2] = '0' + ((v >> (i + 1)) & 1); s[3] = '0' + ((v >> (i + 0)) & 1); s += 4; } } fstWriterEmitValueChange(xc, handle, xc->outval_mem); } } void fstWriterEmitVariableLengthValueChange(fstWriterContext *xc, fstHandle handle, const void *val, uint32_t len) { const unsigned char *buf = (const unsigned char *)val; if (FST_LIKELY((xc) && (handle <= xc->maxhandle))) { uint32_t fpos; uint32_t *vm4ip; if (FST_UNLIKELY(!xc->valpos_mem)) { xc->vc_emitted = 1; fstWriterCreateMmaps(xc); } handle--; /* move starting at 1 index to starting at 0 */ vm4ip = &(xc->valpos_mem[4 * handle]); /* there is no initial time dump for variable length value changes */ if (FST_LIKELY(!vm4ip[1])) /* len of zero = variable length */ { fpos = xc->vchg_siz; if (FST_UNLIKELY((fpos + len + 10 + 5) > xc->vchg_alloc_siz)) { xc->vchg_alloc_siz += (xc->fst_break_add_size + len + 5); /* +len added in the case of extremely long vectors and small break add sizes */ xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz); if (FST_UNLIKELY(!xc->vchg_mem)) { fprintf(stderr, FST_APIMESS "Could not realloc() in " "fstWriterEmitVariableLengthValueChange, exiting.\n"); exit(255); } } xc->vchg_siz += fstWriterUint32WithVarint32AndLength(xc, &vm4ip[2], xc->tchn_idx - vm4ip[3], buf, len); /* do one fwrite op only */ vm4ip[3] = xc->tchn_idx; vm4ip[2] = fpos; } } } void fstWriterEmitTimeChange(fstWriterContext *xc, uint64_t tim) { unsigned int i; int skip = 0; if (xc) { if (FST_UNLIKELY(xc->is_initial_time)) { if (xc->size_limit_locked) /* this resets xc->is_initial_time to one */ { return; } if (!xc->valpos_mem) { fstWriterCreateMmaps(xc); } skip = 1; xc->firsttime = (xc->vc_emitted) ? 0 : tim; xc->curtime = 0; xc->vchg_mem[0] = '!'; xc->vchg_siz = 1; fstWriterEmitSectionHeader(xc); for (i = 0; i < xc->maxhandle; i++) { xc->valpos_mem[4 * i + 2] = 0; /* zero out offset val */ xc->valpos_mem[4 * i + 3] = 0; /* zero out last time change val */ } xc->is_initial_time = 0; } else { if (fstWriterGetFlushContextPendingInternal(xc)) { xc->flush_context_pending = 0; fstWriterFlushContextPrivate(xc); xc->tchn_cnt++; fstWriterVarint(xc->tchn_handle, xc->curtime); } } if (!skip) { xc->tchn_idx++; } fstWriterVarint(xc->tchn_handle, tim - xc->curtime); xc->tchn_cnt++; xc->curtime = tim; } } void fstWriterEmitDumpActive(fstWriterContext *xc, int enable) { if (xc) { struct fstBlackoutChain *b = (struct fstBlackoutChain *)calloc(1, sizeof(struct fstBlackoutChain)); b->tim = xc->curtime; b->active = (enable != 0); xc->num_blackouts++; if (xc->blackout_curr) { xc->blackout_curr->next = b; xc->blackout_curr = b; } else { xc->blackout_head = b; xc->blackout_curr = b; } } } /***********************/ /*** ***/ /*** reader function ***/ /*** ***/ /***********************/ /* * private structs */ static const char *vartypes[] = { "event", "integer", "parameter", "real", "real_parameter", "reg", "supply0", "supply1", "time", "tri", "triand", "trior", "trireg", "tri0", "tri1", "wand", "wire", "wor", "port", "sparray", "realtime", "string", "bit", "logic", "int", "shortint", "longint", "byte", "enum", "shortreal"}; static const char *modtypes[] = {"module", "task", "function", "begin", "fork", "generate", "struct", "union", "class", "interface", "package", "program", "vhdl_architecture", "vhdl_procedure", "vhdl_function", "vhdl_record", "vhdl_process", "vhdl_block", "vhdl_for_generate", "vhdl_if_generate", "vhdl_generate", "vhdl_package"}; static const char *attrtypes[] = {"misc", "array", "enum", "class"}; static const char *arraytypes[] = {"none", "unpacked", "packed", "sparse"}; static const char *enumvaluetypes[] = {"integer", "bit", "logic", "int", "shortint", "longint", "byte", "unsigned_integer", "unsigned_bit", "unsigned_logic", "unsigned_int", "unsigned_shortint", "unsigned_longint", "unsigned_byte"}; static const char *packtypes[] = {"none", "unpacked", "packed", "tagged_packed"}; struct fstCurrHier { struct fstCurrHier *prev; void *user_info; int len; }; struct fstReaderContext { /* common entries */ FILE *f, *fh; uint64_t start_time, end_time; uint64_t mem_used_by_writer; uint64_t scope_count; uint64_t var_count; fstHandle maxhandle; uint64_t num_alias; uint64_t vc_section_count; uint32_t *signal_lens; /* maxhandle sized */ unsigned char *signal_typs; /* maxhandle sized */ unsigned char *process_mask; /* maxhandle-based, bitwise sized */ uint32_t longest_signal_value_len; /* longest len value encountered */ unsigned char *temp_signal_value_buf; /* malloced for len in longest_signal_value_len */ signed char timescale; unsigned char filetype; unsigned use_vcd_extensions : 1; unsigned double_endian_match : 1; unsigned native_doubles_for_cb : 1; unsigned contains_geom_section : 1; unsigned contains_hier_section : 1; /* valid for hier_pos */ unsigned contains_hier_section_lz4duo : 1; /* valid for hier_pos (contains_hier_section_lz4 always also set) */ unsigned contains_hier_section_lz4 : 1; /* valid for hier_pos */ unsigned limit_range_valid : 1; /* valid for limit_range_start, limit_range_end */ char version[FST_HDR_SIM_VERSION_SIZE + 1]; char date[FST_HDR_DATE_SIZE + 1]; int64_t timezero; char *filename, *filename_unpacked; fst_off_t hier_pos; uint32_t num_blackouts; uint64_t *blackout_times; unsigned char *blackout_activity; uint64_t limit_range_start, limit_range_end; /* entries specific to read value at time functions */ unsigned rvat_data_valid : 1; uint64_t *rvat_time_table; uint64_t rvat_beg_tim, rvat_end_tim; unsigned char *rvat_frame_data; uint64_t rvat_frame_maxhandle; fst_off_t *rvat_chain_table; uint32_t *rvat_chain_table_lengths; uint64_t rvat_vc_maxhandle; fst_off_t rvat_vc_start; uint32_t *rvat_sig_offs; int rvat_packtype; uint32_t rvat_chain_len; unsigned char *rvat_chain_mem; fstHandle rvat_chain_facidx; uint32_t rvat_chain_pos_tidx; uint32_t rvat_chain_pos_idx; uint64_t rvat_chain_pos_time; unsigned rvat_chain_pos_valid : 1; /* entries specific to hierarchy traversal */ struct fstHier hier; struct fstCurrHier *curr_hier; fstHandle current_handle; char *curr_flat_hier_nam; int flat_hier_alloc_len; unsigned do_rewind : 1; char str_scope_nam[FST_ID_NAM_SIZ + 1]; char str_scope_comp[FST_ID_NAM_SIZ + 1]; char *str_scope_attr; unsigned fseek_failed : 1; /* self-buffered I/O for writes */ #ifndef FST_WRITEX_DISABLE int writex_pos; int writex_fd; unsigned char writex_buf[FST_WRITEX_MAX]; #endif char *f_nam; char *fh_nam; }; int fstReaderFseeko(struct fstReaderContext *xc, FILE *stream, fst_off_t offset, int whence) { int rc = fseeko(stream, offset, whence); if (rc < 0) { xc->fseek_failed = 1; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "Seek to #%" PRId64 " (whence = %d) failed!\n", offset, whence); perror("Why"); #endif } return (rc); } #ifndef FST_WRITEX_DISABLE static void fstWritex(struct fstReaderContext *xc, void *v, uint32_t len) /* TALOS-2023-1793: change len to unsigned */ { unsigned char *s = (unsigned char *)v; if (len) { if (len < FST_WRITEX_MAX) { if (xc->writex_pos + len >= FST_WRITEX_MAX) { fstWritex(xc, NULL, 0); } memcpy(xc->writex_buf + xc->writex_pos, s, len); xc->writex_pos += len; } else { fstWritex(xc, NULL, 0); if (write(xc->writex_fd, s, len)) { }; } } else { if (xc->writex_pos) { if (write(xc->writex_fd, xc->writex_buf, xc->writex_pos)) { }; xc->writex_pos = 0; } } } #endif /* * scope -> flat name handling */ static void fstReaderDeallocateScopeData(fstReaderContext *xc) { struct fstCurrHier *chp; free(xc->curr_flat_hier_nam); xc->curr_flat_hier_nam = NULL; while (xc->curr_hier) { chp = xc->curr_hier->prev; free(xc->curr_hier); xc->curr_hier = chp; } } const char *fstReaderGetCurrentFlatScope(fstReaderContext *xc) { if (xc) { return (xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : ""); } else { return (NULL); } } void *fstReaderGetCurrentScopeUserInfo(fstReaderContext *xc) { if (xc) { return (xc->curr_hier ? xc->curr_hier->user_info : NULL); } else { return (NULL); } } const char *fstReaderPopScope(fstReaderContext *xc) { if (xc && xc->curr_hier) { struct fstCurrHier *ch = xc->curr_hier; if (xc->curr_hier->prev) { xc->curr_flat_hier_nam[xc->curr_hier->prev->len] = 0; } else { *xc->curr_flat_hier_nam = 0; } xc->curr_hier = xc->curr_hier->prev; free(ch); return (xc->curr_flat_hier_nam ? xc->curr_flat_hier_nam : ""); } return (NULL); } void fstReaderResetScope(fstReaderContext *xc) { if (xc) { while (fstReaderPopScope(xc)) ; /* remove any already-built scoping info */ } } const char *fstReaderPushScope(fstReaderContext *xc, const char *nam, void *user_info) { if (xc) { struct fstCurrHier *ch = (struct fstCurrHier *)malloc(sizeof(struct fstCurrHier)); int chl = xc->curr_hier ? xc->curr_hier->len : 0; int len = chl + 1 + strlen(nam); if (len >= xc->flat_hier_alloc_len) { xc->curr_flat_hier_nam = xc->curr_flat_hier_nam ? (char *)realloc(xc->curr_flat_hier_nam, len + 1) : (char *)malloc(len + 1); } if (chl) { xc->curr_flat_hier_nam[chl] = '.'; strcpy(xc->curr_flat_hier_nam + chl + 1, nam); } else { strcpy(xc->curr_flat_hier_nam, nam); len--; } ch->len = len; ch->prev = xc->curr_hier; ch->user_info = user_info; xc->curr_hier = ch; return (xc->curr_flat_hier_nam); } return (NULL); } int fstReaderGetCurrentScopeLen(fstReaderContext *xc) { if (xc && xc->curr_hier) { return (xc->curr_hier->len); } return (0); } int fstReaderGetFseekFailed(fstReaderContext *xc) { if (xc) { return (xc->fseek_failed != 0); } return (0); } /* * iter mask manipulation util functions */ int fstReaderGetFacProcessMask(fstReaderContext *xc, fstHandle facidx) { if (xc) { facidx--; if (facidx < xc->maxhandle) { int process_idx = facidx / 8; int process_bit = facidx & 7; return ((xc->process_mask[process_idx] & (1 << process_bit)) != 0); } } return (0); } void fstReaderSetFacProcessMask(fstReaderContext *xc, fstHandle facidx) { if (xc) { facidx--; if (facidx < xc->maxhandle) { int idx = facidx / 8; int bitpos = facidx & 7; xc->process_mask[idx] |= (1 << bitpos); } } } void fstReaderClrFacProcessMask(fstReaderContext *xc, fstHandle facidx) { if (xc) { facidx--; if (facidx < xc->maxhandle) { int idx = facidx / 8; int bitpos = facidx & 7; xc->process_mask[idx] &= (~(1 << bitpos)); } } } void fstReaderSetFacProcessMaskAll(fstReaderContext *xc) { if (xc) { memset(xc->process_mask, 0xff, (xc->maxhandle + 7) / 8); } } void fstReaderClrFacProcessMaskAll(fstReaderContext *xc) { if (xc) { memset(xc->process_mask, 0x00, (xc->maxhandle + 7) / 8); } } /* * various utility read/write functions */ signed char fstReaderGetTimescale(fstReaderContext *xc) { return (xc ? xc->timescale : 0); } uint64_t fstReaderGetStartTime(fstReaderContext *xc) { return (xc ? xc->start_time : 0); } uint64_t fstReaderGetEndTime(fstReaderContext *xc) { return (xc ? xc->end_time : 0); } uint64_t fstReaderGetMemoryUsedByWriter(fstReaderContext *xc) { return (xc ? xc->mem_used_by_writer : 0); } uint64_t fstReaderGetScopeCount(fstReaderContext *xc) { return (xc ? xc->scope_count : 0); } uint64_t fstReaderGetVarCount(fstReaderContext *xc) { return (xc ? xc->var_count : 0); } fstHandle fstReaderGetMaxHandle(fstReaderContext *xc) { return (xc ? xc->maxhandle : 0); } uint64_t fstReaderGetAliasCount(fstReaderContext *xc) { return (xc ? xc->num_alias : 0); } uint64_t fstReaderGetValueChangeSectionCount(fstReaderContext *xc) { return (xc ? xc->vc_section_count : 0); } int fstReaderGetDoubleEndianMatchState(fstReaderContext *xc) { return (xc ? xc->double_endian_match : 0); } const char *fstReaderGetVersionString(fstReaderContext *xc) { return (xc ? xc->version : NULL); } const char *fstReaderGetDateString(fstReaderContext *xc) { return (xc ? xc->date : NULL); } int fstReaderGetFileType(fstReaderContext *xc) { return (xc ? (int)xc->filetype : (int)FST_FT_VERILOG); } int64_t fstReaderGetTimezero(fstReaderContext *xc) { return (xc ? xc->timezero : 0); } uint32_t fstReaderGetNumberDumpActivityChanges(fstReaderContext *xc) { return (xc ? xc->num_blackouts : 0); } uint64_t fstReaderGetDumpActivityChangeTime(fstReaderContext *xc, uint32_t idx) { if (xc && (idx < xc->num_blackouts) && (xc->blackout_times)) { return (xc->blackout_times[idx]); } else { return (0); } } unsigned char fstReaderGetDumpActivityChangeValue(fstReaderContext *xc, uint32_t idx) { if (xc && (idx < xc->num_blackouts) && (xc->blackout_activity)) { return (xc->blackout_activity[idx]); } else { return (0); } } void fstReaderSetLimitTimeRange(fstReaderContext *xc, uint64_t start_time, uint64_t end_time) { if (xc) { xc->limit_range_valid = 1; xc->limit_range_start = start_time; xc->limit_range_end = end_time; } } void fstReaderSetUnlimitedTimeRange(fstReaderContext *xc) { if (xc) { xc->limit_range_valid = 0; } } void fstReaderSetVcdExtensions(fstReaderContext *xc, int enable) { if (xc) { xc->use_vcd_extensions = (enable != 0); } } void fstReaderIterBlocksSetNativeDoublesOnCallback(fstReaderContext *xc, int enable) { if (xc) { xc->native_doubles_for_cb = (enable != 0); } } /* * hierarchy processing */ static void fstVcdID(char *buf, unsigned int value) { char *pnt = buf; /* zero is illegal for a value...it is assumed they start at one */ while (value) { value--; *(pnt++) = (char)('!' + value % 94); value = value / 94; } *pnt = 0; } static int fstVcdIDForFwrite(char *buf, unsigned int value) { char *pnt = buf; int len = 0; /* zero is illegal for a value...it is assumed they start at one */ while (value && len < 14) { value--; ++len; *(pnt++) = (char)('!' + value % 94); value = value / 94; } return len; } static int fstReaderRecreateHierFile(struct fstReaderContext *xc) { int pass_status = 1; if (!xc->fh) { fst_off_t offs_cache = ftello(xc->f); int fnam_len = strlen(xc->filename) + 6 + 16 + 32 + 1; char *fnam = (char *)malloc(fnam_len); unsigned char *mem = (unsigned char *)malloc(FST_GZIO_LEN); fst_off_t hl, uclen; fst_off_t clen = 0; gzFile zhandle = NULL; int zfd; int htyp = FST_BL_SKIP; /* can't handle both set at once should never happen in a real file */ if (!xc->contains_hier_section_lz4 && xc->contains_hier_section) { htyp = FST_BL_HIER; } else if (xc->contains_hier_section_lz4 && !xc->contains_hier_section) { htyp = xc->contains_hier_section_lz4duo ? FST_BL_HIER_LZ4DUO : FST_BL_HIER_LZ4; } snprintf(fnam, fnam_len, "%s.hier_%d_%p", xc->filename, getpid(), (void *)xc); fstReaderFseeko(xc, xc->f, xc->hier_pos, SEEK_SET); uclen = fstReaderUint64(xc->f); #ifndef __MINGW32__ fflush(xc->f); #endif if (htyp == FST_BL_HIER) { fstReaderFseeko(xc, xc->f, xc->hier_pos, SEEK_SET); uclen = fstReaderUint64(xc->f); #ifndef __MINGW32__ fflush(xc->f); #endif zfd = dup(fileno(xc->f)); zhandle = gzdopen(zfd, "rb"); if (!zhandle) { close(zfd); free(mem); free(fnam); return (0); } } else if ((htyp == FST_BL_HIER_LZ4) || (htyp == FST_BL_HIER_LZ4DUO)) { fstReaderFseeko(xc, xc->f, xc->hier_pos - 8, SEEK_SET); /* get section len */ clen = fstReaderUint64(xc->f) - 16; uclen = fstReaderUint64(xc->f); #ifndef __MINGW32__ fflush(xc->f); #endif } #ifndef __MINGW32__ xc->fh = fopen(fnam, "w+b"); if (!xc->fh) #endif { xc->fh = tmpfile_open(&xc->fh_nam); free(fnam); fnam = NULL; if (!xc->fh) { tmpfile_close(&xc->fh, &xc->fh_nam); free(mem); return (0); } } #ifndef __MINGW32__ if (fnam) unlink(fnam); #endif if (htyp == FST_BL_HIER) { for (hl = 0; hl < uclen; hl += FST_GZIO_LEN) { size_t len = ((uclen - hl) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - hl); size_t gzreadlen = gzread(zhandle, mem, len); /* rc should equal len... */ size_t fwlen; if (gzreadlen != len) { pass_status = 0; break; } fwlen = fstFwrite(mem, len, 1, xc->fh); if (fwlen != 1) { pass_status = 0; break; } } gzclose(zhandle); } else if (htyp == FST_BL_HIER_LZ4DUO) { unsigned char *lz4_cmem = (unsigned char *)malloc(clen); unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); unsigned char *lz4_ucmem2; uint64_t uclen2; int skiplen2 = 0; fstFread(lz4_cmem, clen, 1, xc->f); uclen2 = fstGetVarint64(lz4_cmem, &skiplen2); lz4_ucmem2 = (unsigned char *)malloc(uclen2); pass_status = (uclen2 == (uint64_t)LZ4_decompress_safe_partial((char *)lz4_cmem + skiplen2, (char *)lz4_ucmem2, clen - skiplen2, uclen2, uclen2)); if (pass_status) { pass_status = (uclen == LZ4_decompress_safe_partial((char *)lz4_ucmem2, (char *)lz4_ucmem, uclen2, uclen, uclen)); if (fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) { pass_status = 0; } } free(lz4_ucmem2); free(lz4_ucmem); free(lz4_cmem); } else if (htyp == FST_BL_HIER_LZ4) { unsigned char *lz4_cmem = (unsigned char *)malloc(clen); unsigned char *lz4_ucmem = (unsigned char *)malloc(uclen); fstFread(lz4_cmem, clen, 1, xc->f); pass_status = (uclen == LZ4_decompress_safe_partial((char *)lz4_cmem, (char *)lz4_ucmem, clen, uclen, uclen)); if (fstFwrite(lz4_ucmem, uclen, 1, xc->fh) != 1) { pass_status = 0; } free(lz4_ucmem); free(lz4_cmem); } else /* FST_BL_SKIP */ { pass_status = 0; if (xc->fh) { fclose(xc->fh); xc->fh = NULL; /* needed in case .hier file is missing and there are no hier sections */ } } free(mem); free(fnam); fstReaderFseeko(xc, xc->f, offs_cache, SEEK_SET); } return (pass_status); } int fstReaderIterateHierRewind(fstReaderContext *xc) { int pass_status = 0; if (xc) { pass_status = 1; if (!xc->fh) { pass_status = fstReaderRecreateHierFile(xc); } xc->do_rewind = 1; } return (pass_status); } struct fstHier *fstReaderIterateHier(fstReaderContext *xc) { int isfeof; fstHandle alias; char *pnt; int ch; int unnamed_scope_idx = 0; if (!xc) return (NULL); if (!xc->fh) { if (!fstReaderRecreateHierFile(xc)) { return (NULL); } } if (xc->do_rewind) { xc->do_rewind = 0; xc->current_handle = 0; fstReaderFseeko(xc, xc->fh, 0, SEEK_SET); clearerr(xc->fh); } if (!(isfeof = feof(xc->fh))) { int tag = fgetc(xc->fh); int cl; switch (tag) { case FST_ST_VCD_SCOPE: xc->hier.htyp = FST_HT_SCOPE; xc->hier.u.scope.typ = fgetc(xc->fh); xc->hier.u.scope.name = pnt = xc->str_scope_nam; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_SIZ) { pnt[cl++] = ch; } }; /* scopename */ if (!cl) { cl = snprintf(pnt, FST_ID_NAM_SIZ, "$unnamed_scope_%d", unnamed_scope_idx++); } pnt[cl] = 0; xc->hier.u.scope.name_length = cl; xc->hier.u.scope.component = pnt = xc->str_scope_comp; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_SIZ) { pnt[cl++] = ch; } }; /* scopecomp */ pnt[cl] = 0; xc->hier.u.scope.component_length = cl; break; case FST_ST_VCD_UPSCOPE: xc->hier.htyp = FST_HT_UPSCOPE; break; case FST_ST_GEN_ATTRBEGIN: xc->hier.htyp = FST_HT_ATTRBEGIN; xc->hier.u.attr.typ = fgetc(xc->fh); xc->hier.u.attr.subtype = fgetc(xc->fh); if (!xc->str_scope_attr) { xc->str_scope_attr = (char *)calloc(1, FST_ID_NAM_ATTR_SIZ + 1); } xc->hier.u.attr.name = pnt = xc->str_scope_attr; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_ATTR_SIZ) { pnt[cl++] = ch; } }; /* attrname */ pnt[cl] = 0; xc->hier.u.attr.name_length = cl; xc->hier.u.attr.arg = fstReaderVarint64(xc->fh); if (xc->hier.u.attr.typ == FST_AT_MISC) { if ((xc->hier.u.attr.subtype == FST_MT_SOURCESTEM) || (xc->hier.u.attr.subtype == FST_MT_SOURCEISTEM)) { int sidx_skiplen_dummy = 0; xc->hier.u.attr.arg_from_name = fstGetVarint64((unsigned char *)xc->str_scope_attr, &sidx_skiplen_dummy); } } break; case FST_ST_GEN_ATTREND: xc->hier.htyp = FST_HT_ATTREND; break; case FST_VT_VCD_EVENT: case FST_VT_VCD_INTEGER: case FST_VT_VCD_PARAMETER: case FST_VT_VCD_REAL: case FST_VT_VCD_REAL_PARAMETER: case FST_VT_VCD_REG: case FST_VT_VCD_SUPPLY0: case FST_VT_VCD_SUPPLY1: case FST_VT_VCD_TIME: case FST_VT_VCD_TRI: case FST_VT_VCD_TRIAND: case FST_VT_VCD_TRIOR: case FST_VT_VCD_TRIREG: case FST_VT_VCD_TRI0: case FST_VT_VCD_TRI1: case FST_VT_VCD_WAND: case FST_VT_VCD_WIRE: case FST_VT_VCD_WOR: case FST_VT_VCD_PORT: case FST_VT_VCD_SPARRAY: case FST_VT_VCD_REALTIME: case FST_VT_GEN_STRING: case FST_VT_SV_BIT: case FST_VT_SV_LOGIC: case FST_VT_SV_INT: case FST_VT_SV_SHORTINT: case FST_VT_SV_LONGINT: case FST_VT_SV_BYTE: case FST_VT_SV_ENUM: case FST_VT_SV_SHORTREAL: xc->hier.htyp = FST_HT_VAR; xc->hier.u.var.svt_workspace = FST_SVT_NONE; xc->hier.u.var.sdt_workspace = FST_SDT_NONE; xc->hier.u.var.sxt_workspace = 0; xc->hier.u.var.typ = tag; xc->hier.u.var.direction = fgetc(xc->fh); xc->hier.u.var.name = pnt = xc->str_scope_nam; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_SIZ) { pnt[cl++] = ch; } }; /* varname */ pnt[cl] = 0; xc->hier.u.var.name_length = cl; xc->hier.u.var.length = fstReaderVarint32(xc->fh); if (tag == FST_VT_VCD_PORT) { xc->hier.u.var.length -= 2; /* removal of delimiting spaces */ xc->hier.u.var.length /= 3; /* port -> signal size adjust */ } alias = fstReaderVarint32(xc->fh); if (!alias) { xc->current_handle++; xc->hier.u.var.handle = xc->current_handle; xc->hier.u.var.is_alias = 0; } else { xc->hier.u.var.handle = alias; xc->hier.u.var.is_alias = 1; } break; default: isfeof = 1; break; } } return (!isfeof ? &xc->hier : NULL); } int fstReaderProcessHier(fstReaderContext *xc, FILE *fv) { char *str; char *pnt; int ch, scopetype; int vartype; uint32_t len, alias; /* uint32_t maxvalpos=0; */ unsigned int num_signal_dyn = 65536; int attrtype, subtype; uint64_t attrarg; fstHandle maxhandle_scanbuild; int cl; int unnamed_scope_idx = 0; if (!xc) return (0); xc->longest_signal_value_len = 32; /* arbitrarily set at 32...this is much longer than an expanded double */ if (!xc->fh) { if (!fstReaderRecreateHierFile(xc)) { return (0); } } str = (char *)malloc(FST_ID_NAM_ATTR_SIZ + 1); if (fv) { char time_dimension[2] = {0, 0}; int time_scale = 1; fprintf(fv, "$date\n\t%s\n$end\n", xc->date); fprintf(fv, "$version\n\t%s\n$end\n", xc->version); if (xc->timezero) fprintf(fv, "$timezero\n\t%" PRId64 "\n$end\n", xc->timezero); switch (xc->timescale) { case 2: time_scale = 100; time_dimension[0] = 0; break; case 1: time_scale = 10; /* fallthrough */ case 0: time_dimension[0] = 0; break; case -1: time_scale = 100; time_dimension[0] = 'm'; break; case -2: time_scale = 10; /* fallthrough */ case -3: time_dimension[0] = 'm'; break; case -4: time_scale = 100; time_dimension[0] = 'u'; break; case -5: time_scale = 10; /* fallthrough */ case -6: time_dimension[0] = 'u'; break; case -10: time_scale = 100; time_dimension[0] = 'p'; break; case -11: time_scale = 10; /* fallthrough */ case -12: time_dimension[0] = 'p'; break; case -13: time_scale = 100; time_dimension[0] = 'f'; break; case -14: time_scale = 10; /* fallthrough */ case -15: time_dimension[0] = 'f'; break; case -16: time_scale = 100; time_dimension[0] = 'a'; break; case -17: time_scale = 10; /* fallthrough */ case -18: time_dimension[0] = 'a'; break; case -19: time_scale = 100; time_dimension[0] = 'z'; break; case -20: time_scale = 10; /* fallthrough */ case -21: time_dimension[0] = 'z'; break; case -7: time_scale = 100; time_dimension[0] = 'n'; break; case -8: time_scale = 10; /* fallthrough */ case -9: default: time_dimension[0] = 'n'; break; } if (fv) fprintf(fv, "$timescale\n\t%d%ss\n$end\n", time_scale, time_dimension); } xc->maxhandle = 0; xc->num_alias = 0; free(xc->signal_lens); xc->signal_lens = (uint32_t *)malloc(num_signal_dyn * sizeof(uint32_t)); free(xc->signal_typs); xc->signal_typs = (unsigned char *)malloc(num_signal_dyn * sizeof(unsigned char)); fstReaderFseeko(xc, xc->fh, 0, SEEK_SET); while (!feof(xc->fh)) { int tag = fgetc(xc->fh); switch (tag) { case FST_ST_VCD_SCOPE: scopetype = fgetc(xc->fh); if ((scopetype < FST_ST_MIN) || (scopetype > FST_ST_MAX)) scopetype = FST_ST_VCD_MODULE; pnt = str; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_ATTR_SIZ) { pnt[cl++] = ch; } }; /* scopename */ if (!cl) { cl = snprintf(pnt, FST_ID_NAM_SIZ, "$unnamed_scope_%d", unnamed_scope_idx++); } pnt[cl] = 0; while (fgetc(xc->fh)) { }; /* scopecomp */ if (fv) fprintf(fv, "$scope %s %s $end\n", modtypes[scopetype], str); break; case FST_ST_VCD_UPSCOPE: if (fv) fprintf(fv, "$upscope $end\n"); break; case FST_ST_GEN_ATTRBEGIN: attrtype = fgetc(xc->fh); subtype = fgetc(xc->fh); pnt = str; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_ATTR_SIZ) { pnt[cl++] = ch; } }; /* attrname */ pnt[cl] = 0; if (!str[0]) { strcpy(str, "\"\""); } attrarg = fstReaderVarint64(xc->fh); if (fv && xc->use_vcd_extensions) { switch (attrtype) { case FST_AT_ARRAY: if ((subtype < FST_AR_NONE) || (subtype > FST_AR_MAX)) subtype = FST_AR_NONE; fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], arraytypes[subtype], str, attrarg); break; case FST_AT_ENUM: if ((subtype < FST_EV_SV_INTEGER) || (subtype > FST_EV_MAX)) subtype = FST_EV_SV_INTEGER; fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], enumvaluetypes[subtype], str, attrarg); break; case FST_AT_PACK: if ((subtype < FST_PT_NONE) || (subtype > FST_PT_MAX)) subtype = FST_PT_NONE; fprintf(fv, "$attrbegin %s %s %s %" PRId64 " $end\n", attrtypes[attrtype], packtypes[subtype], str, attrarg); break; case FST_AT_MISC: default: attrtype = FST_AT_MISC; if (subtype == FST_MT_COMMENT) { fprintf(fv, "$comment\n\t%s\n$end\n", str); } else { if ((subtype == FST_MT_SOURCESTEM) || (subtype == FST_MT_SOURCEISTEM)) { int sidx_skiplen_dummy = 0; uint64_t sidx = fstGetVarint64((unsigned char *)str, &sidx_skiplen_dummy); fprintf(fv, "$attrbegin %s %02x %" PRId64 " %" PRId64 " $end\n", attrtypes[attrtype], subtype, sidx, attrarg); } else { fprintf(fv, "$attrbegin %s %02x %s %" PRId64 " $end\n", attrtypes[attrtype], subtype, str, attrarg); } } break; } } break; case FST_ST_GEN_ATTREND: if (fv && xc->use_vcd_extensions) fprintf(fv, "$attrend $end\n"); break; case FST_VT_VCD_EVENT: case FST_VT_VCD_INTEGER: case FST_VT_VCD_PARAMETER: case FST_VT_VCD_REAL: case FST_VT_VCD_REAL_PARAMETER: case FST_VT_VCD_REG: case FST_VT_VCD_SUPPLY0: case FST_VT_VCD_SUPPLY1: case FST_VT_VCD_TIME: case FST_VT_VCD_TRI: case FST_VT_VCD_TRIAND: case FST_VT_VCD_TRIOR: case FST_VT_VCD_TRIREG: case FST_VT_VCD_TRI0: case FST_VT_VCD_TRI1: case FST_VT_VCD_WAND: case FST_VT_VCD_WIRE: case FST_VT_VCD_WOR: case FST_VT_VCD_PORT: case FST_VT_VCD_SPARRAY: case FST_VT_VCD_REALTIME: case FST_VT_GEN_STRING: case FST_VT_SV_BIT: case FST_VT_SV_LOGIC: case FST_VT_SV_INT: case FST_VT_SV_SHORTINT: case FST_VT_SV_LONGINT: case FST_VT_SV_BYTE: case FST_VT_SV_ENUM: case FST_VT_SV_SHORTREAL: vartype = tag; /* vardir = */ fgetc( xc->fh); /* unused in VCD reader, but need to advance read pointer */ pnt = str; cl = 0; while ((ch = fgetc(xc->fh))) { if (cl < FST_ID_NAM_ATTR_SIZ) { pnt[cl++] = ch; } }; /* varname */ pnt[cl] = 0; len = fstReaderVarint32(xc->fh); alias = fstReaderVarint32(xc->fh); if (!alias) { if (xc->maxhandle == num_signal_dyn) { num_signal_dyn *= 2; xc->signal_lens = (uint32_t *)realloc(xc->signal_lens, num_signal_dyn * sizeof(uint32_t)); xc->signal_typs = (unsigned char *)realloc(xc->signal_typs, num_signal_dyn * sizeof(unsigned char)); } xc->signal_lens[xc->maxhandle] = len; xc->signal_typs[xc->maxhandle] = vartype; /* maxvalpos+=len; */ if (len > xc->longest_signal_value_len) { xc->longest_signal_value_len = len; } if ((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) { len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; } if (fv) { char vcdid_buf[16]; uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); fstVcdID(vcdid_buf, xc->maxhandle + 1); fprintf(fv, "$var %s %" PRIu32 " %s %s $end\n", vartypes[vartype], modlen, vcdid_buf, str); } xc->maxhandle++; } else { if ((vartype == FST_VT_VCD_REAL) || (vartype == FST_VT_VCD_REAL_PARAMETER) || (vartype == FST_VT_VCD_REALTIME) || (vartype == FST_VT_SV_SHORTREAL)) { len = (vartype != FST_VT_SV_SHORTREAL) ? 64 : 32; xc->signal_typs[xc->maxhandle] = FST_VT_VCD_REAL; } if (fv) { char vcdid_buf[16]; uint32_t modlen = (vartype != FST_VT_VCD_PORT) ? len : ((len - 2) / 3); fstVcdID(vcdid_buf, alias); fprintf(fv, "$var %s %" PRIu32 " %s %s $end\n", vartypes[vartype], modlen, vcdid_buf, str); } xc->num_alias++; } break; default: break; } } if (fv) fprintf(fv, "$enddefinitions $end\n"); maxhandle_scanbuild = xc->maxhandle ? xc->maxhandle : 1; /*scan-build warning suppression, in reality we have at least one signal */ xc->signal_lens = (uint32_t *)realloc(xc->signal_lens, maxhandle_scanbuild * sizeof(uint32_t)); xc->signal_typs = (unsigned char *)realloc(xc->signal_typs, maxhandle_scanbuild * sizeof(unsigned char)); free(xc->process_mask); xc->process_mask = (unsigned char *)calloc(1, (maxhandle_scanbuild + 7) / 8); free(xc->temp_signal_value_buf); xc->temp_signal_value_buf = (unsigned char *)malloc(xc->longest_signal_value_len + 1); xc->var_count = xc->maxhandle + xc->num_alias; free(str); return (1); } /* * reader file open/close functions */ int fstReaderInit(struct fstReaderContext *xc) { fst_off_t blkpos = 0; fst_off_t endfile; uint64_t seclen; int sectype; uint64_t vc_section_count_actual = 0; int hdr_incomplete = 0; int hdr_seen = 0; int gzread_pass_status = 1; sectype = fgetc(xc->f); if (sectype == FST_BL_ZWRAPPER) { FILE *fcomp; fst_off_t offpnt, uclen; char gz_membuf[FST_GZIO_LEN]; gzFile zhandle; int zfd; int flen = strlen(xc->filename); char *hf; int hf_len; seclen = fstReaderUint64(xc->f); uclen = fstReaderUint64(xc->f); if (!seclen) return (0); /* not finished compressing, this is a failed read */ hf_len = flen + 16 + 32 + 1; hf = (char *)calloc(1, hf_len); snprintf(hf, hf_len, "%s.upk_%d_%p", xc->filename, getpid(), (void *)xc); fcomp = fopen(hf, "w+b"); if (!fcomp) { fcomp = tmpfile_open(&xc->f_nam); free(hf); hf = NULL; if (!fcomp) { tmpfile_close(&fcomp, &xc->f_nam); return (0); } } #if defined(FST_UNBUFFERED_IO) setvbuf(fcomp, (char *)NULL, _IONBF, 0); /* keeps gzip from acting weird in tandem with fopen */ #endif #ifdef __MINGW32__ xc->filename_unpacked = hf; #else if (hf) { unlink(hf); free(hf); } #endif fstReaderFseeko(xc, xc->f, FST_ZWRAPPER_HDR_SIZE, SEEK_SET); #ifndef __MINGW32__ fflush(xc->f); #else /* Windows UCRT runtime library reads one byte ahead in the file even with buffering disabled and does not synchronise the file position after fseek. */ _lseek(fileno(xc->f), FST_ZWRAPPER_HDR_SIZE, SEEK_SET); #endif zfd = dup(fileno(xc->f)); zhandle = gzdopen(zfd, "rb"); if (zhandle) { for (offpnt = 0; offpnt < uclen; offpnt += FST_GZIO_LEN) { size_t this_len = ((uclen - offpnt) > FST_GZIO_LEN) ? FST_GZIO_LEN : (uclen - offpnt); size_t gzreadlen = gzread(zhandle, gz_membuf, this_len); size_t fwlen; if (gzreadlen != this_len) { gzread_pass_status = 0; break; } fwlen = fstFwrite(gz_membuf, this_len, 1, fcomp); if (fwlen != 1) { gzread_pass_status = 0; break; } } gzclose(zhandle); } else { close(zfd); } fflush(fcomp); fclose(xc->f); xc->f = fcomp; } if (gzread_pass_status) { fstReaderFseeko(xc, xc->f, 0, SEEK_END); endfile = ftello(xc->f); while (blkpos < endfile) { fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); if (sectype == EOF) { break; } if ((hdr_incomplete) && (!seclen)) { break; } if (!hdr_seen && (sectype != FST_BL_HDR)) { break; } blkpos++; if (sectype == FST_BL_HDR) { if (!hdr_seen) { int ch; double dcheck; xc->start_time = fstReaderUint64(xc->f); xc->end_time = fstReaderUint64(xc->f); hdr_incomplete = (xc->start_time == 0) && (xc->end_time == 0); fstFread(&dcheck, 8, 1, xc->f); xc->double_endian_match = (dcheck == FST_DOUBLE_ENDTEST); if (!xc->double_endian_match) { union { unsigned char rvs_buf[8]; double d; } vu; unsigned char *dcheck_alias = (unsigned char *)&dcheck; int rvs_idx; for (rvs_idx = 0; rvs_idx < 8; rvs_idx++) { vu.rvs_buf[rvs_idx] = dcheck_alias[7 - rvs_idx]; } if (vu.d != FST_DOUBLE_ENDTEST) { break; /* either corrupt file or wrong architecture (offset +33 also functions as matchword) */ } } hdr_seen = 1; xc->mem_used_by_writer = fstReaderUint64(xc->f); xc->scope_count = fstReaderUint64(xc->f); xc->var_count = fstReaderUint64(xc->f); xc->maxhandle = fstReaderUint64(xc->f); xc->num_alias = xc->var_count - xc->maxhandle; xc->vc_section_count = fstReaderUint64(xc->f); ch = fgetc(xc->f); xc->timescale = (signed char)ch; fstFread(xc->version, FST_HDR_SIM_VERSION_SIZE, 1, xc->f); xc->version[FST_HDR_SIM_VERSION_SIZE] = 0; fstFread(xc->date, FST_HDR_DATE_SIZE, 1, xc->f); xc->date[FST_HDR_DATE_SIZE] = 0; ch = fgetc(xc->f); xc->filetype = (unsigned char)ch; xc->timezero = fstReaderUint64(xc->f); } } else if ((sectype == FST_BL_VCDATA) || (sectype == FST_BL_VCDATA_DYN_ALIAS) || (sectype == FST_BL_VCDATA_DYN_ALIAS2)) { if (hdr_incomplete) { uint64_t bt = fstReaderUint64(xc->f); xc->end_time = fstReaderUint64(xc->f); if (!vc_section_count_actual) { xc->start_time = bt; } } vc_section_count_actual++; } else if (sectype == FST_BL_GEOM) { if (!hdr_incomplete) { uint64_t clen = seclen - 24; uint64_t uclen = fstReaderUint64(xc->f); unsigned char *ucdata = (unsigned char *)malloc(uclen); unsigned char *pnt = ucdata; unsigned int i; xc->contains_geom_section = 1; xc->maxhandle = fstReaderUint64(xc->f); xc->longest_signal_value_len = 32; /* arbitrarily set at 32...this is much longer than an expanded double */ free(xc->process_mask); xc->process_mask = (unsigned char *)calloc(1, (xc->maxhandle + 7) / 8); if (clen != uclen) { unsigned char *cdata = (unsigned char *)malloc(clen); unsigned long destlen = uclen; unsigned long sourcelen = clen; int rc; fstFread(cdata, clen, 1, xc->f); rc = uncompress(ucdata, &destlen, cdata, sourcelen); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderInit(), geom uncompress rc = %d, exiting.\n", rc); exit(255); } free(cdata); } else { fstFread(ucdata, uclen, 1, xc->f); } free(xc->signal_lens); xc->signal_lens = (uint32_t *)malloc(sizeof(uint32_t) * xc->maxhandle); free(xc->signal_typs); xc->signal_typs = (unsigned char *)malloc(sizeof(unsigned char) * xc->maxhandle); for (i = 0; i < xc->maxhandle; i++) { int skiplen; uint64_t val = fstGetVarint32(pnt, &skiplen); pnt += skiplen; if (val) { xc->signal_lens[i] = (val != 0xFFFFFFFF) ? val : 0; xc->signal_typs[i] = FST_VT_VCD_WIRE; if (xc->signal_lens[i] > xc->longest_signal_value_len) { xc->longest_signal_value_len = xc->signal_lens[i]; } } else { xc->signal_lens[i] = 8; /* backpatch in real */ xc->signal_typs[i] = FST_VT_VCD_REAL; /* xc->longest_signal_value_len handled above by overly large init size */ } } free(xc->temp_signal_value_buf); xc->temp_signal_value_buf = (unsigned char *)malloc(xc->longest_signal_value_len + 1); free(ucdata); } } else if (sectype == FST_BL_HIER) { xc->contains_hier_section = 1; xc->hier_pos = ftello(xc->f); } else if (sectype == FST_BL_HIER_LZ4DUO) { xc->contains_hier_section_lz4 = 1; xc->contains_hier_section_lz4duo = 1; xc->hier_pos = ftello(xc->f); } else if (sectype == FST_BL_HIER_LZ4) { xc->contains_hier_section_lz4 = 1; xc->hier_pos = ftello(xc->f); } else if (sectype == FST_BL_BLACKOUT) { uint32_t i; uint64_t cur_bl = 0; uint64_t delta; xc->num_blackouts = fstReaderVarint32(xc->f); free(xc->blackout_times); xc->blackout_times = (uint64_t *)calloc(xc->num_blackouts, sizeof(uint64_t)); free(xc->blackout_activity); xc->blackout_activity = (unsigned char *)calloc(xc->num_blackouts, sizeof(unsigned char)); for (i = 0; i < xc->num_blackouts; i++) { xc->blackout_activity[i] = fgetc(xc->f) != 0; delta = fstReaderVarint64(xc->f); cur_bl += delta; xc->blackout_times[i] = cur_bl; } } blkpos += seclen; if (!hdr_seen) break; } if (hdr_seen) { if (xc->vc_section_count != vc_section_count_actual) { xc->vc_section_count = vc_section_count_actual; } if (!xc->contains_geom_section) { fstReaderProcessHier(xc, NULL); /* recreate signal_lens/signal_typs info */ } } } return (hdr_seen); } fstReaderContext *fstReaderOpenForUtilitiesOnly(void) { fstReaderContext *xc = (fstReaderContext *)calloc(1, sizeof(fstReaderContext)); return (xc); } fstReaderContext *fstReaderOpen(const char *nam) { fstReaderContext *xc = (fstReaderContext *)calloc(1, sizeof(fstReaderContext)); if ((!nam) || (!(xc->f = fopen(nam, "rb")))) { free(xc); xc = NULL; } else { int flen = strlen(nam); char *hf = (char *)calloc(1, flen + 6); int rc; #if defined(FST_UNBUFFERED_IO) setvbuf(xc->f, (char *)NULL, _IONBF, 0); /* keeps gzip from acting weird in tandem with fopen */ #endif memcpy(hf, nam, flen); strcpy(hf + flen, ".hier"); xc->fh = fopen(hf, "rb"); free(hf); xc->filename = strdup(nam); rc = fstReaderInit(xc); if ((rc) && (xc->vc_section_count) && (xc->maxhandle) && ((xc->fh) || (xc->contains_hier_section || (xc->contains_hier_section_lz4)))) { /* more init */ xc->do_rewind = 1; } else { fstReaderClose(xc); xc = NULL; } } return (xc); } static void fstReaderDeallocateRvatData(fstReaderContext *xc) { if (xc) { free(xc->rvat_chain_mem); xc->rvat_chain_mem = NULL; free(xc->rvat_frame_data); xc->rvat_frame_data = NULL; free(xc->rvat_time_table); xc->rvat_time_table = NULL; free(xc->rvat_chain_table); xc->rvat_chain_table = NULL; free(xc->rvat_chain_table_lengths); xc->rvat_chain_table_lengths = NULL; xc->rvat_data_valid = 0; } } void fstReaderClose(fstReaderContext *xc) { if (xc) { fstReaderDeallocateScopeData(xc); fstReaderDeallocateRvatData(xc); free(xc->rvat_sig_offs); xc->rvat_sig_offs = NULL; free(xc->process_mask); xc->process_mask = NULL; free(xc->blackout_times); xc->blackout_times = NULL; free(xc->blackout_activity); xc->blackout_activity = NULL; free(xc->temp_signal_value_buf); xc->temp_signal_value_buf = NULL; free(xc->signal_typs); xc->signal_typs = NULL; free(xc->signal_lens); xc->signal_lens = NULL; free(xc->filename); xc->filename = NULL; free(xc->str_scope_attr); xc->str_scope_attr = NULL; if (xc->fh) { tmpfile_close(&xc->fh, &xc->fh_nam); } if (xc->f) { tmpfile_close(&xc->f, &xc->f_nam); if (xc->filename_unpacked) { unlink(xc->filename_unpacked); free(xc->filename_unpacked); } } free(xc); } } /* * read processing */ /* normal read which re-interleaves the value change data */ int fstReaderIterBlocks(fstReaderContext *ctx, void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), void *user_callback_data_pointer, FILE *fv) { return (fstReaderIterBlocks2(ctx, value_change_callback, NULL, user_callback_data_pointer, fv)); } int fstReaderIterBlocks2(fstReaderContext *ctx, void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len), void *user_callback_data_pointer, FILE *fv) { struct fstReaderContext *xc = (struct fstReaderContext *)ctx; uint64_t previous_time = UINT64_MAX; uint64_t *time_table = NULL; uint64_t tsec_nitems; unsigned int secnum = 0; int blocks_skipped = 0; fst_off_t blkpos = 0; uint64_t seclen, beg_tim; uint64_t end_tim; uint64_t frame_uclen, frame_clen, frame_maxhandle, vc_maxhandle; fst_off_t vc_start; fst_off_t indx_pntr, indx_pos; fst_off_t *chain_table = NULL; uint32_t *chain_table_lengths = NULL; unsigned char *chain_cmem; unsigned char *pnt; long chain_clen; fstHandle idx, pidx = 0, i; uint64_t pval; uint64_t vc_maxhandle_largest = 0; uint64_t tsec_uclen = 0, tsec_clen = 0; int sectype; uint64_t mem_required_for_traversal; unsigned char *mem_for_traversal = NULL; uint32_t traversal_mem_offs; uint32_t *scatterptr, *headptr, *length_remaining; uint32_t cur_blackout = 0; int packtype; unsigned char *mc_mem = NULL; uint32_t mc_mem_len; /* corresponds to largest value encountered in chain_table_lengths[i] */ int dumpvars_state = 0; if (!xc) return (0); scatterptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); headptr = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); length_remaining = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); if (fv) { #ifndef FST_WRITEX_DISABLE fflush(fv); setvbuf(fv, (char *)NULL, _IONBF, 0); /* even buffered IO is slow so disable it and use our own routines that don't need seeking */ xc->writex_fd = fileno(fv); #endif } for (;;) { uint32_t *tc_head = NULL; uint32_t tc_head_items = 0; traversal_mem_offs = 0; fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); if ((sectype == EOF) || (sectype == FST_BL_SKIP)) { #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "<< EOF >>\n"); #endif break; } blkpos++; if ((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && (sectype != FST_BL_VCDATA_DYN_ALIAS2)) { blkpos += seclen; continue; } if (!seclen) break; beg_tim = fstReaderUint64(xc->f); end_tim = fstReaderUint64(xc->f); if (xc->limit_range_valid) { if (end_tim < xc->limit_range_start) { blocks_skipped++; blkpos += seclen; continue; } if (beg_tim > xc->limit_range_end) /* likely the compare in for(i=0;if) + 66; /* add in potential fastlz overhead */ mem_for_traversal = (unsigned char *)malloc(mem_required_for_traversal); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "sec: %u seclen: %d begtim: %d endtim: %d\n", secnum, (int)seclen, (int)beg_tim, (int)end_tim); fprintf(stderr, FST_APIMESS "mem_required_for_traversal: %d\n", (int)mem_required_for_traversal - 66); #endif /* process time block */ { unsigned char *ucdata; unsigned char *cdata; unsigned long destlen /* = tsec_uclen */; /* scan-build */ unsigned long sourcelen /*= tsec_clen */; /* scan-build */ int rc; unsigned char *tpnt; uint64_t tpval; unsigned int ti; if (fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET) != 0) break; tsec_uclen = fstReaderUint64(xc->f); tsec_clen = fstReaderUint64(xc->f); tsec_nitems = fstReaderUint64(xc->f); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "time section unc: %d, com: %d (%d items)\n", (int)tsec_uclen, (int)tsec_clen, (int)tsec_nitems); #endif if (tsec_clen > seclen) break; /* corrupted tsec_clen: by definition it can't be larger than size of section */ ucdata = (unsigned char *)malloc(tsec_uclen); if (!ucdata) break; /* malloc fail as tsec_uclen out of range from corrupted file */ destlen = tsec_uclen; sourcelen = tsec_clen; fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); if (tsec_uclen != tsec_clen) { cdata = (unsigned char *)malloc(tsec_clen); fstFread(cdata, tsec_clen, 1, xc->f); rc = uncompress(ucdata, &destlen, cdata, sourcelen); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderIterBlocks2(), tsec uncompress rc = %d, exiting.\n", rc); exit(255); } free(cdata); } else { fstFread(ucdata, tsec_uclen, 1, xc->f); } free(time_table); if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1792 for 32b overflow */ uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); size_t chk_32 = ((size_t)tsec_nitems) * sizeof(uint64_t); if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1792"); } else { uint64_t chk_64 = tsec_nitems * sizeof(uint64_t); if ((chk_64 / sizeof(uint64_t)) != tsec_nitems) { chk_report_abort("TALOS-2023-1792"); } } time_table = (uint64_t *)calloc(tsec_nitems, sizeof(uint64_t)); tpnt = ucdata; tpval = 0; for (ti = 0; ti < tsec_nitems; ti++) { int skiplen; uint64_t val = fstGetVarint64(tpnt, &skiplen); tpval = time_table[ti] = tpval + val; tpnt += skiplen; } tc_head_items = tsec_nitems /* scan-build */ ? tsec_nitems : 1; if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1792 for 32b overflow */ uint64_t chk_64 = tc_head_items * sizeof(uint32_t); size_t chk_32 = ((size_t)tc_head_items) * sizeof(uint32_t); if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1792"); } else { uint64_t chk_64 = tc_head_items * sizeof(uint32_t); if ((chk_64 / sizeof(uint32_t)) != tc_head_items) { chk_report_abort("TALOS-2023-1792"); } } tc_head = (uint32_t *)calloc(tc_head_items, sizeof(uint32_t)); free(ucdata); } fstReaderFseeko(xc, xc->f, blkpos + 32, SEEK_SET); frame_uclen = fstReaderVarint64(xc->f); frame_clen = fstReaderVarint64(xc->f); frame_maxhandle = fstReaderVarint64(xc->f); if (secnum == 0) { if ((beg_tim != time_table[0]) || (blocks_skipped)) { unsigned char *mu = (unsigned char *)malloc(frame_uclen); uint32_t sig_offs = 0; if (fv) { char wx_buf[32]; int wx_len; if (beg_tim) { if (dumpvars_state == 1) { wx_len = snprintf(wx_buf, 32, "$end\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 2; } wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", beg_tim); fstWritex(xc, wx_buf, wx_len); if (!dumpvars_state) { wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 1; } } if ((xc->num_blackouts) && (cur_blackout != xc->num_blackouts)) { if (beg_tim == xc->blackout_times[cur_blackout]) { wx_len = snprintf(wx_buf, 32, "$dump%s $end\n", (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); fstWritex(xc, wx_buf, wx_len); } } } if (frame_uclen == frame_clen) { fstFread(mu, frame_uclen, 1, xc->f); } else { unsigned char *mc = (unsigned char *)malloc(frame_clen); int rc; unsigned long destlen = frame_uclen; unsigned long sourcelen = frame_clen; fstFread(mc, sourcelen, 1, xc->f); rc = uncompress(mu, &destlen, mc, sourcelen); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderIterBlocks2(), frame uncompress rc: %d, exiting.\n", rc); exit(255); } free(mc); } for (idx = 0; idx < frame_maxhandle; idx++) { int process_idx = idx / 8; int process_bit = idx & 7; if (xc->process_mask[process_idx] & (1 << process_bit)) { if (xc->signal_lens[idx] <= 1) { if (xc->signal_lens[idx] == 1) { unsigned char val = mu[sig_offs]; if (value_change_callback) { xc->temp_signal_value_buf[0] = val; xc->temp_signal_value_buf[1] = 0; value_change_callback(user_callback_data_pointer, beg_tim, idx + 1, xc->temp_signal_value_buf); } else { if (fv) { char vcd_id[16]; int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); vcd_id[0] = val; /* collapse 3 writes into one I/O call */ vcd_id[vcdid_len + 1] = '\n'; fstWritex(xc, vcd_id, vcdid_len + 2); } } } else { /* variable-length ("0" length) records have no initial state */ } } else { if (xc->signal_typs[idx] != FST_VT_VCD_REAL) { if (value_change_callback) { if (xc->signal_lens[idx] > xc->longest_signal_value_len) { chk_report_abort("TALOS-2023-1797"); } memcpy(xc->temp_signal_value_buf, mu + sig_offs, xc->signal_lens[idx]); xc->temp_signal_value_buf[xc->signal_lens[idx]] = 0; value_change_callback(user_callback_data_pointer, beg_tim, idx + 1, xc->temp_signal_value_buf); } else { if (fv) { char vcd_id[16]; int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); vcd_id[0] = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; fstWritex(xc, vcd_id, 1); if ((sig_offs + xc->signal_lens[idx]) > frame_uclen) { chk_report_abort("TALOS-2023-1793"); } fstWritex(xc, mu + sig_offs, xc->signal_lens[idx]); vcd_id[0] = ' '; /* collapse 3 writes into one I/O call */ vcd_id[vcdid_len + 1] = '\n'; fstWritex(xc, vcd_id, vcdid_len + 2); } } } else { double d; unsigned char *clone_d; unsigned char *srcdata = mu + sig_offs; if (value_change_callback) { if (xc->native_doubles_for_cb) { if (xc->double_endian_match) { clone_d = srcdata; } else { int j; clone_d = (unsigned char *)&d; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } value_change_callback(user_callback_data_pointer, beg_tim, idx + 1, clone_d); } else { clone_d = (unsigned char *)&d; if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } snprintf((char *)xc->temp_signal_value_buf, xc->longest_signal_value_len + 1, "%.16g", d); value_change_callback(user_callback_data_pointer, beg_tim, idx + 1, xc->temp_signal_value_buf); } } else { if (fv) { char vcdid_buf[16]; char wx_buf[64]; int wx_len; clone_d = (unsigned char *)&d; if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } fstVcdID(vcdid_buf, idx + 1); wx_len = snprintf(wx_buf, 64, "r%.16g %s\n", d, vcdid_buf); fstWritex(xc, wx_buf, wx_len); } } } } } sig_offs += xc->signal_lens[idx]; } free(mu); fstReaderFseeko(xc, xc->f, -((fst_off_t)frame_clen), SEEK_CUR); } } fstReaderFseeko(xc, xc->f, (fst_off_t)frame_clen, SEEK_CUR); /* skip past compressed data */ vc_maxhandle = fstReaderVarint64(xc->f); vc_start = ftello(xc->f); /* points to '!' character */ packtype = fgetc(xc->f); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", (int)frame_uclen, (int)frame_clen, (int)frame_maxhandle); fprintf(stderr, FST_APIMESS "vc_maxhandle: %d, packtype: %c\n", (int)vc_maxhandle, packtype); #endif indx_pntr = blkpos + seclen - 24 - tsec_clen - 8; fstReaderFseeko(xc, xc->f, indx_pntr, SEEK_SET); chain_clen = fstReaderUint64(xc->f); indx_pos = indx_pntr - chain_clen; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "indx_pos: %d (%d bytes)\n", (int)indx_pos, (int)chain_clen); #endif chain_cmem = (unsigned char *)malloc(chain_clen); if (!chain_cmem) goto block_err; fstReaderFseeko(xc, xc->f, indx_pos, SEEK_SET); fstFread(chain_cmem, chain_clen, 1, xc->f); if (vc_maxhandle > vc_maxhandle_largest) { free(chain_table); free(chain_table_lengths); vc_maxhandle_largest = vc_maxhandle; if (!(vc_maxhandle + 1)) { chk_report_abort("TALOS-2023-1798"); } if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1798 for 32b overflow */ uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(fst_off_t); size_t chk_32 = ((size_t)(vc_maxhandle + 1)) * sizeof(fst_off_t); if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1798"); } else { uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(fst_off_t); if ((chk_64 / sizeof(fst_off_t)) != (vc_maxhandle + 1)) { chk_report_abort("TALOS-2023-1798"); } } chain_table = (fst_off_t *)calloc((vc_maxhandle + 1), sizeof(fst_off_t)); if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1798 for 32b overflow */ uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(uint32_t); size_t chk_32 = ((size_t)(vc_maxhandle + 1)) * sizeof(uint32_t); if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1798"); } else { uint64_t chk_64 = (vc_maxhandle + 1) * sizeof(uint32_t); if ((chk_64 / sizeof(uint32_t)) != (vc_maxhandle + 1)) { chk_report_abort("TALOS-2023-1798"); } } chain_table_lengths = (uint32_t *)calloc((vc_maxhandle + 1), sizeof(uint32_t)); } if (!chain_table || !chain_table_lengths) goto block_err; pnt = chain_cmem; idx = 0; pval = 0; if (sectype == FST_BL_VCDATA_DYN_ALIAS2) { uint32_t prev_alias = 0; do { int skiplen; if (*pnt & 0x01) { int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; if (shval > 0) { pval = chain_table[idx] = pval + shval; if (idx) { chain_table_lengths[pidx] = pval - chain_table[pidx]; } pidx = idx++; } else if (shval < 0) { chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ chain_table_lengths[idx] = prev_alias = shval; /* because during this loop iter would give stale data! */ idx++; } else { chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ chain_table_lengths[idx] = prev_alias; /* because during this loop iter would give stale data! */ idx++; } } else { uint64_t val = fstGetVarint32(pnt, &skiplen); fstHandle loopcnt = val >> 1; if ((idx + loopcnt - 1) > vc_maxhandle) /* TALOS-2023-1789 */ { chk_report_abort("TALOS-2023-1789"); } for (i = 0; i < loopcnt; i++) { chain_table[idx++] = 0; } } pnt += skiplen; } while (pnt != (chain_cmem + chain_clen)); } else { do { int skiplen; uint64_t val = fstGetVarint32(pnt, &skiplen); if (!val) { pnt += skiplen; val = fstGetVarint32(pnt, &skiplen); chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ chain_table_lengths[idx] = -val; /* because during this loop iter would give stale data! */ idx++; } else if (val & 1) { pval = chain_table[idx] = pval + (val >> 1); if (idx) { chain_table_lengths[pidx] = pval - chain_table[pidx]; } pidx = idx++; } else { fstHandle loopcnt = val >> 1; if ((idx + loopcnt - 1) > vc_maxhandle) /* TALOS-2023-1789 */ { chk_report_abort("TALOS-2023-1789"); } for (i = 0; i < loopcnt; i++) { chain_table[idx++] = 0; } } pnt += skiplen; } while (pnt != (chain_cmem + chain_clen)); } chain_table[idx] = indx_pos - vc_start; chain_table_lengths[pidx] = chain_table[idx] - chain_table[pidx]; for (i = 0; i < idx; i++) { int32_t v32 = chain_table_lengths[i]; if ((v32 < 0) && (!chain_table[i])) { v32 = -v32; v32--; if (((uint32_t)v32) < i) /* sanity check */ { chain_table[i] = chain_table[v32]; chain_table_lengths[i] = chain_table_lengths[v32]; } } } #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "decompressed chain idx len: %" PRIu32 "\n", idx); #endif mc_mem_len = 16384; mc_mem = (unsigned char *)malloc(mc_mem_len); /* buffer for compressed reads */ /* check compressed VC data */ if (idx > xc->maxhandle) idx = xc->maxhandle; for (i = 0; i < idx; i++) { if (chain_table[i]) { int process_idx = i / 8; int process_bit = i & 7; if (xc->process_mask[process_idx] & (1 << process_bit)) { int rc = Z_OK; uint32_t val; uint32_t skiplen; uint32_t tdelta; fstReaderFseeko(xc, xc->f, vc_start + chain_table[i], SEEK_SET); val = fstReaderVarint32WithSkip(xc->f, &skiplen); if (val) { unsigned char *mu = mem_for_traversal + traversal_mem_offs; /* uncomp: dst */ unsigned char *mc; /* comp: src */ unsigned long destlen = val; unsigned long sourcelen = chain_table_lengths[i]; if (traversal_mem_offs >= mem_required_for_traversal) { chk_report_abort("TALOS-2023-1785"); } if (mc_mem_len < chain_table_lengths[i]) { free(mc_mem); mc_mem = (unsigned char *)malloc(mc_mem_len = chain_table_lengths[i]); } mc = mc_mem; fstFread(mc, chain_table_lengths[i], 1, xc->f); switch (packtype) { case '4': rc = (destlen == (unsigned long)LZ4_decompress_safe_partial((char *)mc, (char *)mu, sourcelen, destlen, destlen)) ? Z_OK : Z_DATA_ERROR; break; case 'F': fastlz_decompress(mc, sourcelen, mu, destlen); /* rc appears unreliable */ break; default: rc = uncompress(mu, &destlen, mc, sourcelen); break; } /* data to process is for(j=0;j= mem_required_for_traversal) { chk_report_abort("TALOS-2023-1785"); } fstFread(mu, destlen, 1, xc->f); /* data to process is for(j=0;jsignal_lens[i] == 1) { uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); uint32_t shcnt = 2 << (vli & 1); tdelta = vli >> shcnt; } else { uint32_t vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[i]); tdelta = vli >> 1; } if (tdelta >= tc_head_items) { chk_report_abort("TALOS-2023-1791"); } scatterptr[i] = tc_head[tdelta]; tc_head[tdelta] = i + 1; } } } free(mc_mem); /* there is no usage below for this, no real need to clear out mc_mem or mc_mem_len */ for (i = 0; i < tsec_nitems; i++) { uint32_t tdelta; int skiplen, skiplen2; uint32_t vli; if (fv) { char wx_buf[32]; int wx_len; if (time_table[i] != previous_time) { if (xc->limit_range_valid) { if (time_table[i] > xc->limit_range_end) { break; } } if (dumpvars_state == 1) { wx_len = snprintf(wx_buf, 32, "$end\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 2; } wx_len = snprintf(wx_buf, 32, "#%" PRIu64 "\n", time_table[i]); fstWritex(xc, wx_buf, wx_len); if (!dumpvars_state) { wx_len = snprintf(wx_buf, 32, "$dumpvars\n"); fstWritex(xc, wx_buf, wx_len); dumpvars_state = 1; } if ((xc->num_blackouts) && (cur_blackout != xc->num_blackouts)) { if (time_table[i] == xc->blackout_times[cur_blackout]) { wx_len = snprintf(wx_buf, 32, "$dump%s $end\n", (xc->blackout_activity[cur_blackout++]) ? "on" : "off"); fstWritex(xc, wx_buf, wx_len); } } previous_time = time_table[i]; } } while (tc_head[i]) { idx = tc_head[i] - 1; vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); if (xc->signal_lens[idx] <= 1) { if (xc->signal_lens[idx] == 1) { unsigned char val; if (!(vli & 1)) { /* tdelta = vli >> 2; */ /* scan-build */ val = ((vli >> 1) & 1) | '0'; } else { /* tdelta = vli >> 4; */ /* scan-build */ val = FST_RCV_STR[((vli >> 1) & 7)]; } if (value_change_callback) { xc->temp_signal_value_buf[0] = val; xc->temp_signal_value_buf[1] = 0; value_change_callback(user_callback_data_pointer, time_table[i], idx + 1, xc->temp_signal_value_buf); } else { if (fv) { char vcd_id[16]; int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); vcd_id[0] = val; vcd_id[vcdid_len + 1] = '\n'; fstWritex(xc, vcd_id, vcdid_len + 2); } } headptr[idx] += skiplen; length_remaining[idx] -= skiplen; tc_head[i] = scatterptr[idx]; scatterptr[idx] = 0; if (length_remaining[idx]) { int shamt; vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); shamt = 2 << (vli & 1); tdelta = vli >> shamt; if ((tdelta + i) >= tc_head_items) { chk_report_abort("TALOS-2023-1791"); } scatterptr[idx] = tc_head[i + tdelta]; tc_head[i + tdelta] = idx + 1; } } else { unsigned char *vdata; uint32_t len; vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); len = fstGetVarint32(mem_for_traversal + headptr[idx] + skiplen, &skiplen2); /* tdelta = vli >> 1; */ /* scan-build */ skiplen += skiplen2; vdata = mem_for_traversal + headptr[idx] + skiplen; if (!(vli & 1)) { if (value_change_callback_varlen) { value_change_callback_varlen(user_callback_data_pointer, time_table[i], idx + 1, vdata, len); } else { if (fv) { char vcd_id[16]; int vcdid_len; vcd_id[0] = 's'; fstWritex(xc, vcd_id, 1); vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); { if (sizeof(size_t) < sizeof(uint64_t)) { /* TALOS-2023-1790 for 32b overflow */ uint64_t chk_64 = len * 4 + 1; size_t chk_32 = len * 4 + 1; if (chk_64 != chk_32) chk_report_abort("TALOS-2023-1790"); } unsigned char *vesc = (unsigned char *)malloc(len * 4 + 1); int vlen = fstUtilityBinToEsc(vesc, vdata, len); fstWritex(xc, vesc, vlen); free(vesc); } vcd_id[0] = ' '; vcd_id[vcdid_len + 1] = '\n'; fstWritex(xc, vcd_id, vcdid_len + 2); } } } skiplen += len; headptr[idx] += skiplen; length_remaining[idx] -= skiplen; tc_head[i] = scatterptr[idx]; scatterptr[idx] = 0; if (length_remaining[idx]) { vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); tdelta = vli >> 1; if ((tdelta + i) >= tc_head_items) { chk_report_abort("TALOS-2023-1791"); } scatterptr[idx] = tc_head[i + tdelta]; tc_head[i + tdelta] = idx + 1; } } } else { uint32_t len = xc->signal_lens[idx]; unsigned char *vdata; vli = fstGetVarint32(mem_for_traversal + headptr[idx], &skiplen); /* tdelta = vli >> 1; */ /* scan-build */ vdata = mem_for_traversal + headptr[idx] + skiplen; if (xc->signal_typs[idx] != FST_VT_VCD_REAL) { if (len > xc->longest_signal_value_len) { chk_report_abort("TALOS-2023-1797"); } if (!(vli & 1)) { int byte = 0; int bit; unsigned int j; for (j = 0; j < len; j++) { unsigned char ch; byte = j / 8; bit = 7 - (j & 7); ch = ((vdata[byte] >> bit) & 1) | '0'; xc->temp_signal_value_buf[j] = ch; } xc->temp_signal_value_buf[j] = 0; if (value_change_callback) { value_change_callback(user_callback_data_pointer, time_table[i], idx + 1, xc->temp_signal_value_buf); } else { if (fv) { unsigned char ch_bp = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; fstWritex(xc, &ch_bp, 1); fstWritex(xc, xc->temp_signal_value_buf, len); } } len = byte + 1; } else { if (value_change_callback) { memcpy(xc->temp_signal_value_buf, vdata, len); xc->temp_signal_value_buf[len] = 0; value_change_callback(user_callback_data_pointer, time_table[i], idx + 1, xc->temp_signal_value_buf); } else { if (fv) { unsigned char ch_bp = (xc->signal_typs[idx] != FST_VT_VCD_PORT) ? 'b' : 'p'; uint64_t mem_required_for_traversal_chk = vdata - mem_for_traversal + len; fstWritex(xc, &ch_bp, 1); if (mem_required_for_traversal_chk > mem_required_for_traversal) { chk_report_abort("TALOS-2023-1793"); } fstWritex(xc, vdata, len); } } } } else { double d; unsigned char *clone_d /*= (unsigned char *)&d */; /* scan-build */ unsigned char buf[8]; unsigned char *srcdata; if (!(vli & 1)) /* very rare case, but possible */ { int bit; int j; for (j = 0; j < 8; j++) { unsigned char ch; bit = 7 - (j & 7); ch = ((vdata[0] >> bit) & 1) | '0'; buf[j] = ch; } len = 1; srcdata = buf; } else { srcdata = vdata; } if (value_change_callback) { if (xc->native_doubles_for_cb) { if (xc->double_endian_match) { clone_d = srcdata; } else { int j; clone_d = (unsigned char *)&d; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } value_change_callback(user_callback_data_pointer, time_table[i], idx + 1, clone_d); } else { clone_d = (unsigned char *)&d; if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } snprintf((char *)xc->temp_signal_value_buf, xc->longest_signal_value_len + 1, "%.16g", d); value_change_callback(user_callback_data_pointer, time_table[i], idx + 1, xc->temp_signal_value_buf); } } else { if (fv) { char wx_buf[32]; int wx_len; clone_d = (unsigned char *)&d; if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } wx_len = snprintf(wx_buf, 32, "r%.16g", d); fstWritex(xc, wx_buf, wx_len); } } } if (fv) { char vcd_id[16]; int vcdid_len = fstVcdIDForFwrite(vcd_id + 1, idx + 1); vcd_id[0] = ' '; vcd_id[vcdid_len + 1] = '\n'; fstWritex(xc, vcd_id, vcdid_len + 2); } skiplen += len; headptr[idx] += skiplen; length_remaining[idx] -= skiplen; tc_head[i] = scatterptr[idx]; scatterptr[idx] = 0; if (length_remaining[idx]) { vli = fstGetVarint32NoSkip(mem_for_traversal + headptr[idx]); tdelta = vli >> 1; if ((tdelta + i) >= tc_head_items) { chk_report_abort("TALOS-2023-1791"); } scatterptr[idx] = tc_head[i + tdelta]; tc_head[i + tdelta] = idx + 1; } } } } block_err: free(tc_head); free(chain_cmem); free(mem_for_traversal); mem_for_traversal = NULL; secnum++; if (secnum == xc->vc_section_count) break; /* in case file is growing, keep with original block count */ blkpos += seclen; } if (mem_for_traversal) free(mem_for_traversal); /* scan-build */ free(length_remaining); free(headptr); free(scatterptr); if (chain_table) free(chain_table); if (chain_table_lengths) free(chain_table_lengths); free(time_table); #ifndef FST_WRITEX_DISABLE if (fv) { fstWritex(xc, NULL, 0); } #endif return (1); } /* rvat functions */ static char *fstExtractRvatDataFromFrame(fstReaderContext *xc, fstHandle facidx, char *buf) { if (facidx >= xc->rvat_frame_maxhandle) { return (NULL); } if (xc->signal_lens[facidx] == 1) { buf[0] = (char)xc->rvat_frame_data[xc->rvat_sig_offs[facidx]]; buf[1] = 0; } else { if (xc->signal_typs[facidx] != FST_VT_VCD_REAL) { memcpy(buf, xc->rvat_frame_data + xc->rvat_sig_offs[facidx], xc->signal_lens[facidx]); buf[xc->signal_lens[facidx]] = 0; } else { double d; unsigned char *clone_d = (unsigned char *)&d; unsigned char *srcdata = xc->rvat_frame_data + xc->rvat_sig_offs[facidx]; if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } snprintf((char *)buf, 32, "%.16g", d); /* this will write 18 bytes */ } } return (buf); } char *fstReaderGetValueFromHandleAtTime(fstReaderContext *xc, uint64_t tim, fstHandle facidx, char *buf) { fst_off_t blkpos = 0, prev_blkpos; uint64_t beg_tim, end_tim, beg_tim2, end_tim2; int sectype; #ifdef FST_DEBUG unsigned int secnum = 0; #endif uint64_t seclen; uint64_t tsec_uclen = 0, tsec_clen = 0; uint64_t tsec_nitems; uint64_t frame_uclen, frame_clen; #ifdef FST_DEBUG uint64_t mem_required_for_traversal; #endif fst_off_t indx_pntr, indx_pos; long chain_clen; unsigned char *chain_cmem; unsigned char *pnt; fstHandle idx, pidx = 0, i; uint64_t pval; if ((!xc) || (!facidx) || (facidx > xc->maxhandle) || (!buf) || (!xc->signal_lens[facidx - 1])) { return (NULL); } if (!xc->rvat_sig_offs) { uint32_t cur_offs = 0; xc->rvat_sig_offs = (uint32_t *)calloc(xc->maxhandle, sizeof(uint32_t)); for (i = 0; i < xc->maxhandle; i++) { xc->rvat_sig_offs[i] = cur_offs; cur_offs += xc->signal_lens[i]; } } if (xc->rvat_data_valid) { if ((xc->rvat_beg_tim <= tim) && (tim <= xc->rvat_end_tim)) { goto process_value; } fstReaderDeallocateRvatData(xc); } xc->rvat_chain_pos_valid = 0; for (;;) { fstReaderFseeko(xc, xc->f, (prev_blkpos = blkpos), SEEK_SET); sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); if ((sectype == EOF) || (sectype == FST_BL_SKIP) || (!seclen)) { return (NULL); /* if this loop exits on break, it's successful */ } blkpos++; if ((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && (sectype != FST_BL_VCDATA_DYN_ALIAS2)) { blkpos += seclen; continue; } beg_tim = fstReaderUint64(xc->f); end_tim = fstReaderUint64(xc->f); if ((beg_tim <= tim) && (tim <= end_tim)) { if ((tim == end_tim) && (tim != xc->end_time)) { fst_off_t cached_pos = ftello(xc->f); fstReaderFseeko(xc, xc->f, blkpos, SEEK_SET); sectype = fgetc(xc->f); seclen = fstReaderUint64(xc->f); beg_tim2 = fstReaderUint64(xc->f); end_tim2 = fstReaderUint64(xc->f); if (((sectype != FST_BL_VCDATA) && (sectype != FST_BL_VCDATA_DYN_ALIAS) && (sectype != FST_BL_VCDATA_DYN_ALIAS2)) || (!seclen) || (beg_tim2 != tim)) { blkpos = prev_blkpos; break; } beg_tim = beg_tim2; end_tim = end_tim2; fstReaderFseeko(xc, xc->f, cached_pos, SEEK_SET); } break; } blkpos += seclen; #ifdef FST_DEBUG secnum++; #endif } xc->rvat_beg_tim = beg_tim; xc->rvat_end_tim = end_tim; #ifdef FST_DEBUG mem_required_for_traversal = #endif fstReaderUint64(xc->f); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "rvat sec: %u seclen: %d begtim: %d endtim: %d\n", secnum, (int)seclen, (int)beg_tim, (int)end_tim); fprintf(stderr, FST_APIMESS "mem_required_for_traversal: %d\n", (int)mem_required_for_traversal); #endif /* process time block */ { unsigned char *ucdata; unsigned char *cdata; unsigned long destlen /* = tsec_uclen */; /* scan-build */ unsigned long sourcelen /* = tsec_clen */; /* scan-build */ int rc; unsigned char *tpnt; uint64_t tpval; unsigned int ti; fstReaderFseeko(xc, xc->f, blkpos + seclen - 24, SEEK_SET); tsec_uclen = fstReaderUint64(xc->f); tsec_clen = fstReaderUint64(xc->f); tsec_nitems = fstReaderUint64(xc->f); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "time section unc: %d, com: %d (%d items)\n", (int)tsec_uclen, (int)tsec_clen, (int)tsec_nitems); #endif ucdata = (unsigned char *)malloc(tsec_uclen); destlen = tsec_uclen; sourcelen = tsec_clen; fstReaderFseeko(xc, xc->f, -24 - ((fst_off_t)tsec_clen), SEEK_CUR); if (tsec_uclen != tsec_clen) { cdata = (unsigned char *)malloc(tsec_clen); fstFread(cdata, tsec_clen, 1, xc->f); rc = uncompress(ucdata, &destlen, cdata, sourcelen); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), tsec uncompress rc = %d, exiting.\n", rc); exit(255); } free(cdata); } else { fstFread(ucdata, tsec_uclen, 1, xc->f); } xc->rvat_time_table = (uint64_t *)calloc(tsec_nitems, sizeof(uint64_t)); tpnt = ucdata; tpval = 0; for (ti = 0; ti < tsec_nitems; ti++) { int skiplen; uint64_t val = fstGetVarint64(tpnt, &skiplen); tpval = xc->rvat_time_table[ti] = tpval + val; tpnt += skiplen; } free(ucdata); } fstReaderFseeko(xc, xc->f, blkpos + 32, SEEK_SET); frame_uclen = fstReaderVarint64(xc->f); frame_clen = fstReaderVarint64(xc->f); xc->rvat_frame_maxhandle = fstReaderVarint64(xc->f); xc->rvat_frame_data = (unsigned char *)malloc(frame_uclen); if (frame_uclen == frame_clen) { fstFread(xc->rvat_frame_data, frame_uclen, 1, xc->f); } else { unsigned char *mc = (unsigned char *)malloc(frame_clen); int rc; unsigned long destlen = frame_uclen; unsigned long sourcelen = frame_clen; fstFread(mc, sourcelen, 1, xc->f); rc = uncompress(xc->rvat_frame_data, &destlen, mc, sourcelen); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), frame decompress rc: %d, exiting.\n", rc); exit(255); } free(mc); } xc->rvat_vc_maxhandle = fstReaderVarint64(xc->f); xc->rvat_vc_start = ftello(xc->f); /* points to '!' character */ xc->rvat_packtype = fgetc(xc->f); #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "frame_uclen: %d, frame_clen: %d, frame_maxhandle: %d\n", (int)frame_uclen, (int)frame_clen, (int)xc->rvat_frame_maxhandle); fprintf(stderr, FST_APIMESS "vc_maxhandle: %d\n", (int)xc->rvat_vc_maxhandle); #endif indx_pntr = blkpos + seclen - 24 - tsec_clen - 8; fstReaderFseeko(xc, xc->f, indx_pntr, SEEK_SET); chain_clen = fstReaderUint64(xc->f); indx_pos = indx_pntr - chain_clen; #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "indx_pos: %d (%d bytes)\n", (int)indx_pos, (int)chain_clen); #endif chain_cmem = (unsigned char *)malloc(chain_clen); fstReaderFseeko(xc, xc->f, indx_pos, SEEK_SET); fstFread(chain_cmem, chain_clen, 1, xc->f); xc->rvat_chain_table = (fst_off_t *)calloc((xc->rvat_vc_maxhandle + 1), sizeof(fst_off_t)); xc->rvat_chain_table_lengths = (uint32_t *)calloc((xc->rvat_vc_maxhandle + 1), sizeof(uint32_t)); pnt = chain_cmem; idx = 0; pval = 0; if (sectype == FST_BL_VCDATA_DYN_ALIAS2) { uint32_t prev_alias = 0; do { int skiplen; if (*pnt & 0x01) { int64_t shval = fstGetSVarint64(pnt, &skiplen) >> 1; if (shval > 0) { pval = xc->rvat_chain_table[idx] = pval + shval; if (idx) { xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; } pidx = idx++; } else if (shval < 0) { xc->rvat_chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ xc->rvat_chain_table_lengths[idx] = prev_alias = shval; /* because during this loop iter would give stale data! */ idx++; } else { xc->rvat_chain_table[idx] = 0; /* need to explicitly zero as calloc above might not run */ xc->rvat_chain_table_lengths[idx] = prev_alias; /* because during this loop iter would give stale data! */ idx++; } } else { uint64_t val = fstGetVarint32(pnt, &skiplen); fstHandle loopcnt = val >> 1; for (i = 0; i < loopcnt; i++) { xc->rvat_chain_table[idx++] = 0; } } pnt += skiplen; } while (pnt != (chain_cmem + chain_clen)); } else { do { int skiplen; uint64_t val = fstGetVarint32(pnt, &skiplen); if (!val) { pnt += skiplen; val = fstGetVarint32(pnt, &skiplen); xc->rvat_chain_table[idx] = 0; xc->rvat_chain_table_lengths[idx] = -val; idx++; } else if (val & 1) { pval = xc->rvat_chain_table[idx] = pval + (val >> 1); if (idx) { xc->rvat_chain_table_lengths[pidx] = pval - xc->rvat_chain_table[pidx]; } pidx = idx++; } else { fstHandle loopcnt = val >> 1; for (i = 0; i < loopcnt; i++) { xc->rvat_chain_table[idx++] = 0; } } pnt += skiplen; } while (pnt != (chain_cmem + chain_clen)); } free(chain_cmem); xc->rvat_chain_table[idx] = indx_pos - xc->rvat_vc_start; xc->rvat_chain_table_lengths[pidx] = xc->rvat_chain_table[idx] - xc->rvat_chain_table[pidx]; for (i = 0; i < idx; i++) { int32_t v32 = xc->rvat_chain_table_lengths[i]; if ((v32 < 0) && (!xc->rvat_chain_table[i])) { v32 = -v32; v32--; if (((uint32_t)v32) < i) /* sanity check */ { xc->rvat_chain_table[i] = xc->rvat_chain_table[v32]; xc->rvat_chain_table_lengths[i] = xc->rvat_chain_table_lengths[v32]; } } } #ifdef FST_DEBUG fprintf(stderr, FST_APIMESS "decompressed chain idx len: %" PRIu32 "\n", idx); #endif xc->rvat_data_valid = 1; /* all data at this point is loaded or resident in fst cache, process and return appropriate value */ process_value: if (facidx > xc->rvat_vc_maxhandle) { return (NULL); } facidx--; /* scale down for array which starts at zero */ if (((tim == xc->rvat_beg_tim) && (!xc->rvat_chain_table[facidx])) || (!xc->rvat_chain_table[facidx])) { return (fstExtractRvatDataFromFrame(xc, facidx, buf)); } if (facidx != xc->rvat_chain_facidx) { if (xc->rvat_chain_mem) { free(xc->rvat_chain_mem); xc->rvat_chain_mem = NULL; xc->rvat_chain_pos_valid = 0; } } if (!xc->rvat_chain_mem) { uint32_t skiplen; fstReaderFseeko(xc, xc->f, xc->rvat_vc_start + xc->rvat_chain_table[facidx], SEEK_SET); xc->rvat_chain_len = fstReaderVarint32WithSkip(xc->f, &skiplen); if (xc->rvat_chain_len) { unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len); unsigned char *mc = (unsigned char *)malloc(xc->rvat_chain_table_lengths[facidx]); unsigned long destlen = xc->rvat_chain_len; unsigned long sourcelen = xc->rvat_chain_table_lengths[facidx]; int rc = Z_OK; fstFread(mc, xc->rvat_chain_table_lengths[facidx], 1, xc->f); switch (xc->rvat_packtype) { case '4': rc = (destlen == (unsigned long)LZ4_decompress_safe_partial((char *)mc, (char *)mu, sourcelen, destlen, destlen)) ? Z_OK : Z_DATA_ERROR; break; case 'F': fastlz_decompress(mc, sourcelen, mu, destlen); /* rc appears unreliable */ break; default: rc = uncompress(mu, &destlen, mc, sourcelen); break; } free(mc); if (rc != Z_OK) { fprintf(stderr, FST_APIMESS "fstReaderGetValueFromHandleAtTime(), rvat decompress clen: %d " "(rc=%d), exiting.\n", (int)xc->rvat_chain_len, rc); exit(255); } /* data to process is for(j=0;jrvat_chain_mem = mu; } else { int destlen = xc->rvat_chain_table_lengths[facidx] - skiplen; unsigned char *mu = (unsigned char *)malloc(xc->rvat_chain_len = destlen); fstFread(mu, destlen, 1, xc->f); /* data to process is for(j=0;jrvat_chain_mem = mu; } xc->rvat_chain_facidx = facidx; } /* process value chain here */ { uint32_t tidx = 0, ptidx = 0; uint32_t tdelta; int skiplen; unsigned int iprev = xc->rvat_chain_len; uint32_t pvli = 0; int pskip = 0; if ((xc->rvat_chain_pos_valid) && (tim >= xc->rvat_chain_pos_time)) { i = xc->rvat_chain_pos_idx; tidx = xc->rvat_chain_pos_tidx; } else { i = 0; tidx = 0; xc->rvat_chain_pos_time = xc->rvat_beg_tim; } if (xc->signal_lens[facidx] == 1) { while (i < xc->rvat_chain_len) { uint32_t vli = fstGetVarint32(xc->rvat_chain_mem + i, &skiplen); uint32_t shcnt = 2 << (vli & 1); tdelta = vli >> shcnt; if (xc->rvat_time_table[tidx + tdelta] <= tim) { iprev = i; pvli = vli; ptidx = tidx; /* pskip = skiplen; */ /* scan-build */ tidx += tdelta; i += skiplen; } else { break; } } if (iprev != xc->rvat_chain_len) { xc->rvat_chain_pos_tidx = ptidx; xc->rvat_chain_pos_idx = iprev; xc->rvat_chain_pos_time = tim; xc->rvat_chain_pos_valid = 1; if (!(pvli & 1)) { buf[0] = ((pvli >> 1) & 1) | '0'; } else { buf[0] = FST_RCV_STR[((pvli >> 1) & 7)]; } buf[1] = 0; return (buf); } else { return (fstExtractRvatDataFromFrame(xc, facidx, buf)); } } else { while (i < xc->rvat_chain_len) { uint32_t vli = fstGetVarint32(xc->rvat_chain_mem + i, &skiplen); tdelta = vli >> 1; if (xc->rvat_time_table[tidx + tdelta] <= tim) { iprev = i; pvli = vli; ptidx = tidx; pskip = skiplen; tidx += tdelta; i += skiplen; if (!(pvli & 1)) { i += ((xc->signal_lens[facidx] + 7) / 8); } else { i += xc->signal_lens[facidx]; } } else { break; } } if (iprev != xc->rvat_chain_len) { unsigned char *vdata = xc->rvat_chain_mem + iprev + pskip; xc->rvat_chain_pos_tidx = ptidx; xc->rvat_chain_pos_idx = iprev; xc->rvat_chain_pos_time = tim; xc->rvat_chain_pos_valid = 1; if (xc->signal_typs[facidx] != FST_VT_VCD_REAL) { if (!(pvli & 1)) { int byte = 0; int bit; unsigned int j; for (j = 0; j < xc->signal_lens[facidx]; j++) { unsigned char ch; byte = j / 8; bit = 7 - (j & 7); ch = ((vdata[byte] >> bit) & 1) | '0'; buf[j] = ch; } buf[j] = 0; return (buf); } else { memcpy(buf, vdata, xc->signal_lens[facidx]); buf[xc->signal_lens[facidx]] = 0; return (buf); } } else { double d; unsigned char *clone_d = (unsigned char *)&d; unsigned char bufd[8]; unsigned char *srcdata; if (!(pvli & 1)) /* very rare case, but possible */ { int bit; int j; for (j = 0; j < 8; j++) { unsigned char ch; bit = 7 - (j & 7); ch = ((vdata[0] >> bit) & 1) | '0'; bufd[j] = ch; } srcdata = bufd; } else { srcdata = vdata; } if (xc->double_endian_match) { memcpy(clone_d, srcdata, 8); } else { int j; for (j = 0; j < 8; j++) { clone_d[j] = srcdata[7 - j]; } } snprintf(buf, 32, "r%.16g", d); /* this will write 19 bytes */ return (buf); } } else { return (fstExtractRvatDataFromFrame(xc, facidx, buf)); } } } /* return(NULL); */ } /***********************/ /*** ***/ /*** jenkins hash ***/ /*** ***/ /***********************/ /* -------------------------------------------------------------------- mix -- mix 3 32-bit values reversibly. For every delta with one or two bits set, and the deltas of all three high bits or all three low bits, whether the original value of a,b,c is almost all zero or is uniformly distributed, * If mix() is run forward or backward, at least 32 bits in a,b,c have at least 1/4 probability of changing. * If mix() is run forward, every bit of c will change between 1/3 and 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.) mix() was built out of 36 single-cycle latency instructions in a structure that could supported 2x parallelism, like so: a -= b; a -= c; x = (c>>13); b -= c; a ^= x; b -= a; x = (a<<8); c -= a; b ^= x; c -= b; x = (b>>13); ... Unfortunately, superscalar Pentiums and Sparcs can't take advantage of that parallelism. They've also turned some of those single-cycle latency instructions into multi-cycle latency instructions. Still, this is the fastest good hash I could find. There were about 2^^68 to choose from. I only looked at a billion or so. -------------------------------------------------------------------- */ #define mix(a, b, c) \ { \ a -= b; \ a -= c; \ a ^= (c >> 13); \ b -= c; \ b -= a; \ b ^= (a << 8); \ c -= a; \ c -= b; \ c ^= (b >> 13); \ a -= b; \ a -= c; \ a ^= (c >> 12); \ b -= c; \ b -= a; \ b ^= (a << 16); \ c -= a; \ c -= b; \ c ^= (b >> 5); \ a -= b; \ a -= c; \ a ^= (c >> 3); \ b -= c; \ b -= a; \ b ^= (a << 10); \ c -= a; \ c -= b; \ c ^= (b >> 15); \ } /* -------------------------------------------------------------------- j_hash() -- hash a variable-length key into a 32-bit value k : the key (the unaligned variable-length array of bytes) len : the length of the key, counting by bytes initval : can be any 4-byte value Returns a 32-bit value. Every bit of the key affects every bit of the return value. Every 1-bit and 2-bit delta achieves avalanche. About 6*len+35 instructions. The best hash table sizes are powers of 2. There is no need to do mod a prime (mod is sooo slow!). If you need less than 32 bits, use a bitmask. For example, if you need only 10 bits, do h = (h & hashmask(10)); In which case, the hash table should have hashsize(10) elements. If you are hashing n strings (uint8_t **)k, do it like this: for (i=0, h=0; i= 12) { a += (k[0] + ((uint32_t)k[1] << 8) + ((uint32_t)k[2] << 16) + ((uint32_t)k[3] << 24)); b += (k[4] + ((uint32_t)k[5] << 8) + ((uint32_t)k[6] << 16) + ((uint32_t)k[7] << 24)); c += (k[8] + ((uint32_t)k[9] << 8) + ((uint32_t)k[10] << 16) + ((uint32_t)k[11] << 24)); mix(a, b, c); k += 12; len -= 12; } /*------------------------------------- handle the last 11 bytes */ c += length; switch (len) /* all the case statements fall through */ { case 11: c += ((uint32_t)k[10] << 24); /* fallthrough */ case 10: c += ((uint32_t)k[9] << 16); /* fallthrough */ case 9: c += ((uint32_t)k[8] << 8); /* fallthrough */ /* the first byte of c is reserved for the length */ case 8: b += ((uint32_t)k[7] << 24); /* fallthrough */ case 7: b += ((uint32_t)k[6] << 16); /* fallthrough */ case 6: b += ((uint32_t)k[5] << 8); /* fallthrough */ case 5: b += k[4]; /* fallthrough */ case 4: a += ((uint32_t)k[3] << 24); /* fallthrough */ case 3: a += ((uint32_t)k[2] << 16); /* fallthrough */ case 2: a += ((uint32_t)k[1] << 8); /* fallthrough */ case 1: a += k[0]; /* case 0: nothing left to add */ } mix(a, b, c); /*-------------------------------------------- report the result */ return (c); } /********************************************************************/ /***************************/ /*** ***/ /*** judy HS emulation ***/ /*** ***/ /***************************/ struct collchain_t { struct collchain_t *next; void *payload; uint32_t fullhash, length; unsigned char mem[1]; }; void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint32_t hashmask) { struct collchain_t ***base = (struct collchain_t ***)base_i; uint32_t hf, h; struct collchain_t **ar; struct collchain_t *chain, *pchain; if (!*base) { *base = (struct collchain_t **)calloc(1, (hashmask + 1) * sizeof(void *)); } ar = *base; h = (hf = j_hash(mem, length, length)) & hashmask; pchain = chain = ar[h]; while (chain) { if ((chain->fullhash == hf) && (chain->length == length) && !memcmp(chain->mem, mem, length)) { if (pchain != chain) /* move hit to front */ { pchain->next = chain->next; chain->next = ar[h]; ar[h] = chain; } return (&(chain->payload)); } pchain = chain; chain = chain->next; } chain = (struct collchain_t *)calloc(1, sizeof(struct collchain_t) + length - 1); memcpy(chain->mem, mem, length); chain->fullhash = hf; chain->length = length; chain->next = ar[h]; ar[h] = chain; return (&(chain->payload)); } void JenkinsFree(void *base_i, uint32_t hashmask) { struct collchain_t ***base = (struct collchain_t ***)base_i; uint32_t h; struct collchain_t **ar; struct collchain_t *chain, *chain_next; if (base && *base) { ar = *base; for (h = 0; h <= hashmask; h++) { chain = ar[h]; while (chain) { chain_next = chain->next; free(chain); chain = chain_next; } } free(*base); *base = NULL; } } /**********************************************************************/ /************************/ /*** ***/ /*** utility function ***/ /*** ***/ /************************/ int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len) { const unsigned char *src = s; int dlen = 0; int i; for (i = 0; i < len; i++) { switch (src[i]) { case '\a': /* fallthrough */ case '\b': /* fallthrough */ case '\f': /* fallthrough */ case '\n': /* fallthrough */ case '\r': /* fallthrough */ case '\t': /* fallthrough */ case '\v': /* fallthrough */ case '\'': /* fallthrough */ case '\"': /* fallthrough */ case '\\': /* fallthrough */ case '\?': dlen += 2; break; default: if ((src[i] > ' ') && (src[i] <= '~')) /* no white spaces in output */ { dlen++; } else { dlen += 4; } break; } } return (dlen); } int fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len) { const unsigned char *src = s; unsigned char *dst = d; unsigned char val; int i; for (i = 0; i < len; i++) { switch (src[i]) { case '\a': *(dst++) = '\\'; *(dst++) = 'a'; break; case '\b': *(dst++) = '\\'; *(dst++) = 'b'; break; case '\f': *(dst++) = '\\'; *(dst++) = 'f'; break; case '\n': *(dst++) = '\\'; *(dst++) = 'n'; break; case '\r': *(dst++) = '\\'; *(dst++) = 'r'; break; case '\t': *(dst++) = '\\'; *(dst++) = 't'; break; case '\v': *(dst++) = '\\'; *(dst++) = 'v'; break; case '\'': *(dst++) = '\\'; *(dst++) = '\''; break; case '\"': *(dst++) = '\\'; *(dst++) = '\"'; break; case '\\': *(dst++) = '\\'; *(dst++) = '\\'; break; case '\?': *(dst++) = '\\'; *(dst++) = '\?'; break; default: if ((src[i] > ' ') && (src[i] <= '~')) /* no white spaces in output */ { *(dst++) = src[i]; } else { val = src[i]; *(dst++) = '\\'; *(dst++) = (val / 64) + '0'; val = val & 63; *(dst++) = (val / 8) + '0'; val = val & 7; *(dst++) = (val) + '0'; } break; } } return (dst - d); } /* * this overwrites the original string if the destination pointer is NULL */ int fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len) { unsigned char *src = s; unsigned char *dst = (!d) ? s : (s = d); unsigned char val[3]; int i; for (i = 0; i < len; i++) { if (src[i] != '\\') { *(dst++) = src[i]; } else { switch (src[++i]) { case 'a': *(dst++) = '\a'; break; case 'b': *(dst++) = '\b'; break; case 'f': *(dst++) = '\f'; break; case 'n': *(dst++) = '\n'; break; case 'r': *(dst++) = '\r'; break; case 't': *(dst++) = '\t'; break; case 'v': *(dst++) = '\v'; break; case '\'': *(dst++) = '\''; break; case '\"': *(dst++) = '\"'; break; case '\\': *(dst++) = '\\'; break; case '\?': *(dst++) = '\?'; break; case 'x': val[0] = toupper(src[++i]); val[1] = toupper(src[++i]); val[0] = ((val[0] >= 'A') && (val[0] <= 'F')) ? (val[0] - 'A' + 10) : (val[0] - '0'); val[1] = ((val[1] >= 'A') && (val[1] <= 'F')) ? (val[1] - 'A' + 10) : (val[1] - '0'); *(dst++) = val[0] * 16 + val[1]; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': val[0] = src[i] - '0'; val[1] = src[++i] - '0'; val[2] = src[++i] - '0'; *(dst++) = val[0] * 64 + val[1] * 8 + val[2]; break; default: *(dst++) = src[i]; break; } } } return (dst - s); } struct fstETab *fstUtilityExtractEnumTableFromString(const char *s) { struct fstETab *et = NULL; int num_spaces = 0; int i; int newlen; if (s) { const char *csp = strchr(s, ' '); int cnt = atoi(csp + 1); for (;;) { csp = strchr(csp + 1, ' '); if (csp) { num_spaces++; } else { break; } } if (num_spaces == (2 * cnt)) { char *sp, *sp2; et = (struct fstETab *)calloc(1, sizeof(struct fstETab)); et->elem_count = cnt; et->name = strdup(s); et->literal_arr = (char **)calloc(cnt, sizeof(char *)); et->val_arr = (char **)calloc(cnt, sizeof(char *)); sp = strchr(et->name, ' '); *sp = 0; sp = strchr(sp + 1, ' '); for (i = 0; i < cnt; i++) { sp2 = strchr(sp + 1, ' '); *(char *)sp2 = 0; et->literal_arr[i] = sp + 1; sp = sp2; newlen = fstUtilityEscToBin(NULL, (unsigned char *)et->literal_arr[i], strlen(et->literal_arr[i])); et->literal_arr[i][newlen] = 0; } for (i = 0; i < cnt; i++) { sp2 = strchr(sp + 1, ' '); if (sp2) { *sp2 = 0; } et->val_arr[i] = sp + 1; sp = sp2; newlen = fstUtilityEscToBin(NULL, (unsigned char *)et->val_arr[i], strlen(et->val_arr[i])); et->val_arr[i][newlen] = 0; } } } return (et); } void fstUtilityFreeEnumTable(struct fstETab *etab) { if (etab) { free(etab->literal_arr); free(etab->val_arr); free(etab->name); free(etab); } } nvc-r1.17.1/thirdparty/fstapi.h000066400000000000000000000460111504111170000163720ustar00rootroot00000000000000/* * Copyright (c) 2009-2018 Tony Bybell. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * SPDX-License-Identifier: MIT */ #ifndef FST_API_H #define FST_API_H #ifdef __cplusplus extern "C" { #endif #include #include #include #include #include #include #if defined(_MSC_VER) #include "fst_win_unistd.h" #else #include #endif #include typedef uint32_t fstHandle; typedef uint32_t fstEnumHandle; enum fstWriterPackType { FST_WR_PT_ZLIB = 0, FST_WR_PT_FASTLZ = 1, FST_WR_PT_LZ4 = 2 }; enum fstFileType { FST_FT_MIN = 0, FST_FT_VERILOG = 0, FST_FT_VHDL = 1, FST_FT_VERILOG_VHDL = 2, FST_FT_MAX = 2 }; enum fstBlockType { FST_BL_HDR = 0, FST_BL_VCDATA = 1, FST_BL_BLACKOUT = 2, FST_BL_GEOM = 3, FST_BL_HIER = 4, FST_BL_VCDATA_DYN_ALIAS = 5, FST_BL_HIER_LZ4 = 6, FST_BL_HIER_LZ4DUO = 7, FST_BL_VCDATA_DYN_ALIAS2 = 8, FST_BL_ZWRAPPER = 254, /* indicates that whole trace is gz wrapped */ FST_BL_SKIP = 255 /* used while block is being written */ }; enum fstScopeType { FST_ST_MIN = 0, FST_ST_VCD_MODULE = 0, FST_ST_VCD_TASK = 1, FST_ST_VCD_FUNCTION = 2, FST_ST_VCD_BEGIN = 3, FST_ST_VCD_FORK = 4, FST_ST_VCD_GENERATE = 5, FST_ST_VCD_STRUCT = 6, FST_ST_VCD_UNION = 7, FST_ST_VCD_CLASS = 8, FST_ST_VCD_INTERFACE = 9, FST_ST_VCD_PACKAGE = 10, FST_ST_VCD_PROGRAM = 11, FST_ST_VHDL_ARCHITECTURE = 12, FST_ST_VHDL_PROCEDURE = 13, FST_ST_VHDL_FUNCTION = 14, FST_ST_VHDL_RECORD = 15, FST_ST_VHDL_PROCESS = 16, FST_ST_VHDL_BLOCK = 17, FST_ST_VHDL_FOR_GENERATE = 18, FST_ST_VHDL_IF_GENERATE = 19, FST_ST_VHDL_GENERATE = 20, FST_ST_VHDL_PACKAGE = 21, FST_ST_MAX = 21, FST_ST_GEN_ATTRBEGIN = 252, FST_ST_GEN_ATTREND = 253, FST_ST_VCD_SCOPE = 254, FST_ST_VCD_UPSCOPE = 255 }; enum fstVarType { FST_VT_MIN = 0, /* start of vartypes */ FST_VT_VCD_EVENT = 0, FST_VT_VCD_INTEGER = 1, FST_VT_VCD_PARAMETER = 2, FST_VT_VCD_REAL = 3, FST_VT_VCD_REAL_PARAMETER = 4, FST_VT_VCD_REG = 5, FST_VT_VCD_SUPPLY0 = 6, FST_VT_VCD_SUPPLY1 = 7, FST_VT_VCD_TIME = 8, FST_VT_VCD_TRI = 9, FST_VT_VCD_TRIAND = 10, FST_VT_VCD_TRIOR = 11, FST_VT_VCD_TRIREG = 12, FST_VT_VCD_TRI0 = 13, FST_VT_VCD_TRI1 = 14, FST_VT_VCD_WAND = 15, FST_VT_VCD_WIRE = 16, FST_VT_VCD_WOR = 17, FST_VT_VCD_PORT = 18, FST_VT_VCD_SPARRAY = 19, /* used to define the rownum (index) port for a sparse array */ FST_VT_VCD_REALTIME = 20, FST_VT_GEN_STRING = 21, /* generic string type (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */ FST_VT_SV_BIT = 22, FST_VT_SV_LOGIC = 23, FST_VT_SV_INT = 24, /* declare as size = 32 */ FST_VT_SV_SHORTINT = 25, /* declare as size = 16 */ FST_VT_SV_LONGINT = 26, /* declare as size = 64 */ FST_VT_SV_BYTE = 27, /* declare as size = 8 */ FST_VT_SV_ENUM = 28, /* declare as appropriate type range */ FST_VT_SV_SHORTREAL = 29, /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */ FST_VT_MAX = 29 /* end of vartypes */ }; enum fstVarDir { FST_VD_MIN = 0, FST_VD_IMPLICIT = 0, FST_VD_INPUT = 1, FST_VD_OUTPUT = 2, FST_VD_INOUT = 3, FST_VD_BUFFER = 4, FST_VD_LINKAGE = 5, FST_VD_MAX = 5 }; enum fstHierType { FST_HT_MIN = 0, FST_HT_SCOPE = 0, FST_HT_UPSCOPE = 1, FST_HT_VAR = 2, FST_HT_ATTRBEGIN = 3, FST_HT_ATTREND = 4, /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when fstHier bridges other formats */ FST_HT_TREEBEGIN = 5, FST_HT_TREEEND = 6, FST_HT_MAX = 6 }; enum fstAttrType { FST_AT_MIN = 0, FST_AT_MISC = 0, /* self-contained: does not need matching FST_HT_ATTREND */ FST_AT_ARRAY = 1, FST_AT_ENUM = 2, FST_AT_PACK = 3, FST_AT_MAX = 3 }; enum fstMiscType { FST_MT_MIN = 0, FST_MT_COMMENT = 0, /* use fstWriterSetComment() to emit */ FST_MT_ENVVAR = 1, /* use fstWriterSetEnvVar() to emit */ FST_MT_SUPVAR = 2, /* use fstWriterCreateVar2() to emit */ FST_MT_PATHNAME = 3, /* reserved for fstWriterSetSourceStem() string -> number management */ FST_MT_SOURCESTEM = 4, /* use fstWriterSetSourceStem() to emit */ FST_MT_SOURCEISTEM = 5, /* use fstWriterSetSourceInstantiationStem() to emit */ FST_MT_VALUELIST = 6, /* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */ FST_MT_ENUMTABLE = 7, /* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */ FST_MT_UNKNOWN = 8, FST_MT_MAX = 8 }; enum fstArrayType { FST_AR_MIN = 0, FST_AR_NONE = 0, FST_AR_UNPACKED = 1, FST_AR_PACKED = 2, FST_AR_SPARSE = 3, FST_AR_MAX = 3 }; enum fstEnumValueType { FST_EV_SV_INTEGER = 0, FST_EV_SV_BIT = 1, FST_EV_SV_LOGIC = 2, FST_EV_SV_INT = 3, FST_EV_SV_SHORTINT = 4, FST_EV_SV_LONGINT = 5, FST_EV_SV_BYTE = 6, FST_EV_SV_UNSIGNED_INTEGER = 7, FST_EV_SV_UNSIGNED_BIT = 8, FST_EV_SV_UNSIGNED_LOGIC = 9, FST_EV_SV_UNSIGNED_INT = 10, FST_EV_SV_UNSIGNED_SHORTINT = 11, FST_EV_SV_UNSIGNED_LONGINT = 12, FST_EV_SV_UNSIGNED_BYTE = 13, FST_EV_REG = 14, FST_EV_TIME = 15, FST_EV_MAX = 15 }; enum fstPackType { FST_PT_NONE = 0, FST_PT_UNPACKED = 1, FST_PT_PACKED = 2, FST_PT_TAGGED_PACKED = 3, FST_PT_MAX = 3 }; enum fstSupplementalVarType { FST_SVT_MIN = 0, FST_SVT_NONE = 0, FST_SVT_VHDL_SIGNAL = 1, FST_SVT_VHDL_VARIABLE = 2, FST_SVT_VHDL_CONSTANT = 3, FST_SVT_VHDL_FILE = 4, FST_SVT_VHDL_MEMORY = 5, FST_SVT_MAX = 5 }; enum fstSupplementalDataType { FST_SDT_MIN = 0, FST_SDT_NONE = 0, FST_SDT_VHDL_BOOLEAN = 1, FST_SDT_VHDL_BIT = 2, FST_SDT_VHDL_BIT_VECTOR = 3, FST_SDT_VHDL_STD_ULOGIC = 4, FST_SDT_VHDL_STD_ULOGIC_VECTOR = 5, FST_SDT_VHDL_STD_LOGIC = 6, FST_SDT_VHDL_STD_LOGIC_VECTOR = 7, FST_SDT_VHDL_UNSIGNED = 8, FST_SDT_VHDL_SIGNED = 9, FST_SDT_VHDL_INTEGER = 10, FST_SDT_VHDL_REAL = 11, FST_SDT_VHDL_NATURAL = 12, FST_SDT_VHDL_POSITIVE = 13, FST_SDT_VHDL_TIME = 14, FST_SDT_VHDL_CHARACTER = 15, FST_SDT_VHDL_STRING = 16, FST_SDT_MAX = 16, FST_SDT_SVT_SHIFT_COUNT = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left after shifting FST_SDT_SVT_SHIFT_COUNT */ FST_SDT_ABS_MAX = ((1 << (FST_SDT_SVT_SHIFT_COUNT)) - 1) }; struct fstHier { unsigned char htyp; union { /* if htyp == FST_HT_SCOPE */ struct fstHierScope { unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */ const char *name; const char *component; uint32_t name_length; /* strlen(u.scope.name) */ uint32_t component_length; /* strlen(u.scope.component) */ } scope; /* if htyp == FST_HT_VAR */ struct fstHierVar { unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */ unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */ unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */ unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */ unsigned int sxt_workspace; /* zeroed out by FST reader, for client code use */ const char *name; uint32_t length; fstHandle handle; uint32_t name_length; /* strlen(u.var.name) */ unsigned is_alias : 1; } var; /* if htyp == FST_HT_ATTRBEGIN */ struct fstHierAttr { unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */ unsigned char subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */ const char *name; uint64_t arg; /* number of array elements, struct members, or some other payload (possibly ignored) */ uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer (FST_AT_MISC + FST_MT_SOURCESTEM) */ uint32_t name_length; /* strlen(u.attr.name) */ } attr; } u; }; struct fstETab { char *name; uint32_t elem_count; char **literal_arr; char **val_arr; }; /* * writer functions */ typedef struct fstWriterContext fstWriterContext; void fstWriterClose(fstWriterContext *ctx); fstWriterContext *fstWriterCreate(const char *nam, int use_compressed_hier); fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr); /* used for Verilog/SV */ fstHandle fstWriterCreateVar(fstWriterContext *ctx, enum fstVarType vt, enum fstVarDir vd, uint32_t len, const char *nam, fstHandle aliasHandle); /* future expansion for VHDL and other languages. The variable type, data type, etc map onto the current Verilog/SV one. The "type" string is optional for a more verbose or custom description */ fstHandle fstWriterCreateVar2(fstWriterContext *ctx, enum fstVarType vt, enum fstVarDir vd, uint32_t len, const char *nam, fstHandle aliasHandle, const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt); void fstWriterEmitDumpActive(fstWriterContext *ctx, int enable); void fstWriterEmitEnumTableRef(fstWriterContext *ctx, fstEnumHandle handle); void fstWriterEmitValueChange(fstWriterContext *ctx, fstHandle handle, const void *val); void fstWriterEmitValueChange32(fstWriterContext *ctx, fstHandle handle, uint32_t bits, uint32_t val); void fstWriterEmitValueChange64(fstWriterContext *ctx, fstHandle handle, uint32_t bits, uint64_t val); void fstWriterEmitValueChangeVec32(fstWriterContext *ctx, fstHandle handle, uint32_t bits, const uint32_t *val); void fstWriterEmitValueChangeVec64(fstWriterContext *ctx, fstHandle handle, uint32_t bits, const uint64_t *val); void fstWriterEmitVariableLengthValueChange(fstWriterContext *ctx, fstHandle handle, const void *val, uint32_t len); void fstWriterEmitTimeChange(fstWriterContext *ctx, uint64_t tim); void fstWriterFlushContext(fstWriterContext *ctx); int fstWriterGetDumpSizeLimitReached(fstWriterContext *ctx); int fstWriterGetFseekFailed(fstWriterContext *ctx); int fstWriterGetFlushContextPending(fstWriterContext *ctx); void fstWriterSetAttrBegin(fstWriterContext *ctx, enum fstAttrType attrtype, int subtype, const char *attrname, uint64_t arg); void fstWriterSetAttrEnd(fstWriterContext *ctx); void fstWriterSetComment(fstWriterContext *ctx, const char *comm); void fstWriterSetDate(fstWriterContext *ctx, const char *dat); void fstWriterSetDumpSizeLimit(fstWriterContext *ctx, uint64_t numbytes); void fstWriterSetEnvVar(fstWriterContext *ctx, const char *envvar); void fstWriterSetFileType(fstWriterContext *ctx, enum fstFileType filetype); void fstWriterSetPackType(fstWriterContext *ctx, enum fstWriterPackType typ); void fstWriterSetParallelMode(fstWriterContext *ctx, int enable); void fstWriterSetRepackOnClose(fstWriterContext *ctx, int enable); /* type = 0 (none), 1 (libz) */ void fstWriterSetScope(fstWriterContext *ctx, enum fstScopeType scopetype, const char *scopename, const char *scopecomp); void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx, const char *path, unsigned int line, unsigned int use_realpath); void fstWriterSetSourceStem(fstWriterContext *ctx, const char *path, unsigned int line, unsigned int use_realpath); void fstWriterSetTimescale(fstWriterContext *ctx, int ts); void fstWriterSetTimescaleFromString(fstWriterContext *ctx, const char *s); void fstWriterSetTimezero(fstWriterContext *ctx, int64_t tim); void fstWriterSetUpscope(fstWriterContext *ctx); void fstWriterSetValueList(fstWriterContext *ctx, const char *vl); void fstWriterSetVersion(fstWriterContext *ctx, const char *vers); /* * reader functions */ typedef struct fstReaderContext fstReaderContext; void fstReaderClose(fstReaderContext *ctx); void fstReaderClrFacProcessMask(fstReaderContext *ctx, fstHandle facidx); void fstReaderClrFacProcessMaskAll(fstReaderContext *ctx); uint64_t fstReaderGetAliasCount(fstReaderContext *ctx); const char *fstReaderGetCurrentFlatScope(fstReaderContext *ctx); void *fstReaderGetCurrentScopeUserInfo(fstReaderContext *ctx); int fstReaderGetCurrentScopeLen(fstReaderContext *ctx); const char *fstReaderGetDateString(fstReaderContext *ctx); int fstReaderGetDoubleEndianMatchState(fstReaderContext *ctx); uint64_t fstReaderGetDumpActivityChangeTime(fstReaderContext *ctx, uint32_t idx); unsigned char fstReaderGetDumpActivityChangeValue(fstReaderContext *ctx, uint32_t idx); uint64_t fstReaderGetEndTime(fstReaderContext *ctx); int fstReaderGetFacProcessMask(fstReaderContext *ctx, fstHandle facidx); int fstReaderGetFileType(fstReaderContext *ctx); int fstReaderGetFseekFailed(fstReaderContext *ctx); fstHandle fstReaderGetMaxHandle(fstReaderContext *ctx); uint64_t fstReaderGetMemoryUsedByWriter(fstReaderContext *ctx); uint32_t fstReaderGetNumberDumpActivityChanges(fstReaderContext *ctx); uint64_t fstReaderGetScopeCount(fstReaderContext *ctx); uint64_t fstReaderGetStartTime(fstReaderContext *ctx); signed char fstReaderGetTimescale(fstReaderContext *ctx); int64_t fstReaderGetTimezero(fstReaderContext *ctx); uint64_t fstReaderGetValueChangeSectionCount(fstReaderContext *ctx); char *fstReaderGetValueFromHandleAtTime(fstReaderContext *ctx, uint64_t tim, fstHandle facidx, char *buf); uint64_t fstReaderGetVarCount(fstReaderContext *ctx); const char *fstReaderGetVersionString(fstReaderContext *ctx); struct fstHier *fstReaderIterateHier(fstReaderContext *ctx); int fstReaderIterateHierRewind(fstReaderContext *ctx); int fstReaderIterBlocks(fstReaderContext *ctx, void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), void *user_callback_data_pointer, FILE *vcdhandle); int fstReaderIterBlocks2(fstReaderContext *ctx, void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value), void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len), void *user_callback_data_pointer, FILE *vcdhandle); void fstReaderIterBlocksSetNativeDoublesOnCallback(fstReaderContext *ctx, int enable); fstReaderContext *fstReaderOpen(const char *nam); fstReaderContext *fstReaderOpenForUtilitiesOnly(void); const char *fstReaderPopScope(fstReaderContext *ctx); int fstReaderProcessHier(fstReaderContext *ctx, FILE *vcdhandle); const char *fstReaderPushScope(fstReaderContext *ctx, const char *nam, void *user_info); void fstReaderResetScope(fstReaderContext *ctx); void fstReaderSetFacProcessMask(fstReaderContext *ctx, fstHandle facidx); void fstReaderSetFacProcessMaskAll(fstReaderContext *ctx); void fstReaderSetLimitTimeRange(fstReaderContext *ctx, uint64_t start_time, uint64_t end_time); void fstReaderSetUnlimitedTimeRange(fstReaderContext *ctx); void fstReaderSetVcdExtensions(fstReaderContext *ctx, int enable); /* * utility functions */ int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */ int fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len); int fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len); struct fstETab *fstUtilityExtractEnumTableFromString(const char *s); void fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */ #ifdef __cplusplus } #endif #endif nvc-r1.17.1/thirdparty/getdelim.c000066400000000000000000000075531504111170000167010ustar00rootroot00000000000000/* getdelim.c --- Implementation of replacement getdelim function. Copyright (C) 1994, 1996-1998, 2001, 2003, 2005-2022 Free Software Foundation, Inc. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ /* Ported from glibc by Simon Josefsson. */ /* Don't use __attribute__ __nonnull__ in this compilation unit. Otherwise gcc optimizes away the lineptr == NULL || n == NULL || fp == NULL tests below. */ #define _GL_ARG_NONNULL(params) #include #include #include #include #include #include #ifndef SSIZE_MAX # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2)) #endif #if USE_UNLOCKED_IO # include "unlocked-io.h" # define getc_maybe_unlocked(fp) getc(fp) #elif !HAVE_FLOCKFILE || !HAVE_FUNLOCKFILE || !HAVE_DECL_GETC_UNLOCKED # undef flockfile # undef funlockfile # define flockfile(x) ((void) 0) # define funlockfile(x) ((void) 0) # define getc_maybe_unlocked(fp) getc(fp) #else # define getc_maybe_unlocked(fp) getc_unlocked(fp) #endif static void alloc_failed (void) { #if defined _WIN32 && ! defined __CYGWIN__ /* Avoid errno problem without using the realloc module; see: https://lists.gnu.org/r/bug-gnulib/2016-08/msg00025.html */ errno = ENOMEM; #endif } /* Read up to (and including) a DELIMITER from FP into *LINEPTR (and NUL-terminate it). *LINEPTR is a pointer returned from malloc (or NULL), pointing to *N characters of space. It is realloc'ed as necessary. Returns the number of characters read (not including the null terminator), or -1 on error or EOF. */ ssize_t getdelim (char **lineptr, size_t *n, int delimiter, FILE *fp) { ssize_t result; size_t cur_len = 0; if (lineptr == NULL || n == NULL || fp == NULL) { errno = EINVAL; return -1; } flockfile (fp); if (*lineptr == NULL || *n == 0) { char *new_lineptr; *n = 120; new_lineptr = (char *) realloc (*lineptr, *n); if (new_lineptr == NULL) { alloc_failed (); result = -1; goto unlock_return; } *lineptr = new_lineptr; } for (;;) { int i; i = getc_maybe_unlocked (fp); if (i == EOF) { result = -1; break; } /* Make enough space for len+1 (for final NUL) bytes. */ if (cur_len + 1 >= *n) { size_t needed_max = SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX; size_t needed = 2 * *n + 1; /* Be generous. */ char *new_lineptr; if (needed_max < needed) needed = needed_max; if (cur_len + 1 >= needed) { result = -1; errno = EOVERFLOW; goto unlock_return; } new_lineptr = (char *) realloc (*lineptr, needed); if (new_lineptr == NULL) { alloc_failed (); result = -1; goto unlock_return; } *lineptr = new_lineptr; *n = needed; } (*lineptr)[cur_len] = i; cur_len++; if (i == delimiter) break; } (*lineptr)[cur_len] = '\0'; result = cur_len ? cur_len : result; unlock_return: funlockfile (fp); /* doesn't set errno */ return result; } nvc-r1.17.1/thirdparty/getline.c000066400000000000000000000020401504111170000165200ustar00rootroot00000000000000/* getline.c --- Implementation of replacement getline function. Copyright (C) 2005-2007, 2009-2022 Free Software Foundation, Inc. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ /* Written by Simon Josefsson. */ #include #include ssize_t getdelim (char **lineptr, size_t *n, int delimiter, FILE *fp); ssize_t getline (char **lineptr, size_t *n, FILE *stream) { return getdelim (lineptr, n, '\n', stream); } nvc-r1.17.1/thirdparty/lz4.c000066400000000000000000003416031504111170000156150ustar00rootroot00000000000000/* LZ4 - Fast LZ compression algorithm Copyright (C) 2011-2023, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - LZ4 homepage : http://www.lz4.org - LZ4 source repository : https://github.com/lz4/lz4 */ /*-************************************ * Tuning parameters **************************************/ /* * LZ4_HEAPMODE : * Select how stateless compression functions like `LZ4_compress_default()` * allocate memory for their hash table, * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()). */ #ifndef LZ4_HEAPMODE # define LZ4_HEAPMODE 0 #endif /* * LZ4_ACCELERATION_DEFAULT : * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0 */ #define LZ4_ACCELERATION_DEFAULT 1 /* * LZ4_ACCELERATION_MAX : * Any "acceleration" value higher than this threshold * get treated as LZ4_ACCELERATION_MAX instead (fix #876) */ #define LZ4_ACCELERATION_MAX 65537 /*-************************************ * CPU Feature Detection **************************************/ /* LZ4_FORCE_MEMORY_ACCESS * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. * The below switch allow to select different access method for improved performance. * Method 0 (default) : use `memcpy()`. Safe and portable. * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. * Method 2 : direct access. This method is portable but violate C standard. * It can generate buggy code on targets which assembly generation depends on alignment. * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. * Prefer these methods in priority order (0 > 1 > 2) */ #ifndef LZ4_FORCE_MEMORY_ACCESS /* can be defined externally */ # if defined(__GNUC__) && \ ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \ || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) # define LZ4_FORCE_MEMORY_ACCESS 2 # elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) || defined(_MSC_VER) # define LZ4_FORCE_MEMORY_ACCESS 1 # endif #endif /* * LZ4_FORCE_SW_BITCOUNT * Define this parameter if your target system or compiler does not support hardware bit count */ #if defined(_MSC_VER) && defined(_WIN32_WCE) /* Visual Studio for WinCE doesn't support Hardware bit count */ # undef LZ4_FORCE_SW_BITCOUNT /* avoid double def */ # define LZ4_FORCE_SW_BITCOUNT #endif /*-************************************ * Dependency **************************************/ /* * LZ4_SRC_INCLUDED: * Amalgamation flag, whether lz4.c is included */ #ifndef LZ4_SRC_INCLUDED # define LZ4_SRC_INCLUDED 1 #endif #ifndef LZ4_DISABLE_DEPRECATE_WARNINGS # define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */ #endif #ifndef LZ4_STATIC_LINKING_ONLY # define LZ4_STATIC_LINKING_ONLY #endif #include "lz4.h" /* see also "memory routines" below */ /*-************************************ * Compiler Options **************************************/ #if defined(_MSC_VER) && (_MSC_VER >= 1400) /* Visual Studio 2005+ */ # include /* only present in VS2005+ */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 6237) /* disable: C6237: conditional expression is always 0 */ #endif /* _MSC_VER */ #ifndef LZ4_FORCE_INLINE # ifdef _MSC_VER /* Visual Studio */ # define LZ4_FORCE_INLINE static __forceinline # else # if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # ifdef __GNUC__ # define LZ4_FORCE_INLINE static inline __attribute__((always_inline)) # else # define LZ4_FORCE_INLINE static inline # endif # else # define LZ4_FORCE_INLINE static # endif /* __STDC_VERSION__ */ # endif /* _MSC_VER */ #endif /* LZ4_FORCE_INLINE */ /* LZ4_FORCE_O2 and LZ4_FORCE_INLINE * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8, * together with a simple 8-byte copy loop as a fall-back path. * However, this optimization hurts the decompression speed by >30%, * because the execution does not go to the optimized loop * for typical compressible data, and all of the preamble checks * before going to the fall-back path become useless overhead. * This optimization happens only with the -O3 flag, and -O2 generates * a simple 8-byte copy loop. * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8 * functions are annotated with __attribute__((optimize("O2"))), * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute * of LZ4_wildCopy8 does not affect the compression speed. */ #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__) # define LZ4_FORCE_O2 __attribute__((optimize("O2"))) # undef LZ4_FORCE_INLINE # define LZ4_FORCE_INLINE static __inline __attribute__((optimize("O2"),always_inline)) #else # define LZ4_FORCE_O2 #endif #if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__) # define expect(expr,value) (__builtin_expect ((expr),(value)) ) #else # define expect(expr,value) (expr) #endif #ifndef likely #define likely(expr) expect((expr) != 0, 1) #endif #ifndef unlikely #define unlikely(expr) expect((expr) != 0, 0) #endif /* Should the alignment test prove unreliable, for some reason, * it can be disabled by setting LZ4_ALIGN_TEST to 0 */ #ifndef LZ4_ALIGN_TEST /* can be externally provided */ # define LZ4_ALIGN_TEST 1 #endif /*-************************************ * Memory routines **************************************/ /*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION : * Disable relatively high-level LZ4/HC functions that use dynamic memory * allocation functions (malloc(), calloc(), free()). * * Note that this is a compile-time switch. And since it disables * public/stable LZ4 v1 API functions, we don't recommend using this * symbol to generate a library for distribution. * * The following public functions are removed when this symbol is defined. * - lz4 : LZ4_createStream, LZ4_freeStream, * LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated) * - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC, * LZ4_createHC (deprecated), LZ4_freeHC (deprecated) * - lz4frame, lz4file : All LZ4F_* functions */ #if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) # define ALLOC(s) lz4_error_memory_allocation_is_disabled # define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled # define FREEMEM(p) lz4_error_memory_allocation_is_disabled #elif defined(LZ4_USER_MEMORY_FUNCTIONS) /* memory management functions can be customized by user project. * Below functions must exist somewhere in the Project * and be available at link time */ void* LZ4_malloc(size_t s); void* LZ4_calloc(size_t n, size_t s); void LZ4_free(void* p); # define ALLOC(s) LZ4_malloc(s) # define ALLOC_AND_ZERO(s) LZ4_calloc(1,s) # define FREEMEM(p) LZ4_free(p) #else # include /* malloc, calloc, free */ # define ALLOC(s) malloc(s) # define ALLOC_AND_ZERO(s) calloc(1,s) # define FREEMEM(p) free(p) #endif #if ! LZ4_FREESTANDING # include /* memset, memcpy */ #endif #if !defined(LZ4_memset) # define LZ4_memset(p,v,s) memset((p),(v),(s)) #endif #define MEM_INIT(p,v,s) LZ4_memset((p),(v),(s)) /*-************************************ * Common Constants **************************************/ #define MINMATCH 4 #define WILDCOPYLENGTH 8 #define LASTLITERALS 5 /* see ../doc/lz4_Block_format.md#parsing-restrictions */ #define MFLIMIT 12 /* see ../doc/lz4_Block_format.md#parsing-restrictions */ #define MATCH_SAFEGUARD_DISTANCE ((2*WILDCOPYLENGTH) - MINMATCH) /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */ #define FASTLOOP_SAFE_DISTANCE 64 static const int LZ4_minLength = (MFLIMIT+1); #define KB *(1 <<10) #define MB *(1 <<20) #define GB *(1U<<30) #define LZ4_DISTANCE_ABSOLUTE_MAX 65535 #if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX) /* max supported by LZ4 format */ # error "LZ4_DISTANCE_MAX is too big : must be <= 65535" #endif #define ML_BITS 4 #define ML_MASK ((1U<=1) # include #else # ifndef assert # define assert(condition) ((void)0) # endif #endif #define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use after variable declarations */ #if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2) # include static int g_debuglog_enable = 1; # define DEBUGLOG(l, ...) { \ if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) { \ fprintf(stderr, __FILE__ " %i: ", __LINE__); \ fprintf(stderr, __VA_ARGS__); \ fprintf(stderr, " \n"); \ } } #else # define DEBUGLOG(l, ...) {} /* disabled */ #endif static int LZ4_isAligned(const void* ptr, size_t alignment) { return ((size_t)ptr & (alignment -1)) == 0; } /*-************************************ * Types **************************************/ #include #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # include typedef uint8_t BYTE; typedef uint16_t U16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; typedef uintptr_t uptrval; #else # if UINT_MAX != 4294967295UL # error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4" # endif typedef unsigned char BYTE; typedef unsigned short U16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; typedef size_t uptrval; /* generally true, except OpenVMS-64 */ #endif #if defined(__x86_64__) typedef U64 reg_t; /* 64-bits in x32 mode */ #else typedef size_t reg_t; /* 32-bits in x32 mode */ #endif typedef enum { notLimited = 0, limitedOutput = 1, fillOutput = 2 } limitedOutput_directive; /*-************************************ * Reading and writing into memory **************************************/ /** * LZ4 relies on memcpy with a constant size being inlined. In freestanding * environments, the compiler can't assume the implementation of memcpy() is * standard compliant, so it can't apply its specialized memcpy() inlining * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze * memcpy() as if it were standard compliant, so it can inline it in freestanding * environments. This is needed when decompressing the Linux Kernel, for example. */ #if !defined(LZ4_memcpy) # if defined(__GNUC__) && (__GNUC__ >= 4) # define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) # else # define LZ4_memcpy(dst, src, size) memcpy(dst, src, size) # endif #endif #if !defined(LZ4_memmove) # if defined(__GNUC__) && (__GNUC__ >= 4) # define LZ4_memmove __builtin_memmove # else # define LZ4_memmove memmove # endif #endif static unsigned LZ4_isLittleEndian(void) { const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ return one.c[0]; } #if defined(__GNUC__) || defined(__INTEL_COMPILER) #define LZ4_PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__)) #elif defined(_MSC_VER) #define LZ4_PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop)) #endif #if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2) /* lie to the compiler about data alignment; use with caution */ static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; } static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; } static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; } static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } #elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1) /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ LZ4_PACK(typedef struct { U16 u16; }) LZ4_unalign16; LZ4_PACK(typedef struct { U32 u32; }) LZ4_unalign32; LZ4_PACK(typedef struct { reg_t uArch; }) LZ4_unalignST; static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign16*)ptr)->u16; } static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign32*)ptr)->u32; } static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalignST*)ptr)->uArch; } static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign16*)memPtr)->u16 = value; } static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign32*)memPtr)->u32 = value; } #else /* safe and portable access using memcpy() */ static U16 LZ4_read16(const void* memPtr) { U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; } static U32 LZ4_read32(const void* memPtr) { U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; } static reg_t LZ4_read_ARCH(const void* memPtr) { reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val; } static void LZ4_write16(void* memPtr, U16 value) { LZ4_memcpy(memPtr, &value, sizeof(value)); } static void LZ4_write32(void* memPtr, U32 value) { LZ4_memcpy(memPtr, &value, sizeof(value)); } #endif /* LZ4_FORCE_MEMORY_ACCESS */ static U16 LZ4_readLE16(const void* memPtr) { if (LZ4_isLittleEndian()) { return LZ4_read16(memPtr); } else { const BYTE* p = (const BYTE*)memPtr; return (U16)((U16)p[0] + (p[1]<<8)); } } #ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT static U32 LZ4_readLE32(const void* memPtr) { if (LZ4_isLittleEndian()) { return LZ4_read32(memPtr); } else { const BYTE* p = (const BYTE*)memPtr; return (U32)p[0] + (p[1]<<8) + (p[2]<<16) + (p[3]<<24); } } #endif static void LZ4_writeLE16(void* memPtr, U16 value) { if (LZ4_isLittleEndian()) { LZ4_write16(memPtr, value); } else { BYTE* p = (BYTE*)memPtr; p[0] = (BYTE) value; p[1] = (BYTE)(value>>8); } } /* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */ LZ4_FORCE_INLINE void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd) { BYTE* d = (BYTE*)dstPtr; const BYTE* s = (const BYTE*)srcPtr; BYTE* const e = (BYTE*)dstEnd; do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d= 16. */ LZ4_FORCE_INLINE void LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd) { BYTE* d = (BYTE*)dstPtr; const BYTE* s = (const BYTE*)srcPtr; BYTE* const e = (BYTE*)dstEnd; do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d= dstPtr + MINMATCH * - there is at least 8 bytes available to write after dstEnd */ LZ4_FORCE_INLINE void LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset) { BYTE v[8]; assert(dstEnd >= dstPtr + MINMATCH); switch(offset) { case 1: MEM_INIT(v, *srcPtr, 8); break; case 2: LZ4_memcpy(v, srcPtr, 2); LZ4_memcpy(&v[2], srcPtr, 2); #if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */ # pragma warning(push) # pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */ #endif LZ4_memcpy(&v[4], v, 4); #if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */ # pragma warning(pop) #endif break; case 4: LZ4_memcpy(v, srcPtr, 4); LZ4_memcpy(&v[4], srcPtr, 4); break; default: LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset); return; } LZ4_memcpy(dstPtr, v, 8); dstPtr += 8; while (dstPtr < dstEnd) { LZ4_memcpy(dstPtr, v, 8); dstPtr += 8; } } #endif /*-************************************ * Common functions **************************************/ static unsigned LZ4_NbCommonBytes (reg_t val) { assert(val != 0); if (LZ4_isLittleEndian()) { if (sizeof(val) == 8) { # if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT) /*-************************************************************************************************* * ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11. * The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics * including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC. ****************************************************************************************************/ # if defined(__clang__) && (__clang_major__ < 10) /* Avoid undefined clang-cl intrinsics issue. * See https://github.com/lz4/lz4/pull/1017 for details. */ return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3; # else /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */ return (unsigned)_tzcnt_u64(val) >> 3; # endif # elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) unsigned long r = 0; _BitScanForward64(&r, (U64)val); return (unsigned)r >> 3; # elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ !defined(LZ4_FORCE_SW_BITCOUNT) return (unsigned)__builtin_ctzll((U64)val) >> 3; # else const U64 m = 0x0101010101010101ULL; val ^= val - 1; return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56); # endif } else /* 32 bits */ { # if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT) unsigned long r; _BitScanForward(&r, (U32)val); return (unsigned)r >> 3; # elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT) return (unsigned)__builtin_ctz((U32)val) >> 3; # else const U32 m = 0x01010101; return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24; # endif } } else /* Big Endian CPU */ { if (sizeof(val)==8) { # if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT) return (unsigned)__builtin_clzll((U64)val) >> 3; # else #if 1 /* this method is probably faster, * but adds a 128 bytes lookup table */ static const unsigned char ctz7_tab[128] = { 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, }; U64 const mask = 0x0101010101010101ULL; U64 const t = (((val >> 8) - mask) | val) & mask; return ctz7_tab[(t * 0x0080402010080402ULL) >> 57]; #else /* this method doesn't consume memory space like the previous one, * but it contains several branches, * that may end up slowing execution */ static const U32 by32 = sizeof(val)*4; /* 32 on 64 bits (goal), 16 on 32 bits. Just to avoid some static analyzer complaining about shift by 32 on 32-bits target. Note that this code path is never triggered in 32-bits mode. */ unsigned r; if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; } if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } r += (!val); return r; #endif # endif } else /* 32 bits */ { # if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \ ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \ !defined(LZ4_FORCE_SW_BITCOUNT) return (unsigned)__builtin_clz((U32)val) >> 3; # else val >>= 8; val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) | (val + 0x00FF0000)) >> 24; return (unsigned)val ^ 3; # endif } } } #define STEPSIZE sizeof(reg_t) LZ4_FORCE_INLINE unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) { const BYTE* const pStart = pIn; if (likely(pIn < pInLimit-(STEPSIZE-1))) { reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; } else { return LZ4_NbCommonBytes(diff); } } while (likely(pIn < pInLimit-(STEPSIZE-1))) { reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; } pIn += LZ4_NbCommonBytes(diff); return (unsigned)(pIn - pStart); } if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; } if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; } if ((pIn compression run slower on incompressible data */ /*-************************************ * Local Structures and types **************************************/ typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t; /** * This enum distinguishes several different modes of accessing previous * content in the stream. * * - noDict : There is no preceding content. * - withPrefix64k : Table entries up to ctx->dictSize before the current blob * blob being compressed are valid and refer to the preceding * content (of length ctx->dictSize), which is available * contiguously preceding in memory the content currently * being compressed. * - usingExtDict : Like withPrefix64k, but the preceding content is somewhere * else in memory, starting at ctx->dictionary with length * ctx->dictSize. * - usingDictCtx : Everything concerning the preceding content is * in a separate context, pointed to by ctx->dictCtx. * ctx->dictionary, ctx->dictSize, and table entries * in the current context that refer to positions * preceding the beginning of the current compression are * ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx * ->dictSize describe the location and size of the preceding * content, and matches are found by looking in the ctx * ->dictCtx->hashTable. */ typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive; typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; /*-************************************ * Local Utils **************************************/ int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; } int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); } /*-**************************************** * Internal Definitions, used only in Tests *******************************************/ #if defined (__cplusplus) extern "C" { #endif int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize); int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const void* dictStart, size_t dictSize); int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const void* dictStart, size_t dictSize); #if defined (__cplusplus) } #endif /*-****************************** * Compression functions ********************************/ LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType) { if (tableType == byU16) return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1))); else return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG)); } LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType) { const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG; if (LZ4_isLittleEndian()) { const U64 prime5bytes = 889523592379ULL; return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog)); } else { const U64 prime8bytes = 11400714785074694791ULL; return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog)); } } LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType) { if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType); #ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT return LZ4_hash4(LZ4_readLE32(p), tableType); #else return LZ4_hash4(LZ4_read32(p), tableType); #endif } LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType) { switch (tableType) { default: /* fallthrough */ case clearedTable: { /* illegal! */ assert(0); return; } case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; } case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; } case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; } } } LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType) { switch (tableType) { default: /* fallthrough */ case clearedTable: /* fallthrough */ case byPtr: { /* illegal! */ assert(0); return; } case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; } case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; } } } /* LZ4_putPosition*() : only used in byPtr mode */ LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType) { const BYTE** const hashTable = (const BYTE**)tableBase; assert(tableType == byPtr); (void)tableType; hashTable[h] = p; } LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType) { U32 const h = LZ4_hashPosition(p, tableType); LZ4_putPositionOnHash(p, h, tableBase, tableType); } /* LZ4_getIndexOnHash() : * Index of match position registered in hash table. * hash position must be calculated by using base+index, or dictBase+index. * Assumption 1 : only valid if tableType == byU32 or byU16. * Assumption 2 : h is presumed valid (within limits of hash table) */ LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType) { LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2); if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; assert(h < (1U << (LZ4_MEMORY_USAGE-2))); return hashTable[h]; } if (tableType == byU16) { const U16* const hashTable = (const U16*) tableBase; assert(h < (1U << (LZ4_MEMORY_USAGE-1))); return hashTable[h]; } assert(0); return 0; /* forbidden case */ } static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType) { assert(tableType == byPtr); (void)tableType; { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; } } LZ4_FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, const void* tableBase, tableType_t tableType) { U32 const h = LZ4_hashPosition(p, tableType); return LZ4_getPositionOnHash(h, tableBase, tableType); } LZ4_FORCE_INLINE void LZ4_prepareTable(LZ4_stream_t_internal* const cctx, const int inputSize, const tableType_t tableType) { /* If the table hasn't been used, it's guaranteed to be zeroed out, and is * therefore safe to use no matter what mode we're in. Otherwise, we figure * out if it's safe to leave as is or whether it needs to be reset. */ if ((tableType_t)cctx->tableType != clearedTable) { assert(inputSize >= 0); if ((tableType_t)cctx->tableType != tableType || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU) || ((tableType == byU32) && cctx->currentOffset > 1 GB) || tableType == byPtr || inputSize >= 4 KB) { DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx); MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE); cctx->currentOffset = 0; cctx->tableType = (U32)clearedTable; } else { DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)"); } } /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, * is faster than compressing without a gap. * However, compressing with currentOffset == 0 is faster still, * so we preserve that case. */ if (cctx->currentOffset != 0 && tableType == byU32) { DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset"); cctx->currentOffset += 64 KB; } /* Finally, clear history */ cctx->dictCtx = NULL; cctx->dictionary = NULL; cctx->dictSize = 0; } /** LZ4_compress_generic_validated() : * inlined, to ensure branches are decided at compilation time. * The following conditions are presumed already validated: * - source != NULL * - inputSize > 0 */ LZ4_FORCE_INLINE int LZ4_compress_generic_validated( LZ4_stream_t_internal* const cctx, const char* const source, char* const dest, const int inputSize, int* inputConsumed, /* only written when outputDirective == fillOutput */ const int maxOutputSize, const limitedOutput_directive outputDirective, const tableType_t tableType, const dict_directive dictDirective, const dictIssue_directive dictIssue, const int acceleration) { int result; const BYTE* ip = (const BYTE*)source; U32 const startIndex = cctx->currentOffset; const BYTE* base = (const BYTE*)source - startIndex; const BYTE* lowLimit; const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx; const BYTE* const dictionary = dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary; const U32 dictSize = dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize; const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0; /* make indexes in dictCtx comparable with indexes in current context */ int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx); U32 const prefixIdxLimit = startIndex - dictSize; /* used when dictDirective == dictSmall */ const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary; const BYTE* anchor = (const BYTE*) source; const BYTE* const iend = ip + inputSize; const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1; const BYTE* const matchlimit = iend - LASTLITERALS; /* the dictCtx currentOffset is indexed on the start of the dictionary, * while a dictionary in the current context precedes the currentOffset */ const BYTE* dictBase = (dictionary == NULL) ? NULL : (dictDirective == usingDictCtx) ? dictionary + dictSize - dictCtx->currentOffset : dictionary + dictSize - startIndex; BYTE* op = (BYTE*) dest; BYTE* const olimit = op + maxOutputSize; U32 offset = 0; U32 forwardH; DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType); assert(ip != NULL); if (tableType == byU16) assert(inputSize= 1); lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0); /* Update context state */ if (dictDirective == usingDictCtx) { /* Subsequent linked blocks can't use the dictionary. */ /* Instead, they use the block we just compressed. */ cctx->dictCtx = NULL; cctx->dictSize = (U32)inputSize; } else { cctx->dictSize += (U32)inputSize; } cctx->currentOffset += (U32)inputSize; cctx->tableType = (U32)tableType; if (inputSizehashTable, byPtr); } else { LZ4_putIndexOnHash(startIndex, h, cctx->hashTable, tableType); } } ip++; forwardH = LZ4_hashPosition(ip, tableType); /* Main Loop */ for ( ; ; ) { const BYTE* match; BYTE* token; const BYTE* filledIp; /* Find a match */ if (tableType == byPtr) { const BYTE* forwardIp = ip; int step = 1; int searchMatchNb = acceleration << LZ4_skipTrigger; do { U32 const h = forwardH; ip = forwardIp; forwardIp += step; step = (searchMatchNb++ >> LZ4_skipTrigger); if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals; assert(ip < mflimitPlusOne); match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType); forwardH = LZ4_hashPosition(forwardIp, tableType); LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType); } while ( (match+LZ4_DISTANCE_MAX < ip) || (LZ4_read32(match) != LZ4_read32(ip)) ); } else { /* byU32, byU16 */ const BYTE* forwardIp = ip; int step = 1; int searchMatchNb = acceleration << LZ4_skipTrigger; do { U32 const h = forwardH; U32 const current = (U32)(forwardIp - base); U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType); assert(matchIndex <= current); assert(forwardIp - base < (ptrdiff_t)(2 GB - 1)); ip = forwardIp; forwardIp += step; step = (searchMatchNb++ >> LZ4_skipTrigger); if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals; assert(ip < mflimitPlusOne); if (dictDirective == usingDictCtx) { if (matchIndex < startIndex) { /* there was no match, try the dictionary */ assert(tableType == byU32); matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32); match = dictBase + matchIndex; matchIndex += dictDelta; /* make dictCtx index comparable with current context */ lowLimit = dictionary; } else { match = base + matchIndex; lowLimit = (const BYTE*)source; } } else if (dictDirective == usingExtDict) { if (matchIndex < startIndex) { DEBUGLOG(7, "extDict candidate: matchIndex=%5u < startIndex=%5u", matchIndex, startIndex); assert(startIndex - matchIndex >= MINMATCH); assert(dictBase); match = dictBase + matchIndex; lowLimit = dictionary; } else { match = base + matchIndex; lowLimit = (const BYTE*)source; } } else { /* single continuous memory segment */ match = base + matchIndex; } forwardH = LZ4_hashPosition(forwardIp, tableType); LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType); DEBUGLOG(7, "candidate at pos=%u (offset=%u \n", matchIndex, current - matchIndex); if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; } /* match outside of valid area */ assert(matchIndex < current); if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX)) && (matchIndex+LZ4_DISTANCE_MAX < current)) { continue; } /* too far */ assert((current - matchIndex) <= LZ4_DISTANCE_MAX); /* match now expected within distance */ if (LZ4_read32(match) == LZ4_read32(ip)) { if (maybe_extMem) offset = current - matchIndex; break; /* match found */ } } while(1); } /* Catch up */ filledIp = ip; assert(ip > anchor); /* this is always true as ip has been advanced before entering the main loop */ if ((match > lowLimit) && unlikely(ip[-1] == match[-1])) { do { ip--; match--; } while (((ip > anchor) & (match > lowLimit)) && (unlikely(ip[-1] == match[-1]))); } /* Encode Literals */ { unsigned const litLength = (unsigned)(ip - anchor); token = op++; if ((outputDirective == limitedOutput) && /* Check output buffer overflow */ (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) { return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ } if ((outputDirective == fillOutput) && (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) { op--; goto _last_literals; } if (litLength >= RUN_MASK) { int len = (int)(litLength - RUN_MASK); *token = (RUN_MASK<= 255 ; len-=255) *op++ = 255; *op++ = (BYTE)len; } else *token = (BYTE)(litLength< olimit)) { /* the match was too close to the end, rewind and go to last literals */ op = token; goto _last_literals; } /* Encode Offset */ if (maybe_extMem) { /* static test */ DEBUGLOG(6, " with offset=%u (ext if > %i)", offset, (int)(ip - (const BYTE*)source)); assert(offset <= LZ4_DISTANCE_MAX && offset > 0); LZ4_writeLE16(op, (U16)offset); op+=2; } else { DEBUGLOG(6, " with offset=%u (same segment)", (U32)(ip - match)); assert(ip-match <= LZ4_DISTANCE_MAX); LZ4_writeLE16(op, (U16)(ip - match)); op+=2; } /* Encode MatchLength */ { unsigned matchCode; if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx) && (lowLimit==dictionary) /* match within extDict */ ) { const BYTE* limit = ip + (dictEnd-match); assert(dictEnd > match); if (limit > matchlimit) limit = matchlimit; matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit); ip += (size_t)matchCode + MINMATCH; if (ip==limit) { unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit); matchCode += more; ip += more; } DEBUGLOG(6, " with matchLength=%u starting in extDict", matchCode+MINMATCH); } else { matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit); ip += (size_t)matchCode + MINMATCH; DEBUGLOG(6, " with matchLength=%u", matchCode+MINMATCH); } if ((outputDirective) && /* Check output buffer overflow */ (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) { if (outputDirective == fillOutput) { /* Match description too long : reduce it */ U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255; ip -= matchCode - newMatchCode; assert(newMatchCode < matchCode); matchCode = newMatchCode; if (unlikely(ip <= filledIp)) { /* We have already filled up to filledIp so if ip ends up less than filledIp * we have positions in the hash table beyond the current position. This is * a problem if we reuse the hash table. So we have to remove these positions * from the hash table. */ const BYTE* ptr; DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip)); for (ptr = ip; ptr <= filledIp; ++ptr) { U32 const h = LZ4_hashPosition(ptr, tableType); LZ4_clearHash(h, cctx->hashTable, tableType); } } } else { assert(outputDirective == limitedOutput); return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ } } if (matchCode >= ML_MASK) { *token += ML_MASK; matchCode -= ML_MASK; LZ4_write32(op, 0xFFFFFFFF); while (matchCode >= 4*255) { op+=4; LZ4_write32(op, 0xFFFFFFFF); matchCode -= 4*255; } op += matchCode / 255; *op++ = (BYTE)(matchCode % 255); } else *token += (BYTE)(matchCode); } /* Ensure we have enough space for the last literals. */ assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit)); anchor = ip; /* Test end of chunk */ if (ip >= mflimitPlusOne) break; /* Fill table */ { U32 const h = LZ4_hashPosition(ip-2, tableType); if (tableType == byPtr) { LZ4_putPositionOnHash(ip-2, h, cctx->hashTable, byPtr); } else { U32 const idx = (U32)((ip-2) - base); LZ4_putIndexOnHash(idx, h, cctx->hashTable, tableType); } } /* Test next position */ if (tableType == byPtr) { match = LZ4_getPosition(ip, cctx->hashTable, tableType); LZ4_putPosition(ip, cctx->hashTable, tableType); if ( (match+LZ4_DISTANCE_MAX >= ip) && (LZ4_read32(match) == LZ4_read32(ip)) ) { token=op++; *token=0; goto _next_match; } } else { /* byU32, byU16 */ U32 const h = LZ4_hashPosition(ip, tableType); U32 const current = (U32)(ip-base); U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType); assert(matchIndex < current); if (dictDirective == usingDictCtx) { if (matchIndex < startIndex) { /* there was no match, try the dictionary */ assert(tableType == byU32); matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32); match = dictBase + matchIndex; lowLimit = dictionary; /* required for match length counter */ matchIndex += dictDelta; } else { match = base + matchIndex; lowLimit = (const BYTE*)source; /* required for match length counter */ } } else if (dictDirective==usingExtDict) { if (matchIndex < startIndex) { assert(dictBase); match = dictBase + matchIndex; lowLimit = dictionary; /* required for match length counter */ } else { match = base + matchIndex; lowLimit = (const BYTE*)source; /* required for match length counter */ } } else { /* single memory segment */ match = base + matchIndex; } LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType); assert(matchIndex < current); if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1) && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current)) && (LZ4_read32(match) == LZ4_read32(ip)) ) { token=op++; *token=0; if (maybe_extMem) offset = current - matchIndex; DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i", (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source)); goto _next_match; } } /* Prepare next loop */ forwardH = LZ4_hashPosition(++ip, tableType); } _last_literals: /* Encode Last Literals */ { size_t lastRun = (size_t)(iend - anchor); if ( (outputDirective) && /* Check output buffer overflow */ (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) { if (outputDirective == fillOutput) { /* adapt lastRun to fill 'dst' */ assert(olimit >= op); lastRun = (size_t)(olimit-op) - 1/*token*/; lastRun -= (lastRun + 256 - RUN_MASK) / 256; /*additional length tokens*/ } else { assert(outputDirective == limitedOutput); return 0; /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */ } } DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun); if (lastRun >= RUN_MASK) { size_t accumulator = lastRun - RUN_MASK; *op++ = RUN_MASK << ML_BITS; for(; accumulator >= 255 ; accumulator-=255) *op++ = 255; *op++ = (BYTE) accumulator; } else { *op++ = (BYTE)(lastRun< 0); DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result); return result; } /** LZ4_compress_generic() : * inlined, to ensure branches are decided at compilation time; * takes care of src == (NULL, 0) * and forward the rest to LZ4_compress_generic_validated */ LZ4_FORCE_INLINE int LZ4_compress_generic( LZ4_stream_t_internal* const cctx, const char* const src, char* const dst, const int srcSize, int *inputConsumed, /* only written when outputDirective == fillOutput */ const int dstCapacity, const limitedOutput_directive outputDirective, const tableType_t tableType, const dict_directive dictDirective, const dictIssue_directive dictIssue, const int acceleration) { DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i", srcSize, dstCapacity); if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; } /* Unsupported srcSize, too large (or negative) */ if (srcSize == 0) { /* src == NULL supported if srcSize == 0 */ if (outputDirective != notLimited && dstCapacity <= 0) return 0; /* no output, can't write anything */ DEBUGLOG(5, "Generating an empty block"); assert(outputDirective == notLimited || dstCapacity >= 1); assert(dst != NULL); dst[0] = 0; if (outputDirective == fillOutput) { assert (inputConsumed != NULL); *inputConsumed = 0; } return 1; } assert(src != NULL); return LZ4_compress_generic_validated(cctx, src, dst, srcSize, inputConsumed, /* only written into if outputDirective == fillOutput */ dstCapacity, outputDirective, tableType, dictDirective, dictIssue, acceleration); } int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration) { LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse; assert(ctx != NULL); if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; if (maxOutputSize >= LZ4_compressBound(inputSize)) { if (inputSize < LZ4_64Klimit) { return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration); } else { const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32; return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); } } else { if (inputSize < LZ4_64Klimit) { return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration); } else { const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32; return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration); } } } /** * LZ4_compress_fast_extState_fastReset() : * A variant of LZ4_compress_fast_extState(). * * Using this variant avoids an expensive initialization step. It is only safe * to call if the state buffer is known to be correctly initialized already * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of * "correctly initialized"). */ int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration) { LZ4_stream_t_internal* const ctx = &((LZ4_stream_t*)state)->internal_donotuse; if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; assert(ctx != NULL); if (dstCapacity >= LZ4_compressBound(srcSize)) { if (srcSize < LZ4_64Klimit) { const tableType_t tableType = byU16; LZ4_prepareTable(ctx, srcSize, tableType); if (ctx->currentOffset) { return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration); } else { return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); } } else { const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; LZ4_prepareTable(ctx, srcSize, tableType); return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration); } } else { if (srcSize < LZ4_64Klimit) { const tableType_t tableType = byU16; LZ4_prepareTable(ctx, srcSize, tableType); if (ctx->currentOffset) { return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration); } else { return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration); } } else { const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; LZ4_prepareTable(ctx, srcSize, tableType); return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration); } } } int LZ4_compress_fast(const char* src, char* dest, int srcSize, int dstCapacity, int acceleration) { int result; #if (LZ4_HEAPMODE) LZ4_stream_t* const ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ if (ctxPtr == NULL) return 0; #else LZ4_stream_t ctx; LZ4_stream_t* const ctxPtr = &ctx; #endif result = LZ4_compress_fast_extState(ctxPtr, src, dest, srcSize, dstCapacity, acceleration); #if (LZ4_HEAPMODE) FREEMEM(ctxPtr); #endif return result; } int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity) { return LZ4_compress_fast(src, dst, srcSize, dstCapacity, 1); } /* Note!: This function leaves the stream in an unclean/broken state! * It is not safe to subsequently use the same state with a _fastReset() or * _continue() call without resetting it. */ static int LZ4_compress_destSize_extState_internal(LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration) { void* const s = LZ4_initStream(state, sizeof (*state)); assert(s != NULL); (void)s; if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) { /* compression success is guaranteed */ return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, acceleration); } else { if (*srcSizePtr < LZ4_64Klimit) { return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, acceleration); } else { tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32; return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, acceleration); } } } int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration) { int const r = LZ4_compress_destSize_extState_internal((LZ4_stream_t*)state, src, dst, srcSizePtr, targetDstSize, acceleration); /* clean the state on exit */ LZ4_initStream(state, sizeof (LZ4_stream_t)); return r; } int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize) { #if (LZ4_HEAPMODE) LZ4_stream_t* const ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ if (ctx == NULL) return 0; #else LZ4_stream_t ctxBody; LZ4_stream_t* const ctx = &ctxBody; #endif int result = LZ4_compress_destSize_extState_internal(ctx, src, dst, srcSizePtr, targetDstSize, 1); #if (LZ4_HEAPMODE) FREEMEM(ctx); #endif return result; } /*-****************************** * Streaming functions ********************************/ #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4_stream_t* LZ4_createStream(void) { LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal)); DEBUGLOG(4, "LZ4_createStream %p", lz4s); if (lz4s == NULL) return NULL; LZ4_initStream(lz4s, sizeof(*lz4s)); return lz4s; } #endif static size_t LZ4_stream_t_alignment(void) { #if LZ4_ALIGN_TEST typedef struct { char c; LZ4_stream_t t; } t_a; return sizeof(t_a) - sizeof(LZ4_stream_t); #else return 1; /* effectively disabled */ #endif } LZ4_stream_t* LZ4_initStream (void* buffer, size_t size) { DEBUGLOG(5, "LZ4_initStream"); if (buffer == NULL) { return NULL; } if (size < sizeof(LZ4_stream_t)) { return NULL; } if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL; MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal)); return (LZ4_stream_t*)buffer; } /* resetStream is now deprecated, * prefer initStream() which is more general */ void LZ4_resetStream (LZ4_stream_t* LZ4_stream) { DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream); MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal)); } void LZ4_resetStream_fast(LZ4_stream_t* ctx) { LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32); } #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) int LZ4_freeStream (LZ4_stream_t* LZ4_stream) { if (!LZ4_stream) return 0; /* support free on NULL */ DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream); FREEMEM(LZ4_stream); return (0); } #endif #define HASH_UNIT sizeof(reg_t) int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) { LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse; const tableType_t tableType = byU32; const BYTE* p = (const BYTE*)dictionary; const BYTE* const dictEnd = p + dictSize; U32 idx32; DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict); /* It's necessary to reset the context, * and not just continue it with prepareTable() * to avoid any risk of generating overflowing matchIndex * when compressing using this dictionary */ LZ4_resetStream(LZ4_dict); /* We always increment the offset by 64 KB, since, if the dict is longer, * we truncate it to the last 64k, and if it's shorter, we still want to * advance by a whole window length so we can provide the guarantee that * there are only valid offsets in the window, which allows an optimization * in LZ4_compress_fast_continue() where it uses noDictIssue even when the * dictionary isn't a full 64k. */ dict->currentOffset += 64 KB; if (dictSize < (int)HASH_UNIT) { return 0; } if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB; dict->dictionary = p; dict->dictSize = (U32)(dictEnd - p); dict->tableType = (U32)tableType; idx32 = dict->currentOffset - dict->dictSize; while (p <= dictEnd-HASH_UNIT) { U32 const h = LZ4_hashPosition(p, tableType); LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType); p+=3; idx32+=3; } return (int)dict->dictSize; } void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) { const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL : &(dictionaryStream->internal_donotuse); DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)", workingStream, dictionaryStream, dictCtx != NULL ? dictCtx->dictSize : 0); if (dictCtx != NULL) { /* If the current offset is zero, we will never look in the * external dictionary context, since there is no value a table * entry can take that indicate a miss. In that case, we need * to bump the offset to something non-zero. */ if (workingStream->internal_donotuse.currentOffset == 0) { workingStream->internal_donotuse.currentOffset = 64 KB; } /* Don't actually attach an empty dictionary. */ if (dictCtx->dictSize == 0) { dictCtx = NULL; } } workingStream->internal_donotuse.dictCtx = dictCtx; } static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize) { assert(nextSize >= 0); if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) { /* potential ptrdiff_t overflow (32-bits mode) */ /* rescale hash table */ U32 const delta = LZ4_dict->currentOffset - 64 KB; const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize; int i; DEBUGLOG(4, "LZ4_renormDictT"); for (i=0; ihashTable[i] < delta) LZ4_dict->hashTable[i]=0; else LZ4_dict->hashTable[i] -= delta; } LZ4_dict->currentOffset = 64 KB; if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB; LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize; } } int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration) { const tableType_t tableType = byU32; LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse; const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL; DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize); LZ4_renormDictT(streamPtr, inputSize); /* fix index overflow */ if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; /* invalidate tiny dictionaries */ if ( (streamPtr->dictSize < 4) /* tiny dictionary : not enough for a hash */ && (dictEnd != source) /* prefix mode */ && (inputSize > 0) /* tolerance : don't lose history, in case next invocation would use prefix mode */ && (streamPtr->dictCtx == NULL) /* usingDictCtx */ ) { DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary); /* remove dictionary existence from history, to employ faster prefix mode */ streamPtr->dictSize = 0; streamPtr->dictionary = (const BYTE*)source; dictEnd = source; } /* Check overlapping input/dictionary space */ { const char* const sourceEnd = source + inputSize; if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) { streamPtr->dictSize = (U32)(dictEnd - sourceEnd); if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB; if (streamPtr->dictSize < 4) streamPtr->dictSize = 0; streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize; } } /* prefix mode : source data follows dictionary */ if (dictEnd == source) { if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration); else return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration); } /* external dictionary mode */ { int result; if (streamPtr->dictCtx) { /* We depend here on the fact that dictCtx'es (produced by * LZ4_loadDict) guarantee that their tables contain no references * to offsets between dictCtx->currentOffset - 64 KB and * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe * to use noDictIssue even when the dict isn't a full 64 KB. */ if (inputSize > 4 KB) { /* For compressing large blobs, it is faster to pay the setup * cost to copy the dictionary's tables into the active context, * so that the compression loop is only looking into one table. */ LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr)); result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration); } else { result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration); } } else { /* small data <= 4 KB */ if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) { result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration); } else { result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration); } } streamPtr->dictionary = (const BYTE*)source; streamPtr->dictSize = (U32)inputSize; return result; } } /* Hidden debug function, to force-test external dictionary mode */ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize) { LZ4_stream_t_internal* const streamPtr = &LZ4_dict->internal_donotuse; int result; LZ4_renormDictT(streamPtr, srcSize); if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) { result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1); } else { result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1); } streamPtr->dictionary = (const BYTE*)source; streamPtr->dictSize = (U32)srcSize; return result; } /*! LZ4_saveDict() : * If previously compressed data block is not guaranteed to remain available at its memory location, * save it into a safer place (char* safeBuffer). * Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable, * one can therefore call LZ4_compress_fast_continue() right after. * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error. */ int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize) { LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse; DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer); if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */ if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; } if (safeBuffer == NULL) assert(dictSize == 0); if (dictSize > 0) { const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize; assert(dict->dictionary); LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize); } dict->dictionary = (const BYTE*)safeBuffer; dict->dictSize = (U32)dictSize; return dictSize; } /*-******************************* * Decompression functions ********************************/ typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; #undef MIN #define MIN(a,b) ( (a) < (b) ? (a) : (b) ) /* variant for decompress_unsafe() * does not know end of input * presumes input is well formed * note : will consume at least one byte */ static size_t read_long_length_no_check(const BYTE** pp) { size_t b, l = 0; do { b = **pp; (*pp)++; l += b; } while (b==255); DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1) return l; } /* core decoder variant for LZ4_decompress_fast*() * for legacy support only : these entry points are deprecated. * - Presumes input is correctly formed (no defense vs malformed inputs) * - Does not know input size (presume input buffer is "large enough") * - Decompress a full block (only) * @return : nb of bytes read from input. * Note : this variant is not optimized for speed, just for maintenance. * the goal is to remove support of decompress_fast*() variants by v2.0 **/ LZ4_FORCE_INLINE int LZ4_decompress_unsafe_generic( const BYTE* const istart, BYTE* const ostart, int decompressedSize, size_t prefixSize, const BYTE* const dictStart, /* only if dict==usingExtDict */ const size_t dictSize /* note: =0 if dictStart==NULL */ ) { const BYTE* ip = istart; BYTE* op = (BYTE*)ostart; BYTE* const oend = ostart + decompressedSize; const BYTE* const prefixStart = ostart - prefixSize; DEBUGLOG(5, "LZ4_decompress_unsafe_generic"); if (dictStart == NULL) assert(dictSize == 0); while (1) { /* start new sequence */ unsigned token = *ip++; /* literals */ { size_t ll = token >> ML_BITS; if (ll==15) { /* long literal length */ ll += read_long_length_no_check(&ip); } if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */ LZ4_memmove(op, ip, ll); /* support in-place decompression */ op += ll; ip += ll; if ((size_t)(oend-op) < MFLIMIT) { if (op==oend) break; /* end of block */ DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op); /* incorrect end of block : * last match must start at least MFLIMIT==12 bytes before end of output block */ return -1; } } /* match */ { size_t ml = token & 15; size_t const offset = LZ4_readLE16(ip); ip+=2; if (ml==15) { /* long literal length */ ml += read_long_length_no_check(&ip); } ml += MINMATCH; if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */ { const BYTE* match = op - offset; /* out of range */ if (offset > (size_t)(op - prefixStart) + dictSize) { DEBUGLOG(6, "offset out of range"); return -1; } /* check special case : extDict */ if (offset > (size_t)(op - prefixStart)) { /* extDict scenario */ const BYTE* const dictEnd = dictStart + dictSize; const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart)); size_t const extml = (size_t)(dictEnd - extMatch); if (extml > ml) { /* match entirely within extDict */ LZ4_memmove(op, extMatch, ml); op += ml; ml = 0; } else { /* match split between extDict & prefix */ LZ4_memmove(op, extMatch, extml); op += extml; ml -= extml; } match = prefixStart; } /* match copy - slow variant, supporting overlap copy */ { size_t u; for (u=0; u= ipmax before start of loop. Returns initial_error if so. * @error (output) - error code. Must be set to 0 before call. **/ typedef size_t Rvl_t; static const Rvl_t rvl_error = (Rvl_t)(-1); LZ4_FORCE_INLINE Rvl_t read_variable_length(const BYTE** ip, const BYTE* ilimit, int initial_check) { Rvl_t s, length = 0; assert(ip != NULL); assert(*ip != NULL); assert(ilimit != NULL); if (initial_check && unlikely((*ip) >= ilimit)) { /* read limit reached */ return rvl_error; } s = **ip; (*ip)++; length += s; if (unlikely((*ip) > ilimit)) { /* read limit reached */ return rvl_error; } /* accumulator overflow detection (32-bit mode only) */ if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) { return rvl_error; } if (likely(s != 255)) return length; do { s = **ip; (*ip)++; length += s; if (unlikely((*ip) > ilimit)) { /* read limit reached */ return rvl_error; } /* accumulator overflow detection (32-bit mode only) */ if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) { return rvl_error; } } while (s == 255); return length; } /*! LZ4_decompress_generic() : * This generic decompression function covers all use cases. * It shall be instantiated several times, using different sets of directives. * Note that it is important for performance that this function really get inlined, * in order to remove useless branches during compilation optimization. */ LZ4_FORCE_INLINE int LZ4_decompress_generic( const char* const src, char* const dst, int srcSize, int outputSize, /* If endOnInput==endOnInputSize, this value is `dstCapacity` */ earlyEnd_directive partialDecoding, /* full, partial */ dict_directive dict, /* noDict, withPrefix64k, usingExtDict */ const BYTE* const lowPrefix, /* always <= dst, == dst when no prefix */ const BYTE* const dictStart, /* only if dict==usingExtDict */ const size_t dictSize /* note : = 0 if noDict */ ) { if ((src == NULL) || (outputSize < 0)) { return -1; } { const BYTE* ip = (const BYTE*) src; const BYTE* const iend = ip + srcSize; BYTE* op = (BYTE*) dst; BYTE* const oend = op + outputSize; BYTE* cpy; const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize; const int checkOffset = (dictSize < (int)(64 KB)); /* Set up the "end" pointers for the shortcut. */ const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/; const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/; const BYTE* match; size_t offset; unsigned token; size_t length; DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize); /* Special cases */ assert(lowPrefix <= op); if (unlikely(outputSize==0)) { /* Empty output buffer */ if (partialDecoding) return 0; return ((srcSize==1) && (*ip==0)) ? 0 : -1; } if (unlikely(srcSize==0)) { return -1; } /* LZ4_FAST_DEC_LOOP: * designed for modern OoO performance cpus, * where copying reliably 32-bytes is preferable to an unpredictable branch. * note : fast loop may show a regression for some client arm chips. */ #if LZ4_FAST_DEC_LOOP if ((oend - op) < FASTLOOP_SAFE_DISTANCE) { DEBUGLOG(6, "skip fast decode loop"); goto safe_decode; } /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */ DEBUGLOG(6, "using fast decode loop"); while (1) { /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */ assert(oend - op >= FASTLOOP_SAFE_DISTANCE); assert(ip < iend); token = *ip++; length = token >> ML_BITS; /* literal length */ /* decode literal length */ if (length == RUN_MASK) { size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); if (addl == rvl_error) { DEBUGLOG(6, "error reading long literal length"); goto _output_error; } length += addl; if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ /* copy literals */ LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); if ((op+length>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; } LZ4_wildCopy32(op, ip, op+length); ip += length; op += length; } else if (ip <= iend-(16 + 1/*max lit + offset + nextToken*/)) { /* We don't need to check oend, since we check it once for each loop below */ DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length); /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */ LZ4_memcpy(op, ip, 16); ip += length; op += length; } else { goto safe_literal_copy; } /* get offset */ offset = LZ4_readLE16(ip); ip+=2; DEBUGLOG(6, " offset = %zu", offset); match = op - offset; assert(match <= op); /* overflow check */ /* get matchlength */ length = token & ML_MASK; if (length == ML_MASK) { size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); if (addl == rvl_error) { DEBUGLOG(6, "error reading long match length"); goto _output_error; } length += addl; length += MINMATCH; if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */ if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) { goto safe_match_copy; } } else { length += MINMATCH; if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) { goto safe_match_copy; } /* Fastpath check: skip LZ4_wildCopy32 when true */ if ((dict == withPrefix64k) || (match >= lowPrefix)) { if (offset >= 8) { assert(match >= lowPrefix); assert(match <= op); assert(op + 18 <= oend); LZ4_memcpy(op, match, 8); LZ4_memcpy(op+8, match+8, 8); LZ4_memcpy(op+16, match+16, 2); op += length; continue; } } } if ( checkOffset && (unlikely(match + dictSize < lowPrefix)) ) { DEBUGLOG(6, "Error : pos=%zi, offset=%zi => outside buffers", op-lowPrefix, op-match); goto _output_error; } /* match starting within external dictionary */ if ((dict==usingExtDict) && (match < lowPrefix)) { assert(dictEnd != NULL); if (unlikely(op+length > oend-LASTLITERALS)) { if (partialDecoding) { DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd"); length = MIN(length, (size_t)(oend-op)); } else { DEBUGLOG(6, "end-of-block condition violated") goto _output_error; } } if (length <= (size_t)(lowPrefix-match)) { /* match fits entirely within external dictionary : just copy */ LZ4_memmove(op, dictEnd - (lowPrefix-match), length); op += length; } else { /* match stretches into both external dictionary and current block */ size_t const copySize = (size_t)(lowPrefix - match); size_t const restSize = length - copySize; LZ4_memcpy(op, dictEnd - copySize, copySize); op += copySize; if (restSize > (size_t)(op - lowPrefix)) { /* overlap copy */ BYTE* const endOfMatch = op + restSize; const BYTE* copyFrom = lowPrefix; while (op < endOfMatch) { *op++ = *copyFrom++; } } else { LZ4_memcpy(op, lowPrefix, restSize); op += restSize; } } continue; } /* copy match within block */ cpy = op + length; assert((op <= oend) && (oend-op >= 32)); if (unlikely(offset<16)) { LZ4_memcpy_using_offset(op, match, cpy, offset); } else { LZ4_wildCopy32(op, match, cpy); } op = cpy; /* wildcopy correction */ } safe_decode: #endif /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */ DEBUGLOG(6, "using safe decode loop"); while (1) { assert(ip < iend); token = *ip++; length = token >> ML_BITS; /* literal length */ /* A two-stage shortcut for the most common case: * 1) If the literal length is 0..14, and there is enough space, * enter the shortcut and copy 16 bytes on behalf of the literals * (in the fast mode, only 8 bytes can be safely copied this way). * 2) Further if the match length is 4..18, copy 18 bytes in a similar * manner; but we ensure that there's enough space in the output for * those 18 bytes earlier, upon entering the shortcut (in other words, * there is a combined check for both stages). */ if ( (length != RUN_MASK) /* strictly "less than" on input, to re-enter the loop with at least one byte */ && likely((ip < shortiend) & (op <= shortoend)) ) { /* Copy the literals */ LZ4_memcpy(op, ip, 16); op += length; ip += length; /* The second stage: prepare for match copying, decode full info. * If it doesn't work out, the info won't be wasted. */ length = token & ML_MASK; /* match length */ offset = LZ4_readLE16(ip); ip += 2; match = op - offset; assert(match <= op); /* check overflow */ /* Do not deal with overlapping matches. */ if ( (length != ML_MASK) && (offset >= 8) && (dict==withPrefix64k || match >= lowPrefix) ) { /* Copy the match. */ LZ4_memcpy(op + 0, match + 0, 8); LZ4_memcpy(op + 8, match + 8, 8); LZ4_memcpy(op +16, match +16, 2); op += length + MINMATCH; /* Both stages worked, load the next token. */ continue; } /* The second stage didn't work out, but the info is ready. * Propel it right to the point of match copying. */ goto _copy_match; } /* decode literal length */ if (length == RUN_MASK) { size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); if (addl == rvl_error) { goto _output_error; } length += addl; if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ } #if LZ4_FAST_DEC_LOOP safe_literal_copy: #endif /* copy literals */ cpy = op+length; LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) { /* We've either hit the input parsing restriction or the output parsing restriction. * In the normal scenario, decoding a full block, it must be the last sequence, * otherwise it's an error (invalid input or dimensions). * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow. */ if (partialDecoding) { /* Since we are partial decoding we may be in this block because of the output parsing * restriction, which is not valid since the output buffer is allowed to be undersized. */ DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end") DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length); DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op)); DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip)); /* Finishing in the middle of a literals segment, * due to lack of input. */ if (ip+length > iend) { length = (size_t)(iend-ip); cpy = op + length; } /* Finishing in the middle of a literals segment, * due to lack of output space. */ if (cpy > oend) { cpy = oend; assert(op<=oend); length = (size_t)(oend-op); } } else { /* We must be on the last sequence (or invalid) because of the parsing limitations * so check that we exactly consume the input and don't overrun the output buffer. */ if ((ip+length != iend) || (cpy > oend)) { DEBUGLOG(6, "should have been last run of literals") DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend); DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend); goto _output_error; } } LZ4_memmove(op, ip, length); /* supports overlapping memory regions, for in-place decompression scenarios */ ip += length; op += length; /* Necessarily EOF when !partialDecoding. * When partialDecoding, it is EOF if we've either * filled the output buffer or * can't proceed with reading an offset for following match. */ if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) { break; } } else { LZ4_wildCopy8(op, ip, cpy); /* can overwrite up to 8 bytes beyond cpy */ ip += length; op = cpy; } /* get offset */ offset = LZ4_readLE16(ip); ip+=2; match = op - offset; /* get matchlength */ length = token & ML_MASK; _copy_match: if (length == ML_MASK) { size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); if (addl == rvl_error) { goto _output_error; } length += addl; if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error; /* overflow detection */ } length += MINMATCH; #if LZ4_FAST_DEC_LOOP safe_match_copy: #endif if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error; /* Error : offset outside buffers */ /* match starting within external dictionary */ if ((dict==usingExtDict) && (match < lowPrefix)) { assert(dictEnd != NULL); if (unlikely(op+length > oend-LASTLITERALS)) { if (partialDecoding) length = MIN(length, (size_t)(oend-op)); else goto _output_error; /* doesn't respect parsing restriction */ } if (length <= (size_t)(lowPrefix-match)) { /* match fits entirely within external dictionary : just copy */ LZ4_memmove(op, dictEnd - (lowPrefix-match), length); op += length; } else { /* match stretches into both external dictionary and current block */ size_t const copySize = (size_t)(lowPrefix - match); size_t const restSize = length - copySize; LZ4_memcpy(op, dictEnd - copySize, copySize); op += copySize; if (restSize > (size_t)(op - lowPrefix)) { /* overlap copy */ BYTE* const endOfMatch = op + restSize; const BYTE* copyFrom = lowPrefix; while (op < endOfMatch) *op++ = *copyFrom++; } else { LZ4_memcpy(op, lowPrefix, restSize); op += restSize; } } continue; } assert(match >= lowPrefix); /* copy match within block */ cpy = op + length; /* partialDecoding : may end anywhere within the block */ assert(op<=oend); if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) { size_t const mlen = MIN(length, (size_t)(oend-op)); const BYTE* const matchEnd = match + mlen; BYTE* const copyEnd = op + mlen; if (matchEnd > op) { /* overlap copy */ while (op < copyEnd) { *op++ = *match++; } } else { LZ4_memcpy(op, match, mlen); } op = copyEnd; if (op == oend) { break; } continue; } if (unlikely(offset<8)) { LZ4_write32(op, 0); /* silence msan warning when offset==0 */ op[0] = match[0]; op[1] = match[1]; op[2] = match[2]; op[3] = match[3]; match += inc32table[offset]; LZ4_memcpy(op+4, match, 4); match -= dec64table[offset]; } else { LZ4_memcpy(op, match, 8); match += 8; } op += 8; if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) { BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1); if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */ if (op < oCopyLimit) { LZ4_wildCopy8(op, match, oCopyLimit); match += oCopyLimit - op; op = oCopyLimit; } while (op < cpy) { *op++ = *match++; } } else { LZ4_memcpy(op, match, 8); if (length > 16) { LZ4_wildCopy8(op+8, match+8, cpy); } } op = cpy; /* wildcopy correction */ } /* end of decoding */ DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst)); return (int) (((char*)op)-dst); /* Nb of output bytes decoded */ /* Overflow error detected */ _output_error: return (int) (-(((const char*)ip)-src))-1; } } /*===== Instantiate the API decoding functions. =====*/ LZ4_FORCE_O2 int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, decode_full_block, noDict, (BYTE*)dest, NULL, 0); } LZ4_FORCE_O2 int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity) { dstCapacity = MIN(targetOutputSize, dstCapacity); return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity, partial_decode, noDict, (BYTE*)dst, NULL, 0); } LZ4_FORCE_O2 int LZ4_decompress_fast(const char* source, char* dest, int originalSize) { DEBUGLOG(5, "LZ4_decompress_fast"); return LZ4_decompress_unsafe_generic( (const BYTE*)source, (BYTE*)dest, originalSize, 0, NULL, 0); } /*===== Instantiate a few more decoding cases, used more than once. =====*/ LZ4_FORCE_O2 /* Exported, an obsolete API function. */ int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, decode_full_block, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 0); } LZ4_FORCE_O2 static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity) { dstCapacity = MIN(targetOutputSize, dstCapacity); return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, partial_decode, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 0); } /* Another obsolete API function, paired with the previous one. */ int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize) { return LZ4_decompress_unsafe_generic( (const BYTE*)source, (BYTE*)dest, originalSize, 64 KB, NULL, 0); } LZ4_FORCE_O2 static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize, size_t prefixSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, decode_full_block, noDict, (BYTE*)dest-prefixSize, NULL, 0); } LZ4_FORCE_O2 static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, size_t prefixSize) { dstCapacity = MIN(targetOutputSize, dstCapacity); return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, partial_decode, noDict, (BYTE*)dest-prefixSize, NULL, 0); } LZ4_FORCE_O2 int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const void* dictStart, size_t dictSize) { DEBUGLOG(5, "LZ4_decompress_safe_forceExtDict"); return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, decode_full_block, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize); } LZ4_FORCE_O2 int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const void* dictStart, size_t dictSize) { dstCapacity = MIN(targetOutputSize, dstCapacity); return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, partial_decode, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize); } LZ4_FORCE_O2 static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize, const void* dictStart, size_t dictSize) { return LZ4_decompress_unsafe_generic( (const BYTE*)source, (BYTE*)dest, originalSize, 0, (const BYTE*)dictStart, dictSize); } /* The "double dictionary" mode, for use with e.g. ring buffers: the first part * of the dictionary is passed as prefix, and the second via dictStart + dictSize. * These routines are used only once, in LZ4_decompress_*_continue(). */ LZ4_FORCE_INLINE int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize, size_t prefixSize, const void* dictStart, size_t dictSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, decode_full_block, usingExtDict, (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize); } /*===== streaming decompression functions =====*/ #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4_streamDecode_t* LZ4_createStreamDecode(void) { LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal)); return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t)); } int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream) { if (LZ4_stream == NULL) { return 0; } /* support free on NULL */ FREEMEM(LZ4_stream); return 0; } #endif /*! LZ4_setStreamDecode() : * Use this function to instruct where to find the dictionary. * This function is not necessary if previous data is still available where it was decoded. * Loading a size of 0 is allowed (same effect as no dictionary). * @return : 1 if OK, 0 if error */ int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize) { LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; lz4sd->prefixSize = (size_t)dictSize; if (dictSize) { assert(dictionary != NULL); lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize; } else { lz4sd->prefixEnd = (const BYTE*) dictionary; } lz4sd->externalDict = NULL; lz4sd->extDictSize = 0; return 1; } /*! LZ4_decoderRingBufferSize() : * when setting a ring buffer for streaming decompression (optional scenario), * provides the minimum size of this ring buffer * to be compatible with any source respecting maxBlockSize condition. * Note : in a ring buffer scenario, * blocks are presumed decompressed next to each other. * When not enough space remains for next block (remainingSize < maxBlockSize), * decoding resumes from beginning of ring buffer. * @return : minimum ring buffer size, * or 0 if there is an error (invalid maxBlockSize). */ int LZ4_decoderRingBufferSize(int maxBlockSize) { if (maxBlockSize < 0) return 0; if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0; if (maxBlockSize < 16) maxBlockSize = 16; return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize); } /* *_continue() : These decoding functions allow decompression of multiple blocks in "streaming" mode. Previously decoded blocks must still be available at the memory position where they were decoded. If it's not possible, save the relevant part of decoded data into a safe buffer, and indicate where it stands using LZ4_setStreamDecode() */ LZ4_FORCE_O2 int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize) { LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; int result; if (lz4sd->prefixSize == 0) { /* The first call, no dictionary yet. */ assert(lz4sd->extDictSize == 0); result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize); if (result <= 0) return result; lz4sd->prefixSize = (size_t)result; lz4sd->prefixEnd = (BYTE*)dest + result; } else if (lz4sd->prefixEnd == (BYTE*)dest) { /* They're rolling the current segment. */ if (lz4sd->prefixSize >= 64 KB - 1) result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize); else if (lz4sd->extDictSize == 0) result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, lz4sd->prefixSize); else result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize, lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize); if (result <= 0) return result; lz4sd->prefixSize += (size_t)result; lz4sd->prefixEnd += result; } else { /* The buffer wraps around, or they're switching to another buffer. */ lz4sd->extDictSize = lz4sd->prefixSize; lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, lz4sd->externalDict, lz4sd->extDictSize); if (result <= 0) return result; lz4sd->prefixSize = (size_t)result; lz4sd->prefixEnd = (BYTE*)dest + result; } return result; } LZ4_FORCE_O2 int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize) { LZ4_streamDecode_t_internal* const lz4sd = (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse); int result; DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize); assert(originalSize >= 0); if (lz4sd->prefixSize == 0) { DEBUGLOG(5, "first invocation : no prefix nor extDict"); assert(lz4sd->extDictSize == 0); result = LZ4_decompress_fast(source, dest, originalSize); if (result <= 0) return result; lz4sd->prefixSize = (size_t)originalSize; lz4sd->prefixEnd = (BYTE*)dest + originalSize; } else if (lz4sd->prefixEnd == (BYTE*)dest) { DEBUGLOG(5, "continue using existing prefix"); result = LZ4_decompress_unsafe_generic( (const BYTE*)source, (BYTE*)dest, originalSize, lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize); if (result <= 0) return result; lz4sd->prefixSize += (size_t)originalSize; lz4sd->prefixEnd += originalSize; } else { DEBUGLOG(5, "prefix becomes extDict"); lz4sd->extDictSize = lz4sd->prefixSize; lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; result = LZ4_decompress_fast_extDict(source, dest, originalSize, lz4sd->externalDict, lz4sd->extDictSize); if (result <= 0) return result; lz4sd->prefixSize = (size_t)originalSize; lz4sd->prefixEnd = (BYTE*)dest + originalSize; } return result; } /* Advanced decoding functions : *_usingDict() : These decoding functions work the same as "_continue" ones, the dictionary must be explicitly provided within parameters */ int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize) { if (dictSize==0) return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize); if (dictStart+dictSize == dest) { if (dictSize >= 64 KB - 1) { return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize); } assert(dictSize >= 0); return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize); } assert(dictSize >= 0); return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize); } int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize) { if (dictSize==0) return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity); if (dictStart+dictSize == dest) { if (dictSize >= 64 KB - 1) { return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity); } assert(dictSize >= 0); return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize); } assert(dictSize >= 0); return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize); } int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize) { if (dictSize==0 || dictStart+dictSize == dest) return LZ4_decompress_unsafe_generic( (const BYTE*)source, (BYTE*)dest, originalSize, (size_t)dictSize, NULL, 0); assert(dictSize >= 0); return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize); } /*=************************************************* * Obsolete Functions ***************************************************/ /* obsolete compression functions */ int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { return LZ4_compress_default(source, dest, inputSize, maxOutputSize); } int LZ4_compress(const char* src, char* dest, int srcSize) { return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize)); } int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1); } int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1); } int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity) { return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1); } int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize) { return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1); } /* These decompression functions are deprecated and should no longer be used. They are only provided here for compatibility with older user programs. - LZ4_uncompress is totally equivalent to LZ4_decompress_fast - LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe */ int LZ4_uncompress (const char* source, char* dest, int outputSize) { return LZ4_decompress_fast(source, dest, outputSize); } int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize) { return LZ4_decompress_safe(source, dest, isize, maxOutputSize); } /* Obsolete Streaming functions */ int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); } int LZ4_resetStreamState(void* state, char* inputBuffer) { (void)inputBuffer; LZ4_resetStream((LZ4_stream_t*)state); return 0; } #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) void* LZ4_create (char* inputBuffer) { (void)inputBuffer; return LZ4_createStream(); } #endif char* LZ4_slideInputBuffer (void* state) { /* avoid const char * -> char * conversion warning */ return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary; } #endif /* LZ4_COMMONDEFS_ONLY */ nvc-r1.17.1/thirdparty/lz4.h000066400000000000000000001276711504111170000156310ustar00rootroot00000000000000/* * LZ4 - Fast LZ compression algorithm * Header File * Copyright (C) 2011-2023, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - LZ4 homepage : http://www.lz4.org - LZ4 source repository : https://github.com/lz4/lz4 */ #if defined (__cplusplus) extern "C" { #endif #ifndef LZ4_H_2983827168210 #define LZ4_H_2983827168210 /* --- Dependency --- */ #include /* size_t */ /** Introduction LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core, scalable with multi-cores CPU. It features an extremely fast decoder, with speed in multiple GB/s per core, typically reaching RAM speed limits on multi-core systems. The LZ4 compression library provides in-memory compression and decompression functions. It gives full buffer control to user. Compression can be done in: - a single step (described as Simple Functions) - a single step, reusing a context (described in Advanced Functions) - unbounded multiple steps (described as Streaming compression) lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md). Decompressing such a compressed block requires additional metadata. Exact metadata depends on exact decompression function. For the typical case of LZ4_decompress_safe(), metadata includes block's compressed size, and maximum bound of decompressed size. Each application is free to encode and pass such metadata in whichever way it wants. lz4.h only handle blocks, it can not generate Frames. Blocks are different from Frames (doc/lz4_Frame_format.md). Frames bundle both blocks and metadata in a specified manner. Embedding metadata is required for compressed data to be self-contained and portable. Frame format is delivered through a companion API, declared in lz4frame.h. The `lz4` CLI can only manage frames. */ /*^*************************************************************** * Export parameters *****************************************************************/ /* * LZ4_DLL_EXPORT : * Enable exporting of functions when building a Windows DLL * LZ4LIB_VISIBILITY : * Control library symbols visibility. */ #ifndef LZ4LIB_VISIBILITY # if defined(__GNUC__) && (__GNUC__ >= 4) # define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default"))) # else # define LZ4LIB_VISIBILITY # endif #endif #if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1) # define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY #elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1) # define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ #else # define LZ4LIB_API LZ4LIB_VISIBILITY #endif /*! LZ4_FREESTANDING : * When this macro is set to 1, it enables "freestanding mode" that is * suitable for typical freestanding environment which doesn't support * standard C library. * * - LZ4_FREESTANDING is a compile-time switch. * - It requires the following macros to be defined: * LZ4_memcpy, LZ4_memmove, LZ4_memset. * - It only enables LZ4/HC functions which don't use heap. * All LZ4F_* functions are not supported. * - See tests/freestanding.c to check its basic setup. */ #if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1) # define LZ4_HEAPMODE 0 # define LZ4HC_HEAPMODE 0 # define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1 # if !defined(LZ4_memcpy) # error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'." # endif # if !defined(LZ4_memset) # error "LZ4_FREESTANDING requires macro 'LZ4_memset'." # endif # if !defined(LZ4_memmove) # error "LZ4_FREESTANDING requires macro 'LZ4_memmove'." # endif #elif ! defined(LZ4_FREESTANDING) # define LZ4_FREESTANDING 0 #endif /*------ Version ------*/ #define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */ #define LZ4_VERSION_MINOR 9 /* for new (non-breaking) interface capabilities */ #define LZ4_VERSION_RELEASE 5 /* for tweaks, bug-fixes, or development */ #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE #define LZ4_QUOTE(str) #str #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str) #define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION) /* requires v1.7.3+ */ LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version; requires v1.3.0+ */ LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version; requires v1.7.5+ */ /*-************************************ * Tuning memory usage **************************************/ /*! * LZ4_MEMORY_USAGE : * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB) * Increasing memory usage improves compression ratio, generally at the cost of speed. * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality. * Default value is 14, for 16KB, which nicely fits into most L1 caches. */ #ifndef LZ4_MEMORY_USAGE # define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT #endif #define LZ4_MEMORY_USAGE_MIN 10 #define LZ4_MEMORY_USAGE_DEFAULT 14 #define LZ4_MEMORY_USAGE_MAX 20 #if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN) # error "LZ4_MEMORY_USAGE is too small !" #endif #if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX) # error "LZ4_MEMORY_USAGE is too large !" #endif /*-************************************ * Simple Functions **************************************/ /*! LZ4_compress_default() : * Compresses 'srcSize' bytes from buffer 'src' * into already allocated 'dst' buffer of size 'dstCapacity'. * Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize). * It also runs faster, so it's a recommended setting. * If the function cannot compress 'src' into a more limited 'dst' budget, * compression stops *immediately*, and the function result is zero. * In which case, 'dst' content is undefined (invalid). * srcSize : max supported value is LZ4_MAX_INPUT_SIZE. * dstCapacity : size of buffer 'dst' (which must be already allocated) * @return : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity) * or 0 if compression fails * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer). */ LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity); /*! LZ4_decompress_safe() : * @compressedSize : is the exact complete size of the compressed block. * @dstCapacity : is the size of destination buffer (which must be already allocated), * presumed an upper bound of decompressed size. * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity) * If destination buffer is not large enough, decoding will stop and output an error code (negative value). * If the source stream is detected malformed, the function will stop decoding and return a negative result. * Note 1 : This function is protected against malicious data packets : * it will never writes outside 'dst' buffer, nor read outside 'source' buffer, * even if the compressed block is maliciously modified to order the decoder to do these actions. * In such case, the decoder stops immediately, and considers the compressed block malformed. * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them. * The implementation is free to send / store / derive this information in whichever way is most beneficial. * If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead. */ LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity); /*-************************************ * Advanced Functions **************************************/ #define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */ #define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16) /*! LZ4_compressBound() : Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible) This function is primarily useful for memory allocation purposes (destination buffer size). Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example). Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize) inputSize : max supported value is LZ4_MAX_INPUT_SIZE return : maximum output size in a "worst case" scenario or 0, if input size is incorrect (too large or negative) */ LZ4LIB_API int LZ4_compressBound(int inputSize); /*! LZ4_compress_fast() : Same as LZ4_compress_default(), but allows selection of "acceleration" factor. The larger the acceleration value, the faster the algorithm, but also the lesser the compression. It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed. An acceleration value of "1" is the same as regular LZ4_compress_default() Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c). Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c). */ LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); /*! LZ4_compress_fast_extState() : * Same as LZ4_compress_fast(), using an externally allocated memory space for its state. * Use LZ4_sizeofState() to know how much memory must be allocated, * and allocate it on 8-bytes boundaries (using `malloc()` typically). * Then, provide this buffer as `void* state` to compression function. */ LZ4LIB_API int LZ4_sizeofState(void); LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); /*! LZ4_compress_destSize() : * Reverse the logic : compresses as much data as possible from 'src' buffer * into already allocated buffer 'dst', of size >= 'dstCapacity'. * This function either compresses the entire 'src' content into 'dst' if it's large enough, * or fill 'dst' buffer completely with as much data as possible from 'src'. * note: acceleration parameter is fixed to "default". * * *srcSizePtr : in+out parameter. Initially contains size of input. * Will be modified to indicate how many bytes where read from 'src' to fill 'dst'. * New value is necessarily <= input value. * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity) * or 0 if compression fails. * * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+): * the produced compressed content could, in specific circumstances, * require to be decompressed into a destination buffer larger * by at least 1 byte than the content to decompress. * If an application uses `LZ4_compress_destSize()`, * it's highly recommended to update liblz4 to v1.9.2 or better. * If this can't be done or ensured, * the receiving decompression function should provide * a dstCapacity which is > decompressedSize, by at least 1 byte. * See https://github.com/lz4/lz4/issues/859 for details */ LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize); /*! LZ4_decompress_safe_partial() : * Decompress an LZ4 compressed block, of size 'srcSize' at position 'src', * into destination buffer 'dst' of size 'dstCapacity'. * Up to 'targetOutputSize' bytes will be decoded. * The function stops decoding on reaching this objective. * This can be useful to boost performance * whenever only the beginning of a block is required. * * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize) * If source stream is detected malformed, function returns a negative result. * * Note 1 : @return can be < targetOutputSize, if compressed block contains less data. * * Note 2 : targetOutputSize must be <= dstCapacity * * Note 3 : this function effectively stops decoding on reaching targetOutputSize, * so dstCapacity is kind of redundant. * This is because in older versions of this function, * decoding operation would still write complete sequences. * Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize, * it could write more bytes, though only up to dstCapacity. * Some "margin" used to be required for this operation to work properly. * Thankfully, this is no longer necessary. * The function nonetheless keeps the same signature, in an effort to preserve API compatibility. * * Note 4 : If srcSize is the exact size of the block, * then targetOutputSize can be any value, * including larger than the block's decompressed size. * The function will, at most, generate block's decompressed size. * * Note 5 : If srcSize is _larger_ than block's compressed size, * then targetOutputSize **MUST** be <= block's decompressed size. * Otherwise, *silent corruption will occur*. */ LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity); /*-********************************************* * Streaming Compression Functions ***********************************************/ typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */ /*! Note about RC_INVOKED - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio). https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars) and reports warning "RC4011: identifier truncated". - To eliminate the warning, we surround long preprocessor symbol with "#if !defined(RC_INVOKED) ... #endif" block that means "skip this block when rc.exe is trying to read it". */ #if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4LIB_API LZ4_stream_t* LZ4_createStream(void); LZ4LIB_API int LZ4_freeStream (LZ4_stream_t* streamPtr); #endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ #endif /*! LZ4_resetStream_fast() : v1.9.0+ * Use this to prepare an LZ4_stream_t for a new chain of dependent blocks * (e.g., LZ4_compress_fast_continue()). * * An LZ4_stream_t must be initialized once before usage. * This is automatically done when created by LZ4_createStream(). * However, should the LZ4_stream_t be simply declared on stack (for example), * it's necessary to initialize it first, using LZ4_initStream(). * * After init, start any new stream with LZ4_resetStream_fast(). * A same LZ4_stream_t can be re-used multiple times consecutively * and compress multiple streams, * provided that it starts each new stream with LZ4_resetStream_fast(). * * LZ4_resetStream_fast() is much faster than LZ4_initStream(), * but is not compatible with memory regions containing garbage data. * * Note: it's only useful to call LZ4_resetStream_fast() * in the context of streaming compression. * The *extState* functions perform their own resets. * Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive. */ LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr); /*! LZ4_loadDict() : * Use this function to reference a static dictionary into LZ4_stream_t. * The dictionary must remain available during compression. * LZ4_loadDict() triggers a reset, so any previous data will be forgotten. * The same dictionary will have to be loaded on decompression side for successful decoding. * Dictionary are useful for better compression of small data (KB range). * While LZ4 itself accepts any input as dictionary, dictionary efficiency is also a topic. * When in doubt, employ the Zstandard's Dictionary Builder. * Loading a size of 0 is allowed, and is the same as reset. * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded) */ LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize); /*! LZ4_compress_fast_continue() : * Compress 'src' content using data from previously compressed blocks, for better compression ratio. * 'dst' buffer must be already allocated. * If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster. * * @return : size of compressed block * or 0 if there is an error (typically, cannot fit into 'dst'). * * Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block. * Each block has precise boundaries. * Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata. * It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together. * * Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory ! * * Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB. * Make sure that buffers are separated, by at least one byte. * This construction ensures that each block only depends on previous block. * * Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB. * * Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed. */ LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); /*! LZ4_saveDict() : * If last 64KB data cannot be guaranteed to remain available at its current memory location, * save it into a safer place (char* safeBuffer). * This is schematically equivalent to a memcpy() followed by LZ4_loadDict(), * but is much faster, because LZ4_saveDict() doesn't need to rebuild tables. * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error. */ LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize); /*-********************************************** * Streaming Decompression Functions * Bufferless synchronous API ************************************************/ typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* tracking context */ /*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() : * creation / destruction of streaming decompression tracking context. * A tracking context can be re-used multiple times. */ #if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ #if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void); LZ4LIB_API int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream); #endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ #endif /*! LZ4_setStreamDecode() : * An LZ4_streamDecode_t context can be allocated once and re-used multiple times. * Use this function to start decompression of a new stream of blocks. * A dictionary can optionally be set. Use NULL or size 0 for a reset order. * Dictionary is presumed stable : it must remain accessible and unmodified during next decompression. * @return : 1 if OK, 0 if error */ LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize); /*! LZ4_decoderRingBufferSize() : v1.8.2+ * Note : in a ring buffer scenario (optional), * blocks are presumed decompressed next to each other * up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize), * at which stage it resumes from beginning of ring buffer. * When setting such a ring buffer for streaming decompression, * provides the minimum size of this ring buffer * to be compatible with any source respecting maxBlockSize condition. * @return : minimum ring buffer size, * or 0 if there is an error (invalid maxBlockSize). */ LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize); #define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize)) /* for static allocation; maxBlockSize presumed valid */ /*! LZ4_decompress_safe_continue() : * This decoding function allows decompression of consecutive blocks in "streaming" mode. * The difference with the usual independent blocks is that * new blocks are allowed to find references into former blocks. * A block is an unsplittable entity, and must be presented entirely to the decompression function. * LZ4_decompress_safe_continue() only accepts one block at a time. * It's modeled after `LZ4_decompress_safe()` and behaves similarly. * * @LZ4_streamDecode : decompression state, tracking the position in memory of past data * @compressedSize : exact complete size of one compressed block. * @dstCapacity : size of destination buffer (which must be already allocated), * must be an upper bound of decompressed size. * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity) * If destination buffer is not large enough, decoding will stop and output an error code (negative value). * If the source stream is detected malformed, the function will stop decoding and return a negative result. * * The last 64KB of previously decoded data *must* remain available and unmodified * at the memory position where they were previously decoded. * If less than 64KB of data has been decoded, all the data must be present. * * Special : if decompression side sets a ring buffer, it must respect one of the following conditions : * - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize). * maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes. * In which case, encoding and decoding buffers do not need to be synchronized. * Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize. * - Synchronized mode : * Decompression buffer size is _exactly_ the same as compression buffer size, * and follows exactly same update rule (block boundaries at same positions), * and decoding function is provided with exact decompressed size of each block (exception for last block of the stream), * _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB). * - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes. * In which case, encoding and decoding buffers do not need to be synchronized, * and encoding ring buffer can have any size, including small ones ( < 64 KB). * * Whenever these conditions are not possible, * save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, * then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block. */ LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity); /*! LZ4_decompress_safe_usingDict() : * Works the same as * a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue() * However, it's stateless: it doesn't need any LZ4_streamDecode_t state. * Dictionary is presumed stable : it must remain accessible and unmodified during decompression. * Performance tip : Decompression speed can be substantially increased * when dst == dictStart + dictSize. */ LZ4LIB_API int LZ4_decompress_safe_usingDict(const char* src, char* dst, int srcSize, int dstCapacity, const char* dictStart, int dictSize); /*! LZ4_decompress_safe_partial_usingDict() : * Behaves the same as LZ4_decompress_safe_partial() * with the added ability to specify a memory segment for past data. * Performance tip : Decompression speed can be substantially increased * when dst == dictStart + dictSize. */ LZ4LIB_API int LZ4_decompress_safe_partial_usingDict(const char* src, char* dst, int compressedSize, int targetOutputSize, int maxOutputSize, const char* dictStart, int dictSize); #endif /* LZ4_H_2983827168210 */ /*^************************************* * !!!!!! STATIC LINKING ONLY !!!!!! ***************************************/ /*-**************************************************************************** * Experimental section * * Symbols declared in this section must be considered unstable. Their * signatures or semantics may change, or they may be removed altogether in the * future. They are therefore only safe to depend on when the caller is * statically linked against the library. * * To protect against unsafe usage, not only are the declarations guarded, * the definitions are hidden by default * when building LZ4 as a shared/dynamic library. * * In order to access these declarations, * define LZ4_STATIC_LINKING_ONLY in your application * before including LZ4's headers. * * In order to make their implementations accessible dynamically, you must * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library. ******************************************************************************/ #ifdef LZ4_STATIC_LINKING_ONLY #ifndef LZ4_STATIC_3504398509 #define LZ4_STATIC_3504398509 #ifdef LZ4_PUBLISH_STATIC_FUNCTIONS # define LZ4LIB_STATIC_API LZ4LIB_API #else # define LZ4LIB_STATIC_API #endif /*! LZ4_compress_fast_extState_fastReset() : * A variant of LZ4_compress_fast_extState(). * * Using this variant avoids an expensive initialization step. * It is only safe to call if the state buffer is known to be correctly initialized already * (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized"). * From a high level, the difference is that * this function initializes the provided state with a call to something like LZ4_resetStream_fast() * while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream(). */ LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration); /*! LZ4_compress_destSize_extState() : * Same as LZ4_compress_destSize(), but using an externally allocated state. * Also: exposes @acceleration */ int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration); /*! LZ4_attach_dictionary() : * This is an experimental API that allows * efficient use of a static dictionary many times. * * Rather than re-loading the dictionary buffer into a working context before * each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a * working LZ4_stream_t, this function introduces a no-copy setup mechanism, * in which the working stream references the dictionary stream in-place. * * Several assumptions are made about the state of the dictionary stream. * Currently, only streams which have been prepared by LZ4_loadDict() should * be expected to work. * * Alternatively, the provided dictionaryStream may be NULL, * in which case any existing dictionary stream is unset. * * If a dictionary is provided, it replaces any pre-existing stream history. * The dictionary contents are the only history that can be referenced and * logically immediately precede the data compressed in the first subsequent * compression call. * * The dictionary will only remain attached to the working stream through the * first compression call, at the end of which it is cleared. The dictionary * stream (and source buffer) must remain in-place / accessible / unchanged * through the completion of the first compression call on the stream. */ LZ4LIB_STATIC_API void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream); /*! In-place compression and decompression * * It's possible to have input and output sharing the same buffer, * for highly constrained memory environments. * In both cases, it requires input to lay at the end of the buffer, * and decompression to start at beginning of the buffer. * Buffer size must feature some margin, hence be larger than final size. * * |<------------------------buffer--------------------------------->| * |<-----------compressed data--------->| * |<-----------decompressed size------------------>| * |<----margin---->| * * This technique is more useful for decompression, * since decompressed size is typically larger, * and margin is short. * * In-place decompression will work inside any buffer * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize). * This presumes that decompressedSize > compressedSize. * Otherwise, it means compression actually expanded data, * and it would be more efficient to store such data with a flag indicating it's not compressed. * This can happen when data is not compressible (already compressed, or encrypted). * * For in-place compression, margin is larger, as it must be able to cope with both * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX, * and data expansion, which can happen when input is not compressible. * As a consequence, buffer size requirements are much higher, * and memory savings offered by in-place compression are more limited. * * There are ways to limit this cost for compression : * - Reduce history size, by modifying LZ4_DISTANCE_MAX. * Note that it is a compile-time constant, so all compressions will apply this limit. * Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX, * so it's a reasonable trick when inputs are known to be small. * - Require the compressor to deliver a "maximum compressed size". * This is the `dstCapacity` parameter in `LZ4_compress*()`. * When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail, * in which case, the return code will be 0 (zero). * The caller must be ready for these cases to happen, * and typically design a backup scheme to send data uncompressed. * The combination of both techniques can significantly reduce * the amount of margin required for in-place compression. * * In-place compression can work in any buffer * which size is >= (maxCompressedSize) * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success. * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX, * so it's possible to reduce memory requirements by playing with them. */ #define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize) (((compressedSize) >> 8) + 32) #define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize) ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize)) /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */ #ifndef LZ4_DISTANCE_MAX /* history window size; can be user-defined at compile time */ # define LZ4_DISTANCE_MAX 65535 /* set to maximum value by default */ #endif #define LZ4_COMPRESS_INPLACE_MARGIN (LZ4_DISTANCE_MAX + 32) /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */ #define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize) ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN) /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */ #endif /* LZ4_STATIC_3504398509 */ #endif /* LZ4_STATIC_LINKING_ONLY */ #ifndef LZ4_H_98237428734687 #define LZ4_H_98237428734687 /*-************************************************************ * Private Definitions ************************************************************** * Do not use these definitions directly. * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`. * Accessing members will expose user code to API and/or ABI break in future versions of the library. **************************************************************/ #define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2) #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE) #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG) /* required as macro for static allocation */ #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # include typedef int8_t LZ4_i8; typedef uint8_t LZ4_byte; typedef uint16_t LZ4_u16; typedef uint32_t LZ4_u32; #else typedef signed char LZ4_i8; typedef unsigned char LZ4_byte; typedef unsigned short LZ4_u16; typedef unsigned int LZ4_u32; #endif /*! LZ4_stream_t : * Never ever use below internal definitions directly ! * These definitions are not API/ABI safe, and may change in future versions. * If you need static allocation, declare or allocate an LZ4_stream_t object. **/ typedef struct LZ4_stream_t_internal LZ4_stream_t_internal; struct LZ4_stream_t_internal { LZ4_u32 hashTable[LZ4_HASH_SIZE_U32]; const LZ4_byte* dictionary; const LZ4_stream_t_internal* dictCtx; LZ4_u32 currentOffset; LZ4_u32 tableType; LZ4_u32 dictSize; /* Implicit padding to ensure structure is aligned */ }; #define LZ4_STREAM_MINSIZE ((1UL << (LZ4_MEMORY_USAGE)) + 32) /* static size, for inter-version compatibility */ union LZ4_stream_u { char minStateSize[LZ4_STREAM_MINSIZE]; LZ4_stream_t_internal internal_donotuse; }; /* previously typedef'd to LZ4_stream_t */ /*! LZ4_initStream() : v1.9.0+ * An LZ4_stream_t structure must be initialized at least once. * This is automatically done when invoking LZ4_createStream(), * but it's not when the structure is simply declared on stack (for example). * * Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t. * It can also initialize any arbitrary buffer of sufficient size, * and will @return a pointer of proper type upon initialization. * * Note : initialization fails if size and alignment conditions are not respected. * In which case, the function will @return NULL. * Note2: An LZ4_stream_t structure guarantees correct alignment and size. * Note3: Before v1.9.0, use LZ4_resetStream() instead **/ LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* stateBuffer, size_t size); /*! LZ4_streamDecode_t : * Never ever use below internal definitions directly ! * These definitions are not API/ABI safe, and may change in future versions. * If you need static allocation, declare or allocate an LZ4_streamDecode_t object. **/ typedef struct { const LZ4_byte* externalDict; const LZ4_byte* prefixEnd; size_t extDictSize; size_t prefixSize; } LZ4_streamDecode_t_internal; #define LZ4_STREAMDECODE_MINSIZE 32 union LZ4_streamDecode_u { char minStateSize[LZ4_STREAMDECODE_MINSIZE]; LZ4_streamDecode_t_internal internal_donotuse; } ; /* previously typedef'd to LZ4_streamDecode_t */ /*-************************************ * Obsolete Functions **************************************/ /*! Deprecation warnings * * Deprecated functions make the compiler generate a warning when invoked. * This is meant to invite users to update their source code. * Should deprecation warnings be a problem, it is generally possible to disable them, * typically with -Wno-deprecated-declarations for gcc * or _CRT_SECURE_NO_WARNINGS in Visual. * * Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS * before including the header file. */ #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS # define LZ4_DEPRECATED(message) /* disable deprecation warnings */ #else # if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ # define LZ4_DEPRECATED(message) [[deprecated(message)]] # elif defined(_MSC_VER) # define LZ4_DEPRECATED(message) __declspec(deprecated(message)) # elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45)) # define LZ4_DEPRECATED(message) __attribute__((deprecated(message))) # elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31) # define LZ4_DEPRECATED(message) __attribute__((deprecated)) # else # pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler") # define LZ4_DEPRECATED(message) /* disabled */ # endif #endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */ /*! Obsolete compression functions (since v1.7.3) */ LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress (const char* src, char* dest, int srcSize); LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize); LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize); LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize); LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize); LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize); /*! Obsolete decompression functions (since v1.8.0) */ LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize); LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); /* Obsolete streaming functions (since v1.7.0) * degraded functionality; do not use! * * In order to perform streaming compression, these functions depended on data * that is no longer tracked in the state. They have been preserved as well as * possible: using them will still produce a correct output. However, they don't * actually retain any history between compression calls. The compression ratio * achieved will therefore be no better than compressing each chunk * independently. */ LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer); LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int LZ4_sizeofStreamState(void); LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API int LZ4_resetStreamState(void* state, char* inputBuffer); LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API char* LZ4_slideInputBuffer (void* state); /*! Obsolete streaming decoding functions (since v1.7.0) */ LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize); LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize); /*! Obsolete LZ4_decompress_fast variants (since v1.9.0) : * These functions used to be faster than LZ4_decompress_safe(), * but this is no longer the case. They are now slower. * This is because LZ4_decompress_fast() doesn't know the input size, * and therefore must progress more cautiously into the input buffer to not read beyond the end of block. * On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability. * As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated. * * The last remaining LZ4_decompress_fast() specificity is that * it can decompress a block without knowing its compressed size. * Such functionality can be achieved in a more secure manner * by employing LZ4_decompress_safe_partial(). * * Parameters: * originalSize : is the uncompressed size to regenerate. * `dst` must be already allocated, its size must be >= 'originalSize' bytes. * @return : number of bytes read from source buffer (== compressed size). * The function expects to finish at block's end exactly. * If the source stream is detected malformed, the function stops decoding and returns a negative result. * note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer. * However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds. * Also, since match offsets are not validated, match reads from 'src' may underflow too. * These issues never happen if input (compressed) data is correct. * But they may happen if input data is invalid (error or intentional tampering). * As a consequence, use these functions in trusted environments with trusted data **only**. */ LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial() instead") LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize); LZ4_DEPRECATED("This function is deprecated and unsafe. Consider migrating towards LZ4_decompress_safe_continue() instead. " "Note that the contract will change (requires block's compressed size, instead of decompressed size)") LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize); LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize); /*! LZ4_resetStream() : * An LZ4_stream_t structure must be initialized at least once. * This is done with LZ4_initStream(), or LZ4_resetStream(). * Consider switching to LZ4_initStream(), * invoking LZ4_resetStream() will trigger deprecation warnings in the future. */ LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr); #endif /* LZ4_H_98237428734687 */ #if defined (__cplusplus) } #endif nvc-r1.17.1/thirdparty/memmem.c000066400000000000000000000056471504111170000163660ustar00rootroot00000000000000/* Copyright (C) 1991-1994, 1996-1998, 2000, 2004, 2007-2022 Free Software Foundation, Inc. This file is part of the GNU C Library. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ /* This particular implementation was written by Eric Blake, 2008. */ #ifndef _GL_ATTRIBUTE_PURE # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) || defined __clang__ # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__)) # else # define _GL_ATTRIBUTE_PURE /* empty */ # endif #endif #ifndef _LIBC # include #endif /* Specification of memmem. */ #include #define RETURN_TYPE void * #define AVAILABLE(h, h_l, j, n_l) ((j) <= (h_l) - (n_l)) #include "str-two-way.h" /* Return the first occurrence of NEEDLE in HAYSTACK. Return HAYSTACK if NEEDLE_LEN is 0, otherwise NULL if NEEDLE is not found in HAYSTACK. */ void * memmem (const void *haystack_start, size_t haystack_len, const void *needle_start, size_t needle_len) { /* Abstract memory is considered to be an array of 'unsigned char' values, not an array of 'char' values. See ISO C 99 section 6.2.6.1. */ const unsigned char *haystack = (const unsigned char *) haystack_start; const unsigned char *needle = (const unsigned char *) needle_start; if (needle_len == 0) /* The first occurrence of the empty string is deemed to occur at the beginning of the string. */ return (void *) haystack; /* Sanity check, otherwise the loop might search through the whole memory. */ if (__builtin_expect (haystack_len < needle_len, 0)) return NULL; /* Use optimizations in memchr when possible, to reduce the search size of haystack using a linear algorithm with a smaller coefficient. However, avoid memchr for long needles, since we can often achieve sublinear performance. */ if (needle_len < LONG_NEEDLE_THRESHOLD) { haystack = memchr (haystack, *needle, haystack_len); if (!haystack || __builtin_expect (needle_len == 1, 0)) return (void *) haystack; haystack_len -= haystack - (const unsigned char *) haystack_start; if (haystack_len < needle_len) return NULL; return two_way_short_needle (haystack, haystack_len, needle, needle_len); } else return two_way_long_needle (haystack, haystack_len, needle, needle_len); } #undef LONG_NEEDLE_THRESHOLD nvc-r1.17.1/thirdparty/rawmemchr.c000066400000000000000000000120531504111170000170630ustar00rootroot00000000000000/* Searching in a string. Copyright (C) 2008-2023 Free Software Foundation, Inc. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ #include /* Specification. */ #include /* A function definition is only needed if HAVE_RAWMEMCHR is not defined. */ #if !HAVE_RAWMEMCHR # include # include # include #define alignof(x) __alignof__(x) #define static_assert(x) _Static_assert((x), "Static assertion failed"); #undef UINTPTR_WIDTH #define UINTPTR_WIDTH sizeof(uintptr_t) #undef UCHAR_WIDTH #define UCHAR_WIDTH sizeof(unsigned char) /* Find the first occurrence of C in S. */ void * rawmemchr (const void *s, int c_in) { /* Change this typedef to experiment with performance. */ typedef uintptr_t longword; /* If you change the "uintptr_t", you should change UINTPTR_WIDTH to match. This verifies that the type does not have padding bits. */ static_assert (UINTPTR_WIDTH == UCHAR_WIDTH * sizeof (longword)); const unsigned char *char_ptr; unsigned char c = c_in; /* Handle the first few bytes by reading one byte at a time. Do this until CHAR_PTR is aligned on a longword boundary. */ for (char_ptr = (const unsigned char *) s; (uintptr_t) char_ptr % alignof (longword) != 0; ++char_ptr) if (*char_ptr == c) return (void *) char_ptr; longword const *longword_ptr = s = char_ptr; /* Compute auxiliary longword values: repeated_one is a value which has a 1 in every byte. repeated_c has c in every byte. */ longword repeated_one = (longword) -1 / UCHAR_MAX; longword repeated_c = repeated_one * c; longword repeated_hibit = repeated_one * (UCHAR_MAX / 2 + 1); /* Instead of the traditional loop which tests each byte, we will test a longword at a time. The tricky part is testing if any of the bytes in the longword in question are equal to c. We first use an xor with repeated_c. This reduces the task to testing whether any of the bytes in longword1 is zero. (The following comments assume 8-bit bytes, as POSIX requires; the code's use of UCHAR_MAX should work even if bytes have more than 8 bits.) We compute tmp = ((longword1 - repeated_one) & ~longword1) & (repeated_one * 0x80). That is, we perform the following operations: 1. Subtract repeated_one. 2. & ~longword1. 3. & a mask consisting of 0x80 in every byte. Consider what happens in each byte: - If a byte of longword1 is zero, step 1 and 2 transform it into 0xff, and step 3 transforms it into 0x80. A carry can also be propagated to more significant bytes. - If a byte of longword1 is nonzero, let its lowest 1 bit be at position k (0 <= k <= 7); so the lowest k bits are 0. After step 1, the byte ends in a single bit of value 0 and k bits of value 1. After step 2, the result is just k bits of value 1: 2^k - 1. After step 3, the result is 0. And no carry is produced. So, if longword1 has only non-zero bytes, tmp is zero. Whereas if longword1 has a zero byte, call j the position of the least significant zero byte. Then the result has a zero at positions 0, ..., j-1 and a 0x80 at position j. We cannot predict the result at the more significant bytes (positions j+1..3), but it does not matter since we already have a non-zero bit at position 8*j+7. The test whether any byte in longword1 is zero is equivalent to testing whether tmp is nonzero. This test can read beyond the end of a string, depending on where C_IN is encountered. However, this is considered safe since the initialization phase ensured that the read will be aligned, therefore, the read will not cross page boundaries and will not cause a fault. */ while (1) { longword longword1 = *longword_ptr ^ repeated_c; if ((((longword1 - repeated_one) & ~longword1) & repeated_hibit) != 0) break; longword_ptr++; } char_ptr = s = longword_ptr; /* At this point, we know that one of the sizeof (longword) bytes starting at char_ptr is == c. If we knew endianness, we could determine the first such byte without any further memory accesses, just by looking at the tmp result from the last loop iteration. However, the following simple and portable code does not attempt this potential optimization. */ while (*char_ptr != c) char_ptr++; return (void *) char_ptr; } #endif nvc-r1.17.1/thirdparty/sha1.c000066400000000000000000000503511504111170000157350ustar00rootroot00000000000000/* * SHA-1 in C * By Steve Reid * 100% Public Domain * * Test Vectors (from FIPS PUB 180-1) * "abc" * A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" * 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 * A million repetitions of "a" * 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F */ #include "sha1.h" #include "config.h" #include #include #include #ifdef HAVE_SSE_SHA #include #endif #ifdef HAVE_ARM_CRYPTO #include #endif #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) /* * blk0() and blk() perform the initial expand. * I got the idea of expanding during the round function from SSLeay */ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ # define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ |(rol(block->l[i],8)&0x00FF00FF)) #else /* __BIG_ENDIAN__ */ # define blk0(i) block->l[i] #endif /* __LITTLE_ENDIAN__ */ #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ ^block->l[(i+2)&15]^block->l[i&15],1)) /* * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1 */ #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); typedef union { unsigned char c[64]; uint32_t l[16]; } CHAR64LONG16; /* * Hash a single 512-bit block. This is the core of the algorithm. */ static void SHA1Transform(uint32_t state[5], unsigned char buffer[64]) { uint32_t a, b, c, d, e; CHAR64LONG16 *block; block = (CHAR64LONG16 *)buffer; /* Copy context->state[] to working vars */ a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; /* 4 rounds of 20 operations each. Loop unrolled. */ R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); /* Add the working vars back into context.state[] */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; /* Wipe variables */ a = b = c = d = e = 0; } #ifdef HAVE_SSE_SHA __attribute__((target("sse4.1,sha"))) static void sha1_process_x86(uint32_t state[5], const uint8_t data[], size_t length) { /* Written and place in public domain by Jeffrey Walton */ /* Based on code from Intel, and by Sean Gulley for */ /* the miTLS project. */ __m128i ABCD, ABCD_SAVE, E0, E0_SAVE, E1; __m128i MSG0, MSG1, MSG2, MSG3; const __m128i MASK = _mm_set_epi64x(0x0001020304050607ULL, 0x08090a0b0c0d0e0fULL); /* Load initial values */ ABCD = _mm_loadu_si128((const __m128i*) state); E0 = _mm_set_epi32(state[4], 0, 0, 0); ABCD = _mm_shuffle_epi32(ABCD, 0x1B); while (length >= 64) { /* Save current state */ ABCD_SAVE = ABCD; E0_SAVE = E0; /* Rounds 0-3 */ MSG0 = _mm_loadu_si128((const __m128i*)(data + 0)); MSG0 = _mm_shuffle_epi8(MSG0, MASK); E0 = _mm_add_epi32(E0, MSG0); E1 = ABCD; ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0); /* Rounds 4-7 */ MSG1 = _mm_loadu_si128((const __m128i*)(data + 16)); MSG1 = _mm_shuffle_epi8(MSG1, MASK); E1 = _mm_sha1nexte_epu32(E1, MSG1); E0 = ABCD; ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0); MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1); /* Rounds 8-11 */ MSG2 = _mm_loadu_si128((const __m128i*)(data + 32)); MSG2 = _mm_shuffle_epi8(MSG2, MASK); E0 = _mm_sha1nexte_epu32(E0, MSG2); E1 = ABCD; ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0); MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2); MSG0 = _mm_xor_si128(MSG0, MSG2); /* Rounds 12-15 */ MSG3 = _mm_loadu_si128((const __m128i*)(data + 48)); MSG3 = _mm_shuffle_epi8(MSG3, MASK); E1 = _mm_sha1nexte_epu32(E1, MSG3); E0 = ABCD; MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0); MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3); MSG1 = _mm_xor_si128(MSG1, MSG3); /* Rounds 16-19 */ E0 = _mm_sha1nexte_epu32(E0, MSG0); E1 = ABCD; MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0); MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0); MSG2 = _mm_xor_si128(MSG2, MSG0); /* Rounds 20-23 */ E1 = _mm_sha1nexte_epu32(E1, MSG1); E0 = ABCD; MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1); MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1); MSG3 = _mm_xor_si128(MSG3, MSG1); /* Rounds 24-27 */ E0 = _mm_sha1nexte_epu32(E0, MSG2); E1 = ABCD; MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1); MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2); MSG0 = _mm_xor_si128(MSG0, MSG2); /* Rounds 28-31 */ E1 = _mm_sha1nexte_epu32(E1, MSG3); E0 = ABCD; MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1); MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3); MSG1 = _mm_xor_si128(MSG1, MSG3); /* Rounds 32-35 */ E0 = _mm_sha1nexte_epu32(E0, MSG0); E1 = ABCD; MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1); MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0); MSG2 = _mm_xor_si128(MSG2, MSG0); /* Rounds 36-39 */ E1 = _mm_sha1nexte_epu32(E1, MSG1); E0 = ABCD; MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1); MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1); MSG3 = _mm_xor_si128(MSG3, MSG1); /* Rounds 40-43 */ E0 = _mm_sha1nexte_epu32(E0, MSG2); E1 = ABCD; MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2); MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2); MSG0 = _mm_xor_si128(MSG0, MSG2); /* Rounds 44-47 */ E1 = _mm_sha1nexte_epu32(E1, MSG3); E0 = ABCD; MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2); MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3); MSG1 = _mm_xor_si128(MSG1, MSG3); /* Rounds 48-51 */ E0 = _mm_sha1nexte_epu32(E0, MSG0); E1 = ABCD; MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2); MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0); MSG2 = _mm_xor_si128(MSG2, MSG0); /* Rounds 52-55 */ E1 = _mm_sha1nexte_epu32(E1, MSG1); E0 = ABCD; MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2); MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1); MSG3 = _mm_xor_si128(MSG3, MSG1); /* Rounds 56-59 */ E0 = _mm_sha1nexte_epu32(E0, MSG2); E1 = ABCD; MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2); MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2); MSG0 = _mm_xor_si128(MSG0, MSG2); /* Rounds 60-63 */ E1 = _mm_sha1nexte_epu32(E1, MSG3); E0 = ABCD; MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3); MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3); MSG1 = _mm_xor_si128(MSG1, MSG3); /* Rounds 64-67 */ E0 = _mm_sha1nexte_epu32(E0, MSG0); E1 = ABCD; MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3); MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0); MSG2 = _mm_xor_si128(MSG2, MSG0); /* Rounds 68-71 */ E1 = _mm_sha1nexte_epu32(E1, MSG1); E0 = ABCD; MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1); ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3); MSG3 = _mm_xor_si128(MSG3, MSG1); /* Rounds 72-75 */ E0 = _mm_sha1nexte_epu32(E0, MSG2); E1 = ABCD; MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2); ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3); /* Rounds 76-79 */ E1 = _mm_sha1nexte_epu32(E1, MSG3); E0 = ABCD; ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3); /* Combine state */ E0 = _mm_sha1nexte_epu32(E0, E0_SAVE); ABCD = _mm_add_epi32(ABCD, ABCD_SAVE); data += 64; length -= 64; } /* Save state */ ABCD = _mm_shuffle_epi32(ABCD, 0x1B); _mm_storeu_si128((__m128i*) state, ABCD); state[4] = _mm_extract_epi32(E0, 3); } #endif #ifdef HAVE_ARM_CRYPTO #ifdef __clang__ __attribute__((target("crypto,sha2"))) #else __attribute__((target("+crypto"))) #endif static void sha1_process_arm(uint32_t state[5], const uint8_t data[], uint32_t length) { /* Written and placed in public domain by Jeffrey Walton */ /* Based on code from ARM, and by Johannes Schneiders, Skip */ /* Hovsmith and Barry O'Rourke for the mbedTLS project. */ uint32x4_t ABCD, ABCD_SAVED; uint32x4_t TMP0, TMP1; uint32x4_t MSG0, MSG1, MSG2, MSG3; uint32_t E0, E0_SAVED, E1; /* Load state */ ABCD = vld1q_u32(&state[0]); E0 = state[4]; while (length >= 64) { /* Save state */ ABCD_SAVED = ABCD; E0_SAVED = E0; /* Load message */ MSG0 = vld1q_u32((const uint32_t*)(data)); MSG1 = vld1q_u32((const uint32_t*)(data + 16)); MSG2 = vld1q_u32((const uint32_t*)(data + 32)); MSG3 = vld1q_u32((const uint32_t*)(data + 48)); /* Reverse for little endian */ MSG0 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG0))); MSG1 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG1))); MSG2 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG2))); MSG3 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG3))); TMP0 = vaddq_u32(MSG0, vdupq_n_u32(0x5A827999)); TMP1 = vaddq_u32(MSG1, vdupq_n_u32(0x5A827999)); /* Rounds 0-3 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1cq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG2, vdupq_n_u32(0x5A827999)); MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2); /* Rounds 4-7 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1cq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG3, vdupq_n_u32(0x5A827999)); MSG0 = vsha1su1q_u32(MSG0, MSG3); MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3); /* Rounds 8-11 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1cq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG0, vdupq_n_u32(0x5A827999)); MSG1 = vsha1su1q_u32(MSG1, MSG0); MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0); /* Rounds 12-15 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1cq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG1, vdupq_n_u32(0x6ED9EBA1)); MSG2 = vsha1su1q_u32(MSG2, MSG1); MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1); /* Rounds 16-19 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1cq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG2, vdupq_n_u32(0x6ED9EBA1)); MSG3 = vsha1su1q_u32(MSG3, MSG2); MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2); /* Rounds 20-23 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG3, vdupq_n_u32(0x6ED9EBA1)); MSG0 = vsha1su1q_u32(MSG0, MSG3); MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3); /* Rounds 24-27 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG0, vdupq_n_u32(0x6ED9EBA1)); MSG1 = vsha1su1q_u32(MSG1, MSG0); MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0); /* Rounds 28-31 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG1, vdupq_n_u32(0x6ED9EBA1)); MSG2 = vsha1su1q_u32(MSG2, MSG1); MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1); /* Rounds 32-35 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG2, vdupq_n_u32(0x8F1BBCDC)); MSG3 = vsha1su1q_u32(MSG3, MSG2); MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2); /* Rounds 36-39 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG3, vdupq_n_u32(0x8F1BBCDC)); MSG0 = vsha1su1q_u32(MSG0, MSG3); MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3); /* Rounds 40-43 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1mq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG0, vdupq_n_u32(0x8F1BBCDC)); MSG1 = vsha1su1q_u32(MSG1, MSG0); MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0); /* Rounds 44-47 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1mq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG1, vdupq_n_u32(0x8F1BBCDC)); MSG2 = vsha1su1q_u32(MSG2, MSG1); MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1); /* Rounds 48-51 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1mq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG2, vdupq_n_u32(0x8F1BBCDC)); MSG3 = vsha1su1q_u32(MSG3, MSG2); MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2); /* Rounds 52-55 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1mq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG3, vdupq_n_u32(0xCA62C1D6)); MSG0 = vsha1su1q_u32(MSG0, MSG3); MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3); /* Rounds 56-59 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1mq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG0, vdupq_n_u32(0xCA62C1D6)); MSG1 = vsha1su1q_u32(MSG1, MSG0); MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0); /* Rounds 60-63 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG1, vdupq_n_u32(0xCA62C1D6)); MSG2 = vsha1su1q_u32(MSG2, MSG1); MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1); /* Rounds 64-67 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E0, TMP0); TMP0 = vaddq_u32(MSG2, vdupq_n_u32(0xCA62C1D6)); MSG3 = vsha1su1q_u32(MSG3, MSG2); MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2); /* Rounds 68-71 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); TMP1 = vaddq_u32(MSG3, vdupq_n_u32(0xCA62C1D6)); MSG0 = vsha1su1q_u32(MSG0, MSG3); /* Rounds 72-75 */ E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E0, TMP0); /* Rounds 76-79 */ E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0)); ABCD = vsha1pq_u32(ABCD, E1, TMP1); /* Combine state */ E0 += E0_SAVED; ABCD = vaddq_u32(ABCD_SAVED, ABCD); data += 64; length -= 64; } /* Save state */ vst1q_u32(&state[0], ABCD); state[4] = E0; } #endif __attribute__((always_inline)) static inline void sha1_transform_generic(uint32_t state[5], const unsigned char *data, size_t length) { assert(length % 64 == 0); #ifdef HAVE_SSE_SHA #if __GNUC__ >= 11 || __clang_major__ >= 19 const bool have_sha = __builtin_cpu_supports("sha"); #else static int have_sha = -1; if (have_sha == -1) { int a = 7, b, c = 0, d; asm volatile ("cpuid" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "a"(a), "c"(c)); have_sha = !!((b >> 29) & 1); } #endif if (have_sha) { sha1_process_x86(state, data, length); return; } #endif #ifdef HAVE_ARM_CRYPTO sha1_process_arm(state, data, length); return; #endif unsigned char buffer[64]; for (int i = 0; i < length; i += 64) { memcpy(buffer, data + i, 64); SHA1Transform(state, buffer); } } /* * SHA1Init - Initialize new context */ void SHA1Init(SHA1_CTX *context) { /* SHA1 initialization constants */ context->state[0] = 0x67452301; context->state[1] = 0xEFCDAB89; context->state[2] = 0x98BADCFE; context->state[3] = 0x10325476; context->state[4] = 0xC3D2E1F0; context->count[0] = context->count[1] = 0; } /* * Run your data through this. */ void SHA1Update(SHA1_CTX *context, const unsigned char *data, size_t len) { unsigned int i, j, chunksz; j = context->count[0]; if ((context->count[0] += len << 3) < j) context->count[1] += (len>>29)+1; j = (j >> 3) & 63; if ((j + len) > 63) { memcpy(&context->buffer[j], data, (i = 64-j)); sha1_transform_generic(context->state, context->buffer, 64); chunksz = (len - i) & -64; sha1_transform_generic(context->state, &data[i], chunksz); i += chunksz; j = 0; } else { i = 0; } memcpy(&context->buffer[j], &data[i], len - i); } /* * Add padding and return the message digest. */ void SHA1Final(unsigned char digest[SHA1_LEN], SHA1_CTX *context) { unsigned int i; unsigned char finalcount[8]; for (i = 0; i < 8; i++) { finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ } SHA1Update(context, (const unsigned char *)"\200", 1); while ((context->count[0] & 504) != 448) SHA1Update(context, (const unsigned char *)"\0", 1); SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ if (digest) { for (i = 0; i < 20; i++) digest[i] = (unsigned char) ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); /* Zeroize sensitive information. */ memset(context, '\0', sizeof (*context)); } } #ifdef SHA1TEST #include #include #include #include #include #include int main(int argc, char **argv) { if (argc != 2) errx(1, "missing file argument"); struct stat st; if (stat(argv[1], &st) != 0) err(1, "stat"); unsigned char *buf = malloc(st.st_size); int fd = open(argv[1], O_RDONLY); if (fd < 0) err(1, "open: %s", argv[1]); if (read(fd, buf, st.st_size) != st.st_size) err(1, "read: %s", argv[1]); close(fd); SHA1_CTX ctx; SHA1Init(&ctx); SHA1Update(&ctx, buf, st.st_size); unsigned char hash[SHA1_LEN]; SHA1Final(hash, &ctx); for (int i = 0; i < SHA1_LEN; i++) printf("%02x", hash[i]); printf("\n"); free(buf); return 0; } #endif // SHA1TEST nvc-r1.17.1/thirdparty/sha1.h000066400000000000000000000007211504111170000157360ustar00rootroot00000000000000/* SHA-1 in C By Steve Reid 100% Public Domain */ #ifndef _THIRDPARTY_SHA1_H #define _THIRDPARTY_SHA1_H #include #include typedef struct { uint32_t state[5]; uint32_t count[2]; unsigned char buffer[64]; } SHA1_CTX; #define SHA1_LEN 20 void SHA1Init(SHA1_CTX *); void SHA1Update(SHA1_CTX *, const unsigned char *, size_t); void SHA1Final(unsigned char [SHA1_LEN], SHA1_CTX *); #endif // _THIRDPARTY_SHA1_H nvc-r1.17.1/thirdparty/str-two-way.h000066400000000000000000000423001504111170000173160ustar00rootroot00000000000000/* Byte-wise substring search, using the Two-Way algorithm. Copyright (C) 2008-2022 Free Software Foundation, Inc. This file is part of the GNU C Library. Written by Eric Blake , 2008. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ /* Before including this file, you need to include and , and define: RETURN_TYPE A macro that expands to the return type. AVAILABLE(h, h_l, j, n_l) A macro that returns nonzero if there are at least N_L bytes left starting at H[J]. H is 'unsigned char *', H_L, J, and N_L are 'size_t'; H_L is an lvalue. For NUL-terminated searches, H_L can be modified each iteration to avoid having to compute the end of H up front. For case-insensitivity, you may optionally define: CMP_FUNC(p1, p2, l) A macro that returns 0 iff the first L characters of P1 and P2 are equal. CANON_ELEMENT(c) A macro that canonicalizes an element right after it has been fetched from one of the two strings. The argument is an 'unsigned char'; the result must be an 'unsigned char' as well. This file undefines the macros documented above, and defines LONG_NEEDLE_THRESHOLD. */ #include #include /* We use the Two-Way string matching algorithm (also known as Chrochemore-Perrin), which guarantees linear complexity with constant space. Additionally, for long needles, we also use a bad character shift table similar to the Boyer-Moore algorithm to achieve improved (potentially sub-linear) performance. See https://www-igm.univ-mlv.fr/~lecroq/string/node26.html#SECTION00260, https://en.wikipedia.org/wiki/Boyer-Moore_string_search_algorithm, https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.34.6641&rep=rep1&type=pdf */ /* Point at which computing a bad-byte shift table is likely to be worthwhile. Small needles should not compute a table, since it adds (1 << CHAR_BIT) + NEEDLE_LEN computations of preparation for a speedup no greater than a factor of NEEDLE_LEN. The larger the needle, the better the potential performance gain. On the other hand, on non-POSIX systems with CHAR_BIT larger than eight, the memory required for the table is prohibitive. */ #if CHAR_BIT < 10 # define LONG_NEEDLE_THRESHOLD 32U #else # define LONG_NEEDLE_THRESHOLD SIZE_MAX #endif #ifndef MAX # define MAX(a, b) ((a < b) ? (b) : (a)) #endif #ifndef CANON_ELEMENT # define CANON_ELEMENT(c) c #endif #ifndef CMP_FUNC # define CMP_FUNC memcmp #endif /* Perform a critical factorization of NEEDLE, of length NEEDLE_LEN. Return the index of the first byte in the right half, and set *PERIOD to the global period of the right half. The global period of a string is the smallest index (possibly its length) at which all remaining bytes in the string are repetitions of the prefix (the last repetition may be a subset of the prefix). When NEEDLE is factored into two halves, a local period is the length of the smallest word that shares a suffix with the left half and shares a prefix with the right half. All factorizations of a non-empty NEEDLE have a local period of at least 1 and no greater than NEEDLE_LEN. A critical factorization has the property that the local period equals the global period. All strings have at least one critical factorization with the left half smaller than the global period. And while some strings have more than one critical factorization, it is provable that with an ordered alphabet, at least one of the critical factorizations corresponds to a maximal suffix. Given an ordered alphabet, a critical factorization can be computed in linear time, with 2 * NEEDLE_LEN comparisons, by computing the shorter of two ordered maximal suffixes. The ordered maximal suffixes are determined by lexicographic comparison while tracking periodicity. */ static size_t critical_factorization (const unsigned char *needle, size_t needle_len, size_t *period) { /* Index of last byte of left half, or SIZE_MAX. */ size_t max_suffix, max_suffix_rev; size_t j; /* Index into NEEDLE for current candidate suffix. */ size_t k; /* Offset into current period. */ size_t p; /* Intermediate period. */ unsigned char a, b; /* Current comparison bytes. */ /* Special case NEEDLE_LEN of 1 or 2 (all callers already filtered out 0-length needles. */ if (needle_len < 3) { *period = 1; return needle_len - 1; } /* Invariants: 0 <= j < NEEDLE_LEN - 1 -1 <= max_suffix{,_rev} < j (treating SIZE_MAX as if it were signed) min(max_suffix, max_suffix_rev) < global period of NEEDLE 1 <= p <= global period of NEEDLE p == global period of the substring NEEDLE[max_suffix{,_rev}+1...j] 1 <= k <= p */ /* Perform lexicographic search. */ max_suffix = SIZE_MAX; j = 0; k = p = 1; while (j + k < needle_len) { a = CANON_ELEMENT (needle[j + k]); b = CANON_ELEMENT (needle[max_suffix + k]); if (a < b) { /* Suffix is smaller, period is entire prefix so far. */ j += k; k = 1; p = j - max_suffix; } else if (a == b) { /* Advance through repetition of the current period. */ if (k != p) ++k; else { j += p; k = 1; } } else /* b < a */ { /* Suffix is larger, start over from current location. */ max_suffix = j++; k = p = 1; } } *period = p; /* Perform reverse lexicographic search. */ max_suffix_rev = SIZE_MAX; j = 0; k = p = 1; while (j + k < needle_len) { a = CANON_ELEMENT (needle[j + k]); b = CANON_ELEMENT (needle[max_suffix_rev + k]); if (b < a) { /* Suffix is smaller, period is entire prefix so far. */ j += k; k = 1; p = j - max_suffix_rev; } else if (a == b) { /* Advance through repetition of the current period. */ if (k != p) ++k; else { j += p; k = 1; } } else /* a < b */ { /* Suffix is larger, start over from current location. */ max_suffix_rev = j++; k = p = 1; } } /* Choose the shorter suffix. Return the index of the first byte of the right half, rather than the last byte of the left half. For some examples, 'banana' has two critical factorizations, both exposed by the two lexicographic extreme suffixes of 'anana' and 'nana', where both suffixes have a period of 2. On the other hand, with 'aab' and 'bba', both strings have a single critical factorization of the last byte, with the suffix having a period of 1. While the maximal lexicographic suffix of 'aab' is 'b', the maximal lexicographic suffix of 'bba' is 'ba', which is not a critical factorization. Conversely, the maximal reverse lexicographic suffix of 'a' works for 'bba', but not 'ab' for 'aab'. The shorter suffix of the two will always be a critical factorization. */ if (max_suffix_rev + 1 < max_suffix + 1) return max_suffix + 1; *period = p; return max_suffix_rev + 1; } /* Return the first location of non-empty NEEDLE within HAYSTACK, or NULL. HAYSTACK_LEN is the minimum known length of HAYSTACK. This method is optimized for NEEDLE_LEN < LONG_NEEDLE_THRESHOLD. Performance is guaranteed to be linear, with an initialization cost of 2 * NEEDLE_LEN comparisons. If AVAILABLE does not modify HAYSTACK_LEN (as in memmem), then at most 2 * HAYSTACK_LEN - NEEDLE_LEN comparisons occur in searching. If AVAILABLE modifies HAYSTACK_LEN (as in strstr), then at most 3 * HAYSTACK_LEN - NEEDLE_LEN comparisons occur in searching. */ static RETURN_TYPE _GL_ATTRIBUTE_PURE two_way_short_needle (const unsigned char *haystack, size_t haystack_len, const unsigned char *needle, size_t needle_len) { size_t i; /* Index into current byte of NEEDLE. */ size_t j; /* Index into current window of HAYSTACK. */ size_t period; /* The period of the right half of needle. */ size_t suffix; /* The index of the right half of needle. */ /* Factor the needle into two halves, such that the left half is smaller than the global period, and the right half is periodic (with a period as large as NEEDLE_LEN - suffix). */ suffix = critical_factorization (needle, needle_len, &period); /* Perform the search. Each iteration compares the right half first. */ if (CMP_FUNC (needle, needle + period, suffix) == 0) { /* Entire needle is periodic; a mismatch in the left half can only advance by the period, so use memory to avoid rescanning known occurrences of the period in the right half. */ size_t memory = 0; j = 0; while (AVAILABLE (haystack, haystack_len, j, needle_len)) { /* Scan for matches in right half. */ i = MAX (suffix, memory); while (i < needle_len && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) ++i; if (needle_len <= i) { /* Scan for matches in left half. */ i = suffix - 1; while (memory < i + 1 && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) --i; if (i + 1 < memory + 1) return (RETURN_TYPE) (haystack + j); /* No match, so remember how many repetitions of period on the right half were scanned. */ j += period; memory = needle_len - period; } else { j += i - suffix + 1; memory = 0; } } } else { /* The two halves of needle are distinct; no extra memory is required, and any mismatch results in a maximal shift. */ period = MAX (suffix, needle_len - suffix) + 1; j = 0; while (AVAILABLE (haystack, haystack_len, j, needle_len)) { /* Scan for matches in right half. */ i = suffix; while (i < needle_len && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) ++i; if (needle_len <= i) { /* Scan for matches in left half. */ i = suffix - 1; while (i != SIZE_MAX && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) --i; if (i == SIZE_MAX) return (RETURN_TYPE) (haystack + j); j += period; } else j += i - suffix + 1; } } return NULL; } /* Return the first location of non-empty NEEDLE within HAYSTACK, or NULL. HAYSTACK_LEN is the minimum known length of HAYSTACK. This method is optimized for LONG_NEEDLE_THRESHOLD <= NEEDLE_LEN. Performance is guaranteed to be linear, with an initialization cost of 3 * NEEDLE_LEN + (1 << CHAR_BIT) operations. If AVAILABLE does not modify HAYSTACK_LEN (as in memmem), then at most 2 * HAYSTACK_LEN - NEEDLE_LEN comparisons occur in searching, and sublinear performance O(HAYSTACK_LEN / NEEDLE_LEN) is possible. If AVAILABLE modifies HAYSTACK_LEN (as in strstr), then at most 3 * HAYSTACK_LEN - NEEDLE_LEN comparisons occur in searching, and sublinear performance is not possible. */ static RETURN_TYPE _GL_ATTRIBUTE_PURE two_way_long_needle (const unsigned char *haystack, size_t haystack_len, const unsigned char *needle, size_t needle_len) { size_t i; /* Index into current byte of NEEDLE. */ size_t j; /* Index into current window of HAYSTACK. */ size_t period; /* The period of the right half of needle. */ size_t suffix; /* The index of the right half of needle. */ size_t shift_table[1U << CHAR_BIT]; /* See below. */ /* Factor the needle into two halves, such that the left half is smaller than the global period, and the right half is periodic (with a period as large as NEEDLE_LEN - suffix). */ suffix = critical_factorization (needle, needle_len, &period); /* Populate shift_table. For each possible byte value c, shift_table[c] is the distance from the last occurrence of c to the end of NEEDLE, or NEEDLE_LEN if c is absent from the NEEDLE. shift_table[NEEDLE[NEEDLE_LEN - 1]] contains the only 0. */ for (i = 0; i < 1U << CHAR_BIT; i++) shift_table[i] = needle_len; for (i = 0; i < needle_len; i++) shift_table[CANON_ELEMENT (needle[i])] = needle_len - i - 1; /* Perform the search. Each iteration compares the right half first. */ if (CMP_FUNC (needle, needle + period, suffix) == 0) { /* Entire needle is periodic; a mismatch in the left half can only advance by the period, so use memory to avoid rescanning known occurrences of the period in the right half. */ size_t memory = 0; size_t shift; j = 0; while (AVAILABLE (haystack, haystack_len, j, needle_len)) { /* Check the last byte first; if it does not match, then shift to the next possible match location. */ shift = shift_table[CANON_ELEMENT (haystack[j + needle_len - 1])]; if (0 < shift) { if (memory && shift < period) { /* Since needle is periodic, but the last period has a byte out of place, there can be no match until after the mismatch. */ shift = needle_len - period; } memory = 0; j += shift; continue; } /* Scan for matches in right half. The last byte has already been matched, by virtue of the shift table. */ i = MAX (suffix, memory); while (i < needle_len - 1 && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) ++i; if (needle_len - 1 <= i) { /* Scan for matches in left half. */ i = suffix - 1; while (memory < i + 1 && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) --i; if (i + 1 < memory + 1) return (RETURN_TYPE) (haystack + j); /* No match, so remember how many repetitions of period on the right half were scanned. */ j += period; memory = needle_len - period; } else { j += i - suffix + 1; memory = 0; } } } else { /* The two halves of needle are distinct; no extra memory is required, and any mismatch results in a maximal shift. */ size_t shift; period = MAX (suffix, needle_len - suffix) + 1; j = 0; while (AVAILABLE (haystack, haystack_len, j, needle_len)) { /* Check the last byte first; if it does not match, then shift to the next possible match location. */ shift = shift_table[CANON_ELEMENT (haystack[j + needle_len - 1])]; if (0 < shift) { j += shift; continue; } /* Scan for matches in right half. The last byte has already been matched, by virtue of the shift table. */ i = suffix; while (i < needle_len - 1 && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) ++i; if (needle_len - 1 <= i) { /* Scan for matches in left half. */ i = suffix - 1; while (i != SIZE_MAX && (CANON_ELEMENT (needle[i]) == CANON_ELEMENT (haystack[i + j]))) --i; if (i == SIZE_MAX) return (RETURN_TYPE) (haystack + j); j += period; } else j += i - suffix + 1; } } return NULL; } #undef AVAILABLE #undef CANON_ELEMENT #undef CMP_FUNC #undef MAX #undef RETURN_TYPE nvc-r1.17.1/thirdparty/strcasestr.c000066400000000000000000000063461504111170000173030ustar00rootroot00000000000000/* Case-insensitive searching in a string. Copyright (C) 2005-2022 Free Software Foundation, Inc. Written by Bruno Haible , 2005. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ #ifndef _GL_ATTRIBUTE_PURE # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) || defined __clang__ # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__)) # else # define _GL_ATTRIBUTE_PURE /* empty */ # endif #endif #include /* Specification. */ #include #include #include #include #define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch)) /* Two-Way algorithm. */ #define RETURN_TYPE char * #define AVAILABLE(h, h_l, j, n_l) \ (!memchr ((h) + (h_l), '\0', (j) + (n_l) - (h_l)) \ && ((h_l) = (j) + (n_l))) #define CANON_ELEMENT(c) TOLOWER (c) #define CMP_FUNC(p1, p2, l) \ strncasecmp ((const char *) (p1), (const char *) (p2), l) #include "str-two-way.h" /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive comparison. This function gives unspecified results in multibyte locales. */ char * strcasestr (const char *haystack_start, const char *needle_start) { const char *haystack = haystack_start; const char *needle = needle_start; size_t needle_len; /* Length of NEEDLE. */ size_t haystack_len; /* Known minimum length of HAYSTACK. */ bool ok = true; /* True if NEEDLE is prefix of HAYSTACK. */ /* Determine length of NEEDLE, and in the process, make sure HAYSTACK is at least as long (no point processing all of a long NEEDLE if HAYSTACK is too short). */ while (*haystack && *needle) { ok &= (TOLOWER ((unsigned char) *haystack) == TOLOWER ((unsigned char) *needle)); haystack++; needle++; } if (*needle) return NULL; if (ok) return (char *) haystack_start; needle_len = needle - needle_start; haystack = haystack_start + 1; haystack_len = needle_len - 1; /* Perform the search. Abstract memory is considered to be an array of 'unsigned char' values, not an array of 'char' values. See ISO C 99 section 6.2.6.1. */ if (needle_len < LONG_NEEDLE_THRESHOLD) return two_way_short_needle ((const unsigned char *) haystack, haystack_len, (const unsigned char *) needle_start, needle_len); return two_way_long_needle ((const unsigned char *) haystack, haystack_len, (const unsigned char *) needle_start, needle_len); } #undef LONG_NEEDLE_THRESHOLD nvc-r1.17.1/thirdparty/strchrnul.c000066400000000000000000000131141504111170000171210ustar00rootroot00000000000000/* Searching in a string. Copyright (C) 2003, 2007-2023 Free Software Foundation, Inc. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ #include /* Specification. */ #include void * rawmemchr (const void *s, int c_in); /* Find the first occurrence of C in S or the final NUL byte. */ char * strchrnul (const char *s, int c_in) { /* On 32-bit hardware, choosing longword to be a 32-bit unsigned long instead of a 64-bit uintmax_t tends to give better performance. On 64-bit hardware, unsigned long is generally 64 bits already. Change this typedef to experiment with performance. */ typedef unsigned long int longword; const unsigned char *char_ptr; const longword *longword_ptr; longword repeated_one; longword repeated_c; unsigned char c; c = (unsigned char) c_in; if (!c) return rawmemchr (s, 0); /* Handle the first few bytes by reading one byte at a time. Do this until CHAR_PTR is aligned on a longword boundary. */ for (char_ptr = (const unsigned char *) s; (size_t) char_ptr % sizeof (longword) != 0; ++char_ptr) if (!*char_ptr || *char_ptr == c) return (char *) char_ptr; longword_ptr = (const longword *) char_ptr; /* All these elucidatory comments refer to 4-byte longwords, but the theory applies equally well to any size longwords. */ /* Compute auxiliary longword values: repeated_one is a value which has a 1 in every byte. repeated_c has c in every byte. */ repeated_one = 0x01010101; repeated_c = c | (c << 8); repeated_c |= repeated_c << 16; if (0xffffffffU < (longword) -1) { repeated_one |= repeated_one << 31 << 1; repeated_c |= repeated_c << 31 << 1; if (8 < sizeof (longword)) { size_t i; for (i = 64; i < sizeof (longword) * 8; i *= 2) { repeated_one |= repeated_one << i; repeated_c |= repeated_c << i; } } } /* Instead of the traditional loop which tests each byte, we will test a longword at a time. The tricky part is testing if *any of the four* bytes in the longword in question are equal to NUL or c. We first use an xor with repeated_c. This reduces the task to testing whether *any of the four* bytes in longword1 or longword2 is zero. Let's consider longword1. We compute tmp = ((longword1 - repeated_one) & ~longword1) & (repeated_one << 7). That is, we perform the following operations: 1. Subtract repeated_one. 2. & ~longword1. 3. & a mask consisting of 0x80 in every byte. Consider what happens in each byte: - If a byte of longword1 is zero, step 1 and 2 transform it into 0xff, and step 3 transforms it into 0x80. A carry can also be propagated to more significant bytes. - If a byte of longword1 is nonzero, let its lowest 1 bit be at position k (0 <= k <= 7); so the lowest k bits are 0. After step 1, the byte ends in a single bit of value 0 and k bits of value 1. After step 2, the result is just k bits of value 1: 2^k - 1. After step 3, the result is 0. And no carry is produced. So, if longword1 has only non-zero bytes, tmp is zero. Whereas if longword1 has a zero byte, call j the position of the least significant zero byte. Then the result has a zero at positions 0, ..., j-1 and a 0x80 at position j. We cannot predict the result at the more significant bytes (positions j+1..3), but it does not matter since we already have a non-zero bit at position 8*j+7. The test whether any byte in longword1 or longword2 is zero is equivalent to testing whether tmp1 is nonzero or tmp2 is nonzero. We can combine this into a single test, whether (tmp1 | tmp2) is nonzero. This test can read more than one byte beyond the end of a string, depending on where the terminating NUL is encountered. However, this is considered safe since the initialization phase ensured that the read will be aligned, therefore, the read will not cross page boundaries and will not cause a fault. */ while (1) { longword longword1 = *longword_ptr ^ repeated_c; longword longword2 = *longword_ptr; if (((((longword1 - repeated_one) & ~longword1) | ((longword2 - repeated_one) & ~longword2)) & (repeated_one << 7)) != 0) break; longword_ptr++; } char_ptr = (const unsigned char *) longword_ptr; /* At this point, we know that one of the sizeof (longword) bytes starting at char_ptr is == 0 or == c. On little-endian machines, we could determine the first such byte without any further memory accesses, just by looking at the tmp result from the last loop iteration. But this does not work on big-endian machines. Choose code that works in both cases. */ char_ptr = (unsigned char *) longword_ptr; while (*char_ptr && (*char_ptr != c)) char_ptr++; return (char *) char_ptr; } nvc-r1.17.1/thirdparty/strndup.c000066400000000000000000000020661504111170000166000ustar00rootroot00000000000000/* A replacement function, for systems that lack strndup. Copyright (C) 1996-1998, 2001-2003, 2005-2007, 2009-2022 Free Software Foundation, Inc. This file is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ #include #include #include char * strndup (char const *s, size_t n) { size_t len = strnlen (s, n); char *new = malloc (len + 1); if (new == NULL) return NULL; new[len] = '\0'; return memcpy (new, s, len); } nvc-r1.17.1/tools/000077500000000000000000000000001504111170000136775ustar00rootroot00000000000000nvc-r1.17.1/tools/decode.sh000077500000000000000000000003061504111170000154600ustar00rootroot00000000000000#!/bin/bash sed 's/^.*\[\(.*\)\]$/\1/' | \ addr2line -pife ./bin/nvc | \ grep -v '^??' | \ sed 's/:/ /' | \ sed 's|/.*/||' | \ awk '{ printf("%-25s %-10s %d\n", $1, $3, $4); }' nvc-r1.17.1/tools/hashcol.c000066400000000000000000000017361504111170000154730ustar00rootroot00000000000000// // Tool to find hash collisions for test/regress/case8.vhd // #include #include #include #include static const char slv_map[] = "UX01ZWLH-"; static int rand_slv(void) { return random() % 9; } static int64_t hash_slv(int array[], int length) { uint64_t result = 0; for (int i = 0; i < length; i++) { result *= 0x27d4eb2d; result += array[i]; } return result; } static void slv_to_str(char *buf, int array[], int length) { for (int i = 0; i < length; i++) buf[i] = slv_map[array[i]]; buf[length] = '\0'; } int main(void) { int array[32]; char buf[33]; static const int max_cases = 256; for (;;) { for (int i = 0; i < 32; i++) array[i] = rand_slv(); const int64_t hash = hash_slv(array, 32); if (hash % max_cases == 0) { slv_to_str(buf, array, 32); printf("%s ==> %"PRIi64" %% %d = 0\n", buf, hash, max_cases); } } return 0; } nvc-r1.17.1/tools/llvm-trace.py000077500000000000000000000011621504111170000163220ustar00rootroot00000000000000#!/usr/bin/env python3 # # Usage: # opt -time-trace ... # llc -time-trace ... # llvm-trace.py out.time-trace # import json import sys with open(sys.argv[1]) as f: trace = json.loads(f.read()) namecol = 0 funcs = [] for e in trace['traceEvents']: if 'args' in e and 'detail' in e['args']: f = e['args']['detail'] if f == '': continue name = e['name'].replace('', ''); funcs += [(f, name, e['dur'])] namecol = max(namecol, len(name)) for f in sorted(funcs, key=lambda tup: tup[2]): print("{:8} : {:{}} : {}".format(f[2], f[1], namecol, f[0])) nvc-r1.17.1/tools/perf.sh000077500000000000000000000002201504111170000151640ustar00rootroot00000000000000#!/bin/sh export NVC_LIBPATH=./lib std=${STD:-93} ./bin/nvc --std=$std -a ../test/perf/$1.vhd -e -O3 -V $1 && ./bin/nvc -r --stats --profile $* nvc-r1.17.1/tools/run.sh000077500000000000000000000013501504111170000150410ustar00rootroot00000000000000#!/bin/sh std=${STD:-08} export NVC_LIBPATH=./lib/ export NVC_IMP_LIB=./lib/ root=$(git rev-parse --show-toplevel) aopts="--relaxed --psl" name="$1" shift if [ -e $root/test/vhpi/$name.c ]; then vhpi="--load lib/vhpi_test.so --vhpi-trace --vhpi-debug" aopts="$aopts --preserve-case" export TEST_NAME=$name fi regress=$root/test/regress if [ -f $regress/$name.v ]; then vlog=$regress/$name.v fi if [ -z "$vlog" ] || [ -f $regress/$name.vhd ]; then vhd=$regress/$name.vhd fi PATH="./bin:../bin:$PATH" if [ -f $regress/$name.tcl ]; then nvc --std=$std $vhpi -a $aopts $vhd $vlog -e $name -V \ --do $regress/$name.tcl $* else nvc --std=$std $vhpi -a $aopts $vhd $vlog -e $name -V \ -r --stats --exit-severity=error $* fi nvc-r1.17.1/www/000077500000000000000000000000001504111170000133635ustar00rootroot00000000000000nvc-r1.17.1/www/Makefile000066400000000000000000000010611504111170000150210ustar00rootroot00000000000000PAGES = index.html download.html manual.html news.html readme.html features.html TEMPLATES = defs.m4 header.html.in footer.html.in TMPFILES = nvc.1.html README.html NEWS.html all: $(PAGES) manual.html: nvc.1.html news.html: NEWS.html readme.html: README.html nvc.1.html: ../nvc.1 mandoc -T html -O fragment $< > $@ %.html: ../%.md cmark -t html $< > $@ %.html: %.html.in $(TEMPLATES) m4 $< > $@ clean: rm -f $(PAGES) $(TMPFILES) install: all cp -a $(PAGES) style.css /sites/nick/nvc/ validate: all vnu $(PAGES) .PHONY: clean install validate nvc-r1.17.1/www/defs.m4000066400000000000000000000006621504111170000145520ustar00rootroot00000000000000define(__version, `1.17.1')dnl define(__release_date, `26th July 2025')dnl define(__release_date_short, `2025-07-26')dnl define(__release_notes, `news.html#version-'__version`---'__release_date_short)dnl define(__github_url, `https://github.com/nickg/nvc')dnl define(__download_base, `https://www.nickg.me.uk/files')dnl define(__download_file, `nvc-'__version`.tar.gz')dnl define(__download_url, __download_base`/'__download_file)dnl nvc-r1.17.1/www/download.html.in000066400000000000000000000022111504111170000164610ustar00rootroot00000000000000define(__title, `Download')dnl include(`defs.m4')dnl include(`header.html.in')dnl

Download

The most recent version is __version, released on __release_date (release notes).

__download_file

Releases are signed using PGP key BCDB295F74319F1A. Download __download_file`.sig' and verify with: 

gpg --keyserver pgp.mit.edu --recv-keys BCDB295F74319F1A
gpg --verify `nvc-'__version`.tar.gz.sig'

Refer to the README for instructions on how to build and install the software.

Development version

The latest source code can be fetched using Git: 

git clone https://github.com/nickg/nvc.git

Packages

NVC is currently packaged for the following systems:

Packaging status include(`footer.html.in')dnl nvc-r1.17.1/www/features.html.in000066400000000000000000000607141504111170000165040ustar00rootroot00000000000000define(__title, `')dnl include(`defs.m4')dnl include(`header.html.in')dnl

Language Support

NVC supports almost all of IEEE 1076-1993 and 1076-2002. Please report any missing or incorrectly implemented features.

VHDL-2008

IEEE 1076-2008 was a major update to the VHDL standard. NVC supports many of the new features, please consult the table below.

FeatureStatus
Package generics 1.6
Subprogram generics 1.7
Generic types 1.7
PSL integrated into VHDL
New fixed and floating point arithmetic packages 1.7
/* */ block comments 1.6
New standard functions minimum, maximum, to_string, etc. 1.6
Function rising_edge is defined for boolean 1.7
Arrays and records may contain unconstrained elements 1.7
New boolean_vector, integer_vector, etc. types 1.6
"Matching" case statement case? 1.7
force and release for signals 1.7
'INSTANCE_NAME etc. extended for package and subprogram instantiation 1.11
New standard environment package 1.4
New 'SUBTYPE and 'ELEMENT attributes 1.7
New condition operator ?? 1.6
Enhanced bit string literals 1.6
External names 1.11
Array slices in aggregates 1.7
Conditional and selected sequential statements 1.10
Extensions to generate statement 1.8
all in sensitivity list 1.6
Context declarations 1.4
New and enhanced IEEE standard packages 1.6

VHDL-2019

IEEE 1076-2019 was another major update to the VHDL standard. NVC has experimental support for some of the new features, please consult the table below.

LCSFeatureStatus
LCS2016-001 Partially connected vectors on port map 1.11
LCS2016-002 Allow access to protected type parameters on function interfaces 1.11
LCS2016-004 Allow PT methods with AT and FT parameters 1.11
LCS2016-006a File IO / TextIO updates 1.9
LCS2016-006c Directory API 1.11
LCS2016-006e Environment API 1.10
LCS2016-006f Expose standard conditional analysis identifiers 1.9
LCS2016-007 Sequential declaration regions 1.11
LCS2016-011 Date/time functions 1.10
LCS2016-012 'IMAGE and TO_STRING for composite types 1.11
LCS2016-014 Composites of protected types
LCS2016-014a Pointers to composites of protected types 1.10
LCS2016_015 Standard functions to report calling path 1.9
LCS2016_015a Standard functions to report current file name 1.9
LCS2016-016 Anonymous types
LCS2016-018 Attributes for enumerated types 1.11
LCS2016-018a New attributes - 'INDEX 1.10
LCS2016-018d New attributes - 'DESIGNATED_TYPE 1.10
LCS2016-019 Inferring constraints from initial values for signals and variables 1.10
LCS2016-023 Relax library requirement on configurations 1.11
LCS2016-026c Long integers 1.10
LCS2016_030 Garbage collection 1.7
LCS2016-032 PATH_NAME and INSTANCE_NAME and protected types 1.11
LCS2016-033 Composition with protected types 1.11
LCS2016-034 Protected types with generic clause
LCS2016-036a Allow for conditional expressions in a declaration (baseline) 1.10
LCS2016-041 Record introspection/type reflection 1.11
LCS2016-043 Attributes for PSL
LCS2016-045a Interface - defines new mode view construct for composite interface objects 1.11
LCS2016-045c Interface - 'CONVERSE for a mode view 1.10
LCS2016-047 Protected type: shared variables on entity interface 1.10
LCS2016-049 Map generics on subprogram call 1.14
LCS2016-050 API for assert 1.11
LCS2016-055a Syntax regularisation - component declarations 1.9
LCS2016-059 Array type generics 1.14
LCS2016-059a Allow ordering on any scalar array 1.10
LCS2016_061 Conditional compilation 1.4
LCS2016_071a Optional trailing semicolon 1.9
LCS2016_072b Function knows vector size 1.10
LCS2016_075 Closely related record types 1.11
LCS2016_082 Empty record 1.9
LCS2016_086 All interface lists can be ordered 1.9
LCS2016_094a Conditional return statement 1.10
LCS2016_099 Extended ranges
LCS2016_I03 Signatures required in association lists 1.14
LCS2016_I13 Precedence of unary operators 1.14

Property Specification Language (PSL)

NVC supports the "simple subset" of IEEE 1850-2010. PSL directives may be written directly in VHDL if using VHDL-2008 or later, or embedded in comments. Not all features are currently supported, please consult the table below.

LRM SectionFeatureStatus
5 Boolean Layer
5.1 Boolean expressions 1.15
5.1.1 Bit expressions 1.15
5.1.2 Boolean expressions 1.15
5.1.3 Bit Vector expressions 1.15
5.1.4 Numeric expressions 1.15
5.1.5 String expressions 1.15
5.2 Expression forms 1.15
5.2.1 HDL expressions 1.15
5.2.2 PSL expressions
5.2.3 Built-in functions 1.15
5.2.3.1 prev() 1.16
5.2.3.2 next()
5.2.3.3 stable() 1.16
5.2.3.4 rose() 1.16
5.2.3.5 fell() 1.16
5.2.3.6 ended()
5.2.3.7 isunknown() 1.15
5.2.3.8 countones() 1.15
5.2.3.9 nondet()
5.2.3.10 nondet_vector()
5.2.3.11 onehot(), onehot0() 1.15
5.2.4 Union expressions 1.16
5.3 Clock expressions
5.4 Default clock declaration 1.15
6 Temporal Layer
6.1 Sequential Expressions 1.15
6.1.1 Sequential Extended Regular Expressions (SEREs) 1.15
6.1.1.1 Simple SEREs 1.15
6.1.1.1.1 SERE concatenation (;) 1.15
6.1.1.1.2 SERE fusion (:) 1.15
6.1.1.2 Compound SEREs
6.1.1.2.1 SERE or (|)
6.1.1.2.2 SERE non-length-matching and (&)
6.1.1.2.3 SERE length-matching and (&&) 1.15
6.1.1.2.4 SERE within
6.1.1.2.5 Parameterized SERE
6.1.2 Sequences 1.15
6.1.2.1 SERE consecutive repetition ([* ]) 1.15
6.1.2.2 SERE non-consecutive repetition ([= ]) 1.15
6.1.2.3 SERE goto repetition ([-> ]) 1.15
6.1.2.4 Braced SERE 1.15
6.1.2.5 Clocked SERE (@)
6.2 Properties 1.15
6.2.1 FL Properties 1.15
6.2.1.1 Sequential FL Properties 1.15
6.2.1.2 Clocked FL Properties
6.2.1.3 Simple FL Properties 1.15
6.2.1.3.1 always 1.15
6.2.1.3.2 never 1.15
6.2.1.3.3 eventually! 1.15
6.2.1.3.4 next 1.15
6.2.1.4 Extended next FL Properties
6.2.1.4.1 next_a
6.2.1.4.2 next_e
6.2.1.4.3 next_event
6.2.1.4.4 next_event_a
6.2.1.4.5 next_event_e
6.2.1.5 Compound FL Properties 1.15
6.2.1.5.1 abort, async_abort and sync_abort 1.15
6.2.1.5.2 before 1.15
6.2.1.5.3 until 1.15
6.2.1.6 Sequence-based FL Properties 1.15
6.2.1.6.1 Suffix implication 1.15
6.2.1.7 Logical FL Properties
6.2.1.7.1 Parametrized property
6.2.1.7.2 Logical implication
6.2.1.7.3 Logical iff
6.2.1.7.4 Logical and
6.2.1.7.5 Logical or
6.2.1.7.6 Logical not
6.2.1.8 LTL operators
6.2.2 Optional Branching Extension (OBE) properties N/A
6.2.3 Replicated properties
6.3 Local variables
6.4 Procedural blocks
6.5 Property and sequence declarations
6.5.1 Parameters
6.5.1.1 PSL formal parameter type classes
6.5.1.2 HDL formal parameter type classes
6.5.2 Declarations
6.5.2.1 Sequence Declarations
6.5.2.2 Property Declaration
6.5.3 Instantiation
6.5.3.1 Sequence instantiation
6.5.3.2 Property instantiation
7 Verification Layer
7.1 Verification directives 1.15
7.1.1 assert 1.15
7.1.2 assume
7.1.3 restrict
7.1.4 restrict!
7.1.5 cover 1.15
7.1.6 fairness and strong_fairness
7.2 Verification units
7.2.1 Verification unit binding
7.2.2 Verification unit instantiation
7.2.3 Verification unit inheritance
7.2.4 Overriding assignments
7.2.4.1 Simple case
7.2.4.2 Multiple unrelated vunits
7.2.4.3 Multiple overrides to the same signal
8 Modeling layer
8.1 Integer ranges
8.2 Structures
8 Scope and visibility rules
9.1 Immediate scope
9.2 Extended scope
9.3 Direct and indirect name references
include(`footer.html.in')dnl nvc-r1.17.1/www/footer.html.in000066400000000000000000000000271504111170000161530ustar00rootroot00000000000000 nvc-r1.17.1/www/header.html.in000066400000000000000000000014211504111170000161040ustar00rootroot00000000000000 ifelse(__title, `', `', __title` - ')dnl NVC - VHDL Compiler and Simulator

NVC - VHDL Compiler and Simulator

nvc-r1.17.1/www/index.html.in000066400000000000000000000020061504111170000157630ustar00rootroot00000000000000define(__title, `')dnl include(`defs.m4')dnl include(`header.html.in')dnl

About

NVC is a free software VHDL compiler and simulator implementing almost all of IEEE 1076-2008.

Find out more in the README, see a detailed list of features, or read the manual online.

The project is hosted on GitHub. Please use the issue tracker there to report bugs.

The most recent version is __version, released on __release_date (release notes).

Contact

Send any questions to nick@nickg.me.uk or the discussion forum on GitHub.

include(`footer.html.in')dnl nvc-r1.17.1/www/manual.html.in000066400000000000000000000002061504111170000161310ustar00rootroot00000000000000define(__title, `Manual')dnl include(`defs.m4')dnl include(`header.html.in')dnl include(`nvc.1.html')dnl include(`footer.html.in')dnl nvc-r1.17.1/www/news.html.in000066400000000000000000000002031504111170000156250ustar00rootroot00000000000000define(__title, `News')dnl include(`defs.m4')dnl include(`header.html.in')dnl include(`NEWS.html')dnl include(`footer.html.in')dnl nvc-r1.17.1/www/readme.html.in000066400000000000000000000002071504111170000161120ustar00rootroot00000000000000define(__title, `README')dnl include(`defs.m4')dnl include(`header.html.in')dnl include(`README.html')dnl include(`footer.html.in')dnl nvc-r1.17.1/www/style.css000066400000000000000000000054601504111170000152420ustar00rootroot00000000000000body { margin: 0pt; padding: 0pt; } div.header { margin: 0pt; padding: 0pt; width: 100%; background-color: #EEE; border-bottom: 2pt solid #999; border-top: 0pt; } div.header h1 { font-size: x-large; font-weight: bold; text-align: center; padding: 5pt; margin: 0pt; } div.content { padding: 5pt; vertical-align: top; width: 70%; margin-left: 20%; } div.content h1, h2, h3 { font-size: large; font-weight: bold; } div.content h4 { font-size: normal; font-weight: bold; } div.sidebar { float: left; width: 15%; padding: 2pt; vertical-align: top; overflow: auto; } div.sidebar li { display: list-item; list-style: none; font-size: large; padding: 0.2em; } div.sidebar ul { padding: 0pt 0pt 0pt 1em; } pre, kbd, :not(pre) > code { background-color: #f5f2f0; padding: 1px 4px 1px 4px; border-radius: 5px; font-family: Monospace; font-size: 1.2em; color: #333; } pre { padding: 10px 20px 10px 20px; } /* * Mandoc styles */ div.manual-text code { font-family: Monospace; font-size: 1.2em; border-radius: 0px; padding: 0px; background-color: transparent; color: #000; } div.manual-text br { display: none; } div.manual-text table { padding: 0px; margin: 0px; } div.manual-text td { vertical-align: top; padding-left: 0.2em; padding-right: 0.2em; border-color: inherit; } div.manual-text ul, div.manual-text ol, div.manual-text dl { margin-top: 0em; margin-bottom: 0em; } div.manual-text li, div.manual-text dt { margin-top: 1em; } div.manual-text .permalink { border-bottom: thin dotted; color: inherit; font: inherit; text-decoration: inherit; } table.head { width: 100%; border-bottom: 1px dotted #808080; margin-bottom: 1em; font-size: smaller; } td.head-vol { text-align: center; } td.head-rtitle { text-align: right; } td.foot-os { text-align: right; } table.foot { width: 100%; border-top: 1px dotted #808080; margin-top: 1em; font-size: smaller; } table.feature-table { border: 1px solid #808080; border-collapse: collapse; } table.feature-table td, th { border: 1px solid #808080; padding-left: 5px; padding-right: 5px; padding-top: 2px; padding-bottom: 2px; } table.feature-table th { background-color: #e0e0e0; } td.feature-done { text-align: center; background-color: #53e01b; } td.feature-partial { text-align: center; background-color: #ebc334; } td.feature-missing { text-align: center; background-color: #db4040; } td.feature-na { text-align: center; background-color: #c0c0c0; } tr.feature-group { background-color: #f0f0f0; } tr.feature-group td:nth-child(2) { text-align: center; }